LF PDF

LENGUAJES FORMALES
(Gramáticas y Autómatas en Informática)
Lucio Torrico
A ti: me basta con saber que te reconoces.
TABLA DE CONTENIDO
PREFACIO
CAPÍTULO 1. LIMINAR ..........................................................................................................1
Alfabeto o Vocabulario .......................................................................................................1
Símbolo ...............................................................................................................................1
Cadena o Hilera o Palabra ...................................................................................................1
Lenguaje ..............................................................................................................................2
Operaciones con cadenas.....................................................................................................2
Operaciones con lenguajes ..................................................................................................4
CAPÍTULO 2. GRAMÁTICAS REGULARES........................................................................8
GRAMÁTICAS REGULARES LINEALES DERECHAS ................................................8
Mecanismo de funcionamiento de las GRLD’s.................................................................11
Más de un paso de derivación: el concepto de derivación a secas ....................................13
Cadenas generables por la GRLD G .................................................................................13
L(G) lenguaje generado por una GRLD............................................................................14
Dado un lenguaje escribir las producciones ......................................................................17
Dudas comunes..................................................................................................................18
Errores comunes ................................................................................................................18
GRAMÁTICAS REGULARES LINEALES IZQUIERDAS ...........................................20
NOTACIÓN, CONVENCIONES Y TOMA DE POSICIÓN: el caso de la cadena vacía23
Problemas varios ...............................................................................................................25
Lenguaje regular................................................................................................................26
L(G) lenguaje generado por G versus L lenguaje que creemos genera G ¿L=L(G)?........26
CAPÍTULO 3. AUTÓMATAS FINITOS ................................................................................33
AUTÓMATAS FINITOS DETERMINÍSTICOS (AFD’s) ..............................................33
Función total y determinismo............................................................................................34
Errores comunes ................................................................................................................35
Otras formas de representación de los AFD’s ...................................................................35
AFD’s: mecanismo de funcionamiento .............................................................................38
Descripciones instantáneas en AFD’s ...............................................................................38
Movimiento(s) en un AFD ................................................................................................38
Transiciones = muchos movimientos ................................................................................39
T(A): lenguaje aceptado por un AFD................................................................................40
La función δ*: otra notación frecuente ..............................................................................41
El lema de bombeo ............................................................................................................43
El teorema de Myhill-Nerode............................................................................................45
AUTÓMATAS FINITOS NO DETERMINÍSTICOS (AFN’S) .......................................48
No determinismo, aceptación de una cadena y T(A) en un AFN......................................49
La función d* .....................................................................................................................51
AUTÓMATAS FINITOS NO DETERMINÍSTICOS CON TRANSICIONES VACÍAS52
(λ-AFN’S) .........................................................................................................................52
λ-cierre ..............................................................................................................................53
La función d*.....................................................................................................................58
CAPÍTULO 4. EXPRESIONES REGULARES ......................................................................62
DERIVADAS DE EXPRESIONES REGULARES..........................................................65
ECUACIONES CON EXPRESIONES REGULARES ....................................................75
CAPÍTULO 5. CONVERSIONES GENÉRICAS: El caso regular..........................................77
Construcción de una GRLD cuyo símbolo raíz no aparezca en ninguna parte derecha de
las producciones ................................................................................................................77
Construcción de una GRLIzquierda a partir de una GRLDerecha ....................................78
Construcción de una GRLD a partir de un AFD A ...........................................................81
Construcción de una GRLD a partir de un AFN A ...........................................................83
Construcción de un AFN A a partir de una GRLD G .......................................................85
Construcción de un AFD A’ no reinicializable a partir de un AFD A reinicializable.......87
Construcción de un AFN A’ a partir de un AFD A...........................................................89
Construcción de un AFD A’ a partir de un AFN A...........................................................90
Construcción de un AFD A’ con el alfabeto extendido a partir de un AFD A..................93
Construcción de un AFN A’ a partir de un λ-AFN A .......................................................94
Construcción de un autómata a partir de una e.r. (el Teorema de Kleene parte I) ..........100
Construcción de una e.r. a partir de un autómata A (el Teorema de Kleene parte II) .....111
Construcción de un AFD accesible a partir de un AFD cualquiera................................117
Construcción de un AFD con el menor número posible de estados a partir de un AFD
cualquiera (minimización de AFD’s) ..............................................................................118
CAPÍTULO 6. CERRADURA: El caso regular.....................................................................128
Unión ...............................................................................................................................128
Concatenación .................................................................................................................131
Diferencia ........................................................................................................................133
Complemento ..................................................................................................................134
Intersección .....................................................................................................................134
Estrella de Kleene............................................................................................................135
CAPÍTULO 7. PROBLEMAS DE DECISIÓN......................................................................141
Pertenencia de una cadena a un lenguaje regular (el Algoritmo de Earley) ....................141
Lenguaje aceptado por un AFD: vacío o no ....................................................................143
Infinitud (finitud) del lenguaje aceptado por un AFD.....................................................144
Inclusión del lenguaje aceptado por una AFD respecto de otro AFD .............................144
l-equivalencia de AFD’s (el algoritmo de Moore) ..........................................................145
Equivalencia de e.r ..........................................................................................................145
Lenguajes no regulares ....................................................................................................149
CAPÍTULO 8. GRAMÁTICAS LIBRES DE CONTEXTO..................................................152
Árboles de derivación......................................................................................................154
Operación de reemplazo en árboles.................................................................................156
Derivación más a la izquierda (derecha) .........................................................................158
Ambigüedad ....................................................................................................................158
GLC limpias, reducidas o higienizadas ...........................................................................161
Formas normales .............................................................................................................162
Camino más largo de un árbol de derivación en una GLC en FNCH .............................163
Poda y expansión.............................................................................................................164
Cabeza de la parte derecha (de una producción) .............................................................165
No Terminales recursivos por izquierda de primer orden y de orden mayor ..................165
Lema de bombeo .............................................................................................................165
El lema de Ogden ............................................................................................................167
CAPÍTULO 9. AUTÓMATAS DE PILA (AP)......................................................................169
AUTÓMATAS DE PILA POR PILA VACÍA (APθ).....................................................169
Descripciones instantáneas para AP................................................................................169
Movimientos....................................................................................................................170
Funcionamiento de un AP ...............................................................................................171
T(A) lenguaje aceptado por un APθ................................................................................172
Representación gráfica ....................................................................................................173
Toma de posición, necesidades y errores comunes .........................................................174
AUTÓMATAS DE PILA POR ESTADO FINAL (APe.f.)............................................175
T(A) lenguaje aceptado por un APe.f..............................................................................175
No Determinismo ............................................................................................................176
CAPÍTULO 10. CONVERSIONES GENÉRICAS: el caso libre de contexto .......................180
Construcción de una GLC limpia a partir de otra GLC cualquiera: limpieza de GLC’s.180
Construcción de una GLC en FNCH a partir de otra GLC G..........................................186
Eliminación de la recursividad por izquierda de primer orden........................................189
Construcción de una GLC en FNG a partir de otra GLC arbitraria.................................191
Construcción de una GLC G en 2FNG............................................................................198
Construcción de un APθ a partir de un APe.f. ................................................................199
Construcción de APe.f. a partir de un APθ .....................................................................201
Construcción de APθ a partir de una GLC......................................................................202
Cuasi-gramáticas Libres de Contexto y eliminación de producciones borradoras..........204
Construcción de una GLC a partir de un APθ.................................................................206
Construcción de un APe.f. determinístico a partir de un APθ determinístico.................209
Construcción de un APe.f. determinístico en forma normal a partir de otro APe.f.
determinístico ..................................................................................................................211
CAPÍTULO 11. CERRADURA: el caso libre de contexto ....................................................215
Unión ...............................................................................................................................215
Concatenación .................................................................................................................216
Cruz de Kleene ................................................................................................................219
Intersección, diferencia y complemento..........................................................................222
Intersección y diferencia entre un lenguaje libre de contexto y uno regular ...................223
Intersección, complemento y diferencia entre lenguajes libres de contexto determinísticos
.........................................................................................................................................226
CAPÍTULO 12. PROBLEMAS DE DECISIÓN....................................................................233
Pertenencia de una cadena a un lenguaje libre de contexto (el algoritmo CYK) ............233
Lenguaje aceptado por una GLC: vacío o no ..................................................................235
Infinitud (finitud) del lenguaje aceptado por una GLC ...................................................236
Lenguajes no libres de contexto ......................................................................................236
Gramáticas LL y LR........................................................................................................239
CAPÍTULO 13. LENGUAJES SENSIBLES AL CONTEXTO ............................................241
GRAMÁTICAS SENSIBLES AL CONTEXTO (GSC).................................................241
Forma normal de Kuroda (FNK).....................................................................................242
AUTÓMATAS LIMITADOS LINEALMENTE (ALL) ................................................242
Descripciones instantáneas y lenguaje aceptado T(A) ....................................................244
CONVERSIONES GENÉRICAS Y CERRADURA: El caso sensible al contexto........245
Construcción de una GSC con sólo No Terminales en la parte izquierda de sus
producciones....................................................................................................................245
Construcción de una GSC en forma normal a partir de otra ...........................................246
Construcción de una GSC en FNK a partir de otra .........................................................248
Construcción de un ALL a partir de una GSC.................................................................249
Construcción de una GSC a partir de un ALL.................................................................252
Unión ...............................................................................................................................255
Concatenación .................................................................................................................256
Cruz de Kleene ................................................................................................................256
Intersección .....................................................................................................................257
Complemento ..................................................................................................................259
PROBLEMAS DE DECISIÓN .......................................................................................261
Pertenencia de una cadena a un lenguaje sensible al contexto ........................................261
Algunos otros problemas de decisión..............................................................................261
Lenguajes no sensibles al contexto..................................................................................261
CAPÍTULO 14. RELACIONES Y CONVERSIONES ENTRE NIVELES DE LA
JERARQUÍA DE CHOMSKY...............................................................................................263
Todos los lenguajes regulares son libres de contexto......................................................263
Todos los lenguajes libres de contexto son sensibles al contexto ...................................263
Jerarquía de Chomsky .....................................................................................................263
Construcción de una Gramática de tipo 1,2 ó 3 cuyo símbolo raíz no aparezca en ninguna
parte derecha de las producciones ...................................................................................264
L(G) es recursivo para G una gramática de tipo 1, 2 ó 3.................................................264
Variantes..........................................................................................................................264
BIBLIOGRAFÍA.....................................................................................................................267
ÍNDICE...................................................................................................................................268
PREFACIO
Este trabajo tiene la pretensión de presentar a los lenguajes formales -a sus gramáticas y
autómatas asociados- en sí mismos, tratando de reflejar su elegancia y su riqueza inherente, no
como un medio útil –lo que es un gran logro y un importantísimo punto a favor, por ejemplo
en compilación- sino como uno de los capítulos más hermosos de la informática teórica:
con valor propio.
Como es imaginable, no se ha podido abarcar todo el espectro posible, hubo la necesidad de
tomar posiciones y hacer elecciones; también hay una cierta paridad entre el rigor –la
demostración- y la descripción esquemática y ejemplificada.
Se cubren los lenguajes regulares y los lenguajes libres de contexto con alguna amplitud,
menos ambiciosa es la parte dedicada a los lenguajes sensibles.
Resta agradecer a la Universidad Mayor de San Andrés, a la Facultad de Ciencias Puras y

Naturales, a la Carrera de Informática y al I.I.I., es decir, a las personas de estas instituciones
quienes han hecho que este esfuerzo sea posible; asimismo a tod@s quienes han trabajado y
trabajan en el campo de los lenguajes formales –desde su perspectiva teórica o aplicada- sin
cuya labor previa nada de esto existiría. En particular gracias a Grover Copa.
Los desaciertos son mi responsabilidad: me adelanto en agradecer a quienes hagan notarlos,

tanto en los errores “de transcripción” –valga el eufemismo-, como en los otros que merecerán
doble disculpa y doble agradecimiento.
Lucio Torrico
luciotorrico@gmail.com
CAPÍTULO 1. LIMINAR
Para leer los restantes capítulos es imprescindible un buen manejo de diversos conceptos y
operaciones con cadenas y lenguajes, principalmente de los siguientes.
Alfabeto o Vocabulario
Un alfabeto es un conjunto finito, no vacío, de símbolos indivisibles u objetos atómicos.
Ejemplos:
Alfabeto de dígitos decimales T={0,1,2,3,4,5,6,7,8,9}
Alfabeto de las letras L={a,b,…,z,A,…,Z}
Símbolo
Un símbolo es un componente elemental del alfabeto. Por componente elemental
entenderemos cualquier elemento u objeto atómico considerado como indivisible.
En los ejemplos de arriba el 3 o la z son elementos y son los casos más usuales, sin embargo,
también consideraremos como indivisible y como un único elemento, es decir, como un
símbolo de un alfabeto a objetos tales como pares ordenados u otros.
Por ejemplo, aunque no son usuales, no debe extrañarnos encontrar alfabetos así:
T={a1, a2, a3, a4, a5} de cinco símbolos, uno de ellos es a3.
N={(A,B), (A,A), (B,A)} de tres símbolos, uno de ellos es (A,B).
V={cadenaquefungecomosímbolo1, cadenaquefungecomosímbolo2} de dos símbolos, uno de
ellos es cadenaquefungecomosímbolo2.
Cadena o Hilera o Palabra

Una cadena u es una secuencia ordenada de longitud finita de símbolos de un alfabeto T. Se
dice que la cadena está formada sobre T y a menudo el alfabeto no se indica pues se
sobreentiende.
Se representa como u=a1a2…an donde a1,a2,...,an ∈ T
El símbolo ai 1≤ i ≤ n, ocurre en la posición i de la cadena leída de izquierda a derecha.
La cadena vacía, la cual se denota por el símbolo λ (lambda), es una palabra sobre cualquier
alfabeto y se define como una secuencia vacía de símbolos.
Otros autores prefieren denotar la cadena vacía con un cero (0) y otros con el símbolo
ε (épsilon), lo que nosotros no haremos.
Ejemplos:
Las siguientes son cadenas sobre el alfabeto T={a,b}
u1 = abab
u2 = bbbb
u3 = abbbaaa
u4 = λ
1
Por razones estrictamente teóricas, en otros contextos se maneja la noción de cadenas
infinitas, es decir, secuencias infinitas de símbolos de un alfabeto T.
También puede ser útil definir las cadenas como tuplas, por ejemplo u3 = (a,b,b,b,a,a,a)
Lenguaje
Un lenguaje es un conjunto de cadenas definidas sobre un alfabeto.
Al ser un conjunto, un lenguaje puede ser infinito o finito (incluso vacío).
Ejemplos:
Los siguientes son lenguajes sobre T={0,1}
L1 = ∅ = {} Denominado lenguaje vacío y denotado a menudo por L∅
L2 = {λ} Lenguaje que incluye sólo la cadena vacía, denotado a menudo por Lλ
L3 ={0, 1, 01, 10}
L4 = {0, 00, 000, 0000, …}
Operaciones con cadenas

Sean tres cadenas sobre el alfabeto T
u=c1c2…ck , w=a1a2…an y z=b1b2…bm
Longitud:
La longitud de w se denota mediante el símbolo |w| y se define como el número de símbolos
que tiene la cadena: |w|=n
La cadena vacía λ es una secuencia de 0 símbolos.
Ejemplos:
Si w=0101, |w|= |0101| = 4
Si w=λ, |w| = |λ| = 0
Igualdad de cadenas:
Se dice que w es igual a z, si tienen la misma longitud y los mismos símbolos en idénticas
posiciones. Se denota mediante w=z.
w=z si se cumple que |w| = |z| y (∀i: 1≤ i≤ n: ai= bi )
Inversa o Reversa o Transpuesta:

~
La inversa de una cadena w, es la imagen refleja de w. Para denotar la inversa de w se usa w
~
y se define así: w = an…a2a1
Si w=λ, w ~=w
~
~=w
También, la inversa de la inversa de una cadena es la cadena original: w
Ejemplos:
Si w=0101, w~ = 1010
~
Si w=111, w = 111
2
~ = 00111
Si w=11100, w
Concatenación de cadenas:
La concatenación de w con z es la cadena que se obtiene al añadir a la derecha de la cadena w
la cadena z, y se denota por wz (o w.z, aunque a menudo el punto se omite). Es decir, consiste
de todos los símbolos de w seguidos por los símbolos de z.
wz =a1a2…anb1b2…bm
Propiedades de la concatenación:
1) wz es una cadena sobre T
2) wλ=λw=w
3) |wz| = |w| + |z|
4) uwz = (uw)z = u(wz)
5) En general no es conmutativa, es decir, comúnmente wz ≠ wz
Ejemplos:
Si w = 0101 y z=1111
wz = 01011111
zw = 11110101
zz = 11111111
Potencia enésima de una cadena:

Para n ∈ N0 se define
w0=λ
wn= w n-1.w
Se dice que wn es la potencia enésima de w.
wn denota la concatenación de w consigo misma n veces.
Por la propiedad 3 de la concatenación, |wn| = n|w|, la longitud de la potencia n de w es n

veces la longitud de w.
Ejemplos:
Si w = 0101 y z=1111
z3 = z2z = z1zz = z0zzz = λzzz = zzz = 111111111111
w4 = w3w = w2ww = w1www = w0wwww = λwwww = wwww = 0101010101010101
|w4| = 4|w| = 16
Prefijo:
Sean u, w y z tres cadenas sobre el alfabeto T.
Se dice que la cadena z es prefijo de w, si para alguna cadena u se obtiene w = zu.
La cadena vacía λ es prefijo de cualquier palabra.
Toda palabra puede considerarse prefijo de sí misma.
3
El prefijo z de la cadena w se denomina prefijo propio si z ≠ w.
Sufijo:
Sean u, w y z tres cadenas sobre el alfabeto T
Se dice que la cadena z es sufijo de w, si para alguna cadena u se obtiene w = uz.
La cadena vacía λ es sufijo de cualquier palabra.
Toda palabra puede considerarse sufijo de sí misma.
El sufijo z de la cadena w se denomina sufijo propio si z ≠ w.
Subcadena:
Sean u, v, w y z cuatro cadenas sobre el alfabeto T.
Una cadena z es una subcadena de otra cadena w si existen la cadenas u y v para las cuales,
w=uzv.
Número de ocurrencias de un símbolo dado:

Suele ser útil contar el número de ocurrencias de cierto símbolo dentro de una cadena.
Sea b dicho símbolo, se denota mediante Nb(w) al número de veces que ocurre el símbolo b en
la cadena w.
Ejemplos:
Si w=abbaab, Nb(w)=3
Si w=aaa, Nb(w)=0
Operaciones con lenguajes

Existen diversas operaciones con los lenguajes que devuelven otro lenguaje. Al ser ellos
conjuntos de cadenas, varias de estas operaciones son simples y conocidas operaciones con
conjuntos (la unión de lenguajes, la intersección de lenguajes, etc.). Otras son más particulares
y requieren alguna ampliación.
Sean L1, L2 y L3 tres lenguajes sobre sus respectivos alfabetos, digamos T1, T2 y T3.
Unión:
L1 ∪ L2 = { u / (u ∈ L1 ) ó (u ∈ L2 ) }
Intersección:
L1 ∩ L2 = { u / (u ∈ L1 ) y (u ∈ L2 ) }
Concatenación:
L1. L2 = { uv / ( u ∈ L1 ) y ( v ∈ L2 ) }
(a menudo el punto que denota la operación se omite)
4
Propiedades de la concatenación:
1) L1.∅=∅.L1=∅
2) (L1.L2).L3 = L1.(L2.L3) asociatividad
3) En general no es conmutativa, es decir, comúnmente L1.L2 ≠ L2.L1
4) L1.( L2 ∪ L3) = L1.L2 ∪ L1.L3 distributividad con respecto a la unión
5) En general no es distributiva con respecto a la intersección [L1.( L2∩L3) ≠ L1.L2 ∩ L1.L3]
Inverso:
~
L1 (ó LR) denota el inverso de L1
~ ~ /u∈L }
LR= L1 = { u 1
Potencia:
L10= {λ}
L 1 1 = L1
L12= L1.L1
...
L1k= L1k-1.L1
Estrella o clausura de Kleene:

L1* = {λ} ∪ L1 ∪ (L1. L1) ∪ (L1. L1. L1) ∪ ...
O bien L1* = {λ} ∪ L1 ∪ L12 ∪ L13 ∪ ... = UL1i
i≥ 0
*
O bien L1 = { u1...ui / i≥0, uj ∈ L1 j=1,...,i }
Lenguaje Universal sobre el alfabeto T :

El conjunto de todas las posibles cadenas sobre un alfabeto T, se denota por T*.
Se trata de la estrella de Kleene tomando como lenguaje al propio alfabeto, es decir, L1=T
Así T* = {λ} ∪ T ∪ T2 ∪ T3 ∪ ... = UTi
i≥ 0
Esto es importante porque a menudo un lenguaje L sobre el alfabeto T se define también como
cualquier subconjunto de T*, es decir, L ⊆ T*.
Ejemplos:
Para T={0,1}
T0 ={λ}
T1={0,1}
T2={00,01,10,11}
T3={000,001,010,011,100,101,110,111}
…
Luego
5
T*=T0 ∪ T1 ∪ T2 ∪ T3 ∪... = {λ,0,1,00,01,10,11,000,001,010,011,100,101,110,111,…}
Para T={a,b}
T*={ todas las cadenas que se pueden formar con los símbolos a ó b
en cualquier orden y de cualquier longitud}
T*={ λ, a, b, aa, ab, ba, bb, aaa, ... }
Para T={a}
T*={ λ, a, aa, aaa, ... }
También podemos referirnos a este mismo lenguaje así: {a}*
Para T={b,c,d}
T*={ λ, b, c, d, bb, bc, bd, cb, cc, cd, db, dc, dd, bbb, ... }
También podemos referirnos a este mismo lenguaje así: {b,c,d}*
Diferencia:
Sean L1 y L2 definidos sobre T, L1 ⊆ T* y L2 ⊆ T*, es decir, se toma a T* como conjunto
universo.
L 1 - L2 = { u ∈ T * / u ∈ L 1 y u ∉ L 2 }
Complemento:
L1 = { u ∈ T* / u ∉ L1 } = T* - L1
En este caso se toma a T* como conjunto universo. También se denota por (L1)c.
Cruz de Kleene:
L+ = L*- {λ}
Hay algunos conceptos más que no son tan usuales pero que supondremos se manejan; el
primero es también una operación sobre lenguajes y los otros corresponden a la matemática
discreta.
Cociente de un lenguaje (por una palabra y entre lenguajes):

Como la definición de cociente derecho es análoga a la de cociente izquierdo, sólo
presentaremos esta última.
Sean T un alfabeto, a ∈ T, u ∈ T* y L ⊆ T*
El cociente izquierdo de L entre u, denotado por L/u, es el conjunto de todos los (buenos)
finales de las cadenas de L cuyo prefijo es u.
L/u = { w / uw ∈ L }
Propiedades de L/u:
1) Si L1 ⊆ L2 entonces L1/u ⊆ L2/u
2) (L1 ∪ L2)/u = L1/u ∪ L2/u
6
3) (L1 ∩ L2)/u = L1/u ∩ L2/u
4) (L1L2)/a = (L1/a)L2 si λ ∉ L1
(L1L2)/a = (L1/a)L2 ∪ L2/a en otro caso
5) L*/a = (L/a)L*
6) L/uw = (L/u)/w
El cociente izquierdo de L1 entre L2, denotado por L1/L2 es:
L1/L2 = { w / uw ∈ L1, u ∈ L2 }
Relación de equivalencia y partición de un conjunto:

Sea R una relación definida sobre un conjunto B, si R es reflexiva, simétrica y transitiva se
dice que R es una relación de equivalencia.
El conjunto formado por las clases de equivalencia de R es una partición de B.
El número de clases de equivalencia de R se denomina índice.
Ejemplos:
Sea R definida sobre T+={a,b}+ así:
∀ x,y∈T+ xRy si y sólo si x termina en el mismo símbolo de y
Es claro que la partición formada por las clases de equivalencia de R es
π={[a]R,[b]R} cuyo índice es 2 y donde [a]R={ua / u ∈ Τ*} y [b]R={ub / u ∈ Τ*}
Sea R definida sobre T+={a,b}+ así:

∀ x,y∈T+ xRy si y sólo si |x|=|y|
Es claro que la partición formada por las clases de equivalencia de R es
π={[a]R,[aa]R,[aaa]R,...} cuyo índice es infinito
Clausura reflexiva transitiva de una relación:

Sea R una relación definida sobre un conjunto B y denotemos por ° la composición de
relaciones. Se sabe que la composición de R consigo misma puede repetirse varias veces
dejando la idea de potencia de una relación:
R0 = IB (la relación de identidad sobre B)
n+1 n
R =R °R (n ≥ 0)
La potencia de una relación ofrece una alternativa para definir la clausura transitiva de una
relación –denotada por R+- así:
R+ = U Ri
i>0
Finalmente la clausura reflexiva transitiva de R denotada por R* se define así:
R* = R+ ∪ IB
7
CAPÍTULO 2. GRAMÁTICAS REGULARES
Para el caso de gramáticas, utilizaremos dos alfabetos frecuentemente:

El primero denominado alfabeto de No Terminales y denotado por N.
El segundo denominado alfabeto de Terminales y denotado por T.
Los siguientes son ejemplos de alfabetos (para diferenciarlos utilizamos subíndices):

N1={S,X,Y,Z}
N2={S}
T1={a, b,c}
T2={a}
T3={1,2,3}
T4={1,a,2,b,3}
Nótese que -por convención- generalmente utilizaremos minúsculas o números para los
elementos del alfabeto de Terminales y mayúsculas para los elementos del alfabeto de No
Terminales.
Las Gramáticas Regulares son de dos tipos: Gramáticas Regulares Lineales Derechas y
Gramáticas Regulares Lineales Izquierdas.
Cuando se habla de Gramáticas Regulares alguna literatura sólo hace mención de las
Gramáticas Regulares Lineales Derechas, y en varios casos confunden estos términos, es
decir, hablan de Gramáticas Regulares Lineales Derechas como si fueran las únicas
Gramáticas Regulares.
En estricto rigor es mejor conservar "el apellido", pues –como dijimos- existen Gramáticas
Regulares Lineales Izquierdas y Lineales Derechas.
GRAMÁTICAS REGULARES LINEALES DERECHAS

Una Gramática Regular Lineal Derecha (GRLD), denotada por G, es una cuádrupla:
G=(N, T, P, S) donde
N es un alfabeto de No Terminales o Variables
T es un alfabeto de Terminales
N y T son disjuntos (N∩Τ={}) un símbolo no puede ser Terminal y No Terminal a la vez.
S es un símbolo de N, es decir, S ∈ N, y se llama el símbolo raíz de la GRLD.
P es un conjunto finito, no vacío, de producciones.
Una producción de una GRLD es un par ordenado (α,β).

Al primer elemento α lo denominaremos parte izquierda de la producción y consiste de un
símbolo No Terminal cualquiera, α ∈ N.
8
Al segundo elemento β lo denominaremos parte derecha de la producción y puede ser de dos
tipos: bien un símbolo Terminal; o bien un símbolo Terminal seguido de un símbolo No
Terminal, β ∈ T o β ∈ (T.N).
En vez de un par ordenado, es muy común representar una producción separando las partes
derecha e izquierda por un símbolo de flecha así: α --> β.
Ejemplo:
La siguiente es una Gramática Regular Lineal Derecha (GRLD) G:
G=(N, T, P, S)
N={S}
T={a,b}
P={ (S,aS), (S,b) }
Como dijimos es usual describir el conjunto de producciones así: P={ S --> aS, S --> b }
Igual de frecuente es describir P a manera de un listado como a continuación mostramos.
P:
S --> aS
S --> b
Nosotros daremos las producciones en forma de listado a menudo.
La parte izquierda es un símbolo No Terminal que generalmente es una mayúscula.
La parte derecha es un símbolo Terminal, generalmente una minúscula o un número, que
puede estar solo o seguido de un símbolo No Terminal - generalmente una mayúscula-.
Pueden existir una, dos, tres, etc. producciones, siempre que sea un número finito.
Más ejemplos:
G=(N, T, P, S)
N={S,X,Y}
T={a,b,c}
P:
S --> aX
X --> bY
Y --> c

G=(N, T, P, S)
N={S,X,Y}
T={a}
P:
S --> aX
X --> a
Nótese que en este ejemplo no se utiliza el No Terminal Y. No hay problema, la
definición de GRLD permite este tipo de casos.
9
G=(N, T, P, S)
N={S,X}
T={a,b}
P:
S --> aS
S --> a
Nótese que en el ejemplo no se utilizan el No Terminal X ni el Terminal b. No hay
problema, la definición de GRLD permite este tipo de casos.
El siguiente es un mal ejemplo de Gramática Regular Lineal Derecha (GRLD) G:

G=(N, T, P, S)
N={Y,X}
T={a,b}
P:
S --> aS
S --> a
Nótese que S no está en N, por lo tanto no es una GRLD.

G=(N, T, P, S)
N={S,Y,X}
T={a,b}
P:
S --> aX
X --> Ya
Y --> b
Nótese que la segunda producción no obedece el formato indicado en lo que
concierne a la parte derecha (Terminal solo, ó Terminal seguido de No Terminal), en este caso
está al revés, no sigue la definición y por lo tanto no es una GRLD.

G=(N, T, P, S)
N={S,Y,X}
T={a,b}
P:
S --> aX
X --> aY
aY --> b
Nótese que la tercera producción no obedece el formato indicado en lo que
concierne a la parte izquierda (sólo un No Terminal), en este caso tiene dos símbolos, no sigue
la definición y por lo tanto no es una GRLD.
10
El siguiente es un mal ejemplo de Gramática Regular Lineal Derecha(GRLD) G:
G=(N, T, P, S)
N={S,Y,X}
T={a,b}
P:
S --> aX
X --> aY
a --> b
Nótese que la tercera producción no obedece el formato indicado en lo que concierne
a la parte izquierda (sólo un No Terminal), en este caso tiene un Terminal, no sigue la
definición y por lo tanto no es una GRLD.

G=(N, T, P, S)
N={S}
T={0,1,2,3,4,5,6,7,8,9}
P:
S --> 1S
S --> 2S
S --> 3S
S --> 4S
S --> 5S
S --> 6S
S --> 7S
S --> 8S
S --> 9S
S --> 0S
S --> 0
S --> 2
S --> 4
S --> 6
S --> 8
Es común agrupar varias producciones que tienen la misma parte izquierda separando las
partes derechas con una barra. De este modo el conjunto de producciones del último ejemplo
puede presentarse también como mostramos en seguida.
P:
S --> 1S | 2S | 3S | 4S | 5S | 6S | 7S | 8S | 9S | 0S
S --> 0 | 2 | 4 | 6 | 8
Mecanismo de funcionamiento de las GRLD’s

En principio vamos a definir el concepto de un paso de derivación en GRLD’s:
11
Se dice que en G damos un paso de derivación de la cadena u hacia la cadena v, lo que se
denota por u => v
si u = wXz y v = waz y X --> a ∈ P
o si u = wXz y v = waBz y X --> aB ∈ P
donde
u, v, w, z son cadenas que pueden formarse con los símbolos de (N ∪ T).
w, z pueden ser incluso la cadena vacía.
X, B son No Terminales
a es un Terminal
Ejemplos:
Sea la GRLD G=(N, T, P, S)
N={S,X,Y}
T={a,b,c}
P:
S --> aX
X --> bY
X --> bX
Y --> c
En los siguientes casos se da un paso de derivación de la cadena u hacia v, es lo mismo -y es
usual- decir que v deriva de u en un paso de derivación:
1) aaaXbbb => aaabXbbb pues

u = aaaXbbb v = aaabXbbb
en este caso w = aaa z = bbb y X --> bX ∈ P (es la tercera producción)
2) abXba => abbYba pues

u = abXba v = abbYba
en este caso w = ab z = ba y X --> bY ∈ P (es la segunda producción)
3) YaScYbS => YaSccbS pues

u = YaScYbS v = YaSccbS
en este caso w = YaSc z = bS y Y --> c ∈ P (es la cuarta producción)
4) Sba => aXba pues

u = Sba v = aXba
en este caso w = λ z = ba y S --> aX ∈ P (es la primera producción)
Nótese que cuando la cadena vacía no está sola, simplemente no la escribimos
5) Y => c pues
u=Y v=c
en este caso w = λ z = λ y Y --> c ∈ P (es la cuarta producción)
12
Más de un paso de derivación: el concepto de derivación a secas
Luego de un paso de derivación de una primera cadena hacia una segunda cadena, puede
generalizarse el concepto dando un segundo paso de derivación de la segunda cadena hacia
una tercera, y luego un tercer paso de derivación, y luego un cuarto, etc.
Así por ejemplo en la GRLD G vista arriba es posible escribir lo siguiente:
Sba => aXba => abXba
Donde para el primer paso de derivación se ha utilizado la primera producción (el subrayado
ayuda a ver esto), y para el segundo paso de derivación se ha utilizado la tercera producción
(las letras en negrita ayudan a ver esto).
Cuando escribimos más de un paso de derivación lícitamente, es posible resumir estos varios
pasos de derivación escribiendo un asterisco sobre la doble flecha.
De este modo en vez de Sba => aXba => abXba podemos escribir Sba =>* abXba y decir
que abXba deriva de Sba.
En la misma GRLD G es evidente que aXa => abXa => abbXa => abbbXa => abbbbXa
donde se ha usado varias veces la tercera producción, esto mismo puede escribirse/resumirse
así aXa =>* abbbbXa, lo que indica que abbbbXa deriva de aXa.
Una forma más amigable de mostrar una derivación paso a paso, por ejemplo de S =>* abc, es
así:
S => aX utilizando la primera producción

=> abY utilizando la segunda producción
=> abc utilizando la cuarta producción
Como convención nótese que usamos doble flecha => (con o sin asterisco) en las
derivaciones, y que utilizamos flecha simple --> en las producciones.
En rigor, lo que llamamos un paso de derivación no es sino el establecimiento de una relación

(de derivación) entre cadenas denotada por =>; y lo que estamos llamando resumen no es otra
cosa que la clausura reflexiva transitiva de dicha relación, lo que se denota por =>*; por este
motivo –debido a la identidad de la clausura reflexiva transitiva- siempre es posible escribir
que u =>* u para cualquier cadena u.
Cadenas generables por la GRLD G

Aunque en teoría en una GRLD podemos comenzar una derivación con cualquier cadena en
(N ∪ T)+, es importante considerar las derivaciones que comienzan por el símbolo raíz S, es
decir, con la cadena u = S.
En el ejemplo de la GRLD G de arriba podemos escribir lo siguiente:

=> abX utilizando la tercera producción
13
=> abbX utilizando la tercera producción
=> abbbX utilizando la tercera producción
=> abbbbY utilizando la segunda producción
=> abbbbc utilizando la cuarta producción
ó lo que es lo mismo S =>* abbbbc
Y también
=> abY utilizando la segunda producción
ó lo que es lo mismo S =>* abY
En el primer caso decimos que abbbbc deriva de S; y en el segundo que abY deriva de S.
Una cadena que pueda formarse con los símbolos de (N ∪ T), es generable -o se puede
generar- en la GRLD G (también denominada forma sentencial) si dicha cadena deriva de S.
Hemos llegado a uno de los problemas centrales de las GRLD’s: dada una cadena decir si la
misma deriva o no deriva del símbolo raíz S, es decir, si es una forma sentencial.
Con la GRLD que estamos viendo, la cadena abY si se puede generar en G pues S =>* abY, y
el ejemplo de arriba muestra cómo sería esta derivación paso a paso.
En cambio la cadena aY no se puede generar en G ¡Intente escribir una derivación paso a paso
que comience en S y termine en aY! simplemente es imposible.
Por ahora, para indicar que una cadena si se puede generar en una GRLD basta la derivación
paso a paso, misma que puede seguirse en detalle para ver si las producciones se han utilizado
correctamente. Sin embargo, para indicar que una cadena no se puede generar en una GRLD
sólo tenemos como ayuda el trabajo mental que podamos hacer con las producciones, más
tarde buscaremos otros recursos.
L(G) lenguaje generado por una GRLD

El lenguaje generado por una GRLD G denotado por L(G) se define así:
L(G) = { conjunto de todas las cadenas de sólo Terminales que se pueden generar en G }
Exactamente lo mismo lo anotaremos de manera formal así:
L(G) = { cadenas v de sólo Terminales / S =>* v }
L(G) = { v ∈ T* / S =>* v }
Llegamos así a otro problema central en GRLD’s:

Decidir si una cadena pertenece o no a L(G) para una GRLD G dada, es decir, si tal cadena de
sólo Terminales se deriva o no de S en la gramática.
Ejemplo:
Con la GRLD G de arriba, es claro que abbbbc ∈ L(G) pues ya mostramos con todo detalle
que S =>* abbbbc.
14
Es también posible evidenciar, por inspección de las producciones, que bbb ∉ L(G) pues toda
cadena generable en la GRLD debe empezar su derivación utilizando la primera producción
–las otras producciones no tienen a S como parte izquierda-, sin embargo, esta primera
producción convierte S en aX, de manera que las cadenas generables tendrán una a como
primer símbolo Terminal condición que no cumple bbb.
Ya dijimos que, para mostrar que una cadena no se puede generar en una GRLD sólo tenemos
como ayuda la –a veces no tan– simple inspección de las producciones. Cuando la GRLD
tiene pocos Terminales y No Terminales y cuando el número de sus producciones es menor,
este análisis tiende a simplificarse, empero, cuando esto no es cierto, hacen falta recursos
teóricos adicionales y una alta dosis de práctica.
Ejemplos de L(G):
Fíjese que la definición de L(G) dice todas: no una, ni algunas, ni casi todas. Dice todas las
cadenas de Terminales que se puedan derivar de S. Es decir, hay que imaginar cada una de las
posibles derivaciones.
Sea la GRLD G=({S,X}, {a,b}, P, S)

P:
S --> aX
X --> a
Nótese la manera en que se presentan N y T, forma también válida.
L(G)={aa} Únicamente la cadena "aa" es de sólo Terminales y derivable desde S
Sea la GRLD G=({S,X,Y}, {a,b}, P, S)

P:
S --> aX
X --> bY
Y --> a
L(G)={aba} Únicamente la cadena "aba" es de sólo Terminales y se deriva de S

P:
S --> aX
X --> bS
L(G) = { } No hay siquiera una cadena de sólo Terminales que se pueda derivar de S
Sea la GRLD G=({S}, {a}, P, S)

P:
S --> aS
S --> a
15
Este es un buen ejemplo para ir comprendiendo las GRLD’s. Ahora no debería ser difícil
confirmar que las siguientes derivaciones son lícitas:
En vez de ‘por la segunda producción’, escribiremos simplemente ‘por 2’.
i) S =>* a Pues S => a por 2
ii) S =>* aa Pues S => aS por 1
=> aa por 2
iii) S =>* aaa Pues S => aS por 1
=> aaS por 1
=> aaa por 2
iv) S =>* aaaa Pues S => aS por 1
=> aaS por 1
=> aaaS por 1
=> aaaa por 2
Si analizamos mentalmente el comportamiento de la GRLD entonces podemos inducir que
también lo siguiente es válido: S =>* aaaaa, S =>* aaaaaa, etc. Así
L(G)={ secuencias de a’s: una a, dos a’s, tres a’s, etc.} = {a, aa, aaa, aaaa, aaaaa, ...}
Este ejemplo nos muestra la necesidad de tener una forma de describir los lenguajes cuando
son conjuntos infinitos (o finitos muy grandes). Utilizaremos para ello y de manera libre las
operaciones y notaciones generalmente utilizadas con cadenas y/o lenguajes: la inversa,
concatenaciones, el uso de los paréntesis, potencias de cadenas, longitudes, etc.
Así para este caso tenemos L(G) = {ak / k > 0 } pues
L(G) = {ak / k > 0 } = {a1, a2, a3, ...} = {a, aa, aaa, ...}

P:
S --> aX
X --> bX
X --> b
L(G)={abk / k > 0}, es decir, una a seguida de una, dos o más b’s.
Sea la GRLD G=({S,X,Y}, {a,b,c}, P, S)

P:
S --> aX
X --> bS
X --> bY
Y --> c
Veamos algunas derivaciones para visualizar el comportamiento de esta GRLD.
i) S=>aX=>abY=>abc
ii) S=>aX=>abS=>abaX=>ababY=>ababc
iii) S=>aX=>abS=>abaX=>ababS=>ababaX=>abababY=>abababc
Esto nos sugiere L(G)={(ab)kc / k > 0}
16
Sea la GRLD G=({S,X,A}, {0,1,2,3,4,5,6,7,8}, P, S)
P:
S-->0X
S-->8
X-->3S
Hay algunos terminales que no se usan y A tampoco se usa en las producciones pero ello no
está prohibido por nuestra definición. Es un buen ejemplo cuyo L(G)={ (03)k8 / k ≥ 0 }.
Sea la GRLD G=({S,X,Y}, {a,b,c}, P, S)

P:
S-->aX
X-->bY
X-->bX
Y-->c
L(G) = {abkc / k > 0 }

P:
S-->aX
X-->bS
S-->b
L(G)={ (ab)kb / k ≥ 0 }
Dado un lenguaje escribir las producciones

Un aspecto complementario consiste en escribir la GRLD G cuando nos dan un conjunto dado
de cadenas de sólo Terminales, es decir un lenguaje propuesto que denotaremos por L.
Ejemplos:
Construya una GRLD G para el lenguaje L={ akbi / k > 0, i > 0 }
Podemos escribir la siguiente GRLD –sólo incluimos las producciones-:
P:
S --> aS
S --> aB
B --> bB
B --> b
Construya una GRLD G que genere L={aub / u ∈ {a,b}*}

La siguiente GRLD hace ello –sólo incluimos las producciones-:
P:
S-->aX X-->aX
X-->bX X-->b
17
Dudas comunes
Cuando se intenta derivar una cadena a partir de S -o de cualquier otra cadena- el orden y el
número de veces que se utilicen las producciones no importa. Existen derivaciones donde se
utiliza una; otras en que se utilizan dos, tres o más. Tampoco es necesario un orden dado. Se
puede utilizar sólo la última; sólo la penúltima; la tercera luego la primera; etc., etc., etc.
En las producciones es posible que no se utilicen algunos Terminales o algunos No

Terminales; también es posible que existan producciones que no intervengan en el lenguaje
derivado, no hay problema siempre que respeten el formato, por ejemplo la siguiente GRLD,
de la que sólo presentamos P:
S-->aS
S-->a
Z-->aS
Y-->b
genera L(G)={ak / k>0}, pero ni la tercera ni la cuarta producción intervienen en la generación
de cadenas de sólo Terminales a partir de S. No hay problema toda ella es una muy buena
GRLD.
¿Cuántos No Terminales/Terminales deben tener la gramáticas? Desde 1 hasta n (finito)

depende del lenguaje que estemos considerando.
¿Cuántas producciones del tipo X --> a deben tener las gramáticas? Desde cero hasta todo P,
depende del lenguaje que estemos considerando.
¿Cuántas producciones deben tener las gramáticas y de qué forma? Desde 1 hasta n (finito),
depende -sobre todo la forma de las producciones- del lenguaje que estemos considerando.
Errores comunes
P:
S --> aX
X --> bS
S --> b
Un primer error es de notación:
Si queremos describir que S =>* abb, ello puede hacerse así:
S => aX por 1
=> abS por 2
=> abb por 3
Pero no así:
S => aX por 1
S => abS por 2
S => abb por 3
Pues aquí la "S" que está a la izquierda de la segunda línea y de la tercera hace que esta
descripción sea errónea. En vez de decir lo que queremos, pareciera describir tres ejemplos de
derivación que obviamente no son lícitos en los dos últimos casos.
18
Un segundo error es no percibir que hay una diferencia fuerte entre una cadena derivable a
partir de otra cadena y una cadena en L(G), en este último caso se exige que la derivación
empiece en S. Las cadenas en L(G) son cadenas de sólo terminales cuya derivación comienza
en S (no en X, no en bS, no en SS, sino en S sola).
Por ejemplo cuando con alguna GRLD indicamos que bababb está en L(G) pues
X=>bS=>baX=>babS=>babaX=>bababS=>bababb en esa gramática, ello no es correcto pues
esta argumentación incluye una derivación que no comienza en S.
Igual de errado sería indicar que S=>*abb porque sabemos que aX=>abS =>abb.
Un tercer error común es esperar que las gramáticas se comporten sólo como quisiéramos,
olvidando otras posibles derivaciones. Por ejemplo, cuando se desea escribir una GRLD G
que genere L(G)={(ab) k / k>0}, hay quienes presentan falsas soluciones de este tipo, sólo
incluimos P:
S --> aS
S --> bS
S --> b
Bajo el siguiente razonamiento: esta derivación es posible S=>aS=>ab (por 1 y luego3);
también S=>aS=>abS=>abaS=>abab (por 1, 2, 1 y 3); y también S=>*ababab, S=>*abababab;
etc., luego L(G)= {(ab) k / k>0}.
Todas estas derivaciones son correctas, pero –y aquí está lo errado del razonamiento- no son
las únicas posibles. En esta GRLD también se puede derivar S=>*bbb, S=>*bab, etc.
En estricto rigor para este caso {(ab) k / k>0} _ L(G) y, más precisamente, L(G)={a,b}*.{b}.
Nótese que para denotar L(G) hemos apelado a una notación que va más allá de las potencias
de cadenas. Un cuarto error común es encerrarse en algún tipo de notación, por ejemplo
potencias, subutilizando otras posibilidades.
En este ejemplo también podemos escribir L(G)={ub / u ∈ T*} con T={a,b}.
El tercer error que estamos comentando es muy usual, presentaremos más casos.
Construya una GRLD G que genere L={ oruro }
P erróneo:
S-->oX
X-->rY
Y-->uX
Y-->o
Segundo P erróneo:
S-->oS
S-->rU
U-->uR
R-->rO
O-->o
19
Recordemos que G debe generar oruro y sólo oruro.
Pero en el primer caso es claro que S=>oX=>orY=>oro, también se puede derivar orururo,
orururururo, etc. Este es un típico ejemplo de casi está bien, que en rigor significa: está mal.
En el segundo caso es claro que se puede derivar oruro, ruro, oooooooooruro, ooooruro, etc.
Construya una GRLD G que genere L={aub / u ∈ {a,b}* }

P erróneo:
S-->aX
X-->aY
Y-->bX
X-->bY Esta GRLD no puede generar "ababbb" que está en L. No es solución.
Y-->b
Otro P erróneo:
S-->aS
S-->bS
S-->a Genera a, b, bba, etc. Que no están en L. No es solución.
S-->b
Otro P erróneo:
S-->aX
X-->bY
X-->aY
X-->bS
X-->aS
Y-->aX No logra generar abbbb, abbbbbb, etc. No es solución
Y-->b
GRAMÁTICAS REGULARES LINEALES IZQUIERDAS

La idea de Gramática Regular Lineal Izquierda es semejante a la idea de GRLD. Lo único que
varía es el formato de las partes derechas de las producciones.
Una Gramática Regular Lineal Izquierda (GRLI), denotada por G, es una cuádrupla:
G=(N, T, P, S) donde
N es un alfabeto de No Terminales
N y T son disjuntos (N∩Τ={}) un símbolo no puede ser Terminal y No Terminal a la vez.
S es un símbolo de N, es decir, S ∈ N, y se llama el símbolo raíz de la GRLI.
P es un conjunto finito, no vacío, de producciones.
Una producción de una GRLI es un par ordenado (α,β).

Al primer elemento α lo denominaremos parte izquierda de la producción y consiste de un
símbolo No Terminal cualquiera, α ∈ N.
20
Al segundo elemento β lo denominaremos parte derecha de la producción y puede ser de dos
tipos: bien un símbolo Terminal; o bien un símbolo No Terminal seguido de un símbolo
Terminal, β ∈ T o β ∈ (N.T).
En vez de un par ordenado, es muy común representar una producción separando las partes
derecha e izquierda por un símbolo de flecha así: α --> β. Luego, las producciones en una
GRLI son o bien del tipo A-->a o bien del tipo A-->Ba (donde A,B ∈ N y a ∈ T).
Ejemplos:
Sea la siguiente Gramática Regular Lineal Izquierda (GRLI) G=({S}, {a,b}, P, S)
P:
S --> Sa
S --> b
Sea la siguiente Gramática Regular Lineal Izquierda G=({S,X,Y}, {a,b,c}, P, S)

P:
S --> Xc
X --> Yb
Y --> a
Sea la siguiente Gramática Regular Lineal Izquierda G=({S,X,Y}, {a,b}, P, S)

P:
S --> Xa
X --> a
Todas las otras ideas que existen para GRLD’s se aplican a GRLI’s: derivación, L(G), dado
un lenguaje escribir las producciones, etc., etc., etc.
La siguiente GRLI de la que sólo mostramos P genera L(G)={oruro}

P:
S --> Ro
R --> Ur
U --> Zu
Z --> Or
O --> o
La derivación de la cadena oruro sería así:
S => Ro por 1
=> Uro por 2
=> Zuro por 3
=> Oruro por 4
=> oruro por 5
21
Es interesante cómo las GRLI’s generan los símbolos de derecha a izquierda, al revés que las
GRLD’s.
Una gramática regular o bien es una GRLI o bien es una GRLD, no puede ser ambas cosas a
la vez. Por ejemplo el siguiente conjunto de producciones P:
S --> Sa
S --> aS
S --> Xa
S --> aY
Y --> a no corresponde ni a una GRLI ni a una GRLD. Por ahora no tiene sentido,
X --> b aunque más adelante diremos que es una gramática libre de contexto.
Más ejemplos:
Presentamos a continuación ejemplos de gramáticas tanto lineales izquierdas como derechas,
se puede aprender mucho de ellos. Aquí están:
Sea la GRLD G=({S}, {a}, P, S)

P:
S --> aS
L(G)={ }
Sea la GRLI G=({S,X,Y}, {a,b}, P, S)

P:
S --> Sb | Xb
X --> Xa | a
L(G)={ akbi / k > 0, i > 0 }

P:
S --> aX
X --> aX | b | bY
Y --> bY | b
L(G)={ akbi / k > 0, i > 0 }
Es el mismo lenguaje que el del anterior ejemplo, lo que muestra que puede existir más de una
gramática regular que genere el mismo lenguaje.
Sea la GRLI G=({S}, {0,1}, P, S)

P:
S --> 1 | S1| Y1
Y --> Y0 | 0
L(G)={ 0k1i / k ≥ 0, i > 0 }
22
Queremos enfatizar que k ≥ 0 no es lo mismo que k > 0. En general, al escribir L(G) debemos
ser precisa y rigurosamente exactos, basta que haya una cadena demás o una cadena de
menos para hacer erróneo el resultado.
Sea la GRLD G=({S}, {0,1,2,3,4,5,6,7,8,9}, P, S)

P:
S --> 1S | 2S | 3S | 4S | 5S | 6S | 7S | 8S | 9S | 0S
S --> 0 | 2 | 4 | 6 | 8
L(G)={ uv / ( u ∈ T* ) y ( v=0 ó v=2 ó v=4 ó v=6 ó v=8 )}
Interpretadas las cadenas de sólo Terminales como números enteros no negativos, podríamos
describir L(G) también así L(G)={ números pares }.
Fíjese que es probable que se describa así L(G)={2k / k≥0}, sin embargo, conviene aclarar
esta última notación. Como estamos trabajando con cadenas, diera la impresión que
L(G)={20,21,22,23,24,......} –si se interpreta ‘2k’ como dos concatenado con k-; cuando lo
que significa 2k es la usual representación de los números pares. Por ello es mejor anclarse en
el mundo de las cadenas y los lenguajes (y los superíndices como en la aritmética usual), ó
aclarar la notación si esta es pasible a más de una interpretación.
Sea la GRLI G=({S,X,Y}, {a,b}, P, S)

P:
S --> Xa | Xb
X --> Ya | Yb
Y --> Ya | Yb | a | b
L(G)={ u / ( u ∈ {a,b}* ) y ( |u| ≥ 3 ) }
Sea la GRLD G=({S,X}, {a,b,2}, P, S)

P:
S-->aX
S-->b
X-->2S
L(G)={ (a2)kb / k ≥ 0}
NOTACIÓN, CONVENCIONES Y TOMA DE POSICIÓN: el caso de la cadena vacía

Ya hicimos notar que, según sea la literatura que se revise, existen varias diferencias de
notación. Es típico por ejemplo que muchos textos denoten a la cadena vacía con la letra
griega lambda (λ), mientras que otros la denotan con la letra griega épsilon (∈), e incluso con
un cero (0); otros se refieren al alfabeto T con el símbolo Σ, o con VT para el alfabeto de
Terminales y VN para el de No Terminales; en algunos lugares utilizan R para el símbolo raíz;
otros prefieren no hacer diferencia de notación entre --> y =>; etcétera.
Eso no debiera ser un problema, basta hacer un convenio, es decir, llegar a un acuerdo para
elegir alguna notación y trabajar con ella. Se sobreentiende que si leemos un documento con
23
otra notación debiéramos hacer un breve ejercicio mental -si fuera necesario- para traducir
dicho documento a “nuestra” notación; o bien manejar personalmente más de una notación.
Hay asuntos más complejos que van más allá de la simple notación, se trata de la división que
existe entre los autores acerca de cuestiones, no de matiz, sino de fondo.
Por ejemplo está el caso teórico de si P (el conjunto de producciones) puede ser vacío o no,
algunos teóricos aceptan que P pueda tener cero producciones; y otros exigen que P sea no
vacío; en el tratamiento de autómatas finitos –capítulo que veremos más adelante- ciertos
autores aceptan F vacío y otros exigen F no vacío; y como estas hay otras divergencias de
fondo.
Una por ahora es central en la materia que estamos viendo:

Hay autores que aceptan una GRLD G=({S}, {b}, P, S) así:
P:
S --> bS
S --> λ
Para indicar una GRLD G que genere L(G)={ bk / k ≥ 0 } Se sabe aquí que b0 = λ
Es decir que la parte derecha de una producción no sólo sea del tipo que presentamos en
nuestra definición, sino que también se aceptan partes derechas con la cadena vacía λ, en
cambio otros niegan tal posibilidad, y otros aceptan una única producción de este tipo con S
como parte izquierda. Lo mismo sucede para las GRLI’s.
Nótese que si aceptamos λ como parte derecha la siguiente GRLD: G=({S}, {b}, P, S)
P:
S --> λ
Genera L(G)={λ}
En cambio si no aceptamos λ como parte derecha, es decir, siguiendo nuestra definición de
gramática regular, dichas gramáticas nunca podrán generar la cadena vacía.
Cuando se presentan este tipo de diferencias fuertes, no queda sino tomar posición, mejor si es
en base a argumentos razonablemente plausibles. Nosotros iremos tomando posición explícita
o implícitamente según se presenten los dilemas.
Para el caso que nos ocupa conservaremos nuestra definición y no aceptaremos λ como parte
derecha de ninguna producción en una GR.
Una justificación de ello es que si empezamos una derivación en la cadena S entonces, por la
forma de las producciones, la segunda cadena -obtenida al dar el primer paso de derivación-
será de longitud mayor o igual que |S|; a partir de esta segunda se puede obtener una tercera
en un siguiente paso de derivación que, por lo mismo, será de longitud mayor o igual que la
segunda, etc. Es decir, si tenemos la siguiente derivación genérica:
S => u2 => u3 => ... => un
Con nuestra toma de posición se tiene que: |S| ≤ |u2| ≤ |u3| ≤ ... ≤ |un|
24
Que denominaremos propiedad de no decrecimiento y que permite diseñar algunas
demostraciones teóricas sobre gramáticas en general –regulares y otras- que no tendrían éxito
si aceptamos λ como parte derecha, es decir, si la longitud de las cadenas en una derivación
crece, decrece o se mantiene arbitrariamente.
Estas demostraciones señalan propiedades que –a nuestro juicio- son más trascendentales que
la facilidad de incluir λ como parte derecha o la posibilidad importante de generar la cadena
vacía.
Problemas varios
A continuación presentamos problemas propuestos junto a sus soluciones. Sin embargo, es
importante que intente solucionarlos y -más tarde- comparar las respuestas que se dan con sus
respuestas. Es claro que las soluciones que se muestran a continuación no son únicas
necesariamente, es decir, no quiere decir que son estas a las que se debe llegar.
Pero sean cuales fueren sus soluciones, es claro también que deben ser correctas.
Problema 1
Escriba una GRLD G que genere cadenas en {a,b}* de longitud par y que terminen en a, es
decir, G debe ser tal que L(G)={ua / u ∈ {a,b}* y |u|=2i+1 i ≥ 0}
Solución, sólo escribimos P:
P={ S-->aA, S--> bA, A--> aB, A-->bB, B-->aA, B-->bA, A-->a }
Problema 2
Escriba una GRLD G que genere cadenas en {0,1,...,8,9}* que interpretadas como números
naturales denoten números divisibles por 3.
S --> 0S
S --> 1U U --> 0U D --> 0D
S --> 2D U --> 1D D --> 1S
S --> 3S U --> 2S D --> 2U
S --> 4U U --> 3U D --> 3D
S --> 5D U --> 4D D --> 4S
S --> 6S U --> 5S D --> 5U
S --> 7U U --> 6U D --> 6D
S --> 8D U --> 7D D --> 7S
S --> 9S U --> 8S D --> 8U
S --> 0 U --> 9U D --> 9D
S --> 3 U --> 2 D --> 1
S --> 6 U --> 5 D --> 4
S --> 9 U --> 8 D --> 7
Problema 3
25
naturales denoten números impares.
S --> 1S | 2S | 3S | 4S | 5S | 6S | 7S | 8S | 9S | 0S
S --> 1 | 3 | 5 | 7 | 9
Problema 4
naturales denoten números divisibles por 6.
S --> 0S | 1X | 2Y | 3S | 4X | 5Y | 6S | 7X | 8Y | 9S | 0 | 6
X --> 0X | 1Y | 2S | 3X | 4Y | 5S | 6X | 7Y | 8S | 9X | 2 | 8
Y --> 0Y | 1S | 2X | 3Y | 4S | 5X | 6Y | 7S | 8X | 9Y | 4
Problema 5
Escriba una GRLI G tal que L(G)={ uabaa / u ∈ {a,b}* }
P={S-->Aa, A-->Ba, B-->Zb, Z-->Xa, X-->Xa, X-->Xb, Z-->a, X-->a, X-->b}
Lenguaje regular
Un lenguaje cualquiera L se dice que es un lenguaje regular si existe una GRLD o una GRLI
que genera dicho lenguaje (que eso nos baste por ahora, en realidad hay más casos en los que
a un lenguaje cualquiera se le puede decir regular).
Por ejemplo, a la pregunta si L={a} es o no un lenguaje regular podemos indicar que sí
describiendo la GRLD que genera este lenguaje: G=({S}, {a}, P, S) P: S-->a
A la pregunta si L={ ak / k ≥ 0 } es o no un lenguaje regular podemos indicar que no. Nuestra

definición de gramática regular no permite a las gramáticas regulares generar la cadena vacía,
y este lenguaje cuando k=0 incluye la cadena vacía.
Cuando se pregunta si un L dado es regular o no. Al responder que sí debemos describir la

gramática regular que lo genera.
Es un poco más complicado responder que no, no basta que no podamos escribir una
gramática, debemos mostrar que nadie puede ni podrá hacerlo, veremos eso luego.
L(G) lenguaje generado por G versus L lenguaje que creemos genera G ¿L=L(G)?
Hasta ahora hemos dejado de lado un hecho importante. En los ejemplos vistos no se ha
acompañado una razón, salvo la experiencia del autor, para evidenciar los lenguajes L(G) que
se han anotado.
Es claro que en gramáticas sencillas, tales como P={S --> b}, basta la simple inspección para
escribir o concordar con L(G). Sin embargo, en otras gramáticas más largas y/o más
26
complejas no suele ser claro el lenguaje generado, y por tanto debe exigirse una
argumentación además de la explicitación de L(G).
Lamentablemente otro error común es confundir una prueba del lenguaje generado por una
gramática con la descripción de algunas derivaciones. Para P={S --> aS, S --> a}, por
ejemplo, es un abuso escribir L(G)={ ak / k > 0 } indicando que “... en efecto véase la
siguiente derivación: S=>aS=>aaS=>aaa ” y quizás algunas otras derivaciones. Es una audacia
subtitular esto bajo el epígrafe de prueba. En rigor, una, dos o varias derivaciones no prueban
nada.
Ello es más visible cuando se pide escribir una gramática que genere L={algún lenguaje}; no
basta explicitar las producciones, de manera de confiar en el autor de las mismas, debiera
acompañarse una argumentación o una demostración de que el lenguaje L(G) generado por la
gramática a través de dichas producciones, coincide con el lenguaje L.
Expliquemos la diferencia fuerte que existe entre L y L(G) a través de un ejemplo corto.
Suponga que tenemos el siguiente conjunto de producciones P={S --> bA, A --> a } y se nos
pide indicar el lenguaje que genera esta gramática, suponga que escribimos L(G)={a}.
Evidentemente –debido a la sencillez de la GRLD- ello no es cierto. Debido a esto, aunque la
literatura en general utiliza L(G) directamente, es más prudente indicar el lenguaje que genera
esta gramática a través de L –el nombre de un lenguaje-, así por ejemplo para esta gramática
alguien podría indicar que la misma genera el siguiente lenguaje L1={ab}; e incluso un tercero
podría sugerir que no, que lo que genera esta gramática es L2={b}.
Para cada L sugerido (L1, L2, etc. ) cada proponente tiene además la tarea de demostrar que
L=L(G).
Lo mismo sucede cuando se pide construir las producciones para un L dado. Digamos que se
pide construir una GRLI para L={(ab)i / i > 0} y se propone P={S --> Sa, S --> Sb, S --> a};
no basta este conjunto, debe además comprobarse que L=L(G) –si ello es posible-.
Si se tiene
a) una gramática y se sugiere un lenguaje L como el lenguaje que genera la gramática; o
b) un lenguaje L y se construye el conjunto de producciones pensadas para generar L
y el observador cae en cuenta de que existe un clara equivocación, es decir que L ≠ L(G), es
decir que esas producciones no generan el lenguaje que se indica en L, entonces en este caso
bastará la derivación de una cadena que no esté en L a través de las producciones, a manera de
contraejemplo. Para P={ S --> Sa, S --> Sb, S --> a} y L={(ab)i / i > 0} basta con la
derivación S => a (por 3) para mostrar una cadena que sí está en L(G) y que no está en L pues
para ningún i sucede que a=(ab)i, esto es suficiente para comprobar que L ≠ L(G), en otras
palabras
a) si las producciones estaban dadas y se pedía indicar el lenguaje que generan, dicho L está
errado; o
27
b) si L estaba dado y se pedía construir las producciones de una GRLI, tales producciones no
generan L.
Sin embargo, si parece que en efecto el lenguaje que genera la gramática L(G) es el mismo
que el lenguaje L, entonces dicho parecer debe transformarse en seguridad a través de una
demostración.
La demostración o prueba de que L=L(G) tiene dos partes:

i) L ⊆ L(G), las cadenas del tipo indicado en L sí se pueden generar en G, esto se hace con
frecuencia por inducción sobre la longitud de las cadenas en L; y
ii) L(G) ⊆ L, las cadenas que genera G son del tipo indicado en L, esto se hace con frecuencia
por inducción sobre el número de pasos de derivación en G.
Si bien esta es una salida genérica, las demostraciones son comúnmente áridas.
Ejemplos:
Sea la GRLI G=({S}, {a}, P, S)
P:
S --> Sa
S --> a
Sugerimos que el lenguaje que genera G es L={ai / i > 0}
Y demostraremos que L=L(G)
i) L ⊆ L(G)
Sea u ∈ L entonces -debemos demostrar que- u ∈ L(G).
Para las cadenas que tienen la forma sugerida en L, debemos demostrar que dichas cadenas se
derivan a partir de S en G.
Por inducción sobre la longitud de las cadenas en L.
Es claro que las cadenas en L tienen, genéricamente, una longitud |u|=i, i > 0.
Caso base:
La cadena más pequeña en L tiene longitud |u|=1, cuando dicha cadena es u=a, para i=1.
La derivación S => a (por 2), es lícita y muestra que u ∈ L(G)
Hipótesis inductiva:
Toda cadena u ∈ L de longitud |u|=i –dicha cadena no es otra que u=ai-, sí se puede derivar de
S en G (S=>*u), es decir, también está en L(G), o lo que es lo mismo u ∈ L(G).
Paso inductivo:
Sea una cadena w ∈ L de longitud |w|=i+1, es decir w=ai+1=ua donde |u|=i, u=ai
La siguiente derivación es lícita.
S => Sa por 1
=>* ua por hipótesis inductiva pues S=>*u, cuando u=ai, es decir, cuando u ∈ L y |u|=i
Luego S=>*w, lo que muestra que w ∈ L(G).
28
Por el caso base, la hipótesis inductiva y el paso inductivo: L ⊆ L(G)
ii) L(G) ⊆ L
Sea u ∈ L(G) entonces -debemos demostrar que- u ∈ L.
Para las cadenas que se derivan a partir de S en G, debemos demostrar que dichas cadenas
tienen la forma indicada en L.
Por inducción sobre el número de pasos de derivación de una cadena en L(G).
Caso base:
Sea u ∈ L(G) que se deriva en el menor número de pasos de derivación, es decir un paso. La
única cadena que se puede derivar de S en un solo paso, con la derivación S => a (por 2), es
u=a.
Ahora u=a=a1=ai con i=1, que obviamente obedece el formato de L, es decir, u ∈ L.
Toda cadena u ∈ L(G) que se deriva de S en k pasos o menos también está en L, o lo que es lo
mismo u ∈ L.
Paso inductivo:
Sea w ∈ L(G) que se deriva de S en k+1 pasos.
Para dar k+1 pasos de derivación primero damos un paso de derivación y luego los restantes
k pasos, desglosemos pues de este modo los k+1 pasos de derivación de w.
S => cadenauno aquí está el primer paso de derivación
=>* w a partir de cadenauno se dan otros k pasos de derivación para obtener w
haciendo un total de k+1 pasos de derivación
Ahora bien por la forma de las producciones de G, en el primer paso de derivación a partir de
S, la cadena resultante (cadenauno) no puede ser otra que Sa utilizando la primera producción
(pues la otra alternativa es utilizar la producción 2 que nos devuelve al caso base y que deja
los restantes k pasos iguales a cero).
Luego la derivación de w a partir de S en k+1 pasos no debe ser otra que
S => Sa por 1, primer paso de derivación
=>* w w se obtiene de Sa con los siguientes k pasos de derivación
Pero entonces, por el mecanismo de funcionamiento de las GRLI’s, w es de la forma w=ua

donde S=>*u en k pasos, es decir,
S => Sa por 1
=>*ua(=w) w=ua se obtiene de Sa, con la derivación S=>*u en k pasos
Pero entonces, por hipótesis inductiva u ∈ L, puesto que se deriva de S en k pasos, es decir,
u=ai (i>0), de donde w=aia. Es decir, w=ai+1, o lo que es lo mismo w=aj, con j=i+1 (j > 0).
Luego, w ∈ L.
Por el caso base, la hipótesis inductiva y el paso inductivo: L(G) ⊆ L
29
Por i) L ⊆ L(G) y ii) L(G) ⊆ L, concluimos que L=L(G).
Sea la GRLI G=({S1,S}, {a,b}, P, S1)

P:
S1 --> Sb
S --> Sa
S --> a
Nótese que aquí S es un No Terminal cualquiera y que el símbolo raíz es S1
Sugerimos que el lenguaje que genera G es L={aib / i > 0}
Podemos reutilizar la demostración de arriba donde se vio que

S=>*u si y solo sí u=ai con i > 0
Por tanto, por el mecanismo de funcionamiento de las GRLI’s,
S1 => Sb por la primera producción
=>*ub con u=ai con i > 0 por la demostración de arriba
Luego
S1=>*ub si y solo sí u=ai con i > 0, es decir
S1=>*w si y solo sí w=aib con i > 0, es decir L=L(G)
Sea la GRLD G=({S,B}, {a,b}, P, S)

P:
S --> aB
B --> bS
B --> b
Sugerimos que el lenguaje que genera G es L={(ab)i / i > 0}
Y demostraremos que L=L(G)
i) L ⊆ L(G)
Sea u ∈ L entonces -debemos demostrar que- u ∈ L(G).
Para las cadenas que tienen la forma sugerida en L, debemos demostrar que dichas cadenas se
derivan a partir de S en G.
Por inducción sobre la longitud de las cadenas en L.
Es claro que las cadenas en L tienen, genéricamente, una longitud |u|=2i, i > 0.
Caso base:
La cadena más pequeña en L tiene longitud |u|=2, cuando dicha cadena es u=ab, para i=1
La derivación
S => aB por 1
=> ab por 3
es lícita y muestra que u ∈ L(G)
Toda cadena u ∈ L de longitud |u|=2i –dicha cadena no es otra que u=(ab)i-, sí se puede
derivar de S en G (S=>*u), es decir, también está en L(G), o lo que es lo mismo u ∈ L(G).
30
Paso inductivo:
Sea w∈ L de longitud |w|=2(i+1)=2i+2, es decir w = (ab)i+1 = abu donde |u|=2i, u=(ab)i
La siguiente derivación es lícita.
S => aB por 1
=> abS por 2
=>*abu por hipótesis inductiva
pues S=>*u, cuando u=(ab)i, esto es, cuando u ∈ L y |u|=2i, que es el caso
*
Luego S=> w, lo que muestra que w ∈ L(G)
Por el caso base, la hipótesis inductiva y el paso inductivo: L ⊆ L(G).
ii) L(G) ⊆ L
Sea u ∈ L(G) entonces -debemos demostrar que- u ∈ L.
Para las cadenas que se derivan a partir de S en G, debemos demostrar que dichas cadenas
tienen la forma indicada en L.
Por inducción sobre el número de pasos de derivación de una cadena en L(G).
Caso base:
Sea u ∈ L(G) que se deriva en el menor número de pasos de derivación, en el caso que nos
ocupa dos pasos. La única cadena que se puede derivar de S en dos pasos, con la derivación
S=>aB=>ab -por 1 y 3 respectivamente- es u=ab.
Ahora u=ab=(ab)1=(ab)i con i=1, que obviamente obedece el formato de L, es decir, u ∈ L.
Toda cadena u ∈ L(G) que se deriva de S en menos de k pasos también está en L, o lo que es
lo mismo u ∈ L.
Paso inductivo:
Sea w ∈ L(G) que se deriva de S en k pasos.
Vamos a desglosar estos k pasos de derivación de la siguiente manera, notando que para el
primer paso de derivación la única producción utilizable es la primera.
S => aB aquí está el primer paso de derivación, por 1
=> abS por 2
la otra alternativa para este segundo paso de derivación es usar la producción 3
lo que nos devuelve al caso base ya visto
=>*abu los restantes pasos (del total de k pasos) para obtener w
De manera que w es de la forma w=abu.

Más aún u deriva de S, S=>*u, en menos de k pasos (k-2 si queremos ser precisos), pero
entonces por hipótesis inductiva u ∈ L, es decir, u=(ab)i (i>0).
De donde w=ab(ab)i, es decir, w=(ab)i+1, o lo que es lo mismo w=(ab)j, con j=i+1 (j > 0).
Luego, w ∈ L.
Por el caso base, la hipótesis inductiva y el paso inductivo: L(G) ⊆ L.
Por i) L ⊆ L(G) y ii) L(G) ⊆ L, concluimos que L=L(G).
31
Aunque la literatura rara vez demuestre la comprobación del lenguaje generado para una
gramática completa, es importante comprender la significación del razonamiento expuesto: la
comprobación de que un conjunto dado de producciones genera un lenguaje determinado;
pues de lo contrario la teoría tendría poco que ofrecer y nosotros mucho que confiar –a ciegas-
en lo que los proponentes de L’s o de producciones hagan.
Las ideas aquí presentadas no sólo sirven para gramáticas regulares sino que pueden aplicarse
a otro tipo de gramáticas.
32
CAPÍTULO 3. AUTÓMATAS FINITOS
Así como hay gramática regulares lineales izquierdas y derechas que son diferentes pero que
en el fondo hacen lo mismo, también hay varios tipos de Autómatas Finitos (AF’s). Es usual
considerar principalmente los determinísticos y los no determinísticos pero no son los únicos.
AUTÓMATAS FINITOS DETERMINÍSTICOS (AFD’s)

Un Autómata Finito Determinístico (AFD) es una quíntupla A = ( K, Σ, δ, q1, F ) donde
K : conjunto finito no vacío de estados
Σ : alfabeto de entrada
δ : función de transición (formalmente se define así δ : K X Σ ---> K δ debe ser total)
q1 : estado inicial del AFD q1 ∈ K (es decir, q1 debe estar en K)
F : conjunto de estados finales F ⊆ K
Ya advertimos que a menudo debemos tomar posición respecto a varias cosas: en otros
lugares suelen usar q0 como estado inicial, nosotros haremos uso generalmente de q1.
Tampoco permitimos el conjunto vacío como conjunto de estados.
En cambio F sí puede ser vacío en nuestro caso.
Ejemplo:
El siguiente es un Autómata Finito Determinístico (AFD) A:
A = ( K, Σ, δ, q1, F )
Κ={q1,q2,q3}
Σ={a,b}
F={q2,q3}
δ:
δ(q1,a)=q2
δ(q1,b)=q3
δ(q2,a)=q3
δ(q2,b)=q1
δ(q3,a)=q1
δ(q3,b)=q3
Esta es la apariencia de un AFD descrito formalmente. Fíjese que –respecto al capítulo

anterior- Σ es parecido a T y que así como S debe estar en la cuádrupla que define a una
gramática -y en N-, también q1 debe estar en K y en la quíntupla que define al AFD A.
Así como a los elementos de P se les llama producciones en una gramática, a los elementos de
δ se les llama reglas de transición.
Nuestro ejemplo tiene 6 reglas de transición, la penúltima regla de transición es δ(q3,a)=q1
33
Función total y determinismo
Sea δ(qi,a)=qj una regla de transición genérica.
qi se denomina estado de partida de la regla de transición.
qj se denomina estado de llegada de la regla de transición.
¿Cuántas reglas de transición debe tener A? Esta es una pregunta importante en AFD’s.
La definición formal de δ indica que esta es una función total, entonces, cuando ya tenemos
definido qué es K, qué es Σ y cuántos elementos tienen, es obligatorio colocar |K| * |Σ| reglas
de transición. |K| denota el número de estados, |Σ| denota el número de símbolos del alfabeto
de entrada, y * denota la multiplicación usual.
En el ejemplo 1 tenemos 3 estados y 2 símbolos en el alfabeto de entrada luego deben existir 6
reglas de transición.
Como δ es una función total y su dominio es (K X Σ), entonces debe haber una regla de
transición y solo una para todos y cada uno de los pares del tipo (qi,ak). Cuál estado de
llegada depende del lenguaje que estemos considerando, dejaremos de lado ello por ahora,
basta que sea un elemento de K.
Otros ejemplos:
A = ( K, Σ, δ, q1, F )
Κ={q1,q2}
Σ={a,b}
F={q1}
δ: tenemos |K|=2 y |Σ|=2 luego deben haber 4 reglas de transición
δ(q1,a)=q2
δ(q1,b)=q2
δ(q2,a)=q1
δ(q2,b)=q1

A = ( K, Σ, δ, q1, F )
Κ={q1}
Σ={a,b}
F={ }
δ:
δ(q1,a)=q1
δ(q1,b)=q1
Fíjese que F es vacío, todo está correcto, nuestra definición de AFD permite esto.
El siguiente es un Autómata Finito Determinístico (AFD):
34
A = ( K, Σ, δ, q1, F )
Κ={q1,q2}
Σ={1}
F={q1}
δ:
δ(q1,1)=q2
δ(q2,1)=q1
Como con T, convendremos que Σ generalmente constará de letras minúsculas y/o dígitos.
Errores comunes
Sea A = ( K, Σ, δ, q1, F )
Κ={q1,q2}
Σ={a,b}
F={q1}
δ: tenemos |K|=2 y |Σ|=2 luego deben haber 4 reglas de transición
Fíjese que la siguiente función de transición δ es mala:
δ(q1,a)=q2
δ(q1,a)=q1
δ(q2,a)=q3
δ(q2,b)=q1
Porque el par (q1,a) tiene dos reglas -no es función, no respeta eso de una y sólo una regla de
transición; además el par (q1,b) no tiene una regla de transición asociada, no tiene estado de
llegada, no respeta eso de que haya una regla para todos y cada uno de los pares; finalmente
q3 no es un estado en K.
También sería erróneo escribir este conjunto δ, dados los conjuntos K y Σ de arriba:
δ(q1,a)=q2
δ(q1,b)=q1
δ(q2,b)=q2
El par (q2,a) no tiene una regla asociada.
Resumiendo una función de transición δ lícita es aquella en la que hay una y solo una regla de
transición por cada par (qi,ak) y una regla de transición para todos los pares, esto quiere decir
que δ sea total.
Otras formas de representación de los AFD’s

Los AFD’s se representan de varias maneras: listar cada uno de los elementos de la quíntupla
como en los ejemplos anteriores es un modo habitual.
También se usan tablas de dos entradas para describir la función δ
35
Así por ejemplo el AFD A = ( {q1,q2}, {a,b}, δ, q1, {q1} )
δ: δ(q1,a)=q2 δ(q1,b)=q2 δ(q2,a)=q1 δ(q2,b)=q1
Se representará así: A = ({q1,q2}, {a,b}, δ, q1, {q1} )

δ: a b
q1 q 2 q 2
q2 q 1 q 1
Una representación más popular y más estética apela a los grafos, dibujando lo que se llama
la red o diagrama de transiciones o de estados.
Dicha gráfica puede ayudar a visualizar mejor un AFD –tanto él mismo como su
funcionamiento- y por eso es una herramienta importante, sin embargo, no es obligatorio
graficar un AFD.
Como dijimos básicamente se trata de pintar un grafo donde los nodos son los estados y las
etiquetas son los símbolos de Σ.
A cada estado de un AFD le corresponde un círculo simple. Si el estado en cuestión es además
un estado final entonces le corresponde un círculo doble. El estado inicial se identifica
fácilmente pues es el estado q1 (otros lo señalan con una flecha cortita).
Si tenemos la regla de transición δ(qi,ak)=qj entonces dibujamos un arco con etiqueta ak desde
el nodo qi hasta el nodo qj
El ejemplo que estamos siguiendo se ve así:
Nótese que –salvo excepciones que veremos luego- basta el diagrama de transición para
deducir F (los círculos dobles), K (todos los nodos), Σ (las etiquetas de los arcos) y las
transiciones (el sentido de los arcos), es decir, que podemos presentar un AFD A mostrando
sólo su gráfica.
Mostraremos otros dos ejemplos con estas tres representaciones.
Ejemplos:
Sea el AFD A = ( {q1,q2}, {1}, δ, q1, {q1} )
i) δ: δ(q1,1)=q2 δ(q2,1)=q1
36
ii)
δ: 1
q1 q2
q2 q1
iii)
Sea el AFD A = ( {q1}, {a,b}, δ, q1, { } )

i) δ: δ(q1,a)=q1 δ(q1,b)=q1
ii)
δ: a b
q1 q 1 q 1
iii)
Al dibujar el diagrama de transición, en casos como este, es decir, más de un arco yendo de un
mismo nodo de partida a un mismo nodo de llegada, es usual utilizar un solo arco y poner
todas las etiquetas que correspondan separadas por una barra (o por comas o por algún otro
separador). Luego es más usual este tipo de diagrama (como ya vimos en el primer ejemplo):
37
AFD’s: mecanismo de funcionamiento
Así como en una gramática se tiene la idea de derivación de cadenas usando producciones
para cada paso de derivación, en un AFD se tiene la idea de transiciones usando reglas de
transición para cada movimiento:
En una gramática En un AFD

se tiene la idea de Derivaciones Transiciones
y se usan Producciones Reglas de transición
para dar pasos de derivación Movimientos
Una gramática regular genera cadenas, en cambio un AFD acepta o reconoce cadenas. Para
describir cuál el mecanismo de funcionamiento para este reconocimiento necesitamos algunos
conceptos previos.
Descripciones instantáneas en AFD’s

Una descripción instantánea en un AFD -que se abrevia d.i.- es un par ordenado donde el
primer elemento es un estado del AFD y el segundo elemento es una cadena, por ejemplo
(q2,abba).
Movimiento(s) en un AFD
Así como usábamos => para denotar un paso de derivación usaremos |-- para denotar un
movimiento en un AFD.
Con un movimiento pasamos de una d.i. a otra d.i.
Ejemplo:
Si tenemos la regla de transición δ(q1,b)=q2
podemos dar el siguiente movimiento (q1,bab) |-- (q2,ab)
Es importante fijarse que el movimiento se puede dar sólo si:

a) el primer símbolo de la cadena en la d.i. actual (en negrita) es igual al símbolo de la regla
de transición que queremos usar (en nuestro ejemplo b).
b) el estado en la d.i. actual (en negrita) es igual al estado de partida de la regla de
transición que queremos usar (en nuestro ejemplo q1).
Luego de un movimiento la d.i. actual cambia a otra d.i. (en nuestro ejemplo (q2,ab) ) que se
obtiene así:
a) el estado de esta nueva d.i. es el estado de llegada de la regla de transición que hemos
usado.
b) la cadena de esta nueva d.i. es semejante a la cadena de la d.i. actual (en negrita) excepto
su primer símbolo que se omite.
38
Cuando el AFD da un movimiento diremos que ha leído o consumido un símbolo de la cadena
de entrada.
Formalmente (qi,bu) |-- (qj,u) sólo si δ(qi,b)=qj está en δ (donde b ∈ Σ, u ∈ Σ∗)
Otros ejemplos:
Si tenemos la regla de transición δ(q1,b)=q2
podemos dar el siguiente movimiento (q1,bb) |-- (q2,b)
Si tenemos la regla de transición δ(q2,a)=q2

podemos dar el siguiente movimiento (q2,aaaba) |-- (q2,aaba)
Si tenemos la regla de transición δ(q3,1)=q1

podemos dar el siguiente movimiento (q3,1111) |-- (q1,111)
Si tenemos la regla de transición δ(q1,a)=q1

podemos dar el siguiente movimiento (q1,aba) |-- (q1,ba)
Transiciones = muchos movimientos

Así como resumimos muchos pasos de derivación con =>* también podemos resumir muchos
movimientos con |--*, en realidad |-- es una relación entre descripciones instantáneas y |--* es
su clausura reflexiva transitiva.
Teóricamente un AFD puede empezar su trabajo con cualquier descripción instantánea
(cualquier estado en K, cualquier cadena en Σ∗).
Así, trabajando con el AFD A = ( {q1,q2}, {a,b}, δ, q1, {q1} )
δ:
δ(q1,a)=q2
δ(q1,b)=q2
δ(q2,a)=q1
δ(q2,b)=q1
Un ejemplo de muchos movimientos (un ejemplo de transiciones) es:

(q2,bbab) |-- (q1,bab) por la cuarta regla de transición
|-- (q2,ab) por la segunda regla de transición
|-- (q1,b) por la tercera regla de transición
Resumiendo (q2,bbab) |--* (q1,b)
39
Otro ejemplo de muchos movimientos:
(q2,aaa) |-- (q1,aa) por la tercera regla de transición
|-- (q2,a) por la primera regla de transición
|-- (q1,λ) por la tercera regla de transición
Resumiendo (q2,aaa) |--* (q1,λ)
Nótese que cuando ya no quedan símbolos que leer o cunsumir en la cadena de entrada, ese
hecho se denota por λ y el AFD ya no puede dar más movimientos.
T(A): lenguaje aceptado por un AFD

Aunque en teoría una serie de movimientos puede empezar en cualquier estado y detenerse en
cualquier momento, para decidir si una cadena cualquiera es aceptada o no por el AFD es
necesario:
i) empezar el trabajo del AFD –con dicha cadena- en el estado inicial
ii) analizar y consumir todos los símbolos de la cadena de entrada
Si i) y ii) se cumplen, finalmente debe observarse en qué estado quedamos (cuál es el estado
de la última d.i.), si es un estado final se dice que la cadena de entrada es aceptada por el
AFD, en otro caso se dice que no es aceptada (o lo que es lo mismo, que es rechazada).
Formalmente una cadena u es aceptada por el AFD si y solo si (q1,u) |--* (qi,λ) y qi ∈ F
Ejemplos:
Con el mismo AFD de arriba:
(q1,aa) |-- (q2,a) por la primera regla de transición
|-- (q1,λ) por la tercera regla de transición
Es decir, (q1,aa) |--* (q1,λ) , y como q1 es un estado final concluimos que u=aa es aceptada por
el AFD.
(q1,abb) |-- (q2,bb) por la primera regla de transición

|-- (q1,b) por la cuarta regla de transición
|-- (q2,λ) por la segunda regla de transición
Es decir, (q1,abb) |--* (q2,λ) , y como q2 no es un estado final concluimos que u=abb es
rechazada por el AFD.
Mucha gente opina que con una cadena cualquiera (y el estado q1 o cualquier otro estado) es
muy fácil ir consumiendo la cadena de entrada siguiendo con el dedo el diagrama de
transiciones (la gráfica) y ver en qué estado se acaba. Es ilustrativo hacerlo.
El lenguaje aceptado por un AFD lo denotaremos por T(A) y se define así:

T(A)={todas las cadenas que son aceptadas por el AFD} o más formalmente
T(A)={ u ∈ Σ∗ / (q1,u) |--* (qi,λ) y qi ∈ F}
T(A) también es denominado Conjunto Regular.
40
Así, un conjunto regular es un conjunto de cadenas (un lenguaje) que es aceptado por un
autómata finito.
Sólo falta indicar un caso especial: ¿ qué pasa si la cadena de entrada es la cadena vacía λ ?
En este caso el AFD no puede ir más allá de su d.i. inicial pero está permitido anotar lo
siguiente: (q1,λ) |--* (q1,λ), por la reflexividad de |--*. Efectivamente el AFD termina en la d.i.
en la que ha empezado (¡ya está ahí!), de manera que si el estado inicial es un estado final
entonces se dice que la cadena vacía es aceptada por el AFD (a diferencia de las gramáticas
regulares que no pueden generar λ).
Regla práctica: cuando q1 ∈ F λ ∈ Τ(Α)
La función δ*: otra notación frecuente

Otra notación muy popular -y muy útil para asuntos teóricos- que se usa para indicar cuál es el
último estado al que llega un AFD después de consumir toda la cadena de entrada partiendo
de un estado cualquiera es así:
δ*(qi,u)=qj
Para indicar que partiendo del estado qi y consumiendo toda la cadena u se llega
-finalmente- al estado qj.
Ejemplos:
Se puede escribir (q2,aaa) |--* (q1,λ) y/o también δ*(q2,aaa)=q1
Se puede escribir (q1,aa) |--* (q1,λ) y/o también δ*(q1,aa)=q1
Se puede escribir (q1,abb) |--* (q2,λ) y/o también δ*(q1,abb)=q2
En realidad δ* es una función, δ*: K X Σ*---> K, cuya definición recursiva es

δ*(qi,λ) = qi
δ*(qi,ua) = δ(δ*(qi,u),a)
Ejemplos de uso:
Para el AFD A cuyo diagrama es el siguiente:
41
i) Es claro de la definición que: δ*(q1,λ) = q1
ii) δ*(q1,b) = δ(δ*(q1,λ),b) por definición tomando u = λ

= δ(q1,b) por i)
= q2 por la función de transición δ para este ejemplo
iii) δ*(q1,ba) = δ(δ*(q1,b),a) por definición, u = b

= δ(q2,a) por ii)
= q3 por δ
iv) δ*(q1,bab) = δ(δ*(q1,ba),b) por definición, u = ba

= δ(q3,b) por iii)
= q2 por δ
v) δ*(q1,baba) = δ(δ*(q1,bab),a) por definición, u = bab

= δ(q2,a) por iv)
= q3 por δ
Cuando se requiere el valor de δ*(q1,baba) debe calcularse v) y para eso será necesario
calcular iv), etc.
δ* ofrece una forma más elegante de definir un Conjunto Regular así:

T(A)={ u ∈ Σ∗ / δ* (q1,u)=qi y qi ∈ F }={ u ∈ Σ∗ / δ* (q1,u)∈F }
A semejanza de lo que sucede con gramáticas existen dos problemas básicos: dado un AFD A
decir qué es T(A); y dado un lenguaje L construir un AFD que acepte dicho lenguaje.
Presentaremos algunos ejemplos sobre ambos aspectos.
Ejemplos:
Para el AFD A = ( {q1,q2}, {1}, δ, q1, {q1} )
δ: δ(q1,1)=q2 δ(q2,1)=q1
T(A)={12i / i ≥ 0}, o bien -lo que es lo mismo- T(A)={ (11)i / i ≥ 0}
Para el AFD A = ( {q1}, {a,b}, δ, q1, { } )

δ: δ(q1,a)=q1 δ(q1,b)=q1
T(A)={ }
Sea cual fuere la cadena u ∈ Σ∗ con la que trabajemos ninguna de ellas llegará a un estado
final porque no hay estados finales ( F={ } ).
Para el AFD A = ( {q1,q2}, {a,b}, δ, q1, {q1} )

T(A)={ u ∈ {a,b}∗ / |u| =2i i ≥ 0}
42
Se solicita construir un AFD A que acepte L={a,b}∗
Una solución es A = ( {q1}, {a,b}, δ, q1, {q1} )
δ: δ(q1,a)=q1 δ(q1,b)=q1
Se solicita construir un AFD A que acepte L={a,b}+

Una solución es A = ( {q1,q2}, {a,b}, δ, q1, {q2} )
De manera análoga a lo que sucede con las gramáticas regulares, el número de símbolos y de
estados en un AFD y de éstos cuáles deben/pueden ser finales, depende del lenguaje que
estemos considerando.
Mostraremos ahora dos importantes resultados teóricos para AFD’s que requieren el siguiente
resultado previo.
Sea A un AFD, entonces δ*(δ*(qi,u),v)=δ*(qi,uv)
Demostración:
Por inducción sobre |v|
Caso base:
|v|=0, es decir, v=λ
δ *(δ*(qi,u),v)=δ*(δ*(qi,u),λ) pues v=λ
=δ*(qi,u) por definición de δ* caso λ, recuerde que δ*(qi,u) es un estado
=δ*(qi,uv) pues v=λ y u=uλ
Supondremos válido el enunciado para cadenas de longitud |w|=k
Paso inductivo:
Sea v una cadena tal que |v|=k+1, entonces lícitamente podemos reescribirla así v=wa con
|w|=k. Por claridad, recordemos que δ*(qi,u) es un estado digamos p, es decir, sea δ*(qi,u)=p.
δ *(δ*(qi,u),v)=δ*(p,v) trabajando con δ*(qi,u)=p
*
=δ (p,wa) pues v=wa
*
=δ(δ (p,w),a) por definición de δ*
=δ(δ*(δ*(qi,u),w),a) trabajando con δ*(qi,u)=p
*
=δ(δ (qi,uw),a) por hipótesis inductiva pues |w|=k
*
=δ (qi,uwa) por definición de δ*
=δ*(qi,uv) pues v=wa
Lo que demuestra el enunciado.
El lema de bombeo
Se basa en la observación de que en un grafo de transición con n nodos, cualquier camino de
longitud n o mayor debe tener un nodo repetido, es decir, dicho camino contiene un ciclo, su
enunciado es como sigue:
43
Si L=T(A) y u ∈ T(A) -A un AFD con |K|=n y |u| ≥ n-, entonces
a) u = xyz (puede reescribirse o dividirse u en tres subcadenas)
b) |xy| ≤ n
c) y ≠ λ (la subcadena y no es vacía)
d) ∀ i≥0 xyiz ∈ T(A)
Demostración:
Sabemos que si se presenta u como entrada al AFD, u=a1a2...am con m ≥ n, este termina en un
estado final. Graficaremos la lista de estados que visita el AFD al consumir u empezando en
el estado inicial así:
Esta gráfica no es el diagrama de transición del AFD sino un dibujo de los estados por los que
vamos transitando al consumir la cadena u, para hacer notar la diferencia más aún hemos
dibujado los estados en cuadrados en vez de círculos.
Por ejemplo para el AFD A=({q1,q2},{b},δ,q1,{q2}) con δ: δ(q1,b)=q2 δ(q2,b)=q1 con la
cadena u=bbbbb la lista de estados que visita el AFD -incluyendo el estado inicial- al
consumir u es q1,q2,q1,q2,q1,q2, gráficamente ello se ve así:
Donde se evidencia que por lo menos un estado se visita más de una vez -cuando menos dos
veces- adicionalmente nótese que con 5 símbolos se visitan 6 estados.
Volviendo al caso general, dado que u consiste de por lo menos n símbolos podemos
reescribir esta cadena así u=a1a2...anan+1...am con m ≥ n, o lo que es lo mismo u=a1a2...anz con z
la subcadena final; al transitar -desde el estado inicial- a través de los estados del AFD
consumiendo los símbolos de u (los primeros n símbolos y luego los símbolos de z) la lista de
estados que visita el AFD tendrá por lo menos n+1 estados. Sabiendo esto se deduce que no
es posible que en esta lista de estados que se visita todos estos estados sean distintos, puesto
que sólo existen n estados diferentes. Luego debe existir por lo menos un estado que se visita
más de una vez.
Visto de otro modo -en la gráfica de la lista de estados que se visita – por lo menos algún j es
necesariamente igual a algún k, este hecho suele mostrarse así evidenciando el ciclo:
44
Es decir, con la cadena u la lista de estados que se visita es q1,qi1,qi2,...,qr,...,qr,...qf, donde el
estado que se repite es qr (que es igual a qj y a qk)
Podemos escribir esto así:
δ∗(q1,x)=qr donde x contiene los primeros símbolos de u que me permiten llegar a qr
δ∗(qr,y)=qr donde y contiene los siguientes símbolos de u que me permiten revisitar qr
δ∗(qr,z)=qf donde z contiene los últimos símbolos de u con los que llegamos a qf
y≠λ pues hemos admitido que hay por lo menos un estado que se visita por lo menos dos
veces, con y=λ no habría tal re-visita.
Nótese que la subcadena y está en un ciclo que puede repetirse 0, 1, 2 o más veces con la
propiedad siguiente δ∗(qr,yi)=qr; de este modo si luego de la subcadena x, y luego de una o
más y’s está la subcadena z, toda la cadena resultante sigue llegando finalmente a qf, es decir,
las cadenas del tipo xyiz ∈ T(A) para todo i ≥ 0.
Ya vimos que u puede reescribirse así u=a1a2...anz, y que a1a2...an puede agruparse en dos
subcadenas xy; es decir, efectivamente u puede reescribirse así u=xyz. Sin embargo, la parte
vital del lema es que por lo menos un estado se visite cuando menos dos veces, ello sucede
inevitablemente si xy=a1a2...an pues –como se argumentó- con n símbolos se visitan n+1
estados. Es claro que esta vital revista puede suceder con menos símbolos aún como lo
muestra el siguiente ejemplo: sea A=({q1,q2,q3,q4,q5},{a,b},δ,q1,{q1}) n=|K|=5
δ: δ(q1,a)=q1 δ(q1,b)=q2 δ(q5,a)=δ(q5,b)=q1 δ(qj,a)=δ(qj,b)=qj+1 j=2,3,4
Sea u=aaaaaa, la lista de estados que se visita es: q1,q1,q1,q1,q1,q1,q1 donde la revisita es
evidente. Aquí x=a, y=a, z=aaaa lo que es válido, nótese que |xy|=2<5; pero también puede ser
x=aa, y=a, z=aaa lo que es igualmente válido, nótese que |xy|=3<5; o bien x=λ, y=aaa, z=aaa
lo que es igualmente válido, nótese que |xy|=3<5. En todos estos casos |xy|≤n, es decir, u
puede reescribirse así u=xyz con |xy|≤n.
El teorema de Myhill-Nerode
Veamos algunos elementos previos.
Una relación R sobre Σ∗ se dice que es invariante por derecha con respecto a la concatenación
si ∀ z∈Σ∗: xRy => xzRyz
Sea L un lenguaje, es decir, L⊆Σ*.
Y sea RL la siguiente relación definida sobre Σ∗ e inducida por L: ∀ x,y∈Σ∗
xRLy si y sólo si ∀ w∈Σ∗ xw ∈ L Ù yw ∈ L
Es evidente que RL es una relación de equivalencia puesto que
a) ∀ w∈Σ∗ xw ∈ L Ù xw ∈ L, es decir xRLx, es decir es reflexiva
b) ∀ w∈Σ∗ xw ∈ L Ù yw ∈ L => ∀ w∈Σ∗ yw ∈ L Ù xw ∈ L
es decir xRLy => yRLx, es decir es simétrica
c) ∀ w∈Σ∗ xw ∈ L Ù yw ∈ L y ∀ w∈Σ∗ yw ∈ L Ù zw ∈ L
=> ∀ w∈Σ∗ xw ∈ L Ù zw ∈ L, es decir [xRLy ∧ yRLz] => xRLz, es decir es transitiva
Por lo tanto el conjunto formado por las clases de equivalencia de RL es una partición de Σ∗.
La relación RL es además invariante por la derecha. En efecto, sea que xRLy, es decir,
∀ v∈Σ∗ xv ∈ L Ù yv ∈ L; debemos mostrar que ∀ z∈Σ∗ xzRLyz, es decir, que
45
∀ z,w∈Σ∗ xzw ∈ L Ù yzw ∈ L; hagamos v=zw, luego debemos mostrar que
∀ z,w∈Σ∗ (v=zw) xv ∈ L Ù yv ∈ L, pero eso es precisamente lo que significa xRLy.
El teorema dice que los tres enunciados siguientes son equivalentes:
1) L=T(A), donde A es un AFD
2) L es la unión de algunas clases de equivalencia de alguna relación de equivalencia R
definida sobre Σ∗, invariante por derecha y de índice finito.
3) RL es de índice finito.
Demostración:
i) Sea A un AFD tal que T(A)=L, entonces vamos a mostrar que hay una relación de
equivalencia definida sobre Σ∗, invariante por derecha y de índice finito.
Definamos pues la relación a la que llamaremos RA:
xRAy si y sólo si δ∗(q1,x)=δ∗(q1,y)
Es evidente que RA es de equivalencia pues:
a) δ∗(q1,x)=δ∗(q1,x), es decir RA es reflexiva
b) δ∗(q1,x)=δ∗(q1,y) => δ∗(q1,y)=δ∗(q1,x), es decir RA es simétrica
c) [δ∗(q1,x)=δ∗(q1,y) ∧ δ∗(q1,y)=δ∗(q1,z)]=> δ∗(q1,x)=δ∗(q1,z), es decir RA es transitiva
También RA es invariante por derecha pues:
Si xRAy se sabe que δ∗(q1,x)=δ∗(q1,y).
Además ∀ z∈Σ∗ δ∗(q1,xz)=δ*(δ*(q1,x),z) por un resultado previo
=δ*(δ*(q1,y),z) pues δ∗(q1,x)=δ∗(q1,y)
=δ∗(q1,yz) por el resultado previo
Es decir, ∀ z∈Σ∗ δ∗(q1,xz)=δ∗(q1,yz), que no es otra cosa que decir que xzRAyz
Asimismo RA es de índice finito:
¿Cuántas clases tiene el conjunto de clases de equivalencia de RA?
Que xRAy nos dice simplemente que con la cadena x y con la cadena y el AFD termina en el
mismo estado. Dada una cadena x en Σ∗ supongamos que al consumirla el AFD partiendo de
q1 acaba en q1, la clase [x] está formada por todas las cadenas con las que el AFD -partiendo
de q1- llega finalmente a q1; habrá –posiblemente- otra clase [w] con todas las cadenas con las
que el AFD -partiendo de q1- llega finalmente a, digamos, q2; etc. Así tendremos –a lo más-
tantas clases como estados tenga el AFD, es decir, un número finito de clases, es decir, RA es
de índice finito.
Finalmente queda por mostrar que L es la unión de algunas clases de RA:
Es evidente que L es la unión de las clases de RA que han sido formadas de manera tal que sus
cadenas llegan a los estados finales del AFD.
ii) Sea L la unión de algunas clases de alguna relación de equivalencia R definida sobre Σ∗,
invariante por derecha y de índice finito, entonces vamos a mostrar que RL también es de
índice finito.
En efecto, sean x,y∈Σ∗ tales que
46
xRy, es decir, (x,y)∈R, es decir, x e y están relacionadas y están en la misma clase de
equivalencia digamos [x]R, pero entonces
∀ z∈Σ∗ xzRyz pues R es invariante por derecha, además
∀ z∈Σ∗ xz∈L si y sólo si yz∈L pues L es la unión de algunas clases de R, es decir,
si (xz,yz)∈R, o lo que es lo mismo, si están en la
misma clase y dicha clase aporta a conformar L,
ambas cadenas xz y yz están en L, en otro caso no;
pero entonces
xRLy pues la expresión xz∈L si y sólo si yz∈L, no es sino la definición de RL, es
decir, (x,y)∈RL, es decir, x y y están relacionados por RL y están en la misma clase
de equivalencia digamos [x]RL.
Así, hemos mostrado –tomando de a dos los elementos- que si hay cadenas que están en una
misma clase en R, esas cadenas también están en una misma clase en RL, es decir, [x]R⊆[x]RL,
otra manera de decirlo es que cada clase de equivalencia de R está contenida en alguna de RL
(en estos casos se dice que R refina a RL), es claro a partir de ello que R tiene más clases –o las
mismas- que RL, es decir, R tiene un índice mayor o igual que el índice de RL y como el índice
de R es finito, RL también tiene un índice finito.
iii) Sea RL -de índice finito-, entonces vamos a mostrar que hay un AFD A tal que T(A)=L
En efecto, construimos así el AFD A=(K,Σ,δ,q1,F)
K es el conjunto de clases de equivalencia de RL
K={[x]RL / x∈Σ∗}
q1=[λ]RL el estado inicial es la clase de equivalencia de (que incluye a) la cadena vacía
F={[x]RL / x∈L}
δ: δ([x]RL,a)=[xa]RL
Sólo resta mostrar dos cosas: a) que tanto el conjunto de estados como la regla de transición
son consistentes, es decir, que están acordes a la definición de un AFD y no traen problemas;
y b) que este AFD acepta L.
a) K es finito pues RL es de índice finito.
En la clase de equivalencia de la cadena x, [x]RL, hay posiblemente otras cadenas por ejemplo
y, dado que están en la misma clase xRLy, y también [x]RL=[y]RL. Según nuestra regla de
transición δ([y]RL,a)=[ya]RL, sería inconsistente que [xa]RL≠[ya]RL, afortunadamente eso no
sucede [xa]RL=[ya]RL, pues RL es invariante por la derecha, es decir, ∀ z∈Σ∗ por ejemplo z=a,
si xRLy entonces xaRLya, es decir, xa y ya están en la misma clase de equivalencia, es decir,
[xa]RL=[ya]RL.
b) Utilizaremos el hecho de que δ∗(q1,x)=[x]RL
En efecto cuando x=λ tenemos que δ∗(q1,x)=δ∗(q1,λ)=q1=[λ]RL=[x]RL
Y cuando x=ya tenemos que δ∗(q1,x)= δ∗(q1,ya)=δ(δ∗(q1,y),a)=δ([y]RL,a)=[ya]RL=[x]RL
Finalmente, x∈T(A) si y sólo si δ∗(q1,x)∈F si y sólo si [x]RL∈F si y sólo si x∈L, es decir el
AFD acepta L.
47
AUTÓMATAS FINITOS NO DETERMINÍSTICOS (AFN’S)
Un Autómata Finito No determinístico (AFN) es una quíntupla A = ( K, Σ, d, q1, F ) donde
K: conjunto finito, no vacío, de estados
Σ: alfabeto de entrada
d: función de transición (se define así d: K X Σ ---> 2K, 2K denota el conjunto potencia de K)
q1: estado inicial del AFN q1 ∈ K (es decir, q1 debe estar en K)
F: conjunto de estados finales F ⊆ K
Ejemplo:
Sea el Autómata Finito No Determinístico (AFN) A = ( K, Σ, d, q1, F )
Κ={q1,q2}
Σ={a,b}
F={q2}
d:
d(q1,a)={q1,q2}
d(q2,b)={q2}
Esta es la apariencia de un AFN descrito formalmente y en diagrama.
Hay varias semejanzas entre los AFD’s y los AFN’s: el uso de diagramas de transición, el uso
de descripciones instantáneas, la aceptación o rechazo de cadenas, para mencionar algunas.
Pero tienen también importantes diferencias, veamos las principales:
En los AFD’s: de un par (estado, símbolo) se llega a un estado (escrito suelto, sin llaves)
En los AFN’s de un par (estado, símbolo) se llega a un conjunto de estados (obviamente
escrito entre llaves).
En los AFD’s al estar situados en un estado y al consumir un símbolo de una cadena de

entrada el siguiente estado está determinado irremediablemente (por eso se llaman
Determinísticos).
En los AFN’s al estar situados en un estado y al consumir un símbolo de una cadena de
entrada -a veces- se puede ir a uno u otro (u otro, etc.) estado, según como esté definida la
regla de transición. En el ejemplo de arriba estando en q1 y consumiendo el símbolo a,
podemos pasar ya sea al propio q1 o a q2.
48
Una forma que adoptamos para diferenciar AFD’s de AFN’s es utilizar d para la función de
transición en AFN’s y δ en AFD’s.
El conjunto de estados de llegada ( por ejemplo {q1,q2} en la regla de transición

d(q1,a)={q1,q2} ) es por definición precisamente un conjunto (formalmente un elemento del
conjunto de partes de K), y por lo tanto puede ser vacío, unitario, de dos elementos, tres,
cuatro o todo K.
En estricto rigor d también es total, pero cuando el conjunto de estados de llegada es vacío
simplemente ni lo graficamos ni lo listamos.
Ejemplo (para el AFN de arriba):

d:
d(q1,a)={q1,q2}
d(q1,b)={ }
d(q2,a)={ }
d(q2,b)={q2}
En adelante preferimos -por convención- no anotar las reglas donde el
conjunto de estados de llegada es vacío.
No determinismo, aceptación de una cadena y T(A) en un AFN

En un AFD dada una d.i. la siguiente d.i. –si existe- luego de dar un movimiento lícito es
única y bien determinada.
En cambio en un AFN dada una d.i. –si es posible dar un movimiento lícito- es probable que
exista no una sino varias d.i.’s siguientes de acuerdo al no determinismo implícito en las
reglas de transición.
Ejemplos:
En el AFN de arriba para la d.i. (q2,bb) el único movimiento que puede darse utilizará la regla
de transición d(q2,b)={q2}, luego de lo cual la siguiente d.i. será (q2,b) hecho que hemos
estado representado así: (q2,bb) |-- (q2,b).
En cambio para la d.i. (q1,aa) el AFN puede dar cualquiera de los siguientes dos movimientos
lícitos utilizando la regla de transición d(q1,a)={q1,q2}
i) (q1,aa) |-- (q1,a)
ii) (q1,aa) |-- (q2,a)
Puede ser útil representar estas varias alternativas a través de un árbol de transiciones que para
nuestro ejemplo sería así:
|-- (q1,a)
/
(q1,aa)
\
|-- (q2,a)
49
Representaremos –a través de estos árboles de transiciones- un caso más largo, con el mismo
AFN, partiendo de la misma d.i. (q1,aa)
|--1 (q1,λ)
/
|--1 (q1,a)
/ \
(q1,aa) |--2 (q2,λ)
\
|--2 (q2,a)
Donde hemos anotado con un subíndice el número de regla de transición que se utiliza para
dar un movimiento lícito. Este árbol muestra que todas las siguientes transiciones son
legítimas:
a) (q1,aa) |--* (q1,λ)
b) (q1,aa) |--* (q2,λ)
c) (q1,aa) |--* (q2,a)
El inciso b) muestra que partiendo del estado inicial con la cadena aa podemos llegar a un d.i.
que evidencia que se ha consumido toda la cadena y que se ha arribado a un estado final, q2
en nuestro caso. Es decir, la cadena aa es aceptada por el AFN.
Para descubrir esto no basta con hacer alguna serie de movimientos lícitos –por ejemplo sólo
los del inciso a)-, deben escudriñarse todas las posibilidades dibujando todo el árbol de
transiciones (cuando menos mentalmente).
También nótese, como muestra el inciso c), que dado un AFN siguiendo cierto camino del
árbol de transiciones el autómata ya no puede dar ningún movimiento, no puede ir a ningún
otro estado, ni consumir ningún símbolo más de la cadena. El caso extremo de esto es que un
AFN no pueda dar ni siquiera un movimiento, como sucede con nuestro AFN si partiera de la
d.i. (q1,bbb), en situaciones como esta lo único que podemos escribir es lo siguiente:
(q1,bbb) |--* (q1,bbb).
Una cadena de entrada es aceptada en un AFN si partiendo del estado inicial q1 es posible
llegar a un estado final con alguna serie de movimientos consumiendo toda la cadena. Fíjese
que para decidir si una cadena es aceptada o no debemos analizar todas, absolutamente todas
las transiciones posibles del árbol de transiciones.
Formalmente para un AFN A:

T(A)={ u ∈ Σ∗ / (q1,u) |--* (qi,λ) y qi ∈ F}
Sin embargo esta definición no enfatiza lo suficiente que en un AFN partiendo de un estado
con una cadena de entrada, consumiendo todos los símbolos de dicha cadena de entrada, es
posible llegar a
i) Ningún estado, simplemente porque no se pueden consumir todos los símbolos.
50
ii) Uno, dos o más estados, como en los incisos a) y b) del ejemplo que muestran que se puede
llegar ya sea al estado q1 o al estado q2.
Es decir, es posible llegar no a un estado como sucedía en los AFD’s sino a un conjunto de
estados, posiblemente vacío.
La función d*
Otra notación igual de popular y útil para asuntos teóricos, usada para indicar mejor que en un
AFN se puede llegar a un conjunto de estados, partiendo de un estado y con una cadena u de
entrada es así:
d*(qi,u)={conjunto de todos los estados a los que se puede llegar partiendo de qi
consumiendo todos los símbolos de u}
Ejemplos:
d*(q1,aa)={q1,q2}
d*(q1,bbb)={ }
En realidad d* es una función, d*: K X Σ*---> 2K, cuya definición recursiva es

d*(qi,λ) = {qi}
d*(qi,ua) = U
d(p,a)
p ∈ d *( q i ,u )
Ejemplos de uso (en el AFN de arriba):

i) d*(q1,λ) = {q1} por definición
ii) d*(q1,a) = U
d(p,a) por definición, u = λ
p ∈ d *( q1 ,λ )
= U
p ∈{q1}
d(p,a) por i)
= d(q1,a) desarrollando la unión

= {q1,q2} por la función d
iii) d*(q1,ab) = U d(p, b) por definición, u = a

p ∈ d *( q1 ,a )
= U
p ∈{q1 ,q 2 }
d(p, b) por ii)
= d(q1,b) ∪ d(q2,b) desarrollando la unión

= { } ∪ {q2} por la función d
= {q2} desarrollando la unión
d* ofrece una que forma más elegante de definir T(A) para un AFN
51
T(A)={ u ∈ Σ∗ / (d*(q1,u) ∩ F) ≠ ∅ }
Recuerde que en esta definición d*(q1,u) representa un conjunto de estados.
En el AFN que estamos tomando como ejemplo T(A)={ aibj / i ≥ 1, j ≥ 0 }
Más ejemplos de AFN’s y T(A):

Sea el AFN A = ({q1,q2}, {a,b}, d, q1, {q2} )
d:
d(q1,a)={q1,q2} T(A)={ua / u ∈{a,b}*}
d(q1,b)={q1}
Sea el AFN A = ({q1,q2,q3}, {a,b}, d, q1, {q3} )

d:
d(q1,a)={q2}
d(q2,b)={q3} T(A)={ab}
Como siempre los problemas básicos son dos: dado un AFN A indicar qué es T(A); y dado un
lenguaje L construir un AFN A que acepte L.
AUTÓMATAS FINITOS NO DETERMINÍSTICOS CON TRANSICIONES VACÍAS

(λ-AFN’S)
Un Autómata Finito No determinístico con transiciones vacías (o con lambda transiciones, o
con λ-transiciones) es una quíntupla A = ( K, Σ, d, q1, F ) donde
K: conjunto finito, no vacío, de estados
Σ: alfabeto de entrada
d: función de transición ( se define así d: K X (Σ ∪ {λ}) --> 2K )
q1: estado inicial del AFN q1 ∈ K (es decir, q1 debe estar en K)
F: conjunto de estados finales F ⊆ K
Ejemplo:
Sea el λ−AFN A = ( {q1,q2,q3}, {b,c}, d, q1, {q1,q2,q3})
52
d:
d(q1,λ)={q2,q3}
d(q2,b)={q2}
d(q3,c)={q3}
De este modo los λ-AFN’s son prácticamente lo mismo que los AFN’s sólo que permiten la
flexibilidad de incluir etiquetas λ en sus arcos -si queremos apoyarnos en los diagramas de
estado-, ó más concretamente, pueden haber reglas de transición del tipo d(q3,λ)={q3}, o
cualquier otro conjunto de llegada. En este caso λ no es un símbolo de Σ y la cadena de
entrada permanece tal cual cuando usamos estas λ-transiciones, es decir, no se consume
ningún símbolo al transitar por etiquetas λ.
Los otros formalismos y notaciones (d*, |--, etc.) se siguen usando y tienen significados
análogos.
λ-cierre
La inclusión de transiciones vacías, que en el caso de los diagramas se representa con
etiquetas λ, adiciona cierta complejidad a los cálculos. Por ejemplo si nos encontramos en el
estado qi y consumimos un símbolo ak, el conjunto de estados a los que podemos arribar debe
contemplar la posibilidad de ir de un estado a otro -y aún a otros- sin consumir símbolos, sólo
‘consumiendo’ la cadena λ, antes o después de consumir ak.
Así pues debemos poder calcular a qué otros estados se llega partiendo de un estado y
utilizando sólo λ-transiciones (‘consumiendo’ la cadena λ). En el λ-AFN de arriba por
ejemplo partiendo de q1 podemos llegar, utilizando sólo λ-transiciones sin consumir símbolos
de entrada, a q2 y a q3, y también debido a que ya estamos ahí podemos llegar al propio q1
‘consumiendo’ λ, denotaremos esto así:
λ-cierre({q1}) = {q1,q2,q3}
Que nos dice -repetimos- que estando en q1 podemos llegar, sin consumir símbolos de entrada,
a q1, a q2 y a q3; es importante enfatizar que de un estado cualquiera qi siempre es posible
llegar a sí mismo sin consumir símbolos de entrada simplemente porque ya estamos ahí (ya
‘hemos llegado’), por eso q1 pertenece al λ-cierre({q1})
Podemos extender esta idea para calcular el λ-cierre(C) donde C es un conjunto de estados:
53
λ-cierre({}) = {}
λ-cierre({q}) = { conjunto de todos los estados a los que podemos arribar, incluido q,
utilizando sólo λ-transiciones sin consumir símbolos de entrada partiendo
de q } Es decir,
λ-cierre({q}) = {q} ∪ { p / partiendo de q se arriba a p utilizando sólo λ-transiciones }
λ-cierre(C) = U λ-cierre({q})
q ∈C
Sea A un λ-AFN cuyo conjunto de estados es K; sea C⊆K. En rigor, la definición estándar del
λ-cierre(C) es recursiva y es como sigue:
i) ∀ q∈C: q∈λ-cierre(C)
ii) ∀ q∈λ-cierre(C) ∀ p∈d(q,λ): p∈λ-cierre(C)
iii) Son elementos del λ-cierre(C) sólo aquellos señalados en i y ii
Una manera más operacional de calcular el λ-cierre(C) es así:

λ-cierre(C) = Bn
donde
B0 = C
Bi+1 = Bi ∪ {p / qj ∈ Bi y p ∈ d(qj,λ)}
Si Bi+1 = Bi entonces Bn = Bi
Y aún una manera adicional de tipo matricial la tenemos a continuación.

Podemos construir una matriz de |K| X |K| representando la relación R ⊆ K X K que relaciona
el estado qi con el estado qj si existe una λ-transición explícita de qi a qj.
Donde cada fila y cada columna corresponde a un estado, un 0 indica que los estados no están
relacionados y un 1 que si.
Para el λ-AFN de arriba la matriz R será:
0 1 1
R = 0 0 0
0 0 0
R+, la clausura transitiva de R, relaciona los estados que son accesibles desde otro con sólo λ-
transiciones:
(qi,qj) ∈ R+ si desde qi puede arribarse a qj con sólo λ-transiciones.
Nótese que R+ no relaciona qi consigo mismo a no ser que haya una λ-transición explícita de
qi a qi. Sin embargo para el cálculo del λ-cierre(C) necesitamos incluir cada estado de C
aunque no hayan λ-transiciones explícitas de qi a qi, porque el λ-cierre(C) calcula los estados
que son alcanzables desde cualquier estado de C con la cadena λ, en cambio R+ relaciona los
estados que son alcanzables desde otro con λ-transiciones explícitas. Nosotros obtendremos el
λ-cierre(C) a partir de R+.
El cálculo de R+ se operacionaliza a través de matrices así:
54
R1 = R
Ri+1 = Ri + (Ri * Ri)
Si Ri+1 = Ri entonces R+ = Ri
donde + y * representan la suma boolena y producto booleano de matrices.
R* = R+ + IK donde + representa la suma boolena de matrices.
El λ-cierre(C) se obtiene así:
Para cada estado qi en C se observa la fila i-ésima de R* y se incluyen al λ-cierre(C) los
estados correspondientes a las columnas -de dicha fila- con un 1.
Ejemplos:
Mostraremos el cálculo del λ-cierre(C) tanto para el λ-AFN de arriba como para otro λ-AFN
que presentaremos luego.
En el caso del primer λ-AFN:
Se desea obtener el λ-cierre({q1})
De acuerdo a la primera forma tenemos:
B0 = {q1}
B1 = B0 ∪ {p / qj ∈ B0 y p ∈ d(qj,λ)}
= {q1} ∪ {p / qj ∈ {q1} y p ∈ d(qj,λ)}
= {q1} ∪ {p / p ∈ d(q1,λ)}
= {q1} ∪ {p / p ∈ {q2,q3}}
= {q1} ∪ {q2,q3} = {q1,q2,q3}
B2 = B1 ∪ {p / qj ∈ B1 y p ∈ d(qj,λ)}
= {q1,q2,q3} ∪ {p / qj ∈ {q1,q2,q3} y p ∈ d(qj,λ)}
= {q1,q2,q3} ∪ { p / p ∈ d(q1,λ)} ∪ { p / p ∈ d(q2,λ)} ∪ { p / p ∈ d(q3,λ)}
= {q1,q2,q3} ∪ {q2,q3} ∪ {} ∪ {} = {q1,q2,q3}
Como B2 = B1 entonces Bn = B1 y por lo tanto λ-cierre({q1}) = B1 Es decir
Por el modo matricial tenemos:

0 1 1
R = R = 0 0 0
1
0 0 0
R2 = R1 + (R1 * R1)
0 1 1 0 1 1 0 1 1 0 1 1 0 0 0 0 1 1
= 0 0 0 + ( 0 0 0 * 0 0 0 ) =
    0 0 0 + 0 0 0 = 0 0 0
     
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Como R2 = R1 entonces R+ = R1
55
0 1 1 1 0 0 1 1 1
R = R + IK = 0 0 0 + 0 1 0 = 0 1 0
* +    
0 0 0 0 0 1 0 0 1
El λ-cierre({q1}) = {q1,q2,q3}
Pues la fila 1 de R* tiene un 1 en las columnas 1, 2 y 3.
El cálculo de R* nos facilita otros cálculos, siguiendo el mismo procedimiento tenemos:
El λ-cierre({q2}) = {q2}
El λ-cierre({q2,q3}) = {q2,q3}
El segundo λ-AFN con el que trabajaremos tiene este diagrama:
Se desea obtener el λ-cierre({q2})

De acuerdo a la primera forma tenemos:
B0 = {q2}
B1 = B0 ∪ {p / qj ∈ B0 y p ∈ d(qj,λ)}
= {q2} ∪ {p / qj ∈ {q2} y p ∈ d(qj,λ)}
= {q2} ∪ {p / p ∈ d(q2,λ)}
= {q2} ∪ {p / p ∈ {q4}}
= {q2} ∪ {q4} = {q2,q4}
B2 = B1 ∪ {p / qj ∈ B1 y p ∈ d(qj,λ)}
= {q2,q4} ∪ {p / qj ∈ {q2,q4} y p ∈ d(qj,λ)}
= {q2,q4} ∪ { p / p ∈ d(q2,λ)} ∪ { p / p ∈ d(q4,λ)}
= {q2,q4} ∪ {q4} ∪ {q3} = {q2,q3,q4}
B3 = B2 ∪ {p / qj ∈ B2 y p ∈ d(qj,λ)}
= {q2,q3,q4} ∪ {p / qj ∈ {q2,q3,q4} y p ∈ d(qj,λ)}
= {q2,q3,q4} ∪ { p / p ∈ d(q2,λ)} ∪ { p / p ∈ d(q3,λ)} ∪ { p / p ∈ d(q4,λ)}
= {q2,q3,q4} ∪ {q4} ∪ {q3,q4} ∪ {q3} = {q2,q3,q4}
Como B3 = B2 entonces Bn = B2 y por lo tanto λ-cierre({q2}) = B2. Es decir,
56
Por el modo matricial tenemos:
0 0 0 0
0 0 0 1
R1 = R = 
0 0 1 1
 
0 0 1 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 
1  0 0 0 1 0 0 0 1
R2 = R1 + (R1 * R1) =  + ( *  )
0 0 1 1 0 0 1 1 0 0 1 1
     
0 0 1 0 0 0 1 0 0 0 1 0
0 00 00 0 0 0 0 0 0 0
0 0 
1 00 0 1 
0 0 0 1 1
=  +  =  
0 01 01 0 1 1 0 0 1 1
     
0 00 01 0 1 1 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0
0 0 1 
1 0 0 1 
1 0 0 1 1
R3 = R2 + (R2 * R2) =  + ( *  )
0 0 1 1 0 0 1 1 0 0 1 1
     
0 0 1 1 0 0 1 1 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0
0 0 1 
1 0 0 1 
1 0 0 1 1
=  +  = 
0 0 1 1 0 0 1 1 0 0 1 1
     
0 0 1 1 0 0 1 1 0 0 1 1
Como R3 = R2 entonces R+ = R2
0 0 0 0 1 0 0 0 1 0 0 0
0 0 1 
1 0 1 0 
0 0 1 1 1
R* = R+ + IK =  +  = 
0 0 1 1 0 0 1 0 0 0 1 1
     
0 0 1 1 0 0 0 1 0 0 1 1
El λ-cierre({q2}) = {q2,q3,q4}
Pues la fila 2 de R* tiene un 1 en las columnas 2, 3 y 4.
El cálculo de R* nos facilita otros cálculos, siguiendo el mismo procedimiento tenemos:
El λ-cierre({q3}) = {q3,q4}
El λ-cierre({q4}) = {q3,q4}
El λ-cierre({q3,q4}) = {q3,q4}
Quedan pendientes algunas cuestiones.
El algoritmo para calcular el λ-cierre(C) puede reescribirse equivalentemente así:
57
B0 = C
Bi+1 = Bi U d(q,λ)
q ∈ Bi
i=0,1,... (*)
Si Bi+1 = Bi entonces para todo n>0 Bi = Bi+n y λ-cierre(C) = Bi
Que este algoritmo sea finito es evidente: a partir de C pueden añadirse uno o más estados de
manera que algún Bi+1 sea K en el extremo, a partir de ahí Bi+2 y los siguientes deben ser
iguales al anterior pues ya no hay más estados que añadir.
Cuando Bi+1 = Bi, no es muy obvio que para todo n>0 Bi = Bi+n, y este resultado es el que
queremos probar a continuación.
Por inducción sobre n:
Caso base.
n=1
Si Bi+1 = Bi entonces Bi = Bi+1 es verdadero inmediatamente.
Hipótesis inductiva.
n=k
Si Bi+1 = Bi entonces Bi = Bi+k es cierto.
Paso inductivo.
n=k+1
Sea Bi+1 = Bi (**)
Luego,
Bi = Bi+1 por (**)
= Bi U
d(q,λ)
q ∈ Bi
por la forma de calcular cada Bi+1 en el cálculo del λ-cierre(C) (*)
= Bi+k U d(q,λ)
q ∈ Bi+k
por hipótesis inductiva
= Bi+k+1 por la forma de calcular cada Bi+1 en el cálculo del λ-cierre(C) (*)
Por los tres casos el enunciado que queríamos se mantiene.
La función d*
d*(qi,u)={conjunto de todos los estados a los que se puede llegar partiendo de qi
consumiendo todos los símbolos de u}
Nótese que ahora deben considerarse las λ-transiciones.
d* es una función, d*: K X Σ*---> 2K, cuya definición recursiva es
d*(qi,λ) = λ-cierre({qi})
 
d*(qi,ua) = λ-cierre  U d(p,a)
 p ∈ d*( q i ,u ) 
Ejemplos de uso:
En el caso del primer λ-AFN:
58
d*(q1,λ) = λ-cierre({q1}) = {q1,q2,q3}
   
d*(q1,b) = λ-cierre  U λd(p, b) = λ-cierre  U d(p, b)
 p ∈ d*( q1 , )   p ∈ {q1 ,q 2 ,q 3} 
= λ-cierre(d(q1,b) ∪ d(q2,b) ∪ d(q3,b)) = λ-cierre({} ∪ {q2} ∪ {}) = λ-cierre({q2})
= {q2}
   
d*(q1,bc) = λ-cierre  U d(p,c) = λ-cierre 
  U d(p,c) = λ-cierre(d(q2,c))

 p ∈ d*( q1 ,b)   p ∈ {q 2 } 
= λ-cierre({}) = {}
   
d*(q1,bcb) = λ-cierre  U d(p, b) = λ-cierre  U d(p, b) = λ-cierre({}) = {}
 
 p ∈ d*( q1 ,bc)   p ∈ {} 
Por otro lado:
   
d*(q1,c) = λ-cierre  U d(p,c) = λ-cierre 
  Ud(p,c)

 p ∈ d*( q1 ,λ )   p ∈ {q1 ,q 2 ,q 3} 
= λ-cierre(d(q1,c) ∪ d(q2,c) ∪ d(q3,c)) = λ-cierre({} ∪ { } ∪ {q3}) = λ-cierre({q3})
= {q3}
   
d*(q1,cc) = λ-cierre  U d(p,c) = λ-cierre 
  U d(p,c) = λ-cierre(d(q3,c))

 p ∈ d*( q1 ,c)   p ∈ {q 3} 
= λ-cierre({q3}) = {q3}
En el caso del segundo λ-AFN:

d*(q1,λ) = λ-cierre({q1}) = {q1}
   
d*(q1,a) = λ-cierre  U d(p,a) = λ-cierre 
 
d(p,a) = λ-cierre(d(q1,a))
U 
 p ∈ d*( q1 ,λ )   p ∈ {q1} 
= λ-cierre({q2}) = {q2,q3,q4}
   
d*(q1,ab) = λ-cierre  U d(p, b) = λ-cierre  U d(p, b)
 p ∈ d*( q1 ,a)   p ∈ {q 2 ,q 3 ,q 4 } 
= λ-cierre(d(q2,b) ∪ d(q3,b) ∪ d(q4,b)) = λ-cierre({q1,q3} ∪ {q1,q4} ∪ {})
= λ-cierre({q1,q3,q4})
= U λ-cierre({p}) = λ-cierre({q1}) ∪ λ-cierre({q3}) ∪ λ-cierre({q4})
p ∈{q1 ,q 3 ,q 4 }
= {q1} ∪ {q3,q4} ∪ {q3,q4} = {q1,q3,q4}
59
d* ofrece una forma elegante de definir la aceptación de una cadena en un λ-AFN y en
consecuencia también de T(A):
La cadena u es aceptada si (d*(q1,u) ∩ F) ≠ ∅
T(A)={ u ∈ Σ∗ / (d*(q1,u) ∩ F) ≠ ∅ }
Así en nuestro primer ejemplo como d*(q1,bcb) = {}, tenemos que d*(q1,bcb) ∩ F = ∅, luego
la cadena bcb es rechazada por el λ-AFN. También como d*(q1,cc) = {q3}, tenemos que
(d*(q1,cc) ∩ F) ≠ ∅, luego la cadena cc es aceptada por el λ-AFN.
En nuestro segundo ejemplo, es claro que (d*(q1,ab) ∩ F) = {q1,q3,q4} ∩ {q1,q4} = {q1,q4},
luego (d*(q1,ab) ∩ F) ≠ ∅ y por lo tanto la cadena ab es aceptada por este segundo λ-AFN.
Como siempre los problemas básicos son dos: dado un λ-AFN A indicar qué es T(A); y dado
un lenguaje L construir un λ-AFN A que acepte L. Por ejemplo la simple inspección nos dice
que T(A) = {b}* ∪ {c}* en el caso de nuestro primer λ-AFN.
Hasta ahora hemos visto algunos ejemplos de autómatas (λ-AFN’s, AFN’s o AFD’s) y, en
algunos casos, hemos indicado T(A) sin argumentación. Cuando la simple inspección no es
suficiente, puede pensarse una demostración de L=T(A) semejante a L=L(G), con inducción
sobre la longitud de las cadenas y sobre la longitud de las transiciones, afortunadamente hay
otro mecanismo más formal e interesante mostrado más adelante pero que requiere algunos
conceptos que recién veremos.
Terminaremos este capítulo con algunos resultados interesantes.

i) En los λ-AFN’s, d*(qi,a) ≠ d(qi,a)
En efecto, en el segundo λ-AFN que tenemos de ejemplo, obtuvimos d*(q1,a)={q2,q3,q4}, en
cambio de la gráfica del λ-AFN se desprende que d(q1,a)={q2}
ii) Demostraremos que, en los AFD’s, δ*(qi,a) = δ(qi,a)

En efecto:
δ*(qi,a) = δ(δ*(qi,λ),a) por definición recursiva de δ*
= δ(qi,a) por definición recursiva de δ* (caso u=λ)
iii) Demostraremos que, en los AFN’s, d*(qi,a) = d(qi,a)

En efecto:
d*(qi,a) = U
d(p,a) por definición recursiva de d*
p ∈ d *( q i ,λ )
= U d(p,a) por definición recursiva de d* ( es decir, d*(qi,λ)={qi} )

p ∈{q i }
= d(qi, a) desarrollando la unión
60
iv) Dado un diagrama de transición solamente, por ejemplo
sin más datos, resulta ambiguo indicar si dicho diagrama corresponde a un λ-AFN, a un AFN
o a un AFD, por ello cuando un diagrama no sea suficientemente claro es exigible indicar la
función o explicitar de qué tipo de autómata finito se trata.
61
CAPÍTULO 4. EXPRESIONES REGULARES
Las expresiones regulares (e.r.) tienen un importante desarrollo teórico, constituyen además
otro medio para denotar lenguajes y conjuntos regulares.
Las e.r. de un alfabeto Σ y los lenguajes que denotan se definen como sigue:
∅ es una e.r.
λ es una e.r.
Para cada a ∈ Σ, a es una e.r.
Si r y s son e.r. entonces (r+s), (r.s) y (r*) son también e.r.
En la concatenación r.s el punto suele omitirse quedando rs.

A menudo los paréntesis se omiten también cuando se toma en cuenta la prioridad de las
operaciones (“*”, “.” y “+” en ese orden) y no hay lugar a confusión.
De este modo la apariencia de la expresiones regulares es la siguiente:

(ab+c+b)*abc
(a+b+λ)*
(0+1+...+9)*(0+1+...+9)*
Cada expresión regular r de un alfabeto Σ denota un lenguaje, es decir un conjunto de

cadenas, mismo que representaremos por L(r).
La e.r. ∅ denota al lenguaje {}, es decir, L(∅)={}
La e.r. λ denota al lenguaje {λ}, es decir, L(λ)={λ}
Para cada a ∈ Σ , la e.r. a denota al lenguaje {a}, es decir, L(a)={a}
Si r y s son e.r. entonces:
la e.r. (r+s) denota al lenguaje L(r) ∪ L(s), es decir, L(r+s)=L(r) ∪ L(s)
la e.r. (rs) denota al lenguaje L(r)L(s), es decir, L(rs)=L(r)L(s)
la e.r. (r*) denota al lenguaje [L(r)]*, es decir, L(r*)=[L(r)]*
Se puede indicar un lenguaje utilizando -como hasta ahora- notación en potencias, con
operaciones entre lenguajes, etc.; pero también podemos utilizar e.r., por ejemplo:
Estilo sin e.r. Con e.r.

L={1u / u ∈ {0,1}* } L=L(r) donde r es la e.r. 1(0+1)*
L={aibj / i > 0, j > 0 } L=L(r) donde r es la e.r. aa*bb*
L={aibj / i ≥ 0, j ≥ 0 } L=L(r) donde r es la e.r. a*b*
L={a}{a,b,c}*{c} L=L(r) donde r es la e.r. a(a+b+c)*c
Un problema típico es escribir una e.r. que denote un lenguaje descrito literalmente y que
tiene ciertas restricciones.
62
Ejemplos:
Escriba una e.r. que denote el conjunto de cadenas en {a,b}* donde inmediatamente luego de
toda b aparece una a: (a+ba)*
Escriba una e.r. que denote el conjunto de cadenas en {a,b}* que contengan la subcadena bb
por lo menos una vez: (a+b)*bb(a+b)*
Escriba una e.r. que denote el conjunto de cadenas en {a,b}* que contengan la subcadena
bb exactamente una vez: (ba+a)*bb(a+ab)*
Escriba una e.r. que denote el conjunto de cadenas en {a,b}* que no contengan la subcadena
bb: (a+ba)*(b+λ)
Escriba una e.r. que denote el conjunto de cadenas en {0,1}* tal que si una cadena incluye la
subcadena 00 no debe contener la subcadena 11: (1+01)*(0+λ) + (0+10)*(1+λ)
Dos e.r. pueden denotar al mismo lenguaje, por ejemplo

r = a(a+λ) s = aa+a
denotan el mismo lenguaje:
L(r)=L(a(a+λ))=L(a)L((a+λ))=L(a)[L(a) ∪ L(λ)]={a}[{a} ∪ {λ}]={a}[{a, λ}]={aa,a}
L(s)=L(aa+a)=L(aa) ∪ L(a)=[L(a)L(a) ∪ L(a)]=[{a}{a} ∪ {a}]={aa} ∪ {a}={aa,a}
Se dice que dos e.r. r y s son equivalentes, lo que representaremos así r ≡ s, si y solo si
denotan al mismo lenguaje, es decir, L(r)=L(s).
Existen varias equivalencias muy conocidas:

Grupo I Grupo II Grupo III
(r+s) ≡ (s+r) rλ ≡ λr ≡ r r(s+t) ≡ rs+rt
(r+s)+t ≡ r+(s+t) ≡ r∅ ≡ ∅r ≡ ∅ (s+t)r ≡ sr+tr
r+s+t (rs)t ≡ r(st) ≡ rst
r+∅ ≡ ∅+r ≡ r
r+r ≡ r
Grupo IV Grupo V Grupo VI
r* ≡ r*r* (r+s)* ≡ (r*+s*)*
≡ (r*)* r* ≡ λ+rr* ≡ (r*s*)* ≡ (r*s)*r*
≡ (λ+r)* ≡ r*(sr*)*
∅* ≡ λ* ≡ λ pero
(r+s)* ≡/ r*+s*
Grupo VII Grupo VIII Grupo IX
r*r ≡ rr* (r s)* ≡ λ+(r+s)*s
*
r ≡ sr+t ssi r ≡ s*t
r(sr)* ≡ (rs)*r (rs*)* ≡ λ+r(r+s)* r ≡ rs+t ssi r ≡ ts*
63
Estas equivalencias se utilizan para, a partir de una e.r., obtener otra e.r. equivalente, es decir,
que denote al mismo lenguaje pero que –a juicio de quien realiza la tarea- sea más útil o más
simple, esto último se denomina también simplificación de e.r.
Ejemplo de verificación de la equivalencia de dos e.r. o de simplificación:

En efecto el mismo problema puede plantearse así
i) Mostrar que las e.r. (10 + 1)*1 y 1(01 + 1)* son equivalentes; o así
ii) Simplificar la e.r. (10 + 1)*1
En este ejemplo subrayamos la parte de la e.r. que es tomada en cuenta para aplicar una de las
equivalencias conocidas.
(10+1)*1 ≡ (1+10)*1 Grupo I: (r+s)≡(s+r) donde r=10
≡ (1*10)*1*1 Grupo VI: (r+s)*≡(r*s)*r* donde r=1
* * *
≡ ((1 1)0) 1 1 Grupo II: rst≡(rs)t donde r=1*
* * *
≡ ((1 1)0) (1 1) Grupo II: rst≡r(st) donde r=((1*1)0)*
≡ (1*1)(0(1*1))* Grupo VII: (rs)*r≡r(sr)* donde r=(1*1)
* * *
≡ (11 )(0(1 1)) Grupo VII: r*r≡rr* donde r=1
≡ (11*)(0(11*))* Grupo VII: r*r≡rr* donde r=1
* * *
≡ (11 )(011 ) Grupo II: r(st)≡rst donde r=0
* * *
≡ 11 (011 ) Grupo II: (rs)t≡rst donde t=(011*)*
≡ 1(1*(011*)*) Grupo II: rst≡r(st) donde t=(011*)*
*
≡ 1(1+01) Grupo VI: r*(sr*)*≡(r+s)* donde r=1
*
≡ 1(01+1) Grupo I: (r+s)≡(s+r) donde r=1
En todo caso la idea de simplificación suele partir de una e.r. larga y tratar de obtener una e.r.
mucho más corta.
Sin apelar a autómatas, los grupos de equivalencias utilizadas pueden demostrarse de dos
formas:
i) Las más complejas a partir de las más simples.
Ejemplo (donde subrayamos la parte de la e.r. tomada en cuenta al aplicar una equivalencia):
Si r ≡ s*t demostrar que r ≡ sr+t
r ≡ s*t Por hipótesis
≡ (λ+ss*)t Grupo V: r*≡λ+rr*
≡ λt+ss*t Grupo III: (s+t)r≡sr+tr
*
≡ t+ss t Grupo II: λr≡r
≡ t+sr Por hipótesis s*t≡r
≡ sr+t Grupo I: (r+s)≡(s+r)
ii) Las más simples a través de lo que se llama reasociación y/o el trabajo con lenguajes.
Ejemplos:
ii.a: Demostrar que r(sr)* ≡ (rs)*r
Es decir, demostrar que L(r(sr)*) = L((rs)*r)
64
Como es habitual en conjuntos, se hace en dos partes:
L(r(sr)*) ⊆ L((rs)*r)
Sea w ∈ L(r(sr)*), entonces w es de la forma w=r0(s1r1)(s2r2)...(snrn) para algún n≥0 -cada ri y
cada sj es una (sub)cadena-, pero esta cadena w puede reagruparse o reasociarse –por la
asociatividad de la concatenación de cadenas- de esta forma: w=(r0s1)(r1s2)(r2s3)...(rn-1sn-1)rn,
por lo tanto, w ∈ L((rs)*r)
L((rs)*r) ⊆ L(r(sr)*)
Sea w ∈ L((rs)*r), entonces w es de la forma w=(r0s0)(r1s1)(r2s2)...(rn-1sn-1)rn para algún n≥0
–cada ri y cada sj es una (sub)cadena-, pero esta cadena w puede reagruparse o reasociarse
–por la asociatividad de la concatenación de cadenas- de esta forma: w=r0(s0r1)(s1r2)...(sn-1rn),
por lo tanto, w ∈ L(r(sr)*).
ii.b: Demostrar que r* ≡ (r*)*
Es decir, demostrar que L(r*) = L((r*)*)
Sea L(r)=L, entonces lo que hay que demostrar es L* = (L*)*
Por definición de la operación * con lenguajes (L*)* = {λ} ∪ L* ∪ ... etc., es decir, L* ⊆ (L*)*
Nos resta probar que (L*)* ⊆ L*
Sea w ∈ (L*)*, es decir, por definición de la operación *, existe n tal que w ∈ (L*)n, luego w se
puede reescribir así w=w1w2...wn donde cada wi ∈ L*, además y otra vez por definición de la
operación *, para cada i existe mi tal que wi ∈ Lmi de manera que wi= wi1wi2...wi(mi) donde
cada wij ∈ L, pero entonces w ∈ Lm1+...+mn, es decir, w ∈ L*.
ii.c: Demostrar que (r+s)* ≡ (r*s*)*
Es decir, demostrar que L((r+s)*) = L((r*s*)*)
Por un lado sabemos que
L((r+s)*) = {λ} ∪ L(r+s) ∪ (L(r+s))2 ∪... = {λ} ∪ L(r+s) ∪ L(r+s)L(r+s) ∪...
= {λ} ∪ L(r) ∪ L(s) ∪ (L(r))2 ∪ (L(s))2 ∪ L(r)L(s) ∪ L(s)L(r) ∪...
Por otro lado también sabemos que
L((r*s*)*) = {λ} ∪ L((r*s*)) ∪ (L((r*s*)))2 ∪... = {λ} ∪ L((r*s*)) ∪ L((r*s*))L((r*s*)) ∪...
= {λ} ∪ L(r*)L(s*) ∪ L(r*)L(s*)L(r*)L(s*) ∪...
= {λ} ∪ L(r) ∪ L(s) ∪ (L(r))2 ∪ (L(s))2 ∪ L(r)L(s) ∪ L(s)L(r) ∪...
Que son iguales.
DERIVADAS DE EXPRESIONES REGULARES

Sabemos que la e.r. r denota al lenguaje L(r), podemos efectuar la operación cociente
izquierdo a L(r) por una cadena.
Por ejemplo sea r=baa+bac+aa, L(r)={baa,bac,aa} y efectuemos la operación cociente
izquierdo con la cadena u=b, el resultado es L(r)/u={aa,ac}, este nuevo lenguaje puede
denotarse con la expresión regular aa+ac.
Se define como la derivada –izquierda- de la e.r. r respecto de la cadena u a la e.r. que denota
al lenguaje L(r)/u; representaremos esta derivada así Du(r) que leeremos derivada -izquierda-
de r respecto de u (también es usual la notación u-1r). Como la derivada izquierda es más
65
generalmente estudiada omitiremos la palabra izquierda dándola por supuesta. En nuestro
ejemplo, Db(baa+bac+aa)=aa+ac
Esta definición planteada inicialmente por Brzozowski permite establecer las siguientes reglas
para la derivación respecto de un símbolo:
Da(∅)=∅
Da(λ)=∅
Da(a)=λ
Db(a)=∅ a≠b
Da(r+s)=Da(r) + Da(s)
Estructuralmente nos falta considerar dos casos en la derivada respecto de un símbolo, la
concatenación de dos e.r. y la estrella de Kleene de una e.r.
La e.r rs tiene una consideración importante: si el lenguaje que denota r incluye o no a la
cadena vacía. Si no incluye la cadena vacía entonces la derivada de esta e.r. debe denotar las
cadenas L(rs)/a, es decir cadenas en rs que empiecen con el prefijo ‘a’ mismo que se les quita,
pero dado que r no incluye a la cadena vacía, dichas cadenas son aquellas en r -que empiecen
con el prefijo ‘a’- a las que se les quita dicho prefijo, seguidas de las cadenas en s, es decir,
Da(rs)=Da(r)s si λ ∉ L(r)
En cambio si r incluye a la cadena vacía hay que considerar también quitar el prefijo ‘a’ de las
cadenas en s que empiecen con este prefijo, es decir,
Da(rs)=Da(r)s + Da(s) si λ ∈ L(r)
Es común reunir ambas reglas en una así:
Da(rs)=Da(r)s + δ(r)Da(s)
donde δ(r)=∅ si λ ∉ L(r)
δ(r)=λ si λ ∈ L(r)
El último caso de la derivada respecto de un símbolo es para la e.r. r*.

Sea L=L(r), se sabe que L(r*)=[L(r)]*=L*={λ} ∪ L ∪ L2 ∪ L3 ∪ ...
={λ} ∪ L ∪ LL ∪ LLL ∪...
La derivada Da(r ) no es otra cosa que la e.r. que denota al lenguaje L*/a, que no es otra cosa
*
que el conjunto de cadenas en L* que empiezan con el prefijo ‘a’ y a las que se les quita dicho
prefijo.
Suprimamos pues dicho símbolo a estas cadenas, volvemos a considerar dos casos.
Cuando λ ∉ L(r) y sabiendo que {λ}/a={}, el resultado es
L*/a = {} ∪ L/a ∪ (L/a)L ∪ (L/a)LL ∪... = (L/a) ({λ} ∪ L ∪ LL ∪ ...)
= (L/a)(L*)
que puede ser denotado por Da(r)r*
Cuando λ ∈ L(r) y sabiendo que {λ}/a={}, el resultado es
L*/a = {} ∪ L/a ∪ (LL)/a ∪ (LLL)/a ∪...
= {} ∪ L/a ∪ (L/a)L ∪ (L/a) ∪ (L/a)LL ∪ (LL/a) ∪ (L/a) ∪ ... donde se subraya
= {} ∪ L/a ∪ (L/a)L ∪ (L/a) ∪ (L/a)LL ∪ (L/a)L ∪ (L/a) ∪ ... las partes añadidas
= (L/a) ({λ} ∪ L ∪ LL ∪ ...) por efecto de que λ ∈ L
66
= (L/a) (L*)
que puede ser denotado también por Da(r)r*
Es decir,
Da(r*)=Da(r)r*
Algunos denominan derivada de orden superior cuando la derivación de una e.r. se extiende a
más de un símbolo y se hace respecto de una cadena, cuya interpretación ya dimos.
Ejemplo:
Dc(c)=λ
Da(ac)=Da(a)c=λc=c
Db(bac)=Db(b)ac=λac=ac
Dbac(bac)=Dc(Da(Db(bac)))=Dc(Da(ac))=Dc(c)=λ
Así cuando u=bac, Du(bac)=λ
Fíjese que para calcular Du(r) la secuencia de las derivadas respecto de un símbolo
corresponde a los símbolos de u leídos de izquierda a derecha.
Si definimos Dλ(r)=r, una definición recursiva para la derivada respecto de una cadena es:
Dλ(r)=r
Dwa(r)=Da(Dw(r))
Reuniendo nuevamente todo tenemos:
Da(∅)=∅
Da(λ)=∅
Da(a)=λ
Db(a)=∅ a≠b
Da(r+s)=Da(r) + Da(s)
Da(rs)=Da(r)s si λ ∉ L(r) o bien Da(rs)=Da(r)s + δ(r)Da(s) con δ(r)=∅ si λ∉L(r)
Da(rs)=Da(r)s + Da(s) si λ ∈ L(r) δ(r)=λ si λ∈L(r)
Da(r*)=Da(r)r*
Dλ(r)=r
Dwa(r)=Da(Dw(r))
Ejemplo:
Sea r=b(ab)*+bb*aa*, calcular Dbaa(r)
Dbaa(r)=Dbaa(b(ab)*+bb*aa*)=Da(Da(Db(b(ab)*+bb*aa*)))
Necesitamos calcular Db(b(ab)*+bb*aa*)=Db(b(ab)*) + Db(bb*aa*)
Db(b(ab)*)=Db(b)(ab)* pues L(b) no incluye a λ
=λ(ab)*=(ab)*
Db(bb*aa*)=Db(b)b*aa* pues L(b) no incluye a λ
=λb*aa*=b*aa*
Así pues Db(b(ab)*+bb*aa*)=(ab)*+b*aa*
67
Luego requerimos calcular
Da(Db(b(ab)*+bb*aa*))=Da((ab)*+b*aa*)=Da((ab)*)+Da(b*aa*)
Da((ab)*)=Da((ab))(ab)*
=Da(ab)(ab)*
=Da(a)b(ab)* pues L(a) no incluye a λ
=λb(ab)*=b(ab)*
Da(b aa )=Da(b*)aa*+Da(aa*)
* *
pues L(b*) incluye a λ
= Da(b)b*aa*+Da(a)a* pues L(a) no incluye a λ
=∅b*aa*+λa*=a*
Así pues Da(Db(b(ab)*+bb*aa*))=b(ab)*+a*
Finalmente
Da(Da(Db(b(ab)*+bb*aa*)))=Da(b(ab)*+a*)
=Da(b(ab)*)+Da(a*)
=Da(b)(ab)*+Da(a)a*
=∅(ab)* +λa*
=a*
Así, Dbaa(b(ab) +bb aa )=a*
* * *
Mostraremos ahora algunos resultados previos a uno que será decisivo para más adelante.
I. Probaremos por inducción sobre |w| que si |w|>0
Dw(s+t)=Dw(s) + Dw(t)
Caso base:
|w|=1, es decir, w=a lo que se reduce a la regla ya presentada.
El resultado sigue para cadenas w de longitud |w|=k.
Paso inductivo:
Sea w una cadena tal que |w|=k+1, es decir, podemos reescribir w así: w=ua con |u|=k. Luego,
Dw(s+t)=Dua(s+t) pues w=ua
=Da(Du(s+t)) por la regla para cadenas
=Da(Du(s) + Du(t)) por hipótesis inductiva
=Da(Du(s)) + Da(Du(t)) por la regla + ya vista, dado que Du(t) y Du(s) son e.r.
=Dua(s) + Dua(t) por la regla para cadenas
=Dw(s) + Dw(t) pues w=ua
II. Probaremos por inducción sobre |v| que Duv(r) = Dv(Du(r))

Caso base:
|v|=0, es decir, v=λ
Duv(r)=Du(r) pues v=λ
=Dλ(Du(r)) por la regla para cadenas
=Dv(Du(r)) pues v=λ
El resultado sigue para cadenas v de longitud |v|=k.
68
Paso inductivo:
Sea v una cadena tal que |v|=k+1, es decir, podemos reescribir v así: v=wa con |w|=k. Luego,
Duv(r)=Duwa(r) pues v= wa
=Da[Duw(r)] por la regla para cadenas
=Da[Dw(Du(r))] por hipótesis inductiva
=Dwa(Du(r)) por la regla para cadenas dado que Du(r) es una e.r.
=Dv(Du(r)) pues v= wa
III. Sea δ la función definida en la regla para la derivación de dos e.r. concatenadas, entonces
Dv[δ(s)Dw(t)] = δ(s)Dv[Dw(t)]
En efecto, sabemos que δ(s)=∅ o bien δ(s)=λ, luego por las propiedades de las e.r.:
En el primer caso Dv[δ(s)Dw(t)]=Dv[∅Dw(t)]=Dv[∅]=∅=∅Dv[Dw(t)]=δ(s)Dv[Dw(t)]
Y en el segundo Dv[δ(s)Dw(t)]=Dv[λDw(t)]=Dv[Dw(t)]=λDv[Dw(t)]=δ(s)Dv[Dw(t)]
Adicionalmente mostraremos por inducción sobre el número n de sumandos que
Dv{[δ(Du1(t))+...+δ(Dun(t))] Dw(t)} = [δ(Du1(t))+...+δ(Dun(t))] Dv[Dw(t)]
Caso base:
n=1, Dv{δ(Du1(t))Dw(t)} se reduce al resultado anterior con s=Du1(t)
El resultado sigue para k sumandos.
Paso inductivo:
Dv{[δ(Du1(t))+... +δ(Duk(t))+δ(Duk+1(t))]Dw(t)}
=Dv{[δ(Du1(t))+...+δ(Duk(t))]Dw(t) + δ(Duk+1(t))Dw(t)} distribuyendo Dw(t)
=Dv{[δ(Du1(t))+...+δ(Duk(t))]Dw(t)} + Dv{δ(Duk+1(t))Dw(t)} por I
=Dv{[δ(Du1(t))+...+δ(Duk(t))]Dw(t)} + δ(Duk+1(t))Dv[Dw(t)] por el caso base
=[δ(Du1(t))+...+δ(Duk(t))]Dv[Dw(t)] + δ(Duk+1(t))Dv[Dw(t)] por hipótesis inductiva
={[δ(Du1(t))+...+δ(Duk(t))] + δ(Duk+1(t))} Dv[Dw(t)] por la regla de distribución (grupo III)
IV. Mostraremos ahora por inducción sobre |w| que si |w|>0, w=a1a2…an
n
Dw(st) = Dw(s)t + ∑
i= 2
[δ(Da1...a(i-1)(s)) Dai...an(t)] + δ(s)Dw(t)
Caso base:
|w|=1, se reduce a la regla ya presentada con la sumatoria ignorada por vacuidad.
Sólo por claridad haremos el caso cuando |w|=2, es decir, w=a1a2 (n=2).
Dw(st)=Da1a2(st) pues w=a1a2
=Da2(Da1(st)) por la regla para cadenas
=Da2(Da1(s)t+δ(s)Da1(t)) por la regla para concatenación
=Da2(Da1(s)t) + Da2(δ(s)Da1(t)) por la regla + ya vista
=Da2(Da1(s))t+δ[Da1(s)] Da2(t) + Da2(δ(s)Da1(t)) por la regla para concatenación
=Da2(Da1(s))t+δ[Da1(s)] Da2(t) + δ(s)Da2(Da1(t)) por III
=Da1a2(s)t+δ[Da1(s)] Da2(t)+δ(s)Da1a2(t) por la regla para cadenas
=Dw(s)t+δ(Da1(s)) Da2(t)+δ(s)Dw(t) pues w=a1a2
69
n
=Dw(s)t+ ∑
i= 2
[δ(Da1...a(i-1)(s)) Dai...an(t)]+δ(s)Dw(t) reescribiendo
Paso inductivo:
Sea w una cadena tal que |w|=k+1, es decir, podemos reescribir w así: w=uak+1 con |u|=k,
u=a1a2…ak. Luego,
Dw(st)=Dua(k+1)(st) pues w=uak+1
=Da(k+1)[Du(st)] por la regla para cadenas
k
=Da(k+1)[Du(s)t + ∑
i= 2
[δ(Da1...a(i-1)(s)) Dai...ak(t)] + δ(s)Du(t)] por hipótesis inductiva
k
=Da(k+1)[Du(s)t] + Da(k+1)[ ∑ i= 2
[δ(Da1...a(i-1)(s)) Dai...ak(t)]] + Da(k+1)[δ(s)Du(t)] regla +
Ahora bien
Da(k+1)[Du(s)t]
=Da(k+1)[Du(s)]t+δ(Du(s))Da(k+1)(t)
=Dua(k+1)(s)t+δ(Du(s))Da(k+1)(t)
=Dw(s)t+δ(Du(s))Da(k+1)(t)
por la regla para la concatenación, la regla para cadenas y dado que w=uak+1
También
Da(k+1)[δ(s)Du(t)]
=δ(s)Da(k+1)[Du(t)]
=δ(s)Dua(k+1)(t)
=δ(s)Dw(t) por III, la regla para cadenas y dado que w=uak+1.
Y también
k
Da(k+1)[ ∑
i= 2
[δ(Da1...a(i-1)(s)) Dai...ak(t)]]
k
= ∑
i= 2
[δ(Da1...a(i-1)(s)) Da(k+1)[Dai...ak(t)]]
k
= ∑
i= 2
[δ(Da1...a(i-1)(s)) Dai...aka(k+1)(t)] por la regla para +, III y la regla para cadenas.
Es decir,
Dw(st)
k
=Dw(s)t+δ(Du(s))Da(k+1)(t) + ∑
i= 2
[δ(Da1...a(i-1)(s)) Dai...aka(k+1)(t)]+δ(s)Dw(t)
70
k
=Dw(s)t+δ(Da1...ak(s))Da(k+1)(t) + ∑i= 2
[δ(Da1...a(i-1)(s)) Dai...aka(k+1)(t)]+δ(s)Dw(t) pues u=a1a2…ak
k +1
=Dw(s)t+ ∑
i= 2
[δ(Da1...a(i-1)(s)) Dai...aka(k+1)(t)]+δ(s)Dw(t)
V. Probaremos por inducción sobre |w| que si |w|>0, w=a1a2…an

  
( )
n
*
Dw(t )={ Dw(t) + 


∑ ∑ 
δ [ D u1 ( t)]... δ [ D u m ( t)] D a i ...a n ( t)
i = 2   ∀ 1≤ m ≤ i − 1 ∀ u1 ,..., u m∴u j ≠ λ & a 1 ...a i−1= u1 ...u m
 }t*

  
Caso base:
|w|=1, se reduce a la regla ya presentada con la sumatoria ignorada por vacuidad.
Sólo por claridad haremos el caso cuando |w|=2, es decir, w=a1a2 (n=2).
Dw(t*)=Da1a2(t*) pues w=a1a2
=Da2(Da1(t*)) por la regla para cadenas
=Da2(Da1(t) t*) por la regla para *
* *
=Da2[Da1(t)] t + δ[Da1(t)] Da2(t ) por la regla para la concatenación
=Da1a2(t) t* + δ[Da1(t)] Da2(t*) por la regla para cadenas
* *
=Da1a2(t) t + δ[Da1(t)] Da2(t) t por la regla para *
={Dw(t) + δ[Da1(t)] Da2(t)} t* por distribución y w=a1a2
que tiene la forma de nuestro enunciado con n=2
Paso inductivo:
Sea w una cadena tal que |w|=k+1, es decir, podemos reescribir w así: w=uak+1 con |u|=k,
u=a1a2…ak. Luego,
Dw(t*)
=Dua(k+1)(t*) pues w=uak+1
=Da(k+1)[Du(t*)] por la regla para cadenas
  
( )
k
=Da(k+1)[{ Du(t) + ∑ 
 ∑ δ [ D u1 ( t )]... δ [ D
um ( t )]

 D a i ...a k ( t)
 }t*]

  
por hipótesis inductiva con u=a1a2…ak
  
( )
k
*
= Da(k+1)[ Du(t)t + 


∑ ∑ 
δ [ D u1 ( t)]... δ [ D u m ( t)] D a i ...a k ( t) t* ]
  
distribuyendo t*
ahora aplicaremos la regla para + y derivaremos
cada miembro respecto de ak+1; para el segundo miembro
aplicaremos además I y III
71
  
( )
k
=Da(k+1)[Du(t)t ] + *


∑ ∑ 
δ [ D u1 ( t)]...δ [ D u m ( t)] D a k+1 [ D a i ...a k ( t) t*]
  
ahora aplicaremos la regla para la concatenación en ambos casos
=Da(k+1)[Du(t)]t*+δ[Du(t)]Da(k+1)(t*)
  
( ) ( )
k
+ ∑ 
 ∑ δ [ D u1 ( t )]... δ [ D
um ( t )]
 
D D
  a k+1 a i ...a k ( t ) t* + δ D a i ...a k ( t ) D a k +1 ( t*) 

  
ahora aplicaremos la regla para cadenas y la regla para *
=Dua(k+1)(t) t* + δ[Du(t)]Da(k+1)(t) t*
+
  
( )
k
∑ 
 ∑  
δ [ D u1 ( t)]... δ [ D u m ( t)]  D a i ...a k a k +1 ( t) t* + δ D a i ...a k ( t) D a k +1 ( t) t * ]
i = 2   ∀ 1≤ m ≤ i − 1 ∀ u1 ,..., u m∴u j ≠ λ & a1 ...a i−1= u1 ...u m


  
ahora distribuiremos las sumatorias y haremos uak+1=w
= Dw(t) t* + δ[Du(t)]Da(k+1)(t) t*
  
( )
k
+ ∑ 
 ∑ δ [ D u1 ( t )]... δ [ D
um ( t )]

D
 a i ...a k a k +1 ( t ) t* ]

  
k   
∑
+   ∑ 
( )
δ [ D u1 ( t)]... δ [ D u m ( t)]  δ D a i ...a k ( t) D a k +1 ( t) t* ]
  
ahora aplicaremos la regla de distribución ‘factorizando’ t*
y colocaremos el segundo término al final haciendo u=a1a2…ak
={ Dw(t)
  
( )
k
+ ∑ 
 ∑ 
δ [ D u1 ( t)]... δ [ D u m ( t)] D a i ...a k a k +1 ( t) ]
  
k   
∑
+   ∑ 
( )
δ [ D u1 ( t)]... δ [ D u m ( t)]  δ D a i ...a k ( t) D a k +1 ( t) ]
  
+ δ[Da1...ak(t)]Da(k+1)(t)
} t*
(la sumatoria interna del segundo término sólo llega hasta a1…ai-1,
y como i puede ser a lo más k se tiene a1a2…ak-1, fíjese como la función δ
más interna del tercer término junto al último término cubren el
caso a1…ak)
nótese que con las dos sumatorias junto a δ[Da1...ak(t)]Da(k+1)(t)
se obtiene la siguiente igualdad:
72
k +1    
={ Dw(t) + 
∑

∑ 
(
δ [ D u1 ( t)]... δ [ D u m ( t)] D a i ...a k +1 ( t)
) }t*

  
El importante resultado anunciado es que el número de derivadas distintas que se pueden
obtener a partir de una e.r. es finito, es decir, sea Σ el alfabeto sobre el que se forman las e.r. y
sea r una e.r., el conjunto {Dw(r) / w∈ Σ*} es finito.
Demostración:
Por inducción sobre la longitud de la e.r. r
Caso base:
Sea r una e.r. de longitud |r|=1, es decir r=∅ o r=λ o r=a (a ∈ Σ)
i. Cuando r=∅ es fácil ver de nuestras reglas que Dw(∅)=∅ para todo w, es decir hay una
derivada, no infinitas derivadas distintas.
ii. Cuando r=λ las reglas permiten evidenciar que Dw(λ)=λ para w=λ, Dw(λ)=∅ para w≠λ, es
decir hay dos derivadas diferentes, no infinitas derivadas distintas.
ii. Cuando r=a es fácil ver que según nuestras reglas Dw(a)=a para w=λ, Dw(a)=λ para w=a y
Dw(a)=∅ para (w≠λ y w≠a), es decir hay tres derivadas diferentes, no infinitas derivadas
distintas.
Una e.r. r de longitud |r|<k tiene un número finito de derivadas distintas que se pueden
obtener a partir de ella.
Paso inductivo:
Sea r una e.r. de longitud |r|=k
Entonces, de acuerdo a la estructura de las e.r., r=s+t o r=st o r=t*
i.Cuando r=s+t, Dw(s+t)=Dw(s) + Dw(t), y de ahí por hipótesis inductiva cada miembro de esta
e.r. tiene un número finito de derivadas distintas, luego r tiene un número finito de derivadas
distintas.
n
ii.Cuando r=st, Dw(st)=Dw(s)t + ∑i= 2
[δ(Da1...ai-1(s)) Dai...an(t)] + δ(s)Dw(t), y de ahí por
hipótesis inductiva cada miembro de esta e.r. tiene un número finito de derivadas distintas,
luego r tiene un número finito de derivadas distintas.
iii.Cuando r= t*,
  
( )
n
Dw(t*)={ Dw(t) + ∑ 
 ∑ δ [ D u1 ( t )]... δ [ D
um ( t )]

 D a i ...a n ( t)
 }t*,

  
y de ahí por hipótesis inductiva esta larga e.r. tiene un número finito de derivadas distintas,
luego r tiene un número finito de derivadas distintas.
Un resultado más ambicioso es el siguiente –que busca un número límite superior de

derivadas distintas-:
73
Sea ds = | {Dz(s) / z ∈ Σ*} |
dt = | {Dz(t) / z ∈ Σ*} |
a) Sea r=s+t, entonces como Dw(s+t)=Dw(s) + Dw(t)

{Dz(s+t) / z ∈ Σ*}={ Dz(s)+Dz(t) / z ∈ Σ*}
luego si hacemos dr=|{Dz(s+t) / z ∈ Σ*}| entonces la combinatoria nos dice que dr = dsdt
b) Sea r=t*, y sea w= a1a2…an entonces como

  
( )
n
*
Dw(t )={ Dw(t) + 
 ∑ δ [ D∑u1 ( t )]... δ [ D
um ( t )]

 D a i ...a n ( t)
 }t*

  
y como estamos buscando un número límite superior,
dicho caso extremo sucede cuando todas las funciones δ son iguales a λ,
la expresión –en este caso extremo- se convierte en
∑ [D ]
n
Dw(t*)={ a i ...a n ( t) }t*
i =1
={Da1...an(t)+Da2...an(t)...+Da(n-1)an(t)+Dan(t)}t*
Luego
{Dz(t*) / z ∈ Σ*} = {[Da1...a|z|(t)+Da2...a|z|(t)+...+Da|z|(t)] t* / z ∈ Σ*}
¿ cuántas e.r. distintas [Da1...a|z|(t)+Da2...a|z|(t)...+Da|z|(t)] para z ∈ Σ* pueden haber sabiendo
que dt = | {Dz(t) / z ∈ Σ*} | ?
Es posible, para cadenas z dadas, que alguna de estas e.r. distintas sea un elemento
de {Dz(t) / z ∈ Σ*}, o la suma –en términos de e.r.- de dos elementos cualesquiera
de dicho conjunto, o de todos sus elementos (siempre tomando en cuenta que r+s=s+r y
que r+r=r) eso no es otra cosa que el conjunto de partes de {Dz(t) / z ∈ Σ*} excepto el
conjunto vacío, es decir, si hacemos dr=| {Dz(t*) / z ∈ Σ*} | entonces dr ≤ 2dt - 1
c) Sea r=st, entonces como

n
Dw(st)=Dw(s)t + ∑ i= 2
[δ(Da1...ai-1(s)) Dai...an(t)] + δ(s)Dw(t)
y como estamos buscando un número límite superior,

dicho caso extremo sucede cuando todas las funciones δ son iguales a λ,
la expresión –en este caso extremo- se convierte en
n
Dw(st)=Dw(s)t + ∑i= 2
[Dai...an(t)] + Dw(t), es decir,
n
Dw(st)=Dw(s)t + ∑i =1
Dai...an(t)
74
Dw(st)=Dw(s)t + Da1...an(t) + Da2...an(t) + ... + Da(n-1)an(t) + Dan(t)
Por un razonamiento semejante al anterior inciso, pero considerando que

ahora tenemos que tomar en cuenta Dw(s) también, tenemos que
si hacemos dr=| {Dz(st) / z ∈ Σ*} | entonces dr ≤ ds 2dt.
ECUACIONES CON EXPRESIONES REGULARES

Una idea interesantísima es pensar en ecuaciones donde las incógnitas sean e.r. denotadas por
x o xi.
Por ejemplo, sea la ecuación (a+b)x≡∅, ¿qué e.r. x es tal que esta identidad se cumple?, es
posible que existan muchas soluciones y no una, en nuestro caso x=∅, o x=b∅a, satisfacen la
identidad.
Para la ecuación (a+b)x+ac+bc≡a+b+bc+ac una posible solución es x=λ+c
Esta idea de una ecuación puede extenderse a varias ecuaciones, es decir, un sistema de
ecuaciones. Por ejemplo:
1) x1≡(a+b)x2
2) x2≡a*+x3
3) x3≡b+c*
Asimismo la idea de sustitución se aplica naturalmente, por ejemplo sustituyendo 3) en 2):
x2≡a* + b+c*
Una ecuación particularmente productiva es la siguiente x≡rx+s, donde r y s son expresiones

regulares dadas. La solución a esta ecuación es bien conocida y recibe el nombre del Lema de
Arden debido a su autor:
Si λ ∈ L(r) entonces la ecuación tiene infinitas soluciones x≡r*(s+t), donde t representa
cualquier e.r.
Si λ ∉ L(r) entonces la ecuación tiene una única solución x≡r*s.
Demostración:
i) Si λ ∉ L(r) entonces la ecuación tiene una única solución x≡r*s
Que r*s sea solución se comprueba sustituyendo este valor en la ecuación. En efecto,
x ≡ r*s ≡ (r*)s ≡ (rr*+λ)s ≡ (rr*s+λs) ≡ rr*s+s ≡ r(r*s)+s ≡ r(x)+s ≡ rx+s
Probaremos ahora, por reducción al absurdo, que esta solución es única.
Supongamos pues que hay otra solución con cadenas diferentes adicionales a las que denota
r*s, es decir supongamos que x≡r*s+p, donde p es una e.r., es solución también y que
L(p) ∩ L(r*s)=∅, para que esta sea una otra solución es claro que L(p)≠∅.
Si r*s+p es solución –como estamos suponiendo- satisface la ecuación, es decir,
r*s+p≡r(r*s+p)+s
pero r(r*s+p)+s≡rr*s+rp+s≡rr*s+s+rp≡(rr*s+s)+rp≡(rr*+λ)s+rp≡r*s+rp
Luego,
r*s+p≡r*s+rp
75
Es decir, L(r*s+p)=L(r*s+rp), o lo que es lo mismo L(r*s) ∪ L(p)=L(r*s) ∪ L(rp)
Como esta igualdad se cumple podemos intersectar ambos miembros de ella con otro conjunto
y la igualdad debiera persitir, haremos la intersección con L(p):
Lado izquierdo: [L(r*s) ∪ L(p)] ∩ L(p)=[L(r*s) ∩ L(p)] ∪ [L(p) ∩ L(p)]=∅ ∪ L(p)=L(p)
Derecho: [L(r*s) ∪ L(rp)] ∩ L(p)=[ L(r*s) ∩ L(p)] ∪ [L(rp) ∩ L(p)]=L(rp) ∩ L(p)
Como la igualdad se cumple resulta
L(p)=L(rp) ∩ L(p)
Sea w la cadena más pequeña de L(p) –existe pues el supuesto es que L(p)≠∅-; a partir de la
última igualdad es claro que también w ∈ L(rp) ∩ L(p), es decir, también w ∈ L(rp), es
decir, también w ∈ L(r).L(p), por lo tanto w=uv con u ∈ L(r), v ∈ L(p), sabemos que u≠λ
pues λ ∉ L(r), y por lo tanto que |u|>0, lo que quiere decir que |v|<|w| con v ∈ L(p), pero esto
es absurdo pues w es la cadena más pequeña de L(p).
Este absurdo muestra que nuestro supuesto está equivocado y que no hay otra solución
además de x≡r*s.
ii) Si λ ∈ L(r) entonces la ecuación tiene infinitas soluciones x≡r*(s+t), donde t representa
cualquier e.r.
Que r*(s+t) sea solución, para cualquier e.r. t, se comprueba sustituyendo este valor en la
ecuación como lo haremos enseguida.
Conviene establecer un hecho previo, si λ ∈ L(r) entonces de acuerdo a la definición de e.r. y
el lenguaje que denota: r* ≡ rr*
En efecto, sea L=L(r), como λ ∈ L, podemos reescribir L así L=({λ} ∪ L’). Luego,
L(rr*)=L(r).L(r*)=L(r).[ L(r)]*=L.[L]*=L.L*
=L.[{λ} ∪ L ∪ L.L ∪ L.L.L ∪...]
=L.{λ} ∪ L.L ∪ L.L.L ∪ L.L.L.L ∪...
= L ∪ L.L ∪ L.L.L ∪ L.L.L.L ∪...
=({λ} ∪ L’) ∪ L.L ∪ L.L.L ∪ L.L.L.L ∪...
=({λ} ∪ {λ} ∪ L’) ∪ L.L ∪ L.L.L ∪ L.L.L.L ∪...
={λ} ∪ ({λ} ∪ L’) ∪ L.L ∪ L.L.L ∪ L.L.L.L ∪...
={λ} ∪ L ∪ L.L ∪ L.L.L ∪ L.L.L.L ∪ ...
*
=L
=L(r*)
Hagamos la sustitución ahora, todo es evidente a partir de las equivalencias conocidas y del
anterior resultado cuyo uso hemos subrayado:
x ≡ r*(s+t) ≡ r*s+r*t ≡ r*s+rr*t ≡ (r*)s+rr*t ≡ (rr*+λ)s+rr*t ≡ (rr*s+λs)+rr*t
≡ (rr*s+s)+rr*t ≡ rr*s+s+rr*t ≡ rr*s+rr*t+s ≡ r[r*s+r*t]+s ≡ r[r*(s+t)]+s ≡ r[x]+s ≡ rx+s
76
CAPÍTULO 5. CONVERSIONES GENÉRICAS: El caso regular
A continuación presentamos algunas conversiones genéricas conocidas. Por conversión

entenderemos la construcción de una abstracción a partir de alguna otra de manera que el
lenguaje subyacente sea el mismo.
Construcción de una GRLD cuyo símbolo raíz no aparezca en ninguna parte derecha de
las producciones
Por ejemplo G=({S},{a},{S-->aS,S-->a},S) incluye a su símbolo raíz S en la parte derecha de
la primera de sus producciones, G’=({S’,A},{a},{S’-->aA,A-->aA,S’-->a,A-->a},S’) en
cambio no incluye a su símbolo raíz S’ en la parte derecha de ninguna de sus producciones, y
ambas gramáticas generan el mismo lenguaje.
Sea G=(N, T, P, S) tal que L(G)=L y G incluye a su símbolo raíz S en la parte derecha de
alguna(s) de sus producciones, entonces podemos construir una GRLD G’ tal que G’ no
incluya a su símbolo raíz en la parte derecha de ninguna de sus producciones y L(G’)=L(G).
Demostración:
Construimos G’ así: G’=(N ∪ { S’ }, T, P’, S’) S’ es un nuevo No Terminal, S’ ∉ N
P’ = P ∪ { S’ --> α / S --> α ∈ P }
Es obvio que S’ no aparecerá en ninguna parte derecha porque S’ no es un símbolo de G (es
nuevo), es decir, no está en ningún α.
i) Sea u ∈ L, entonces u ∈ L(G) pues L=L(G), es decir, S=>* u con las producciones de P.
Podemos desglosar esta derivación en su primer paso y el resto de los pasos:
S=>α=>* u donde los pasos de derivación se dan utilizando producciones de P
α denota la cadena que se deriva de S en el primer paso de derivación
que ha debido utilizar la producción S-->α ∈ P
Por la forma de nuestra construcción, entonces S’-->α ∈ P’, por lo tanto
S’=>α donde en este primer paso se utiliza una producción de P’
=>*u con producciones de P’, en realidad las mismas producciones de P que en la
derivación S=>α=>* u, es claro que estas producciones también están en P’.
Es decir, S’=>* u, es decir, u ∈ L(G’). Lo que prueba que L(G) ⊆ L(G’).
ii) Inversamente sea u ∈ L(G’), es decir, S’=>* u con producciones de P’
S’=>α=>* u donde los pasos de derivación se dan utilizando producciones de P’
α denota la cadena que se deriva de S’ en el primer paso de derivación
que ha debido utilizar la producción S’-->α ∈ P’
Por la forma de nuestra construcción, el único modo de que exista la producción S’-->α en P’
es que provenga de la existencia de la producción S-->α ∈ P.
Precisamente por ello, ya hicimos notar que es evidente que α no incluye a S’, por lo tanto el
resto de los pasos de derivación (α=>* u) que se dieron utilizando producciones de P’, han
debido darse con las producciones de P que son parte de P’ y son las únicas que quedan en P’
de acuerdo a nuestra construcción.
77
Es decir, es posible que S=>α=>* u con sólo producciones de P, es decir, u ∈ L(G), lo que
prueba que L(G’) ⊆ L.
Es decir, L(G’)=L(G), y G’ no incluye a S’ –su símbolo raíz- en ninguna parte derecha de sus
producciones.
Ejemplo:
Sea la GRLD G=({S,B},{a,b},P,S)
P:
S-->aS
S-->bB
B-->bS
S-->a
Construimos así la GRLD G’=({S,B,S’},{a,b},P’,S’)
P’:
S’-->aS
S’-->bB
S’-->a
S-->aS
S-->bB
B-->bS
S-->a
Que no tiene a S’ en ninguna de sus partes derechas y genera el mismo lenguaje que G.
Construcción de una GRLIzquierda a partir de una GRLDerecha

Sea G una GRLD que genera L={aub / u ∈{a,b}*} (sólo mostramos P):
P:
S --> aX
X --> aX
X --> bX
X --> b
Para escribir una GRLI que genere L es una pésima idea -que a menudo se tiene- simplemente
invertir las partes derechas así:
P:
S --> Xa
X --> Xa
X --> Xb
X --> b
Fíjese que esta GRLI genera cadenas que terminan en "a", nada que ver con L. No sirve
invertir.
Sea G=(N, T, P, S) una GRLD tal que L(G)=L, entonces podemos construir una GRLI G’ tal
que L(G’)=L(G)
78
Demostración:
Sin pérdida de generalidad -por la anterior conversión- podemos suponer que G es tal que sus
producciones no incluyen a su símbolo raíz en la parte derecha de ninguna de sus
producciones. Entonces construimos así G’=(N, T, P’, S)
P’:
Y --> Xa si ( X --> aY ∈ P ) y X ≠ S
S --> Xa si ( X --> a ∈ P ) y X≠S
S --> a si ( S --> a ∈ P )
Y --> a si ( S --> aY ∈ P )
Es claro que las producciones de P’ respetan el formato de las GRLI’s.
i) Sea u∈L(G) , es decir, S=>* u con las producciones de P.
Si dicha derivación se hace en un paso S=>u, entonces S-->u ∈ P, y por lo tanto –tercera línea
de la construcción de P’- S-->u ∈ P’, así S=>*u con una producción de P’, es decir, u∈L(G’).
Si la derivación S=>* u con producciones de P se hace en más de un paso, podemos desglosar
esta derivación, suponiendo lícitamente que u=bi1bi2...bikbik+1 con bij ∈ T, así:
S=>bi1Vj1 donde se ha utilizado la producción S-->bi1Vj1 ∈ P
=>bi1bi2Vj2 donde se ha utilizado la producción Vj1-->bi2Vj2 ∈ P
...
=>bi1bi2... bikVjk donde se ha utilizado la producción Vjk-1-->bikVjk ∈ P
=>bi1bi2... bikbk+1 donde se ha utilizado la producción Vjk-->bik+1 ∈ P
Ningún Vjh es S, pues G no incluye al símbolo raíz en la parte derecha de sus producciones.
Luego, por la forma de nuestra construcción, las siguientes producciones deben estar en P’:
Vj1-->bi1
Vj2-->Vj1bi2
...
Vjk-->Vjk-1bik
S-->Vjkbik+1
Luego, la siguiente derivación es posible en G’:
S=>Vjkbik+1=>Vjk-1bikbik+1=>...=>Vj2bi3...bikbik+1=>Vj1bi2bi3...bikbik+1=>bi1bi2bi3...bikbik+1
Es decir, S=>*u en G’, es decir u ∈ L(G’). Lo que prueba que L(G) ⊆ L(G’).
ii) Inversamente, sea u ∈ L(G’):
Si S=>u en un paso, ello sucede utilizando la producción S-->u ∈ P’, pero –por construcción,
tercera línea- esta producción está en P’ sólo cuando S-->u ∈ P, así S=>u también en G.
Si S=>*u en G’ dando más de un paso, podemos desglosar esta derivación, suponiendo
lícitamente que u=bi1bi2...bikbik+1 con bij ∈ T, así:
S=>Vjkbik+1 donde se ha debido utilizar la producción S-->Vjkbik+1 ∈ P’
=>Vjk-1bikbik+1 donde se ha debido utilizar la producción Vjk-->Vjk-1bik ∈ P’
...
=>Vj2bi3...bikbik+1 donde se ha debido utilizar la producción Vj3-->Vj2bi3 ∈ P’
=>Vj1bi2bi3...bikbik+1 donde se ha debido utilizar la producción Vj2-->Vj1bi2 ∈ P’
=>bi1bi2... bikbk+1 donde se ha debido utilizar la producción Vj1-->bi1 ∈ P’
79
Estas producciones están en P’ fruto de nuestra construcción y les haremos un análisis tanto
para mostrar que ningún Vjh es S como para indicar qué producciones están en P.
La inclusión de S-->Vjkbik+1 a P’ ha utilizado necesariamente la segunda línea de nuestra
construcción a partir de Vjk-->bik+1 en P, con Vjk≠S.
La inclusión de Vjk-->Vjk-1bik a P’ ha utilizado la primera línea de nuestra construcción a partir
de Vjk-1-->bikVjk en P, con Vjk-1≠S. No ha podido usarse la segunda línea pues en ese caso
Vjk=S lo que ya está descartado.
Podemos seguir desarrollando un razonamiento análogo recurrente para indicar que:
La inclusión de Vj3-->Vj2bi3 a P’ ha utilizado la primera línea de nuestra construcción a partir
de Vj2-->bi3Vj3 en P, con Vj2≠S. No ha podido usarse la segunda línea pues en ese caso Vj3=S
lo que ya está descartado.
La inclusión de Vj2-->Vj1bi2 a P’ ha utilizado la primera línea de nuestra construcción a partir
La inclusión de Vj1-->bi1 a P’ ha utilizado la cuarta línea de nuestra construcción a partir de
S-->bi1Vj1 en P. No ha podido usarse la tercera línea pues en ese caso Vj1=S lo que ya está
descartado.
Así pues, tenemos en P las producciones:
Vjk-->bik+1
Vjk-1-->bikVjk
...
Vj2-->bi3Vj3
Vj1-->bi2Vj2
S-->bi1Vj1
Donde ningún Vjh es S.
Luego, la siguiente derivación es posible en G:
S=>bi1Vj1=>bi1bi2Vj2=>bi1bi2bi3Vj3=>...=>bi1bi2bi3...bikVjk=>bi1bi2bi3...bikbik+1
Es decir, u ∈ L(G). Lo que prueba que L(G’) ⊆ L(G).
Ambas inclusiones demuestran que L(G’)=L(G), y es claro que G’ es una GRLI.
Ejemplo:
A partir de la GRLD G (sólo mostramos P):
P:
S --> aX
X --> aX nótese que G no incluye a su símbolo raíz en
X --> bX la parte derecha de ninguna de sus producciones
X --> b
escriba una GRLI G’ que genere el mismo lenguaje que G.
Construimos así G’=({S,X},{a,b},P’,S)
80
P’:
X --> a
X --> Xa
X --> Xb
S --> Xb
Construcción de una GRLD a partir de un AFD A

En esta construcción es claro que si el AFD acepta la cadena vacía, la GRLD no podrá generar
dicha cadena de acuerdo a nuestras convenciones. Esta salvedad debe notarse en nuestro
enunciado como se muestra a continuación.
Sea el AFD A=(K, Σ, δ, q1, F) tal que T(A)=L, entonces podemos construir una GRLD G tal
que L(G) = T(A) – {λ}.
Demostración:
Construimos G así: G=(K, Σ, P, q1)
P = { qi-->aqj / δ(qi,a)=qj } ∪ { qi-->a / δ(qi,a)=qj y qj ∈ F}
Es exactamente lo mismo si escribimos P = { qi-->aqj / δ (qi,a)=qj } ∪ { qi-->a / δ(qi,a) ∈ F}
Nótese que en este caso los No Terminales no son letras mayúsculas usuales sino símbolos del
tipo q1,q2, etc., y que el símbolo raíz de la GRLD no es S sino q1.
i) Sea u ∈ T(A) (u≠λ), es decir, δ*(q1,u) ∈ F.
Si la transición desde q1 hacia un estado final consumiendo la cadena u se hace en un
movimiento entonces la cadena u es de un símbolo y δ*(q1,u)=qj con qj ∈ F; se sabe que
δ*(q1,u)=δ(q1,u) cuando u es de un símbolo, luego δ(q1,u)=qj con qj ∈ F, o lo que es lo mismo,
δ(q1,u) ∈ F; por lo tanto, por la construcción de P, q1-->u ∈ P, así q1=>*u con una producción
de P, es decir, la cadena u ∈ L(G), pues q1 es el símbolo raíz de G.
Si la transición desde q1 hacia un estado final consumiendo la cadena u se hace en más de un
movimiento, podemos desglosar esta transición, suponiendo lícitamente que u=bi1bi2...bikbik+1
con bij ∈ T, así:
(q1,bi1bi2...bikbik+1)|--(q j1,bi2bi3...bikbik+1) utilizando la regla δ(q1,bi1)=qj1
|--(q j2,bi3...bikbik+1) utilizando la regla δ(q j1,bi2)=qj2
...
|--(q jk-1,bikbik+1) utilizando la regla δ(q jk-2,bik-1)=qjk-1
|--(q jk,bik+1) utilizando la regla δ(q jk-1,bik)=qjk
|--(q j,λ) utilizando la regla δ(q jk,bik+1)=qj con qj ∈ F
Por nuestra construcción, a partir de dichas reglas de transición, debemos tener las siguientes
producciones en P:
q1-->bi1qj1
q j1-->bi2qj2
...
q jk-2-->bik-1qjk-1
q jk-1-->bikqjk
q jk-->bik+1
81
Y por lo tanto la siguiente derivación es posible en G:
q1=>bi1qj1=>bi1bi2qj2 =>...=>bi1bi2...bik-2q jk-2=>bi1bi2...bik-2bik-1qjk-1
=>bi1bi2...bik-2bik-1bikqjk=>bi1bi2...bik-2bik-1bikbik+1
Es decir, q1=>*bi1bi2...bik-2bik-1bikbik+1, es decir, u ∈ L(G).
Lo que prueba que T(A)-{λ} ⊆ L(G).
ii) Inversamente, sea u ∈ L(G):
Si q1=>u en un paso de derivación, ello sucede utilizando la producción q1-->u ∈ P, pero por
construcción esta producción está en P sólo cuando en A tenemos la regla δ(q1,u)=qj (qj ∈ F),
así δ*(q1,u) ∈ F, es decir, u ∈ T(A).
Si q1=>*u en G dando más de un paso, podemos desglosar esta derivación, suponiendo
q1=>bi1qj1 donde se ha debido utilizar la producción q1-->bi1qj1 ∈ P
=>bi1bi2qj2 donde se ha debido utilizar la producción qj1-->bi2qj2 ∈ P
...
=>bi1bi2...bik-2q jk-2 donde se ha debido utilizar la producción qjk-3-->bik-2qjk-2 ∈ P
=>bi1bi2...bik-2bik-1qjk-1 donde se ha debido utilizar la producción qjk-2-->bik-1qjk-1 ∈ P
=>bi1bi2...bik-2bik-1bikqjk donde se ha debido utilizar la producción qjk-1-->bikqjk ∈ P
=>bi1bi2...bik-2bik-1bikbik+1 donde se ha debido utilizar la producción qjk-->bik+1 ∈ P
Estas producciones están en P fruto de nuestra construcción y su presencia se debe solamente
a que en A existen las siguientes reglas de transición:
δ(q1,bi1)=qj1
δ(q j1,bi2)=qj2
...
δ(q jk-3,bik-2)=qjk-2
δ(q jk-2,bik-1)=qjk-1
δ(q jk-1,bik)=qjk
δ(q jk,bik+1)=qj con qj ∈ F
A partir de estas reglas es fácil describir una serie de transiciones así:
(q1,bi1bi2...bikbik+1)|--(q j1,bi2bi3...bikbik+1) utilizando la regla δ(q1,bi1)=qj1
|--(q j2,bi3...bikbik+1) utilizando la regla δ(q j1,bi2)=qj2
...
|--(q jk-1,bikbik+1) utilizando la regla δ(q jk-2,bik-1)=qjk-1
|--(q jk,bik+1) utilizando la regla δ(q jk-1,bik)=qjk
|--(q j,λ) utilizando la regla δ(q jk,bik+1)=qj con qj ∈ F
Es decir, (q1,bi1bi2...bikbik+1)|-- *(q j,λ) con qj ∈ F, es decir, u ∈ T(A).
Lo que prueba que L(G) ⊆ T(A).
Recuérdese que en la demostración de T(A)-{λ} ⊆ L(G) se descarta el caso u=λ.
Ambas inclusiones junto al último comentario demuestran que L(G)=T(A)-{λ}, y es claro que
G es una GRLD.
82
Ejemplo:
Sea A=({q1,q2}, {a}, δ, q1, {q1})
δ:
δ(q1,a)=q2
δ(q2,a)=q1
Construimos así la GRLD G=({q1,q2}, {a}, P, q1)

P:
q1-->aq2
q2-->aq1
q2-->a pues en la regla δ(q2,a)=q1, q1 ∈ F
Nótese que A acepta λ, pero G no genera λ.
Construcción de una GRLD a partir de un AFN A

En esta construcción es claro que si el AFN acepta la cadena vacía, la GRLD no podrá generar
dicha cadena de acuerdo a nuestras convenciones. Esta salvedad debe notarse en nuestro
enunciado.
Sea el AFN A=(K, Σ, d, q1, F) tal que T(A)=L entonces podemos construir una GRLD G tal
que L(G)=T(A) - {λ}.
Demostración:
Construimos G=(K, Σ, P, q1) así:
P = { qi-->aqj / qj ∈ d(qi,a) } ∪ { qi-->a / qj ∈ d(qi,a) y qj ∈ F}
Nótese que en este caso los No Terminales no son letras mayúsculas usuales sino símbolos del
tipo q1,q2, etc., y que el símbolo raíz de la GRLD no es S sino q1.
i) Sea u ∈ T(A) (u≠λ), es decir, d*(q1,u) ∩ F ≠ ∅.
Si la transición desde q1 hacia algún estado final consumiendo la cadena u se hace en un
movimiento entonces la cadena u es de un símbolo y qj ∈ d*(q1,u) con qj ∈ F; se sabe que
d*(q1,u)=d(q1,u) cuando u es de un símbolo, luego qj ∈ d(q1,u) con qj ∈ F; por lo tanto, por la
construcción de P, q1-->u ∈ P, así q1=>*u con una producción de P, luego u ∈ L(G), pues q1
es el símbolo raíz de G.
Si la transición desde q1 hacia algún estado final consumiendo la cadena u se hace en más de
un movimiento, podemos desglosar estas transiciones, suponiendo lícitamente que
u=bi1bi2...bikbik+1 con bij ∈ T, de la siguiente manera, donde debe tenerse en cuenta que esta es
una de las transiciones posibles –la que nos lleva de q1 a un estado final qj- pues por el no
determinismo el árbol de transiciones puede tener muchas ramas más:
(q1,bi1bi2...bikbik+1)|--(q j1,bi2bi3...bikbik+1) utilizando una regla donde qj1 ∈ d(q1,bi1)
|--(q j2,bi3...bikbik+1) utilizando una regla donde qj2 ∈ d(q j1,bi2)
...
|--(q jk-1,bikbik+1) utilizando una regla donde qjk-1 ∈ d(q jk-2,bik-1)
|--(q jk,bik+1) utilizando una regla donde qjk ∈ d(q jk-1,bik)
|--(q j,λ) utilizando una regla donde qj ∈ d(q jk,bik+1) con qj ∈ F
83
Por nuestra construcción, a partir de dichas reglas de transición, debemos tener las siguientes
producciones en P:
q1-->bi1qj1
q j1-->bi2qj2
...
q jk-2-->bik-1qjk-1
q jk-1-->bikqjk
q jk-->bik+1
q1=>bi1qj1=>bi1bi2qj2 =>...=>bi1bi2...bik-2q jk-2=>bi1bi2...bik-2bik-1qjk-1
=>bi1bi2...bik-2bik-1bikqjk=>bi1bi2...bik-2bik-1bikbik+1
*
Es decir, q1=> bi1bi2...bik-2bik-1bikbik+1, es decir, u ∈ L(G).
Lo que prueba que T(A)-{λ} ⊆ L(G).
ii) Inversamente, sea u ∈ L(G):
Si q1=>u en un paso de derivación, ello sucede utilizando la producción q1-->u ∈ P, pero por
construcción esta producción está en P sólo cuando en A tenemos una regla de transición
d(q1,u) tal que qj ∈ d(q1,u) con qj ∈ F; por un resultado ya visto se sabe que d(q1,u)=d*(q1,u)
cuando u es de un símbolo, entonces qj ∈ d*(q1,u) con qj ∈ F, luego d*(q1,u) ∩ F ≠ ∅, es
decir, u ∈ T(A).
Si q1=>*u en G dando más de un paso, podemos desglosar esta derivación, suponiendo
q1=>bi1qj1 donde se ha debido utilizar la producción q1-->bi1qj1 ∈ P
=>bi1bi2qj2 donde se ha debido utilizar la producción qj1-->bi2qj2 ∈ P
...
=>bi1bi2...bik-2q jk-2 donde se ha debido utilizar la producción qjk-3-->bik-2qjk-2 ∈ P
=>bi1bi2...bik-2bik-1qjk-1 donde se ha debido utilizar la producción qjk-2-->bik-1qjk-1 ∈ P
=>bi1bi2...bik-2bik-1bikqjk donde se ha debido utilizar la producción qjk-1-->bikqjk ∈ P
=>bi1bi2...bik-2bik-1bikbik+1 donde se ha debido utilizar la producción qjk-->bik+1 ∈ P
Estas producciones están en P fruto de nuestra construcción y su presencia se debe solamente
a que en A existen reglas de transición así:
d(q1,bi1) con qj1 ∈ d(q1,bi1)
d(q j1,bi2) con qj2 ∈ d(q j1,bi2)
...
d(q jk-3,bik-2) con qjk-2 ∈ d(q jk-3,bik-2)
d(q jk-2,bik-1) con qjk-1 ∈ d(q jk-2,bik-1)
d(q jk-1,bik) con qjk ∈ d(q jk-1,bik)
d(q jk,bik+1) con qj ∈ d(q jk,bik+1) y qj ∈ F
A partir de estas reglas es fácil describir una serie de transiciones así –aunque por el no
determinismo es posible que existan otras ramas en el árbol de transiciones-:
(q1,bi1bi2...bikbik+1)|--(q j1,bi2bi3...bikbik+1)
|--(q j2,bi3...bikbik+1)|-- ... |--(q jk-1,bikbik+1)|--(q jk,bik+1)|--(q j,λ)
84
Es decir, una de las ramas del árbol de transiciones es tal que podemos escribir
(q1,bi1bi2...bikbik+1)|-- *(q j,λ) con qj ∈ F, es decir, u ∈ T(A).
Recuérdese que en la demostración de T(A)-{λ} ⊆ L(G) se descarta el caso u=λ.
Ambas inclusiones junto al último comentario demuestran que L(G)=T(A)-{λ}, y es claro que
G es una GRLD.
Ejemplo:
Sea A=({q1,q2,q3}, {a,b,c}, d, q1, {q1,q2,q3})
d:
d(q1,a)={q2,q3}
d(q2,b)={q2}
d(q3,c)={q3}
Construimos así la GRLD G=({q1,q2,q3}, {a,b,c}, P, q1)

P:
q1-->aq2 que viene de la regla de transición 1
q1-->aq3 que viene de la regla de transición 1
q2-->bq2 que viene de la regla de transición 2
q3-->cq3 que viene de la regla de transición 3
q1-->a que viene de la regla de transición 1
q2-->b que viene de la regla de transición 2
q3-->c que viene de la regla de transición 3
Nótese que A acepta λ, pero G no genera λ.
Construcción de un AFN A a partir de una GRLD G

Nótese que en esta construcción los estados del AFN no son como siempre q1, q2, etc.
-excepto el nuevo estado qf- sino elementos de N (es decir, S, X, etc.) y que el estado inicial
no es q1 sino S.
Sea G=(N, T, P, S) -qf ∉ N- una GRLD tal que L(G)=L entonces podemos construir un AFN
A tal que T(A)=L(G).
Demostración:
Construimos el AFN A así:
A=(N ∪ {qf}, T, d, S, {qf})
qf es un nuevo elemento y es el único estado final
d:
Y ∈ d(X,a) si X-->aY ∈ P
qf ∈ d(X,a) si X-->a ∈ P
i) Sea u ∈ T(A), es decir, d*(S,u) ∩ F ≠ ∅.
Si la transición desde S hacia algún estado final consumiendo la cadena u se hace en un
movimiento entonces la cadena u es de un símbolo y qf ∈ d*(S,u) con qf ∈ F; se sabe que
d*(S,u)=d(S,u) cuando u es de un símbolo, luego qf ∈ d(S,u) con qf ∈ F; por la construcción
85
de A esta regla de transición está en A solamente cuando S-->u ∈ P, así S=>*u con una
producción de P, luego u ∈ L(G).
Si la transición desde S hacia algún estado final consumiendo la cadena u se hace en más de
un movimiento, podemos desglosar estas transiciones, suponiendo lícitamente que
u=bi1bi2...bikbik+1 con bij ∈ T, de la siguiente manera, donde debe tenerse en cuenta que esta es
una de las transiciones posibles –la que nos lleva de S hacia el único estado final qf- pues por
el no determinismo el árbol de transiciones puede tener muchas ramas más:
(S,bi1bi2...bikbik+1)|--(X j1,bi2bi3...bikbik+1) utilizando una regla donde Xj1 ∈ d(S,bi1)
|--(X j2,bi3...bikbik+1) utilizando una regla donde Xj2 ∈ d(X j1,bi2)
...
|--(X jk-1,bikbik+1) utilizando una regla donde Xjk-1 ∈ d(X jk-2,bik-1)
|--(X jk,bik+1) utilizando una regla donde Xjk ∈ d(X jk-1,bik)
|--(qf,λ) utilizando una regla donde qf ∈ d(X jk,bik+1) con qf ∈ F
Por la construcción de A estas regla de transición están en A solamente cuando las siguientes
producciones están en P:
S-->bi1Xj1
X j1-->bi2Xj2
...
X jk-2-->bik-1Xjk-1
X jk-1-->bikXjk
X jk-->bik+1
S=>bi1Xj1=>bi1bi2Xj2 =>...=>bi1bi2...bik-2X jk-2=>bi1bi2...bik-2bik-1Xjk-1
=>bi1bi2...bik-2bik-1bikXjk=>bi1bi2...bik-2bik-1bikbik+1
*
Es decir, S=> bi1bi2...bik-2bik-1bikbik+1, es decir, u ∈ L(G).
Lo que prueba que T(A) ⊆ L(G).
ii) Inversamente, sea u ∈ L(G).
Si S=>u en un paso de derivación, ello sucede utilizando la producción S-->u ∈ P, entonces
por construcción en A incluimos la regla d(S,u) tal que qf ∈ d(S,u) con qf ∈ F; por un
resultado ya visto se sabe que d(S,u)=d*(S,u) cuando u es de un símbolo, luego qf ∈ d*(S,u)
con qf ∈ F, así d*(S,u) ∩ F ≠ ∅, es decir, u ∈ T(A).
Si S=>*u en G dando más de un paso, podemos desglosar esta derivación, suponiendo
S=>bi1Xj1 donde se ha debido utilizar la producción S-->bi1Xj1 ∈ P
=>bi1bi2Xj2 donde se ha debido utilizar la producción Xj1-->bi2Xj2 ∈ P
...
=>bi1bi2...bik-2bik-1Xjk-1 donde se ha debido utilizar la producción Xjk-2-->bik-1Xjk-1 ∈ P
=>bi1bi2...bik-2bik-1bikXjk donde se ha debido utilizar la producción Xjk-1-->bikXjk ∈ P
=>bi1bi2...bik-2bik-1bikbik+1 donde se ha debido utilizar la producción Xjk-->bik+1 ∈ P
Por construcción, en A incluimos las siguientes reglas:
86
d(S,bi1) con X j1 ∈ d(S,bi1)
d(X j1,bi2) con Xj2 ∈ d(X j1,bi2)
...
d(X jk-2,bik-1) con Xjk-1 ∈ d(X jk-2,bik-1)
d(X jk-1,bik) con Xjk ∈ d(X jk-1,bik)
d(X jk,bik+1) con {qf} ∈ d(X jk,bik+1)
A partir de estas reglas es fácil describir una serie transiciones así –aunque por el no
determinismo es posible que existan otras ramas en el árbol de transiciones-:
(S,bi1bi2...bikbik+1)|--(X j1,bi2bi3...bikbik+1)
|--(X j2,bi3...bikbik+1)|-- ... |--(X jk-1,bikbik+1)|--(X jk,bik+1)|--(q f,λ)
Es decir, una de las ramas del árbol de transiciones permite escribir lo siguiente
(S,bi1bi2...bikbik+1)|-- *(q f,λ) con qf ∈ F, es decir, u ∈ T(A).
Ambas inclusiones demuestran que L(G)=T(A), y es claro que A es un AFN.
Ejemplo:
Sea G=({S,B}, {a,b}, P, S)
P:
S-->aB
B-->bS
B-->b
Construimos así el AFN A=({S,B,qf }, {a,b}, d, S, {qf})

d:
d(S,a)={B} que viene de la primera producción
d(B,b)={S,qf} que viene de la segunda y tercera producciones
Construcción de un AFD A’ no reinicializable a partir de un AFD A reinicializable

Se dice que un AFD es no reinicializable si no hay ninguna transición así δ(qi,a)=q1, es decir
desde el punto de vista del diagrama de transiciones, si no llega ningún arco al estado inicial,
en caso contrario el AFD se dice reinicializable.
Sea A=(K, Σ, δ, q1, F) –q0 ∉ K- un AFD tal que T(A)=L, entonces podemos construir un
AFD A’ tal que T(A’)=T(A) y A’ es no reinicializable.
Demostración:
Construimos el AFN A’ así:
A’=(K ∪ {q0}, Σ, δ’, q0, F’)
F’ = F si q1 ∉ F
= F ∪ {q0} si q1 ∈ F
δ’:
δ’(q0,a) = δ(q1,a)
δ’(qi,a) = δ(qi,a) qi ∈ K
87
A partir de esta construcción es claro que δ ⊆ δ’ (la segunda línea de δ’ dice prácticamente
que copiemos δ), por lo tanto es obvio que si qi ∈ K entonces δ*(qi,w)=δ’*(qi,w).
También es claro que ninguna regla de transición tiene a q0 como imagen, es decir, ningún
arco llega a q0 que es el estado inicial.
Sea u=λ ∈ T(A), eso ocurre si y sólo si δ*(q1,λ)=q1 y q1 ∈ F, lo cual ocurre si y sólo si en A’
F’=F ∪ {q0}, es decir, si y sólo si δ*(q0,λ)=q0 y q0 ∈ F’, es decir, si y sólo si u=λ ∈ T(A’).
Sea u ∈ T(A) con u=bw, es decir, δ*(q1,u) ∈ F, si y sólo si
(q1,bw)|--(qh,w) utilizando la regla δ(q1,b)=qh
|--*(q j,λ) donde δ*(q h,w)=qj con qj ∈ F
Por nuestra construcción eso ocurre si y sólo si en A’ tenemos la regla δ’(q0,b)=qh[=δ(q1,b)],
y si y sólo si δ*(q h,w)=δ’*(q h,w)=qj con qj ∈ F’ (pues F ⊆ F’), es decir,
si y sólo si en A’ es posible la siguiente serie de transiciones:
(q0,bw)|--(qh,w) utilizando la regla δ’(q0,b)=qh
|--*(q j,λ) pues δ*(q h,w)=δ’*(q h,w)=qj con qj ∈ F’ (pues F ⊆ F’)
es decir si y sólo si δ’*(q0,u) ∈ F’, o lo que es lo mismo, u ∈ T(A’).
Una construcción alternativa es:

A’=(K ∪ {qf}, Σ, δ’, q1, F)
F’ = F si q1 ∉ F
= F ∪ {qf} si q1 ∈ F
δ’:
δ’(qi,a) = δ(qi,a) si δ(qi,a)≠q1
= qf en otro caso
δ’(qf,a) = δ’(q1,a)
Ejemplo:
Sea el AFD A=({q1,q2}, {a,b}, δ, q1, {q1})
δ:
δ(q1,a)=q1
δ(q1,b)=q2
δ(q2,a)=q1
δ(q2,b)=q2
Construimos así el AFD A’=({q1,q2,q0}, Σ, δ’, q0, {q1,q0})
δ’:
δ’(q0,a)=q1
δ’(q0,b)=q2
δ’(q1,a)=q1
δ’(q1,b)=q2
δ’(q2,a)=q1
δ’(q2,b)=q2
88
La construcción alternativa obtiene el siguiente AFD A’=({q1,q2,qf}, {a,b}, δ’, q1, {q1,qf})
δ’:
δ’(q1,a)=qf
δ’(q1,b)=q2
δ’(q2,a)=qf
δ’(q2,b)=q2
δ’(qf,a)=qf
δ’(qf,b)=q2
Construcción de un AFN A’ a partir de un AFD A

Sea A=(K, Σ, δ, q1, F) un AFD tal que T(A)=L entonces podemos construir un AFN A’ tal
que T(A’)=T(A).
Demostración:
A’=(K, Σ, d, q1, F)
d:
d(qi,a)={δ(qi,a)}
Sea u ∈ T(A) si u=λ entonces q1 ∈ F en el AFD si y sólo si q1 ∈ F también en el AFN y por
tanto, como d*(q1, λ)={q1}, d*(q1, λ) ∩ F ≠ ∅, es decir, u ∈ T(A’).
Sea u ∈ T(A), suponiendo lícitamente que u=bi1bi2...bik con bij ∈ T podemos desglosar la
aceptación (q1,bi1bi2...bik)|--*(q j,λ) con qj ∈ F así:
(q1,bi1bi2...bik)|--(q j1,bi2bi3...bik) utilizando la regla δ(q1,bi1)=qj1
|--(q j2,bi3...bik) utilizando la regla δ(q j1,bi2)=qj2
...
|--(q jk-1,bik) utilizando la regla δ(q jk-2,bik-1)=qjk-1
|--(q j,λ) utilizando la regla δ(q jk-1,bik)=qj con qj ∈ F en el AFD A
lo que ocurre si y sólo si en el AFN A’ tenemos –por construcción- las siguientes reglas y de
ahí la siguiente transición:
(q1,bi1bi2...bik)|--(q j1,bi2bi3...bik) utilizando la regla d(q1,bi1)={qj1}
|--(q j2,bi3...bik) utilizando la regla d(q j1,bi2)={qj2}
...
|--(q jk-1,bik) utilizando la regla d(q jk-2,bik-1)={qjk-1}
|--(q j,λ) utilizando la regla d(q jk-1,bik)={qj} con qj ∈ F en el AFN A’.
Y por tanto u ∈ T(A’).
Es decir, T(A)=T(A’)
Ejemplo:
δ:
δ(q1,a)=q2 δ(q1,b)=q2
δ(q2,a)=q2 δ(q2,b)=q2
89
Construimos así el AFN A’=({q1,q2}, {a,b}, d, q1, {q2})
d:
d(q1,a)={q2}
d(q1,b)={q2}
d(q2,a)={q2}
d(q2,b)={q2}
Nótese la importantísima diferencia formal de que las reglas tengan como imagen estados en
el caso del AFD y conjuntos de estados en el caso del AFN.
Construcción de un AFD A’ a partir de un AFN A

Sea A=(K, Σ, d, q1, F) un AFN tal que T(A)=L entonces podemos construir un AFD A’ tal
que T(A’)=T(A).
Demostración:
Construimos el AFD A’ así:
A’=(K’, Σ, δ, Q1, F’)
K’ = 2K es decir, el conjunto de estados del nuevo AFD se construye armando el conjunto de
partes de K.
Por ejemplo si K={q1,q2} entonces K’={ {q1}, {q2}, {q1,q2}, {} } = {Q1, Q2, Q3, Q4}; aunque
los conjuntos no tienen orden, nótese que nosotros siempre escribiremos el conjunto vacío
(elemento del conjunto de partes) al final y los elementos de K’ en forma organizada tal como
el ejemplo sugiere (de a uno, de a dos, de a tres, etc., todos y el vacío); también los nombres
de los estados de A’ vendrán en mayúsculas referenciando a cada elemento de 2K.
Q1 es el estado inicial del nuevo AFD y se define así Q1={q1}.
F’ = { Qi / Qi ∈ K’ y (Qi ∩ F) ≠ {} }
δ:
δ(Qi,a) =U
p ∈ Qi
d(p,a)
Recuerde que δ debe ser total.
Antes de continuar con la demostración presentaremos un ejemplo:

Sea el AFN A=({q1,q2}, {a,b}, d, q1, {q1,q2})
d:
d(q1,a)={q1}
d(q1,b)={q2}
d(q2,a)={q1,q2}
sabemos que si no se escribe d(q2,b)={}
90
Construimos el AFD A’ así:
A’=(K’, {a,b}, δ, Q1, F’)
K’={ {q1}, {q2}, {q1,q2}, {} } = {Q1, Q2, Q3, Q4}
Para construir F’ debemos averiguar cuáles Qi entran a este conjunto:
así:
Para Q1: Q1 ∩ F={q1} ∩ {q1,q2}={q1} y por tanto (Q1 ∩ F) ≠ {}, luego Q1 entra a F’
Para Q2: Q2 ∩ F={q2} ∩ {q1,q2}={q2} y por tanto (Q2 ∩ F) ≠ {}, luego Q2 entra a F’
Para Q3: Q3 ∩ F={q1,q2} ∩ {q1,q2}={q1,q2} y por tanto (Q3 ∩ F) ≠ {}, luego Q3 entra a F’
Para Q4: Q4 ∩ F={} ∩ {q1,q2}={} y por tanto (Q4 ∩ F) = {}, luego Q4 no entra a F’
Luego, F’={Q1, Q2, Q3}
δ:
δ(Q1,a) = U d(p,a) =
p ∈ Q1
U
d(p,a) = d(q1,a) = {q1} = Q1
p ∈{q1}
δ(Q1,b) = U
p ∈ Q1
d(p, b) = U
p ∈{q1}
d(p, b) = d(q1,b) = {q2} = Q2
δ(Q2,a) = U
p ∈ Q2
d(p,a) = U
p ∈{q 2 }
d(p,a) = d(q2,a) = {q1,q2} = Q3
δ(Q2,b) = U
p ∈ Q2
d(p, b) = U
p ∈{q 2 }
d(p, b) = d(q2,b) = {} = Q4
δ(Q3,a) = U
p ∈ Q3
d(p,a) = U
p ∈{q1 ,q 2 }
d(p,a) = d(q1,a) ∪ d(q2,a) = {q1} ∪ {q1,q2} ={q1,q2}= Q3
δ(Q3,b) = U
p ∈ Q3
d(p, b) = U
p ∈{q1 ,q 2 }
d(p, b) = d(q1,b) ∪ d(q2,b) = {q2} ∪ {} = {q2} = Q2
δ(Q4,a) = U
p ∈ Q4
d(p,a) = U
p ∈{}
d(p,a) = {} = Q4
δ(Q4,b) = U
p ∈ Q4
d(p, b) = U
p ∈{}
d(p, b) = {} = Q4
Resumiendo, el AFD A’=({Q1, Q2, Q3, Q4}, {a,b}, δ, Q1, {Q1, Q2, Q3})
δ:
δ(Q1,a) = Q1
δ(Q1,b) = Q2
δ(Q2,a) = Q3
δ(Q2,b) = Q4
δ(Q3,a) = Q3
δ(Q3,b) = Q2
δ(Q4,a) = Q4
δ(Q4,b) = Q4
91
Cuya gráfica es:
Retomemos la demostración, probaremos que δ∗(Q1,u)=d∗(q1,u), esto se hace por inducción

sobre la longitud de u.
Caso base:
|u|=0, es decir u=λ
δ∗(Q1,u) = δ∗(Q1,λ) pues u=λ
= Q1 por definición de δ∗
= {q1} por definición de Q1
= d (q1,λ) por definición de d∗
∗
= d∗(q1,u) pues u=λ

El enunciado es cierto para cadenas u de longitud |u|=k.
Paso inductivo:
Sea u una cadena tal que su longitud es |u|=k+1. Luego, lícitamente se puede reescribir u así
u=va, donde v es una cadena de longitud |v|=k.
δ∗(Q1,u) = δ∗(Q1,va) pues u=va
∗
= δ(δ (Q1,v),a) por definición de δ∗
= δ(d∗(q1,v),a) por hipótesis inductiva
= U d(p,a)
p ∈ d *( q1 , v )
por la forma de construir δ,
recuerde que d∗(q1,v) es un conjunto de estados

∗
= d (q1,va) por definición de d∗
= d∗(q1,u) pues u=va
Ahora bien, ya sabemos que δ∗(Q1,u)=d∗(q1,u), lo que permite decir lo siguiente:
u ∈ T(A) si y sólo si (d∗(q1,u) ∩ F) ≠ {}
es decir, si y sólo si (δ∗(Q1,u) ∩ F) ≠ {}
lo que sucede –por construcción- si y sólo si δ∗(Q1,u) ∈ F’
es decir, si y sólo si u ∈ T(A’).
Lo que demuestra que T(A)=T(A’), y es claro que A’ es un AFD.
Las últimas dos construcciones muestran que siempre que un lenguaje es aceptado por un
AFN también es aceptado por un AFD (y viceversa), es decir, L es aceptado por un AFN si y
sólo si L es aceptado por un AFD, lo que algunos denominan equivalencia entre AFN’s y
AFD’s.
92
Sorprendentemente los AFN’s –aunque parecen- no son más poderosos que los AFD’s.
Hay ciertos casos en los que la construcción de un AFD a partir de un AFN se simplifica
(puede retomarse la misma idea también con λ-AFN’s); considere por ejemplo el siguiente
AFN A=({q1,q2}, {a,b}, d, q1, {q2}) d: d(q1,a)=d(q1,b)=d(q2,a)={q2}
No es que haya no determinismo -al contrario, dado un estado y un símbolo el siguiente
estado está bien determinado salvo para el estado q2 y el símbolo b- sino que únicamente hay
ausencia de algunas reglas de transición, falta(n) algún(os) par(es) estado/símbolo que
llegue(n) a -o cuya imagen sea- un único estado; cierta literatura denomina a este tipo de
autómatas ‘AFD’s incompletos’ (siguiendo esta línea se define el determinismo cuando
|d(qi,cj)|≤1); nosotros los seguiremos llamando AFN’s, y su conversión a AFD requiere
simplemente la inclusión de las reglas de transición que faltan, como indicamos ahora.
Dado un AFN A=(K, Σ, d, q1, F) del tipo descrito con |K|=n, se construye así el AFD
A’=(K ∪ {qn+1}, Σ, δ, q1, F) tal que T(A)=T(A’)
δ:
δ(qn+1,a) = qn+1 a∈Σ
δ(qi,a) = qj si d(qi,a)={qj}
= qn+1 si d(qi,a)={}
qn+1 se denomina estado muerto o estado trampa y también suele denotarse con qm.
Ejemplo:
Sea el AFN A=({q1,q2}, {a,b}, d, q1, {q2}) d: d(q1,a)=d(q1,b)=d(q2,a)={q2}
Construimos así el AFD A’=({q1,q2,qm}, {a,b}, δ, q1, {q2})

δ:
δ(qm,a)=δ(qm,b)=qm
δ(q1,a)=δ(q1,b)=δ(q2,a)=q2
δ(q2,b)=qm
En esta y en la siguiente conversión es evidente que los autómatas construidos aceptan el

mismo lenguaje que el autómata de origen.
Construcción de un AFD A’ con el alfabeto extendido a partir de un AFD A

En la misma línea que la anterior conversión puede ser útil, dado un AFD A, construir un
AFD A’ que acepte el mismo lenguaje pero cuyo alfabeto de entrada sea más grande.
Dado el AFD A=(K, Σ, δ, q1, F) construimos el AFD A’ tal que T(A)=T(A’) así:
A’=(K ∪ {qm}, Σ’, δ’, q1, F) donde Σ ⊂ Σ’
δ’:
δ’(qi,a) = δ(qi,a) qi ∈ K, a ∈ Σ
δ’(qi,a) = qm qi ∈ K, a ∈ Σ’-Σ
δ’(qm,a) = qm a ∈ Σ’
93
Ejemplo:
Dado el AFD A=({q1,q2}, {a,b}, δ, q1, {q2})
δ:
δ(q1,a)=δ(q1,b)=δ(q2,a)=δ(q2,b)=q2
Construimos así el AFD A’=({q1,q2,qm}, {a,b,c}, δ’, q1, {q2}) nótese el alfabeto {a,b,c}
δ’:
δ’(q1,a)=δ’(q1,b)=δ’(q2,a)=δ’(q2,b)=q2
δ’(q1,c)=δ’(q2,c)=qm
δ’(qm,a)=δ’(qm,b)=δ’(qm,c)=qm
Este resultado se puede utilizar para hacer iguales los alfabetos de entrada de dos AFD’s
distintos A1 y A2, con alfabetos Σ1 y Σ2 respectivamente (Σ1 ≠ Σ2), podemos construir los
autómatas A’1 y A’2, con el alfabeto extendido Σ’=(Σ1 ∪ Σ2), de manera que A’1 y A’2
trabajan con el mismo alfabeto.
Construcción de un AFN A’ a partir de un λ-AFN A

Sea A=(K, Σ, d, q1, F) un λ-AFN tal que T(A)=L entonces podemos construir un AFN A’ tal
que T(A’)=T(A).
Demostración:
A’=(K, Σ, d’, q1, F’)
 F ∪ {q 1} si λ−cierre({q 1}) ∩ F ≠ ∅
F’= 
F en otro caso
d’:
d’(qi,a) = d∗(qi,a)
Si recordamos la definición de d∗ para λ-AFN’s tenemos que:

   
d’(qi,a) = λ-cierre  U d(p,a) = λ-cierre 
  U d(p,a)

 p ∈ d*( q i ,λ )   p ∈ λ−cierr e({q i }) 
Antes de continuar con la demostración presentaremos un ejemplo:
Sea el λ−AFN A = ({q1,q2,q3}, {b,c}, d, q1, {q1,q2,q3})
d: d(q1,λ)={q2,q3} d(q2,b)={q2} d(q3,c)={q3}
94
A’=({q1,q2,q3}, {b,c}, d’, q1, F’)
F’={q1,q2,q3} pues el λ−cierre({q1})={q1,q2,q3} y por tanto (λ−cierre({q1}) ∩ F) ≠ ∅
d’:
   
d’(q1,b) = λ-cierre  U d(p, b) = λ-cierre  U d(p, b)
 p ∈ λ−cierr e({q1})   p ∈ {q1 ,q 2 ,q 3} 
= λ-cierre(d(q1,b) ∪ d(q2,b) ∪ d(q3,b))
= λ-cierre(∅ ∪ {q2} ∪ ∅) =λ-cierre({q2}) = {q2}
   
d’(q1,c) = λ-cierre  U d(p,c) = λ-cierre  U d(p,c)
 p ∈ λ−cierr e({q1})   p ∈ {q1 ,q 2 ,q 3} 
= λ-cierre(d(q1,c) ∪ d(q2,c) ∪ d(q3,c))
= λ-cierre(∅ ∪ ∅ ∪ {q3}) =λ-cierre({q3}) = {q3}
   
 p ∈ λ−cierr e({q 2 })   p ∈ {q 2 } 
= λ-cierre(d(q2,b))
= λ-cierre({q2}) = {q2}
   
d’(q2,c) = λ-cierre  U d(p,c) = λ-cierre  U d(p,c)
 p ∈ λ−cierr e({q 2 })   p ∈ {q 2 } 
= λ-cierre(d(q2,c))
= λ-cierre(∅) = {}
   
 p ∈ λ−cierr e({q 3})   p ∈ {q 3} 
= λ-cierre(d(q3,b))
= λ-cierre(∅) = {}
   
d’(q3,c) = λ-cierre  U d(p,c) = λ-cierre 
  U d(p,c)

 p ∈ λ−cierr e({q 3})   p ∈ {q 3} 
= λ-cierre(d(q3,c))
= λ-cierre({q3}) = {q3}
Resumiendo –no anotamos las reglas de transición cuya imagen es el conjunto vacío-:
A’=({q1,q2,q3}, {b,c}, d’, q1, {q1,q2,q3})
d’:
d’(q1,b)={q2} d’(q1,c)={q3}
d’(q2,b)={q2} d’(q3,c)={q3}
95
Cuya gráfica es:
Nótese la particularidad de que

i) En el λ−AFN A, d∗(q1,λ)=λ−cierre({q1})={q1,q2,q3}
ii) En el AFN A’, d’∗(q1,λ)={q1}
Es decir, como muestra este ejemplo para la cadena u=λ, no siempre d∗(q1,λ)=d’∗(q1,λ)
Resta probar que T(A)=T(A’)

Dividiremos ello en dos partes el caso de la cadena u=λ y el resto de los casos.
Cuando u=λ y u ∈ T(A) entonces
d∗(q1,λ) ∩ F ≠ ∅, pero d∗(q1,λ)=λ−cierre({q1}), entonces
λ−cierre({q1}) ∩ F ≠ ∅ y por lo tanto, por construcción,
F’=F ∪ {q1}, es decir
q1 ∈ F’, y por lo tanto -dado que d’∗(q1,λ)={q1}- tenemos que
d’∗(q1,λ) ∩ F’ ≠ ∅, es decir,
u ∈ T(A’).
Inversamente si u=λ y u ∈ T(A’), entonces
d’∗(q1,λ) ∩ F’ ≠ ∅, es decir dado que por definición d’∗(q1,λ)={q1}
{q1} ∩ F’ ≠ ∅, lo que indica que q1 ∈ F’, ello significa –por construcción- que
λ−cierre({q1}) ∩ F ≠ ∅ (nótese que si q1 ∈ F esto también es cierto),
pero entonces, dado que d∗(q1,λ)=λ−cierre({q1}),
∗
d (q1,λ) ∩ F ≠ ∅, es decir,
u ∈ T(A).
El caso |u|>0 requiere algunos interesantes y no muy simples resultados previos. Veamos.
Probaremos primero que λ-cierre(λ-cierre(C))=λ-cierre(C).
Para ello debemos recordar la definición recursiva del λ-cierre(C) y utilizaremos lo que se
denomina una prueba por inducción estructural.
De la definición (inciso i) es claro que λ-cierre(C)⊆λ-cierre(λ-cierre(C)).
Mostraremos ahora que si q∈λ-cierre(λ-cierre(C)) entonces q∈λ-cierre(C).
Caso base: Debemos mostrar (trabajando el inciso i) que si q∈λ-cierre(C) entonces
q∈λ-cierre(C), lo que es obvio.
Hipótesis inductiva: Si q∈λ-cierre(λ-cierre(C)) entonces q∈λ-cierre(C)
96
Paso inductivo: (Trabajaremos el inciso ii) Sea p∈λ-cierre(λ-cierre(C)), ello debe suceder
porque p∈d(q,λ) con q∈λ-cierre(λ-cierre(C)). Pero entonces, por hipótesis inductiva,
q∈λ-cierre(C) y como p∈d(q,λ), precisamente por el inciso ii, p∈λ-cierre(C).
Esto nos ayuda a utilizar un resultado valioso, en los λ-AFN’s: λ-cierre(d∗(qi,w))= d∗(qi,w)
Ello es evidente pues si w=λ, tenemos que
λ-cierre(d∗(qi,λ)) = λ-cierre(λ-cierre({qi})) por definición de d∗
= λ-cierre({qi}) por el resultado que se acaba de probar
∗
= d (qi,λ) por definición de d∗
Si w=ua, tenemos que
λ-cierre(d∗(qi,w)) = λ-cierre(d∗(qi,ua))
 
= λ-cierre(λ-cierre  U d(p,a) ) por definición de d
∗
 p ∈ d*( q i ,u ) 
 
= λ-cierre  U d(p,a) por el resultado que se acaba de probar
 p ∈ d*( q i ,u ) 
= d∗(qi,ua) = d∗(qi,w)
Ahora probaremos que si C⊆Q, entonces λ-cierre(C)⊆λ-cierre(Q), es decir, dado que C⊆Q
mostraremos que si q∈λ-cierre(C) entonces q∈λ-cierre(Q).
Caso base: Es claro, de la definición (inciso i), que Q⊆λ-cierre(Q); como tenemos que C⊆Q,
resulta que C⊆λ-cierre(Q), es decir, que si q∈C entonces q∈λ-cierre(Q).
Hipótesis inductiva: Si q∈λ-cierre(C) entonces q∈λ-cierre(Q)
Paso inductivo: (Trabajaremos el inciso ii) Sea p∈λ-cierre(C), ello debe suceder porque
p∈d(q,λ) con q∈λ-cierre(C). Pero entonces, por hipótesis inductiva, q∈λ-cierre(Q) y como
p∈d(q,λ), precisamente por el inciso ii, p∈λ-cierre(Q).
Seguidamente probaremos que λ-cierre(C ∪ Q) = λ-cierre(C) ∪ λ-cierre(Q).
Es claro que tanto C⊆(C∪Q) como Q⊆(C∪Q), por el anterior resultado entonces
λ-cierre(C)⊆λ-cierre(C∪Q) y λ-cierre(Q)⊆λ-cierre(C∪Q), de donde
λ-cierre(C) ∪ λ-cierre(Q) ⊆ λ-cierre(C∪Q).
Resta probar que λ-cierre(C∪Q) ⊆ λ-cierre(C) ∪ λ-cierre(Q), es decir, que
si q∈λ-cierre(C∪Q) entonces q∈[λ-cierre(C) ∪ λ-cierre(Q)].
Caso base: Si q∈(C∪Q), entonces [q∈C ó q∈Q], luego (inciso i de la definición de λ-cierre)
[q∈λ-cierre(C) ó q∈λ-cierre(Q)], es decir, q∈[λ-cierre(C) ∪ λ-cierre(Q)].
Hipótesis inductiva: Si q∈λ-cierre(C∪Q) entonces q∈[λ-cierre(C) ∪ λ-cierre(Q)].
Paso inductivo: (Trabajaremos el inciso ii de la definición de λ-cierre).
Sea p∈λ-cierre(C∪Q), ello debe suceder porque p∈d(q,λ) con q∈λ-cierre(C∪Q). Pero
entonces, por hipótesis inductiva, q∈[λ-cierre(C) ∪ λ-cierre(Q)] y como p∈d(q,λ),
precisamente por el inciso ii, p∈[λ-cierre(C) ∪ λ-cierre(Q)].
Estábamos queriendo demostrar que en la construcción del AFN A’ a partir del λ-AFN A
T(A)=T(A’) y restaba demostrar que esto es así en el caso |u|>0.
97
Ello se simplifica si evidenciamos que d’∗(q1,u) = d∗(q1,u), lo que haremos por inducción
sobre |u|.
Caso base.
|u|=1, es decir, u=a
d’∗(q1,a) = d’(q1,a) por un resultado ya conocido
= d∗(q1,a) por la forma de construir d’
Hipótesis inductiva.
El resultado se mantiene para |u|=k
Paso inductivo.
Sea |u|=k+1, podemos suponer lícitamente que u=wa con |w|=k, luego
d’∗(q1,wa) = Ud'(p,a) por definición de d’∗
p ∈ d '*( q1 , w )
= U d' (p,a) por hipótesis inductiva

p ∈ d *( q1 , w )
= U d*(p,a) por la forma de construir d’

p ∈ d *( q1 , w )
supongamos ahora -lícitamente- que d∗(q1,w)={qj1,..., qjn}

= d∗(qj1,a) ∪...∪ d∗(qjn,a)
   
   
= λ-cierre  U d(p,a) ∪...∪ λ-cierre  U d(p,a) por definición de d∗
 p ∈ d*( q ,λ )   p ∈ d*( q ,λ ) 
 j1   jn 
   
   
= λ-cierre  U d(p,a) ∪...∪ λ-cierre  U d(p,a) por definición de d∗
 p ∈ λ−cierre({q })   p ∈ λ−cierre({q }) 
 j1   jn 
nótese que tenemos lo siguiente: λ-cierre(conjunto) unión λ-cierre(conjunto), etc.
podemos utilizar λ-cierre(C ∪ Q)=λ-cierre(C) ∪ λ-cierre(Q), ya demostrado (**)
 
 
= λ-cierre  U
d(p,a) ∪...
 p ∈ λ−cierre({q })
U
d(p,a)
p ∈ λ−cierre ({q jn }) 
 j1 
 
 
= λ-cierre  U d(p,a) 
 p ∈ λ−cierre({q }) ∪ ...∪ λ−cierre({q })
operando sobre conjuntos
 j1 jn 
 
 
= λ-cierre  U
d(p,a)  utilizando otra vez (**)
 p ∈ λ−cierre({q } ∪ ...∪ {q })
 j1 jn 
dado que d∗(q1,w)={qj1,..., qjn}={qj1}∪...∪{qjn}
98
 
= λ-cierre  U d(p,a)

 p ∈ λ−cierre( d *( q1 , w )) 
 
= λ-cierre  U d(p,a)

pues ya demostramos que λ-cierre(d∗(q1,w))=d∗(q1,w)
 p ∈ d *( q1 , w ) 
= d*(q1,wa) por definición de d*
Los tres casos confirman que d’ (q1,u) = d∗(q1,u) para |u|>0.
∗
Ahora bien, sea u ∈ T(A), es decir d∗(q1,u) ∩ F ≠ ∅, pero entonces d’∗(q1,u) ∩ F ≠ ∅ y como
F ⊆ F’, entonces d’∗(q1,u) ∩ F’ ≠ ∅, es decir, u ∈ T(A’).
Inversamente, sea u ∈ T(A’), es decir d’∗(q1,u) ∩ F’ ≠ ∅, pero entonces d∗(q1,u) ∩ F’ ≠ ∅ y
como F’=F (trataremos enseguida el caso F’=F ∪ {q1}) entonces d∗(q1,u) ∩ F ≠ ∅, es decir,
u∈T(A).
Cuando F’=F ∪ {q1} y la intersección d∗(q1,u) ∩ F’ cae sólo en elementos de F el argumento
es el mismo.
En el último caso de análisis supongamos que F’=F ∪ {q1} y q1 ∉ F (cuando q1 ∈ F, F’=F lo
que nos remite a algo ya tratado). q1 se incluye a F’ porque λ−cierre({q1}) ∩ F ≠ ∅, en este
caso hay un(os) estado(s) en λ−cierre({q1}) y en F diferente(s) de q1, vamos a mostrar que
el(ellos) está(n) en d∗(q1,u), de este modo d∗(q1,u) ∩ F ≠ ∅, y por lo tanto u ∈ T(A).
En efecto, sabemos que d’∗(q1,u) ∩ F’ ≠ ∅, es decir, d∗(q1,u) ∩ F’ ≠ ∅, supongamos también
que la interseción se da (también) en q1 (en otro caso la intersección se da sólo con elementos
de F lo cual ya fue tratado), es decir q1 ∈ d∗(q1,u), o sea podemos escribir lo siguiente:
d∗(q1,u)={q1} ∪ {elrestoded∗(q1,u)}. Sabemos que λ-cierre(d∗(q1,u))=d∗(q1,u), de ahí es lícito
escribir d∗(q1,u)=λ-cierre(d∗(q1,u))= λ-cierre({q1} ∪ {elrestoded∗(q1,u)})
= λ-cierre({q1}) ∪ λ-cierre({elrestoded∗(q1,u)})
El último paso se dio por un resultado ya visto. Pero λ-cierre({q1}) ∩ F ≠ ∅ y q1 ∉ F, es decir
que en d∗(q1,u) hay elementos de F –que no son q1- que es lo que queríamos probar.
Así T(A)=T(A’).
Un modo alterno de construir el AFN A’ que utiliza la matriz R+ es como sigue.

A partir del λ-AFN A=(K, Σ, d, q1, F) construimos el AFN A’ así:
A’=(K, Σ, d’, q1, F’)
F’=F ∪ {qi / (qi,qf) ∈ R+ ; qf ∈ F}
Es decir, a los estados de F se añaden los estados correspondientes a las filas de R+ tales
que su intersección con alguna columna f (correspondiente al estado qf ∈ F) tenga el
valor 1.
d’:
d’(qi,a) = d(qi,a) U d(q j ,a)
( q i ,q j ) ∈ R +
99
Ejemplo:
Con el mismo λ−AFN A = ({q1,q2,q3}, {b,c}, d, q1, {q1,q2,q3})
d:
d(q1,λ)={q2,q3}
d(q2,b)={q2}
d(q3,c)={q3}
El AFN A’=({q1,q2,q3}, {b,c}, d’, q1, F’)
0 1 1
Tenemos ya calculado R = 0 0 0 y por tanto
+
0 0 0
F’={q1,q2,q3}
d’:
d’(q1,b) = d(q1,b) U d(q j , b) = d(q1,b) ∪ d(q2,b) ∪ d(q3,b)
( q1 , q j ) ∈ R +
hemos marcado en negrita lo que viene fruto de la expresión (qi,qj) ∈ R+

= ∅ ∪ {q2} ∪ ∅ = {q2}
En idéntica forma se construyen las otras reglas de transición mismas que pasamos a
resumir:
d’(q1,b) = {q2}
d’(q1,c) = {q3}
d’(q2,b) = {q2}
d’(q3,c) = {q3}
No anotamos las reglas d’(q2,c)=∅, d’(q3,b)=∅ porque la imagen es el conjunto vacío; en
las últimas dos reglas (d’(q2,b) y d’(q3,c)) la parte de la unión en la construcción de d’ se
hace vacía pues las filas correspondientes a q2 y q3 en R+ son de ceros.
Es interesante remarcar que ambas formas de proceder (matricial y con el λ−cierre) no
siempre construyen el mismo AFN A’ como puede comprobarse con el siguiente λ−AFN A:
sin embargo ambos métodos devuelven AFN’s equivalentes al λ−AFN de partida.

Hay una equivalencia entre AFN’s y λ-AFN’s (y por tanto también entre AFD’s), lo que
muestra de manera aún más sorprendente que los λ-AFN’s no son más poderosos que los
AFN’s ni que los AFD’s.
Construcción de un autómata a partir de una e.r. (el Teorema de Kleene parte I)

Por estar fuera del alcance de este trabajo prescindiremos de las demostraciones en algunas
partes, como en la que sigue, y nos centraremos en la descripción del proceso de obtención
del autómata.
100
Podemos construir un AFN A (denominado autómata de posición, autómata Glushkov o
autómata de McNaughton-Yamada debido a sus descubridores) a partir de una e.r. asignando
posiciones a los símbolos de dicha expresión regular. Por ejemplo sea r=a(ba) una e.r.,
designaremos las posiciones con subíndices de izquierda a derecha así: r’=a1(b2a3)
El conjunto de símbolos subindizados –denominado conjunto de posiciones- de una e.r. r,
donde los subíndices indican la posición que ocupa el símbolo en la e.r. leída de izquierda a
derecha, lo denominaremos pos(r), en nuestro ejemplo pos(r)={a1,b2,a3}. Al construir pos(r)
no colocaremos subíndices a λ ni a ∅, si están presentes en r.
Cuando una e.r. no es elemental (r=ts ó r=t+s) denotaremos con
posr(t) al subconjunto de posiciones de t que son posiciones de r; y con
posr(s) al subconjunto de posiciones de s que son posiciones de r.
Por supuesto esta idea es recurrente si a su vez t o s son e.r. no elementales, en nuestro
ejemplo r=ts con t=a1 y s=(b2a3), de este modo posr(s)={b2,a3}; a su vez s=(b2a3) es otra vez
de la forma no elemental pues s=t’s’ con s’=a3, cuyo conjunto de posiciones es {a3}, etc.
La idea ahora es asignar a cada símbolo subindizado un estado del autómata y dirigir un arco
de un estado a otro según el símbolo denotado en el estado de llegada siga o no al símbolo
denotado en el estado de partida en las cadenas en L(r). Los índices cuentan y sirven para este
propósito, en el ejemplo que tenemos una a1 nunca seguirá a una b2 pero si una a3, nótese
cómo los índices hacen cambiar el significado de estas frases pues sin índices es claro que una
a sigue a una b en la(s) cadena(s) de L(r).
La construcción del AFN exige construir los siguientes conjuntos para la e.r r –lo cual,
insistimos, requiere de la vital subindización de las posiciones-:
primer(r)={todos los primeros símbolos de cadenas en L(r)}
Para nuestro ejemplo primer(r)={a1}
último(r)={todos los últimos símbolos de cadenas en L(r)}
Para nuestro ejemplo último(r)={a3}
siguiente(r,ci)={todos los símbolos que siguen al símbolo ci en cadenas en L(r)}
Para nuestro ejemplo siguiente(r,a1)={b2}; siguiente(r,b2)={a3}; siguiente(r,a3)={}
Es claro que si la e.r. es más compleja los conjuntos a construirse requieren de más
herramientas que la simple inspección, por ejemplo en r=a*b*a*, es decir, en r’=a1*b2*a3*
no es muy inmediato ver que b2 pertenece a último(r).
Las siguientes definiciones recurrentes –que son bastante intuitivas- permiten hallar estos
conjuntos mecánicamente, en ellas ci es un símbolo subindizado de la e.r.
r=λ: primer(λ) = {}
r=∅: primer(∅) = {}
r=a: primer(a) = {a}
r=t+s: primer(t+s) = primer(t) ∪ primer(s)
r=t*: primer(t*) = primer(t)
r=ts: primer(ts) = primer(t) ∪ primer(s) si λ ∈ L(t)
= primer(t) si λ ∉ L(t)
101
r=λ: último(λ) = {}
r=∅: último (∅) = {}
r=a: último(a) = {a}
r=t+s: último(t+s) = último(t) ∪ último(s)
r=t*: último(t*) = último(t)
r=ts: último(ts) = último(t) ∪ último(s) si λ ∈ L(s)
= último(s) si λ ∉ L(s)
r=λ: siguiente(λ,ci) = {}
r=∅: siguiente(∅,ci) = {}
r=a: siguiente(a,ci) = {}
r=t+s: siguiente(t+s,ci) = siguiente(t,ci) si ci ∈ posr(t)
= siguiente(s,ci) si ci ∈ posr(s)
r=t*: siguiente(t*,ci) = siguiente(t,ci) si ci ∈ posr(t)-último(t)
= siguiente(t,ci) ∪ primer(t) si ci ∈ último(t)
r=ts: siguiente(ts,ci) = siguiente(t,ci) si ci ∈ posr(t)-último(t)
= siguiente(t,ci) ∪ primer(s) si ci ∈ último(t)
= siguiente(s,ci) si ci ∈ posr(s)
Cuando la e.r. r no es elemental los conjuntos primer(t), primer(s), último(t) y último(s)

toman sus subíndices tomando como referencia los subíndices de r (una notación que
reflejaría esto sería por ejemplo primerr(t) o últimor(s), nosotros preferimos usar la notación
original), es claro que la idea se aplica recurrentemente si t o s a su vez no son elementales.
Es fácil determinar si λ ∈ L(r) o no con una ligera modificación de la función δ ya vista en las
derivadas de e.r. que puede calcularse así –donde V significa verdadero y F falso-:
δ(∅) = F
δ(λ) = V
δ(a) = F
δ(t+s) = δ(t) ∨ δ(s)
δ(t*) = V
δ(ts) = δ(t) ∧ δ(s)
Finalmente introduciremos la función ε que transforma un símbolo subindizado en un símbolo
sin subíndice, por ejemplo ε[a3]=a.
Una vez que para la e.r. r se tienen los conjuntos pos(r), primer(r), último(r) y siguiente(r,ci)
para cada ci que aparece en r se construye el AFN A así:
A=( pos(r) ∪ {q0}, Σ, d, q0, F)
Σ={ a / ci ∈ pos(r) y ε[ci]=a } o bien Σ es el alfabeto sobre el cual se construyó r
F = último(r) ∪ {q0} si λ ∈ L(r)
último(r) si λ ∉ L(r)
102
d:
d(q0,a)={ cj / cj ∈ primer(r) y ε[cj]=a }
d(ci,a)={ cj / cj ∈ siguiente(r,ci) y ε[cj]=a }
Una cualidad de esta construcción es que el autómata obtenido no tiene λ-transiciones.
Ejemplo:
Sea r=(ab+ac)d*
Construimos así el AFN A tal que T(A)=L(r)
r’=(a1b2+a3c4)d5*
pos(r)={a1,b2,a3,c4,d5}
Ahora construimos los tres conjuntos detallando sólo algunas de las partes de la construcción,
en todo caso simplemente aplicaremos lo descrito antes.
Como r=ts con t=(a1b2+a3c4) y s=d5*

Y como –aplicando la función modificada δ-
δ(t)=δ(a1b2+a3c4)=δ(a1b2) ∨ δ(a3c4)=[ δ(a1) ∧ δ(b2)] ∨ [δ(a3) ∧ δ(c4)]=[F ∧ F] ∨ [F ∧ F]=F
Es decir, como λ ∉ L(t), aplicando la definición recurrente tenemos que
primer(r)=primer(t)=primer(a1b2+a3c4)
=primer(a1b2) ∪ primer(a3c4)
=primer(a1) ∪ primer(a3c4) pues λ ∉ L(a1)
=primer(a1) ∪ primer(a3) pues λ ∉ L(a3)
={a1} ∪ {a3}={a1,a3}

Y como δ(s)=δ(d5*)=V, es decir, como λ ∈ L(s)
último(r)=último(t) ∪ último(s)=último(a1b2+a3c4) ∪ último(d5*)
=[último(a1b2) ∪ último(a3c4)] ∪ [último(d5)]
=[último(b2) ∪ último(a3c4)] ∪ [último(d5)] pues λ ∉ L(b2)
=[último(b2) ∪ último(c4)] ∪ [último(d5)] pues λ ∉ L(c4)
=[{b2} ∪ {c4}] ∪ {d5}={b2,c4,d5}

Y como
pos(t)={a1,b2,a3,c4}
último(t)=último(a1b2) ∪ último(a3c4)
=último(b2) ∪ último(a3c4) pues λ ∉ L(b2)
=último(b2) ∪ último(c4) pues λ ∉ L(c4)
={b2} ∪ {c4}={b2,c4}
Es claro pues que a1 ∈ pos(t)-último(t), luego
103
siguiente(r,a1)=siguiente(t,a1)=siguiente(a1b2+a3c4,a1)
=siguiente(a1b2,a1) pues a1 ∈ pos(a1b2)
=siguiente(a1,a1) ∪ primer(b2) pues a1 ∈ último(a1)={a1}
={} ∪ {b2}={b2}

Y como d5 ∈ pos(s)={d5}
siguiente(r,d5)=siguiente(s,d5)=siguiente(d5*,d5)
=siguiente(d5,d5) ∪ primer(d5) pues d5 ∈ último(d5)={d5}
={} ∪ primer(d5)
={} ∪ {d5}={d5}
Todos los otros conjuntos se construyen de manera similar y aquí están reunidos en una lista:
r=(ab+ac)d*
pos(r)={a1,b2,a3,c4,d5}
primer(r)={a1,a3}
último(r)={b2,c4,d5}
siguiente(r,a1)={b2}
siguiente(r,b2)={d5}
siguiente(r,a3)={c4}
siguiente(r,c4)={d5}
siguiente(r,d5)={d5}
Ahora construimos el autómata dos de cuyas reglas detallamos a continuación:
d(b2,b)={ cj / cj ∈ siguiente(r,b2) y ε[cj]=b }
={ cj / cj ∈ {d5} y ε[cj]=b }
={} pues ε[d5]=d y obviamente d≠b
Recordemos que las reglas con imagen {} no se anotan.
d(b2,d)={ cj / cj ∈ siguiente(r,b2) y ε[cj]=d }
={ cj / cj ∈ {d5} y ε[cj]=d }
={d5} pues d5 ∈ {d5}, ε[d5]=d y obviamente d=d
El resto está aquí integrado:
A=( {q0,a1,b2,a3,c4,d5}, {a,b,c,d}, d, q0, {b2,c4,d5} )
d:
d(q0,a)={a1,a3}
d(a1,b)={b2}
d(b2,d)={d5}
d(a3,c)={c4}
d(c4,d)={d5}
d(d5,d)={d5}
Otra idea muy popular debida a Thompson construye λ-AFN’s con la propiedad de tener un
único estado final del que no salen arcos y un estado inicial al que no llegan arcos.
104
A la e.r. a le corresponde el siguiente λ-AFN:
A la e.r. λ le corresponde el siguiente λ-AFN:
A la e.r. ∅ le corresponde el siguiente λ-AFN:
Toda e.r. es una combinación de estas e.r. básicas, utilizando los operadores ‘+’, ‘.’ y ‘*’.
En la tabla siguiente At denota el λ-AFN para la e.r. t, As denota el λ-AFN para la e.r. s, se
supone que ya se tienen construidos ambos λ-AFN’s y por ello se los grafica dentro de un
recuadro, a la e.r. de la izquierda le corresponde el λ-AFN de la derecha
r=ts:
El estado final de At es solapado por el
estado inicial de As.
r=t+s:
La línea punteada indica un estado que
era final en el autómata original
(At o As) pero que ya no lo es en la
construcción que se plantea.
r=t*:
La línea punteada indica el estado final
del autómata At pero que ya no lo es en
la construcción que se plantea.
105
Ejemplo:
Sea r=(ab+ac)d*
Construimos así el λ-AFN A tal que T(A)=L(r), es claro que los subíndices de los estados
deben adecuarse a la construcción, así lo haremos renombrando si es necesario.
Para la e.r. a (de manera semejante para b, c y d) el λ-AFN es:
Para la e.r. ab (de manera semejante para ac) el λ-AFN es:
Para la e.r. ab+ac el λ-AFN es:
Para la e.r. d* el λ-AFN es:
Finalmente el λ-AFN para r=(ab+ac)d* es:
Otra alternativa es utilizar lo que se denomina grafo de transición generalizado.

Un grafo de transición generalizado gtg es semejante a un diagrama de transición con la única
y notable diferencia que admite que sus arcos sean etiquetados con e.r.
Si admitimos por un lado que un diagrama de transición de un autómata puede verse como un
gtg simplemente considerando las etiquetas de los arcos como e.r.; y por otro lado si dado un
gtg sustituimos cada e.r. de sus arcos por autómatas utilizando el modo de Thompson,
entonces admitiremos que los gtg’s y los autómatas son equivalentes en relación a los
lenguajes que aceptan.
La alternativa que estamos describiendo difiere del modo de Thompson en el tratamiento de
los arcos con e.r.
106
Se construye un gtg con la e.r. r así A=({q1,qf},{r},d,q1,{qf}) donde d: d(q1,r)={qf}, y a partir
de dicho gtg se van construyendo nuevos gtg’s descomponiendo r en sus partes elementales
según se indica a continuación de manera gráfica.
El punteado indica que si qi (ó qj) es un estado final, este preserva dicha cualidad.
Si i=j el reemplazo es equivalente, aunque la gráfica varía obviamente.
qk es un nuevo estado que se añade al gtg
Si una parte del gtg incluye la se la reemplaza por
transición
r=ts:
r=t+s:
r=t*:
Ejemplo:
Sea r=(ab+ac)d*
Construimos así el λ-AFN A tal que T(A)=L(r)
El gtg inicial es:
Es claro que t=ab+ac y s=d*

Luego aplicamos el reemplazo correspondiente añadiendo un nuevo estado q2, resultando:
En el arco de q1 a q2 la e.r. se descompone en t=ab y s=ac, resultando:
107
Las e.r. ab y ac se tratan de manera semejante a lo que hicimos inicialmente, lo interesante es
observar cómo funciona el reemplazo para d*, todo ello resulta en:
Cuando i=j el tratamiento es el mismo como muestra el siguiente ejemplo del cual no
mostramos todos los detalles.
Sea r=(a*+b)*
Luego de trabajar la ‘*’ más externa tenemos:
Ahora trabajamos el reemplazo para ‘+’, resultando:
Finalmente la última ‘*’ nos devuelve el siguiente resultado final:
Otra alternativa debida a Brzozowski es utilizar las derivadas de la e.r. r para construir el
AFD. Esta idea procede de dos maneras, una manera obtiene un AFD con el menor número
posible de estados y la otra un AFD cualquiera posiblemente con muchos estados, explicamos
ambas a continuación.
108
Sea r una e.r. construida sobre Σ, construimos el AFD A con el menor número posible de
estados tal que T(A)=L(r) así:
A=(K, Σ, δ, r, F)
K={Dw(r) / w∈ Σ*} recuerde que este conjunto es finito, note que los estados son e.r.
F={ Dw(r) / λ ∈ L(Dw(r))}
δ: δ( Dw(r),a) = Dwa(r)
Una forma más gráfica de ver esta construcción es como sigue.
Construimos un árbol de e.r. con r como nodo raíz.
Se deriva el árbol por niveles -desde el nodo raíz- respecto a cada símbolo de Σ, cada una de
estas derivadas es un nuevo nodo y el arco que enlaza una e.r. y su derivada se etiqueta con el
símbolo utilizado para la derivación:
- la derivada se compara con todas las e.r. de los nodos existentes hasta el momento y si es
equivalente a alguna e.r. previa entonces el nombre del nodo resultante –la derivada- se
reemplaza por dicha e.r. previa.
- si es equivalente a ∅ el nombre del nodo resultante es precisamente ∅.
Se cierra una rama del árbol si el nombre del nodo es idéntico a algún otro nodo ya existente
en el árbol o si es ∅.
Cuando todas las ramas del árbol estén cerradas (lo que se garantiza por la finitud de las
derivadas de una e.r.), se construye el AFD así:
Los estados son los nombres de los nodos del árbol. De acuerdo a lo descrito puede haber más
de un nodo con el mismo nombre a los que les corresponde un único estado.
Son estados finales los nodos cuyo lenguaje asociado a su e.r. incluya la cadena vacía.
De cada nodo padre a un nodo hijo hay una regla de transición con el símbolo que etiqueta el
arco que los une. Si el árbol incluye un nodo con nombre ∅, este estado es el equivalente al
estado muerto o trampa y de ahí hay reglas a sí mismo con todos los símbolos de Σ.
Ejemplo:
Sea r=(ab+ac)d*
Construimos así el AFD A tal que T(A)=L(r)
Primero construimos el árbol de derivadas a partir de nodo raíz con etiqueta (ab+ac)d*.
Derivamos esta e.r. respecto de a, b, c y d. Cada resultado es un nuevo nodo.
109
Es vital comparar cada nuevo nodo con los existentes previamente para ver si son e.r.
equivalentes y hacer lo que indica el procedimiento.
Note por ejemplo que con la e.r. (b+c)d* la derivada respecto de b -Db[(b+c)d*]- es d* que es
inexistente en el segundo nivel y que obviamente no es equivalente a Da[(b+c)d*]=∅. En
cambio Dc[(b+c)d*] es también d* y por lo tanto esta rama se cierra pues esta e.r. ya existe.
Hemos representado con una x pequeña el hecho de que una rama se cierre.
A=(K,Σ,δ,r=q1,F)
K={(ab+ac)d*, (b+c)d*, d*, ∅} que pueden renombrarse como K={q1,q2,q3,qm }
Σ={a,b,c,d}
Es claro que λ ∈ d* pero no a las otras e.r. de K, es decir F={q3}
δ:
δ(q1,a)=q2 δ(q1,b)=qm δ(q1,c)=qm δ(q1,d)=qm
δ(q2,a)=qm δ(q2,b)=q3 δ(q2,c)=q3 δ(q2,d)=qm
δ(q3,a)=qm δ(q3,b)=qm δ(q3,c)=qm δ(q3,d)=q3
δ(qm,a)=qm δ(qm,b)=qm δ(qm,c)=qm δ(qm,d)=qm
Uno de los obstáculos de esta alternativa es tener que averiguar la equivalencia entre e.r. que
puede no ser un trabajo elemental ni rápido; por ejemplo si el nodo raíz fuese r=(a*+ba*+b*)*
y derivamos r respecto de a y b se tiene:
Da(a*+ba*+b*)*=a*(a*+ba*+b*)* ¡que es equivalente a r!
Db(a*+ba*+b*)*=(a*+b*)(a*+ba*+b*)* ¡que es equivalente a r!
Por lo tanto los nombres de los nodos de las derivadas se reemplazan por la e.r. previa
existente en el árbol que no es otra que r. Así el árbol para esta e.r. -que no contiene a ∅- es:
Es claro que F=K={q1}; Σ={a,b} y que δ(q1,a)=δ(q1,b)=q1

La equivalencia de e.r. es en realidad otro problema complejo dentro de los lenguajes
regulares y que ha merecido especial atención para diseñar un procedimiento que sea eficiente
computacionalmente en tiempo y espacio.
Una variante de esta forma de proceder requiere la definición siguiente:

Dos e.r. se dicen similares si una puede transformarse en la otra utilizando solamente las
equivalencias r+r≡r, r+s≡s+r, (r+s)+t≡r+(s+t), rλ≡λr≡r, r∅≡∅r≡∅ y r+∅≡∅+r≡r.
Brzozowski plantea un procedimiento muy semejante al anterior con la diferencia que ahora
se compara la derivada –el nombre del nodo- no para ver si es equivalente sino simplemente si
110
es similar a alguno de los nodos existentes hasta el momento en el árbol (el conjunto de
derivadas similares de una e.r. es también finito); el resto del procedimiento es exactamente
igual. El AFD resultante aquí no es necesariamente uno con el menor número posible de
estados.
Ejemplo:
Para el caso r=(a*+ba*+b*)* el árbol de derivadas considerando solamente similaridad es el
que se muestra enseguida; todas las ramas están cerradas –aunque no hemos colocado las x- y
el autómata correspondiente con cuatro estados se construye como indica el procedimiento
descrito.
Hay otras alternativas que simplemente mencionamos como las derivadas parciales de e.r.
propuesta de Antimirov que devuelve un AFN o el llamado Follow Automaton.
Construcción de una e.r. a partir de un autómata A (el Teorema de Kleene parte II)
Sea A un AFD entonces puede denotarse T(A) en términos de e.r.
Demostración:
Sea A=(K, Σ, δ, q1, F) con K={q1,...,qn}
Definiremos las siguientes expresiones regulares:
ri,jn es una e.r. que denota al siguiente conjunto de cadenas:
L(ri,jn ) = { u ∈ Σ∗ / δ∗(qi,u)=qj
y
el AFD no pasa por ningún estado qm con m > n al consumir u
excepto posiblemente el primer estado y el último estado }
Es decir, ri,jn denota todas las cadenas u que me llevan de qi a qj pero que son tales que al ir
de qi a qj no pisamos, no atravesamos, no pasamos por ningún estado qm cuyo subíndice m
sea mayor que n. Esta restricción de que m no sea mayor que n no incluye al estado de partida
ni al estado de llegada.
111
Otra forma equivalente de indicar el conjunto de cadenas que denota esta expresión regular es
así:
L(ri,jn ) = { es el conjunto de cadenas u=a1a2...apap+1 tales que
δ(qi,a1)=qj1
δ(qj1,a2)=qj2
...
δ(qjp-1,ap)=qjp
δ(qjp,ap+1)=qj
donde j1,j2,...,jp ≤ n }
Fíjese que la restricción j1,j2,...,jp ≤ n no afecta al estado de partida qi ni al de llegada qj
Cada L(ri,jn) puede obtenerse de lenguajes -conjuntos de cadenas- finitos a través de un
número finito de aplicaciones de las operaciones ∪, * y . (unión, estrella de Kleene y
concatenación ) permitidas sobre lenguajes.
La prueba del enunciado se hace por inducción sobre n:
Caso base:
Para n=0 el resultado es evidente puesto que L(ri,j0) es un conjunto finito de cadenas.
L(ri,j0) = { a ∈ Σ / δ(qi,a)=qj } si i ≠ j.
L(ri,i0) = { a ∈ Σ / δ(qi,a)=qi } ∪ {λ} si i = j
Puesto que cualquier cadena de longitud mayor a 1 atravesará por algún estado cuyo subíndice
es mayor que 0 (recuerde que nuestros subíndices empiezan en 1).
Es claro que estos son conjuntos finitos de cadenas.
Asumimos que el enunciado es cierto para n=k
Paso inductivo:
Para n=k+1 tenemos esta ingeniosa relación que prueba lo deseado y que se autoexplica:
L(ri,jk+1) = L(ri,jk ) ∪ { L(ri,k+1k) . (L(rk+1,k+1k))*. L(rk+1,jk) }
Finalmente el broche de oro está cuando notamos que
T(A) = U L(r1,jn)
q j ∈F
Sólo nos resta probar que para cada L(ri,jn) existe una e.r.
Para n=0
ri,j0 = aj1 + ... + ajm si i ≠ j y δ(qi,ajh)=qj
ri,i0 = aj1 + ... + ajm + λ si i = j y δ(qi,ajh)=qi
Y asumiendo que para n=k el enunciado es cierto se tiene
para n=k+1
ri,jk+1 = { ri,jk } + { [ri,k+1k] . (rk+1,k+1k)*. [rk+1,jk] }
donde hemos usado llaves, paréntesis y corchetes sólo con fines de claridad.
La e.r s para T(A)=L(s) sería así: s = r1,j1n + ... + r1,jhn para todo qji ∈ F
La anterior prueba no es otra cosa que un instrumento para hallar T(A) de manera mecánica,
en términos de expresiones regulares, sin embargo se advierte que la e.r. resultante puede ser
muy larga y se recomienda su simplificación haciendo uso de las equivalencias ya conocidas.
112
Ejemplo:
δ:
δ(q1,a)=q1
δ(q1,b)=q2
δ(q2,a)=q1
δ(q2,b)=q2
T(A)=L(s) donde la e.r. s = r1,12
Cuando se pueda es mejor simplificar las e.r. resultantes a través de las equivalencias
conocidas.
r1,10 = a+λ
r1,11 = r1,10 + [r1,10].(r1,10)*.[r1,10]
= a+λ + [a+λ](a+λ)*[a+λ] = a+λ{λ + (a+λ)*[ a+λ]} = (a+λ)(a+λ)* = (a+λ)* = a*
0
r1,2 = b
r1,21 = r1,20 + [r1,10].(r1,10)*.[r1,20]
= b + [a+λ](a+λ)*[b] = {λ + [a+λ](a+λ)*}b = {(a+λ)*}b = a*b
0
r2,1 = a
r2,11 = r2,10 + [r2,10].(r1,10)*.[r1,10]
= a + [a](a+λ)*[a+λ] = a{λ + (a+λ)*[ a+λ]} = a(a+λ)* = aa*
0
r2,2 = b+λ
r2,21 = r2,20 + [r2,10].(r1,10)*.[r1,20]
= b+λ + [a](a+λ)*[b] = λ+b + a(a+λ)*b = λ + [λ + a(a+λ)*]b = λ + [λ+aa*]b = λ+a*b
r1,12 = r1,11 + [r1,21].(r2,21)*.[r2,11]
= a* + [a*b](λ+a*b)*[aa*] = a* + [a*b](a*b)*[aa*]
= a* + [a*b](a*b)*[ a*a] = a* + a*b (a*b)*a* a = a* + a*b (a+b)* a = a*[λ+ b(a+b)*a]
Una alternativa interesante es construir la e.r. solucionando un sistema de ecuaciones por

medio de sustituciones y del Lema de Arden, dicho sistema se obtiene a partir del autómata
(generalmente se ha considerado un λ-AFN aunque como se verá puede reutilizarse la idea
para AFN’s y AFD’s también).
Conceptualmente lo que se hace es asociar a cada estado del autómata un conjunto de cadenas
que parten de dicho estado y llegan a algún estado final, ello puede hacerse apelando a los
conjuntos de cadenas de los otros estados representados por incógnitas en nuestro sistema de
ecuaciones, como se indica a continuación.
A cada estado qi en el λ-AFN se asocia una incógnita xi cuya ecuación xi ≡ ... se escribe así:
xi ≡ ∑c xj + λ
qj∈ d ( qi ,c )
si qi ∈ F
∑ cx
qj∈ d ( qi ,c )
j en otro caso
Es decir, en la parte derecha se añade -suma en términos de e.r.- cxj si qj ∈ d(qi,c) con
c∈(Σ ∪{λ}), si qi ∈ F entonces también se añade λ.
113
Una vez que tenemos para cada uno de los n estados una incógnita y su ecuación asociada
estamos en la presencia de un sistema de n ecuaciones con n incógnitas, donde es claro que
podemos utilizar las equivalencias r+r≡r, r+s≡s+r, (r+s)+t≡r+(s+t), rλ≡λr≡r, r∅≡∅r≡∅ y
r+∅≡∅+r≡r.
Ahora aplicamos recurrentemente el Lema de Arden a través del siguiente procedimiento que
elimina una incógnita y una ecuación a la vez y que lo aplicaremos sistemáticamente desde xn
hasta x1 (es claro que este orden puede cambiarse).
Podemos considerar cada ecuación de la forma genérica
xi ≡ ci1x1+ ... +cinxn+t (t=λ o t=∅ dependiendo si qi es final o no)
Y reordenarla de manera que la incógnita esté también al principio en la parte derecha así:
xi ≡ ciixi+ci2x2+ ... +cinxn+t
Es interesante notar que esta ecuación puede lícitamente verse también así:
xi ≡ ciixi+r donde r=ci2x2+ ... +cinx+t, r no incluye a xi
Ya vimos la demostración de Arden que xi=cii*r es solución de esta ecuación.
Así pues podemos aplicar dicha reordenación para cada ecuación y donde sea posible
reemplazar las soluciones que vayamos encontrando para las incógnitas. Al final tendremos
una ecuación con una incógnita que también se soluciona con el Lema de Arden obteniendo la
e.r. requerida en la solución para x1 que representa al estado inicial q1.
Ejemplo:
δ:
δ(q1,a)=q1
δ(q1,b)=q2
δ(q2,a)=q1
δ(q2,b)=q2
Construimos la e.r. s tal que T(A)=L(s) así:
x1 ≡ ax1+bx2+λ
x2 ≡ bx2+ax1
Para x2: x2≡bx2+[ax1] con r=ax1, luego x2=b*ax1
Para x1: x1≡ax1+bx2+λ haciendo el reemplazo para x2 tenemos:
x1≡ax1+bb*ax1+λ que reordenando resulta en:
x1≡(a+bb*a)x1+λ con r=λ, luego x1=(a+bb*a)*λ
Una otra alternativa elimina estados del gtg correspondiente al λ-AFN haciendo que en los
arcos queden e.r. cada vez más cercanas a T(A).
Sin pérdida de generalidad exigiremos que al estado inicial no lleguen arcos y que haya un
único estado final del que no salen arcos. Es decir, dado el λ-AFN A’=(K’, Σ, d’, q1, F’)
construimos así el λ-AFN A=(K, Σ, d, q0, F)
Con K = K’ ∪ {q0,qf}
F = {qf}
114
d:
d(q0,λ) = {q1}
d(qi,cj) = d’(qi,cj) si qi ∈ K’-F’, cj ∈ Σ ∪ {λ} ó si qi ∈ F’, cj ∈ Σ
d’(qi,cj) ∪ {qf } si qi ∈ F’, cj = λ
Lo que se hace luego es transformar el gtg correspondiente al λ-AFN en otro gtg que no tenga
varios arcos y etiquetas que vayan de un mismo estado de partida a un mismo estado de
llegada, por ejemplo d(qi,λ)={qj}, d(qi,a)={qj}, d(qi,b)={qj},..., d(qi,z)={qj}, que se ve así:
ó
Sustituyendo esas etiquetas y/o arcos con una única e.r. así:
Se hace una sustitución similar cuando el arco de partida y el de llegada son el mismo.
Este nuevo gtg tiene una sola etiqueta por arco y un sólo arco entre un estado de partida y un
estado de llegada.
A continuación, básicamente se trata de eliminar los estados uno a uno hasta que queden sólo
los dos nuevos estados añadidos q0 y qf. Al eliminar estados, las etiquetas de los arcos que
queden deben simular a través de e.r. los caminos que pasaban por el estado eliminado, ello se
hace a través del siguiente procedimiento:
Mientras el número de estado del gtg resultante sea > 2:
Elegir un estado qi ∈ K-{q0,qf}
Eliminar el estado qi
Es obvio que en algún momento tendremos un gtg con dos estados (q0 y qf), la e.r. que une
ambos estados que denominaremos s es tal que L(s)=T(A).
Aquí supondremos que siempre que se pueda acudiremos a estas equivalencias conocidas:
r+r≡r, r+s≡s+r, (r+s)+t≡r+(s+t), rλ≡λr≡r, r∅≡∅r≡∅ y r+∅≡∅+r≡r, es claro que pueden
utilizarse las otras equivalencias también.
La eliminación del estado qi se hace así:
115
Construir el conjunto de estados desde los cuales se llega a qi (excepto el propio qi), es decir,
los estados predecesores de qi: pre(qi)={ qh / qh ∈ K-{qi } y qi ∈ d(qh,r), r es una e.r.}.
Construir el conjunto de estados hasta los cuales se llega desde qi (excepto el propio qi), es
decir, los estados sucesores de qi: suc(qi)={ qj / qj ∈ K-{qi } y qj ∈ d(qi, r), r es una e.r.}.
Eliminar qi y todos sus arcos de salida o llegada.
Para todo par (qh,qj) ∈ [pre(qi) X suc(qi)], incluidos los pares tales que qh=qj, incluir la
siguiente transición:
qj ∈ d(qh,pt*s)
donde
qi ∈ d(qh,p) p es la etiqueta del arco que va de qh a qi
qj ∈ d(qi,s) s es la etiqueta del arco que va de qi a qj
qi ∈ d(qi,t) t es la etiqueta del arco que va de qi a qi si existe, en otro caso t=λ
Si es necesario se transforman los gtg’s resultantes en otros gtg’s que no tenga varios arcos o
varias etiquetas que vayan de un mismo estado de partida a un mismo estado de llegada como
se indicó atrás.
Ejemplo:
Sea el siguiente λ-AFN A’=({q1,q2}, {a,b}, d’, q1, {q1})
d’:
d’(q1,a)={q1}
d’(q1,b)={q2}
d’(q2,a)={q1}
d’(q2,b)={q2}
El nuevo λ-AFN es A=({q0,q1,q2,qf}, {a,b}, d, q0, {qf}):
d:
d(q0,λ)={q1}
d(q1,a)={q1}
d(q1,b)={q2}
d(q2,a)={q1}
d(q2,b)={q2}
d(q1,λ)={qf}
El gtg es básicamente el mismo salvo que las etiquetas de los arcos serán consideradas e.r.
Eliminamos el estado q1:
pre(q1)={q0,q2}
suc(q1)={q2,qf}
pre(q1) X suc(q1)={(q0,q2),(q0,qf),(q2,q2),(q2,qf)}
Para el par (q0,q2): q2 ∈ d(q0,a*b)
Para el par (q0,qf): qf ∈ d(q0,a*)
Para el par (q2,q2): q2 ∈ d(q2,aa*b)
Para el par (q2,qf): qf ∈ d(q2,aa*)
Luego de la integración de varias etiquetas el resultante gtg tiene los estados {q0,q2,qf} con
116
d:
d(q0,a*b)={q2}
d(q0,a*)={qf}
d(q2,aa*b+b)={q2}
d(q2,aa*)={qf}
Eliminamos el estado q2:
pre(q2)={q0}
suc(q2)={qf}
pre(q2) X suc(q2)={(q0,qf)}
Para el par (q0,qf): qf ∈ d(q0,a*b[aa*b+b]*aa*)
Luego de la integración de varias etiquetas el resultante gtg tiene los estados {q0,qf} con
d:
d(q0,a*b[aa*b+b]*aa*+a*)={qf}
Que tiene sólo los dos estados añadidos, de donde la e.r. buscada es s=a*b[aa*b+b]*aa*+a*
Construcción de un AFD accesible a partir de un AFD cualquiera

Un AFD A=(K,Σ,δ,q1,F) se dice accesible si ∀ qi∈K ∃ u∈Σ∗ δ∗(q1,u)=qi
Sea A’=(K’,Σ,δ’,q1,F’), construimos así el AFD accesible A=(K,Σ,δ,q1,F)
K={ qj ∈ K’ / ∃ u∈Σ∗ δ∗(q1,u)=qj }
F=F’ ∩ K
δ: δ(qj,a) = δ’(qj,a) ∀ qj∈K
La construcción del conjunto de estados K a los que se puede accesar desde q1 la hacemos así:
B0 = {q1}
Bi+1 = Bi ∪ { δ’(qj,a) / qj ∈ Bi , a ∈ Σ }
Si Bi=Bi+1 entonces alcanzablesdesdeq1=Bi
K=alcanzablesdesdeq1
Es evidente que T(A)=T(A’) pues el autómata resultante es esencialmente el mismo, sólo le
quitamos los estados inaccesibles mismos que no intervienen en el lenguaje aceptado.
Ejemplo:
Sea A’=({q1,q2,q3,q4},{a},δ’,q1,{q2,q3})
δ’: δ’(q1,a)=q2 δ’(q2,a)=δ’(q3,a)=δ’(q4,a)=q1
Construimos así el AFD accesible A=(K,{a},δ,q1,F):
B0={q1}
B1={q1} ∪ {q2} pues q1∈B0 y δ(q1,a)=q2
B2={q1,q2}
Como B1=B2, entonces K=alcanzablesdesdeq1=B1={q1,q2}
F={q2,q3} ∩ {q1,q2}={q2}
δ: δ(q1,a)=q2 δ(q2,a)=q1
117
Construcción de un AFD con el menor número posible de estados a partir de un AFD
cualquiera (minimización de AFD’s)
Lo primero que debemos hacer es i) mostrar que para cualquier lenguaje regular existe un
AFD mínimo, es decir, un AFD con el menor número posible de estados; ii) averiguar si este
es único; y iii) indicar una manera algorítmica de obtenerlo.
Para ello debemos recordar el teorema de Myhill-Nerode puesto que se utiliza.
i) Sea L un lenguaje regular, entonces existe un AFD A tal que L=T(A) y A tiene el menor
número de estados posible (A es mínimo).
Demostración:
Es claro que si L es regular debe haber un AFD A’ cualquiera que lo acepte.
Sin embargo recuérdese que el teorema de Myhill-Nerode dice que, si L es regular entonces la
relación RL es de índice finito, y si ello es así entonces la tercera parte del teorema muestra
cómo construir una AFD A tal que T(A)=L a partir de RL.
El AFD A=(K,Σ,δ,q1,F), construido como se indica en dicho teorema con |K|=n –el índice de
RL es n-, tiene el menor número de estados posible.
En efecto, sea A’=(K’,Σ,δ’,p1,F’) cualquier otro AFD tal que T(A’)=L con |K’|=m,
mostraremos que m≥n.
Recordemos que en K cada estado es una clase de equivalencia de RL y que hay un número
finito n de clases de equivalencia.
También sabemos que dentro de cada clase los elementos están relacionados entre si, es decir,
si las cadenas x,y pertenecen a una clase es porque xRy, es decir, ∀ w∈Σ∗ xw∈LÙyw∈L,
otra manera de decir ello es que ∀ w∈Σ∗ ambas cadenas xw,yw están en L o ambas no lo
están, en este caso se dice que las cadenas x,y son indistinguibles.
Por el contrario si la cadena u está en una clase, y la cadena v está en otra clase entonces las
cadenas u,v se dice que son distinguibles, es decir, ∃ w∈Σ∗ tal que de las dos cadenas uw,vw
sólo una de ellas está en L, es decir, ∃ w∈Σ∗ [(uw∈L ∧ vw∉L) ∨ (uw∉L ∧ vw∈L)], ello es
obvio puesto que si ∀ w∈Σ∗ uw∈LÙvw∈L las dos cadena u,v estarían relacionadas y en la
misma clase.
A partir de K podemos formar el siguiente conjunto:
S = {x1,...,xn} donde cada xi es un representante de la clase [xi]RL, es decir, tomamos un
elemento cualquiera de cada una de las n clases de K para formar S.
Es evidente que los n elementos de S son distinguibles entre sí.
Mostraremos que cualquier AFD que acepte L –en particular A’- debe tener por lo menos n
estados, es decir, m≥n:
Sean xi,xj (i≠j) dos elementos cualesquiera de S, mismos que son –como dijimos- distinguibles
entre sí, es decir ∃ w∈Σ∗ tal que sólo una de las cadenas xiw,xjw está en L, como T(A’)=L se
tiene que la cadena w es tal que sólo una de las cadenas xiw,xjw llega a un estado final de A’
[(δ’∗(p1,xiw)∈F’ ∧ δ’∗(p1,xjw)∉F’) ∨ (δ’∗(p1,xiw)∉F’ ∧ δ’∗(p1,xjw)∈F’)], es decir,
δ’∗(p1,xiw)≠δ’∗(p1,xjw), una de las cadenas xiw,xjw llega –partiendo de p1- a un estado que es
final y la otra cadena llega a un estado que no es final y por lo tanto diferente.
Sabemos también que δ’∗(p1,xiw)=δ’∗(δ’∗(p1,xi),w) y que δ’∗(p1,xjw)=δ’∗(δ’∗(p1,xj),w)
118
De donde tenemos que δ’∗(δ’∗(p1,xi),w)≠δ’∗(δ’∗(p1,xj),w).
Permítasenos hacer δ’∗(p1,xi)=ph y δ’∗(p1,xj)=pg, luego, δ’∗(ph,w)≠δ’∗(pg,w).
Es evidente que si ph=pg entonces δ’∗(ph,w)=δ’∗(pg,w), la contrarrecíproca nos dice que
Si δ’∗(ph,w)≠δ’∗(pg,w) entonces ph≠pg.
Es decir, que para cualesquier par de cadenas xi,xj (i≠j) de S se tiene que δ’∗(p1,xi)≠δ’∗(p1,xj),
es decir, el AFD A’ llega a estados diferentes con dos cualesquier elementos de S; como S
tiene n elementos entonces el AFD A’ llegará a n estados diferentes, ello sólo puede suceder si
el AFD A’ tiene por lo menos n estados, es decir, m≥n.
ii) ¿Existirá otro AFD con n estados que acepte L pero que sea diferente de A? La respuesta es
negativa: el AFD mínimo A es único salvo isomorfismos, es decir, salvo que los estados se
renombren.
Demostración:
Sea A=(K,Σ,δ,[λ]RL,F) el AFD mínimo que se construye en la tercera parte del teorema de
Nerode, y sea A’=(K’,Σ,δ’,p1,F’) otro AFD, tales que T(A)=T(A’)=L y |K|=|K’|=n.
Para mostrar que A’ es isomorfo a A, es decir, que los estados de A’ son simplemente un
renombramiento de los de A, identificaremos cada estado de K’ con algún estado de K, tal
identificación supone que el estado de A’ y el correspondiente estado identificado de A se
comportan igual:
Recordemos que el estado inicial de A es [λ]RL y que K={[x]RL / x∈Σ∗}
Sea pi∈K’, es obvio que A’ es accesible, luego ∃ u∈Σ∗ δ’∗(p1,u)=pi.
Con la misma cadena u en el AFD A llegamos a δ∗([λ]RL,u)=[u]RL.
Identificaremos a pi con [u]RL.
Supongamos que hay otra cadena v tal que δ’∗(p1,v)=pi, es claro que en la relación RA’
definida en la primera parte del teorema de Myhill-Nerode uRA’v pues δ’∗(p1,u)=δ’∗(p1,v), de
acuerdo a la segunda parte del mencionado teorema también uRLv, es decir, las cadenas u,v
están en la misma clase de equivalencia en RL; de este hecho y dado que δ∗([λ]RL,u)=[u]RL y
δ∗([λ]RL,v)=[v]RL, se deduce que la clase de equivalencia de u es la misma que la clase de
equivalencia de v, es decir, δ∗([λ]RL,u)=δ∗([λ]RL,v).
Así pues, con cualquier cadena que llegue a pi en el AFD A’–partiendo de su estado inicial-,
también el AFD A llegará –partiendo de su estado inicial- a [u]RL, es decir, la identificación de
pi con [u]RL es buena pues ambos estados son básicamente el mismo estado sólo que con
diferente nombre en uno y otro autómata pues su comportamiento es idéntico: en efecto,
supongamos que los estados pi y pj de A’ se identifican con los estados [u]RL y [w]RL de A,
ya vimos que cualquier cadena que partiendo del estado inicial de A’ llegue a pi, llegará
también sistemáticamente –partiendo del estado inicial de A- a [u]RL; en A’ cualquier cadena z
que pase por pi y de ahí llegue a pj, se puede subdividir en dos subcadenas z=xy, con la
subcadena x se llega a pi y con la subcadena y se llega de pi a pj –nótese como pi interviene en
esta transición-, análogamente ocurrirá en A, con la cadena z llegaremos a [w]RL,
primeramente con x llegaremos a [u]RL y, de ahí, llegaremos a [w]RL –nótese cómo la
intervención de [u]RL es la misma que de pi-.
119
Finalmente resta argumentar que la identificación de los estados de A’ se hace con estados
diferentes, uno a uno, de A; si no fuera así A’ tendría estados demás y, por lo tanto, no sería
mínimo lo cual era un supuesto de partida.
iii) Se sabe que dado un lenguaje regular tenemos un AFD A’ tal que T(A’)=L. El problema es
ahora, dado L y/o dado A’, cómo construir el AFD mínimo.
Es obvio que dado el AFD A’ podemos hallar primero L(=T(A’)) -o bien tenemos L
directamente-, a partir de éste podemos hallar la relación RL y apelar a la tercera parte del
teorema de Myhill-Nerode para construir el AFD mínimo A.
Ejemplo:
Sea el lenguaje regular L={ u∈{a,b}∗ / Na(u)=2i ∧ Nb(u)=2j; i,j≥0 }
Las cadenas de L son aquellas que tienen un número par tanto de a’s como de b’s.
Construyamos la partición de Σ∗ inducida por la relación RL, recordando que dos cadenas x,y
están en una misma clase si y sólo sí ∀ w∈{a,b}∗ xw,yw están ambas en L o no lo están.
Cadenas que tienen un número impar de a’s y par de b´s:
[a]RL={ u∈{a,b}∗ / Na(u)=2i+1 ∧ Nb(u)=2j; i,j≥0 }
Cadenas que tienen un número par de a’s e impar de b´s:
[b]RL={ u∈{a,b}∗ / Na(u)=2i ∧ Nb(u)=2j+1; i,j≥0 }
Cadenas que tienen un número impar de a’s e impar de b´s:
[ab]RL={ u∈{a,b}∗ / Na(u)=2i+1 ∧ Nb(u)=2j+1; i,j≥0 }
Cadenas que tienen un número par de a’s y b´s:
[λ]RL={ u∈{a,b}∗ / Na(u)=2i ∧ Nb(u)=2j; i,j≥0 }
La tercera parte del teorema de Myhil-Nerode nos dice que:
A=(K,{a,b},δ,q1,F)
K={[λ]RL, [a]RL , [b]RL, [ab]RL}={q1,q2,q3,q4}
F={[λ]RL}={q1}
δ:
δ([λ]RL,a)=[a]RL, es decir, δ(q1,a)=q2
δ([λ]RL,b)=[b]RL, es decir, δ(q1,b)=q3
δ([a]RL,a)=[aa]RL, es decir, δ(q2,a)=q1 nótese que [aa]RL=[λ]RL
δ([a]RL,b)=[ab]RL, es decir, δ(q2,b)=q4
δ([b]RL,a)=[ba]RL, es decir, δ(q3,a)=q4 nótese que [ba]RL=[ab]RL
δ([b]RL,b)=[bb]RL, es decir, δ(q3,b)=q1 nótese que [bb]RL=[λ]RL
δ([ab]RL,a)=[aba]RL, es decir, δ(q4,a)=q3 nótese que [aba]RL=[b]RL
δ([ab]RL,b)=[abb]RL, es decir, δ(q4,b)=q2 nótese que [abb]RL =[a]RL
Sin embargo, en esta construcción la identificación de las clases puede ser árida y nos interesa
particularmente otra idea, la de construir al AFD A a partir del AFD A’ -L=T(A’)- sin hallar
RL.
Sea el AFD accesible A’=(K’,Σ,δ’,p1,F’) tal que T(A’)=L, ya dijimos cómo construir un AFD
accesible a partir de uno que no lo es.
120
Sobre K’ definiremos la relación E así:
piEpj si y sólo si ∀ w∈Σ∗ δ’∗(pi,w)∈F’Ùδ’∗(pj,w)∈F’
Que evidentemente es de equivalencia y se denominada relación de equivalencia entre
estados.
Construiremos así el AFD A=(K, Σ, δ, [p1]E, F) a partir de A’:
K={[pi]E / pi∈K’}, la partición en clases de equivalencia de K’ inducida por la relación E
[p1]E el estado inicial de A es la clase de equivalencia que contiene al estado inicial p1 de A’
F={[pi]E / pi∈F’}
δ: δ([pi]E,a)=[δ’(pi,a)]E
Luego mostraremos que T(A)=L y que es el AFD mínimo.
Lo que debemos mostrar ahora es cómo construir K:
Para ello definiremos la relación de m-equivalencia Em así:
piEmpj si y sólo si ∀ w∈Σ∗ |w|≤m δ’∗(pi,w)∈F’Ùδ’∗(pj,w)∈F’
Mostraremos ahora resultados que nos permitirán construir fácilmente la partición de K’.
1) piEm+1pj => piEmpj
Demostración:
Que piEm+1pj significa que ∀ w∈Σ∗ |w|≤m+1 δ’∗(pi,w)∈F’Ùδ’∗(pj,w)∈F’, si esto es cierto
para |w|≤m+1, obviamente también es cierto para |w|≤m, es decir,
∀ w∈Σ∗ |w|≤m δ’∗(pi,w)∈F’Ùδ’∗(pj,w)∈F’, es decir, piEmpj
2) piEm+1pj Ù piEmpj ∧ ∀ a∈Σ δ’(pi,a)Emδ’(pj,a)
Demostración:
=>) Es claro –por 1- que piEm+1pj => piEmpj
Si mostramos que piEm+1pj => ∀ a∈Σ δ’(pi,a)Emδ’(pj,a), de ambas implicaciones sigue
que piEm+1pj => piEmpj ∧ ∀ a∈Σ δ’(pi,a)Emδ’(pj,a).
Si piEm+1pj, entonces ∀ w∈Σ∗ |w|≤m+1 δ’∗(pi,w)∈F’Ùδ’∗(pj,w)∈F’, si ello es cierto para
|w|≤m+1, en particular es cierto para 0<|w|≤m+1, es decir,
∀ w∈Σ∗ 0<|w|≤m+1 δ’∗(pi,w)∈F’Ùδ’∗(pj,w)∈F’, aprovechando las propiedades de la
concatenación ello puede reescribirse así, con w=au:
∀ a∈Σ ∀ u∈Σ∗ |u|≤m δ’∗(pi,au)∈F’Ùδ’∗(pj,au)∈F’, que por propiedades de δ’∗ puede
reescribirse así: ∀ a∈Σ ∀ u∈Σ∗ |u|≤m δ’∗(δ’∗(pi,a),u)∈F’Ùδ’∗(δ’∗(pj,a),u)∈F’, que es lo
mismo que ∀ a∈Σ ∀ u∈Σ∗ |u|≤m δ’∗(δ’(pi,a),u)∈F’Ùδ’∗(δ’(pj,a),u)∈F’, es decir,
∀ a∈Σ δ’(pi,a)Emδ’(pj,a); así pues piEm+1pj => ∀ a∈Σ δ’(pi,a)Emδ’(pj,a)
<=) Si piEmpj ∧ ∀ a∈Σ δ’(pi,a)Emδ’(pj,a), ello significa que
∀ w∈Σ∗ |w|≤m δ’∗(pi,w)∈F’Ùδ’∗(pj,w)∈F’, y que
∀ a∈Σ ∀ w∈Σ∗ |w|≤m δ’∗(δ’(pi,a),w)∈F’Ùδ’∗(δ’(pj,a),w)∈F’, esto último es lo mismo que
∀ a∈Σ ∀ w∈Σ∗ |w|≤m δ’∗(δ’∗(pi,a),w)∈F’Ùδ’∗(δ’∗(pj,a),w)∈F’, que es lo mismo que
∀ a∈Σ ∀ w∈Σ∗ |w|≤m δ’∗(pi,aw)∈F’Ùδ’∗(pj,aw)∈F’, que por concatenación de cadenas con
u=aw, es lo mismo que ∀ u∈Σ∗ 0<|u|≤m+1 δ’∗(pi,u)∈F’Ùδ’∗(pj,u)∈F’, como el caso de la
cadena vacia está cubierto por el hecho de que piEmpj, resulta que piEm+1pj.
121
3) Denominaremos Pm a la partición en clases de equivalencia de K’ inducida por Em.
Si Pm=Pm+1 entonces ∀ i≥0 Pm=Pm+i
Demostración:
Por inducción sobre i. Es obvio que el enunciado es cierto para i=0 (y para i=1); supongamos
que es cierto para i=k, mostraremos que es cierto para i=k+1, es decir, mostraremos que
Pm=Pm+k+1. En efecto, sean dos estados tales que piEm+k+1pj, por 1 sabemos que piEm+kpj y por
hipótesis inductiva se tiene que piEmpj; inversamente sean dos estados tales que piEmpj, por el
supuesto de partida (Pm=Pm+1) tenemos que piEm+1pj, por 2 se deduce que
piEmpj ∧ ∀ a∈Σ δ’(pi,a)Emδ’(pj,a), por hipótesis inductiva resulta que
piEm+kpj ∧ ∀ a∈Σ δ’(pi,a)Em+kδ’(pj,a), y otra vez por 2 finalmente tenemos que piEm+k+1pj.
4) Si Pm=Pm+1 entonces Pm=K
Si piEpj, entonces ∀ w∈Σ∗ δ’∗(pi,w)∈F’Ùδ’∗(pj,w)∈F’, como es cierto ∀ w∈Σ∗ en particular
es cierto ∀ w∈Σ∗ |w|≤m, luego ∀ w∈Σ∗ |w|≤m δ’∗(pi,w)∈F’Ùδ’∗(pj,w)∈F’, es decir, piEmpj.
Inversamente, si piEmpj entonces ∀ w∈Σ∗ |w|≤m δ’∗(pi,w)∈F’Ùδ’∗(pj,w)∈F’, además como
Pm=Pm+1 por 3 tenemos que ∀ k≥0 piEm+kpj, es decir,
∀ k≥0 ∀ w∈Σ∗ |w|≤m+k δ’∗(pi,w)∈F’Ùδ’∗(pj,w)∈F’, que se puede expresar también así
∀ w∈Σ∗ δ’∗(pi,w)∈F’Ùδ’∗(pj,w)∈F’, es decir, piEpj.
Estos resultados permiten diseñar el siguiente procedimiento para calcular K:
P0 = { [pj / pj∈F’], [pj / pj∈(K’-F’)] }, es decir finales por un lado y no finales por otro
Pi+1 se construye así: dos estados ph,pj están en la misma clase en Pi+1 si están en una misma
clase en Pi y ∀ a∈Σ los estados δ’(ph,a),δ’(pj,a) también están en una misma clase.
Si Pi=Pi+1 entonces Pi=K.
Sólo resta argumentar que algún momento la condición Pi=Pi+1 se cumple, ello es así puesto
que cada refinamiento, es decir cada partición, dividirá las primeras clases a lo más hasta tener
por cada estado una clase, luego no es posible hacer más divisiones o refinamientos.
El caso extremo en el que P0 tiene una sola clase (cuando F=K o cuando F={}), se maneja
igual aunque es inmediato que en este caso P0 será igual a P1 y las reglas de transición van del
único estado a sí mismo con todos los símbolos del alfabeto .
Para construir Pi+1 a partir de Pi lo que hay que ver es si las clases se subdividen, ello puede
hacerse en un cierto modo sistemático así:
Tomando un estado ph de alguna clase en Pi como una especie de pivote y ver si los demás
estados que lo acompañan (en Pi) –por ejemplo pj- siguen acompañándolo en Pi+1 (verificando
si ∀ a∈Σ los estados δ’(ph,a),δ’(pj,a) están en una misma clase en Pi aunque no es necesario
que sea la misma clase en la que están ph y pj).
Los estados que están junto a ph en una misma clase en Pi y que, fruto de la verificación, lo
acompañen en Pi+1, se ponen todos en una misma clase precisamente en Pi+1 y se los
considerará como marcados en Pi; los estados que están junto a ph en una misma clase en Pi y
que, fruto de la verificación, no lo acompañen ya en Pi+1, se los considera como no marcados y
de entre ellos se toma un nuevo pivote (en la clase en Pi) y se procede nuevamente a ver
cuáles de los no marcados lo acompañan del modo sistemático que indicamos.
122
Se hace lo mismo para cada clase en Pi.
Es obvio que si una clase de Pi tiene un solo estado, esta clase ya no se refinará y se repetirá
tal cual en Pi+1.
Ejemplo:
Sea el siguiente AFD accesible A’=({p1,p2,p3,p4,p5},{a,b},δ’,p1,{p1,p4,p5})
δ’:
δ’(p1,a)=p2
δ’(p1,b)=p3
δ’(p2,b)=p4
δ’(p2,a)=δ’(p3,a)=δ’(p4,a)=δ’(p5,a)=p1
δ’(p3,b)=δ’(p4,b)=δ’(p5,b)=p5
P0={ [p1,p4,p5], [p2,p3] }

Detallaremos sólo la primera subdivisión de la clase [p1,p4,p5] al construir P1 a partir de P0.
Tomamos a p1 como pivote:
¿Le acompaña p4? Debemos verificar que δ’(p1,a),δ’(p4,a) estén en una misma clase en P0, es
decir que p2,p5 estén en una misma clase en P0, es claro que no, luego p4 no acompaña a p1.
decir que p2,p1 estén en una misma clase en P0, es claro que no, luego p5 no acompaña a p1.
Es decir, como no hay más estados en esta clase de P0, el estado p1 va sólo a la nueva partición
P1 .
P0 (y P1 aún en etapa de construcción) se verían así hasta el momento, donde hemos puesto en
negrita el estado marcado p1:
P0={ [p1,p4,p5], [p2,p3] }
P1={ [p1], ... }
Ahora hay que ver qué pasa con los estados no marcados de la clase [p1,p4,p5] de P0.
Tomamos a p4 como pivote:
decir que p1,p1 estén en una misma clase en P0, es claro que si; pero ello no basta, tenemos
más símbolos en Σ. Debemos verificar además que δ’(p4,b),δ’(p5,b) estén en una misma clase
en P0, es decir que p5,p5 estén en una misma clase en P0, es claro que si, luego p5 si acompaña
a p4. Y, como no hay más estados no marcados en esta clase de P0, P0 (y P1 aun en etapa de
construcción) se verían así hasta el momento, donde hemos puesto en negrita los estados
marcados:
P0={ [p1,p4,p5], [p2,p3] }
P1={ [p1], [p4,p5], ... }
Falta ver qué pasa con la otra clase, resumimos todo el trabajo así:
P0={ [p1,p4,p5], [p2,p3] }
P1={ [p1], [p4,p5], [p2,p3] }
P2={ [p1], [p4,p5], [p2,p3] }
Como P1=P2, K=PE={ [p1], [p4,p5], [p2,p3] }= {q1,q2,q3}, que también puede denotarse así:
123
K={ [p1]E, [p4]E, [p2]E }={ [p1]E, [p5]E, [p3]E }
La clase que contiene al estado inicial de A’ es q1=[p1]E que es el estado inicial de A.
F={ [p1]E, [p4]E }={q1,q2}
Sólo resta construir δ, por ejemplo δ([p4]E,b)=[δ’(p4,b)]E=[p5]E, es decir, δ(q2,b)=q2
El resto está aquí
δ:
δ(q1,a)=δ(q1,b)=q3
δ(q2,a)=δ(q3,a)=q1
δ(q2,b)=δ(q3,b)=q2
Mostraremos ahora que T(A)=L:

Previamente probaremos por inducción sobre |u| que δ∗([pi]E,u)=[δ’∗(pi,u)]E
Caso base:|u|=0, es decir, u=λ. δ∗([pi]E,λ)=[pi]E=[δ’∗(pi,λ)]E, donde en ambas igualdades se
utiliza la definición de δ∗ y δ’∗ respectivamente para el caso de la cadena vacia.
Hipótesis inductiva: supondremos cierto el enunciado para |u|=k.
Paso inductivo: Sea |v|=k+1, entonces podemos reescribir dicha cadena así v=ua con |u|=k.
δ∗([pi]E,v)=δ∗([pi]E,ua)=δ(δ∗([pi]E,u),a) por definición de δ∗
∗
=δ([δ’ (pi,u)]E,a) por hipótesis inductiva
∗
=[δ’(δ’ (pi,u),a)]E por definición de δ
=[δ’∗(pi,ua)]E por definición de δ’∗
∗
=[δ’ (pi,v)]E
Ahora u∈T(A) si y sólo si δ∗([p1]E,u)∈F
si y sólo si [δ’∗(p1,u)]E∈F (aquí se utiliza el resultado previo )
∗
si y sólo si δ’ (p1,u)∈F’ (pues F se define así)
si y sólo si u∈T(A’) si y sólo si u∈L (pues T(A’)=L)
Sólo resta mostrar que |K|=n donde n es el índice de la relación RL. Es decir, que A no tiene
más estados y es idéntico o isomorfo al AFD mínimo A que se construye en el teorema de
Myhill-Nerode y de ahí es el AFD mínimo buscado. Haremos esto por reducción al absurdo:
Supongamos que A tiene –en K- más estados que A, el cual tiene |K|=n estados. Es decir
supongamos que A tiene por lo menos n+1 estados.
Véase el esquema de la siguiente página como ayuda.
Así pues las cadenas xi1,...,xin,xin+1 nos permiten llegar desde p1 a pi1,...,pin,pin+1
respectivamente.
Ahora bien, todas estas cadenas xi1,...,xin,xin+1 no pueden estar en diferentes clases de
equivalencia en la partición de Σ∗ que induce RL, pues solamente tenemos n clases de
equivalencia, así pues dos de estas cadenas están en una misma clase de equivalencia en la
partición de Σ∗ que induce RL (en la columna izquierda de nuestra tabla-esquema).
Sean xij,xih dichas cadenas, es decir, xijRLxih.
124
El AFD A El AFD A
construido según el teorema de Construido según se indica arriba
Myhill-Nerode tiene n estados Tiene –por nuestro supuesto- más de n
los cuales podrían llamarse: estados, digamos n+1 estados, los cuales
representaremos así:
q1 correspondiente a la clase [λ]RL [pi1]E xi1
... ... cada pij es un estado de K’ ...
qj correspondiente a otra clase de RL [pij]E y para cada uno de ellos xij
... ... ∃ xij∈Σ∗ δ’∗(p1,xij)=pij ...
qn correspondiente a la última clase de RL [pin]E pues A’ es accesible, xin
[pin+1]E anotemos estas cadenas xin+1
aquí la derecha
Además estas cadenas son tales que δ’∗(p1,xij)=pij y δ’∗(p1,xih)=pih, con [pij]E y [pih]E dos clases
de equivalencia en la partición de K’ que induce E, es decir, [pij]E y [pih]E son dos estados de
K y [pij]E ≠ [pih]E, que es lo mismo que decir que pij y pih no están relacionados (bajo E).
Pero entonces –de acuerdo a la definición de E-:
no es cierto que ∀ w∈Σ∗ δ’∗(pij,w)∈F’Ùδ’∗(pih,w)∈F’,
en esta expresión podemos reemplazar pij con δ’∗(p1,xij) y pih con δ’∗(p1,xih), luego,
no es cierto que ∀ w∈Σ∗ δ’∗(δ’∗(p1,xij),w)∈F’Ùδ’∗(δ’∗(p1,xih),w)∈F’, por propiedades de δ’∗
resulta lo siguiente: no es cierto que ∀ w∈Σ∗ δ’∗(p1,xijw)∈F’Ùδ’∗(p1,xihw)∈F’,
como A’ acepta L, deducimos esto: no es cierto que ∀ w∈Σ∗ xijw∈LÙxihw∈L,
-nótese la definición de RL-, así pues tenemos que xij no está relacionada con xih (bajo RL).
Líneas arriba concluimos que xijRLxih y ahora concluimos que ello no es cierto, esta
contradicción prueba el enunciado de que A no tiene más estados que A, es decir, es el AFD
mínimo.
Hay una alternativa muy popular aunque exigente en tiempo computacional para calcular las
clases de equivalencia de la partición de K’ inducida por E, en vez de refinar las clases a partir
de P0, lo que hace es averiguar poco a poco cuáles pares de estados son distinguibles, es decir
no equivalentes, para finalmente agruparlos en clases. Se basa en los siguientes resultados:
i) Es obvio que si sólo uno de los dos estados pi,pj está en F’, con w=λ:
∃ w∈Σ∗ [{δ’∗(pi,w)∈F’ ∧ δ’∗(pj,w)∉F’} ∨ {δ’∗(pi,w)∉F’ ∧ δ’∗(pj,w)∈F’}], es decir,
pi,pj no son equivalentes (bajo E). Esto nos permite identificar los primeros pares de estados
distinguibles, son aquellos en los que uno es final y el otro no.
ii) Si δ’(pi,a)=ph y δ’(pj,a)=pg y ph,pg son distinguibles entonces pi,pj son distinguibles.
Ello es inmediato puesto que ph,pg sean distinguibles no es otra cosa que
∃ w∈Σ∗ [{δ’∗(ph,w)∈F’ ∧ δ’∗(pg,w)∉F’} ∨ {δ’∗(ph,w)∉F’ ∧ δ’∗(pg,w)∈F’}]; sea la cadena
u=aw, dado que δ’∗(pi,aw)=δ’∗(δ’(pi,a),w)=δ’∗(ph,w) y δ’∗(pj,aw)=δ’∗(δ’(pj,a),w)=δ’∗(pg,w),
resulta que ∃ u∈Σ∗ [{δ’∗(pi,u)∈F’ ∧ δ’∗(pj,u)∉F’} ∨ {δ’∗(pi,u)∉F’ ∧ δ’∗(pj,u)∈F’}] es decir,
125
pi,pj no son equivalentes (bajo E) o lo que es lo mismo son distinguibles. Esto nos permite
identificar pares de estados distinguibles a partir de otros que ya son distinguibles.
La idea se integra en el siguiente procedimiento que construye una matriz de pares de estados
distinguibles, las filas corresponden a estados y las columnas también –la matriz triangular
superior se omite por simetría y porque la diagonal compararía un estado consigo mismo lo
que no tiene sentido pues siempre un estado es indistinguible de sí mismo-:
. Construimos la matriz B marcando toda celda B(i,j) correspondiente al par de estados pi,pj
en el que sólo uno de ellos está en F’.
. Se hace lo siguiente
Se revisan una a una las celdas B(i,j) no marcadas,
∀ a∈Σ se obtiene ph=δ’(pi,a) y pg= δ’(pj,a)
si la celda B(h,g) está marcada, entonces se marca B(i,j)
hasta que no se añadan marcas en B.
Una vez que se tiene el B final, las celdas marcadas corresponden a los pares de estados
distinguibles; y las celdas no marcadas corresponden a los pares de estados indistinguibles, es
decir, equivalentes, basta reunir estos estados en clases de equivalencia para obtener K.
Si algún estado es tal que toda su fila y toda su columna está marcada –o se omite- este estado
constituye una clase por sí mismo.
Ejemplo:
Sea el mismo AFD A’ de arriba.
En el primer paso se obtiene la siguiente matriz donde hemos rayado la parte omitida y la
marca utilizada es una x, cada fila corresponde a un estado y cada columna también, así la
primera fila corresponde a p1, etc.:
≡ ≡ ≡ ≡ ≡
x ≡ ≡ ≡ ≡
B= x ≡ ≡ ≡
x x ≡ ≡
x x ≡
Como siguiente paso se observa cada celda no marcada -por ejemplo B(4,1) correspondiente
al par p4,p1- y obtenemos δ’(p4,a)=p1 y δ’(p1,a)=p2, B(1,2)=B(2,1) si está marcado y por tanto
procedemos a marcar también B(4,1); sólo por diferenciar haremos las marcas en este paso
con una X mayúscula. Es claro que si B(2,1) no estuviera marcado debemos seguir probando
con todos los símbolos de Σ. El resultado es:
≡
≡ ≡ ≡ ≡
x ≡ ≡ ≡ ≡
B= x ≡ ≡ ≡
X x x ≡ ≡
X x x ≡
Otra vez observamos cada celda no marcada, y ahora ya no se añaden marcas.
126
Las celdas no marcadas corresponden a pares de estados indistinguibles o equivalentes
mismos que pasamos a agrupar, así [p3,p2] están en una clase y [p5,p4] están en otra clase.
Es claro también que p1 constituye una clase por sí misma: [p1].
127
CAPÍTULO 6. CERRADURA: El caso regular
La idea de cerradura, cierre o clausura es la siguiente:

Sean L1 y L2 dos lenguajes/conjuntos regulares arbitrarios.
Sea L el resultado de alguna operación con ellos, ya sea sobre L1 (complemento, reversa, etc.)
o sobre L1 y L2 (unión, intersección, etc.)
¿ Será L un lenguaje/conjunto regular también ?
Si es cierto, se dice que los lenguajes/conjuntos regulares son cerrados respecto a la operación
aplicada.
Hasta ahora hemos utilizado los conceptos de lenguaje regular para gramáticas y de conjunto
regular para autómatas, simplificaremos las cosas indicando que, salvo la excepción de la
cadena vacía -cosa que precisaremos cuando sea necesario- un lenguaje es regular si hay una
gramática regular que lo genera (lineal izquierda o derecha), una e.r. que lo represente o un
autómata finito que lo acepte (determinístico, no determinístico o con transiciones vacías).
La propia definición de e.r. muestra que los lenguajes regulares son cerrados respecto de la
unión, concatenación y estrella de Kleene; además, a partir de las conversiones genéricas, para
e.r. dadas podemos construir autómatas y a partir de ellos gramáticas correspondientes.
Junto a la verificación de la cerradura respecto de otras operaciones, sin embargo, es usual
considerar estos problemas también de manera directa –por ejemplo trabajar exclusivamente
con GRLI’s- sin apelar a las conversiones en uno u otro sentido. Intentaremos mostrar ello
aunque no seremos exhaustivos.
Unión
Los lenguajes regulares son cerrados respecto de la operación unión.
Sean G1=(N1,T1,P1,S1) tal que L(G1)=L1 y G2=(N2,T2,P2,S2) tal que L(G2)=L2 dos GRLD’s con
(N1 ∩ Ν2)={}, S ∉ N1 y S ∉ N2, entonces podemos construir una GRLD G tal que
L(G)=L1∪L2.
Demostración:
Construimos así la GRLD G=(N,T,P,S)
N = N1 ∪ N2 ∪ { S }
T = T1 ∪ T 2
P = { S --> α / ( S1 --> α ∈ P1 ) ó ( S2 --> α ∈ P2 ) } ∪ P1 ∪ P2
Los subíndices de esta construcción deben seguirse bien; α representa cualquier parte derecha
(de un símbolo o de dos).
i) Sea u ∈ L(G), es decir, S=>*u con las producciones de P.

S=>α=>* u donde los pasos de derivación se dan utilizando producciones de P
α denota la cadena que se deriva de S en el primer paso de derivación
que ha debido utilizar la producción S-->α ∈ P
Por la forma de nuestra construcción, en P1 tenemos la producción S1-->α, ó en P2 S2-->α.
128
Además, como α contiene solo símbolos de N1 ó N2 y -precisamente por esto- como ningún
símbolo o producción de P1 aparece en P2 (y viceversa), entonces la derivación α=>* u se ha
debido realizar sólo con producciones de P1 ó de P2 (que están en P) por lo tanto, la derivación
que estamos desglosando puede descomponerse así:
S1=>α=>*u con producciones de P1, utilizando en el primer paso S1-->α ó
S2=>α=>*u con producciones de P2, utilizando en el primer paso S2-->α
es decir, u ∈ L(G1) ó u ∈ L(G2).
ii) Inversamente sea u ∈ L(G1) ó u ∈ L(G2), es decir,
S1=>α=>*u con producciones de P1 ó
S2=>α=>*u con producciones de P2,
Por la forma de nuestra construcción –dado que P1 ⊆ P y P2 ⊆ P- la derivación α=>*u puede
hacerse con producciones de P.
Además, por la forma de nuestra construcción, S-->α está en P. Luego, es posible que
S=>α=>* u con sólo producciones de P, es decir, u ∈ L(G).
Ejemplo:
Sea el lenguaje regular L1={ak / k > 0} generado por la GRLD G1=(N1,T1,P1,S1)
N1={S1}
T1={a}
P1 :
S1-->aS1
S1-->a
Sea el lenguaje regular L2={bi / i > 0} generado por la GRLD G2=(N2,T2,P2,S2)
N2={S2}
T2={b}
P2 :
S2-->bS2
S2-->b
Construimos así la GRLD G=(N,T,P,S) tal que L(G)=L1 ∪ L2={ak / k > 0} ∪ {bi / i > 0}
N={S,S1,S2}
T={a,b}
P:
S --> a
S --> b
S --> aS1
S --> bS2
S1 --> aS1
S1 --> a
S2 --> bS2
S2 --> b
Mostraremos la construcción con AFD’s.
129
Sean A1=(K1, Σ1, δ1, q1, F1) tal que T(A1)=L1 y A2=(K2, Σ2, δ2, p1, F2) tal que T(A2)=L2 dos
AFD’s con (K1 ∩ Κ2)={}, entonces podemos construir un AFD A tal que T(A)= L1 ∪ L2 así:
Por un resultado anterior es posible suponer sin pérdida de generalidad que Σ1=Σ2=Σ.
A=(K1 X K2, Σ, δ, [q1,p1], F)
F={ [qi,pj] / qi ∈ F1 ó qj ∈ F2}
δ: δ([qi,pj],a)=[δ1(qi,a),δ2(pj,a)]
Mostraremos por inducción sobre |u| que δ∗([qi,pj],u)=[δ1∗(qi,u),δ2∗(pj,u)]
Caso base:
|u|=0, es decir u=λ
δ∗([qi,pj],u)=δ∗([qi,pj],λ) pues u=λ
=[qi,pj] por definición de δ∗ caso λ
=[δ1∗(qi,λ),δ2∗(pj,λ)] por definición de δ1∗ y δ2∗ caso λ
∗ ∗
=[δ1 (qi,u),δ2 (pj,u)] pues u=λ
Hipótesis inductiva:El enunciado es cierto para cadenas de longitud k.
Paso inductivo:
Sea w una cadena de longitud k+1, es decir, w=ua con |u|=k.
δ∗([qi,pj],w)=δ∗([qi,pj],ua) pues w=ua
=δ(δ∗([qi,pj],u),a) por definición de δ∗
=δ([δ1∗(qi,u),δ2∗(pj,u)],a) por hipótesis inductiva
=[δ1(δ1∗(qi,u),a),δ2(δ2∗(pj,u),a)] por construcción de δ
=[δ1∗(qi,ua),δ2∗(pj,ua)] por definición de δ∗
=[δ1∗(qi,w),δ2∗(pj,w)] pues w=ua
Ahora bien,
u ∈ T(A) si y sólo si δ∗([q1,p1],u) ∈ F -y por la reciente inducción-
si y sólo si [δ1∗(q1,u),δ2∗(p1,u)] ∈ F –y por construcción de F-
si y sólo si δ1∗(q1,u) ∈ F1 ó δ2∗(p1,u) ∈ F2
si y sólo si u ∈ T(A1) ó u ∈ T(A2)
Ejemplo:
Sean los AFD’s
A1=({q1}, {a,b}, δ1, q1, {q1})
δ1: δ1(q1,a)=δ1(q1,b)=q1 y
A2=({p1,p2}, {a,b}, δ2, p1, {p2})
δ2: δ2(p1,a)=δ2(p1,b)=p2
δ2(p2,a)=δ2(p2,b)=p1
Construimos así el AFD A=({[q1,p1],[q1,p2]}, {a,b}, δ, [q1,p1], {[q1,p1],[q1,p2]})
δ:
δ([q1,p1],a)=δ([q1,p1],b)=[q1,p2]
δ([q1,p2],a)=δ([q1,p2],b)=[q1,p1]
130
Concatenación
Los lenguajes regulares son cerrados respecto de la operación concatenación.
(N1 ∩ Ν2)={}, entonces podemos construir una GRLD G tal que L(G)=L1.L2.
Demostración:
Construimos así la GRLD G=(N,T,P,S1)
N = N1 ∪ N2
T = T1 ∪ T 2
P = [ P1 - { X --> a / X --> a ∈ P1 } ] ∪ { X --> aS2 / ( X --> a ∈ P1 ) } ∪ P2
Fíjese que a diferencia de lo que hacíamos en la unión el símbolo raíz de G1 es ahora el
símbolo raíz de G y no se aumentan nuevos No Terminales.
i) Sea u ∈ L(G), u=vw

Por la forma de P es posible desglosar esta derivación así:
S1=>*αX=>αaS2=>*vw
los primeros pasos de derivación de v que se han debido dar con producciones de P1 del tipo
Y-->bZ que son parte de P, el último paso de derivación de v donde se ha debido utilizar la
producción X-->aS2 ∈ P y el resto de los pasos de derivación de w que se han debido dar con
producciones de P2 que son parte de P
Por la forma de nuestra construcción X-->aS2 ∈ P sólo porque X-->a ∈ P1, luego se deduce
que las siguientes derivaciones son posibles:
S1=>*αX=>αa con producciones de P1
S2=>*w con producciones de P2
es decir, v ∈ L(G1) y w ∈ L(G2).
ii) Inversamente sea u=vw, v ∈ L(G1) y w ∈ L(G2), es decir,

S1=>*v con producciones de P1
S2=>*w con producciones de P2,
La derivación de v puede desglosarse en su último paso y el resto de los primeros pasos:
S1=>*αX=>v donde v=αa, X ∈ N1, α ∈ T1* y X-->a ∈ P1
Por la forma de nuestra construcción X-->a ya no está en P pero si X-->aS2
Luego en la gramática G puede hacerse la siguiente derivación:
S1=>*αX=>αaS2=>*vw
Es decir, u ∈ L(G).
Ejemplo:
Sea el lenguaje regular L1={ak / k > 0} generado por G1=({S1},{a},P1,S1)
P1 :
S1-->aS1
S1-->a
Sea el lenguaje regular L2={bi / i > 0 } generado por G2=({S2},{b},P2,S2)
131
P2 :
S2-->bS2
S2-->b
Construimos así la GRLD G=(N,T,P,S1) tal que L(G)= L1.L2 = {akbi / k > 0 , i > 0}
N={S1,S2}
T={a,b}
P:
S1 --> aS1
S1 --> aS2
S2 --> bS2
S2 --> b
Veamos cómo es la construcción para GRLIzquierdas.

Sean G1=(N1,T1,P1,S1) tal que L(G1)=L1 y G2=(N2,T2,P2,S2) tal que L(G2)=L2 dos GRLI’s con
(N1 ∩ Ν2)={}, entonces se construye así una nueva GRLI G tal que genera L(G)=L1.L2:
G=(N,T,P,S2)
N = N1 ∪ N2
T = T1 ∪ T 2
P = [ P2 - { X --> a / X --> a ∈ P2 } ] ∪ { X --> S1a / ( X --> a ∈ P2 ) } ∪ P1
Ejemplo:
Sean G1=({S1},{a},{S1-->S1a,S1-->a},S1) y G2=({S2},{b},{S2-->S2b,S2-->b},S2) dos GRLI’s,
construimos así la GRLI G=({S1,S2},{a,b},P,S2)
P:
S2-->S2b
S2-->S1b
S1-->S1a
S1-->a
La construcción con λ-AFN’s es muy sencilla:

Sean A1=(K1, Σ1, d1, q1, F1) tal que T(A1)=L1 y A2=(K2, Σ2, d2, p1, F2) tal que T(A2)=L2 dos
λ-AFN’s con (K1 ∩ Κ2)={}, entonces se construye así un λ-AFN A tal que T(A)=L1.L2:
A=(K1 ∪ K2, Σ1 ∪ Σ2, d, q1, F2)
d:
d(pi,a) = d1(pi,a) si pi ∈ K1, a ∈ Σ1
d1(pi,λ) si pi ∈ K1-F1, a=λ
d1(pi,λ) ∪ {p1} si pi ∈ F1, a=λ
d2(pi,a) si pi ∈ K2, a ∈ Σ2 ∪ {λ}
Ejemplo:
Sean A1=({q1,q2}, {a}, d1, q1, {q2}) y A2=({p1,p2}, {b}, d2, p1, {p2}) los λ-AFN’s con
d1: d1(q1,a)={q2} y d2: d2(p1,b)={p2}
132
Construimos así el λ-AFN A=({q1,q2,p1,p2}}, {a,b}, d, q1, {p2})
d: d(q1,a)={q2} d(q2,λ)={p1} d(p1,b)={p2}
Presentamos dos variantes para la construcción con AFN’s:

i) De un estado final de A1 -además de a donde se llegaba- debe llegarse donde nos lleva el
estado inicial de A2, con el mismo símbolo.
A=(K1 ∪ K2, Σ1 ∪ Σ2, d, q1, F)
d: d(pi,a) = d1(pi,a) si pi ∈ K1-F1 F = F2 si λ ∉ L2
d1(pi,a) ∪ d2(p1,a) si pi ∈ F1 F2 ∪ F1 si λ ∈ L2
d2(pi,a) si pi ∈ K2
Ejemplo:
Sean A1=({q1,q2}, {a}, d1, q1, {q2}) y A2=({p1,p2}, {b}, d2, p1, {p1,p2}) los AFN’s con
d1: d1(q1,a)={q2} y d2: d2(p1,b)={p2}
Construimos así el AFN A=({q1,q2,p1,p2}}, {a,b}, d, q1, {q2,p1,p2})
d: d(q1,a)={q2} d(q2,b)={p2} d(p1,b)={p2}
ii) Si de un estado cualquiera en A1 llego a un estado final (en A1) además debe llegarse al
estado inicial de A2, con el mismo símbolo.
A=(K1 ∪ K2, Σ1 ∪ Σ2, d, q1, F)
d: d(pi,a) = d1(pi,a) ∪ {p1} si pi ∈ K1, [d1(pi,a) ∩ F1]≠∅ F = F2 si λ ∉ L2
d1(pi,a) si pi ∈ K1, [d1(pi,a) ∩ F1]=∅ F2 ∪ F1 si λ ∈ L2
d2(pi,a) si pi ∈ K2
Si q1 ∈ F1, es decir si λ ∈ L1, la construcción debe complementarse en el caso de q1 así:
d(q1,a) = d(q1,a) ∪ d2(p1,a) a ∈ (Σ1 ∪ Σ2)
Ejemplo:
Sean A1=({q1,q2}, {a}, d1, q1, {q1,q2}) y A2=({p1,p2}, {b}, d2, p1, {p1,p2}) los λ-AFN’s con
d1: d1(q1,a)={q2} y d2: d2(p1,b)={p2}
Construimos así el AFN A=({q1,q2,p1,p2}}, {a,b}, d, q1, {q1,q2,p1,p2})
d: [inicialmente d(q1,b)={ }] d(q1,a)={q2,p1} d(p1,b)={p2} complementando d(q1,b)={p2}
Diferencia
Los lenguajes regulares son cerrados respecto de la operación diferencia de conjuntos.
AFD’s con (K1 ∩ Κ2)={}, entonces podemos construir un AFD A tal que T(A)= L1-L2.
Demostración:
Se construye así el AFD A=(K1 X K2, Σ, δ, [q1,p1], F)
F={ [qi,pj] / qi ∈ F1 y pj ∉ F2 }
133
Ya demostramos que δ∗([qi,pj],u)=[δ1∗(qi,u),δ2∗(pj,u)], luego
u ∈ T(A) si y sólo si δ∗([q1,p1],u) ∈ F
si y sólo si [δ1∗(q1,u),δ2∗(p1,u)] ∈ F
si y sólo si δ1∗(q1,u) ∈ F1 y δ2∗(p1,u) ∉ F2 -por construcción de F-
si y sólo si u ∈ T(A1) y u ∉ T(A2)
si y sólo si u ∈ [T(A1)-T(A2)]
Ejemplo:
Con los mismos AFD’s que para la unión lo único que varía es F que es así:
F={[q1,p1]}
Complemento
Los lenguajes regulares son cerrados respecto del complemento (con Σ* como universo).
Sea A=(K, Σ, δ, q1, F) tal que T(A)=L un AFD, entonces podemos construir otro AFD A’ tal
que T(A’)=Σ*-L.
Demostración:
Se construye así el AFD A’=(K, Σ, δ, q1, K-F)
u ∈ T(A’) si y sólo si δ∗(q1,u) ∈ K-F
si y sólo si δ∗(q1,u) ∉ F
si y sólo si u ∉ T(A)
Ejemplo:
Sea el AFD A1=({q1}, {a,b}, δ1, q1, {q1})
δ1: δ1(q1,a)=δ1(q1,b)=q1
Construimos así el AFD A’=({q1}, {a,b}, δ1, q1, ∅)
Una alternativa es la siguiente:

A1=({q1}, Σ, δ, q1, {q1})
δ: δ(q1,a)=q1 a∈Σ
es claramente un AFD que acepta Σ*. Si tenemos el AFD que acepta L, y dado que los
lenguajes regulares son cerrados respecto de la diferencia de conjuntos, es claro que hay un
AFD para Σ*-L, luego la cerradura vale también para el complemento.
Intersección
Los lenguajes regulares son cerrados respecto de la operación intersección.
AFD’s con (K1 ∩ Κ2)={}, entonces podemos construir un AFD A tal que T(A)= L1 ∩ L2.
Demostración:
Construimos así el AFD A=(K1 X K2, Σ, δ, [q1,p1], F)
F= F1 X F2
134
Ya demostramos que δ∗([qi,pj],u)=[δ1∗(qi,u),δ2∗(pj,u)], luego
u ∈ T(A) si y sólo si δ∗([q1,p1],u) ∈ F
si y sólo si [δ1∗(q1,u),δ2∗(p1,u)] ∈ F
si y sólo si δ1∗(q1,u) ∈ F1 y δ2∗(p1,u) ∈ F2 -por construcción de F-
si y sólo si u ∈ T(A1) y u ∈ T(A2)
si y sólo si u ∈ [T(A1) ∩ T(A2)]
Ejemplo:
Con los mismos AFD’s que para la unión lo único que varía es F que es así:
F={[q1,p2]}
La construcción con GRLD’s es así:

(N1 ∩ Ν2)={}, entonces podemos construir así una GRLD G tal que L(G)= L1 ∩ L2.
G=( N,T,P,[S1,S2] )
N = N1 X N2
T = T1 ∪ T 2
(serviría T1 ∩ T2 pero tal intersección puede ser vacía, violentando la definición de alfabeto)
P = { (A,X) --> a(B,Y) / ( A --> aB ∈ P1 ) y ( X --> aY ∈ P2 ) }
∪ { (A, X) --> a / ( A --> a ∈ P1 ) y ( X --> a ∈ P2 ) }
Note que el Terminal debe ser el mismo.
Ejemplo:
Sean las GRLD’s G1=({S1,Y},{a,b},{S1-->aS1,S1-->aY,Y-->b},S1) y
G2=({S2,Z},{a,b},{S2-->aZ, Z-->bZ,Z-->b },S2), construimos así la GRLD G=(N,T,P,[S1,S2])
N={[S1,S2],[S1,Z],[Y,S2],[Y,Z]}
T={a,b}
P:
[S1,S2]-->a[S1,Z]
[S1,S2]-->a[Y,Z]
[Y,Z]-->b
Una alternativa de demostración interesante es como sigue:

Se sabe que los lenguajes regulares son cerrados respecto de la diferencia y la unión, además
suponiendo sin pérdida de generalidad que L1⊆Σ* y L2⊆Σ*se sabe que
L1 ∩ L2 = Σ* - [ (Σ*-L1) ∪ (Σ*-L2) ]
Lo que demuestra que los lenguajes regulares son cerrados también respecto de la
intersección.
Estrella de Kleene
Los lenguajes regulares son cerrados respecto de la operación estrella de Kleene.
135
Mostraremos la construcción con GRLD’s, en cuyo caso por la excepción de la cadena vacía
hablamos de la operación cruz de Kleene.
Sea la GRLD G=(N,T,P,S) L(G)=L entonces podemos construir otra GRLD G’ tal que
L(G’)=L*.
Demostración:
Se construye así la GRLD G’=( N,T,P’,S)
P’= P ∪ {X-->aS / X-->a ∈ P }
i) Sea u ∈ L+, es decir, existe un i tal que u ∈ Li , es decir, u=u1...ui con uj ∈ L=L(G), es
decir, para cada uj S=>*uj, es posible desglosar cada una de estas derivaciones así:
S=>*αjXj=>αjaj
Donde se ha evidenciado el último paso de derivación de uj=αjaj que ha debido utilizar la
producción Xj-->aj ∈ P.
Por la forma de nuestra construcción Xj-->ajS ∈ P’, luego se deduce que la siguiente
derivación es posible:
S=>*α1X1=>α1a1S=>...=>*α1a1...αiXi=>α1a1...αiai
Es decir, u ∈ L(G’).
ii) Inversamente sea u ∈ L(G’), es decir, S=>*u.
P’ tiene las mismas producciones de P junto al conjunto {X-->aS / X-->a ∈ P }, de ahí que
Esta derivación puede desglosarse así, utilizando las producciones de P y en vez de utilizar
una producción que finalice la derivación de terminales reiniciar el trabajo de las
producciones de P utilizando una del tipo X-->aS que si está en P’ tantas i veces como se
quiera así:
S=>*α1X1=>α1a1S=>...=>*α1a1...αiXi=>α1a1...αiai
Pero entonces u es una cadena con la siguiente forma u=u1...ui con uj ∈ L(G)=L, es decir,
u ∈ L +.
Ejemplo:
Sea la GRLD G=({S,Y},{a,b},{S-->aS,S-->aY,Y-->b},S), construimos así la GRLD
G’=({S,Y},{a,b},{S-->aS,S-->aY,Y-->b,Y-->bS},S)
Mostraremos la construcción con AFN’s.

Sea el AFN A=(K, Σ, d, q1, F) tal que T(A)=L entonces podemos construir un AFN A’ tal que
T(A’)=L* así: A’=(K, Σ, d’, q1, F’)
F’ = {q1}
d’:
d’(qi,a)=d(qi,a) si [d(qi,a) ∩ F]=∅
d’(qi,a)=d(qi,a) ∪ {q1} si [d(qi,a) ∩ F]≠∅
Ejemplo:
Sea el AFN A=({q1,q2}, {a}, d1, q1, {q2}) con
d1: d1(q1,a)={q2}
136
Construimos así el AFN A’=({q1,q2}, {a}, d, q1, {q1})
d: d(q1,a)={q2,q1}
Es usual presentar en esta parte los siguientes resultados.

Sea L un lenguaje regular, entonces LR es también un lenguaje regular.
En efecto, sea G=(N, T, P, S) –S’ ∉ N- una GRLD tal que L(G)=L, entonces podemos
construir otra GRLD G’ tal que L(G’)=LR.
Demostración:
Sin pérdida de generalidad podemos suponer que G es tal que sus producciones no incluyen a
su símbolo raíz en la parte derecha de ninguna de sus producciones. Entonces construimos así
G’=(N ∪ {S’},T,P’,S’)
P’:
Y --> aX si ( X --> aY ∈ P ) y X ≠ S
S’ --> aX si ( X --> a ∈ P ) y X≠S
S’ --> a si ( S --> a ∈ P )
Y --> a si ( S --> aY ∈ P )
i) Sea u ∈ L(G) , es decir, S=>* u con las producciones de P.

Si dicha derivación se hace en un paso S=>u, entonces la cadena u es de un símbolo y uR=u,
también S-->u ∈ P, y por lo tanto –tercera línea de la construcción de P’- S’-->u ∈ P’, así
S’=>*u con una producción de P’, es decir, la cadena uR ∈ L(G’).
Si la derivación S=>* u con producciones de P se hace en más de un paso, podemos desglosar
esta derivación, suponiendo lícitamente que u=bi1bi2...bikbik+1 con bij ∈ T, así:
S=>bi1Vj1 donde se ha utilizado la producción S-->bi1Vj1 ∈ P
=>bi1bi2Vj2 donde se ha utilizado la producción Vj1-->bi2Vj2 ∈ P
...
=>bi1bi2... bikVjk donde se ha utilizado la producción Vjk-1-->bikVjk ∈ P
=>bi1bi2... bikbk+1 donde se ha utilizado la producción Vjk-->bik+1 ∈ P
Ningún Vjh es S, pues G no incluye al símbolo raíz en la parte derecha de sus producciones.
Luego, por la forma de nuestra construcción, las siguientes producciones deben estar en P’:
Vj1-->bi1
Vj2-->bi2Vj1
...
Vjk-->bikVjk-1
S’-->bik+1Vjk
Luego, la siguiente derivación es posible en G’:
S’=>bik+1Vjk=>bik+1bikVjk-1=>...=>bik+1bik...bi3Vj2=>bik+1bik...bi3bi2Vj1=>bik+1bik...bi3bi2bi1
Es decir, S’=>*uR en G’, es decir uR ∈ L(G’).
ii) Inversamente, sea u ∈ L(G’):
137
Si S’=>u en un paso, ello sucede utilizando la producción S’-->u ∈ P’, también es claro que
uR=u, pero –por construcción, tercera línea- esta producción está en P’ sólo si S-->u ∈ P, así
S=>u también en G.
Si S=>*u en G’ dando más de un paso, podemos desglosar esta derivación, suponiendo
lícitamente que u=bik+1bik...bi1bi2 con bij ∈ T, así:
S’=>bik+1Vjk donde se ha debido utilizar la producción S’-->bik+1Vjk ∈ P’
=>bik+1bikVjk-1 donde se ha debido utilizar la producción Vjk-->bikVjk-1 ∈ P’
...
=>bik+1bik...bi3Vj2 donde se ha debido utilizar la producción Vj3-->bi3Vj2 ∈ P’
=>bik+1bik...bi3bi2Vj1 donde se ha debido utilizar la producción Vj2-->bi2Vj1 ∈ P’
=>bik+1bik...bi3bi2bi1 donde se ha debido utilizar la producción Vj1-->bi1 ∈ P’
Estas producciones están en P’ fruto de nuestra construcción y les haremos un análisis tanto
para mostrar que ningún Vjh es S como para indicar qué producciones están en P.
La inclusión de S’-->bik+1Vjk a P’ ha utilizado necesariamente la segunda línea de nuestra
construcción a partir de Vjk-->bik+1 en P, con Vjk≠S.
La inclusión de Vjk-->bikVjk-1 a P’ ha utilizado la primera línea de nuestra construcción a partir
de Vjk-1-->bikVjk en P, con Vjk-1≠S. No ha podido usarse la segunda línea pues en ese caso
Vjk=S lo que ya está descartado.
Podemos seguir desarrollando un razonamiento análogo recurrente para indicar que:
La inclusión de Vj3-->bi3Vj2 a P’ ha utilizado la primera línea de nuestra construcción a partir
La inclusión de Vj2-->bi2Vj1 a P’ ha utilizado la primera línea de nuestra construcción a partir
La inclusión de Vj1-->bi1 a P’ ha utilizado la cuarta línea de nuestra construcción a partir de
S-->bi1Vj1 en P. No ha podido usarse la tercera línea pues en ese caso Vj1=S lo que ya está
descartado.
Así pues, tenemos en P las producciones:
Vjk-->bik+1
Vjk-1-->bikVjk
...
Vj2-->bi3Vj3
Vj1-->bi2Vj2
S-->bi1Vj1
Donde ningún Vjh es S.
Luego, la siguiente derivación es posible en G:
S=>bi1Vj1=>bi1bi2Vj2=>bi1bi2bi3Vj3=>...=>bi1bi2bi3...bikVjk=>bi1bi2bi3...bikbik+1
Es decir, uR ∈ L(G).
138
Ejemplo:
A partir de la GRLD G=({S,X},{a,b},P,S):
P:
S --> aX
X --> aX nótese que G no incluye a su símbolo raíz en
X --> bX la parte derecha de ninguna de sus producciones
X --> b
Construimos así G’=({S’,S,X},{a,b},P’,S’)
P’:
X --> a
X --> aX
X --> bX
S’ --> bX
Mostraremos el resultado con e.r. Si L es regular debe haber una e.r. r que la representa, es
decir, L(r)=L . El siguiente procedimiento parte de la e.r. r y construye la e.r. rR tal que
L(rR)=LR:
cuando r=λ: rR =λ
cuando r=∅: rR=∅
cuando r=a: rR=a
cuando r=t+s: rR=tR+sR
cuando r=t*: rR=(tR)*
cuando r=ts: rR=sRtR
Una inducción sobre la longitud de r muestra que rR es tal que L(rR)=LR.

Caso base:
|r|=1
Cuando r=λ, es claro que L=L(r)={λ}, y que LR={λ}=L(rR), con rR=λ como indica nuestra
construcción.
Cuando r=∅, es claro que L=L(r)={}, y que LR={}=L(rR), con rR=∅ como indica nuestra
construcción.
Cuando r=a, es claro que L=L(r)={a}, y que LR={a}=L(rR), con rR=a como indica nuestra
construcción.
El enunciado es cierto para |r|<k
Paso inductivo:
Sea r una e.r. tal que |r|=k
Por la estructura de las e.r. r sólo puede ser de una de tres formas:
r=t+s: en este caso L=L(r)=L(t) ∪ L(s), y de ahí LR=[L(t)]R ∪ [L(s)]R. Por nuestra
construcción rR=tR+sR, donde L(rR)=L(tR) ∪ L(sR), por hipótesis inductiva L(tR)=[L(t)]R y
L(sR)=[L(s)]R, es decir, L(rR)=[L(t)]R ∪ [L(s)]R.
139
r=ts: en este caso L=L(r)=L(t).L(s), y de ahí por definición de reversa LR=[L(s)]R.[L(t)]R. Por
nuestra construcción rR=sRtR, donde L(rR)=L(sR).L(tR), por hipótesis inductiva L(tR)=[L(t)]R
y L(sR)=[L(s)]R, es decir, L(rR)=[L(s)]R[L(t)]R.
r=t*: en este caso L=L(r)=[L(t)]* , y de ahí por definición de reversa LR=([L(t)]R)*. Por
nuestra construcción rR=[tR]*, donde L(rR)=[L(tR)]*, por hipótesis inductiva L(tR)=[L(t)]R, es
decir, L(rR)=([L(t)]R)*.
Ejemplo:
Sea L=L(r) con r=a(a+b)*b
rR=b(a+b)*a
Sea L un conjunto finito de cadenas, entonces L es regular.

Demostración:
i)L=∅
La GRLI=({S},{a},{S-->Sa},S) claramente es tal que L(G)=∅.
Es evidente también que T(A)=∅ para el AFD A=({q1}, {a}, δ, q1, ∅)
δ: δ(q1,a)=q1
Por otro lado la e.r. r=∅ es tal que L(r)=∅ por definición.
ii)L={λ}
Es claro que T(A)={λ} para el AFD A=({q1,q2}, {a}, δ, q1, {q1})
δ: δ (q1,a)=q2 δ(q2,a)=q2
Por otro lado la e.r. r=λ es tal que L(r)={λ} por definición.
iii)L={w}
El caso w=λ se acaba de ver. Sea w=a1...am.
Es claro que T(A)={w} para el AFN A=({q1,...,qm,qm+1}, {a1,...,am}, d, q1, {qm+1})
d: d(qi,ai)={qi+1} i=1,...,m
Es evidente también que L(G)={w} para la GRLI G=({S1,...,Sm},{a1,...,am},P,Sm)
P:
Si-->Si-1ai i=m,...,2
S1-->a1
Por otro lado la e.r. r=a1. ... .am es tal que L(r)={w}
iv)L={w1,...,wk}
Dado que L puede reescribirse como L={w1} ∪...∪ {wk}, que L={w} es un lenguaje regular y
que la unión de lenguajes regulares es también regular, se sigue que L es regular.
140
CAPÍTULO 7. PROBLEMAS DE DECISIÓN
Siempre es posible describir un problema de manera que su respuesta sea una decisión por un
sí o por un no, estos problemas denominados de decisión pueden ser muchísimos aunque
usualmente se consideran únicamente aquellos catalogados como generales e importantes.
En este contexto, se dice que un problema es decidible si su respuesta correcta siempre puede
obtenerse siguiendo un algoritmo ya sea explícito o implícito en algún resultado teórico; es
imprescindible mencionar que hay problemas que no son decidibles, es decir, que –para
dichos problemas- no hay un algoritmo que nos permita decir siempre un sí o un no como
respuesta.
La selección de problemas no siempre es coincidente, nosotros veremos algunos de los más
comunes. Nótese que si resolvemos un problema para una de las abstracciones –autómatas
finitos, gramáticas o expresiones regulares- el mismo también es resoluble para las otras pues
podemos apelar a la respuesta inicial a través de las conversiones que conocemos.
Pertenencia de una cadena a un lenguaje regular (el Algoritmo de Earley)

El problema siguiente es decidible: ¿pertenece la cadena u a L(G) donde G es una GRLD?
Es claro –como anticipamos- que si L está representado por una e.r. o si L es el lenguaje
subyacente a un AFN, a un λ–AFN o a una gramática regular, podemos construir por
conversión el AFD correspondiente y luego testear dicho AFD con u para ver si δ*(q1,u) ∈ F o
no. Sin embargo, a menudo interesa resolver el problema directamente, sin conversiones
previas, ya sea por simple elegancia o interés teórico, o bien por algún asunto de eficiencia.
Aprovecharemos el problema que estamos considerando para presentar el Algoritmo de
Earley que responderá si una cadena de entrada es generada o no por una GR lineal derecha o
izquierda. Casi siempre se presenta este algoritmo para otro tipo de gramáticas en lo que se
denomina parsing, pero funciona también para las regulares y haremos su presentación
general aquí en lo que hace al reconocimiento (sin involucrarnos en los árboles parsing).
Básicamente lo que propone Earley es operar con las producciones de manera que sean reglas
de producción activas parcial o completamente reconocidas: se intenta una derivación,
llamada más a la izquierda, prediciendo las producciones que sirvan para derivar la cadena u,
símbolo a símbolo, y colocando un punto en la parte derecha de las producciones que indica
cuánto de esa parte derecha se ha reconocido hasta ahora a través del escaneo de la entrada.
Para ello se construyen conjuntos de ítemes Ij; un ítem en forma genérica tiene una producción
A-->αβ (αβ representa la parte derecha de la producción) marcada con un punto y seguida de
un número: [A-->α•β, i].
El algoritmo, que se supone trabaja con la GR=(N,T,P,S) y la cadena u=a1...an tiene estos tres
subprocedimientos:
Procedimiento PREDECIR (se supone que se trabaja con Ij):

Para cada [A-->α•Bβ,i] C Ij A-->αBβ C P; α,β C (N ∪ T)*
añadir para cada B-->γ C P γ C (N ∪ T)*
[B-->•γ,j] a Ij
141
Procedimiento COMPLETAR (se supone que se trabaja con Ij):
Para cada [A-->α•,k] C Ij A-->α C P; α C (N ∪ T)*
añadir para cada [B-->β•Aγ,i] C Ik B-->βAγ C P; β,γ C (N ∪ T)*
[B-->βA•γ,i] a Ij
Procedimiento ESCANEAR (se supone que se trabaja con Ij):

Para cada [A-->α•aβ,i] C Ij-1 con a=aj A-->αaβ C P; α,β C (N ∪ T)*
añadir [A-->αa•β,i] a Ij
Y el procedimiento principal es este:
Construir el conjunto I0 así:

Añadir [S-->•α, 0] a I0 S-->α C P, α es cualquier parte derecha
Ejecutar los procedimientos
PREDECIR con I0 y/o COMPLETAR con I0
hasta que no se añadan nuevo ítemes a I0
Construir los conjuntos I1,...,Ij,...,In así:
Ejecutar los procedimientos
ESCANEAR con Ij, PREDECIR con Ij y/o COMPLETAR con Ij
hasta que no se añadan nuevo ítemes a Ij
Testear In así: si [S-->α•,0] C In, entonces u pertenece a L(G), en otro caso no.
Ejemplo:
Sea la cadena de entrada u=a1a2a3=abc, y la GRLD G=({S,A,B,C,D},{a,b,c,d},P,S)
P:
S-->aB
B-->bC
C-->c
C-->cD
D-->d
I0: [S-->•aB,0]
Ni PREDECIR ni COMPLETAR añaden nuevos ítemes
Ahora j=1 y a1=a, I1:
[S-->a•B,0] añadido en ESCANEAR a partir de [S-->•aB,0]
[B-->•bC,1] añadido en PREDECIR a partir de [S-->a•B,0] y B-->bC
No se pueden añadir más ítemes
Ahora j=2 y a2=b, I2:
[B-->b•C,1] añadido en ESCANEAR a partir de [B-->•bC,1]
[C-->•c,2] añadido en PREDECIR a partir de [B-->b•C,1] y C-->c
[C-->•cD,2] añadido en PREDECIR a partir de [B-->b•C,1] y C-->cD
142
Ahora j=3 y a3=c, I3:
[C-->c•,2] añadido en ESCANEAR a partir de [C-->•c,2]
[C-->c•D,2] añadido en ESCANEAR a partir de [C-->•cD,2]
[D-->•d,3] añadido en PREDECIR a partir de [C-->c•D,2] y D-->d
[B-->bC•,1] añadido en COMPLETAR a partir de [C-->c•,2] y [B-->b•C,1] C I2
[S-->aB•,0] añadido en COMPLETAR a partir de [B-->bC•,1] y [S-->a•B,0] C I1
Testear I3: como [S-->aB•,0] C I3 entonces la cadena u=abc está en L(G).
Intuitivamente, que [A-->α•β,i] C Ij significa que la producción A-->αβ puede aplicarse en la

derivación tal que el prefijo a1...ai ya ha sido reconocido, y que la subcadena ai+1...aj puede
derivarse a partir de α. La parte β es la parte que falta derivar, misma que se predice.
Es necesario remarcar que al construir Ij, los procedimientos escanear, predecir y completar
pueden efectuarse repetidamente y en cualquier orden una y otra y otra vez hasta que no se
añadan nuevos ítemes.
Lenguaje aceptado por un AFD: vacío o no

El problema siguiente es decidible: ¿el lenguaje aceptado por un AFD es vacío?
En efecto, sea el AFD A=(K, Σ, δ, q1, F), construimos primero el conjunto de estados
alcanzablesdesdeq1 como ya se indicó antes, si alguno de ellos es final es claro que T(A) no es
vacío:
Si [alcanzablesdesdeq1 ∩ F]=∅ entonces T(A) si es vacío, en otro caso T(A) no es vacío.
Una alternativa es construir el conjunto de estados desde los cuales se llega a un estado final,
incluidos los propios estados finales.
B0 = F
Bi+1 = Bi ∪ { qj / δ(qj,a) ∈ Bi , a ∈ Σ }
Si Bi=Bi+1 entonces E=Bi
Si q1∈E entonces T(A) no es vacío, en otro caso T(A) sí es vacío.
Otra alternativa es ir probando cadenas para ver si el AFD acepta cuando menos una de ellas.
Para hacer más sistemática la prueba se escogen las cadenas en orden léxico, es decir, primero
λ luego a1 luego a2 ... luego an, luego a1a1, etc.
Si hay una cadena que es aceptada T(A) no es vacío, en otro caso T(A) si es vacío.
Lo central en esta alternativa es tener un número finito de cadenas de prueba, de lo contrario
podríamos estar intentando con las infinitas cadenas de Σ* lo que es una pésima idea.
Este conjunto finito de cadenas de prueba lo ofrece el lema de bombeo. En efecto, sea A un
AFD con |K|=n: T(A)≠∅ Ù ∃ u∈Σ∗ |u|<n δ∗(p1,u)∈F
Es obvio que si hay una cadena que llega a un estado final entonces T(A)≠∅.
143
Inversamente, supongamos que T(A)≠∅, probaremos que ∃ u∈Σ∗ |u|<n δ∗(p1,u)∈F por
reducción al absurdo.
Supongamos que la cadena más pequeña –en longitud- de T(A) es u, con |u|≥n-, por el lema
de bombeo podemos reescribirla así u=xyz con y≠λ, así pues xz no está en T(A), pues xz es
más pequeña que u y el supuesto es que u es la cadena más pequeña de T(A).
Por el lema de bombeo sabemos que ∀ i≥0 xyiz ∈ T(A) , de ahí es claro que xz está en T(A)
y, dado que |xz|<|xyz|, xz es aun más pequeña que u. Esta contradicción prueba el enunciado
que nos da el conjunto finito de cadenas de prueba buscado: debemos probar solamente las
cadenas de longitud menor que |K| si alguna de ellas, es aceptada es obvio que T(A)≠∅, en
otro caso T(A)=∅.
Infinitud (finitud) del lenguaje aceptado por un AFD

El problema siguiente es decidible: ¿el lenguaje aceptado por un AFD es infinito?
Sea A un AFD con |K|=n, nuevamente el lema de bombeo nos ayudará a demostrar que
T(A) es infinito Ù ∃ u∈Σ∗ n≤|u|<2n u∈T(A).
Es claro, por dicho lema, que si ∃ u∈Σ∗ n≤|u|<2n u∈T(A), es decir, si ∃ u∈Σ∗ |u|≥n u∈T(A),
podemos reescribir esta cadena así u=xyz con xyiz ∈ T(A) para todo i, luego T(A) es infinito.
Inversamente, sea T(A) infinito, mostraremos que hay una cadena en T(A) de longitud entre n
y 2n. Como T(A) es infinito, tiene infinitas cadenas de longitud mayor o igual a 2n. Sea w la
más pequeña –en longitud- de esas cadenas, es decir, w∈T(A) y |w|≥2n. Entonces, podemos
reescribir w así w=uv con |u|=n, |v|≥n. Usando el razonamiento del lema de bombeo, la
primera subcadena puede reescribirse así u=xyz -con y≠λ- de manera que toda la cadena w
puede reescribirse así w=xyzv; por dicho lema tanto xyzv∈T(A) como xzv∈T(A); dado que
|xzv|≥|v| y |v|≥n, es claro que |xzv|≥n, además |xzv|<|xyzv|=|uv|=|w|, es decir, |xzv|<|w|, como
w fue elegida siendo la cadena en T(A) más pequeña que tenga longitud mayor o igual a 2n,
es claro que xzv∈T(A) es de longitud |xzv|<2n; así pues tenemos n≤|xzv|<2n y xzv es la
cadena buscada.
Por tanto, probamos con las cadenas de longitud mayor o igual a |K|=n pero menor que 2n, si
el AFD acepta alguna T(A) es infinito, en otro caso no.
Inclusión del lenguaje aceptado por un AFD respecto de otro AFD

El problema siguiente es decidible: ¿el lenguaje aceptado por el AFD A1 es subconjunto del
lenguaje aceptado por el AFD A2?
Sean L1=T(A1) y L2=T(A2) con L1,L2⊆Σ∗.
Se sabe que L1-L2={u / u∈L1 y u∉L2}={ u / u∈L1 y u∈ L2 }=L1∩ L2
Y se sabe que los lenguajes regulares son cerrados respecto de la diferencia como de la
intersección.
Además L1⊆L2 ÙL1-L2=∅ ÙL1∩ L2 =∅
Luego, para determinar si T(A1)⊆T(A2) basta con construir el AFD A que acepte L1-L2 (o bien
que acepte L1∩ L2 ) y testear si T(A) es vacío o no, lo que vimos que es decidible.
144
l-equivalencia de AFD’s (el algoritmo de Moore)
El problema siguiente es decidible: ¿son iguales los lenguajes aceptados por A1 y A2?
En efecto, sean A1 y A2 dos AFD’s tales que L1=T(A1) y L2=T(A2), basta con testear los
siguiente que sabemos que si es decidible: L1⊆L2 y L2⊆L1, puesto que
L1=L2 Ù L1⊆L2 ∧ L2⊆L1
Una alternativa es efectuar lo que se denomina la suma directa de AFD’s denotada por /.
Sin pérdida de generalidad supondremos que el alfabeto de entrada es el mismo para A1 y A2.
A1/A2=A=(K1∪K2, Σ, δ, q1 -ó p1-, F1∪F2)
δ: δ(ri,a) = δi(ri,a) ri∈Ki
Luego, construimos la partición en clases de equivalencia de K=K1∪K2 inducida por la
relación E (como en la construcción del autómata mínimo), y vemos si los estados iniciales de
A1 y A2 están en la misma clase de equivalencia, si es así T(A1)=T(A2), en otro caso no.
Equivalencia de e.r
El problema siguiente es decidible: ¿son equivalentes las e.r. r1 y r2?
Sean L(r1), L(r2)⊆Σ∗.
Construimos los AFD’s mínimos A1 y A2 tales que L(r1)=T(A1) y L(r2)=T(A2) ya vimos que
ello es posible. Luego basta con verificar que A1 y A2 son isomorfos.
O bien construimos los AFD’s A1 y A2 tales que L(r1)=T(A1) y L(r2)=T(A2), ya vimos que
ello es posible. Luego verificamos la l-equivalencia de estos AFD’s, es decir, si T(A1)=T(A2)
cosa que ya la sabemos decidible.
Una otra posibilidad es aplicar el procedimiento de Ginzburg.

Para ello se requiere construir diagramas de transición tanto para r1 como para r2, por ejemplo
aplicando el teorema de Kleene, aunque la versión original de Ginzburg trabaja con grafos de
transición más flexibles puesto que se permiten, además de λ-transiciones, varios estados
iniciales señalados con un signo “-” junto al nodo en cuestión.
Es obvio que con un sólo estado inicial funciona también.
Lo que se hace es simular sistemas de ecuaciones en derivadas de e.r. con matrices.
Sea B la matriz a construirse para cada e.r. cuyos encabezamientos son como sigue:
Su primera columna se denomina de “entradas”, es decir, en cada fila hay cadenas en Σ∗
dispuestas en orden léxico.
La última columna se denomina “incluye λ” y precisamente testea este hecho.
La penúltima columna se denomina “igual a” y verifica si una fila es igual a una anterior.
Las columnas intermedias corresponden a los nodos del diagrama (o grafo) de transición que a
su vez corresponden a los estados del autómata, una columna por estado; los estados finales se
anotan con un signo más (+) a su lado.
Se añaden filas según se indica a continuación.
El procedimiento de llenado de la matriz B termina cuando todas las filas están cerradas.
145
Para las marcas usaremos un “*” e indicaremos una fila cerrada con el subíndice x a la
izquierda de su entrada, tanto el marcado como el cierre de filas debe hacerse en orden,
primero la fila uno, luego la dos, etc.
Para cualquier fila, si alguna marca corresponde a una columna +, es decir, a un estado final,
en su última columna se anota ‘si’ (incluye λ).
La primera fila tiene la entrada λ y se marcan todas las columnas correspondientes a los
estados iniciales, y luego todas las columnas correspondientes a los estados a los que se llegue
desde algún estado inicial con sólo λ-transiciones.
Si hay una fila no cerrada –digamos la fila i- con entrada w se añaden ∀ a∈Σ filas con
entrada wa y se procede a cerrar la fila i.
Para una fila añadida que sólo tiene un dato en su columna entrada, se añaden marcas en todas
las columnas correspondientes a los estados a los que se llegue desde algún estado inicial con
su cadena de entrada incluyendo el uso de λ-transiciones (ello puede facilitarse observando
que la fila i, que ha dado lugar a esta fila añadida, ya tiene marcas con su cadena de entrada:
sólo resta ver a qué estados llegamos -con el símbolo a- de los estados correspondientes a
dichas marcas, incluyendo el uso de λ-transiciones, y marcarlos en la fila añadida).
Si una fila nueva -digamos la fila i- es exactamente igual a otra fila anterior -digamos la fila j-
en las columnas correspondientes a los estados (tiene las mismas marcas –o ninguna- en las
mismas posiciones), se cierra y se coloca la cadena de entrada de la fila j en la columna igual
a de la fila i (si la igualdad es con más de una fila anterior, se elige la primera).
Una vez que se termina de construir B para las e.r. r1 y r2, se comparan las filas de ambas
matrices correspondientes a las mismas entradas, pero sólo aquellas que tengan la columna
igual a en blanco: para cada una de estas filas, si en ambas matrices sus columnas incluye λ
están en blanco -o contienen ‘si’- ambas, las e.r. r1 y r2 son equivalentes, en otro caso no.
Es posible que las matrices B para r1 y r2 no tengan todas sus entradas en común, es decir, en
una matriz puede existir una entrada digamos w –con la columna igual a en blanco- y dicha
entrada puede no estar presente en la otra matriz (porque ya se cerraron todas sus filas), en
este caso se añade en la matriz ‘incompleta’ una fila con la entrada w faltante y cuyas otras
celdas se llenan copiando sus datos de una fila anterior según el siguiente criterio: con
seguridad hay otra(s) fila(s) que tiene(n) en su entrada una cadena que es prefijo de la entrada
w que falta, si hay más de una se elige la que tenga el prefijo más largo en longitud, esta fila
–con este prefijo más largo, digamos u tal que w=uv- debe tener su columna igual a no en
blanco sino con una cadena, a esta cadena se le concatena v, la fila que hay que copiar es la
que tiene en su entrada esta concatenación.
Ejemplos:
Sean las e.r. r1=(ab*)* y r2=λ+a(a+b)* ¿son equivalentes r1 y r2?
Trabajaremos con los siguientes diagramas de transición para r1 y r2:
146
r1: r2:
Luego construimos las matrices B para ambas e.r.

Para r1:
entrada q1 + q2 igual a incluye λ
x λ * si
x a * * si
x b
x aa * * a si
x ab * * a si
x ba b
x bb b
Las primera fila es inmediata; como es no cerrada y su entrada es w=λ, añadimos las
siguientes dos filas con entradas ‘a’ y ‘b’ respectivamente, para luego cerrar esta fila uno.
Las marcas de estas filas añadidas son inmediatas, comentando simplemente que con la
cadena b, partiendo de q1, no se llega a ningún estado y por ello no hay marcas en su fila.
Como la segunda fila es no cerrada y su entrada es w=a, añadimos otras dos filas con
entradas aa y ab respectivamente, para luego cerrar esta segunda fila.
Ocurre algo semejante con la tercera fila.
La cuarta fila con entrada w=aa se trabaja así: debemos marcar todos los estados a los que se
llega –partiendo de q1- con la cadena ‘aa’ incluyendo λ-transiciones, ellos son q1 y q2; como
hay una marca en la columna q1 que es final colocamos ‘si’ en la columna incluye λ; y como
las marcas son exactamente iguales a la segunda fila (que tiene en su entrada la cadena ‘a’)
entonces colocamos en la cuarta fila dicha cadena ‘a’ en la columna igual a y cerramos esta
cuarta fila. Decíamos que puede facilitarse la tarea observando que la segunda fila –que es la
que ha dado lugar a esta cuarta fila- ya tiene marcas en q1 y q2, así en esta cuarta fila debemos
marcar todos los estados a los que se llega con el símbolo ‘a’ partiendo de los estados
marcados de la fila que ha dado lugar a esta, es decir, de la segunda.
Esto facilita mucho la tarea cuando las entradas son de longitud mayor.
Ocurre algo semejante con la quinta fila.
Y algo similar con la últimas dos filas con la observación que –en las celdas correspondientes
a las columnas de los estados- son iguales a la tercera fila cuya entrada es b, pues tienen
ninguna marca en las mismas posiciones.
No anotamos los detalles para r2 cuya tabla completa está a continuación:
147
entrada p1 p2 p3 + igual a incluye λ
x λ * * si
x a * * si
x b
x aa * * a si
x ab * * a si
x ba b
x bb b
Ahora nos resta ver –de las filas que tienen en blanco la celda de la columna igual a, que son
aquellas con entrada λ, ‘a’ y ‘b’- si coinciden en la celdas incluye λ, en efecto es así pues
estas celdas –para dichas entradas- tienen los valores ‘si’, ‘si’ y en blanco respectivamente en
ambas matrices. Luego, r1 y r2 si son equivalentes.
Uno de los ejemplos clásicos de Ginzburg ofrece estas dos matrices. Para r1:
entrada p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 + igual a incluye λ
x λ *
x 0 *
x 1 * * * si
x 00 * 0
x 01 * *
x 10 * λ
x 11 * 0
x 010 * 0
x 011 * * * * si
x 0110 * * 01
x 0111 * 0
Para r2 (nótese que no tiene una entrada w=011):
entrada q1 q2 q3 q4 q5 + igual a incluye λ
x λ *
x 0 *
x 1 * * * si
x 00 * 0
x 01 * λ
x 10 * λ
x 11 * 0
Añadimos una fila con la entrada faltante cuyos demás datos se copian según lo indicado, en
este caso de la fila con entrada ‘1’; ello es así pues w=011=01.1=u.v, es decir, u=01 es el
prefijo más largo de w, prefijo que es entrada de la quinta fila y que tiene en su columna igual
a la cadena λ, misma que concatenada con v=1 nos devuelve λ.1=1, como dijimos la fila que
se copia es la que tiene en su entrada esta concatenación, es decir, la fila con entrada ‘1’:
x 011 * * * si
148
Nótese también que la tabla para r1 en la entrada 01 tiene la celda igual a en blanco (aunque
no ocurre esto en la tabla para r2) en este caso también hay que comparar esta fila.
Todo el proceso de comparación indica que r1 y r2 si son equivalentes.
Para finalizar indicaremos brevemente que este procedimiento se basa en el hecho siguiente,
supongamos que el alfabeto sobre el que se conforman las e.r. es {a1,...,an}:
r = a1.Da1(r) + ... + an.Dan(r) + δ(r)
δ es la función –ya conocida- que testea si λ∈L(r), y r es cualquier e.r. incluso una derivada.
Como puede hacerse lo mismo para otra e.r., es imaginable construir un sistema compuesto de
ecuaciones en e.r. como se simula con las matrices. Es claro que esta no es una descripción
completa de cómo trabaja y demuestra Ginzburg su procedimiento cosa que escapa al alcance
de este trabajo.
Lenguajes no regulares
El siguiente es un problema complejo: ¿es L un lenguaje regular?
En efecto, hay lenguajes que no son regulares, es decir, lenguajes para los cuales no es posible
escribir una gramática regular que los genere ni un autómata finito que los acepte.
El ejemplo típico es L={ajbj / j>0}, es imposible escribir una gramática que genere L o un
autómata que acepte L.
Conviene pues tener instrumentos que nos ayuden en la tarea de decidir si un lenguaje es o no
es regular y, sólo si es regular, empezar la tarea de escribir una gramática o un autómata para
ese lenguaje.
Sabemos que los conjuntos –de cadenas- finitos son regulares.
Dado un conjunto infinito de cadenas, el lema de bombeo puede ser útil para mostrar que no
es regular.
Ejemplos:
Mostraremos que L={ajbj / j>0} no es regular por reducción al absurdo.
Supongamos que sí lo es, es decir, hay un AFD A tal que T(A)=L, con |K|=n.
Es claro que L es infinito, luego hay una cadena u∈T(A) tal que |u|≥n, por ejemplo para j=n la
cadena u=anbn es tal que |u|=2n≥n, por el lema de bombeo u puede reescribirse así u=xyz, con
|xy|≤n, por lo tanto como y≠λ, la subcadena y=ak con 1≤k≤n, pues los primeros n símbolos de
u son a’s y la subcadena y está entre estos primeros n símbolos; por el mismo lema sabemos
que ∀ i≥0 xyiz∈T(A), es decir, ∀ i≥0 xyiz está en L; pero por simple inspección es claro que
las cadenas xyiz con i=2,3,4,etc., no están en L, puesto que tendrán más a’s que b’s. Esta
contradicción indica que nuestro supuesto es falso y que L no es regular.
A menudo este mismo hecho suele mostrarse así: es claro que L es infinito, luego hay una
cadena u∈T(A), tal que |u|≥n.
Por el lema de bombeo u puede reescribirse así u=xyz
¿Cómo son las cadenas x,y,z? Abarcaremos –genéricamente- todas las posibilidades:
1) x=aj, y=bj, z=λ
Por el lema de bombeo con i=2,3,4,etc., las cadenas xyiz están en T(A), es decir, en L.
149
Por simple inspección es claro que las cadenas xyiz i=2,3,4,etc., no están en L, puesto que
tendrán más b’s que a’s.
2) x=λ , y=aj, z=bj
Por simple inspección es claro que las cadenas xyiz i=2,3,4,etc., no están en L, puesto que
tendrán más a’s que b’s.
3) x=aj-h, y=ahbk, z=bj-k
Por simple inspección es claro que las cadenas xyiz i=2,3,4,etc., no están en L, puesto que al
incrementar i –ello es muy claro ya con i=2- obtenemos cadenas del tipo xahbk...ahbkz es decir
con a’s y b’s mezcladas.
Cualquier otra posibilidad será semejante a las ya vistas y su razonamiento es análogo.
Estas contradicciones -agotadas todas las posiblidades para x,y,z- muestran que nuestro
supuesto es falso y que L no es regular.
Mostraremos que L={aj / j un número primo} no es regular –nótese que las longitudes de las
cadenas de L son números primos-.
Supongamos que si lo es, es decir, hay un AFD A tal que T(A)=L, con |K|=n.
Se sabe que L es infinito, luego hay una cadena u∈T(A) -digamos u=aj- tal que |u|=j≥n, con j
un número primo, según el lema u puede reescribirse así u=xyz.
Es claro que, por la propiedad asociativa y conmutativa de la suma de longitudes,
|u| = |xyz| = |x|+|y|+|z| = |xz|+|y| = j, con j primo. Sea |y|=m (m>0 pues y≠λ).
Por el lema de bombeo sabemos que ∀ i≥0 xyiz∈T(A), es decir, ∀ i≥0 xyiz está en L, es decir,
|xyiz| = |xz|+|yi| = |xz| + i |y| = |xz| + im es un número primo ∀ i≥0.
En particular, cuando i=0, |xz|=p es un número primo (es decir, p>1).
Por lo ya dicho, |xz| + im = p + im es un número primo ∀ i≥0, según el lema de bombeo.
Pero por simple inspección es claro que cuando i=p dicho número (p + pm) no es primo
puesto que es divisible por p (p≠1 y p≠p+pm, esto último porque p>1 y m>0).
Esta contradicción muestra que nuestro supuesto está equivocado y L no es regular.
2
Mostraremos que L={ a j / j2 un cuadrado perfecto} no es regular –nótese que las longitudes
de las cadenas de L son cuadrados perfectos-.
Supongamos que si lo es, es decir, hay un AFD A tal que T(A)=L, con |K|=n.
Es claro que L es infinito, luego hay una cadena u∈T(A) tal que |u|≥n, por ejemplo para j=n la
2
cadena u = a n es tal que |u|=n2≥n, por el lema de bombeo u puede reescribirse así u=xyz; por
el mismo lema ∀ i≥0 xyiz∈T(A), en particular con i=2, xyyz está en L, es decir,
|xyyz| es un cuadrado perfecto. Además:
|u|=|xyz|=n2
Como |y|≤|xy|, y como |xy|≤n –por el lema-, resulta que |y|≤n.
Como |xyyz|=|xyz|+|y|, como |xyz|=n2, y como |y|≤n, resulta que |xyyz|≤n2+n
Como n2+n≤n2+2n<n2+2n+1 y como n2+2n+1=(n+1)2, resulta que |xyyz|<(n+1)2
150
Como n2=|xyz|, y como |xyz|<|xyyz| -ya que |y|>0, pues y≠λ-, resulta que n2<|xyyz|.
De ahí, n2<|xyyz|<(n+1)2, es decir, xyyz es una cadena cuya longitud está entre dos cuadrados
perfectos consecutivos, es decir, su longitud no es un cuadrado perfecto, luego por simple
inspección xyyz no está en L.
Esta contradicción muestra que nuestro supuesto está equivocado y que L no es regular.
El teorema de Myhill-Nerode también puede usarse para mostrar que ciertos lenguajes no son
regulares. En efecto, dicho teorema dice que L es regular si y sólo si la relación RL tiene
índice finito. Así, mostrar que la relación RL tiene índice infinito –es decir tiene infinitas
clases de equivalencia- para un L dado, es lo mismo que mostrar que L no es regular.
Recuerde que dos cadenas x,y están en una misma clase de equivalencia en RL cuando
∀ w∈Σ∗ xw ∈ L Ù yw ∈ L.
Por lo mismo dos cadenas x,y no están relacionadas, es decir, están en diferentes clases de
equivalencia cuando ∃ w∈Σ∗ tal que sólo una de las cadenas xw,yw está en L y la otra no.
Este es el criterio que se utiliza: mostrar cadenas -infinitas- que sean distinguibles entre sí, es
decir, que estén en diferentes -infinitas- clases de equivalencia.
Ejemplos:
Mostraremos que L={ajbj / j>0} no es regular.
Sea [a]RL una clase de RL.
Obviamente aa∉[a]RL, pues con w=bb, abb∉L pero aabb∈L.
Sea [aa]RL otra clase de RL. Por razones semejantes aaa∉[a]RL y aaa∉[aa]RL, w=bbb sirve para
ver esto, sea [aaa]RL otra clase de RL.
Podemos extender el razonamiento recurrentemente e indicar la presencia de las siguientes
clases [a]RL, [aa]RL, [aaa]RL, [aaaa]RL, [aaaaa]RL, etc., es decir, RL tiene infinitas clases de
equivalencia, luego L no puede ser regular.
Mostraremos que L={ u∈{a,b}* / u es palíndrome } no es regular.

Sea [ab]RL una clase de RL.
Obviamente aab∉[ab]RL, pues con w=aa, abaa∉L pero aabaa∈L.Sea [aab]RL otra clase de RL.
Por razones semejantes aaab∉[ab]RL y aaab∉[aab]RL, w=aaa sirve para ver esto, sea [aaab]RL
otra clase de RL.
Podemos extender el razonamiento recurrentemente e indicar la presencia de las siguientes
clases [ab]RL, [aab]RL, [aaab]RL, [aaaab]RL, [aaaaab]RL, etc., es decir, RL tiene infinitas clases de
equivalencia, luego L no puede ser regular.
Otros resultados pueden utilizarse para mostrar que un lenguaje dado no es regular. El hecho
de que los lenguajes regulares sean cerrados respecto de la intersección por ejemplo.
Mostraremos que L1={ u∈{a,b}+ / Na(u)=Nb(u) } no es regular.
Supongamos que sí lo es. Sabemos también que L2={a}*.{b}* es regular.
Luego, por la cerradura indicada L=L1∩L2 también es regular. Pero L={ajbj / j>0} y ya
sabemos que L no es regular. Esta contradicción prueba el enunciado.
151
CAPÍTULO 8. GRAMÁTICAS LIBRES DE CONTEXTO
Una Gramática Libre de Contexto (GLC) es una cuádrupla G=(N,T,P,S) donde

N es un alfabeto de No Terminales
S∈N se llama el símbolo raíz de la GLC
P es un conjunto -finito y no vacío- de producciones del siguiente tipo:
A --> α A∈N, α∈(N ∪ T)+
Es decir, a diferencia de las gramáticas regulares, la parte derecha de una producción en una
GLC puede ser cualquier cadena de Terminales o No Terminales, en cualquier orden, de
cualquier longitud, excepto la cadena vacía λ.
Ejemplos:
Esta es la apariencia de una GLC G=({S,A,B},{a,b},P,S)
P:
S --> A
S --> ABBB
A --> aba
A --> aBBAaaA
B --> b
Sea la GLC G=({S},{a,b},P,S)

P:
S --> aSb
S --> ab
Sea L={ajbj / j>0}, probaremos que L=L(G).
L⊆L(G): Por inducción sobre la longitud de las cadenas en L (que genéricamente es 2j).
Caso Base: u∈L, |u|=2 con j=1, es decir, u=ab, por la segunda producción es claro que S=>ab,
es decir, u∈L(G).
Hipótesis Inductiva: sea u∈L con |u|=2k, entonces u∈L(G), es decir, S=>*u
Paso Inductivo: sea u∈L con |u|=2(k+1), es decir, |u|=2k+2, como u está en L, debe ser de la
forma allí indicada, es decir, podemos reescribir lícitamente esta cadena así u=aakbkb=awb,
con |w|=2k además que w∈L. Por hipótesis inductiva S=>*w. Por otra parte, utilizando la
primera producción S=>aSb. Luego S=>aSb=>*awb, es decir, S=>*u, entonces u∈L(G).
L(G)⊆L: Por inducción sobre el número de pasos de derivación.

Caso Base: u∈L(G) y se deriva en un paso, es decir, S=>u, ello sólo puede suceder si se
utiliza la segunda producción y u=ab, pero entonces u∈L (con j=1).
Hipótesis Inductiva: sea u∈L(G) generada en menos de k pasos de derivación, entonces u∈L.
152
Paso Inductivo: Sea u∈L(G) generada en k pasos de derivación. Por la forma de las
producciones podemos desglosar dicha derivación en su primer paso y el resto de los pasos:
S=>aSb=>*awb=u, pero entonces w deriva de S en menos de k pasos, por hipótesis inductiva
w∈L, luego es de la forma aibi (i>0) de donde u=aaibib=ajbj, con j=i+1 (j>0), luego u∈L.

P:
S --> SS
S --> aSb S --> abS S --> Sab
S --> bSa S --> baS S --> Sba
S --> ab
S --> ba
Sea L={u∈{a,b}+ / Na(u)=Nb(u)}, probaremos que L=L(G).
L⊆L(G): Por inducción sobre la longitud de las cadenas en L (que es un número par).
Caso Base: u∈L, |u|=2, es decir, u=ab ó u=ba, por la producción S --> ab es claro que S=>ab,
o bien por la producción S --> ba es claro que S=>ba, es decir, u∈L(G).
Hipótesis Inductiva: Sea u∈L con |u|<k, entonces u∈L(G), es decir, S=>*u
Paso Inductivo: Sea u∈L con |u|=k, como u está en L, debe ser de la forma allí indicada, es
decir, Na(u)=Nb(u); podemos reescribir lícitamente esta cadena de diversas formas: u=awb,
u=bwa, u=abw, u=baw, u=wab ó u=wba, en todas estas posibilidades |w|<k además que
Na(w)=Nb(w), es decir, w∈L, luego por hipótesis inductiva S=>*w. Pero entonces,
S=>aSb=>*awb, utilizando la producción S --> aSb en el primer paso, es decir, S=>*u; o bien
S=>bSa=>*bwa, utilizando la producción S --> bSa en el primer paso, es decir, S=>*u; o bien
S=>abS=>*abw, utilizando la producción S --> abS en el primer paso, es decir, S=>*u; o bien
S=>baS=>*baw, utilizando la producción S --> baS en el primer paso, es decir, S=>*u; o bien
S=>Sab=>*wab, utilizando la producción S --> Sab en el primer paso, es decir, S=>*u; o bien
S=>Sba=>*wba, utilizando la producción S --> Sba en el primer paso, es decir, S=>*u
Está claro que en todos estos casos S=>*u, luego u∈L(G).
Las otras formas de u (por ejemplo cuando empieza y termina con el mismo símbolo) pueden
reescribirse así u=vw con v∈L, w∈L y |v|<k, |w|<k, por hipótesis inductiva S=>*v, así como
S=>*w, pero entonces S=>SS=>*vS=>*vw, utilizando la producción S --> SS en el primer
paso, es decir, S=>*u, luego u∈L(G).
L(G)⊆L: Por inducción sobre el número de pasos de derivación.

Caso Base: u∈L(G) y se deriva en un paso, es decir, S=>u, ello sólo sucede si se utiliza la
producción S --> ab ó S --> ba con u=ab o u=ba, pero entonces u∈L con Na(u)=Nb(u)=1.
Hipótesis Inductiva: Sea u∈L(G) generada en menos de k pasos de derivación, entonces u∈L.
153
Paso Inductivo: Sea u∈L(G) generada en k pasos de derivación. Por la forma de las
producciones podemos desglosar dicha derivación en su primer paso y el resto de los pasos
así:
S=>aSb=>*awb=u, si utilizamos S --> aSb en el primer paso; o bien
S=>bSa=>*bwa=u, si utilizamos S --> bSa en el primer paso; o bien
S=>abS=>*abw=u, si utilizamos S --> abS en el primer paso; o bien
S=>baS=>*baw=u, si utilizamos S --> baS en el primer paso; o bien
S=>Sab=>*wab=u, si utilizamos S --> Sab en el primer paso; o bien
S=>Sba=>*wba=u, si utilizamos S --> Sba en el primer paso;
pero en todos estos casos w deriva de S en menos de k pasos, luego por hipótesis inductiva
w∈L, es decir Na(w)=Nb(w), de donde Na(u)=Na(w)+1=Nb(w)+1=Nb(u), es decir, u∈L.
Si el primer paso se da utilizando S --> SS tenemos: S=>SS=>*wS=>*wv=u; pero aquí tanto w
como v derivan de S en menos de k pasos, luego por hipótesis inductiva w,v∈L, es decir
Na(w)=Nb(w) y Na(v)=Nb(v), de donde Na(u)=Na(w)+Na(v)= Nb(w)+Nb(v)=Nb(u), es decir,
u∈L.
La siguiente GLC G=({S},{a,b},P,S) es tal que L(G)={aibk / i>k, k>0}

P:
S --> aSb S --> aS S --> aab
La siguiente GLC G=({S},{a,b},P,S) es tal que L(G)={aibk / k>i, i>0}

P:
S --> aSb S --> Sb S --> abb
La siguiente GLC G=({S,Z},{a,b,c,d},P,S) es tal que L(G)={aibkckdi / i>0, k>0}

P:
S --> aSd
S --> aZd
Z --> bZc
Z --> bc
La siguiente GLC G=({S,X,Z},{a,b,c,d},P,S) es tal que L(G)={aibickdk / i>0, k>0}

P:
S --> XZ
X --> aXb
X --> ab
Z --> cZd
Z --> cd
Árboles de derivación
Además de la (relación de) derivación que conocemos denotada por =>, podemos realizar el
gráfico de una derivación utilizando árboles en lo que se denomina árboles de derivación.
154
Sea G una GLC, un árbol de derivación A es aquel donde:
i) Cada nodo o vértice tiene una etiqueta en (N ∪ T).
ii) Si un nodo no es hoja entonces su etiqueta está en N y lo denominaremos nodo interior
(salvo el caso del árbol con un solo nodo etiquetado con S).
iii) Si el nodo ni con etiqueta X tiene como hijos a los nodos nj1,..., njm –de izquierda a
derecha- con etiquetas ej1,...,ejm respectivamente, entonces X-->ej1...ejm ∈ P.
Si la etiqueta del nodo raíz es X, podemos referirnos al árbol A como árbol X.
A la cadena conformada por las etiquetas de los nodos hoja del árbol A, leídas de izquierda a
derecha, la llamaremos producto del árbol de derivación.
Un árbol de derivación con su nodo raíz etiquetado con S (símbolo raíz de G) y con producto
w∈T+, se dice que es un árbol de derivación completo (conocido también como parse tree).
Ejemplo:
Sea G=({A,B},{a,b},P,S)
P:
S-->AB A-->aA B-->bB
A-->a B--> b
La cadena aabbb tiene la siguiente derivación:
S=>AB=>AbB=>AbbB=>Abbb=>aAbbb=>aabbb
Y el árbol de derivación correspondiente A es:
Cuyos nodos interiores están todos etiquetados con No Terminales.

Sea n un nodo cualquiera con etiqueta Y de un árbol de derivación A, se denomina subárbol
de derivación (determinado por n) a dicho nodo del árbol junto a todos sus descendientes
(arcos y etiquetas incluidos); este subárbol es en sí mismo un árbol de derivación con su nodo
raíz etiquetado con Y, podemos denotarlo por A n (otros se refieren a él como árbol Y, aunque
esto puede no ser del todo claro si la etiqueta se repite en otros nodos).
Ejemplo:
Si en el árbol de derivación A de arriba denominamos los nodos por niveles de arriba a abajo y
de izquierda a derecha así: n1,n2,...,n11, la etiqueta del nodo n7 es B, y el subárbol A n7 es:
155
cuyo producto es bb.
Operación de reemplazo en árboles

Para una GLC G:
Sea A un árbol de derivación uno de cuyos nodos (n) tiene la etiqueta No Terminal X.
Sea B otro árbol de derivación cuya raíz también tiene la etiqueta X.
Reemplazar B en el nodo n de A es reemplazar el subárbol A n del árbol A por el árbol B, es
decir, borrar en el árbol A el nodo n junto a todos sus descendientes (etiquetas y arcos
incluidos) y en su lugar colocar el árbol B.
Es claro –de la definición de árbol de derivación- que el resultado de reemplazar B en (el nodo
n de) A es un árbol de derivación también.
Ejemplo:
Con la GLC de arriba tenemos el siguiente árbol de derivación B:
B
b
Si reemplazamos B en el nodo n7 de A el resultado es el siguiente nuevo y legítimo árbol de
derivación que podríamos llamar C:
Sea G una GLC y sea A=>*u entonces hay un árbol de derivación A con producto u y cuya
raíz tiene la etiqueta A (un ejemplo de ello es el árbol de derivación A de arriba).
Demostración:
Por inducción sobre el número de pasos derivación.
Caso base: La derivación A=>*u se efectúa en un paso, es decir, A=>u. Pero entonces, la
producción A-->u está en P. Sea u=ej1...ejm, entonces el siguiente es un árbol de derivación
lícito con producto u y cuya raíz tiene la etiqueta A:
156
Alguna literatura se aprovecha de la reflexividad de la clausura reflexiva transitiva de =>, y
trabaja con cero pasos como el caso más pequeño de A=>*u, es decir, u=A y la derivación es
A=>*A, es claro que un árbol con un sólo nodo etiquetado con A es ciertamente un árbol de
derivación que representa la derivación indicada.
Hipótesis inductiva: El enunciado es cierto para derivaciones de menos de k pasos.
Paso inductivo: La derivación A=>*u se efectúa en k pasos. Podemos desglosar lícitamente
esta derivación en su último paso y el resto, es decir, A=>*w=>u. Para el último paso de
derivación debe suceder que w=yXz además que u=yej1...ejmz, donde X-->ej1...ejm∈P.
Dado que la derivación A=>*w toma menos de k pasos por hipótesis inductiva hay un árbol de
derivación A con producto w y cuya raíz tiene la etiqueta A.
Además, dado que X-->ej1...ejm∈P, el siguiente árbol de derivación B también es lícito:
Como dijimos el producto de A es w=yXz, luego si reemplazamos B en A (justamente en el

nodo hoja con etiqueta X) obtendremos un nuevo y legítimo árbol de derivación cuya raíz
tiene la etiqueta A y cuyo producto es yej1...ejmz=u. Lo que prueba el enunciado.
Por otro lado: Sea A un árbol de derivación con etiqueta A en su raíz y con producto u,
entonces hay (por lo menos) una derivación A=>*u.
En efecto, si partimos de un árbol A dado, por ejemplo el primero que graficamos, dicho árbol
puede estar asociado no sólo a una derivación sino a varias, en el caso que estamos
mencionando:
S=>AB=>AbB=>AbbB=>Abbb=>aAbbb=>aabbb
S=>AB=>aAB=>aaB=>aabB=>aabbB=>aabbb
S=>AB=>aAB=>aAbB=>aAbbB=>aAbbb=>aabbb
Demostración:
Por inducción sobre el número de nodos interiores de A.
Caso base: Hay sólo un nodo interior en A. Es decir, A es así:
El producto es u=ej1...ejm, luego –por definición de árbol de derivación- A-->u∈P, es decir, es

posible escribir la siguiente derivación, A=>u, y por ello A=>*u.
Hipótesis inductiva: El enunciado es cierto para árboles con menos de k nodos interiores.
157
Paso inductivo: Sea A un árbol de derivación, con etiqueta A en su raíz y con producto u, que
tiene k nodos interiores. Supongamos que la raíz tiene m nodos hijo cuyas etiquetas de
izquierda a derecha son ej1,...,ejm respectivamente, luego A-->ej1...ejm∈P con eji∈(N ∪ T).
Además, cuando el nodo hijo de la raíz cuya etiqueta eji es un No Terminal entonces dicho
nodo con dicha etiqueta eji es la raíz de un subárbol de A que, como se dijo, es también un
árbol de derivación que tiene la particularidad, en este caso, de tener menos de k nodos
interiores y a cuyo producto denominaremos wi. Luego por hipótesis inductiva, eji=>*wi.
Si la etiqueta eji del nodo hijo de la raíz es un Terminal entonces, por la reflexividad de =>*,
podemos hacer eji=wi y escribir lícitamente eji=>*wi.
Es claro de aquí que u=w1...wm
Pero entonces se puede escribir la siguiente derivación:
A=>ej1...ejm puesto que A-->ej1...ejm∈P
=>w1ej2...ejm puesto que, como ya se argumentó, eji=>*wi
...
=>w1...wm por lo mismo recurrentemente
Es decir A=>*w1...wm, es decir, la derivación A=>*u existe y es lícita.
Conviene recalcar que esta es una de –tal vez- muchas derivaciones posibles para el árbol
dado A.
Sin embargo, si introducimos el concepto de derivación más a la izquierda (derecha) que
limita la forma de derivar, dado un árbol de derivación A con etiqueta A en su raíz y con
producto u, la derivación A=>*u es única y la demostración de ello es prácticamente la que se
acaba de dar (o bien análoga para la derivación más a la derecha) bastando que eji=>*wi se
haga a través de una derivación más a la izquierda.
Derivación más a la izquierda (derecha)

Se dice que en una GLC cualquiera efectuamos una derivación más a la izquierda si, como su
nombre lo indica, siempre reemplazamos (siempre utilizamos, o siempre derivamos a partir
de) el No Terminal que está lo más a la izquierda posible en la derivación en curso.
Por ejemplo, con la primera GLC de arriba:
S=>ABBB=>abaBBB=>ababBB=>ababbB
Es una derivación más a la izquierda, donde hemos puesto en negrita el No Terminal más a la
izquierda en cada paso de derivación. Nótese que no es necesario que una derivación más a la
izquierda termine en cadenas de sólo Terminales.
Formalmente, una derivación u=>*w es una derivación más a la izquierda si cada paso de
derivación es más a la izquierda. Un paso de derivación u=>w es más a la izquierda si u=yXz,
w=yαz, X-->α∈P, z∈(N ∪ T)*, y∈T*.
La derivación más a la derecha se define de manera análoga.
Ambigüedad
Hay otro concepto muy utilizado sobre todo en compilación y reconocimiento de cadenas.
Ya vimos que varias derivaciones distintas (no necesariamente más a la izquierda) A=>*u
pueden tener el mismo árbol de derivación como gráfica.
158
También dijimos que a un árbol de derivación A con producto u y cuya raíz tiene la etiqueta
A, se asocia una única derivación más a la izquierda A=>*u.
Ahora queremos hacer notar que en una GLC G para una misma cadena u si empezamos a
hacer no árboles sino derivaciones -e incluso si sólo efectuamos derivaciones más a la
izquierda- podemos obtener dos o más derivaciones que tienen árboles de derivación distintos
(dos o más).
Ejemplos:
Sea G=({S},{a,b,c,},P={S-->SbS, S-->ScS, S-->a},S)
La derivación S=>*abaca puede hacerse así:
Nótese que en este ejemplo no son derivaciones más a la izquierda todas.
S=>SbS=>SbScS=>SbSca=>Sbaca=>abaca
S=>ScS=>SbScS=>abScS=>abacS=>abaca
Los correspondientes árboles de derivación son.
En este caso, para una misma cadena, se obtuvieron árboles de derivación distintos.
Sea G=({S,A},{a},P={S-->AA,A-->aSa,A-->a},S)
Se obtienen estos dos árboles de derivación para la cadena ‘aaaaa’:
159
Un clásico ejemplo es con G=({S,I,E},{a,b,c,:=,(,*,),+},P,S)
P:
S --> I := E
E --> E+E
E --> E*E
E --> (E)
E --> I
I --> a | b | c
Podemos obtener dos árboles de derivación para la cadena a:=b+c*a:
El valor del resultado de la expresión a la derecha del operador de asignación (:=) tiene,
ambiguamente, dos interpretaciones posibles: b+(c*a) ó (b+c)*a.
Se dice que una GLC G es ambigua cuando hay dos o más árboles de derivación distintos para
una misma cadena.
El último ejemplo muestra que la ambigüedad no es una característica deseable en una GLC.
A veces es posible -para una GLC ambigua- encontrar otra GLC equivalente pero que no sea
ambigua.
Ejemplos:
Sea la GLC G’=({S,A,B},{a},{S-->A,S--> B,A-->a,B-->a},S)
Es ambigua porque tiene árboles de derivación distintos para la cadena ‘a’ (el segundo nodo a
partir de la raíz tiene etiquetas distintas).
Una gramática equivalente, más simple y claramente no ambigua es G=({S},{a},{S-->a},S).
Sea la GLC G’=({S,A},{a},{S-->AA,A-->aSa,A-->a},S) una gramática equivalente que no es

ambigua es G=({S,A},{a},{S-->aaaS,S-->aa},S).
160
En una GLC G no ambigua para una cadena en L(G) hay sólo un árbol de derivación.
En cambio si todas las GLC’s para un lenguaje L dado son ambiguas, se dice que L es
inherentemente ambiguo. Hay lenguajes (por ejemplo L={aibicj / i,j>0}∪{aibjcj / i,j>0}) que
son inherentemente ambiguos pero la demostración de ello suele ser bastante extensa;
finalmente existen pruebas (por ejemplo utilizando el denominado Teorema De Greibach, que
no exponemos) de que el problema de determinar si un lenguaje libre de contexto es
inherentemente ambiguo o no es indecidible.
GLC limpias, reducidas o higienizadas

Hay algunas características –incluso en otras gramáticas además de las libres de contexto- que
impiden seguir ciertos procedimientos interesantes. Se suele decir que estas características son
aspectos "indeseables" de las gramáticas y que por ello debemos limpiar dichas gramáticas
para obtener otras que no tengan estas características indeseables. Es obvio que lo de
indeseable lo admitimos por convención, es posible que siguiendo otros criterios estas
características tengan ventajas y signos positivos.
Una característica indeseable es que una GLC tenga una o más producciones del tipo A-->B,
que se conocen como producciones renombradoras (o unitarias).
Otra característica indeseable es que una GLC tenga No Terminales inaccesibles, es decir,
No Terminales inalcanzables a partir de S, esto es que nunca estén presentes en una derivación
que empiece en el símbolo raíz S. Formalmente el No Terminal X es inaccesible si es
imposible que S=>*yXz con y,z∈(N ∪ T)*.
Otra característica indeseable es que una GLC tenga No Terminales inútiles, es decir, No
Terminales de los que no se puedan derivar sólo Terminales. Lo mismo se puede indicar así:
sea G una GLC y sea X un No Terminal de G, X es inútil si L(G’X)=∅, donde G’X es una
GLC con las mismas producciones que G pero con símbolo raíz X (en lugar de S).
Hay otra característica indeseable que es cuando se tienen producciones borradoras (o
nulas) del tipo A-->λ, nosotros hemos prohibido estas producciones, sin embargo, una
circunstancia especial puede permitirnos manejar temporalmente estas producciones y
limpiarlas luego, veremos esto después.
Una misma GLC G puede tener todas, algunas o ninguna de estas características indeseables.
Ejemplos:
En la GLC G=({S,X},{a},{S-->a,X-->b},S) el No Terminal X es inaccesible.
En la GLC G=({S,X},{a,b},{S-->a,S-->X,X-->Xa},S) el No Terminal X es inútil.
Una misma GLC G puede tener No Terminales útiles e inútiles, No Terminales accesibles e
inaccesibles, etc., lo que se puede ver en el siguiente caso:
Sea la GLC G=({S,X,Y,W,Z},{a,b},P,S)
P:
S --> aS S --> Y S --> bbZ
Y --> a Z --> bZ
X --> Xa X --> b
W --> WaW
161
S es útil; Y es accesible y útil; X es útil pero inaccesible; Z es accesible pero inútil; W es
inaccesible e inútil; la producción S-->Y es renombradora.
Una GLC G libre de características indeseables se dice que está limpia.
Formas normales
Es posible que una GLC no sólo cumpla la definición sino que además posea otras
restricciones en sus partes derechas, así por ejemplo una GLC se dice que es lineal (derecha)
si todas sus producciones son de la forma A-->wX, con A,X∈N y w∈T*. Otras restricciones
han dado paso a lo que se llaman formas normales.
1) Forma normal de Chomsky (FNCH)
Una GLC G se dice que está en FNCH si todas sus producciones son de la forma:
A-->BC A,B,C∈N ó A-->d A∈N, d∈T
Es decir las partes derechas deben tener o un Terminal o dos No Terminales.
2) Forma normal de Greibach (FNG)
Una GLC G se dice que está en FNG si todas sus producciones son de la siguiente forma :
A-->aα A∈N, a∈Τ, α∈N*
Es decir las partes derechas son de un Terminal seguido de 0, 1 o más No Terminales
3) Forma normal cuadrática de Greibach (2FNG)
Se dice que una GLC G está en 2FNG si todas sus producciones son de la forma:
A-->aα A∈N, a∈Τ, α∈N*, |α| < 3
Exactamente lo mismo es decir que todas sus producciones son de la forma:
A-->a ó A-->aB ó A-->aBC A,B,C∈N, a∈Τ
Ejemplos:
La GLC G=({S,A,B,X},{a,b},P,S) está en FNCH
P:
S --> AX
X --> SB
S --> AB
A --> a
B --> b
La GLC G=({S,A,B,X},{a,b},P,S) está en 2FNG y también en FNG

P:
S --> aSB
S --> aB
B --> b
Es claro que toda GLC G que esté en 2FNG está en FNG. La inversa no es cierta, por ejemplo
la GLC G=({S},{a},{S-->aSSSS,S-->a},S) está en FNG pero no en 2FNG.
162
Camino más largo de un árbol de derivación en una GLC en FNCH
Sean G una GLC y A un árbol para la derivación A=>*w.
Un camino de A es una secuencia de nodos nj1,...,njm, tales que nj(i+1) es un nodo hijo de nji.
Nótese que si la GLC G está en FNCH, sus árboles de derivación son árboles binarios.
Por ejemplo para P={S-->AX, X-->SA, S-->a, A-->a} y para la cadena ‘aaaaa’, su árbol de
derivación es:
Donde la línea jaspeada indica un camino en el árbol, desde el nodo
raíz etiquetado con S hasta un nodo hoja que tiene la etiqueta
Terminal ‘a’.
Este camino se lo puede representar así: S-X-S-X-S-a, el cual
evidentemente tiene 6 nodos.
Hay otros caminos, por ejemplo S-A-a, que tiene 3 nodos.
Sin embargo, el camino jaspeado es el camino más largo, es decir el
que tiene más nodos, en este árbol de derivación.
En un árbol de derivación, no hay necesariamente un único camino
más largo. Por ejemplo en este árbol otro camino más largo es:
S-X-S-X-A-a, que también tiene 6 nodos.
En todo caso el(o los) camino(s) más largo(s) de este árbol tiene(n)
6 nodos.
En particular también se puede decir que en este camino más largo
–el jaspeado- la etiqueta X se repite dos veces, y la etiqueta S se
repite tres veces.
Sea G una GLC en FNCH, y A un árbol de derivación para la derivación A=>*w, con w∈T+.
Si A tiene k nodos en su camino más largo, entonces |w|≤2k-2.
Demostración:
Por inducción sobre el número de nodos del camino más largo en A.
Caso base: No puede haber un camino más largo con sólo un nodo que corresponda a una
cadena en T+. Así, en el caso base, si el camino más largo tiene k=2 nodos, eso corresponderá
a una derivación del tipo A=>b, utilizando alguna producción A-->b. Es claro que |b|≤22-2=20,
es decir, es cierto que |b|≤1.
Hipótesis inductiva: El enunciado sigue para k nodos o menos en el camino más largo de A.
Paso inductivo: Supongamos que A es un árbol de derivación para A=>*w con k+1 nodos en
su camino más largo. Como G está en FNCH, el símbolo raíz A debe tener dos hijos cuyas
etiquetas denominaremos D y E, que son, a su vez, raíces de dos subárboles D y E
respectivamente, lo cual podemos graficar ‘en abstracto’ así:
163
Si denominamos u y v a los productos de D y E es claro que D=>*u, E=>*v, w=uv.
Uno de los (sub)árboles –digamos el de u- tiene k nodos en su camino más largo (pues el
árbol para w tiene k+1 nodos en su camino más largo), luego -por hipótesis inductiva- |u|≤2k-2;
el otro (sub)árbol tiene k’ nodos en su camino más largo con k’≤k, luego |v|≤2k’-2≤2k-2. Es
decir, |w|=|u|+|v|≤ 2k-2 +2k-2=2k-1=2(k+1)-2, es decir, |w|≤2(k+1)-2, que demuestra lo indicado.
Cuando la GLC G no está en FNCH una forma análoga de trabajar es considerar al árbol
como m-ario, donde m es el máximo de número de hijos de los nodos.
Poda y expansión
Sea G una GLC y A un árbol de derivación para A=>*w.
Si A tiene algún camino en el que dos nodos de dicho camino –llamémosles ni y nj con i<j, es
decir, con nj descendiente de ni- tienen la misma etiqueta X, entonces los subárboles con
nodos raíz ni y nj respectivamente son, como ya se sabe, árboles de derivación en sí mismos a
los que denominaremos Ai y Aj.
La operación de poda consiste en reemplazar Aj en el nodo ni de A.
La operación de expansión consiste en reemplazar Ai en el nodo nj de A.
El árbol A ‘en abstracto’, Poda de A Expansión de A
se han señalado los nodos
ni y nj
Recordemos que w es el producto de A, llamemos t y x a los productos de Ai y Aj, como X es

la etiqueta de sus raíces, entonces X=>*t y X=>*x; además como nj es descendiente de ni,
resulta que:
i) t=uxv con u,v∈(N ∪ T)*; u es la subcadena (a la izquierda del producto de Aj) que es la
primera parte del producto de Ai; v es la subcadena (a la derecha del producto de Aj) que es la
última parte del producto de Ai; la parte central es obviamente x.
164
ii) w=ytz con y,z∈(N ∪ T)*; y es la subcadena (a la izquierda del producto de Ai) que es la
primera parte del producto de A; z es la subcadena (a la derecha del producto de Ai) que es la
última parte del producto de A; la parte central es obviamente t.
iii) w=yuxvz.
El producto del árbol podado es yxz; el producto del árbol expandido es yuuxvvz.
Nótese que si la GLC G está limpia, entonces no hay producciones renombradoras y por tanto
u,v no pueden ser ambas la cadena vacía y por lo tanto |yxz|<|yuxvz|.
Pero si ni es el nodo raíz de A entonces y,z son ambas la cadena vacía pues A=Ai y w=t.
Cabeza de la parte derecha (de una producción)

Denominaremos cabeza de la parte derecha de una producción en una GLC G al primer
símbolo de dicha parte derecha, por ejemplo en la producción Z-->BcA la cabeza de la parte
derecha es B.
No Terminales recursivos por izquierda de primer orden y de orden mayor

En una GLC G se dice que el No Terminal X es recursivo por izquierda de primer orden si
existen producciones del tipo X-->Xα , es decir, que el No Terminal esté en la parte izquierda
y sea cabeza de la parte derecha.
Si X es recursivo por izquierda entonces en G es posible dar este paso de derivación X=>Xα.
Por ejemplo en el conjunto de producciones P={S-->ZaY,Y-->a,Z-->ZbZZb,Z-->b} la tercera
producción nos permite decir que Z es un No terminal recursivo por izquierda de primer
orden. En efecto, si empezamos una derivación en Z obtendremos: Z=>ZbZZb, es decir, en un
paso de derivación -a partir de Z- este No Terminal ‘reaparece recursivamente’ como el
primer símbolo de la cadena que emerge (en nuestro caso ZbZZb).
En una GLC G se dice que el No Terminal X es recursivo por izquierda de orden mayor si
existen producciones tales que si realizamos una derivación más a la izquierda que empiece en
X, entonces, en dos, tres o más pasos de derivación, se deriva una cadena que incluye a X
como primer símbolo.
Por ejemplo con P={S-->XaZ, Z-->b, X-->ZZY, Z-->YbY, Y-->a, Y-->SbbS} se deriva:
S=>XaZ=>ZZYaZ=>YbYZYaZ=>SbbSbYZYaZ
Hemos puesto en negrita lo que nos interesa, que a partir de S en esta derivación más a la
izquierda, se obtiene una cadena (SbbSbYZYaZ) cuyo primer símbolo es también S. Es decir,
S es un No Terminal recursivo por izquierda de orden mayor.
Lo mismo hubiéramos dicho de X por lo siguiente, si empezamos una derivación en X:
X=>ZZY=>YbYZY=>SbbSbYZY=>XaZbbSbYZY
Con más detalle, el orden es el (menor) número de pasos que se necesitan para que el No
Terminal reaparezca como primer símbolo de una cadena derivada, así X en el último ejemplo
es recursivo por izquierda de cuarto orden.
Lema de bombeo
Sea G una GLC, con |N|=n, limpia y en FNCH. Si w∈L(G) con |w|≥2n entonces
i) w = yuxvz w puede descomponerse en cinco subcadenas
165
ii) |uv| > 0 u y v no son simultáneamente la cadena vacía
iii) |uxv| ≤ 2n
iv) yuixviz ∈ L(G) para todo i≥0
Demostración:
Sea w∈L(G) con |w|≥2n, entonces el árbol de derivación A para S=>*w tiene en su camino más
largo n+2 nodos ó más. En efecto, si dicho árbol tuviera n+1 nodos (o menos) en su camino
más largo, entonces por el resultado de arriba con k=n+1 (o menos), |w|≤2n+1-2, es decir,
|w|≤2n-1 lo que no coincide con nuestro supuesto de que |w|≥2n.
Así pues, A tiene en su camino más largo por lo menos n+2 nodos. Lo que quiere decir que:
a) El último nodo de ese camino más largo es una hoja y tiene como etiqueta un Terminal.
b) Hay n+1 nodos (o más) -antes del último nodo en ese camino más largo- etiquetados con
No Terminales. Pero como sólo hay n No Terminales entonces alguna etiqueta X se repite.
Recogiendo los resultados vistos en poda y expansión (con A=S):
i) La cadena w puede reescribirse como w=yuxvz, una secuencia de 5 subcadenas (y,u,x,v,z).
ii) Como G está limpia, entonces u,v no pueden ser ambas la cadena vacía, es decir |uv|>0.
iii) Podemos suponer sin pérdida de generalidad que el subárbol que empieza en la primera
aparición de X (con producto t=uxv) tiene los últimos n+2 nodos del camino más largo de A,
esto es suficiente para que exista la repetición de la etiqueta X pues –sin contar el nodo hoja-
sólo hay |N|=n No Terminales para los n+1 nodos restantes; este supuesto es posible porque el
árbol A tiene -en su camino más largo- n+2 nodos o más: luego, por el resultado para la
longitud del producto en un camino más largo, |uxv|≤2(n+2)-2, es decir, |uxv|≤2n.
iv) La derivación de w=yuxvz a partir de S se puede representar legítimamente así:
S=>*yXz=>*yuXvz=>*yuxvz
Donde se han usado las dos derivaciones lícitas:
a) X=>*t que la hemos desglosado como X=>*uXv=>*uxv
b) X=>*x
Pero entonces también es posible derivar S=>*yXz=>*yxz (es decir, la poda de A).
Y también, S=>*yXz=>*yuXvz=>*yuuXvvz=>*yuuxvvz (es decir, la expansión de A).
Pero se puede expandir la expansión de A, es decir:
S=>*yXz=>*yuXvz=>*yuuXvvz=>*yuuuXvvvz=>yuuuxvvvz también se puede derivar.
Y así sucesivamente muchas veces, de manera que se puede derivar en general:
S=>*yuiXviz=>yuixviz, es decir, yuixviz ∈ L(G) para todo i≥0.
Algunas veces este lema se enuncia así:
Sea la GLC G, con |N|=n y limpia. Existe un entero e tal que si w∈L(G) con |w|≥e entonces
ii) |uv| > 0 u y v no son simultáneamente la cadena vacía
iii) |uxv| ≤ e
iv) yuixviz ∈ L(G) para todo i≥0
La demostración es la misma suponiendo –sin pérdida de generalidad- que G está en FNCH y
haciendo e=2n.
166
El lema de Ogden
Es una versión más fuerte que el lema de bombeo; en vez de trabajar con toda la cadena w,
limita nuestro foco de atención a alguna porción que marcamos de w (por ejemplo en la
cadena w=aaabbccdd la parte marcada está en negrita).
Sea la GLC G, con |N|=n y limpia. Existe un entero e tal que si w∈L(G) y marcamos por lo
menos e símbolos de w entonces
ii) x contiene algún símbolo marcado
iii) u y v no son simultáneamente libres de símbolos marcados (u.v tiene por lo menos uno)
iv) uxv tiene a lo más e símbolos marcados
v) yuixviz ∈ L(G) para todo i≥0
Demostración:
Supongamos –sin pérdida de generalidad- que G está en FNCH, hagamos e=2n+1 y para
w∈L(G) marquemos e símbolos de w. Sea A el árbol de derivación para S=>*w.
Basaremos todo en la noción de nodo-r. Un nodo-r (nodo de ramificación) es aquel cuyos dos
hijos tienen símbolos marcados en sus productos.
Construiremos un camino-r (es decir, un camino donde se señalan los nodos-r) empezando
con un nodo interior cualquiera así:
Sea n el último nodo añadido al camino-r.
Proceso:
Si n es hoja, terminamos.
Si n tiene dos hijos ni,nj los cuales tienen –ambos- símbolos marcados en sus productos,
señálese a n como nodo-r y añádase al camino-r el hijo con el mayor número de símbolos
marcados en su producto –digamos nj-. Repítase el proceso con nj.
Si n tiene dos hijos ni,nj de los cuales sólo uno de ellos tiene por lo menos un símbolo
marcado en su producto -digamos ni-, añádase ni al camino (nótese que no se señala a ni como
nodo-r). Repítase el proceso con ni.
Denotaremos a un camino-r poniendo en secuencia sus nodos así ni1-...-nih., donde se suponen
señalados los nodos-r.
Como resultado trabajaremos con caminos-r que incluyen nodos-r y probaremos que si un
camino-r construido como se indica arriba contiene q nodos-r entonces ni1 tiene a lo más 2q
símbolos marcados en su producto.
Demostración:
Por inducción sobre el número de nodos-r del camino-r.
Caso base: El camino-r tiene (q=)1 nodo-r. Llamemos nk a dicho nodo-r. Es claro que todos
los descendientes (hijos, nietos, etc.) de nk no son nodos-r.
Para ser un nodo-r, los dos hijos de nk tienen por lo menos un símbolo marcado en sus
productos, es decir, hay por lo menos 2=21=2q símbolo marcados.
No pueden haber más símbolo marcados, si ello sucediera uno de los hijos de nk tendría no
uno sino por los menos dos símbolos marcados en su producto, estos dos símbolos marcados
tendrían que estar en dos nodos hoja, como el árbol es binario estos dos nodos hoja deben
tener un ascendiente (padre, abuelo, etc.) en común (descendiente de nk), que por lo tanto
167
debería ser un nodo-r, pero sólo hay un nodo-r que es nk. Luego, hay a lo más 2q símbolos
marcados.
Hipótesis inductiva: El enunciado es cierto cuando el camino-r tiene q nodos-r.
Paso inductivo: Sea que el camino-r ni1-ni2-...-nih tiene q+1 nodos-r. Hay dos posibilidades,
que ni1 sea un nodo-r o no lo sea.
a) Si ni1 es un nodo-r, entonces hay q nodos-r en el camino ni2-...-nih, por hipótesis inductiva el
producto del subárbol con raíz en ni2 tiene a los más 2q símbolo marcados. Pero ni2 fue elegido
(al señalar ni1 como nodo-r) porque tiene el mayor número de símbolos marcados en su
producto; ni2 es uno de los dos hijos de ni1, por lo tanto el otro hijo de ni1 tiene –igualmente- a
lo más 2q símbolo marcados en su producto. Luego ni1 tiene a lo más 2q+2q=2q+1 símbolos
marcados en su producto.
b) Si ni1 no es un nodo-r, entonces trabajamos con ni2, nótese que el otro hijo de ni1 no tiene
–de acuerdo a nuestra construcción- símbolos marcados en su producto; si ni2 no es un nodo-r,
entonces trabajamos con ni3, etc., hasta tener un nodo-r nij, luego realizamos un razonamiento
análogo al inciso b, con ni(j+1) en lugar de ni2.
Lo que prueba el resultado previo. Continuemos con el lema de Ogden:
Recuerde que A es el árbol de derivación para S=>*w y que se marcan e=2n+1 símbolos de w.
Si construimos un camino-r cuyo primer nodo es el nodo raíz etiquetado con S hasta un nodo
hoja en A y denotamos a dicho camino por ni1-ni2-...-nih, dicho camino-r debe tener por lo
menos n+1 nodos-r, pues si tuviera n nodos-r o menos, por el resultado anterior, el producto w
de ni1 tendría a lo más 2n símbolos marcados, lo que no coincide con nuestro supuesto.
Así pues en ese camino-r con n+1 nodos-r y con sólo |N|=n No Terminales alguna etiqueta X
se repite.
Elijamos exactamente n+1 nodos-r (de dicho camino) lo más abajo posible, por ejemplo de
una hoja marcada hacia arriba. Sea ni el nodo-r con la primera aparición de X, y sea nj el
nodo-r con la segunda aparición de X, luego todo el tratamiento visto en el lema de bombeo
puede repetirse aquí básicamente. Es decir,
El producto de nj es x. El producto de ni es uxv.
ii) Dado que nj es un nodo-r, su producto x contiene algún símbolo marcado.
iii) Sabemos que ni es un nodo-r, que nj es un nodo-r descendiente de ni y que el producto de
ni es uxv. Como ni es un nodo-r sus dos hijos tienen símbolos marcados en sus productos,
digamos que su hijo izquierdo ha sido elegido para ser parte del camino-r, en este caso su hijo
derecho tiene un producto que es parte de v, que –por lo dicho- tiene símbolos marcados. Si su
hijo derecho es el elegido entonces u tiene símbolos marcados. Luego,
u y v no son simultáneamente libres de símbolos marcados.
iv) Hemos elegido los n+1 nodos-r lo más abajo posible, luego el camino-r que empieza en ni
(cuyo producto es uxv) que tiene n+1 nodos-r, por el resultado previo, tiene a lo más 2n+1
símbolos marcados. Es decir, uxv tiene a lo más e símbolos marcados.
v) La derivación de w=yuxvz a partir de S se puede representar legítimamente así:
S=>*yXz=>*yuXvz=>*yuxvz, donde se han usado las dos derivaciones lícitas:
a) X=>*uXv=>*uxv, b) X=>*x , luego yuixviz ∈ L(G) para todo i≥0.
168
CAPÍTULO 9. AUTÓMATAS DE PILA (AP)
Además de los estados K y los alfabetos N y T, los AP’s añaden una estructura de datos que
servirá como memoria: la pila. Hay una variedad de ellos, los más conocidos son los
Autómatas de Pila por pila vacía (APθ) y los Autómatas de Pila por estado final (APe.f.)
AUTÓMATAS DE PILA POR PILA VACÍA (APθ)

Formalmente un Autómata de Pila (APθ) se define así:
A = ( K, Σ, Γ, δ, q0, Z, F ) donde
K : conjunto finito no vacío de estados
Σ : alfabeto de entrada
Γ : alfabeto de la pila
δ : función de transición, se define así δ: K X (Σ ∪ {λ}) X Γ---> 2(K X Γ∗)
q0 : estado inicial del APθ q0∈K
Z: símbolo inicial de la pila Z∈Γ
F : conjunto de estados finales, genéricamente F⊆K, pero en un APθ F=∅
Ejemplo:
La apariencia del APθ A=({q0,q1},{a,b},{Z,X},δ,q0, Z,{}) es así.
δ:
δ(q0,a,Z)={(q0,XZ)}
δ(q0,a,X)={(q0,XX)}
δ(q0,b,X)={(q1,λ)}
δ(q1,b,X)={(q1,λ)}
δ(q1,λ,Z)={(q2,λ)}
Entre las llaves es posible que hayan varios pares en vez de uno (por ejemplo podría haber
otro APθ con una regla de transición así δ(q0,a,X) = {(q0,XX), (q1,XZ), (q2,λ)}) o ninguno (las
reglas de transición que lleguen al conjunto vacío no se escriben).
Nosotros usaremos a veces q0 para el estado inicial, a veces q1 y a veces cualquier otro
nombre, esto no debe causar confusión siempre que se indique cuál es el estado inicial.
Descripciones instantáneas para AP

Los AP tienen sus descripciones instantáneas de las cuales nos valdremos para mostrar el
mecanismo de funcionamiento.
Una descripción instantánea (d.i.) para un AP es una tripleta (qi,u,α), donde
. qi es el estado actual
. u es una cadena (el sufijo de la cadena de entrada que aún no se ha leído/consumido)
. α es el contenido de toda la pila, es decir, es una cadena que leída de izquierda a derecha nos
describe lo que está en la pila del AP de arriba hacia abajo.
169
Un AP siempre empieza su funcionamiento en el estado inicial y con la pila conteniendo
únicamente su símbolo inicial, de manera que si alimentamos al AP con la entrada u al
principio la d.i. inicial será (q0,u,Ζ), fíjese como el tercer componente describe la pila
conteniendo sólo Z, por ejemplo si u=aaabbb, la d.i. inicial es (q0,aaabbb,Ζ).
Movimientos
Indicaremos con el símbolo |-- el hecho de que un AP dé un movimiento, que es con el que
pasamos de una d.i. a otra d.i. (|-- no es sino el nombre de una relación entre d.i.’s).
En los AP’s hay una especie de ‘control avanzado’ sobre la cinta de entrada de manera que no
es necesario consumir un símbolo de entrada para dar un movimiento. El cambio de estado -y
lo que le sucede a la pila- depende (además del estado actual y, tal vez, del símbolo que
estamos leyendo en la entrada) del contenido de la pila, específicamente del símbolo en el
tope de la pila.
Los movimientos son básicamente de dos tipos:
i) Movimiento tipo 1
Sean (qi,aw,Xβ) y (qj,w,γβ) dos d.i. con γ,β∈Γ*, X∈Γ, a∈Σ, w∈Σ*, qi,qj∈K; escribiremos
(qi,aw,Xβ) |-- (qj,w,γβ) si (qj,γ)∈δ(qi,a,X)
Y diremos que hemos dado un movimiento tipo 1 (aquel donde se usa una regla de transición
con un símbolo diferente de λ como segundo elemento de la preimagen, que hemos resaltado
en negrita), por ejemplo δ(q0,a,X)={(q0,XX)} ó δ(q1,a,X)={(q1,λ)}.
Para realizar un movimiento utilizando esta regla de transición es necesario que el estado
actual sea qi, estar analizando/leyendo una a en la cadena de entrada y tener en el tope de la
pila una X. Cuando el AP da un movimiento tipo 1 pasa lo siguiente:
Consume el símbolo a de la entrada y la cabeza lectora avanza un símbolo a la derecha en la
cinta de entrada (es claro que si hay más de un par de imágenes entre llaves se tiene que hacer
una elección de qué par utilizar, genéricamente se elige (qj,γ)); el estado actual cambia a qj; y
el tope de la pila X se reemplaza por γ (hay quien explica esto diciendo que el AP saca X de la
pila colocando γ en su lugar).
Por ejemplo, con la transición δ(q1,a,X)={(q2,YY)} y la d.i. (q1,abbab,XZ), el siguiente
movimiento tipo 1 es posible: (q1,abbab,XZ)|--(q2,bbab,YYZ).
Fíjese que el estado actual cambia de q1 a q2; que se ha consumido a de manera que lo que
queda por analizar de la cadena de entrada es bbab; que en la pila el tope X se reemplaza por
YY; y lo que estaba debajo del tope (Z en nuestro caso) se mantiene tal cual.
ii) Movimiento tipo 2 ó λ-movimiento
Sean (qi,w,Xβ) y (qj,w,γβ) dos d.i. con γ,β∈Γ*, X∈Γ, w∈Σ*, qi,qj∈K; escribiremos
(qi,w,Xβ) |-- (qj,w,γβ) si (qj,γ)∈δ(qi,λ,X)
Y diremos que hemos dado un movimiento tipo 2 o un λ-movimiento (aquel donde se usa una
regla de transición con λ como segundo elemento de la preimagen, que hemos resaltado en
negrita), por ejemplo δ(q0,λ,X)={(q0,XX)} ó δ(q1,λ,X)={(q1,λ)}.
Para realizar un movimiento utilizando esta regla de transición es necesario que el estado
actual sea qi y tener en el tope de la pila una X.
170
Nótese que no interesa qué se está analizando/leyendo en la cinta de entrada. Cuando el AP da
un movimiento tipo 2 pasa lo siguiente:
No se consume ningún símbolo en la entrada, es como si el AP ni siquiera se fijara la cinta de
entrada y la cabeza lectora se queda estática donde estaba (es claro que si hay más de un par
de imágenes entre llaves se tiene que hacer una elección de qué par utilizar, genéricamente se
elige (qj,γ)); el estado actual cambia a qj; y el tope de la pila X se reemplaza por γ.
Por ejemplo, con la transición δ(q2,λ,X)={(q2,YX)} y la d.i. (q2,abbaa,XXZ), el siguiente
movimiento tipo 2 es posible: (q2,abbaa,XXZ) |-- (q2,abbaa,YXXZ).
Fíjese que el estado actual ‘cambia’ de q2 a q2; que se consume nada en la cadena de entrada;
que en la pila el tope X se reemplaza por YX; y lo que estaba debajo del tope (XZ en nuestro
caso) se mantiene tal cual.
Este movimiento de tipo 2 permite que el AP manipule la pila sin leer símbolos de entrada.
En cualquiera de los dos tipos de movimiento, es posible que utilicemos alguna imagen
donde γ=λ, en este caso se sustituye el tope X por λ, que en realidad significa que extraemos
el tope X de la pila sin introducir nada en su lugar (denominada a veces operación pop).
Por ejemplo, con la transición δ(q2,λ,X)={(q2, λ)} y la d.i. (q2,abb,XYZ) el siguiente
movimiento tipo 2 es posible: (q2,abb,XYZ)|--(q2,abb,YZ).
Fíjese que el estado actual ‘cambia’ de q2 a q2; que se no se consume nada en la cadena de
entrada; que en la pila el tope X se extrae; y lo que estaba debajo del tope (YZ en nuestro
caso) se mantiene tal cual.
|--* no es otra cosa que la clausura reflexiva transitiva de |--.
Funcionamiento de un AP
Un AP empieza su trabajo en la d.i. inicial y empieza a dar movimientos.
Cuando ocurra que un AP termine de consumir toda su cadena de entrada, ello se denota con
λ como segundo elemento de una d.i. -genéricamente (qi,λ,α)- en especial si la cadena de
entrada es la cadena vacía ello ocurre desde la d.i. inicial.
Cuando ocurra que un AP vacíe su pila, ello se denota con λ como tercer elemento de una d.i.
-genéricamente (qi,w,λ)−.
Es posible que ambas cosas ocurran a la vez, consumir toda la entrada y vaciar la pila, lo que
se denotará así (qi,λ,λ).
Ejemplo:
Recordemos -y enumeremos- las reglas de transición de nuestro ejemplo:
1) δ(q0,a,Z)={(q0,XZ)}
2) δ(q0,a,X)={(q0,XX)}
3) δ(q0,b,X)={(q1,λ)}
4) δ(q1,b,X)={(q1,λ)}
5) δ(q1,λ,Z)={(q2,λ)}
Empecemos a describir el funcionamiento de este APθ con la cadena de entrada
w=aaabbb:
171
(q0,aaabbb,Ζ) d.i. inicial
|--(q0,aabbb,XΖ) movimiento tipo 1, por la regla 1
|--(q0,abbb,XXΖ) movimiento tipo 1, por la regla 2
|--(q0,bbb,XXXΖ) movimiento tipo 1, por la regla 2
|--(q1,bb,XXΖ) movimiento tipo 1, por la regla 3
|--(q1,b,XΖ) movimiento tipo 1, por la regla 4
|--(q1,λ,Ζ) movimiento tipo 1, por la regla 4 (se ha consumido toda la entrada)
|--(q2,λ,λ) movimiento tipo 2, por la regla 5 (se ha vaciado la pila)
Como sabemos, ello puede resumirse así: (q0,aaabbb,Ζ)|--*(q2,λ,λ).
T(A) lenguaje aceptado por un APθ

En un APθ se dice que una cadena de entrada w ha sido aceptada si a partir de la d.i. inicial
podemos llegar a una d.i. del tipo (qj,λ,λ) con qj∈K, es decir, si (q0,w,Ζ)|--*(qj,λ,λ), en nuestro
ejemplo la cadena ‘aaabbb’ sí es aceptada.
Si hay más de un movimiento posible en una d.i. dada entonces debemos agotar todas,
absolutamente todas, las transiciones posibles para averiguar si la cadena de entrada es o no
aceptada, es decir, para decidir si una cadena es aceptada o no debemos analizar todos los
caminos posibles del árbol de movimientos dibujado para la cadena de entrada -mental o
explícitamente-.
Por ejemplo, con la regla de transición δ(q0,a,Z)={(q0,Z),(q1,λ)} y con la d.i. (q0,a,Ζ), el APθ
puede dar:
|--(q0,λ,Ζ) movimiento tipo 1, por el primer par de la regla (camino 1)
/
(q0,a,Ζ)
\
|-- (q1λ,λ) movimiento tipo 1, por el segundo par de la regla (camino 2)
Este corto ejemplo es más bien simple, podemos imaginar AP’s con muchas reglas de
transición tales que para una cadena de entrada tengan muchas muchos caminos de
movimientos alternativos.
El conjunto de todas las cadenas aceptadas por el APθ se denota por T(A) y es el lenguaje
aceptado por el APθ. Formalmente T(A)={u∈Σ∗ / (q0,u,Ζ)|--*(qj,λ,λ) qj∈K}.
En los AP no siempre se vacía la pila para la cadena de entrada, ni tampoco se consume
siempre toda la cadena pues, siguiendo cierto camino del árbol de movimientos, es posible
que el autómata ya no puede dar ninguno, el caso extremo de esto es que el AP no pueda dar
siquiera un movimiento, en estos casos hay quienes utilizan la expresión ‘el autómata está
bloqueado’ o ‘el autómata se tranca’; también es posible que el autómata dé movimientos
repetitivos sin llegar a ninguna parte.
Por ejemplo en el APθ de arriba (q0,abb,Ζ)|--(q0,bb,XΖ)|--(q1,b,Ζ)|--(q2,b,λ), de modo que la
entrada ‘abb’ no se acepta pues el APθ ya no puede dar más movimientos.
Como otro ejemplo aquí está un APθ que puede girar en ciclos infinitos sin aceptar nada:
A=({q0,q1},{a},{Z,X},δ,q0, Z,{})
172
δ:
δ(q0,λ,Z)={(q1,XZ)}
δ(q1,λ,X)={(q0,λ)}
Donde es posible (q0,a,Ζ)|--(q1,a,XΖ)|--(q0,a,Ζ)|--(q1,a,XΖ)|--(q0,a,Ζ)|--(q1,a,XΖ)|--...
Representación gráfica
Aunque es menos frecuente hay quienes utilizan la siguiente representación gráfica para AP’s:
Cada estado es un nodo.
Si el par (qj,α)∈δ(qi,c,X) con c∈(Σ∪{λ}), se dibuja un arco de qi a qj etiquetado con [c,X; α]
Más ejemplos de APθ’s:

El siguiente APθ acepta T(A)={aibi / i>0}
A=({q0,q1,q2},{a,b},{Z,X},δ,q0,Z,{})
δ(q0,a,Z)={(q0,XZ)}
δ(q0,a,X)={(q0,XX)}
δ(q0,b,X)={(q1,λ)}
δ(q1,b,X)={(q1,λ)}
δ(q1,λ,Z)={(q2,λ)}
El siguiente APθ acepta también T(A)={aibi / i>0}

Fíjese como Z sólo sirve para empezar a trabajar con el APθ y luego desaparece de escena:
A=({q0,q1},{a,b},{Z,X}, δ,q0,Z,{})
δ(q0,a,Z)={(q0,X)}
δ(q0,a,X)={(q0,XX)}
δ(q0,b,X)={(q1,λ)}
δ(q1,b,X)={(q1,λ)}
El siguiente APθ acepta también T(A)={aibi / i>0}

Fíjese como trabajan los dos pares de la última regla en este APθ, para i>1 si elegimos una el
AP puede ‘bloquearse’ sin aceptar cadenas -ya no se mueve de q2- y si elegimos la otra las
cadenas en T(A) se aceptan:
A=({q0,q1,q2},{a,b},{Z,X},δ,q0,Z,{})
δ(q0,a,Z)={(q0,X)}
δ(q0,a,X)={(q0,XX)}
δ(q0,b,X)={(q1,λ)}
δ(q1,b,X)={(q1,λ),(q2,λ)}
173
El siguiente APθ acepta T(A)={aibib / i≥0}
Fíjese como Z puede usarse incluso en el centro y el tope de la pila.
A=({q0,q1},{a,b},{Z},δ,q0,Z,{})
δ(q0,a,Z)={(q0,ZZ)}
δ(q0,b,Z)={(q1,λ)}
δ(q1,b,Z)={(q1,λ)}
El siguiente APθ -un clásico- acepta T(A)={ wcwR / w∈{a,b}* }

A=({q0,q1},{a,b,c},{Z,A,B},δ,q0,Z,{})
δ(q0,c,Z)={(q0,λ)}
δ(q0,a,Z)={(q0,A)}
δ(q0,b,Z)={(q0,B)}
δ(q0,a,A)={(q0,AA)}
δ(q0,b,B)={(q0,BB)}
δ(q0,a,B)={(q0,AB)}
δ(q0,b,A)={(q0,BA)}
δ(q0,c,A)={(q1,A)}
δ(q0,c,B)={(q1,B)}
δ(q1,a,A)={(q1,λ)}
δ(q1,b,B)={(q1,λ)}
Toma de posición, necesidades y errores comunes

Ya advertimos que en ciertos casos hay que tomar posición. Algunos elementos que aquí
presentamos como errores pueden ser aceptados por otras definiciones de AP’s o por variantes
más flexibles, sin embargo, nuestra definición es muy común.
Utilizar la regla δ(q0,a,XZ)={(q0,Z)} para que se de un movimiento si la pila tiene ‘XZ’ en el
tope, o peor, si el contenido de la pila es ‘XZ’ no está de acuerdo con nuestra definición que
sólo acepta preguntar por un símbolo en el tope y por lo tanto es un error.
Utilizar la regla δ(q0,a,X)={(q0,λλλ)} para que se extraigan tres elementos de la pila no está
de acuerdo con nuestra definición que sólo permite extraer un símbolo de la pila, el del tope.
Utilizar la regla δ(q0,a,λ)={(q0,Z)} para que se de un movimiento independientemente de lo
que tenga la pila en el tope, o para preguntar si la pila está vacía es un error pues nuestra
definición exige preguntar por el tope de la pila.
Más que un error es un exagerado respeto a Z el símbolo inicial de la pila, si bien un AP
empieza con sólo este símbolo en su pila, no hay ninguna razón para cambiarlo en el primer
movimiento, o para que aparezca -más tarde- al centro o en el tope de la pila, inclusive varias
veces, por ejemplo la siguiente regla de transición es buena δ(q0,a,Z)={(q0,ZXXZZYY)}.
Aunque no lo subrayamos trabajaremos con el hecho de que (Σ∩Γ)=∅, otra literatura no hace
esta distinción; de igual manera hay quienes aceptan preguntar por un símbolo especial que
denota pila vacía, que no es otra cosa que consultar si la pila está vacía o notaciones
particulares tales como δ(qi,λ,λ)={(qj,λ)} en vez de ∀ X∈Γ δ(qi,λ,X)={(qj,X)}.
174
En este como en otros casos, sin embargo, es posible –con nuestra definición- escribir AP’s de
manera que satisfagan las necesidades que se tengan, utilizando por ejemplo Z como marca de
pila “vacía”, o bien recurriendo a varios estados y/o reglas auxiliares para efectuar ciertos
movimientos complejos:
Por ejemplo, una necesidad común es, dado un símbolo b en la cinta (o bien λ para ignorar la
cinta) y otro X en el tope de la pila, pasar de un estado qi a otro qj extrayendo no sólo X sino
otros símbolos –digamos dos en total, no es difícil generalizar ello-. Podemos hacerlo así,
donde qa denota un estado auxiliar:
δ(qi,b,X)={(qa,λ)}
δ(qa,λ,Y)={(qj,λ)} si Y es el segundo símbolo a extraer, o bien
∀ Y∈Γ δ(qa,λ,Y)={(qj,λ)} o bien otra expresiones del tipo ∀ Y∈Γ-{X}, etc.
Así las reglas δ(qi,b,X)={(qa,λ)} y δ(qa,λ,X)={(qj,λ)} permiten extraer dos X’s por cada b.
Otra necesidad común es extraer una X del tope de la pila por cada dos b’s, lo hacemos con
δ(qi,b,X)={(qa,X)} y δ(qa,b,X)={(qj,λ)}.
Otra necesidad común es añadir una X al tope de la pila por cada dos b’s, lo hacemos con
δ(qi,b,Y)={(qa,Y)} y δ(qa,b,Y)={(qj,XY}.
Otra necesidad común es añadir dos X’s al tope de la pila por cada b, lo hacemos con
δ(qi,b,Y)={(qa,XY)} y δ(qa,λ,X)={(qj,XX}.
Insistimos en que se trabajan dos símbolos por simplicidad y espacio, las mismas reglas dan
idea de cómo generalizar ello a más símbolos.
AUTÓMATAS DE PILA POR ESTADO FINAL (APe.f.)

La definición de los APe.f. es análoga a la de los APθ, así como la idea de movimientos,
descripciones instantáneas, etc.
La diferencia está en que el conjunto de estados finales F no es vacío y en las condiciones
bajo las cuales una cadena es aceptada.
T(A) lenguaje aceptado por un APe.f.

En un APe.f. una cadena de entrada w es aceptada si (q0,w,Ζ)|--*(qj,λ,β) qj∈F, β∈Γ∗.
El conjunto de todas las cadenas aceptadas por el APe.f. A se denota por T(A), el lenguaje
aceptado por A, formalmente T(A)={ w∈Σ∗ / (q0,w,Ζ)|--*(qj,λ,β) qj∈F, β∈Γ∗}.
Nótese que no es necesario que la pila esté vacía –puede estar vacía o no-, β representa el
contenido de la pila, sea cual fuere.
Ejemplo:
El siguiente APe.f. A=({q0,q1,q2},{a,b},{Z,X},δ,q0,Z,{q2}) acepta T(A)={aibi / i>0}
δ(q0,a,Z)={(q0,XZ)}
δ(q0,a,X)={(q0,XX)}
δ(q0,b,X)={(q1,λ)}
δ(q1,b,X)={(q1,λ)}
δ(q1,λ,Z)={(q2,XXX)}
175
Nótese que cuando este APe.f. acepta las cadenas de entrada, la pila no se vacia.
El siguiente APe.f. acepta también T(A)={aibi / i>0}

A=({q0,q1,q2},{a,b},{Z,X},δ,q0,Z,{q2})
δ(q0,a,Z)={(q0,XZ)}
δ(q0,a,X)={(q0,XX)}
δ(q0,b,X)={(q1,λ)}
δ(q1,b,X)={(q1,λ)}
δ(q1,λ,Z)={(q2,λ)}
Nótese que cuando este APe.f. acepta las cadenas de entrada, la pila se vacia.
No Determinismo
El siguiente APθ acepta T(A)={ wwR / w∈{a,b}* }
A=({q0,q1},{a,b},{Z,A,B},δ,q0,Z,{})
δ(q0,a,Z)={(q0,A)}
δ(q0,b,Z) ={(q0,B)}
δ(q0,a,A)={(q0,AA),(q1,λ)}
δ(q0,b,B)={(q0,BB),(q1,λ)}
δ(q0,a,B)={(q0,AB)}
δ(q0,b,A)={(q0,BA)}
δ(q1,a,A)={(q1,λ)}
δ(q1,b,B)={(q1,λ)}
El siguiente APθ acepta T(A)={ w∈{a,b}* / w es palíndrome}

A=({q0,q1},{a,b},{Z,A,B},δ,q0,Z,{})
δ(q0,λ,Z) ={(q1,λ)}
δ(q0,a,Z)={(q0,A),(q1,λ)}
δ(q0,b,Z) ={(q0,B),(q1,λ)}
δ(q0,a,A)={(q0,AA),(q1,A),(q1,λ)}
δ(q0,b,B)={(q0,BB),(q1,B),(q1,λ)}
δ(q0,a,B)={(q0,AB),(q1,B)}
δ(q0,b,A)={(q0,BA),(q1,A)}
δ(q1,a,A)={(q1,λ)}
δ(q1,b,B)={(q1,λ)}
En el segundo APθ |δ(q0,a,Z)+δ(q0,λ,Z)|=3. Más genéricamente los ejemplos anteriores son

tales que, por lo menos para algún qi y para algún X, |δ(qi,a,X)+δ(qi,λ,X)|>1. Es decir, en
algún momento para una d.i. dada es posible dar más de un movimiento. A los AP’s de este
tipo (por estado final o por pila vacía) se les llama No Determinísticos. Inversamente si un AP
(por estado final o por pila vacía) es tal que a lo más un movimiento es posible para cada d.i.,
es decir, |δ(qi,a,X)+δ(qi,λ,X)|≤1, se denomina Determinístico.
176
A los lenguajes aceptados por AP’s (por estado final o por pila vacía) los denominaremos
también lenguajes libres de contexto. Un lenguaje aceptado por un AP Determinístico se
denomina lenguaje libre de contexto determinístico.
Ejemplos:
Para L={ w∈{a,b}* / Na(w)>Nb(w) }
Los siguientes APe.f aceptan L
APe.f No Determinístico APe.f Determinístico
A=({q0,q1,q2,qf},{a,b},{Z,A,B},δ,q0,Z,{qf}) A=({q0,qf},{a,b},{Z,A,B},δ,q0,Z,{qf})
δ: δ:
δ(q0,a,Z)={(q1,AZ)} δ(q0,a,Z)={(qf,Z)}
δ(q1,a,A)={(q1,AA)} δ(qf,a,Z)={(qf,AZ)}
δ(q1,b,A)={(q1,λ)} δ(qf,a,A)={(qf,AA)}
δ(q1,b,Z)={(q2,BZ)} δ(qf,b,A)={(qf,λ)}
δ(q1,a,Z)={(q1,AZ)} δ(qf,b,Z)={(q0,Z)}
δ(q0,b,Z)={(q2,BZ)} δ(q0,b,Z)={(q0,BZ)}
δ(q2,b,B)={(q2,BB)} δ(q0,b,B)={(q0,BB)}
δ(q2,a,B)={(q2,λ)} δ(q0,a,B)={(q0,λ)}
δ(q2,a,Z)={(q1,AZ)}
δ(q2,b,Z)={(q2,BZ)}
δ(q1,λ,A)={(qf,λ)}
Sin embargo, a diferencia de lo que sucede con los AF’s los AP’s No Determinísticos no son
equivalentes a los Determinísticos, es decir, hay lenguajes que son aceptados por AP No
Determinísticos para los cuales no existe ningún AP Determinístico que los acepte.
Ejemplo:
El siguiente APθ No Determinístico acepta L=T(A)={aibi / i>0} ∪ {aib2i / i>0}
A=({q0},{a,b},{Z,Y,W,B},δ,q0,Z,{})
δ:
δ(q0,a,Z)={(q0,WB),(q0,B),(q0,BB),(q0,YBB)}
δ(q0,a,W)={(q0,WB),(q0,B)}
δ(q0,a,Y)={(q0,YBB),(q0,BB)}
δ(q0,b,B)={(q0,λ)}
Sin embargo, probaremos que no existe ningún APe.f. Determinístico que acepte L.
Demostración:
Supongamos que sí existe un APe.f. Determinístico A1=(K1,{a,b},Γ,δ1,q0,Z,F1) tal que
T(A1)=L con K1={q0,...,qm}.
Construimos otro APe.f. A2=(K2,{a,b},Γ,δ2,p0,Z,F2) tal que T(A2)=L con K2={p0,...,pm}.
La idea es que A2 sea un clon de A1 difiriendo solamente en los nombres de los estados.
A partir de A1 y A2 construiremos otro APe.f. A así.
177
El conjunto de estados de A es (K1∪K2).
El estado inicial de A es q0.
El conjunto de estados finales de A es F2.
El alfabeto de A es {a,b,c}.
Es claro que tanto en δ1 como en δ2 cada regla tiene a lo más un par de llegada, pues A1 y A2
son determinísticos.
Las reglas de transición δ de A prácticamente se copian de δ1 y δ2 –obviamente quitando el
subíndice- con los siguientes cambios:
i) Si δ1(qi,d,X)={(qj,α)} está en δ1 -con qi∈F1, d∈{a,b,λ}, X∈Γ- se elimina (qj,α) y en su
lugar colocamos(pj,α), es decir, añadimos δ(qi,d,X)={(pj,α)} a δ.
ii) Si δ2(pi,b,X)={(pj,α)} está en δ2 -con pi∈K2, X∈Γ- en lugar de dicha regla añadimos
δ(pi,c,X)= {(pj,α)}, es decir, las reglas con ‘b’ de A2 se copian colocando en lugar de ‘b’ el
símbolo ‘c’.
iii) Todas las otras reglas de δ1 y δ2 se copian.
Una vez que tenemos las reglas de δ efectuamos –en δ- el siguiente cambio:
iv) Si δ(ri,b,X)={(pj,α)} está en δ -con ri∈(K1∪K2), pj∈K2, X∈Γ- se elimina dicha regla y en
su lugar colocamos δ(ri,c,X)={(pj,α)}. Nótese que primero debe seguirse el inciso i, mismo
que influye en este inciso iv.
Analicemos qué hace este nuevo APe.f. A:
Se sabe que A1 acepta {aibi / i>0}∪{aib2i / i>0}, en particular acepta cadenas en {aibi / i>0}.
Al aceptar una cadena del tipo aibi, A1 siempre acaba en el mismo estado final, pues es
determinista.
Se sabe que A2 acepta {aibi / i>0}∪{aib2i / i>0}, en particular acepta cadenas en {aib2i / i>0}.
Si en la cinta de entrada de A está una cadena w=aibici, en principio se comportará como A1 y
luego de consumir la subcadena aibi de w (está en negrita para que se note) el autómata A
estará en un estado qi que era de aceptación en A1 (qi∈F1) pues A1 acepta cadenas del tipo aibi;
a partir de ahí, por el inciso i primero y por el inciso iv luego, con la primera ‘c’ el autómata A
irá a un estado que era de A2, luego se comportará como A2 –con la novedad que las b’s ahora
están cambiadas por c’s- y, como A2 acepta cadenas del tipo aib2i, terminará consumiendo las
últimas c’s de w y aceptando esta cadena.
Por otro lado, A no puede aceptar otras cadenas que no sean del tipo aibici pues para ir de la
parte que era A1 a la parte que es A2 (que tiene los estados finales) debemos situarnos en un
estado que era final en A1, eso sólo sucede si contamos con una subcadena inicial tipo aibi;
luego –por el inciso i- necesariamente vamos a la parte que era A2, pero eso sucede sólo con el
símbolo ‘b’ cambiado por ‘c’ por el inciso iv, una vez ahí, para aceptar alguna cadena la parte
que era A2 requiere tantas c’s como sean necesarias para alcanzar un tipo de cadena semejante
a aibici, pues A2 es clon de A1, es decir acepta cadenas del tipo aib2i=aibibi que con las b’s
cambiadas por c’s resultan en aibici.
Es decir, A es tal que T(A)={aibici / i>0}, luego este lenguaje es libre de contexto. Pero al final
del subsiguiente capítulo probaremos que este lenguaje no es libre de contexto. Esta
contradicción muestra que nuestro supuesto está equivocado y que no hay ningún APe.f.
Determinístico que acepte L={aibi / i>0}∪{aib2i / i>0}.
178
En el siguiente capítulo veremos que si no hay un APe.f. Determinístico que acepte L,
entonces tampoco hay un APθ Determinístico que acepte L.
Para el próximo ejemplo tómese en cuenta que en el siguiente capítulo probaremos que:
i) Dada una GLC G es posible construir un APθ A (generalmente No Determinístico, como es
el caso de la GLC del ejemplo) tal que L(G)=T(A).
ii) Los lenguajes libres de contexto determinísticos son cerrados respecto de la operación de
complemento.
iii) La intersección de un lenguaje libre de contexto con un lenguaje regular es un lenguaje
libre de contexto.
La siguiente GLC G y el APθ No Determinístico A construido a partir de ella, son tales que
L1=L(G)=T(A)={aibjck / i≠j ∨ i≠k}.
G=({S,S1,S2,Z1,Z2,A,B,C,Z,},{a,b,c},P,S)
P:
S-->S1 S-->S2
S1-->Z S2-->aS2c
S1-->ZC S2-->A
Z-->aZb S2-->AB
Z-->A S2-->C
Z-->B S2-->BC
A-->aA C-->cC
A-->a C-->c
B-->Bb
B-->b
Sin embargo, probaremos que no existe ningún APe.f. Determinístico que acepte L1.
Demostración:
Supongamos que sí existe un APe.f. Determinístico A1=(K1,{a,b,c},Γ,δ1,q0,Z,F1) tal que
T(A1)=L1.
Denominaremos L2 al complemento de L1, luego L2 es libre de contexto determinístico.
Se sabe que L3={aibjck / i,j,k>0 } es regular (la e.r. r=aa*bb*cc* es tal que L(r)=L3).
Luego, L=(L2 ∩ L3) es un lenguaje libre de contexto.
Pero qué es L. El complemento de L1 puede caracterizarse así,
L2 = {aibjck / i=j ∧ i=k}∪R = {aibici / i≥0}∪R, donde R contiene el resto de las cadenas de L2,
por ejemplo las que empiecen con ‘c’, etc.
L=(L3 ∩ L2)={aibjck / i,j,k>0} ∩ ({aibici / i≥0}∪R)={aibici / i>0} que como dijimos resulta libre
de contexto. Pero al final del subsiguiente capítulo probaremos que este lenguaje no es libre
de contexto. Esta contradicción muestra que nuestro supuesto está equivocado y que no hay
ningún APe.f. Determinístico que acepte {aibjck / i≠j ∨ i≠k}.
Ya dijimos que si no hay un APe.f. Determinístico que acepte L1, entonces tampoco hay un
APθ Determinístico que acepte L1.
179
CAPÍTULO 10. CONVERSIONES GENÉRICAS: el caso libre de contexto
Construcción de una GLC limpia a partir de otra GLC cualquiera: limpieza de GLC’s
Si se trabaja con la GLC G tal que L(G)=∅ -cosa que se puede decidir como veremos en el
próximo capítulo-, entonces el resultado de limpiar G será una especial GLC canónica
G’={{S},{a},{S-->aS},S} que es tal que L(G’)=∅. Si bien S es inútil en esta GLC,
recurriremos a esta convención.
i) Eliminación de producciones renombradoras (A-->B):
Sea G una GLC tal que L(G)≠∅, entonces es posible construir otra GLC G’ tal que G’ no
tenga producciones renombradoras y L(G)=L(G’).
Demostración:
Sea la GLC G=(N,T,P,S) cuyos |N|=n No Terminales representaremos por V1,...,Vn.
A partir de G hacemos lo siguiente para construir la GLC G’=(N,T,P’,S) (no tomamos en
cuenta producciones del tipo B-->B que se eliminan directamente):
a) P0={ Vi-->α / Vi-->α∈P y α∉N }
Inicialmente incluimos en P0 todas las producciones de P que no son renombradoras.
b) Para i=1,...,n
DerivadeVi = { Vj∈N / Vj≠Vi y Vi=>*Vj en P}
Pi = Pi-1 ∪ { Vi-->α / Vj∈DerivadeVi y Vj-->α∈Pi-1 }
c) P’ = Pn
Es claro que las producciones en P’no son producciones renombradoras.
Sea w∈L(G’), es decir, S=>*w con producciones de P’, sea η1Viη2=>η1αη2 un paso
cualquiera de esta derivación dado con la producción Vi-->α de P’, η1,η2∈(N∪T)*.
Por un lado, si esta producción se ha añadido a P’ en el inciso a) es que está en P, es decir, se
puede dar este paso en G.
Por otro lado, si esta producción se ha añadido a P’ en el inciso b) es que Vi=>*Vj en P y
Vj-->α∈Pi-1 para algún i, es decir η1Viη2=>*η1Vjη2=>η1αη2, salvo posiblemente el último
paso todos los demás pueden hacerse en P, si Vj-->α ha sido añadido en el inciso b) este
razonamiento se repite recurrentemente de manera que η1Viη2=>*η1αη2 puede hacerse en P.
Es decir cada paso de S=>*w en P’, puede hacerse o simularse en P, es decir, S=>*w también
en P, luego w∈L(G).
Sea w∈L(G) y sea A el árbol de derivación con etiqueta S en su raíz y con producto w,
sabemos que si efectuamos una derivación más a la izquierda entonces la derivación S=>*w es
única. Desglosemos esta derivación más a la izquierda en su último paso y el resto de ellos
S=>*yViz=>yαz=w, con Vi-->α∈P, z∈(N ∪ T)*, y∈T*, sin pérdida de generalidad
supondremos que el último paso no utiliza una producción renombradora (puesto que w∈T*).
Un derivación más la izquierda -efectuada con producciones de P- que empiece en S y derive
una cadena u∈(N ∪ T)* -no necesariamente de sólo Terminales, pero también éstas- cuyo
último paso no utilice una producción renombradora se puede hacer o simular con
producciones de P’: en efecto, ello puede mostrarse por inducción sobre el número de pasos
de la derivación.
180
Caso base: Un paso de derivación, es decir S=>u donde se ha utlizado S-->u∈P que no es
renombradora, pero entonces esta producción se añade a P’ en P0, luego S=>u también en P’.
Paso inductivo: Sea S=>*u una derivación más a la izquierda con producciones de P efectuada
en k pasos, misma que puede desglosarse así S=>*yViz=>yαz=u, con Vi-->α∈P, z∈(N ∪ T)*,
y∈T*, el último paso no utiliza una producción renombradora.
Qué pasa con la primera parte de esta derivación, es decir, con S=>*yViz.
Una posibilidad es que todos sus pasos se hayan dado utilizando producciones renombradoras,
en cuyo caso y=z=λ, u=α lo que hace que esta parte de la derivación sea así
S=>*Vi y toda la derivación de la cadena u sea así S=>*Vi=>α, recordemos que el último paso
utiliza Vi-->α∈P no renombradora y por tanto añadida a P’ en P0, pero entonces como
Vi∈DerivadeS, S-->α∈Ph para algún h, es decir, S-->α∈P’, luego S=>u en P’.
Otra posibilidad es que la derivación más a la izquierda S=>*yViz incluya pasos de derivación
(pueden ser muchos, todos o sólo uno) que utilicen producciones no renombradoras.
Consideremos el último paso de derivación que utiliza una producción no renombradora en
S=>*yViz, dicho paso de derivación obtiene la cadena yVjz, es decir, S=>*yVjz=>*yViz,
puesto que yVjz aparece en el último paso de derivación que utiliza una producción no
renombradora, el resto de los pasos (de yVjz=>*yViz) utiliza sólo producciones
renombradoras.
Por hipótesis inductiva S=>*yVjz puede hacerse o simularse en P’.
Si Vj=Vi, como Vi-->α∈P es no renombradora y por tanto añadida a P’ en P0, entonces
S=>*yViz=>yαz puede hacerse o simularse en P’.
Si Vj≠Vi, es claro que Vi∈DerivadeVj, como Vi-->α∈P es no renombradora, entonces por el
inciso b), Vj-->α∈Ph para algún h, es decir Vj-->α∈P’, luego S=>*yVjz=>yαz puede hacerse o
simularse en P’.
Todo ello muestra que S=>*w puede hacerse o simularse en P’, es decir, w∈L(G’).
Puede obtenerse el conjunto DerivadeVi a través de un grafo de dependencias en una GLC que
es una forma de ver las conexiones entre los No Terminales, para construirlo se forman tantos
nodos como No Terminales haya, y se grafica un arco –sin etiqueta- del nodo Vi al nodo Vj si
y sólo si hay una producción de la forma Vi-->uVjv, donde u y v son cualquier cadena en
(N ∪ T)*. Una variante útil a nuestro propósito es dibujar el grafo de dependencias que resulte
de tomar en cuenta sólo las producciones renombradoras. Con ayuda de este último grafo de
dependencias, Vi=>*Vj si en el grafo hay un camino de Vi a Vj.
Otra alternativa más explícita es la siguiente:
B0 = { Vj / Vi-->Vj∈P y Vj≠Vi }
Bk+1 = Bk ∪ { Vj / Vh∈Bk, Vh-->Vj∈P y Vj≠Vi }
Si Bk=Bk+1 entonces DerivadeVi=Bk
Ejemplo:
Sea la GLC G=({S,A,B,C},{a,b},P,S)
181
P:
S-->A B-->aBb
A-->B C-->ab
B-->C
C-->S
El grafo de dependencias considerando sólo las producciones renombradoras es así:
Hacemos -para estar a tono con la demostración- N={S,A,B,C}={V1,V2,V3,V4}

Detallaremos sólo el cálculo de DerivadeV1(=DerivadeS) escribiendo el resto sin detalle.
B0={A}
B1={A} ∪ { B}={A,B}
B2={A,B} ∪ {B,C}={A,B,C}
B3={A,B,C} ∪ {B,C}={A,B,C}
Como B2=B3 entonces DerivadeV1=DerivadeS={A,B,C}
DerivadeV2=DerivadeA={B,C,S}
DerivadeV3=DerivadeB={C,S,A}
DerivadeV4=DerivadeC={S,A,B}
Las producciones de la GLC G’=({S,A,B,C},{a,b},P’,S) se construyen así:
P0={B-->aBb,C-->ab}
P1={B-->aBb,C-->ab} ∪ {S-->aBb,S-->ab}={B-->aBb,C-->ab,S-->aBb,S-->ab}
P2={B-->aBb,C-->ab,S-->aBb,S-->ab} ∪ {A-->aBb,A-->ab}
P3={B-->aBb,C-->ab,S-->aBb,S-->ab,A-->aBb,A-->ab} ∪ {B-->ab}
P4={B-->aBb,C-->ab,S-->aBb,S-->ab,A-->aBb,A-->ab,B-->ab} ∪ {C-->aBb}
Luego P4=P’:
S-->aBb
S-->ab
B-->aBb
B-->ab
A-->aBb
A-->ab
C-->aBb
C-->ab
ii) Eliminación de No Terminales inútiles:

Sea G una GLC tal que L(G)≠∅, entonces es posible construir otra GLC G’ tal que G’ carezca
de No Terminales inútiles y L(G)=L(G’).
Demostración:
Sea la GLC G=(N,T,P,S), identificaremos todos sus No terminales útiles -y por lo tanto sus
inútiles- así:
Σ0 = T
182
UTIL0 = {}
UTILi+1 = UTILi ∪ {X / X -->α∈P y α∈Σi*} (para i=0,1,...)
Σi+1 = Σi ∪ UTILi+1 (fíjese bien los subíndices)
Si UTILi=UTILi+1 entonces UTILES=UTILi, INUTILES=(N-UTILES).
Σ0 es de sólo Terminales pero los restantes Σ1, Σ2, etc., incluyen -posiblemente- Terminales y
No Terminales. Hay quienes en vez de exigir que α∈Σi* piden que todos los No Terminales de
α estén en UTILi, para el efecto es lo mismo. Es claro que algún momento se cumple la
condición -incluso añadiendo un No Terminal a la vez- pues N es finito.
A partir de G hacemos lo siguiente para construir la GLC G’=(N’=UTILES,T,P’,S).
Se construye P’ eliminando de P todas las producciones en las que aparezcan -donde fuere-
los No Terminales inútiles.
Debemos mostrar que A=>*w con w∈T* si y sólo si A∈UTILES.
Mostramos que si A=>*w entonces A∈UTILES por inducción sobre el número de pasos de
derivación (es obvio que si A está en algún UTILi está en UTILES).
Caso base: A=>w con w∈T* en un paso, es decir, A-->w∈P con w∈T*=Σ0*, luego A está en
UTIL1, es decir, A∈UTILES.
Paso inductivo: Sea que A=>*w con w∈T* en k pasos de derivación. Podemos desglosar esta
derivación así A=>ej1...ejm=>*w1...wm donde A-->ej1...ejm∈P, eji=>*wi, w=w1...wm.
Si eji es un Terminal entonces eji=wi (y eji=>*wi es cierto por la reflexividad de =>*).
Si eji es un No Terminal entonces eji=>*wi se hace en menos de k pasos, por hipótesis
inductiva eji∈UTILES, pero entonces todos estos No Terminales están en algún Σh, luego
ej1...ejm∈Σh* y por tanto A está en UTILh+1, es decir, A∈UTILES.
El hecho de que si A∈UTILES entonces A=>*w sigue de la forma indicada de construir este
conjunto (aunque puede pensarse una inducción sobre i para UTILi pues UTILES no es más
que la reunión de todos estos conjuntos UTILi).
Resta mostrar que L(G)=L(G’).
Recordemos que P’=P-{producciones eliminadas por incluir No Terminales inútiles}, es decir,
P’⊆P, luego es claro que si w∈L(G’), es decir, S=>*w con producciones de P’, lo mismo
puede hacerse en G con las mismas producciones, es decir, w∈L(G).
Si w∈L(G) entonces w∈L(G’): Supongamos que no, que una cadena en L(G) no está en
L(G’). Es decir, S=>*w con producciones de P donde se ha utilizado una producción -que
incluye un No Terminal, digamos X- de G que no está en G’, pero entonces por un lado
X∉N’, y por otro X deriva una cadena de sólo Terminales, es decir, X∈N’(=UTILES), esta
contradicción prueba el enunciado.
Ejemplo:
Sea la GLC G=({S,B,C},{a},P,S)
P:
S-->aBa S-->BC
B-->a C-->aC
183
Σ0={a}
UTIL0={}
UTIL1={} ∪ {B}={B}
Σ1={a,B}
UTIL2={B} ∪ {S,B}={B,S}
Σ2={a,B,S}
UTIL3={B,S} ∪ {S,B}={B,S}
Σ3={a,B,S}
Como UTIL2=UTIL3 entonces N’=UTILES={B,S }, INUTILES={C}
Se construye así la GLC G’=({S,B},{a},{S-->aBa,B-->a},S)
ii) Eliminación de No Terminales inaccesibles:

Sea G una GLC tal que L(G)≠∅, entonces es posible construir otra GLC G’ tal que G’ carezca
de No Terminales inaccesibles y L(G)=L(G’).
Demostración:
Sea la GLC G=(N,T,P,S), identificaremos todos sus No terminales accesibles -y por lo tanto
sus inaccesibles- así:
B0 = { S }
Bi+1 = Bi ∪ { Y / X -->α∈P y X∈Βi y α=uYw u,w∈(N ∪ T)*}
Es decir, Y debe estar en algún lugar en la parte derecha de X-->α.
Si Bi=Bi+1 entonces ACCESIBLES=Bi, INACCESIBLES=N-ACCESIBLES.
A partir de G hacemos lo siguiente para construir la GLC G’=(N’,T’,P’,S).
los No Terminales inaccesibles.
T’=T. N’=ACCESIBLES.
Una interesante generalización es identificar y eliminar los símbolos inaccesibles sean
Terminales o No Terminales:
Z0 = { S }
Zi+1 = Zi ∪ { ej∈(Ν∪Τ) / X -->α∈P y X∈Ζi y α=uejw u,w∈(N ∪ T)*}
Si Zi=Zi+1 entonces ACCESIBLES={X∈Zi / X∈N}, INACCESIBLES=N-ACCESIBLES,
T’={c∈Zi / c∈T}.
los No Terminales inaccesibles.
N’=ACCESIBLES.
Es claro que algún momento se cumple la condición -incluso añadiendo un símbolo a la vez-
pues N y T son finitos.
Mostramos que si S=>*yejz con y,z∈(N ∪ T)*, ej∈(Ν∪Τ) entonces ej∈ACCESIBLES por
inducción sobre el número de pasos de derivación (es obvio que si ej está en algún Zi está en
ACCESIBLES).
Caso base: S=>*yejz en un paso, es decir, S--> yejz∈P, luego ej está en Z1, es decir,
ej∈ACCESIBLES.
184
Paso inductivo: Sea que S=>*yejz en k pasos de derivación. Podemos desglosar esta
derivación así S=>*uAw=>uy’ejz’w donde y=uy’, z=z’w, u,w,y’,z’∈(N ∪ T)*, A-->y’ejz’∈P.
Como S=>*uAw se hace en menos de k pasos, por hipótesis inductiva A está en está en algún
Zh (A∈ACCESIBLES, así como todos los símbolos de u,w), además como A-->y’ejz’∈P,
resulta que ej está en Zh+1, es decir, ej∈ACCESIBLES (así como todos los símbolos de y’,z’).
El hecho de que si ej∈ACCESIBLES entonces S=>*yejz sigue de la forma indicada de
construir este conjunto (aunque puede pensarse una inducción sobre i para Zi pues los
Terminales accesibles y los No Terminales ACCESIBLES no son sino la reunión de todos
estos conjuntos Zi).
Resta mostrar que L(G)=L(G’).
Recordemos que P’ es P-{producciones eliminadas por incluir No Terminales inaccesibles},
es decir, P’⊆P, luego es claro que si w∈L(G’), es decir, S=>*w con producciones de P’, lo
mismo puede hacerse en G con las mismas producciones, es decir, w∈L(G).
Si w∈L(G) entonces w∈L(G’): Supongamos que no, que una cadena en L(G) no está en
L(G’). Es decir, S=>*w con producciones de P donde se ha utilizado una producción -que
incluye un No Terminal, digamos X- de G que no está en G’, pero entonces por un lado x∉N’,
es decir, es imposible que S=>*yXz, por otro lado como la derivación S=>*w que incluye a X
no significa otra cosa que S deriva una cadena que incluye a X (que luego deriva en w), es
decir, X∈N’(=ACCESIBLES), esta contradicción prueba el enunciado.
Ejemplo:
Sea la GLC G=({S,B,C},{a,b},P,S)
P:
S-->aBa
B-->a
C-->ab
Z0={S}
Z1={S} ∪ {a,B}={S,a,B}
Z2={S,a,B} ∪ {a,B}={S,a,B}
Como Z1=Z2 entonces ACCESIBLES={S,B}, INACCESIBLES={C}, T’={a}.
P’:
S-->aBa
B-->a
Dada una GLC G tal que L(G)≠∅, para construir una GLC G’ limpia tal que L(G)=L(G’),
eliminamos –en orden- las producciones renombradoras, los No Terminales inútiles y los No
Terminales inaccesibles. El orden es relevante.
Ejemplo:
Con la GLC G=({S,X,A,B},{a},P,S)
185
P:
S-->X
X-->AB
S-->aa
X-->a A-->a
Si eliminamos primero los No Terminales inaccesibles (ninguno, todos son accesibles), luego
las producciones renombradoras obteniendo {S-->AB,S-->a,X-->AB,S-->aa,X-->a,A-->a} y
finalmente los No Terminales inútiles –{B}- queda el siguiente conjunto de producciones
{ S-->a,S-->aa,X-->a,A-->a } que evidentemente no es de una GLC limpia pues X y A son
inaccesibles.
Construcción de una GLC en FNCH a partir de otra GLC G

Sea G una GLC sin producciones renombradoras, es posible construir otra GLC G’ en FNCH
tal que L(G)=L(G’).
Demostración:
Dada la cadena w denotaremos el reemplazo del símbolo a por el símbolo b en w por w[a/b],
por ejemplo abYbaY[a/b]=bbYbbY, por convención (w)[a/b]=w[a/b].
Denotaremos múltiples reemplazos a la vez por w[a1/b1,...,a2/b2], por ejemplo
(abYba)[a/X,b/Z]=XZYZX.
Si la cadena w no incluye los símbolos de el o los reemplazos queda igual, por ejemplo
YbbY[a/X]=YbbY.
Sea G=(N,T,P,S) con T={a1,...,am}, construimos así la GLC G1=(N1,T,P1,S)
P1 = { (A-->α)[a1/Xa1,...,am/Xam] / A-->α∈P, α∉T }
∪ { Xai-->ai / ai∈T } ∪ { A-->ai / A-->ai∈P, ai∈T }
Es decir, hacemos que todas las partes derechas –excepto las que son de un sólo Terminal-
sean cadenas de No Terminales, además Xai∉N.
N1=N ∪ {Xai / ai∈T}
Como P no tiene producciones renombradoras, entonces si Y-->α∈P1 con α∉T, resulta que
|α|≥2.
L(G)=L(G1). En efecto, para mostrar que si w∈L(G1) entonces w∈L(G), probaremos por
inducción sobre el número de pasos de derivación el enunciado más general siguiente:
Si X=>*w -X∈N, w∈T*- con producciones de P1 entonces X=>*w con producciones de P.
Caso base: X=>*w en un paso de derivación, es decir, X=>w con X-->w∈P1, esta producción
está en P1 sólo porque X-->w∈P, por la última parte de la construcción de P1, recordemos que
X∈N, entonces X=>*w con producciones de P.
Paso inductivo: Sea que X=>*w en k pasos de derivación que pueden desglosarse así:
X=>Z1..Zi..Zm con m≥2, pues las producciones de P1 que no tienen un Terminal en
*
=> w1...wm=w su parte derecha α, tienen |α|≥2.
Además Zi=>*wi, es claro que wi∈T*: Por un lado si Zi∈N, dado que esta derivación toma
menos de k pasos, resulta que, por hipótesis inductiva, la misma puede hacerse con
186
producciones de P. Por otro lado, si Zi∉N, entonces Zi=Xaj, y la derivación Xaj=>*wi debe
hacerse en un paso con wi=aj, pues por la forma de construcción de P1 sólo la producción
Xaj-->aj tiene a Xaj como parte izquierda; además el primer paso de derivación X=>Z1..Zi..Zm
se da porque X-->Z1..Zi..Zm∈P1, o lo que es lo mismo X-->Z1..Xaj..Zm∈P1, entonces por la
forma de construcción de P1, la producción X-->Z1..wi..Zm∈P, recuerde que wi=aj y nótese que
hemos simplificado el razonamiento a un sólo Zi, si más de un Zi∉N, el razonamiento es
semejante, luego como cada uno de los otros Zj=>*wj con producciones de P, resulta que
X=>Z1..wi..Zm=>*w con producciones de P.
Resta mostrar que si w∈L(G) entonces w∈L(G1), también probaremos por inducción sobre el
número de pasos de derivación el enunciado más general siguiente:
Si X=>*w -w∈T*- con producciones de P entonces X=>*w con producciones de P1.
Caso base: X=>*w en un paso de derivación, es decir, X=>w con X-->w∈P. Sea w=ej1...ejm,
si m=1 entonces –por la forma de construir P1- X-->w∈P1, luego X=>*w con producciones de
P1; si m>1, entonces –por la forma de construir P1- las siguientes producciones están en P1:
(X-->ej1...ejm)[a1/Xa1,...,am/Xam] junto a {Xai-->ai / ai∈T}, es decir,
X-->Xj1...Xjm junto a {Xai-->ai / ai∈T}, de donde se desprende que Xji-->eji está en P1, es decir,
Xji=>eji. Luego, con producciones de P1 es posible X=>Xj1...Xjm=>*ej1...ejm.
Paso inductivo: Sea que X=>*w en k pasos de derivación que pueden desglosarse así:
X=>ej1...ejm con m≥2, pues P no tiene producciones renombradoras
=>*w1...wm=w
Donde eji=>*wi -es claro que wi∈T*- en menos de k pasos, es decir, por hipótesis inductiva,
eji=>*wi puede hacerse con producciones de P1.
El primer paso ha debido utilizar la producción X-->ej1...ejm∈P, entonces –por la forma de
construir P1- las siguientes producciones están en P1:
(X-->ej1...ejm)[a1/Xa1,...,am/Xam] junto a {Xai-->ai / ai∈T}, es decir,
X-->Xj1...Xjm junto a {Xai-->ai / ai∈T}, de donde se desprende que Xji-->eji está en P1, es decir,
Xji=>eji. Luego, con producciones de P1 es posible X=>Xj1...Xjm=>*ej1...ejm=>*w1...wm. Es
decir, w∈L(G1).
Sea la GLC G1=(N1,T,P1,S) como se indica arriba, construimos así la GLC G’=(N’,T,P’,S).
P’:
Y --> X1Zj1
Zj1 --> X2Zj2 si Y-->X1...Xm ∈ P1 con m≥3
... los Zji∉N1, son nuevos No Terminales
Zj(m-2) --> Xm-1Xm
A --> α Si A-->α ∈ P1 con |α|≤2
N’ = N1 ∪ { Zji / Zji es un nuevo No Terminal añadido en la construcción de P’}
L(G1)=L(G’). En efecto, mostraremos que si w∈L(G1) entonces w∈L(G’), es decir, si S=>*w
con producciones de P1 entonces S=>*w con producciones de P’.
Sea yAz=>yβz un paso de derivación cualquiera (de S=>*w) dado con la producción A-->β de
P1, la misma puede simularse en P’: si A-->β∈P1 es tal que |β|≤2, por construcción de P’, esta
187
producción está -precisamente- en P’; por otro lado A-->β∈P1 es tal que |β|>2, entonces debe
ser del tipo A-->X1...Xm, otra vez por construcción de P’, las siguientes producciones están en
P’: A-->X1Zj1, Zj1-->X2Zj2,..., Zj(m-2)-->Xm-1Xm, luego en P’ es posible la siguiente derivación
yAz=>yX1Zj1z=>yX1X2Zj2z=>...=>yX1...Xm-2Zj(m-2)z=>yX1...Xmz, es decir, yAz=>*yβz con
producciones de P’. Luego, cada paso en S=>*w con producciones de P1 puede simularse con
producciones de P’, es decir, S=>*w con producciones de P’.
Inversamente, para mostrar que si w∈L(G’) entonces w∈L(G1), probaremos por inducción
sobre el número de pasos de derivación el enunciado más general siguiente:
Si Y=>*w -Y∈N1, w∈T*- con producciones de P’ entonces Y=>*w con producciones de P1.
Caso base: Y=>*w en un paso de derivación, es decir, Y=>w con Y-->w∈P’, por la forma de
las producciones de P’ w=a. Observando la construcción de P’, esta producción está presente
porque Y-->w∈P1, luego Y=>*w con producciones de P1.
Paso inductivo: Sea que Y=>*w en k pasos de derivación, con producciones de P’.
Desglosaremos esta derivación en sus formas genéricas posibles así:
a) Si el primer paso de derivación es así Y=>X1X2 con X1,X2∈N1, donde se ha utilizado la
producción Y-->X1X2∈P’, por la forma de construir P’ debe suceder que Y-->X1X2∈P1.
Luego la derivación es Y=>X1X2=>*w1w2 con w=w1w2, X1=>*w1 y X2=>*w2, estas dos
últimas derivaciones se hacen en menos de k pasos, así -por hipótesis de inducción- pueden
hacerse con producciones de P1, es decir, Y=>*w con producciones de P1.
b) Si el primer paso de derivación es así Y=>X1X2, por la la forma de construir P’ no es
posible que X1∉N1, es decir, X1∈N1.
c) Si el primer paso de derivación es así Y=>X1Zj1 con X1∈N1 y Zj1∉N1 (es un nuevo No
Terminal), donde se ha utilizado la producción Y-->X1Zj1 de P’, entonces por la forma de
construir P’, también deben estar presentes las producciones Zj1-->X2Zj2,...,Zj(m-2)-->Xm-1Xm,
de manera que la derivación es Y=>X1Zj1=>X1X2Zj2=>...=>X1...Xm=>*w1...wm donde
w=w1...wm, X1=>*w1, ... , Xm=>*wm, cada Xj∈N1, estas derivaciones se hacen en menos de k
pasos, luego -por hipótesis de inducción- cada derivación Xj=>*wj puede hacerse con
producciones de P1. Además, las producciones mencionadas están en P’ porque
Y-->X1...Xm∈P1, es decir, es posible derivar Y=>X1...Xm =>*w con producciones de P1.
Ejemplo:
Sea la GLC G=({S,X,Y},{a,b,c},P,S)
P:
S --> Sabcc
S --> XX
X --> XYa
Y --> XSSX
X --> abb
Y --> a
Construimos así la GLC G1=(N1,{a,b,c},P1,S)
188
P1 : Es decir P1:
(S --> Sabcc)[a/Xa,b/Xb,c/Xc] S --> SXaXbXcXc
(S --> XX)[a/Xa,b/Xb,c/Xc] S --> XX
(X --> XYa)[a/Xa,b/Xb,c/Xc] X --> XYXa
(Y --> XSSX)[a/Xa,b/Xb,c/Xc] Y --> XSSX
(X --> abb)[a/Xa,b/Xb,c/Xc] X --> XaXbXb
Xa --> a Xa --> a
Xb --> b Xb --> b
Xc --> c Xc --> c
Y --> a Y --> a
N1={S,X,Y,Xa,Xb,Xc}
A partir de G1 construimos así la GLC G’=(N’,{a,b,c},P’,S)
P’:
De S-->SXaXbXcXc vienen S --> SZ1
Z1 --> XaZ2
Z2 --> XbZ3
Z3 --> XcXc
De X --> XYXa vienen X --> XZ4
Z4 --> YXa
De Y --> XSSX vienen Y --> XZ5
Z5 --> SZ6
Z6 --> SX
De X --> XaXbXb vienen X --> XaZ7

Z7 --> XbXb
Las restantes producciones S --> XX
se copian tal cual Y --> a
pues tienen |α|≤2 Xa --> a
Xb --> b
Xc --> c
N’={S,X,Y,Xa,Xb,Xc,Z1,Z2,Z3,Z4,Z5,Z6,Z7}
Que evidentemente ya está en FNCH y que genera el mismo lenguaje que G.
Eliminación de la recursividad por izquierda de primer orden

Sea G=(N,T,P,S) una GLC limpia, entonces es posible construir otra GLC G’ tal que G’
carece de No Terminales recursivos por izquierda de primer orden y L(G)=L(G’).
Demostración:
Sea X un No Terminal recursivo por izquierda de primer orden en G y llamemos Q al
conjunto de todas las producciones de P con parte izquierda X (Q⊆P).
Podemos dividir Q en dos subconjuntos, ya que X es útil:
{X -->Xα1,...,X-->Xαk} que hacen que X sea recursivo por izquierda de primer orden; y
{X -->β1,...,X-->βm} (βi no tiene a X como cabeza).
189
Construimos la GLC G’=(N’,T,P’,S) como sigue.
P’ = P – ({ X-->Xα1,...,X-->Xαk })
∪ { Zjq-->α1Zjq,...,Zjq-->αkZjq }
∪ { Zjq-->α1, ... , Zjq-->αk }
∪ { X-->β1Zjq,...,X-->βmZjq }
N’ = N ∪ { Zjq / Zjq es un nuevo No Terminal añadido en la construcción de P’}
Nótese que ninguna de las nuevas producciones hace recursiva por izquierda de primer orden
a X. También es claro que Zjq no puede ser recursiva por izquierda de primer orden porque los
αi no contienen a Zjq ya que este No Terminal es nuevo. Es decir, se ha eliminado la
recursividad por izquierda de primer orden de X.
L(G)=L(G’). En efecto, cualquier derivación que involucre al No Terminal X se realiza con
producciones de P si y sólo si se realiza con producciones de P’ (obviamente las derivaciones
que no involucren a X pueden hacerse idénticamente en P y en P’). Analicemos sólo la parte
concerniente a este No Terminal: seguramente tendremos una (sub)derivación de una de estas
dos formas:
a) X=>βj con la producción X-->βj∈P si y sólo si X=>βj con la producción X-->βj∈P’, pues
dicha producción se copia de P a P’.
b) X=>Xαi1=>Xαi2αi1=> ... =>Xαim...αi2αi1=>βjαim...αi2αi1 (m≥1) en P, cuyo último paso
utiliza la producción X-->βj∈P y los restantes producciones X-->αih∈P, si y sólo si
-observando la forma de construir P’- X-->βjZjq∈P’, Zjq-->αihZjq∈P’ y Zjq-->αih∈P’, es decir,
si y sólo si X=>βjZjq=>βjαinZjq=> ... =>βjαim...αi2Zjq=>βjαim...αi2αi1 en P’.
Hacemos lo mismo para cada No Terminal recursivo por izquierda de primer orden, si es que
hay varios.
En rigor para este resultado, no es necesario que G sea una GLC limpia, es suficiente que
además de las producciones X -->Xα1,...,X-->Xαk que hacen que X sea recursivo por
izquierda de primer orden, existan las producciones X -->β1,...,X-->βm (βi no tiene a X como
cabeza).
Ejemplo:
Sea la GLC G=({S,X,B},{a,b},P,S)
P:
S-->aX β1=aX
S-->SaSaX α1=aSaX
X-->Xa
X-->XXX
X-->aBa
X-->ab
B-->aXB
B-->b
Es evidente que tanto X como S son No Terminales recursivos por izquierda de primer orden.
190
Trabajaremos primero con S, ya hemos anotado arriba los αi y los βj. Todo el conjunto de
producciones resultantes se anota a continuación, donde además se destacan los αi y los βj
para el No Terminal X, obviamente Z1 es un Nuevo No Terminal.
S-->aX
Z1-->aSaXZ1
Z1-->aSaX
S-->aXZ1
X-->Xa α1=a
X-->XXX α2=XX
X-->aBa β1=aBa
X-->ab β2=ab
B-->aXB
B-->b
Trabajando ahora con X, finalmente la GLC G’=(N’,{a,b},P’,S) es como sigue, Z2 es nuevo.
P’:
S-->aX
Z1-->aSaX
Z1-->aSaXZ1
S-->aXZ1
Z2-->aZ2
Z2-->XXZ2
Z2-->a
Z2-->XX
X-->aBaZ2
X-->abZ2
X-->aBa
X-->ab
B-->aXB
B-->b
N’={S,X,B,Z1,Z2}
Construcción de una GLC en FNG a partir de otra GLC arbitraria

Previamente necesitamos el siguiente resultado imprescindible.
Sea G=(N,T,P,S) una GLC, sean X,Y∈N con X≠Y, sea X-->αYη∈P con α,η∈(N∪T) *, y sea
{Y-->β1,...,Y-->βm}⊆P el conjunto de todas las producciones de P con parte izquierda Y
entonces la GLC G’=(N,T,P’,S) donde P’= (P – {X-->αYη}) ∪ {X-->αβ1η,...,X-->αβmη} es
tal que L(G)=L(G’).
Demostración:
Mostraremos que cualquier derivación en P’ que involucre el uso de alguna producción
X-->αβjη puede hacerse en P (obviamente las derivaciones que no involucren esta producción
pueden hacerse idénticamente en P y en P’). Analicemos sólo la parte concerniente a esta
producción: seguramente tendremos una (sub)derivación del tipo X=>αβjη, pero la
191
producción X-->αβjη∈P’ porque αYη,Y-->βj∈P, es decir, en P puede hacerse la derivación
X=>αYη=>αβjη.
Inversamente, mostraremos que cualquier derivación en P que involucre el uso de la
producción X-->αYη puede hacerse o simularse en P’ (obviamente las derivaciones que no
involucren esta producción pueden hacerse idénticamente en P y en P’). Analicemos sólo la
parte concerniente a esta producción: seguramente tendremos una (sub)derivación del tipo
X=>αYη, el No Terminal Y debe dar paso –en la derivación- a una otra subcadena, para ello
en P hemos de utilizar alguna producción Y-->βj, un caso -genérico- posible es que la
(sub)derivación sea X=>αYη=>αβjη, pero ambos pasos de derivación pueden simularse en P’
así X=>αβjη utilizando la producción X-->αβjη que está presente en la construcción de este
conjunto de producciones (el caso mencionado es genérico en el sentido que si Y se reemplaza
en un paso de derivación posterior al paso X=>αYη ello no afecta nuestro razonamiento más
que en la descripción de la derivación pues finalmente Y se convertirá en βj).
Al construir P’ a partir de P, es posible que algún(os) No Terminal(es) se haga(n) recursivo(s)
por izquierda de primer orden.
Ejemplo:
Sea la GLC Trabajaremos con la producción S-->YaZ, obviamente S
G=({S,X,B},{a,b},P,S) juega el papel de X en el enunciado, α=λ y η=aZ.
P: {Y-->aZY,Y-->SaS,Y-->b} es el conjunto de todas las
S-->YaZ producciones de P con parte izquierda Y.
Z-->aSa Construimos así la GLC G’=({S,X,B},{a,b},P’,S)
Z-->a P’:
Y-->aZY S-->aZYaZ
Y-->SaS S-->SaSaZ
Y-->b S-->baZ
Z-->aSa
Z-->a
Y-->aZY
Y-->SaS
Y-->b
Cuando este resultado previo se utilice con producciones X-->αYη, que como en el ejemplo
tienen α=λ, es decir, con producciones X-->Yη, nos referiremos al hecho de reemplazar
X-->Yη por X-->β1η,...,X-->βmη -donde{Y-->β1,...,Y-->βm} es el conjunto de todas las
producciones de P con parte izquierda Y- bajo el nombre de reemplazar la cabeza Y (en la
producción X-->Yη por la parte derecha de todas las producciones donde Y es parte
izquierda).
Cuando vimos la FNCH hicimos que todas las partes derechas –excepto las que son de un sólo
Terminal- sean cadenas de No Terminales, de manera muy semejante si a partir de una GLC
con producciones P, construimos otra GLC G1 con producciones
192
P’ = {A-->bα’ / A-->bα∈P, b∈T, α’=α[a1/Xa1,...,am/Xam]} ∪ { Xai-->ai / ai∈T }
Xai∉N, N1 = N ∪ {Xai / ai∈T}. Nos referiremos a esta construcción bajo el nombre de
Mayusculizar P (sus partes derechas, excepto sus cabezas).
La demostración de que L(G)=L(G1) es básicamente la misma que antes.
Ahora sí presentamos el enunciado buscado.
Sea G=(N,T,P,S) una GLC limpia, entonces es posible construir otra GLC G’ en FNG tal que
L(G)=L(G’).
Demostración:
Establecimiento de un orden en N cambiando de nombre a los No Terminales:
Sin pérdida de generalidad podemos cambiar de nombre a los No Terminales por V1,V2, etc.,
estableceremos un orden a partir de los subíndices, así V1<V2<V3 etc.
Por ejemplo si N={S,A,B,C}, lo cambiamos por N={V1,V2,V3,V4}.
Hay que cambiar también los nombres de los No Terminales en el conjunto de producciones.
Se supone que tenemos |N|=n (es decir, n No Terminales)
Procedimiento para construir la GLC G’ en FNG.
Paso 1 de 5:
Establecer un orden en N, cambiando de nombre a los No Terminales en caso de ser
necesario. Tomaremos a P como conjunto de trabajo, todas las condiciones sobre
producciones en lo que sigue se refieren a producciones de P.
Paso 2 de 5:
Para k := 1,..., n
Inicio (para k)
Para j:= 2,..., k-1
Inicio (para j)
Si hay una producción Vk-->Vjα (fíjese que la condición es que k>j)
Entonces Reemplazar la cabeza Vj
Fin (para j)
Si aparece o existe recursividad por izquierda de primer orden para Vk
Entonces eliminarla
Fin (para k)
Paso 3 de 5:
Para i := n-1,..., 1
Inicio (para i)
Si hay una producción Vi-->Vjα con i<j
Entonces Reemplazar la cabeza Vj
Fin (para i)
Para k := 1,..., n
Inicio (para k)
Si hay una producción Zj-->Vkα (Zj es un nuevo No Terminal)
Entonces Reemplazar la cabeza Vk
Fin (para k)
193
Paso 4 de 5:
Mayusculizar P
Paso 5 de 5:
Si es necesario re-nombrar los No Terminales (excepto los nuevos) a como estaban antes.
Aunque esta última GLC ya está en FNG es posible que algunos No Terminales sean
inaccesibles, no es necesario pero es recomendable hacer una nuevo proceso de limpieza.
El procedimiento visto lo que persigue es:
En el paso 2 tener las producciones de la forma Vi-->Vjα con i<j
En el paso 3 tener las producciones de la forma Vi-->aα con α ∈ (N’ ∪ T)*
En el paso 4 tener las producciones de la forma Vi-->aα con α ∈ N’*
P’ es el conjunto de producciones que se obtiene finalmente.
N’ es el conjunto de No Terminales que resulta finalmente, incluye todos los nuevos No
Terminales.
La primera parte del paso 3 también puede ser:
Para i := n,..., 2
Inicio (para i)
Si hay una producción Vj-->Viα con j<i
Entonces Reemplazar la cabeza Vi
Fin (para i)
Dado que los cambios que se hacen en el conjunto de producciones de trabajo resultan de la
eliminación de la recursividad por izquierda de un No Terminal o del reemplazo de una
producción por otras, es claro que -según los resultados previos- L(G)=L(G’).
Ejemplo:
Sea la GLC G2=({S,A,B,X},{a,b},P2,S)
P2 :
S-->A A-->BaX B-->aXB
X-->aAa B-->AaA
X-->a B-->b
Luego del proceso de limpieza se obtiene la siguiente GLC limpia G=({S,A,B,X},{a,b},P,S).
P:
S-->BaX
A-->BaX
X-->a
B-->aXB
X-->aAa
B-->AaA
B-->b
A partir de G construimos así la GLC G’=(N’,P’,{a,b},S)
Haremos N={S,A,B,X}={V1,V2,V3,V4}, con |N|=n=4 No Terminales.
194
Y tomaremos a P como conjunto de trabajo.
Paso 1:
V1-->V3aV4
V2-->V3aV4
V4-->a
V3-->aV4V3
V4-->aV2a
V3-->V2aV2
V3-->b
Paso 2: Con k=1 y k=2 no hay problema; con k=3 si.
En V3-->V2aV2 es evidente que k>j ( 3 > 2), reemplazamos la cabeza V2 así:
Con este reemplazo todas las producciones
son ahora:
V3-->V2aV2
V1-->V3aV4
V2-->V3aV4
se reemplaza por
V4-->a
V3-->aV4V3
V3-->V3aV4aV2
V4-->aV2a
V3-->V3aV4aV2
V3-->b
Es claro que surgió recursividad por izquierda para V3, la eliminamos:

Sabiendo que están las
Se reemplaza por estas:
producciones:
V3-->aV4V3Z
V3-->aV4V3
V3-->bZ
V3-->b
Z-->aV4aV2Z
La producción:
Z-->aV4aV2
V3-->V3aV4aV2
De donde todo el conjunto de producciones es ahora así, Z es un nuevo No Terminal:
V1-->V3aV4
V2-->V3aV4
V4-->a
V4-->aV2a
V3-->aV4V3
V3-->b
V3-->aV4V3Z
V3-->bZ
Z-->aV4aV2Z
Z-->aV4aV2
Terminamos los ciclos del paso 2 y para k=4 no hay problema.
195
Paso 3:
Primer ciclo (fíjese que va de mayor a menor, en nuestro caso de 3 a 1): Para i=3 no hay
problema; para i=2 si.
En V2-->V3aV4 es evidente que i<j (2<3), reemplazamos la cabeza V3 así:
Con este reemplazo el nuevo grupo de
todas las producciones es:
V1-->V3aV4
V2-->V3aV4 V4-->a
V4-->aV2a
se reemplaza por V3-->aV4V3
V3-->b
V2-->aV4V3aV4 V3-->aV4V3Z
V2-->baV4 V3-->bZ
V2-->aV4V3ZaV4 Z-->aV4aV2Z
V2-->bZaV4 Z-->aV4aV2
V2-->aV4V3aV4
V2-->baV4
V2-->aV4V3ZaV4
V2-->bZaV4
Siempre en el primer ciclo del paso 3, también hay problemas con i=1.
En V1-->V3aV4 es evidente que i<j (1< 3), reemplazamos la cabeza V3 así:
Con este reemplazo el nuevo grupo de
todas las producciones es:
V1-->aV4V3aV4
V1-->baV4
V1-->aV4V3ZaV4
V1-->V3aV4 V1-->bZaV4
V4-->a
se reemplaza por V4-->aV2a
V3-->aV4V3
V1-->aV4V3aV4 V3-->b
V1-->baV4 V3-->aV4V3Z
V1-->aV4V3ZaV4 V3-->bZ
V1-->bZaV4 Z-->aV4aV2Z
Z-->aV4aV2
V2-->aV4V3aV4
V2-->baV4
V2-->aV4V3ZaV4
V2-->bZaV4
Segundo Ciclo: no hay problema.
196
Paso 4: Mayusculizando las producciones el resultado es como sigue (con Xa en vez de ‘a’).
V1-->aV4V3XaV4
V1-->bXaV4
V1-->aV4V3ZXaV4
V1-->bZXaV4
V4-->a
V4-->aV2Xa
V3-->aV4V3
V3-->b
V3-->aV4V3Z
V3-->bZ
Z-->aV4XaV2Z
Z-->aV4XaV2
V2-->aV4V3XaV4
V2-->bXaV4
V2-->aV4V3ZXaV4
V2-->bZXaV4
Xa-->a
Podemos dejar ahí el ejemplo o dar el

Paso 5: re-nombrando los No Terminales tenemos G’=(N’,{a,b},P’,S)
P’:
S-->aXBXaX
S-->bXaX
S-->aXBZXaX
S-->bZXaX
X-->a
X-->aAXa
B-->aXB
B-->b
B-->aXBZ
B-->bZ
Z-->aXXaAZ
Z-->aXXaA
A-->aXBXaX
A-->bXaX
A-->aXBZXaX
A-->bZXaX
Xa-->a
N’={S,A,B,X,Z,Xa}
Que ya está en FNG y es además una GLC limpia.
197
Construcción de una GLC G en 2FNG
Sea G una GLC G limpia, entonces es posible construir otra GLC G’ en 2FNG tal que
L(G)=L(G’).
Demostración:
1) A partir de G construimos otra GLC G1=(N1,T,P1,S) en FNG misma que tendrá todas sus
producciones del tipo A-->aα, donde A∈N1, a∈Τ, α∈N1*
2) A partir de G1 efectuamos un proceso de partición prácticamente idéntico al que se hizo en
la FNCH y construimos así la GLC G2=(N2,T,P2,S)
P2 :
Y --> aZj1
Zj1 --> X1Zj2 si Y-->aX1...Xm ∈ P1 con m≥2
... los Zji∉N1, son nuevos No Terminales.
Zj(m-1) --> Xm-1Xm Fíjese que se aplica incluso a las
producciones del tipo A-->aBC
A --> α Si A-->α ∈ P1 con |α|≤2
N2 = N1 ∪ { Zji / Zji es un nuevo No Terminal añadido en la construcción de P2}
La demostración de que L(G1)=L(G2) es básicamente la misma que antes.
Nótese que ahora todas las producciones son del tipo:
A-->a que hemos copiados con A∈N1, ó
A-->aB que hemos copiado con A,B∈N1, ó
A-->aZk que resultan del proceso de partición con A∈N1, Zk un nuevo No Terminal, ó
Zj-->XiZk que resultan del proceso de partición con Xi∈N1 y Zj,Zk nuevos No Terminales
Fíjese que para todos los No Terminales en N1: si son parte izquierda de una producción,
entonces la parte derecha de dicha producción empieza con un Terminal.
Finalmente para construir la GLC G’=(N’,T,P’,S) a partir de G2, no hacemos más que
reemplazar la cabeza Xi (en la producción Zj-->XiZk∈P2 –donde Xi∈N1- por la parte derecha
de todas las producciones donde Xi es parte izquierda).
Es evidente que en este reemplazo, la subcadena que se reemplace -en vez de la cabeza Xi-
será del tipo a, ó aB ó aZk que darán lugar a la GLC en 2FNG que estamos buscando.
Ya demostramos que al reemplazar la cabeza W el lenguaje resultante de la nueva gramática
es l-equivalente a la gramática original, es decir, L(G2)=L(G’).
Ejemplo:
Partiremos de una GLC limpia y en FNG, nos resta dar el segundo paso del procedimiento.
Sea la GLC G1=({S,B,X,Y},{a,b},P1,S) en FNG
P1 :
S-->aBBXX Y-->aB
X-->aSB B-->aXB
B-->bSYS
B-->b
X-->a
198
Construimos así la GLC G2=(N2,{a,b},P2,S)
P2:
De S-->aBBXX vienen S-->aZ1
Z1-->BZ2
Z2-->BZ3
Z3-->XX
Y-->aB se copia Y-->aB
De X-->aSB vienen X-->aZ4
Z4-->SB
De B-->aXB vienen B-->aZ5
Z5-->XB
De B-->bSYS vienen B-->bZ6
Z6-->SZ7
Z7-->YS
B-->b se copia B-->b
X-->a se copia X-->a
N2={S,B,X,Y,Z1,Z2,Z3,Z4,Z5,Z6,Z7}
Finalmente construimos G’=({S,B,X,Y,Z1,Z2,Z3,Z4,Z5,Z6,Z7},{a,b},P’,S) así.
P’:
S-->aZ1 Z1-->aZ5Z2
Y-->aB Z1-->bZ6Z2
B-->aZ5 Z1-->bZ2
B-->bZ6 Z2-->aZ5Z3
B-->b Z2-->bZ6Z3
X-->aZ4 Z2-->bZ3
X-->a Z3-->aZ4X
Z3-->aX
Z4-->aZ1B
Z5-->aZ4B
Z5-->aB
Z6-->aZ1Z7
Z7-->aBS
Que está en 2FNG.
Construcción de un APθ a partir de un APe.f.

Sea A un APe.f., entonces es posible construir un APθ A’ tal que T(A)=T(A’).
Demostración:
La idea es vaciar la pila una vez que estamos en un estado final utilizando un nuevo estado (si
la cadena de entrada no ha sido totalmente analizada seguirá en esa situación).
Sea A=(K,Σ,Γ,δ,q0,Z,F) el APe.f. –Z’∉Γ; q0’,qe∉K -, construimos así el APθ
A’=(K∪{q0’,qe}, Σ, Γ∪{Z’}, δ’, q0’, Z’, {})
199
δ’:
1) δ’(q0’,λ,Z’) = {(q0,ZZ’)}
2) δ’(qi,c,X) = δ(qi,c,X) qi∈K, c∈(Σ ∪ {λ}), X∈Γ
3) δ’(qj,λ,X) = {(qe,X)} qj∈F, X∈Γ∪{Z’}
4) δ’(qe,λ,X) = {(qe,λ)} X∈Γ∪{Z’}
Nótese que el inciso 2 nos dice que copiemos δ.
T(A)=T(A’). En efecto, mostraremos inicialmente que si w∈T(A) entonces w∈T(A’), es
decir, si (q0,w,Ζ)|--*(qj,λ,β) en A con las reglas δ (qj∈F) entonces (q0’,w,Z’)|--*(qe,λ,λ) en A’.
Veamos qué sucede en A’ con la cadena w:
(q0’,w,Z’)|-- (q0,w,ZZ’) por 1
|--*(qj,λ,βZ’) por hipótesis y por 2, qj∈F
|-- (qe,λ,βZ’) por 3
|--*(qe,λ,λ) por 4
*
Es decir, (q0’,w,Z’)|-- (qe,λ,λ) en A’.
Inversamente, si (q0’,w,Z’)|--*(qe,λ,λ) en A’ entonces (q0,w,Ζ)|--*(qj,λ,β) en A (qj∈F).
Analicemos cuándo sucede que (q0’,w,Z’)|--*(qe,λ,λ) en A’:
A partir de (q0’,w,Z’) el único movimiento que se puede dar en A’ es utilizando la regla 1
pues ninguna otra regla tiene a q0’ como estado de partida : (q0’,w,Z’)|-- (q0,w,ZZ’), a partir de
aquí, por la forma de construir δ’, la única forma de consumir toda la cadena w es
consumiéndola con las reglas de 2 (pues las reglas 3 y 4 no consumen símbolos de entrada), la
única forma de llegar al estado qe es partiendo de un estado que era final en F -sin importar el
contenido de la pila- lo que sólo hacen las reglas de 3, y la única forma de vaciar la pila es,
estando en qe, con las reglas 4. Si juntamos estos datos resulta que estando en (q0,w,ZZ’) para
llegar a (qe,λ,λ), debe ocurrir que: (q0,w,ZZ’)|--*(qj,λ,βZ’) con la reglas de 2 y qj∈F. Luego
(qj,λ,βZ’)|--* (qe,λ,λ) con las reglas de 3 y 4.
Pero entonces, como (q0,w,ZZ’)|--*(qj,λ,β Z’) con la reglas de 2 y qj∈F, y como Z’∉Γ, es
decir, ninguna regla de 2 incluye a Z’, debe ser posible que (q0,w,Z)|--*(qj,λ,β) con la reglas de
2 y qj∈F, pero las reglas de 2 no son otras que las reglas de δ, es decir, (q0,w,Z)|--*(qj,λ,β) en
A.
Ejemplo:
Sea el APe.f. A=({q0,q1},{a,b},Γ,δ,q0,Z,F)
Γ={Z}
F={q1}
δ:
δ(q0,a,Z)={(q0,Z),(q1,Z)}
δ(q1,b,Z)={(q0,Z),(q1,Z)}
Construimos así el APθ A’=({q0,q1,q0’},{a,b},{Z,Z’},δ’,q0’,Z’,{})
200
δ’:
δ’(q0’,λ,Z’) = {(q0,ZZ’)}
δ’(q0,a,Z)={(q0,Z),(q1,Z)}
δ’(q1,b,Z)={(q0,Z),(q1,Z)}
δ’(q1,λ,Z)={(qe,λ)}
δ’(q1,λ,Z’)={(qe,λ)}
δ’(qe,λ,Z)= {(qe,λ)}
δ’(qe,λ,Z’)= {(qe,λ)}
Construcción de APe.f. a partir de un APθ

Sea A un APθ, entonces es posible construir un APe.f. A’ tal que T(A)=T(A’).
Demostración:
La idea es simular una pila “vacía” utilizando un nuevo símbolo inicial de la pila llamado Z’.
Cuando estemos en tal situación, es decir cuando tengamos una pila vacía simulada (la pila no
está realmente vacía) transitamos hacia el estado final qf.
Sea A=(K,Σ,Γ,δ,q0,Z,{}) el APθ –Z’∉Γ; q0’,qf∉K-, construimos así el APe.f.
A’=(K∪{q0’,qf}, Σ, Γ∪{Z’}, δ’, q0’, Z’, {qf})
δ’:
1) δ’(q0’,λ,Z’) = {(q0,ZZ’)}
3) δ’(qi,λ,Z’) = {(qf,Z’)} qi∈K
T(A)=T(A’). En efecto, mostraremos inicialmente que si w∈T(A) entonces w∈T(A’), es
decir, si (q0,w,Ζ)|--*(qi,λ,λ) en A entonces (q0’,w,Z’)|--*(qf,λ,Z’) en A’.
Veamos qué sucede en A’ con la cadena w:
(q0’,w,Z’)|-- (q0,w,ZZ’) por 1
|--*(qi,λ,Z’) por hipótesis y por 2
|-- (qf,λ,Z’) por 3
Es decir, (q0’,w,Z’)|--*(qf,λ,Z’) en A’.
Inversamente, si (q0’,w,Z’)|--*(qf,λ,Z’) en A’ entonces (q0,w,Ζ)|-- *(qi,λ,λ) en A.
Analicemos cuándo sucede que (q0’,w,Z’)|--*(qf,λ,Z’) en A’:
A partir de (q0’,w,Z’) el único movimiento que se puede dar en A’ es utilizando la regla 1
pues ninguna otra regla tiene a q0’ como estado de partida : (q0’,w,Z’)|-- (q0,w,ZZ’), a partir de
aquí, por la forma de construir δ’, la única forma de consumir toda la cadena w es
consumiéndola con las reglas de 2 (pues las reglas de 3 no consumen símbolos de entrada), y
la única forma de llegar al estado qf es partiendo de un estado en K con el contenido de la pila
siendo Z’, lo que sólo hace 3.
Si juntamos estos datos resulta que estando en (q0,w,ZZ’) para llegar a (qf,λ,Z’), debe ocurrir
que: (q0,w,ZZ’)|--*(qi,λ,Z’) con la reglas de 2. Luego (qi,λ,Z’)|--* (qf,λ,Z’) con 3. Pero
entonces, como (q0,w,ZZ’)|--*(qi,λ,Z’) con la reglas de 2 y como Z’∉Γ, es decir, ninguna regla
201
de 2 incluye a Z’, debe ser posible que (q0,w,Z)|--*(qi,λ,λ) con la reglas de 2, pero las reglas de
2 no son otras que las reglas de δ, es decir, (q0,w,Z)|--*(qi,λ,λ) en A.
Ejemplo:
Sea el APθ A=({q0,q1,qe},{a,b},{Z},δ,q0,Z,{})
δ(q0,a,Z)= {(q0,Z),(q1,Z)}
δ(q1,b,Z)= {(q0,Z),(q1,Z)}
δ(q1,λ,Z)= {(qe,λ)}
δ(qe,λ,Z)= {(qe,λ)}
Construimos así el APe.f. A’=({q0,q1,q0’},{a,b},{Z,Z’},δ’,q0’,Z’,{qf})
δ’(q0’,λ,Z’) = {(q0,ZZ’)}
δ’(q0,a,Z)= {(q0,Z),(q1,Z)}
δ’(q1,b,Z)= {(q0,Z),(q1,Z)}
δ’(q1,λ,Z)= {(qe,λ)}
δ’(qe,λ,Z)= {(qe,λ)}
δ’(q0,λ,Z’) = {(qf,Z’)}
δ’(q1,λ,Z’) = {(qf,Z’)}
δ’(qe,λ,Z’) = {(qf,Z’)}
Construcción de APθ a partir de una GLC

Sea G una GLC en FNG entonces es posible construir un APθ A tal que L(G)=T(A).
Demostración:
Sea G=(N,T,P,S) una GLC en FNG, construimos así el APθ A=({q0},Τ,N,δ,q0,S,{}).
Nótese que el símbolo inicial de la pila es S y no Z y que tenemos un único estado q0.
δ: (q0,α) ∈ δ(q0,a,X) si X-->aα ∈ P
L(G)=T(A). En efecto, primero mostraremos que si S=>*wα entonces (q0,w,S)|--*(q0,λ,α) por
inducción sobre el número de pasos de derivación.
Caso base: S=>*wα en un paso, es decir, S=>wα lo que sólo puede hacerse si S-->wα∈P,
pero entonces por construcción de A (q0,α)∈δ(q0,w,S), luego en A es posible el siguiente
movimiento (q0,w,S)|--(q0,λ,α), es decir, (q0,w,S)|--*(q0,λ,α).
Paso inductivo: Supongamos que S=>*wα es una derivación más a la izquierda que toma k
pasos. Desglosemos esta derivación más a la izquierda así: S=>*uXβ=>uaηβ donde w=ua,
α=ηβ y X-->aη∈P. Es claro que S=>*uα’ -con α’=Xβ- en menos de k pasos, luego por
hipótesis inductiva (q0,u,S)|--*(q0,λ,α’), es decir, (q0,w,S)|--*(q0,a,Xβ). Además, por
construcción de A, como X-->aη∈P, tenemos que (q0,η)∈δ(q0,a,X), luego es posible dar el
siguiente movimiento (q0,a,Xβ)|--*(q0,λ,ηβ), es decir, en A es posible (q0,w,S)|--*(q0,λ,α) pues
α=ηβ.
Inversamente mostraremos que si (q0,w,S)|--*(q0,λ,α) entonces S=>*wα por inducción sobre el
número de movimientos.
202
Caso base: (q0,w,S)|--*(q0,λ,α) en un paso, es decir, (q0,w,S)|--(q0,λ,α), ello sólo puede
suceder porque (q0,α)∈δ(q0,w,S), lo cual sólo sucede si S-->wα∈P, pero entonces es posible
S=>*wα.
Hipótesis inductiva: El enunciado es cierto para menos de k movimientos.
Paso inductivo: Supongamos que (q0,w,S)|--*(q0,λ,α) en k movimientos. Desglosemos estos
movimientos en su último movimiento y el resto, para ello es bueno recordar que por la forma
de construir δ, las reglas de transición sólo permiten movimientos tipo 1, es decir el último
movimiento de nuestro desglose debe consumir un símbolo y debe preguntar por un tope de
pila que puede tener o no símbolos β debajo de él, de manera que podemos suponer que w=ua,
α=ηβ en este desglose: (q0,ua,S)|--*(q0,a,Xβ)|--(q0,λ,ηβ), donde los primeros movimientos
toman menos de k pasos y pueden dar lugar legítimamente a lo siguiente (q0,u,S)|--*(q0,λ,Xβ);
pero entonces por hipótesis inductiva S=>*uXβ. El último movimiento (q0,a,Xβ)|--(q0,λ,ηβ)
ha debido utilizar una regla donde (q0,η)∈δ(q0,a,X), que está en A sólo porque X-->aη∈P.
Luego, en G es posible S=>*uXβ=>uaηβ, es decir, S=>*wα pues α=ηβ y w=ua.
Por los anteriores resultados tenemos que S=>*wα si y sólo si (q0,w,S)|--*(q0,λ,α), haciendo
α=λ resulta que S=>*w si y sólo si (q0,w,S)|--*(q0,λ,λ), es decir, L(G)=T(A).
Ejemplo:
Sea la GLC en FNG G=({S,B},{a,b},{S-->aSB,S-->aB,B-->b},S)
Construimos así el APθ A=({q0},{a,b},{S,B},δ,q0,S,{})
δ:
δ(q0,a,S)={(q0,SB),(q0,B)}
δ(q0,b,B)= {(q0,λ)}
Alguna literatura sugiere otro procedimiento de construcción del APθ A, el mismo es más
simple y no condiciona a la GLC G -es decir, no es necesario que G esté en forma normal
alguna-, lamentablemente no respeta nuestra convención de que N y T sean disjuntos. A pesar
de ello lo describimos a continuación.
Sea G=(N,T,P,S) una GLC construimos así el APθ A=({q0},Τ,(N∪T),δ,q0,S,{})
Nótese que la pila incluye los símbolos de T.
δ:
1) (q0,α) ∈ δ(q0,λ,X) si X-->α ∈ P
2) δ(q0,a,a) = {(q0,λ)} a∈T
Para el ejemplo de arriba, construimos así el APθ A=({q0},{a,b},{S,B,a,b},δ,q0,S,{})
δ:
δ(q0,λ,S)={(q0,aSB),(q0,aB)}
δ(q0,λ,B)={(q0,b)}
δ(q0,a,a) = {(q0,λ)}
δ(q0,b,b) = {(q0,λ)}
203
Cuasi-gramáticas Libres de Contexto y eliminación de producciones borradoras
Dada nuestra restricción de prohibir producciones borradoras, es decir, producciones del tipo
A-->λ en una GLC, denominaremos cuasi gramática libre de contexto (cuasi-GLC) a una
cuádrupla G=(N,T,P,S) cuyo comportamiento es semejante a las GLC’s y cuyo conjunto de
producciones siguen la definición de las producciones de una GLC excepto por la presencia de
producciones borradoras.
Por ejemplo G=({S},{a},{S-->aSa, S-->λ},S) es una cuasi-GLC.
Las introducimos aquí por ser necesarias para un resultado posterior.
Sea G una cuasi-GLC entonces es posible construir un GLC G’ tal que L(G’)=L(G)-{λ}.
Demostración:
Hacemos notar previamente que una cuasi-GLC no necesariamente genera la cadena vacía,
por ejemplo la cuasi-GLC G=({S,B},{a},{S-->aB,B-->λ},S) es tal que L(G)={a}.
Sea G=(N,T,P,S) una cuasi-GLC.
Sea ANULABLES = { A∈N / A=>*λ }
Identificaremos los No Terminales ANULABLES así:
B0 = {A / A-->λ ∈ P}
Bi+1 = Bi ∪ {A / A-->α, α∈Bi+}
Si Bi=Bi+1 entonces Bi=ANULABLES
Construimos así la GLC G’=(N,T,P’,S).
P’ = { A-->α / A-->α∈P, α≠λ } (*)
∪ { A-->e1e2...em / A-->β0e1β1e2...emβm ∈ P,
m ≥ 1, |β0e1β1e2...emβm| ≥ 2
ei∈(N∪T), βj∈ANULABLES*} (**)
Es decir:
(*) Copiamos todas las producciones de P que no sean borradoras; y
(**) Añadimos las producciones que resulten de hacer lo siguiente:
En todas y cada una de las producciones de las producciones de (*) cuya parte derecha
tenga por lo menos dos símbolos, reemplazar uno o más símbolos ANULABLES de la
parte derecha por λ (es decir, borrar las subcadenas que estén en ANULABLES*).
Excepto si resultare una producción borradora (que por supuesto no se añade).
Mostramos que si A=>*λ entonces A∈ANULABLES por inducción sobre el número de pasos
de derivación (es obvio que si A está en algún Bi está en ANULABLES).
Caso base: A=>λ en un paso, es decir, A-->λ∈P, luego A está en B0, es decir,
A∈ANULABLES.
Paso inductivo: Sea que A=>*λ en k pasos de derivación. Podemos desglosar esta derivación
en su primer paso y los restantes así: A=>ej1...ejm=>*λ donde A-->ej1...ejm∈P, eji=>*λ.
Es claro que cada eji es un No Terminal pues los Terminales no pueden derivar λ; como
eji=>*λ toma menos de k pasos, por hipótesis inductiva eji∈ANULABLES, pero entonces
ej1,...,ejm están en algún Bh, luego la cadena ej1...ejm∈Bh+ y por tanto A está en Bh+1, es decir,
A∈ANULABLES.
204
El hecho de que si A∈ANULABLES entonces A=>*λ sigue de la forma indicada de construir
este conjunto (aunque puede pensarse una inducción sobre i para Bi pues ANULABLES no es
más que la reunión de todos estos conjuntos Bi).
Resta mostrar que L(G’)=L(G)-{λ}. En efecto, mostraremos por inducción sobre el número
de pasos de derivación el enunciado general siguiente:
Si A=>*w (w≠λ) en G, entonces A=>*w en G’.
Caso base: A=>w en un paso de derivación en G con A-->w∈P (w≠λ), es claro por (*) que
esta producción está en P’, luego A=>*w en G’.
Paso inductivo: Sea que A=>*w en k pasos de derivación con producciones de P (w≠λ).
Desglosaremos esta derivación en su primer paso y los restantes así:
A=>w0X1w1X2w2...Xmwm=>*w0v1w1v2w2...vmwm así pues w=w0v1w1v2w2...vmwm, donde en el
primer paso se ha utilizado A-->w0X1w1X2w2...Xmwm∈P con m≥1, Xi∈N, wj∈T* y donde
Xj=>*vj en menos de k pasos con producciones de P. Si vj≠λ por hipótesis inductiva Xj=>*vj
con producciones de P’, en cambio si vj=λ es claro que Xj∈ANULABLES.
Sea Yj=Xj si vj≠λ, Yj=λ en otro caso: por (**) es claro que A-->w0Y1w1Y2w2...Ymwm está en
P’. Luego, A=>w0Y1w1Y2w2...Ymwm=>*w0v1w1v2w2...vmwm puede hacerse en G’.
Inversamente, mostraremos que si A=>*w en G’ entonces A=>*w en G.
Cuando la derivación A=>*w en G’ utiliza sólo producciones que estaban en P, es obvio que
puede hacerse en G. Supongamos que un paso cualquiera de la derivación A=>*w en G’ se
hace utilizando una producción (nueva) de P’ que no estaba en P: sea αAη=>αe1e2...emη
dicho paso de derivación efectuado con la producción A-->e1e2...em∈P’, por la forma de
construir P’ dicha producción está presente porque A-->β0e1β1e2...emβm∈P con
βj∈ANULABLES*, es decir, βj=>*λ. Pero entonces en G es posible la derivación
αAη=>αβ0e1β1e2...emβmη=>*αe1e2...emη, es decir, αAη=>*αe1e2...emη, luego el paso de
derivación αAη=>αe1e2...emη con una producción de P’ puede simularse en P.
Ejemplo:
Sea la cuasi-GLC G=({S,A,B,F},{a,b},P,S)
P:
S -->aSb
S -->BaA
S -->abF
S-->ABA
S-->A
F-->ASA
A-->λ
B-->λ
Primero calculamos ANULABLES:
B0={A,B}
B1=B0 ∪ {A / A-->u, u∈B0+}={A,B} ∪ {S}={A,B,S}
205
B2=B1 ∪ {A / A-->u, u∈B1+}={A,B,S} ∪ {S,F}={A,B,S,F}
B3=B2 ∪ {A / A-->u, u∈B2+}={A,B,S,F} ∪ {S,F}={A,B,S,F}
Como B2=B3 entonces B2=ANULABLES={A,B,S,F}
Luego G’=({S,A,B,F},{a,b},P’,S)
P’:
De (*) De (**) vienen
vienen
S -->ab borrando S en S -->aSb
S -->aSb S -->Ba borrando A en S-->BaA
S -->BaA S -->aA borrando B en S-->BaA
S -->abF S -->a borrando A,B en S-->BaA
S-->ABA S-->abF borrando F en S-->abF
S-->A S-->BA borrando A en S-->ABA (la primera A)
F-->ASA S-->AB borrando A en S-->ABA (la segunda A)
S-->AA borrando B en S-->ABA
S-->B borrando A en S-->ABA (ambas)
S-->A borrando A,B (ó B,A) en S-->ABA
F-->SA borrando A en F-->ASA (la primera A)
F-->AS borrando A en F-->ASA (la segunda A)
F-->AA borrando S en F-->ASA
F-->S borrando A en F-->ASA (ambas)
F-->A borrando A,S (ó S,A) en F-->ASA
Construcción de una GLC a partir de un APθ

Inicialmente, sea A un APθ entonces es posible construir una cuasi-GLC G tal que
L(G)=T(A).
Demostración:
Sea el APθ A=(K,Σ,Γ,δ,q0,Z,{}), construimos así la cuasi-GLC G=(N,Σ,P,S)
N = {S} ∪ {[qi,X,qj]} qi,qj∈K, X∈Γ
Nótese que los No Terminales son tripletas, salvo S.
P:
1) [qi,X,qkm]-->c[qj,Y1,qk1][qk1,Y2,qk2][qk2,Y3,qk3]...[qk(m-2),Ym-1,qk(m-1)][qk(m-1),Ym,qkm]
c∈(Σ ∪ {λ}), Yj∈Γ, qki∈K si (qj,Y1Y2...Ym)∈δ(qi,c,X)
2) [qi,X,qj]-->c c∈(Σ ∪ {λ}) si (qj,λ)∈δ(qi,c,X)
3) S-->[q0,Z,qi] qi∈K
En 1, fíjese muy atentamente las coincidencias de los qki. Por ejemplo el qkm de la parte
izquierda es el mismo que el qkm de la última terna de la parte derecha.
L(G)=T(A).
En efecto, mostraremos por inducción sobre el número de pasos de derivación que si
[qi,X,qj]=> *w entonces (qi,w,X)|--*(qj,λ,λ).
206
Caso base: [qi,X,qj]=>w en un paso de derivación con [qi,X,qj]-->w∈P, por la forma de
construir P esta producción está presente porque (qj,λ)∈δ(qi,w,X), luego (qi,w,X)|--*(qj,λ,λ) es
posible en A, sea que w=λ o que w es un símbolo de Σ.
Paso inductivo: Sea que [qi,X,qj]=>*w en k pasos de derivación con producciones de P.
Desglosaremos esta derivación en su primer paso y los restantes así:
[qi,X,qj]=>c[qh,Y1,qk1][qk1,Y2,qk2][qk2,Y3,qk3]...[qk(m-2),Ym-1,qk(m-1)][qk(m-1),Ym,qj]=>*cw1...wm,
así pues w=cw1...wm, con c∈(Σ∪{λ}) y donde en el primer paso se ha utilizado
[qi,X,qj]-->c[qh,Y1,qk1][qk1,Y2,qk2][qk2,Y3,qk3]...[qk(m-2),Ym-1,qk(m-1)][qk(m-1),Ym,qj]∈P, por la
forma de construir P dicha producción está presente porque (qh,Y1Y2...Ym)∈δ(qi,c,X).
Además [qh,Y1,qk1]=>*w1, [qk(m-1),Ym,qj]=>*wm y [qk(n-1),Yn,qkn]=>*wn para n=2,...,m-1 en
menos de k pasos, por hipótesis inductiva (qh,w1,Y1)|--*(qk1,λ,λ), (qk(m-1),wm,Ym)|--*(qj,λ,λ) y
(qk(n-1),wn,Yn)|--*(qkn,λ,λ) para n=2,...,m-1. Luego, en A es posible:
(qi, cw1...wm,X)|--(qh,w1...wm,Y1Y2...Ym)|--*(qk1,w2...wm,Y2...Ym)|--*(qk(m-1),wm,Ym)|--*(qj,λ,λ).
Es decir, (qi,w,X)|--*(qj,λ,λ) pues w=cw1...wm.
Inversamente, mostraremos por inducción sobre el número de movimientos que
si (qi,w,X)|--*(qj,λ,λ) entonces [qi,X,qj]=>*w.
Caso base: (qi,w,X)|--(qj,λ,λ) en un movimiento, lo cual sucede cuando (qj,λ)∈δ(qi,w,X), pero
entonces por construcción de P [qi,X,qj]-->w está presente, luego [qi,X,qj]=>w, es decir,
[qi,X,qj]=>*w.
Paso inductivo: Sea que (qi,w,X)|--*(qj,λ,λ) en k movimientos. Desglosémoslos en el primer
movimiento y los restantes haciendo w=cw1...wm, c∈(Σ∪{λ}), así:
(qi,cw1...wm,X)|--(qh,w1...wm,Y1Y2...Ym)|--*(qj,λ,λ)
Donde el primero movimiento ha utilizado la regla (qh,Y1Y2...Ym)∈δ(qi,c,X), por la forma de
construir P [qi,X,qj]-->c[qh,Y1,qk1][qk1,Y2,qk2][qk2,Y3,qk3]...[qk(m-2),Ym-1,qk(m-1)][qk(m-1),Ym,qj]
está presente.
Y donde (qh,w1,Y1)|--*(qk1,λ,λ), (qk(m-1),wm,Ym)|--*(qj,λ,λ) y (qk(n-1),wn,Yn)|--*(qkn,λ,λ) para
n=2,...,m-1 en menos de k movimientos. Por hipótesis inductiva [qh,Y1,qk1]=>*w1,
[qk(m-1),Ym,qj]=>*wm y [qk(n-1),Yn,qkn]=>*wn para n=2,...,m-1 son posibles en P. Luego en G es
posible la derivación
[qi,X,qj]=>c[qh,Y1,qk1][qk1,Y2,qk2][qk2,Y3,qk3]...[qk(m-2),Ym-1,qk(m-1)][qk(m-1),Ym,qj]
=>*cw1[qk1,Y2,qk2][qk2,Y3,qk3]...[qk(m-2),Ym-1,qk(m-1)][qk(m-1),Ym,qj]
=>*cw1...wm-1[qk(m-1),Ym,qj]
=>*cw1...wm-1wm
Es decir, [qi,X,qj]=>*w pues w=cw1...wm.
Con X=Z y qi=q0 los resultados anteriores dicen que (q0,w,Z)|--*(qj,λ,λ) si y sólo si
[q0,Z,qj]=>*w, además S=>*[q0,Z,qj] por 3), luego (q0,w,Z)|--*(qj,λ,λ) si y sólo si S=>*w, es
decir, L(G)=T(A).
207
Ejemplo:
Sea el siguiente APθ A=(K,Σ,Γ,δ,q0,Z,{})
K={q0,q1}, Σ={a,b}, Γ={Z,B}
δ:
δ(q0,a,Z)= {(q0,ZB)}
δ(q0,λ,Z) = {(q1,λ)}
δ(q1,b,B)= {(q1,λ)}
Que acepta T(A)={ aibi / i≥0 }
Construimos así la cuasi-GLC G=(N,{a,b},P,S)
N={S,[q0,Z,q0],[q0,Z,q1],[q1,Z,q0],[q1,Z,q1],[q0,B,q0],[q0,B,q1],[q1,B,q0],[q1,B,q1]}
P:
1) [q0,Z,qk2]-->a[q0,Z,qk1][qk1,B,qk2] qk1,qk2∈K que viene de (q0,ZB)∈δ(q0,a,Z)
Es decir,
[q0,Z,q0]-->a[q0,Z,q0][q0,B,q0]
[q0,Z,q0]-->a[q0,Z,q1][q1,B,q0]
[q0,Z,q1]-->a[q0,Z,q0][q0,B,q1]
[q0,Z,q1]-->a[q0,Z,q1][q1,B,q1]
2) [q0,Z,q1]-->λ que viene de (q1,λ)∈δ(q0,λ,Z) (nótese que la producción es borradora)
[q1,B,q1]-->b que viene de (q1,λ)∈δ(q1,b,B)
3) S-->[q0,Z,q0]
S-->[q0,Z,q1]
No es necesario pero por claridad haremos un cambio de nombre en los No Terminales así:
Reemplazaremos [q0,Z,q1] por A, [q0,Z,q0] por B, [q0,B,q0] por C, [q0,B,q1] por D, [q1,B,q0]
por E y [q1,B,q1] por F.
De donde las producciones de la cuasi-GLC son P:
S-->B
S-->A
A-->λ
F-->b
B-->aBC
B-->aAE
A-->aBD
A-->aAF
Ahora sí, consideramos el enunciado buscado, sea A un APθ entonces es posible construir una
GLC G’ tal que L(G’)=T(A)-{λ}.
Demostración:
Sea el APθ A=(K,Σ,Γ,δ,q0,Z,{})
Partiendo de A construimos la cuasi-GLC G tal que L(G)=T(A) como se indica arriba.
208
Y a partir de la cuasi-GLC G construimos la GLC G’ tal que L(G’)=L(G)-{λ} como se indicó
antes, es decir, eliminando las producciones borradoras de G. Dado que L(G)=T(A), entonces
L(G’)=T(A)-{λ}. No es necesario pero recomendamos limpiar la GLC G’.
Ejemplo:
Vamos a continuar el ejemplo de la cuasi-GLC G de antes.
Para eliminar las producciones borradoras de esta cuasi-GLC y construir así la GLC G’
primero calculamos ANULABLES:
B0={A}
B1=B0 ∪ {A / A-->u, u∈B0+}={A} ∪ {S}={A,S}
B2=B1 ∪ {A / A-->u, u∈B1+}={A,S}
Como B1=B2 entonces B1=ANULABLES={A,S}
Luego G’=({S,A,B,C,D,E,F},{a,b},P’,S)
P’:
S-->B
S-->A
F-->b
B-->aBC
B-->aAE
A-->aBD
A-->aAF
B-->aE borrando A en B-->aAE
A-->aF borrando A en A-->aAF
Nótese que no podemos añadir S-->λ (borrando A en S-->A pues resulta una producción
borradora).
Si queremos podemos continuar la limpieza de la gramática para obtener finalmente
G’=({S,A,F},{a,b},P’,S)
P’:
S --> aF
S --> aAF
A --> aAF
A --> aF
F --> b
Nótese que esta GLC G’ genera L(G)={ aibi / i>0 }=T(A)-{λ}.
Construcción de un APe.f. determinístico a partir de un APθ determinístico

Sea A un APθ determinístico entonces es posible construir un APe.f determinístico A’ tal que
T(A)=T(A’).
Demostración:
Sea el APθ A=(K,Σ,Γ,δ,q0,Z,{}) –Z’∉Γ; q0’,qf∉K-, construimos así el APe.f
A’=(K∪{q0’,qf}, Σ, Γ∪{Z’}, δ’, q0’, Z’, {qf})
209
δ’:
1) δ’(q0’,λ,Z’) = {(q0,ZZ’)}
3) δ’(qi,λ,Z’) = {(qf,Z’)} qi∈K
La demostración de que T(A)=T(A’) es semejante a la que se hizo con AP’s arbitrarios.
Ninguna regla de los incisos 2 y 3 incluye a q0’, luego para cualquier símbolo W
|δ’(q0’,a,W)+δ’(q0’,λ,W)|≤1, en realidad |δ’(q0’,λ,Z’)|=1 por el inciso 1.
Todas las reglas del inciso 2 preservan la propiedad |δ’(qi,a,X)+δ’(qi,λ,X)|≤1 pues A es
determinístico y ninguna incluye a q0’ ni a Z’ usadas en las reglas de 1 y 3.
Finalmente la regla del inciso 3 pregunta por el tope Z’ y desde un estado en K, ninguna del
inciso 2 lo hace porque Z’∉Γ, además aunque la regla del inciso 1 pregunta por el tope Z’ lo
hace desde q0’ y q0’∉K, es decir, |δ’(qi,a,Z’)+δ’(qi,λ,Z’)|≤1 con qi∈K, en realidad
|δ’(qi,λ,Z’)|=1 con qi∈K.
Luego el APe.f A’ es determinístico.
Una forma alternativa de enunciar este resultado es así: Si existe un APθ determinístico que
acepte L entonces existe un APe.f. determinístico que acepte L. Cuya contrarrecíproca es:
Si no existe un APe.f. determinístico que acepte L entonces no existe un APθ determinístico
que acepte L.
Sin embargo el otro enunciado: Si existe un APe.f. determinístico que acepte L entonces
existe un APθ determinístico que acepte L, es falso.
Para probar ello mostraremos un lenguaje que sea aceptado por un APe.f. determinístico pero
que no sea aceptado por ningún APθ determinístico.
Es claro que el siguiente APe.f. determinístico A es tal que T(A)={a,aa}
A=({q0,qf},{a},{Z,X,Y},δ,q0,Z,{qf})
δ’:
δ(q0,a,Z)={(qf,X)}
δ(qf,a,X)={(qf,Y)}
Ahora mostraremos que si un lenguaje L incluye dos cadenas u,w (u≠w) tales que u es prefijo
de w (w=uv), ningún APθ determinístico acepta L:
Supongamos que el APθ A’=(K,Σ,Γ,δ,q0,Z,{}) es tal que T(A’)=L, en particular acepta tanto u
como w, entonces (q0,u,Z)|--*(qh,λ,λ) con qh∈K. Veamos qué pasa con w=uv:
(q0,uv,Z)|--*(qh,v,λ) pues A’ es determinístico, pero entonces w no será aceptada nunca pues la
pila ya está vacía.
El lenguaje L={a,aa} cumple las condiciones del enunciado y por lo tanto ningún APθ
determinístico acepta L.
210
Construcción de un APe.f. determinístico en forma normal a partir de otro APe.f.
determinístico
Diremos que el APe.f. determinístico A está en forma normal 1 si todas sus reglas de
transición son del tipo δ(q,c,Y)={(p,α)} c∈(Σ∪{λ}) con |α|≤2.
Diremos que el APe.f. determinístico A está en forma normal 2 si todas sus reglas de
transición son del tipo δ(q,c,Y)={(p,α)} c∈(Σ∪{λ}) con α=λ, α=Y ó α=XY.
Sea A=(K,Σ,Γ,δ,q0,Z,F) un APe.f. determinístico entonces construimos así un APe.f
determinístico A’ en forma normal 1 tal que T(A)=T(A’):
A’=(K’,Σ, Γ,δ’,q0,Z,F)
δ’:
1) Si δ(q,c,Y)={(p,α)} -c∈(Σ∪{λ})- con |α|≤2
δ’(q,c,Y) = δ(q,c,Y)
2) Si δ(q,c,Y)={(p,α)} -c∈(Σ∪{λ})- con |α|>2
Sea α=Y1...Yn, n>2
δ’(q,c,Y) = {(p1,Yn-1Yn)}
δ’(pi,λ,Yn-i) = {(pi+1,Yn-i-1Yn-i)} i=1,...,n-3
δ’(pn-2,λ,Y2) = {(p,Y1Y2)}
donde los pj son nuevos estados (no finales).
K’ = K ∪ {todos los nuevos estados añadidos}
Sea A=(K,Σ,Γ,δ,q0,Z,F) un APe.f. determinístico en forma normal 1 entonces construimos así

un APe.f determinístico A’ en forma normal 2 tal que T(A)=T(A’):
A’=(K’,Σ, Γ ∪ {Z0}, δ’,q0’,Z0,F)
δ’:
1) δ’(q0’,λ,Z0) = {(q0,ZZ0)}
2) Si δ(q,c,Y)={(p,α)} -c∈(Σ∪{λ})- con α=λ, α=Y ó α=XY
δ’(q,c,Y) = δ(q,c,Y)
3) Si δ(q,c,Y)={(p,X)} -c∈(Σ∪{λ})-
δ’(q,c,Y) = {(pj,λ)}
δ’(pj,λ,W) = {(p,XW)} W∈(Γ∪{Z0})
donde pj es un nuevo estado (no final)
4) Si δ(q,c,Y)={(p,XU)} -c∈(Σ∪{λ})-
δ’(q,c,Y) = {(pj,λ)}
δ’(pj,λ,W) = {(ph,UW)} W∈(Γ∪{Z0})
δ’(ph,λ,U) = {(p,XU)}
donde pj,ph son nuevos estados (no finales)
K’ = K ∪ {q0’} ∪ {todos los nuevos estados añadidos}
Ejemplo:
Sea el APe.f A1=({q0,q1,q2},{a,b,c,d,e},{Z,B,C,D,E},δ1,q0,Z,{q2})
211
δ1:
δ1(q0,a,Z)={(q1,BDE)}
δ1(q1,b,B)={(q1,C)}
δ1(q1,c,C)={(q1, λ)}
δ1(q1,d,D)={(q1,λ)}
δ1(q1,e,E)={(q2,ZZZZ)}
Construimos así el APe.f A=(K,{a,b,c,d,e},{Z,B,C,D,E},δ,q0,Z,{q2}) en forma normal 1.
K={q0,q1,q2,p1,p2,p3}
δ:
De Viene
δ1(q0,a,Z)={(q1,BDE)} δ(q0,a,Z)={(p1,DE)}
δ(p1,λ,D) = {(q1,BD)}
δ1(q1,b,B)={(q1,C)} δ(q1,b,B)={(q1,C)}
δ1(q1,c,C)={(q1, λ)} δ(q1,c,C)={(q1, λ)}
δ1(q1,d,D)={(q1,λ)} δ(q1,d,D)={(q1,λ)}
δ1(q1,e,E)={(q2,ZZZZ)} δ(q1,e,E)={(p2,ZZ)}
δ(p2,λ,Z) = {(p3,ZZ)}
δ(p3,λ,Z) = {(q2,ZZ)}
Construimos así el APe.f. en forma normal 2

A’=(K’,{a,b,c,d,e},{Z,B,C,D,E,Z0},δ’,q0’,Z0,{q2}).
δ’:
De Viene
δ’(q0’,λ,Z0) = {(q0,ZZ0)}
δ(q0,a,Z)={(p1,DE)} δ’(q0,a,Z) = {(p4,λ)}

δ’(p4,λ,Z) = {(p5,EZ)}
δ’(p4,λ,B) = {(p5,EB)}
δ’(p4,λ,C) = {(p5,EC)}
δ’(p4,λ,D) = {(p5,ED)}
δ’(p4,λ,E) = {(p5,EE)}
δ’(p4,λ,Z0) = {(p5,EZ0)}
δ’(p5,λ,E) = {(p1,DE)}
δ(p1,λ,D) = {(q1,BD)} δ’(p1,λ,D) = {(q1,BD)}
212
δ(q1,b,B)={(q1,C)} δ’(q1,b,B) = {(p6,λ)}
δ’(p6,λ,Z) = {(q1,CZ)}
δ’(p6,λ,B) = {(q1,CB)}
δ’(p6,λ,C) = {(q1,CC)}
δ’(p6,λ,D) = {(q1,CD)}
δ’(p6,λ,E) = {(q1,CE)}
δ’(p6,λ,Z0) = {(q1,CZ0)}
δ(q1,c,C)={(q1, λ)} δ’(q1,c,C)={(q1, λ)}

δ(q1,d,D)={(q1,λ)} δ’(q1,d,D)={(q1,λ)}
δ(q1,e,E)={(p2,ZZ)} δ’(q1,e,E) = {(p7,λ)}
δ’(p7,λ,Z) = {(p8,ZZ)}
δ’(p7,λ,B) = {(p8,ZB)}
δ’(p7,λ,C) = {(p8,ZC)}
δ’(p7,λ,D) = {(p8,ZD)}
δ’(p7,λ,E) = {(p8,ZE)}
δ’(p7,λ,Z0) = {(p8,ZZ0)}
δ’(p8,λ,Z) = {(p2,ZZ)}
δ(p2,λ,Z) = {(p3,ZZ)} δ’(p2,λ,Z) = {(p3,ZZ)}

δ(p3,λ,Z) = {(q2,ZZ)} δ’(p3,λ,Z) = {(q2,ZZ)}
Vamos a terminar este capítulo con el siguiente resultado:
Sea A un APe.f. A con |F| > 1, es decir con más de un estado final, entonces es posible
construir un otro APe.f. A’ tal que |F’| = 1 y T(A)=T(A’).
Demostración:
A partir de A construimos un APθ A’’ como se indicó antes.
A partir de A’’ construimos un APe.f. A’ como se indicó antes.
Es obvio que A’ tiene F’={qf} un solo estado final, las demostraciones anteriores prueban que
T(A)=T(A’).
Ofrecemos la siguiente alternativa.
Sea el APe.f. A=(K,Σ,Γ,δ,q0,Z,F) -Z’∉Γ; q0’,qf∉K -, construimos así el APe.f.
A’=(K∪{q0’,qf},Σ,Γ∪{Z’},δ’,q0’, Z’,F’)
F’ = {qf }
δ’:
1) δ’(q0’,λ,Z’) = {(q0,ZZ’)}
3) δ’(qj,λ,X) = {(qf,λ)} qj∈F, X∈Γ∪{Z’}
213
Ejemplo:
Sea el APe.f A=({q0,q1,q2,q3},{a,b,c},{Z},δ,q0,Z,{q2,q3})
δ:
δ(q0,a,Z)={(q1,Z)}
δ(q1,b,Z)={(q2,Z)}
δ(q2,c,Z)={(q3,Z)}
Construimos así el APe.f A’=({q0,q1,q2,q3,q0’,qf},{a,b,c},{Z,Z’},δ’,q0’,Z’,{qf})
δ’:
δ’(q0’,λ,Z’)={(q0,ZZ’)}
δ’(q0,a,Z)={(q1,Z)}
δ’(q1,b,Z)={(q2,Z)}
δ’(q2,c,Z)={(q3,Z)}
δ’(q2,λ,Z) = {(qf,λ)}
δ’(q2,λ,Z’) = {(qf,λ)}
δ’(q3,λ,Z) = {(qf,λ)}
δ’(q3,λ,Z’) = {(qf,λ)}
214
CAPÍTULO 11. CERRADURA: el caso libre de contexto
Unión
Los lenguajes libres de contexto son cerrados respecto de la operación unión.
Sean G1=(N1,T1,P1,S1) y G2=(N2,T2,P2,S2) dos GLC’s tales que L(G1)=L1 y L(G2)=L2 con
(N1∩Ν2)={}, S∉(N1∪N2), entonces podemos construir una GLC G tal que L(G)=L1∪L2.
Demostración:
Construimos así la GLC G=(N1∪N2∪{S},T1∪T2,P,S)
P = {S-->S1} (1)
∪ {S-->S2} (2)
∪ P1 ∪ P2 (3)
L(G)=L1∪L2. En efecto, sea w∈L1∪L2, es decir, S1=>*w en P1 ó S2=>*w en P2. Es claro que
S=>S1=>*w por 1 para el primer paso; por hipótesis y P1⊆P -por 3- para el resto. Ó
*
S=>S2=> w por 2 para el primer paso; por hipótesis y P2⊆P -por 3- para el resto.
Es decir, S=>*w en G, es decir, w∈L(G).
Inversamente, sea w∈L(G), es decir, S=>*w en G. Ninguna producción de 3 incluye a S, luego
el primer paso de dicha derivación es S=>S1 ó S=>S2 (por 1 ó 2), además dado que
(N1∩N2)={}, no es posible que el uso de producciones “se mezcle” y por tanto el resto de la
derivación se hace o sólo con P1 o sólo con P2. Es decir, la derivación es S=>S1=>*w
utilizando sólo producciones de P1 –excepto el primer paso- lo que muestra que es posible
S1=>*w en G1, es decir, w∈L1; ó S=>S2=>*w utilizando sólo producciones de P2 –excepto el
primer paso- lo que muestra que es posible S2=>*w en G2, es decir, w∈L2. Es decir, w∈L1 ó
w∈L2, es decir, w∈(L1∪L2).
Ejemplo:
Sea el lenguaje libre de contexto L1=L(G1)={aibj / i>j≥0} donde G1=({S1},{a,b},P1,S1)
P1 :
S1-->aS1b
S1-->aS1
S1-->a
Sea el lenguaje libre de contexto L2=L(G2)={aibj / 0≤i<j} donde G2=({S2},{a,b},P2,S2)
P2 :
S2-->aS2b
S2-->S2b
S2-->b
Construimos así la GLC G=({S,S1,S2},{a,b},P,S)
P:
S-->S1
S-->S2
S1-->aS1b
215
S1-->aS1
S1-->a
S2-->aS2b
S2-->S2b
S2-->b
G es tal que L(G)=L1∪L2={aibj / i>j≥0}∪{aibj / 0≤i<j}. Nótese que si tenemos el lenguaje
L’={ aibj / i≠j, i+j>0 }, este puede caracterizarse como L’={aibj / i>j≥0}∪{aibj / 0≤i<j}, que en
otros términos podríamos anotar así L’={aibj / i>j}∪{aibj / i<j} ó así L’={aibj / i≠j}.
Mostraremos la construcción con APe.f.’s:

Sean A1=(K1,Σ1,Γ1,δ1,q0,Z1,F1) y A2=(K2,Σ2,Γ2,δ2,p0,Z2,F2) -(K1∩K2)={}, Z∉(Γ1∪Γ2),
r0∉(K1∪K2)– dos APe.f tales que T(A1)=L1 y T(A2)=L2, construimos así el APe.f.
A=(K1∪K2∪{r0}, Σ1∪Σ2, Γ1∪Γ2∪{Z}, δ, r0, Z, F1∪F2)
δ:
1) δ(r0,λ,Z) = { (q0,Z1), (p0,Z2) }
2) δ(qi,c,X) = δ1(qi,c,X) qi∈K1, c∈(Σ1 ∪ {λ}), X∈Γ1
3) δ(pj,c,Y) = δ2(pj,c,Y) pj∈K2, c∈(Σ2 ∪ {λ}), Y∈Γ2
Nótese que el inciso 2 nos dice que copiemos δ1.
Nótese que el inciso 3 nos dice que copiemos δ2. Además,
w∈[L1∪L2] si y sólo si w∈[T(A1)∪T(A2)] si y sólo si
(q0,w,Z1)|--*(qf,λ,β) qf∈F1 ó (p0,w,Z2)|--*(ph,λ,η) ph∈F2 si y sólo si por 1y2 ó 1y3
(r0,w,Z)|--(q0,w,Z1)|--*(qf,λ,β) qf∈F1 ó (r0,w,Z)|--(p0,w,Z2)|--*(ph,λ,η) ph∈F2 en A si y sólo si
(r0,w,Z)|--*(rj,λ,γ) rj∈F si y sólo si
w∈T(A)
La construcción y la demostración con APθ’s es prácticamente idéntica con γ=β=η=λ.
Ejemplo:
Sea A1=({q0,q1},{a},{Z1},δ1,q0,Z1,{q1})
δ1: δ1(q0,a,Z1)={(q1,Z1)}
Sea A2=({p0,p1},{b},{Z2},δ2,p0,Z2,{p1})
δ2: δ2(p0,b,Z2)={(p1,Z2)}
Construimos así el APe.f. A=({q0,q1,p0,p1,r0},{a,b},{Z1,Z2,Z},δ,r0,Z,{q1,p1})
δ:
δ(r0,λ,Z)={(q0,Z1),(p0,Z2)}
δ(q0,a,Z1)={(q1,Z1)}
δ(p0,b,Z2)={(p1,Z2)}
Concatenación
Los lenguajes libres de contexto son cerrados respecto de la operación concatenación.
Sean G1=(N1,T1,P1,S1) y G2=(N2,T2,P2,S2) dos GLC’s tales que L(G1)=L1 y L(G2)=L2 con
(N1∩Ν2)={}, S∉(N1∪N2), entonces podemos construir una GLC G tal que L(G)=L1.L2.
216
Demostración:
Construimos así la GLC G=(N1∪N2∪{S},T1∪T2,P,S)
P = { S -->S1S2 } (1)
∪ P1 ∪ P2 (2)
L(G)=L1.L2.
En efecto, sea w∈L1.L2 -w=uv-, es decir, S1=>*u en P1, S2=>*v en P2. Es claro que
S=>S1S2 por 1
*
=> uS2 por hipótesis y P1⊆P -por 2-
=>*uv por hipótesis y P2⊆P -por 2-
Es decir, S=>*w en G pues w=uv, es decir, w∈L(G).
Inversamente, sea w∈L(G), es decir, S=>*w en G. Ninguna producción de 2 incluye a S, luego
el primer paso de dicha derivación es S=>S1S2 -por 1-, además dado que (N1∩N2)={}, no es
posible que el uso de producciones “se mezcle” y por tanto efectuando una derivación más a
la izquierda S1S2=>*uS2 se hace sólo con P1, es decir S1=>*u en P1; y a partir de ahí uS2=>*uv
se hace sólo con P2, es decir S2=>*v en P2. Resulta pues que si S=>*uv=w, u∈L1 y v∈L2, es
decir, w∈L1.L2.
Ejemplo:
P1 :
S1-->aS1b
S1-->aS1
S1-->a
Sea el lenguaje libre de contexto L2=L(G2)={aibj / 0≤i<j} donde G2=({S2},{a,b},P2,S2)
P2 :
S2-->aS2b
S2-->S2b
S2-->b
Construimos así la GLC G=({S,S1,S2},{a,b},P,S)
P:
S-->S1S2
S1-->aS1b
S1-->aS1
S1-->a
S2-->aS2b
S2-->S2b
S2-->b
Mostraremos la construcción con APe.f.:

Sean A1=(K1,Σ1,Γ1,δ1,q0,Z1,F1) y A2=(K2,Σ2,Γ2,δ2,p0,Z2,F2) -(K1∩K2)={}, (Γ1∩Γ2)={},
Z∉(Γ1∪Γ2), r0∉(K1∪K2)– dos APe.f tales que T(A1)=L1 y T(A2)=L2, construimos así el APe.f.
A=(K1∪K2∪{r0}, Σ1∪Σ2, Γ1∪Γ2∪{Z}, δ, r0, Z, F2)
217
δ:
1) δ(r0,λ,Z) = { (q0,Z1Z) }
2) δ(qi,c,X) = δ1(qi,c,X) qi∈K1, c∈(Σ1∪{λ}), X∈Γ1
3) δ(qi,λ,X) = { (p0,Z2X) } qi∈F1, X∈(Γ1∪{Z})
4) δ(pj,c,Y) = δ2(pj,c,Y) pj∈K2, c∈(Σ2∪{λ}), Y∈Γ2
Nótese que el inciso 2 nos dice que copiemos δ1 y que el inciso 4 nos dice que copiemos δ2.
Además, trabajando con w=uv,
uv∈[L1.L2] si y sólo si uv∈[T(A1).T(A2)] si y sólo si
(q0,u,Z1)|--*(qf,λ,β) qf∈F1 y (p0,v,Z2)|--*(ph,λ,η) ph∈F2 si y sólo si
(r0,uv,Z)|--(q0,uv,Z1Z)|--*(qf,v,βZ) qf∈F1 por 1,2; y
(qf,v,βZ)|--(p0,v,Z2βZ)|--*(ph,λ,ηβZ) ph∈F2 por 3,4 si y sólo si en A
*
(r0,uv,Z)|-- (rj,λ,γ) rj∈F si y sólo si
uv∈T(A)
Ejemplo:
Sea A1=({q0,q1},{a},{Z1},δ1,q0,Z1,{q1})
δ1: δ1(q0,a,Z1)={(q1,Z1)}
Sea A2=({p0,p1},{b},{Z2},δ2,p0,Z2,{p1})
δ2: δ2(p0,b,Z2)={(p1,Z2)}
Construimos así el APe.f. A=({q0,q1,p0,p1,r0},{a,b},{Z1,Z2,Z},δ,r0,Z,{p1})
δ:
δ(r0,λ,Z)={(q0,Z1Z)}
δ(q0,a,Z1)={(q1,Z1)}
δ(q1,λ,Z1)={(p0,Z2Z1)}
δ(q1,λ,Z)={(p0,Z2Z)}
δ(p0,b,Z2)={(p1,Z2)}
La construcción con APθ’s es así:

Sean A1=(K1,Σ1,Γ1,δ1,q0,Z1,{}) y A2=(K2,Σ2,Γ2,δ2,p0,Z2,{}) -(K1∩K2)={}, Z∉(Γ1∪Γ2),
r0∉(K1∪K2)– dos APθ’s tales que T(A1)=L1 y T(A2)=L2, construimos así el APθ
A=(K1∪K2∪{r0}, Σ1∪Σ2, Γ1∪Γ2∪{Z}, δ, r0, Z, {})
δ:
1) δ(r0,λ,Z) = { (q0,Z1Z) }
3) δ(qi,λ,Z) = { (p0,Z2) } qi∈K1
4) δ(pj,c,Y) = δ2(pj,c,Y) pj∈K2, c∈(Σ2∪{λ}), Y∈Γ2
Además, trabajando con w=uv,
uv∈[L1.L2] si y sólo si uv∈[T(A1).T(A2)] si y sólo si
218
(q0,u,Z1)|--*(qi,λ,λ) qi∈K1 y (p0,v,Z2)|--*(pj,λ,λ) pj∈K2 si y sólo si
(r0,uv,Z)|--(q0,uv,Z1Z)|--*(qi,v,Z) qi∈K1 por 1,2; y
*
(qi,v,Z)|--(p0,v,Z2)|-- (pj,λ,λ) pj∈K2 por 3,4 en A si y sólo si
(r0,uv,Z)|--*(rj,λ,λ) rj∈K si y sólo si
uv∈T(A)
Ejemplo:
Sea A1=({q0,q1},{a},{Z1},δ1,q0,Z1,{q1})
δ1: δ1(q0,a,Z1)={(q1,λ)}
Sea A2=({p0,p1},{b},{Z2},δ2,p0,Z2,{p1})
δ2: δ2(p0,b,Z2)={(p1,λ)}
Construimos así el APe.f. A=({q0,q1,p0,p1,r0},{a,b},{Z1,Z2,Z},δ,r0,Z,{p1})
δ:
δ(r0,λ,Z)={(q0,Z1Z)}
δ(q0,a,Z1)={(q1,λ)}
δ(q0,λ,Z) = {(p0,Z2)}
δ(q1,λ,Z) = {(p0,Z2)}
δ(p0,b,Z2)={(p1,λ)}
Cruz de Kleene
Los lenguajes libres de contexto son cerrados respecto de la operación cruz de Kleene.
Sea G1=(N1,T1,P1,S1) una GLC tal que L(G1)=L con S∉N1, entonces podemos construir una
GLC G tal que L(G)=L+.
Demostración:
Construimos así la GLC G=(N1∪{S},T1,P,S)
P = { S --> S1S } (1)
∪ { S --> S1 } (2)
∪ P1 (3)
L(G)=L . En efecto, sea w∈L , es decir, w=w1...wm con m>0, S1=>*wi. Es claro que
+ +
S=>*S1...S1 por 1 y 2, S deriva una cadena de m (m>0) símbolos S1

=>*w1S1...S1 por hipótesis y P1⊆P -por 3- iniciando una derivación más a la izquierda
=>*w1...wm por hipótesis y P1⊆P -por 3-
Luego, w∈L(G).
Inversamente, sea w∈L(G), es decir, S=>*w en G. La forma en que se construye P indica que
esta derivación debe ser de la forma S=>*S1...S1S=>*S1...S1=>*w1...wm
Donde cada wi se deriva de S1, es decir, cada wi∈L. Luego, si S=>*w en G, w=w1...wm, con
wi∈L, es decir, w∈L+.
Ejemplo:
219
P1 :
S1-->aS1b
S1-->aS1
S1-->a
Construimos así la GLC G=({S,S1},{a,b},P,S)
P:
S-->S1S
S-->S1
S1-->aS1b
S1-->aS1
S1-->a
Mostraremos la construcción con APe.f. -incluyendo la cadena vacía-:

Sea A1=(K1,Σ1,Γ1,δ1,q0,Z1,F1) - Z∉Γ1, r0∉K1– un APe.f tal que T(A1)=L, construimos así el
APe.f. A tal que T(A)=L*: A=(K1∪{r0,r1}, Σ1, Γ1∪{Z}, δ, r0, Z, {r0})
δ:
1) δ(r0,λ,Z) = { (q0,Z1Z) }
3) δ(qi,λ,X) = { (r1,X) } qi∈F1, X∈(Γ1∪{Z})
4) δ(r1,λ,X) = { (r1,λ) } X∈Γ1
5) δ(r1,λ,Z) = { (r0,Z) }
Nótese que el inciso 2 nos dice que copiemos δ1. Además
w∈L+ si y sólo si
w=w1...wm con m>0 wi∈T(A1) si y sólo si
(q0,wi,Z1)|--*(qi,λ,βj) qi∈F1 si y sólo si en A
(r0,wi,Z)|--(q0,wi,Z1Z) por 1
|--*(qi,λ,βjZ) por hipótesis y 2, qi∈F1
|--(r1,λ,βjZ) por 3
|--*(r1,λ,Z) por 4
|--(r0,λ,Z) por 5 si y sólo si
(r0,w1...wm,Z)|--*(r0,λ,Z) con m>0, r0∈F si y sólo si
w∈T(A) w=w1...wm
Por otro lado es claro que (r0,λ,Z)|--*(r0,λ,Z) con r0∈F por la reflexividad de la clausura
reflexiva transitiva de |--, es decir, λ∈T(A).
Una construcción alternativa es A=(K1∪{r0}, Σ1, Γ1∪{Z}, δ, r0, Z, {r0})

δ:
1) δ(r0,λ,Z) = { (q0,Z1Z) }
3) δ(qi,λ,X) = { (r0,ZX) } qi∈F1, X∈(Γ1∪{Z})
220
Ejemplo:
Sea A1=({q0,q1},{a},{Z1},δ1,q0,Z1,{q1})
δ1: δ1(q0,a,Z1)={(q1,Z1)}
Construimos así el APe.f. A=({q0,q1,r0,r1},{a},{Z1,Z},δ,r0,Z,{r0})
δ:
δ(r0,λ,Z) = {(q0,Z1Z)}
δ(q0,a,Z1)={(q1,Z1)}
δ(q1,λ,Z1)={(r1,Z1)}
δ(q1,λ,Z)={(r1,Z)}
δ(r1,λ,Z1)={(r1,λ)}
δ(r1,λ,Z)={(r0,Z)}
La construcción alternativa da A=({q0,q1,r0},{a},{Z1,Z},δ,r0,Z,{r0})

δ(r0,λ,Z) = {(q0,Z1Z)}
δ(q0,a,Z1)={(q1,Z1)}
δ(q1,λ,Z1) = {(r0,ZZ1)}
δ(q1,λ,Z) = {(r0,ZZ)}
La construcción con APθ’s es así:

Sea A1=(K1,Σ1,Γ1,δ1,q0,Z1,F1) - Z∉Γ1, r0∉K1– un APθ tal que T(A1)=L construimos así el
el APθ A=(K1∪{r0}, Σ1, Γ1∪{Z}, δ, r0, Z, {})
δ:
1) δ(r0,λ,Z) = { (q0,Z1Z), (r0,λ) }
3) δ(qi,λ,Z) = { (r0,Z) } qi∈K1
Nótese que el inciso 2 nos dice que copiemos δ1. Además
w∈L+ si y sólo si
w=w1...wm con m>0 wi∈T(A1) si y sólo si
*
(q0,wi,Z1)|-- (qi,λ,λ) qi∈K1 si y sólo si en A
(r0,wi,Z)|--(q0,wi,Z1Z)|--*(qi,λ,Z)|--(r0,λ,Z)|--(r0,λ,λ) qi∈K1 por 1,2,3 y 1 si y sólo si
(r0,w1...wm,Z)|--*(r0,λ,λ) rj∈K con m>0 si y sólo si
w∈T(A) w=w1...wm
Por otro lado es claro que (r0,λ,Z)|--(r0,λ,λ) -por 1-, es decir, λ∈T(A).
Ejemplo:
Sea A1=({q0,q1},{a},{Z1},δ1,q0,Z1,{})
δ1: δ1(q0,a,Z1)={(q1,λ)}
Construimos así el APe.f. A=({q0,q1,r0},{a},{Z1,Z},δ,r0,Z,{})
221
δ:
δ(r0,λ,Z) = { (q0,Z1Z), (r0,λ) }
δ(q0,a,Z1)={(q1,λ)}
δ(q0,λ,Z) = {(r0,Z)}
δ(q1,λ,Z) = {(r0,Z)}
Intersección, diferencia y complemento

Los lenguajes libres de contexto no son cerrados respecto de la operación intersección: es
decir dados dos lenguajes libres de contexto L1 y L2: L=(L1∩L2) no es siempre libre de
contexto, puede serlo o no. En otras palabras, existen lenguajes libres de contexto L1 y L2 tales
que L=(L1∩L2) no es libre de contexto.
Lo mismo sucede con la operación complemento y con la operación diferencia.
En efecto, es claro que L1={a,b} y L2={b,c} son lenguajes libre de contexto, pues son finitos y
de ahí regulares -es obvio que toda GR es una GLC-. L=(L1∩L2)={b}, que es finito y de ahí
regular y por lo tanto libre de contexto.
Por otro lado, L1={aibicj / i+j>0} y L2={aibjcj / i+j>0} son lenguajes libres de contexto pues
L1=L(G1) con G1=({S,X,C},{a,b,c},P1,S)
P1 :
S-->XC
S-->X
S-->C
X-->aXb
X-->ab
C-->cC
C-->c
Y L2=L(G2) con G2=({Z,Y,A},{a,b,c},P2,Y)
P2 :
Z-->AY
Z-->A
Z-->Y
Y-->bXc
Y-->bc
A-->aA
A-->a
En este caso L=(L1∩L2)={ajbjcj / j>0}, en el siguiente capítulo demostraremos que este
lenguaje no es libre de contexto.
Para la diferencia: con los lenguajes libre de contexto L1={a,b} y L2={b,c}, L=(L1-L2)={a}
que es finito y de ahí regular y por lo tanto libre de contexto.
Por otro lado, L1={aibicj / i+j>0} y L2={aibjck / j≠k, i+j+k>0} son libres de contexto pues
L1=L(G1) con G1 como antes y L2=L(G2) con G2=({Z,A,W,S1,S2},{a,b},P2:,Z)
222
P2 :
Z-->A
Z-->W
Z-->AW
W-->S1
W-->S2
S1-->bS1c
S1-->bS1
S1-->b
S2-->bS2c
S2-->S2c
S2-->c
A-->aA
A-->a
Ahora L=(L1-L2)={ajbjcj / j>0} (esto puede verse más rápidamente recordando que
L1-L2=L1∩L2c, L2c representa el complemento de L2), en el siguiente capítulo demostraremos
que este lenguaje no es libre de contexto.
Para el complemento: Supongamos que los lenguajes libres de contexto son cerrados respecto
de la operación complemento. Sean L1 y L2 dos lenguajes libres de contexto, sean L3=L1c y
L4=L2c sus complementos (libres de contexto, por el supuesto), entonces L5=L3∪L4 también es
libre de contexto (por la cerradura para la unión). Luego L= L5c también es libre de contexto
(por el supuesto). Pero L=(L1∩L2), de modo que los lenguajes libres de contexto son cerrados
respecto de la operación intersección. Sabemos que esto falso, lo muestra que nuestro
supuesto está equivocado.
Intersección y diferencia entre un lenguaje libre de contexto y uno regular

Aunque los lenguajes libres de contexto no son cerrados respecto de la intersección, ello
cambia cuando se intersecta un lenguaje libre de contexto con uno regular.
Sean L1=T(A1) A1 un APe.f. y L2=T(A2) A2 un AFD, entonces podemos construir un APe.f A
tal que T(A)=(L1∩L2).
Demostración:
Sean A1=(K1,Σ,Γ,δ1,q0,Z,F1) y A2=(K2,Σ,δ2,p0,F2), construimos así el APe.f
A=(K1 X K2), Σ, Γ, δ, [q0,p0], Z, F1 X F2)
δ:
1) ([qj,ph],α)∈δ([qi,pg],a,X) si (qj,α)∈δ1(qi,a,X) y δ2(pg,a)=ph
2) ([qj,ph],α)∈δ([qi,ph],λ,X) si (qj,α)∈δ1(qi,λ,X), ph∈K2
T(A)=[T(A1)∩T(A2)]. En efecto, mostraremos por inducción sobre el número de movimientos
que si ([q0,p0],w,Z)|--*([qj,ph],λ,η) en A entonces (q0,w,Z)|--*(qj,λ,η) en A1 y δ2*(p0,w)=ph.
Caso base: Nótese que por ser un APe.f se puede alcanzar un estado final con cero
movimientos si la cadena de entrada es la vacía y si el estado inicial es final. Sea pues,
223
([q0,p0],w,Z)|--*([qj,ph],λ,η) en cero movimientos, por lo cual [q0,p0]=[qj,ph], w=λ y η=Z.
Entonces es obvio que (q0,w,Z)|--*(qj,λ,η) en A1 por la reflexividad de |--* y δ2*(p0,w)=ph por
definición de δ2*.
Paso inductivo: Sea que ([q0,p0],w,Z)|--*([qj,ph],λ,η) en k movimientos. Desglosémoslos en el
último movimiento y el resto, con w=uc -c∈(Σ∪{λ})-, así:
([q0,p0],uc,Z)|--*([qi,pg],c,Xβ)|--([qj,ph],λ,αβ) donde η=αβ y el último movimiento ha utilizado
la regla ([qj,ph],α)∈δ([qi,pg],c,X), esta regla está presente porque (qj,α)∈δ1(qi,c,X) y
δ2(pg,c)=ph si c≠λ (si c=λ, pg=ph). Además, ([q0,p0],uc,Z)|--*([qi,pg],c,Xβ) se hace en menos de
k movimientos, es decir, ([q0,p0],u,Z)|--*([qi,pg],λ,γ) con γ=Xβ se hace en menos de k
movimientos, por hipótesis inductiva resulta que (q0,u,Z)|--*(qi,λ,γ) en A1 y δ2*(p0,u)=pg.
Pero entonces en A1 es posible (q0,uc,Z)|--*(qi,c,Xβ)|--(qj,λ,αβ) y en A2 es posible
δ2*(p0,uc)=δ2(δ2*(p0,u),c)=δ2(pg,c)=ph (si c=λ, δ2*(p0,uc)=δ2*(p0,u)=pg=ph).
Es decir, (q0,w,Z)|--*(qj,λ,η) en A1 y δ2*(p0,w)=ph -pues w=uc, η=αβ−.
Inversamente, mostraremos por inducción sobre el número de movimientos que
si (q0,w,Z)|--*(qj,λ,η) en A1 y δ2*(p0,w)=ph entonces ([q0,p0],w,Z)|--*([qj,ph],λ,η) en A.
Caso base: Nótese que por ser un APe.f se puede alcanzar un estado final con cero
movimientos si la cadena de entrada es la vacía y si el estado inicial es final. Sea pues,
(q0,w,Z)|--*(qj,λ,η) en A1 en cero movimientos y δ2*(p0,w)=ph, por lo cual qj=q0, w=λ y η=Z,
además que ph=p0. Pero entonces por la reflexividad de |--* en A ([q0,p0],w,Z)|--*([qj,ph],λ,η).
Paso inductivo: Sea que (q0,w,Z)|--*(qj,λ,η) en A1 en k movimientos y δ2*(p0,w)=ph.
Desglosemos los movimientos en el último y el resto, con w=uc -c∈(Σ∪{λ})-, así:
(q0,uc,Z)|--*(qi,c,Xβ)|--(qj,λ,αβ) donde η=αβ y el último movimiento ha utilizado la regla
(qj,α)∈δ1(qi,c,X). Es claro que (q0,uc,Z)|--*(qi,c,Xβ), se hace en menos de k movimientos, es
decir, (q0,u,Z)|--*(qi,λ,γ) con γ=Xβ se hace en menos de k movimientos.
. si c=λ: tenemos que δ2*(p0,u)=ph y (q0,u,Z)|--*(qi,λ,γ) con γ=Xβ se hace en menos de k
movimientos, por hipótesis inductiva resulta que ([q0,p0],u,Z)|--*([qi,ph],λ,γ) en A. Como
(qj,α)∈δ1(qi,λ,X), esta regla permite, por 2, que ([qj,ph],α)∈δ([qi,ph],λ,X). Luego, en A es
posible ([q0,p0],u,Z)|--*([qi,ph],λ,Xβ)|--([qj,ph],λ,αβ), es decir, ([q0,p0],w,Z)|--*([qj,ph],λ,η)
pues w=u, η=αβ.
. si c=a, a∈Σ: tenemos que δ2*(p0,w)=ph, sea δ2*(p0,u)=pg, como w=ua, resulta que δ2(pg,a)=ph.
Así pues (q0,u,Z)|--*(qi,λ,γ) con γ=Xβ se hace en menos de k movimientos y δ2*(p0,u)=pg, por
hipótesi inductiva ([q0,p0],u,Z)|--*([qi,pg],λ,γ) en A. Como (qj,α)∈δ1(qi,a,X), esta regla junto a
δ2(pg,a)=ph permiten, por 1, que ([qj,ph],α)∈δ([qi,pg],a,X). Luego, en A es posible
([q0,p0],ua,Z)|--*([qi,pg],a,Xβ)|--([qj,ph],λ,αβ), es decir, ([q0,p0],w,Z)|--*([qj,ph],λ,η) pues w=ua,
η=αβ.
Hemos probado que ([q0,p0],w,Z)|--*([qj,ph],λ,η) en A si y sólo si (q0,w,Z)|--*(qj,λ,η) en A1 y
δ2*(p0,w)=ph. Con qj∈F1 y ph∈F2, el enunciado dice que w∈T(A) si y sólo si w∈T(A1) y
w∈T(A2).
224
Ejemplo:
Sea el AFD A2=({p0},{a},δ2,p0,{p0})
δ2: δ2(p0,a)=p0
Sea el APe.f. A1=({q0,q1},{a},{Z},δ,q0,Z,{q1})
δ1:
δ1(q0,a,Z)={(q1,Z)}
δ1(q1,a,Z)={(q0,Z)}
Contruimos así el APe.f. A=({[q0,p0],[q1,p0]},{a},{Z},δ,[q0,p0],Z,{[q1,p0]})

δ:
δ([q0,p0],a,Z)={([q1,p0],Z)}
δ([q1,p0],a,Z)={([q0,p0],Z)}
Es importante hacer resaltar, para ello basta ver la forma de construir A, que si el APe.f. A1 es
determinístico, el APe.f resultante A es también determinístico.
Una interesante construcción alternativa parte de una GLC limpia G=(N,T,P,S) y de un AFD
A=(K,T,δ,q1,F) para construir la GLC G’ tal que L(G’)=L(G)∩T(A) así:
G’=(N’,T,P’,S’)
N’={S’} ∪ { Ypq / Y∈(N∪T); p,q∈K }
P’:
1) S’-->Sq1p p∈K
2) Ypq-->X1pr1X2r1r2...Xmr(m-1)q si Y-->X1...Xm∈P; p,r1,...,r(m-1),q∈K
pq
3) a -->a si δ(p,a)=q
Ejemplo:
Sea el AFD A=({q1},{a,b},δ,q1,{q1})
δ: δ(q1,a)=δ(q1,b)=q1
P:
S-->aSb
S-->ab
Construimos así la GLC G’=(N’,{a,b},P’,S’)

N’={S’, Sq1q1, aq1q1, bq1q1}
P’:
S’-->Sq1q1
Sq1q1-->aq1q1Sq1q1bq1q1
Sq1q1-->aq1q1bq1q1
aq1q1-->a
bq1q1-->b
225
Para la diferencia: sean L1=T(A1) A1 un APe.f. y L2=T(A2) A2 un AFD, entonces podemos
construir un APe.f A tal que T(A)=(L1-L2). En efecto, sabemos que los lenguajes regulares son
cerrados respecto de la operación complemento, es decir L2c es regular.
(L1-L2)=(L1∩L2c), es decir, la diferencia entre un lenguaje libre de contexto y uno regular no
es sino la intersección entre un lenguaje libre de contexto y otro regular, lo que –como
acabamos de ver- es libre de contexto.
Intersección, complemento y diferencia entre lenguajes libres de contexto

determinísticos
Sea L=T(A) A un APe.f. determinístico, entonces podemos construir otro APe.f.
determinístico A’ tal que T(A’)=Lc.
Para mostrar este enunciado requerimos algunos resultados previos.
El siguiente APe.f.determinístico de ejemplo A=({q0,q1},{a},{Z},δ,q0,Z,{q1}) con una única
regla de transición δ(q0,a,Z)={(q1,Z)} nos sirve para mostrar que necesitamos alguna forma de
consumir toda la cadena entrada (para cualquier entrada). Con la entrada w=aaa tenemos que
(q0,aaa,Z)|--(q1,aa,Z). Es claro que w no es aceptada, sin embargo lo que nos interesa remarcar
ahora es que este APe.f. no ha leído toda su entrada, que es lo que se desea.
Aunque apelaremos a un “estado muerto”, no basta incluirlo directamente, pues necesitamos
que el APe.f. resultante no sólo acepte el mismo lenguaje que el autómata inicial sino que
además siga siendo determinístico.
El ejemplo siguiente muestra efectivamente que añadir un “estado muerto” directamente
puede ser erróneo.
Sea el APe.f. determinístico A=({q0,q1,q2},{a},{Z},δ,q0,Z,{q2})
δ: δ(q0,a,Z)={(q1,Z)} δ(q1,λ,Z)={(q2,Z)} δ(q2,λ,Z)={(q1,Z)}
T(A)={a} nuevamente y -por ejemplo- con w=aaa este autómata sigue sin consumir toda su
entrada. Sin embargo, si pensamos transitar de q1 (o q2) hacia un estado muerto con el símbolo
“a” para allí consumir toda la entrada es evidente que el nuevo autómata será no
determinístico.
Debemos pues construir otro APe.f. tal que consuma toda su entrada pero siga siendo
determinístico. Para ello definiremos al par (q,Y) con q∈K,Y∈Γ como cíclico si
(q,λ,Yβ)|--+(q,λ,Yαβ) con α,β∈Γ*. Si desde la d.i. inicial logramos accesar a otra d.i. que
tenga a q como estado actual y a Y como el tope de la pila, entonces el APe.f. A puede
ingresar a una secuencia infinita de movimientos de tipo 2, atravesando posiblemente por
estados finales incluso sin consumir toda su entrada.
Sea A=(K,Σ,Γ,δ,q0,Z,F) el APe.f. determinístico inicial con q0’,qe,qm∉K y Z0∉Γ, a partir de él
construimos así otro APe.f A’=(K ∪ {q0’,qe,qm},Σ,Γ ∪ {Z0},δ’,q0’,Z0,F ∪ {qe})
δ’:
1) δ’(q0’,λ,Z0) = {(q0,ZZ0)}
2) δ’(q,a,Z0) = {(qm,Z0)} q∈K, a∈Σ
3) δ’(q,a,Y) = {(qm,Y)} si |δ(q,a,Y)+δ(q,λ,Y)|=0 q∈K, a∈Σ, Y∈Γ
4) δ’(qm,a,Y) = {(qm,Y)} a∈Σ, Y∈Γ∪{Z0}
226
5) Calculamos todos los pares cíclicos.
Para cada par cíclico (q,Y) calculamos todos los estados qj a los que se llega desde el estado q
–con el tope Y∈Γ- solamente con λ-transiciones, es decir, con q∈K,Y∈Γ, todos los estados qj
tales que (q,λ,Y)|--*(qj,λ,β) β∈Γ*:
δ’(q,λ,Y) = {(qm,Y)} si ningún qj∈F
δ’(q,λ,Y) = {(qe,Y)} si algún qj∈F
6) δ’(qe,λ,Y) = {(qm,Y)} Y∈Γ∪{Z0}
7) δ’(q,a,Y) = δ(q,a,Y) si δ’(q,a,Y) no se ha definido en 2,3 ó 5 q∈K, a∈Σ∪{λ}, Y∈Γ
A’ no sólo consumirá toda su entrada, sino que ya no tiene ningún par cíclico, de manera que
no ingresará a secuencias infinitas de movimientos, además T(A)=T(A’).
Ahora sí retornamos al enunciado inicial, a partir del APe.f A=(K,Σ,Γ,δ,q0,Z,F) que no tiene
pares cíclicos (y que consume toda su entrada) construimos otro APe.f A’ tal que
T(A’)=Σ*-T(A), es decir A’ acepta el complemento de A.
A’=(K’,Σ,Γ,δ’,q0’,Z,F’)
K’ = {[q,r] / q∈K, r=1,2,3}
q0’ = [q0,1] si q0∈F
[q0,2] si q0∉F
F’={ [q,3] / q∈K }
δ’:
1) Si δ(q,λ,Y)={(p,α)} y p∈F
δ’([q,1],λ,Y) = {([p,1],α)}
δ’([q,2],λ,Y) = {([p,1],α)}
2) Si δ(q,λ,Y)={p,α)} y p∉F
δ’([q,1],λ,Y) = {([p,1],α)}
δ’([q,2],λ,Y) = {([p,2],α)}
3) Si δ(q,a,Y)={(p,α)} y p∈F
δ’([q,2],λ,Y) = {([q,3],Y)}
δ’([q,1],a,Y) = δ’([q,3],a,Y) = {([p,1],α)}
4) Si δ(q,a,Y)={(p,α)} y p∉F
δ’([q,2],λ,Y) = {([q,3],Y)}
δ’([q,1],a,Y) = δ’([q,3],a,Y) = {([p,2],α)}
Ejemplo:
Sea el APe.f A1=({q0,q1,q2},{a},{Z},δ1,q0,Z,{q2})
δ1:
δ1(q0,a,Z)={(q1,Z)}
δ1(q1,λ,Z)={(q2,Z)}
δ1(q2,λ,Z)={(q1,Z)}
Es claro que T(A)={a}.
Ahora construiremos otro APe.f. determinístico A que consuma toda su entrada, que no tenga
pares cíclicos y tal que T(A)=T(A1):
227
A=({q0,q1,q2,p0,qe,qm},{a},{Z,Z0},δ,p0,Z0,{q2,qe})
δ:
a) δ(p0,λ,Z0)={(q0,ZZ0)} por la regla 1
b) δ(q0,a,Z0)={(qm,Z0)} por la regla 2
c) δ(q1,a,Z0)={(qm,Z0)} idem
d) δ(q2,a,Z0)={(qm,Z0)} idem
la regla 3 no se aplica (todos los estados tienen salidas)
e) δ(qm,a,Z)={(qm,Z)} por la regla 4
f) δ(qm,a,Z0)={(qm,Z0)} idem
En A1 los pares cíclicos son (q1,Z) y (q2,Z) pues (q1,λ,Z)|--+(q1,λ,Z) y (q2,λ,Z)|--+(q2,λ,Z).
Desde q1 con el tope Z podemos llegar a q2(∈F) y a q1.
Desde q2 con el tope Z podemos llegar a q1 y a q2(∈F).
g) δ(q1,λ,Z)={(qe,Z)} por la regla 5
h) δ(q2,λ,Z)={(qe,Z)} idem
i) δ(qe,λ,Z)={(qm,Z)} por la regla 6
j) δ(qe,λ,Z0)={(qm,Z0)} idem
k) δ(q0,a,Z)={(q1,Z)} por la regla 7
Partiendo de A construiremos otro APe.f. determinístico A’ talque T(A’)=Σ*-T(A).
A’=(K’,{a},{Z,Z0},δ’,q0’,Z0,F’)
K’={[p0,1],[q0,1],[q1,1],[q2,1],[qe,1],[qm,1],
[p0,2],[q0,2],[q1,2],[q2,2],[qe,2],[qm,2],
[p0,3],[q0,3],[q1,3],[q2,3],[qe,3],[qm,3]}
q0’=[p0,2]
F’={[p0,3],[q0,3],[q1,3],[q2,3],[qe,3],[qm,3]}
δ’:
De la transición a) por la regla 2 :
δ’([p0,1],λ,Z0)={([q0,1],ZZ0)}
δ’([p0,2],λ,Z0)={([q0,2],ZZ0)}
De la transición b) por la regla 4:
δ’([q0,2],λ,Z0)={([q0,3],Z0)}
δ’([q0,1],a,Z0)={([qm,2],Z0)}
δ’([q0,3],a,Z0)={([qm,2],Z0)}
De la transición c) por la regla 4:
δ’([q1,2],λ,Z0)={([q1,3],Z0)}
δ’([q1,1],a,Z0)={([qm,2],Z0)}
δ’([q1,3],a,Z0)={([qm,2],Z0)}
De la transición d) por la regla 4:
δ’([q2,2],λ,Z0)={([q2,3],Z0)}
δ’([q2,1],a,Z0)={([qm,2],Z0)}
δ’([q2,3],a,Z0)={([qm,2],Z0)}
228
De la transición e) por la regla 4:
δ’([qm,2],λ,Z)={([qm,3],Z)}
δ’([qm,1],a,Z)={([qm,2],Z)}
δ’([qm,3],a,Z)={([qm,2],Z)}
De la transición f) por la regla 4:
δ’([qm,2],λ,Z0)={([qm,3],Z0)}
δ’([qm,1],a,Z0)={([qm,2],Z0)}
δ’([qm,3],a,Z0)={([qm,2],Z0)}
De la transición g) por la regla 1:
δ’([q1,1],λ,Z)={([qe,1],Z)}
δ’([q1,2],λ,Z)={([qe,1],Z)}
De la transición h) por la regla 1:
δ’([q2,1],λ,Z)={([qe,1],Z)}
δ’([q2,2],λ,Z)={([qe,1],Z)}
De la transición i) por la regla 2:
δ’([qe,1],λ,Z)={([qm,1],Z)}
δ’([qe,2],λ,Z)={([qm,2],Z)}
De la transición j) por la regla 2:
δ’([qe,1],λ,Z0)={([qm,1],Z0)}
δ’([qe,2],λ,Z0)={([qm,2],Z0)}
De la transición k) por la regla 4:
δ’([q0,2],λ,Z)={([q0,3],Z)}
δ’([q0,1],a,Z)={([q1,2],Z)}
δ’([q0,3],a,Z)={([q1,2],Z)}
Hemos resaltado en negrita las reglas de transición que sería interesante graficar primero si así
se desea.
Resta indicar si el cálculo de pares cíclicos es computable, es decir, si podemos escribir algún
algoritmo que nos diga, dado un APe.f. determinístico A, cuáles son sus pares cíclicos si
existen. Dicho cálculo en efecto es computable: Para cada par estado,símbolo de la pila (q,Y)
podemos iniciar una serie de λ-transiciones, si en algún momento ello no es posible es claro
que el par no es cíclico, sólo resta ver si (q,λ,Yβ)|--+(q,λ,Yαβ) en un número posiblemente
largo pero finito de movimientos puesto que el número de estados y el número de símbolos es
finito.
Ello se simplifica si A está en forma normal 2, cosa que exigiremos al utilizar la conversión.
Existen lenguajes libres de contexto determinísticos cuya unión no es un lenguaje libre de

contexto determinístico: En efecto, sean L1={aibjck / i≥j, j≥0} y L2={aibjck / i≥k, j≥0}, primero
mostraremos que ambos lenguajes son libres de contexto determinísticos describiendo AP’s
determinísticos que los acepten:
El APe.f. determinístico A1=({q0,q1},{a,b,c},{Z,A,C},δ1,q0,Z,{q0,q1}) acepta L1.
229
δ1:
δ1(q0,a,Z)={(q0,AZ)}
δ1(q0,a,A)={(q0,AA)}
δ1(q0,b,A)={(q1,λ)}
δ1(q1,b,A)={(q1,λ)}
δ1(q0,c,A)={(q1,C)}
δ1(q1,c,A)={(q1,C)}
δ1(q0,c,Z)={(q1,C)}
δ1(q1,c,Z)={(q1,C)}
δ1(q1,c,C)={(q1,C)}
El APe.f. determinístico A2=({p0,p1},{a,b,c},{Z,A,B},δ2,p0,Z,{p0,p1}) acepta L2.
δ2:
δ2(p0,a,Z)={(p0,AZ)}
δ2(p0,a,A)={(p0,AA)}
δ2(p0,b,A)={(p0,A)}
δ2(p0,c,A)={(p1,λ)}
δ2(p1,c,A)={(p1,λ)}
δ2(p0,b,Z)={(p1,B)}
δ2(p1,b,B)={(p1,B)}
Sea L=(L1∪L2). Es claro que
Lc = (L1∪L2)c = [ {aibjck / i≥j, j≥0} ∪ {aibjck / i≥k, j≥0} ]c
= ({a}*{b}*{c}*)c ∪ {aibjck / i<j, i<k}
Y de ahí L3 = [Lc ∩ ({a}*{b}*{c}*)] = {aibjck / i<j, i<k}
Ahora mostraremos que L3 no es libre de contexto. Supongamos que lo es y que G=(N,T,P,S)
con |N|=n es una GLC en FNCH tal que L(G)=L3, sea m=2n y sea la cadena w=aibjck en L(G)
con i=m, j=k=m+1, es decir w=ambm+1cm+1, por el lema de bombeo podemos reescribir así
w=yuxvz con |uv|>0, |uxv|≤2n, además que yuhxvhz∈L(G) para todo h≥0. Como siempre
hacemos un análisis de las cadenas u y v:
. Si u o v (o ambas subcadenas) incluyen dos símbolos diferentes, con h=2 por simple
inspección la cadena resultante yu2xv2z no está en L(G) pues tiene símbolos “mezclados” (por
ejemplo a..ab..ba..ab..b), pero el lema dice que esas cadenas están en L(G). Una
contradicción.
. Si u (o v) incluye sólo a’s, con h suficientemente grande –e incluso con h=2- por simple
inspección las cadenas resultantes no están en L(G) pues tienen i≥j (basta una ‘a’ más para
igualar las m+1 b’s), pero el lema dice que esas cadenas están en L(G). Una contradicción.
. Si ni u ni v incluyen a’s, con h=0 por simple inspección la cadena resultante yxz no está en
L(G) pues tiene i≥j (o i≥k) (basta una ‘b’ menos -o una ‘c’ menos - para igualar las m a’s),
pero el lema dice que esas cadenas están en L(G). Una contradicción.
Hemos mostrado que [Lc ∩ ({a}*{b}*{c}*)] no es libre de contexto. Es evidente que
({a}*{b}*{c}*) es regular, sabemos que un lenguaje libre de contexto intersectado con un
lenguaje regular es también libre de contexto, luego si Lc fuera libre de contexto, toda la
230
intersección sería un lenguaje libre de contexto, pero no es el caso, entonces Lc no es libre de
contexto. También sabemos que si un lenguaje es libre de contexto determinístico su
complemento también es libre de contexto determinístico. Así, si L fuera libre de contexto
determinístico, entonces Lc sería también libre de contexto determinístico, pero Lc no es libre
de contexto determinístico (¡ni siquiera es libre de contexto!), luego L=(L1∪L2) no es libre de
contexto determinístico, que es lo que queriamos probar.
Existen lenguajes libres de contexto determinísticos cuya intersección no es un lenguaje libre

de contexto determinístico, es decir, los lenguajes libres de contexto determinísticos no son
cerrados respecto de la intersección: En efecto, sabemos que estos lenguajes son cerrados
respecto al complemento. Sean L1 y L2 lenguajes libres de contexto determinísticos, entonces
como L=(L1c ∩ L2c)c=(L1∪L2), si el cierre se diera con la intersección, también se daría con la
unión, cosa que hemos probado falsa.
Existen lenguajes libres de contexto determinísticos cuya diferencia no es un lenguaje libre de

contexto determinístico, es decir, los lenguajes libres de contexto determinísticos no son
cerrados respecto de la diferencia: En efecto, sabemos que estos lenguajes son cerrados
respecto al complemento. Sean L1 y L2 lenguajes libres de contexto determinísticos, entonces
como (L1-L2) =(L1∩L2c), si el cierre se diera con la diferencia, también se daría con la
intersección, cosa que hemos probado falsa.
Existen lenguajes libres de contexto determinísticos cuya concatenación no es un lenguaje

libre de contexto determinístico, es decir, los lenguajes libres de contexto determinísticos no
son cerrados respecto de la concatenación: En efecto, en principio mostraremos que los
lenguajes L=({0}.L1) ∪ L2 --donde L1={aibjck / i≥j, j≥0} y L2={aibjck / i≥k, j≥0}- y L3={0}*
son libres de contexto determinísticos.
El APe.f. determinístico A3=({r0},{0},{Z},δ3,r0,Z,{r0}) acepta L3.
δ3: δ3(q0,0,Z)={(q0,Z)}
El APe.f. determinístico A=({r0,q0,q1,p0,p1},{0,a,b,c},{Z,A,B,C},δ,r0,Z,{r0,q0,q1,p0,p1}) acepta
L.
δ:
δ(r0,0,Z)={(q0,Z)} δ(q0,a,Z)={(q0,AZ)} δ(p0,a,A)={(p0,AA)}
δ(q0,a,A)={(q0,AA)} δ(p0,b,A)={(p0,A)}
δ(r0,b,Z)={(p1,B)} δ(q0,b,A)={(q1,λ)} δ(p0,c,A)={(p1,λ)}
δ(r0,a,Z)={(p0,AZ)} δ(q1,b,A)={(q1,λ)} δ(p1,c,A)={(p1,λ)}
δ(q0,c,A)={(q1,C)} δ(p1,b,B)={(p1,B)}
δ(q1,c,A)={(q1,C)}
δ(q0,c,Z)={(q1,C)}
δ(q1,c,Z)={(q1,C)}
δ(q1,c,C)={(q1,C)}
231
Si los lenguajes libres de contexto determinísticos fueran cerrados respecto de la
concatenación, el lenguaje L4=L3.L sería un lenguaje libre de contexto determinístico.
Pero no lo es como argumentamos a continuación. Es claro que ({0}{a}*{b}*{c}*) es regular.
Sabemos que el resultado de intersectar un lenguaje libre de contexto determinístico con un
lenguaje regular es un lenguaje libre de contexto determinístico.
Trabajando bajo el supuesto de que L4 es libre de contexto determinístico, entonces
[L4 ∩ ({0}{a}*{b}*{c}*)] resulta un lenguaje libre de contexto determinístico, pero
L4 ∩ [{0}{a}*{b}*{c}*]
=[L3.L] ∩ [{0}{a}*{b}*{c}*]
=[{0}*. ([{0}.L1] ∪ L2)] ∩ [{0}{a}*{b}*{c}*]
=[ {0}*. ([{0}.{aibjck / i≥j, j≥0}] ∪ {aibjck / i≥k, j≥0})] ∩ [{0}{a}*{b}*{c}*]
={0}.{aibjck / i≥j, j≥0}] ∪ {0}{aibjck / i≥k, j≥0}
={0}.L1 ∪ {0}.L2
Es decir, ({0}.L1 ∪ {0}.L2) es libre de contexto determinístico, pero ello indica que (L1 ∪ L2)
es libre de contexto determinístico: en efecto, necesitamos un AP determinístico que acepte
cadenas en (L1 ∪ L2), si ya hay un AP determinístico A’ que acepta cadenas en
({0}.L1∪{0}.L2) entonces podemos utilizar el mismo A’ para reconocer cadenas en (L1 ∪ L2)
adicionando a cada entrada el prefijo ‘0’ que es espúreo pero necesario para utilizar A’, con
este artificio el AP determinístico A’ nos sirve bien para reconocer (L1 ∪ L2) lo que nos
permite decir que (L1 ∪ L2) si es libre de contexto determinístico. Sin embargo hemos ya
probado que (L1 ∪ L2) no es libre de contexto determinístico, lo que prueba nuestro
enuenciado.
Existen lenguajes libres de contexto determinísticos cuya estrella de Kleene no es un lenguaje

libre de contexto determinístico: En efecto, sabemos que L=({0}.L1) ∪ L2 es libre de contexto
determinístico -el APe.f determinísitico A de arriba lo acepta-, pero L* no lo es puesto que si
lo fuera entonces el lenguaje [L* ∩ ({0}{a}*{b}*{c}*)] también sería libre de contexto
determinístico –por la misma razón de arriba-, como [L* ∩ ({0}{a}*{b}*{c}*)] = {0}.L1 ∪
{0}.L2 estaríamos diciendo que (L1 ∪ L2) es libre de contexto determinístico –que por lo
expuesto arriba- es falso.
232
CAPÍTULO 12. PROBLEMAS DE DECISIÓN
Pertenencia de una cadena a un lenguaje libre de contexto (el algoritmo CYK)

El problema siguiente es decidible: ¿pertenece la cadena w a L(G) donde G es una GLC?
Mostraremos primero un conocido procedimiento teórico. Sea G una GLC en FNCH, Z∈N y
Z=>∗w, probaremos por inducción sobre |w| que hay una derivación de (2|w|-1) pasos de w a
partir de Z.
Caso base: |w|=1, pero entonces w∈T, como G está en FNCH debe existir una producción
Z-->w∈P y por tanto es posible la derivación Z=>w de 1(=2(1)-1=2|w|-1) paso.
Hipótesis inductiva: El enunciado es cierto para |w|<k.
Paso inductivo: Sea |w|=k. Como G está en FNCH la derivación debe ser de la forma
Z=>XY=>∗uv, donde w=uv. Es claro que X=>∗u, que Y=>∗v, que |w|=|u|+|v| y que tanto |u|<k
como |v|<k.
De ahí es posible describir dicha derivación así:
Z=>XY en un paso
∗
=> uY en (2|u|-1) pasos por hipótesis inductiva
=>∗uv en (2|v|-1) pasos por hipótesis inductiva
Es decir, Z=>∗w en [1+2|u|-1+2|v|-1] = [2|u|+2|v|-1] = [2(|u|+|v|)-1] = (2|w|-1) pasos.
Pero entonces una forma de determinar si w∈L(G), es decir si S=>∗w, es averiguar si hay una
derivación de (2|w|-1) pasos de w a partir de S, como el número de producciones –y de No
Terminales y Terminales- es finito podemos escribir y testear todas las derivaciones que
toman (2|w|-1]) pasos a partir de S y ver si alguna de las cadenas derivadas es w.
El anterior procedimiento puede ser costoso computacionalmente, de ahí que otras propuestas
de reconocimiento de pertenencia se han propuesto. El algoritmo, ya visto, de Earley se aplica
directamente aquí; aprovechamos este problema de decisión para introducir un popular
algoritmo llamado CYK cuyo nombre viene de su descubridor Cocke y sus publicadores
Younger y Kasami.
El algoritmo CYK usualmente trabaja sobre una GLC en FNCH. Sea w=a1...am la cadena de
testeo (por ejemplo w=abaab), sea zij la subcadena de w que comienza en la posición i, de
longitud j (en el ejemplo z23=baa, z51=b, z15=w). El algoritmo se basa en el hallazgo de No
Terminales X que deriven la subcadena zij, es decir, X=>∗zij, todos estos No Terminales se
reunen en el conjunto Bij. El objetivo es hallar el conjunto B1m, es decir, los No Terminales X
tales que X=>∗z1m, y ver si la raíz S está en dicho conjunto, si lo está w∈L(G), en otro caso
no.
Aunque en la subcadena zij el rango de i –o el de j- pueden ir de 1 a m, es claro que se
influyen: así si el rango de i va de 1 a m, el rango de j depende de i pues va de 1 a m-i+1, en
el ejemplo con i=4, j va de 1 a 2(=5-4+1 ), no tiene sentido hablar de z43, es decir la
subcadena que empieza en la posición 4 de longitud 3, pues w solamente tiene 5 símbolos.
Inversamente, por similares razones, si el rango de j va de 1 a m, el rango de i depende de j
pues va de 1 a m-j+1.
Sea X∈N, es posible decidir si X=>∗zij.
233
Ello se muestra por inducción sobre j, basta para ello construir el conjunto Bij, es decir, hallar
todos los No Terminales X tales que X=>∗zij y ver si X∈Bij.
Caso base: j=1. Es evidente que para construir Bi1, es decir, hallar los No Terminales X tales
que X=>∗zi1 (subcadenas de w que comienzan en la posición i, de longitud 1, esto es zi1=ai ), es
decir, No Terminales que derivan el símbolo de la posición i, basta hallar
Bi1={ X∈N / X->ai ∈ P } y ver si X está en este conjunto.
Hipótesis inductiva: El enunciado es cierto para j<k.
Paso inductivo: Sea j=k(>1). Es claro que X=>∗zik si y sólo si X=>YW=>∗zihW=>∗zihz(i+h)(k-h)
con X-->YW∈P y 1≤h<k, Y deriva los primeros h símbolos de zik, W deriva los últimos k-h
símbolos de zik. Por hipótesis inductiva es posible decidir si Y=>∗zih así como si W=>∗z(i+h)(k-h),
pues h<k y k-h<k, bastará observar los conjuntos Bih y B(i+h)(k-h). De ahí es posible decidir si
X=>∗zik, basta construir Bik={ X / X-->YW∈P, Y∈Bih, W∈B(i+h)(k-h)} –para todas las
combinaciones a que de lugar 1≤h<k - y ver si X está en este conjunto.
El procedimiento siguiente se desprende de lo que se acaba de anotar:
Para i de 1 a m: Bi1={ X∈N / X->ai ∈ P }
Para j de 2 a m:
Para i de 1 a m-j+1:
Bij={}
Para h de 1 a j-1: Bij=Bij ∪ { X / X-->YW∈P, Y∈Bih, W∈B(i+h)(j-h)}
Es común presentar esta construcción de los conjuntos Bij en una matriz cuadrada B de
dimensión (m X m) de la que sólo se llena una parte triangular como se muestra a
continuación.
Ejemplos:
Sea la GLC en FNCH G=({S,X,Y,A},{a,b},P,S)
P:
S-->XY
X-->XA
Y-->AY
A-->a
X-->a
X-->b
Y-->a
Con la cadena de testeo w=baa=a1a2a3 configuramos la matriz B del modo que se ilustra
enseguida; cada posición i,j representa al conjunto Bij descrito arriba:
Así por ejemplo B21={X / X->a2∈P}={X / X->a∈P}={A,X,Y}
X
A,X,Y -
A,X,Y - -
Trabajando con la celda B12 (i=1, j=2, h=1) tenemos B12={ X / X-->YW∈P, Y∈B11, W∈B21}
Como B11.B21={X}.{A,X,Y}={XA,XX,XY}, buscamos todas las producciones que tengan
estas partes derechas, y añadimos sus partes izquierdas al conjunto.
234
Trabajando con la celda B22 (i=2, j=2, h=1) tenemos B22={ X / X-->YW∈P, Y∈B21, W∈B31}
Como B21.B31={A,X,Y}.{A,X,Y}={AA,AX,AY,XA,XX,XY,YA,YX,YY}, buscamos todas
las producciones que tengan estas partes derechas, y añadimos sus partes izquierdas al
conjunto.
X S,X
A,X,Y X,Y,S -
A,X,Y - -
Trabajando con la celda B13 (i=1, j=3), en este caso h debe ir de 1 a 2(=j-1).
En principio B13={}, para h=1 tenemos:
B13={} ∪ { X / X-->YW∈P, Y∈B11, W∈B22}
Como B11.B22={X}.{X,Y,S}={XX,XY,XS}, buscamos todas las producciones que tengan
estas partes derechas, y añadimos sus partes izquierdas al conjunto, así B13={S}
Para h=2 tenemos:
B13={S} ∪ { X / X-->YW∈P, Y∈B12, W∈B31}
Como B12.B31={S,X}.{A,X,Y}={SA,SX,SY,XA,XX,XY}, buscamos todas las producciones
que tengan estas partes derechas, y añadimos sus partes izquierdas al conjunto, finalmente
B13={S,X}, luego la matriz entera es:
X S,X S,X
A,X,Y X,Y,S -
A,X,Y - -
Como la raíz S está en B13 entonces w∈L(G).
Para la cadena de testeo w=babaa, la matriz final es:
X X,S
A,X,Y -
X X,S S,X - -
A,X,Y Y,X,S - - -
A,X,Y - - - -
Como la raíz S no está en B15 entonces w∉L(G).
Lenguaje aceptado por una GLC: vacío o no

El problema siguiente es decidible: ¿el lenguaje aceptado por una GLC es vacío?
En efecto, sea la GLC G=(N,T,P,S), construimos el conjunto de No Terminales UTILES
como se indicó antes, si S∈UTILES es claro que L(G) no es vacío, en otro caso lo es.
Otra alternativa es ir probando cadenas para ver si alguna es generada por la GLC, es decir, si
cuando menos una de ellas pertenece a L(G). Para hacer más sistemática la prueba se escogen
las cadenas en orden léxico, es decir, primero λ luego a1 luego a2 ... luego an, luego a1a1, etc.
Si hay una cadena que pertenece a L(G) este conjunto no es vacío, en otro caso lo es.
Lo central en esta alternativa es tener un número finito de cadenas de prueba, de lo contrario
podríamos estar intentando con las infinitas cadenas de Σ*. Este conjunto finito de cadenas de
prueba lo ofrece el lema de bombeo. En efecto, supongamos que G está en FNCH y que |N|=n:
L(G)≠∅ Ù ∃ w∈Σ∗ |w|<2n S=>∗w
235
Es obvio que si hay una cadena w -|w|<2n- tal que S=>∗w entonces L(G)≠∅.
Inversamente, sea L(G)≠∅, probaremos que ∃ w∈Σ∗ |w|<2n S=>∗w por reducción al absurdo.
Supongamos que la cadena más pequeña –en longitud- de L(G) es w, con |w|≥2n-, por el lema
de bombeo podemos reescribirla así w=yuxvz con |uv|>0 y por lo tanto |yxz|<|yuxvz|, por el
supuesto es claro que yxz∉L(G) pues la cadena más peuqeña es w. Pero por el lema
mencionado con i=0 yxz∈L(G).
Esta contradicción prueba el enunciado que nos da el conjunto finito de cadenas de prueba
buscado: debemos probar solamente las cadenas de longitud menor que 2n si alguna de ellas,
es aceptada es obvio que L(G)≠∅, en otro caso L(G)=∅.
Infinitud (finitud) del lenguaje aceptado por una GLC

El problema siguiente es decidible: ¿el lenguaje aceptado por una GLC es infinito?
Sea G una GLC en FNCH con |N|=n, nuevamente el lema de bombeo nos ayudará a demostrar
que L(G) es infinito Ù ∃ w∈Σ∗ 2n≤|w|<2n+1 w∈L(G).
Si hay una cadena w∈L(G) -2n<|w|<2n+1- es claro que |w|>2n, por el lema de bombeo podemos
reescribirla así w=yuxvz, además yuixviz∈L(G) para todo i≥0, de ahí que L(G) sea infinito.
Inversamente, supongamos que L(G) es infinito, sea w la cadena más pequeña –en longitud-
de L(G) con |w|≥2n+1, por este hecho es obvio que también |w|≥2n, de ahí por el lema de
bombeo podemos reescribir esta cadena así w=yuxvz con |uxv|≤2n. Además con i=0,
yxz∈L(G). Sea w’=yxz. Resulta pues que |w’|<|w| pues |uv|>0. Como w es la cadena más
pequeña en L(G) de longitud |w|≥2n+1, entonces la cadena w’ no puede ser sino tal que
|w’|<2n+1.
Por otro lado, |w’|=|yxz|>|yz|. Además, como |w|≥2n+1 y |uxv|≤2n, resulta que |yuxvz|-|uxv|≥2n,
es decir, (|yz|+|uxv|)-|uxv|≥2n . Pero entonces |yz|≥2n. Es decir, 2n<|w’|<2n+1 con w’∈L(G).
Adicionalmente mencionaremos que es indecidible el problema de determinar si la

intersección de dos lenguajes libres de contexto es vacía. La demostración de ello requiere
introducir el concepto de insolubilidad (su prueba) y otros aspectos relacionados, cosa que no
cubre este trabajo.
Lenguajes no libres de contexto

El siguiente es un problema complejo: ¿es L un lenguaje libre de contexto?
En efecto, hay lenguajes que no son libres de contexto, es decir, lenguajes para los cuales no
es posible escribir una GLC que los genere ni un AP que los acepte. El ejemplo típico es
L={ajbjcj / j>0}, es imposible escribir una GLC que genere L o un AP que acepte L.
Conviene pues tener instrumentos que nos ayuden en la tarea de decidir si un lenguaje es o no
es libre de contexto y, sólo si lo es, empezar la tarea de escribir una GLC o un AP para ese
lenguaje.
Sabemos que los conjuntos –de cadenas- finitos son regulares y por lo tanto son libres de
contexto.
236
Dado un conjunto infinito de cadenas, el lema de bombeo puede ser útil para mostrar que no
es libre de contexto.
Ejemplos:
Mostraremos que L={ajbjcj / j>0} no es libre de contexto, es decir, no hay una GLC G que lo
genere.
Demostración:
Supongamos que L si es libre de contexto, es decir, L=L(G) con |N|=n y G en FNCH.
Es claro que L es infinito y que las cadenas de L tienen longitud 3j, luego hay una cadena
w∈L(G) tal que |w|≥2n, por ejemplo para j=2n la cadena w es tal que |w|=3(2n)≥2n. Por el lema
de bombeo w puede reescribirse así w=yuxvz con |uv|>0 y |uxv|≤2n, además yuixviz∈L(G)
para todo i≥0.
Procedemos a analizar cuál es la forma de la cadena uxv y por lo tanto de u y v:
i) Una posibilidad es que uxv sea una secuencia del mismo símbolo y por lo tanto u y v
también, digamos u=a...a, v=a...a, pero entonces con i=0 la cadena yxz tiene igual número de
b’s y c’s pero tiene menos a’s: por simple inspección dicha cadena no está en L, pero por el
lema de bombeo con i=0 esa cadena sí está en L. Una contradicción.
El razonamiento es idéntico si las secuencias son del símbolo ‘b’ o del símbolo ‘c’, e incluso
si una de las cadenas u o v es vacía.
ii) Otra posibilidad es que uxv sea una secuencia de dos símbolos (no de longitud 2), por
ejemplo uxv=a...ab...b, de manera que:
u=a..ab..b y v=b..b, o bien u=a..a y v=a..ab..b, en cualesquiera de estos casos con i=2 tenemos
que la cadena yu2xv2z tiene una secuencia (una subcadena) del tipo a..ab..ba...ab..b
(correspondiente a u2 o bien a v2) que por simple inspección no corresponde a una cadena en
L, pero por el lema de bombeo esta cadena sí está en L. Una contradicción.
Esto sucede incluso si la cadena v es vacía en el primer caso, o si la cadena u es vacía en el
segundo caso.
u=a...a y v=b...b, pero entonces con i=0 la cadena yxz tienen más c’s que a’s y más c’s que
b’s: por simple inspección dicha cadena no está en L, pero por el lema de bombeo con i=0 esa
cadena sí están en L. Una contradicción.
El razonamiento es idéntico si uxv=b...bc...c.
ii) No hay otras formas posibles. Una secuencia de tres símbolos (no de longitud 3) para uxv
es imposible pues |uxv|≤2n, pero (con j=2n) la última ‘a’ de u debe estar a más de 2n posiciones
de la primera ‘c’ (pues de por medio están las 2n ‘b’es).
Estas contradicciones invalidan nuestro supuesto y concluimos que L no es libre de contexto.
L={bjckdh / j+k+h>0}∪{ambjcjdj / m+j>0}={ambjckdh / m=0 ó j=k=h} no es libre de contexto.
Demostración:
Supongamos que L si es libre de contexto, es decir, L=L(G) con |N|=n y G en FNCH.
Lamentablemente no se puede utilizar el lema de bombeo. En efecto, trabajando con dicho
lema, elijamos w∈L(G) tal que |w|≥2n, sabemos que w puede reescribirse así w=yuxvz con
|uv|>0 y |uxv|≤2n, además yuixviz∈L(G) para todo i≥0.
Procedemos a analizar cuál es la forma de u y v:
237
i) Si w=bjckdh, es posible que u y v sean secuencias de un sólo símbolo –no necesariamente el
mismo-, en cuyo caso la conclusión del lema que yuixviz∈L(G) para todo i≥0 no se
contradice.
ii) Si w=ambjcjdj, es posible que u y v sean secuencias del mismo símbolo ‘a’, en cuyo caso la
conclusión del lema que yuixviz∈L(G) para todo i≥0 no se contradice.
Sin embargo, el lema de Ogden sí puede aplicarse.
Sea w∈L(G) con w=ambjcjdj y m>0. Sea e el entero del lema. Marquemos e símbolos de w así:
w=ambjcjdj. Por el lema podemos descomponer así w=yuxvz, x contiene algún símbolo
marcado, u y v no son simultáneamente libres de símbolos marcados (u.v tiene por lo menos
uno), uxv tiene a lo más e símbolos marcados, yuixviz∈L(G) para todo i≥0.
Procedemos a analizar cuál es la forma de la cadena u:
i) Si u incluye una secuencia de dos símbolos marcados b’s y c’s ó c’s y d’s1, u=apb..bc..c,
u=b..bc..c, ó u=c...cd...d con i=2 tenemos que la cadena yu2xv2z tiene una subcadena del tipo
apb..bc..capb..bc..c (ó b..bc..cb..bc..c ó c..cd..dc..cd..d) correspondiente a u2 que por simple
inspección no corresponde a una cadena en L, pero por el lema de Ogden esta cadena sí está
en L. Una contradicción.
ii) Si u incluye una secuencia de tres símbolos marcados el razonamiento es semejante al
anterior.
iii) Si u incluye una secuencia de sólo un símbolo marcado, digamos b’s, tenemos varios
subcasos -el razonamiento es idéntico si la secuencia es del símbolo ‘c’ o del símbolo ‘d’-:
. u=apb...b, con i=2 la cadena yu2xv2z tiene una subcadena del tipo apb..bapb..b que por simple
inspección no corresponde a una cadena en L, pero por el lema de Ogden esta cadena sí está
en L. Una contradicción.
. u=b...b, v=λ. En este caso con i=0 la cadena yxz tiene a’s, luego igual número de c’s y d’s
pero tiene menos b’s: por simple inspección dicha cadena no está en L, pero por el lema de
Ogden con i=0 esa cadena sí está en L. Una contradicción.
. u=b...b, por la forma de nuestro marcado v contiene una secuencia de un símbolo marcado,
digamos v=d...d. En este caso con i=0 la cadena yxz tiene a’s y luego más c’s que b’s y más
c’s que d’s: por simple inspección no corresponde a una cadena en L, pero por el lema de
Ogden esta cadena sí está en L. Una contradicción. Pasa algo semejante con v=d...d.
Si v=b...b con i=0 la cadena yxz tiene a’s, luego igual número de c’s y d’s pero tiene menos
b’s: por simple inspección dicha cadena no está en L, pero por el lema de Ogden con i=0 esa
cadena sí está en L. Nuevamente una contradicción.
iv) Si u no incluye símbolos marcados, u=ap ó u=λ. Por el lema sabemos que x contiene por lo
menos un símbolo marcado, entonces por la forma de nuestro marcado v debe ser de sólo
símbolos marcados, si es una secuencia de dos o tres símbolos marcados con i=2 la cadena
yu2xv2z tiene una subcadena del tipo c..cd..d, si es una secuencia de sólo un símbolo marcado
con i=0 la cadena yxz tendrá a’s y luego menos de un símbolo que de los otros dos: en ambos
casos por simple inspección dichas cadenas no están en L, pero por el lema de Ogden sí lo
están. Una contradicción.
v) No hay otras formas posibles.
Estas contradicciones invalidan nuestro supuesto y concluimos que L no es libre de contexto.
238
Gramáticas LL y LR
Hemos visto el algoritmo CYK y el de Earley para decidir si una cadena está o no en L(G),
dicho de otro modo, para reconocer si la cadena dada está o no en el lenguaje que representa
(genera) la gramática G.
Aunque el reconocimiento más propiamente es parte de estudios sobre compilación (diseño de
compiladores, análisis léxico, etc.) aprovecharemos su mención para presentar una noción de
las gramáticas LL y LR.
Supongamos que se tiene el conjunto de producciones P={S-->aSb,S-->Y,Y-->ab,S-->ab} y
queremos esgrimir un algoritmo que para la cadena w -por ejemplo w=aabb- nos diga si hay o
no una derivación S=>*w:
La construcción de analizadores sintácticos se ocupa precisamente de ello: cómo diseñar un
reconocedor lo más eficientemente posible. Fíjese que una alternativa elemental es contruir un
autómata de pila a partir de la gramática –según se vio- y dejar que dicho autómata reconozca
o no la cadena w. En función de los problemas que aparezcan puede ser útil variar la
construcción del autómata, mejorarlo en algún sentido o bien construir otra GLC que
minimice los problemas.
Es claro que el algoritmo que estamos considerando tendrá que leer la cadena de entrada w
para ver si es o no generada en G, es común hacerlo revisando los símbolos de izquierda a
derecha.
Con la gramática y la cadena de ejemplo podemos pensar que nuestro algoritmo leerá una “a”
y empezará la derivación en “S”, enseguida tendrá que enfrentar el problema de utilizar
alguna producción: puede buscar todas las que tengan como parte izquierda “S” intentar
fortuna con alguna elegida al azar y si se deriva w (en base a una serie de pasos de derivación)
terminar con éxito, sino retroceder hasta la (errónea) decisión tomada e intentar con otra.
Nótese que si P={S-->aSb,S-->ab,S-->dY,Y-->cc} y w=aabb, una decisión mejor se tomará
seleccionando sólo las producciones que tengan como parte izquierda “S” y “a” como cabeza
de la parte derecha.
Si nos permitimos preanalizar, es decir, leer un símbolo más a la derecha del que estamos
revisando, las cosas podrían mejorar en este ejemplo, pues si el siguiente símbolo a una “a” es
otra “a”, es claro que sólo la producción “S-->aSb” puede ser útil para intentar una derivación.
Una exigencia fuerte es que no tengamos necesidad de retroceder para tomar otra decisión
sino hacer nuestro algoritmo tan ingenioso que cada decisión sea la buena (si w es generada, e
incluso si no es generada), es decir, que haya determinismo.
En otros casos, es imprescindible reducir los problemas y tomar la decisión buena requiere
leer no uno sino 2 (o bien k) símbolos más a la derecha del que se escudriña.
Si exigimos una derivación más a la izquierda, a los algoritmos que tienen este
comportamiento (tomando siempre buenas decisiones) los llamaremos analizadores sintácticos
LL(k) –la primera L es por left to right (leer los símbolos de entrada de izquierda a derecha) y
la segunda L es por leftmost derivation (derivación más a la izquierda)-.
239
No siempre es posible construir uno de estos para una GLC (e incluso para un lenguaje dado),
por ejemplo para el lenguaje L={aibi / i>0}∪{ai / i>0} no hay un analizador LL(k).
Una GLC LL es aquella que admite la construcción de un (algoritmo) analizador sintáctico LL
con la peculiaridad que las producciones se usan en el sentido ParteIzquierda-->ParteDerecha,
es decir, se busca una derivación que parte del símbolo raíz hasta la cadena de entrada w (top-
down o descendente).
Por otro lado en los analizadores sintácticos LR(k) –la primera L es por left to right (leer los
símbolos de entrada de izquierda a derecha)- lo que se busca es una derivación más a la
derecha (la segunda R es precisamente por rightmost derivation), la k tiene una significación
análoga. Una GLC LR es aquella que admite la construcción de un (algoritmo) analizador
sintáctico LR donde las producciones se usan en el sentido ParteDerecha-->ParteIzquierda, es
decir, se busca una derivación que parte de la cadena de entrada w hasta el símbolo raíz
(bottom-up o ascendente).
Ahora queda el problema de reconocer si una GLC es LL o LR, o el más fuerte de construir
una GLC de uno de estos dos tipos directamente (o a partir de otra dada):
En principio diremos que una GLC es LL si es LL(k), y es LR si es LR(k) para algún k.
Denotaremos por PRIMEROSk(η) a los primeros k Terminales con que empiezan las cadenas
derivables desde η, PRIMEROSk(η)={u / η=>*uβ con |u|=k ó η=>*u con |u|<k}
Sea G una GLC limpia, aquí sólo consideraremos derivaciones más a la izquierda.
Diremos que G es LL(k) si
i) S=>*wAγ=>wβγ=>*wη
ii) S=>*wAγ=>wαγ=>*wψ
iii) PRIMEROSk(η)=PRIMEROSk(ψ)
implican que β=α.
Sea G=(N,T,P,S) una GLC y sea G’=(N∪{S’},T,P∪{S’-->S},S’) donde S’ es un nuevo No
Terminal, aquí sólo consideraremos derivaciones más a la derecha.
Diremos que G es LR(k) si
i) S’=>*αAw=>αβw
ii) S’=>*γBx=>αβy
iii) PRIMEROSk(w)= PRIMEROSk(y)
implican que αAy=γBx con α=γ, y=x.
240
CAPÍTULO 13. LENGUAJES SENSIBLES AL CONTEXTO
Un lenguaje es sensible al contexto si hay una Gramática Sensible al Contexto que lo genera,
o un Autómata Limitado Linealmente que lo acepte.
GRAMÁTICAS SENSIBLES AL CONTEXTO (GSC)

Las GSC’s son semejantes a las GLC’s salvo la parte izquierda de las producciones que es
ahora más permisiva.
Una GSC es una cuádrupla G=(N,T,P,S) donde N,T y S se definen de manera idéntica a como
lo hemos estado haciendo y donde P es un conjunto de producciones del siguiente tipo:
α --> β donde α,β ∈ (N ∪ T)+, |α| ≤ |β|
Aunque suele presentarse la definición de una GSC indicando que P es un conjunto de
producciones del tipo: α1Αα2-->α1βα2 A∈N, α1,α2∈(N ∪ T)*, β ∈ (N ∪ T)+; donde se
evidencia claramente que el contexto de A está tomado en cuenta y está conformado por α1 a
la izquierda de A y α2 a la derecha de A, nosotros tomaremos esta restricción como una forma
normal -muy utilizada- de las GSC’s.
Ejemplos:
El lenguaje L={aibici / i>0} es sensible al Contexto. En efecto, la GSC
G=({S,B,C},{a,b,c},P,S)
P:
S-->aSBC
S-->abC
CB-->BC
bB-->bb
bC-->bc
cC-->cc
es tal que L(G)=L.
Intentemos una breve descripción de cómo se comporta esta GSC:
Es claro que S=>abC=>abc utilizando la segunda y la quinta producción.
Derivemos aaabbbccc utilizando las producciones pertinentes:
S=>aSBC
=>aaSBCBC
=>aaabCBCBC
... hasta aquí hemos utilizado las producciones 1 y 2 que podrían recibir el sobrenombre de
generadoras; en efecto estas dos producciones generan cadenas que tienen un número igual de
símbolos que son o representan a’s, b’s y c’s (aunque todavía no en el orden deseado, ni de
sólo Terminales). Sigamos...
=>aaabCBCBC=>aaabCBBCC=>aaabBCBCC=>aaabBBCCC
... que se obtiene utilizando varias veces la tercera producción, que reemplaza la cadena CB,
subrayada para que se note mejor, por la cadena BC, en negrita para que se note mejor, esta
producción podría recibir el sobrenombre de ordenadora. Sigamos...
241
=>aaabbBCCC=>aaabbbCCC=>aaabbbcCC=>aaabbbccC=>aaabbbccc
... que se obtiene utilizando las últimas tres producciones, que actúan simulando una caída de
dominó y que podrían recibir el sobrenombre de minusculizadoras.
Sabemos que hay muchas otras derivaciones posibles a partir de S, un ejemplo de una
derivación alternativa es el siguiente:
S=>aSBC=>aaSBCBC=>aaabCBCBC=>aaabcBCBC=>aaabcBBCC
Que se trunca ahí.
La GSC G=({S,D,A},{a,b,c},P,S)
P:
S-->DS
S-->A
DA-->aA
Da-->aaD
A-->a
k
Es tal que L(G)={ a 2 | k≥0}.
Un ejemplo de derivación es este: S=>DS=>DDS=>DDA=>DaA=>aaDA=>aaaA=>aaaa
El formato α-->β con |α|≤|β|, permite conjunto extraños de producciones por ejemplo:
P={S-->ab,ab-->cd} que corresponde a una GSC que genera L(G)={ab,cd}.
Forma normal de Kuroda (FNK)

Una GSC G se dice que está en FNK si cada una de sus producciones es de uno de los
siguientes tipos:
A-->a, A-->B, A-->BC ó AB-->CD donde a∈T y A,B,C,D∈N.
AUTÓMATAS LIMITADOS LINEALMENTE (ALL)

Técnicamente los ALL’s (Linear Bounded Automata en inglés) son Máquinas de Turing (con
una cinta finita) cuyo conocimiento se presupone en este capítulo. Sin embargo, a modo de
recordatorio, describiremos brevemente estos artefactos.
Como en los otros autómatas, hay una cinta (con la cadena) de entrada con una especie de
cabezal que apunta los símbolos que están siendo leídos:
En los AF’s se analiza (se consume) un símbolo de entrada y el cabezal se mueve a la derecha.
Podemos graficar ello, por ejemplo, así:
abaab abaab
^ ^
| |
En cambio en los AP’s, a través de los λ-movimientos existe la posibilidad de que el
mencionado cabezal no se mueva a la derecha sino que permanezca estático, por ejemplo:
abaab abaab
^ ^
| |
242
Los ALL’s introducen nuevos tipos de movimientos de manera que el cabezal de la cinta de
entrada, ya no solo podrá quedarse estático, sino que -incluso- podrá ir hacia la izquierda o
hacia la derecha o quedarse fijo, según sus reglas de transición. Más aún, los ALL’s tienen la
capacidad de modificar los símbolos de la cinta de entrada; por ejemplo, en algún momento la
entrada aaba puede cambiar por aada o bien por aa&a.
Un ALL es una quíntupla A=(K,Σ ∪ Γ ∪ {Λ,ρ},δ,q0,F)

K es el conjunto de estados
C = Σ ∪ Γ ∪ {Λ,ρ} es el conjunto de símbolos admisibles en la cinta
Σ es el alfabeto de entrada
Γ es un conjunto de marcas auxiliares para el trabajo del ALL
Λ y ρ son los delimitadores izquierdo y derecho de la cadena de entrada
q0 es el estado inicial
F⊆K es el conjunto de estados finales, convencionalmente F={qf} (un único estado final)
δ es la función de transición definida como δ: K X C --> 2K X ({R,L} ∪ C), cuya interpretación y
restricciones indicaremos enseguida.
Las reglas de transición siguiendo la representación que hemos estado manejando tendrían
esta apariencia:
δ(q0,a)={(q1, R)}
δ(q1,b)={(qf , *)}
Son más populares las respresentaciones de las reglas de transición de un ALL (de una
Máquina de Turing) en otros términos equivalentes: en forma de tablas, de ternas, de
quíntuplas, de cuádruplas, etc.
Nosotros adoptaremos la representación en cuádruplas, en donde las reglas de transición de
δ tienen estas formas:
1) qi a R qj
Que indica que si estamos en el estado qi y el cabezal está analizando una a, el ALL se mueve
un símbolo hacia la derecha y cambia al estado qj. (La R es por Right).
2) qi a L qj
Que indica que si estamos en el estado qi y el cabezal está analizando una a, el ALL se mueve
un símbolo hacia la izquierda y cambia al estado qj. (La L es por Left).
3) qi a c qj
Que indica que si estamos en el estado qi y el cabezal está analizando una a, el ALL
reemplaza el símbolo a por el símbolo c en la cinta de entrada pero el cabezal no se mueve; el
estado actual cambia de qi a qj.
4)Además:
Si una cuádrupla empieza con qi Λ . . el tercer componente es necesariamente R
Si una cuádrupla empieza con qi ρ . . el tercer componente es necesariamente L
Ninguna cuádrupla tiene como tercer componente a Λ ni ρ
Ninguna cuádrupla empieza con qf
243
Está claro pues que la cinta (de entrada) de los ALL’s es finita y está limitada por los
marcadores Λ y ρ.
Así, las reglas de transición de un ALL siguiendo esta representación en cuádruplas tendrían
la siguiente apariencia:
q0 a R q1
q1 b * qf
Obviamente este es sólo un ejemplo para mostrar la apariencia de un ALL: el número y la
forma exacta de las cuádruplas depende del lenguaje en consideración.
Si no hay dos cuádruplas que empiecen con el mismo par inicial qi a . ., el ALL se dice
determinístico, en otro caso se dice no determinístico.
Descripciones instantáneas y lenguaje aceptado T(A)

En un ALL una d.i. es una tripleta (i,qj,Λuρ) donde
. i señala la posición del cabezal en la cinta del ALL, el símbolo Λ está en la posición 0, el
primer símbolo de la cadena u está en la posición 1, etc.; el símbolo ρ está en la posición
|u|+1.
. qj es el estado actual
. Λuρ indica el contenido actual de la cinta del ALL, u∈(Σ∪Γ)*
Al empezar su trabajo con la cadena de entrada w, el cabezal del ALL se posiciona
inmediatamente a la derecha de Λ y, obviamente, el estado inicial es q0, es decir, la d.i. inicial
es (1,q0,Λwρ). Cuando la cadena de entrada es la cadena vacía, la d.i. es (1,q0,Λρ) y el cabezal
apunta a ρ.
La idea de un movimiento para pasar de una d.i. a otra se preserva.
El lenguaje aceptado por el ALL A se define así:
T(A)={ w∈Σ* / (1,q0,Λwρ)|--*(i,qf,Λuρ), 0≤i≤|u|+1, u∈(Σ∪Γ)* }
Ejemplos:
El ALL A=({q0,q1,qf},{a}∪{ }∪{Λ,ρ},δ,q0,{qf})
δ: q0aRq1
Acepta T(A)={}, pues nunca llegará al estado final -condición para aceptar cadenas-.
El ALL A=({q0,qf},{a}∪{ }∪{Λ,ρ},δ,q0,{qf})

δ: q0ρLqf
Acepta T(A)={λ}, el único movimiento que puede dar es (1,q0,Λρ)|--*(0,qf,Λρ) con λ como
cadena de entrada. Con otra entrada, digamos Λaaρ, la d.i. inicial sería (1,q0,Λaaρ), ninguna
cuádrupla empieza por q0 a . ., y el trabajo del ALL quedaría truncado sin llegar a qf.
El ALL A=({q0,q1,q2,q3,q4,q5,qf},{a,b}∪{*,&}∪{Λ,ρ},δ,q0,{qf})
244
δ:
1) q0 a * q4
2) q4 ∗ R q1
3) q1 a R q1
4) q1 & R q1
5) q1 b & q5
6) q5 & L q2
7) q2 & L q2
8) q2 a L q2
9) q2 * R q0
10) q0 & R q3
11) q3 & R q3
12) q3 ρ L qf
Acepta T(A)={aibi / i>0}, presentaremos los movimientos para la aceptación de la cadena
“aabb” indicando con un subíndice el número de regla utilizado:
(1,q0,Λaabbρ)|--1(1,q4,Λ*abbρ)|--2(2,q1,Λ*abbρ)|--3(3,q1,Λ*abbρ)|--5(3,q5,Λ*a&bρ)
|--6(2,q2,Λ*a&bρ)|--8(1,q2,Λ*a&bρ)|--9(2,q0,Λ*a&bρ)|--1(2,q4,Λ**&bρ)
|--2(3,q1,Λ**&bρ)|--4(4,q1,Λ**&bρ)|--5(4,q5,Λ**&&ρ)|--6(3,q2,Λ**&&ρ)
|--8(2,q2,Λ**&&ρ)|--9(3,q0,Λ**&&ρ)|--10(4,q3,Λ**&&ρ)|--11(5,q3,Λ**&&ρ)
|--12(4,qf,Λ**&&ρ), es decir,
(1,q0,Λaabbρ)|--*(4,qf,Λ**&&ρ)
CONVERSIONES GENÉRICAS Y CERRADURA: El caso sensible al contexto
Construcción de una GSC con sólo No Terminales en la parte izquierda de sus

producciones
Dada una GSC G podemos construir otra GSC G’ tal que L(G)=L(G’) y tal que G’ tenga sólo
No Terminales en la parte izquierda de sus producciones.
Sea G=(N,T,P,S), con T={a1,...,am}; básicamente se trata de construir G’ a través de una
Mayusculización semejante a la ya vista en GLC’s. G’=(N’,T,P’,S)
P’ = {α’-->β’ / α-->β∈P, α’=α[a1/Xa1,...,am/Xam], β’=β[a1/Xa1,...,am/Xam]} (*)
∪ { Xai-->ai / ai∈T } (**)
Xai∉N, N’ = N ∪ {Xai / ai∈T}
Es decir, en todas y cada una de las producciones de G reemplazamos cada Terminal ai por un
nuevo No Terminal Xai y agregamos la producción Xai-->ai.
Como L(G)⊆{a1,...,am}*, con los reemplazos es claro que con la parte (*) de P’ se genera un
lenguaje sobre {Xa1,...,Xam}* prácticamente igual a L(G) salvo que los “terminales” son Xai en
vez de ai, si a ello agregamos el trabajo de las producciones de (**) tenemos que L(G)=L(G’).
245
Construcción de una GSC en forma normal a partir de otra
Es claro que una GSC tal que todas sus producciones son del tipo
α1Αα2-->α1βα2 donde A∈N, α1,α2∈(N∪T)*, β∈(N ∪ T)+
tiene todas sus producciones del tipo α-->β donde α,β∈(N ∪ T)+, |α|≤|β|.
Dada una GSC G=(N,T,P,S) podemos construir otra GSC G’ tal que L(G)=L(G’) y tal que G’
tenga sus producciones en forma normal, es decir, del tipo
α1Αα2-->α1βα2 donde A∈N, α1,α2∈(N∪T)*, β∈(N∪T)+
En efecto, podemos suponer sin pérdida de generalidad que G tiene sólo No Terminales en la
parte izquierda de sus producciones. Si no es así podemos recurrir a la construcción anterior,
sin embargo, es posible que G ya tenga sólo No Terminales en la partes izquierdas de sus
producciones –sin recurrir a la construcción anterior - en cuyo caso sus partes derechas no
necesariamente serán cadenas de sólo No Terminales que es lo que ocurre con las
producciones de la parte (*) en la mencionada construcción.
A partir de P construimos P’ así:
1) Si una producción de P ya tiene el tipo indicado no debemos hacerle ningún cambio y la
copiamos en P’.
2) Si una producción de P no respeta el tipo indicado, le aplicamos lo siguiente:
Representaremos la producción de la que hablamos así:
Y1Y2...Yn-1Yn --> q1q2...qn-1qnqn+1...qm n≤m
Todos los símbolos de la parte izquierda son No Terminales, debido al supuesto.
Reemplazamos esta producción por el siguiente conjunto de producciones (W es un nuevo No
terminal):
Y1Y2Y3...Yn-1Yn --> WY2Y3...Yn-1Yn
WY2Y3...Yn-1Yn --> Wq2Y3...Yn-1Yn
Wq2Y3..Yn-1Yn --> Wq2q3Y4...Yn-1Yn
... ... ...
Wq2q3q4...qn-2Yn-1Yn --> Wq2q3q4...qn-2qn-1Yn
Wq2q3q4...qn-1Yn --> Wq2q3q4...qn-1qnqn+1...qm
Wq2q3q4...qn-1qnqn+1...qm --> q1q2q3q4...qn-1qnqn+1...qm
Donde hemos resaltado en negrita el No Terminal en la parte izquierda (A) que se reemplaza
por la subcadena en la parte derecha (β), de manera que todas estas nuevas producciones están
en el formato α1Aα2-->α1βα2 cuyo contexto α1 y α2 es evidente. Por ejemplo en la primera
producción α1=λ, A=Y1, α2=Y2Y3...Yn-1Yn, β=W.
Fíjese que la parte derecha de la primera producción es la parte izquierda de la segunda; la
parte derecha de la segunda producción es la parte izquierda de la tercera; etc.
Fíjese que todas reemplazan un No Terminal (A) por la subcadena β de un símbolo, excepto
la penúltima que reemplaza Yn por qnqn+1...qm.
N’ se construye a partir de N añadiendo todos los nuevos No Terminales.
Ejemplos:
Sea la GSC G=({S},{a,b,c,d},{S-->ab,ab-->cd},S)
246
Luego de la Mayusculización tenemos el siguiente conjunto de producciones:
S-->XaXb
XaXb-->XcXd
Xa-->a Xb-->b
Xc-->c Xd-->d
Excepto la producción XaXb-->XcXd todas respetan la forma normal con α1=λ, α2=λ, su parte
izquierda como A y su parte derecha como β.
En la producción XaXb-->XcXd: n=m=2, así reemplazamos esta por:
XaXb-->WXb
WXb -->WXd
WXd -->XcXd
Luego tenemos la resultante GSC G’=({S,Xa,Xb,Xc,Xd,W},{a,b,c,d},P’,S)
P’:
S-->XaXb
XaXb-->WXb
WXb -->WXd
WXd -->XcXd
Xa-->a
Xb-->b
Xc-->c
Xd-->d
Sea la GSC G=({S,B,C},{a,b,c},P,S)

P:
S-->aSBC
S-->abC
CB-->BC
bB-->bb
bC-->bc
cC-->cc
Luego de la Mayusculización tenemos el siguiente conjunto de producciones:
que respetan la forma normal excepto la 3
S-->XaSBC α1=λ, α2=λ, A=S, β=XaSBC
S-->XaXbC α1=λ, α2=λ, A=S, β=XaXbC
CB-->BC no respeta el tipo
XbB-->XbXb α1=Xb, α2=λ, A=B, β=Xb
XbC-->XbXc α1=Xb, α2=λ, A=C, β=Xc
XcC-->XcXc α1=Xc, α2=λ, A=C, β=Xc
Xa-->a
Xb-->b
Xc-->c
247
Reemplazamos CB-->BC, donde n=m=2, por:
CB-->WB
WB-->WC
WC-->BC
Así tenemos la resultante GSC G’=({S,B,C,Xa,Xb,Xc,W},{a,b,c},P’,S)
P’:
S-->XaSBC
S-->XaXbC
CB-->WB
WB-->WC
WC-->BC
XbB-->XbX
XbC-->XbXc
XcC-->XcXc
Xa-->a
Xb-->b
Xc-->c
Construcción de una GSC en FNK a partir de otra

Dada una GSC G=(N,T,P,S) podemos construir otra GSC G’ tal que L(G)=L(G’) y tal que G’
este en FNK.
En efecto, podemos suponer sin pérdida de generalidad que a G ya se le ha aplicado el proceso
de Mayusculización. A partir de P construimos P’ así:
1) Si una producción de P ya tiene el tipo indicado no debemos hacerle ningún cambio y la
copiamos en P’.
2) Si en P está la producción A-->X1...Xm con m>2 se le aplica un proceso de partición tal
como se hizo en la forma normal de Chomsky en gramáticas libres de contexto.
3) Si en P está la producción X1...Xn-->Y1...Ym con n≥2 y m≥n (nótese que por la
mayusculización todos los símbolos son No Terminales), se reemplaza por las siguientes
producciones:
X1X2 --> Y1W1
WjXj+2 --> Yj+1Wj+1 j=1,...,n-2
Wn-1 --> Yn...Ym (si esta producción tiene la parte derecha de longitud mayor a 2
se le aplica el proceso de partición de Chomsky)
Todos los Wi son nuevos No Terminales.
N’ se construye a partir de N añadiendo todos los nuevos No Terminales.
Ejemplo:
Sea la GSC G=({S,A,B,C,D,E},{a,b,d,c,e},P,S)
P:
S-->ABCD
S-->ABC
248
ABC-->DDD
ABCD-->CCACBEE
A-->a B-->b
C-->c D-->d
E-->e
Construimos así la GSC G’=(N’,{a,b,d,c,e},P’,S)
P’:
1)
A-->a
B-->b
C-->c
D-->d
E-->e
2) De S-->ABCD
S-->AZ1
Z1-->BZ2
Z2-->CD
De S-->ABC
S-->AZ3
Z3-->BC
3) De ABC-->DDD
AB-->DW1
W1C-->DW2
W2-->D
De ABCD-->CCACBEE
AB-->CV1
V1C-->CV2
V2D-->AV3
V3-->CBEE esta producción se reemplaza por
V3-->CZ4
Z4-->BZ5
Z5-->EE
Construcción de un ALL a partir de una GSC

Sea G=(N,T,P,S) una GSC, entonces podemos construir un ALL A tal que T(A)=L(G).
Representaremos la producción j-ésima así:
j
I1... jIn --> jD1... jDm donde n≤m
Cuando n<m, extenderemos la parte izquierda de la producción j-ésima así:

j
I1... jInjIn+1... jIm --> jD1... jDm donde jIn+1=...= jIm=b
(b es un símbolo auxiliar que denota el espacio en blanco)
249
De manera que después de esta transformación, todas las producciones de P son tales que
la parte izquierda es igual -en longitud- a la parte derecha. Denominaremos lj a la longitud de
la parte derecha (o izquierda) de la producción j-ésima, supondremos que existen |P|=k
producciones.
Construimos así el ALL A=(K,T ∪ (N ∪ {b}) ∪ {Λ,ρ},δ,q0,{qf })

δ:
1) q0 c c q1 c∈(T∪N∪{b})
q0 c c p1 c∈(T∪N∪{b})
2) q1 c R q1 c∈(T∪N∪{b,Λ})
q1 ρ L q2
q1 jD1 jD1 jp1 j=1,...,k
q2 c L q2 c∈(T∪N∪{b,ρ})
q2 Λ R q0
3) jph jDh jIh jqh j=1,...,k; h=1,...,(lj -1)
j
qh jIh R jph+1 j=1,...,k; h=1,...,(lj -1)
j j
ph b R ph j=1,...,k; h=1,...,(lj -1)
j
plj jDlj jIlj q2 j=1,...,k
4) p1 b R p1
p1 S R p2
p2 b R p2
p2 ρ L qf
K={q0,q1,q2,qf,p1,p2} ∪ {jqh / j=1,...,k; h=1,...,lj} ∪ {jph / j=1,...,k; h=1,...,lj}
La idea aquí es simular la derivación S=>*w de G en el ALL A pero en orden inverso.

Por ejemplo si el último paso de una derivación es abcD=>abcd, entonces en la cinta del ALL
las reglas deben cambiar el contenido de la cinta “abcd” por “abcD”, y así sucesivamente; los
espacios b añadidos aseguran que cada reemplazo coincida en tamaño. Si la simulación es
exitosa, al final el contenido de la cinta sera “S” posiblemente con espacios b a izquierda y
derecha.
Ejemplo:
Sea la GSC G=({S,B,A},{a},P,S) cuyo conjunto de producciones transformadas (con k=5) es
P:
i) Sb-->BS l1=2
ii) S-->A l2=1
iii) BA-->aA l3=2
iv) Bab-->aaB l4=3
v) A-->a l5=1
250
Construimos así el ALL A=(K,{a} ∪ {S,B,A,b} ∪ {Λ,ρ},δ,q0,{qf })
K = {q0,q1,q2,qf,p1,p2}
∪ {1 q 1 , 1 q 2 , 2 q 1 , 3 q 1 , 3 q 2 , 4 q 1 , 4 q 2 , 4 q 3 , 5 q 1 }
∪ {1 p 1 , 1 p 2 , 2 p 1 , 3 p 1 , 3 p 2 , 4 p 1 , 4 p 2 , 4 p 3 , 5 p 1 }
δ:
1) q0 a a q1 q0 a a p1
q0 b b q1 q0 b b p1
q0 c c q1 q0 c c p1
q0 S S q1 q0 S S p1
q0 B B q1 q0 B B p1
q0 A A q1 q0 A A p1
q0 b b q1 q0 b b p1
1
2) q1 a R q1 q1 B B p1 q2 a L q2
q1 b R q1 q1 A A 2p1 q2 b L q2
q1 c R q1 q1 a a 3p1 q2 c L q2
q1 S R q1 q1 a a 4p1 q2 S L q2
q1 B R q1 q1 a a 5p1 q2 B L q2
q1 A R q1 q2 A L q2
q1 b R q1 q2 b L q2
q1 Λ R q1 q2 ρ L q2
q1 ρ L q2 q2 Λ R q0
3) Para i) Sb-->BS l1=2
1
p1 B S 1q1
1
q1 S R 1p2
1
p1 b R 1p1
1
p2 S b q2
Para ii) S-->A l2=1

2
p1 A S q2
Para iii) BA-->aA l3=2

3
p1 a B 3q1
3
q1 B R 3p2
3
p1 b R 3p1
3
p2 A A q2
251
Para iv) Bab-->aaB l4=3
4
p1 a B 4q1
4
q1 B R 4p2
4
p1 b R 4p1
4
p2 a a 4q2
4
q2 a R 4p3
4
p2 b R 4p2
4
p3 B b q2
Para v) A-->a l5=1
5
p1 a A q2
4) p1 b R p1
p1 S R p2
p2 b R p2
p2 ρ L qf
Por ejemplo la derivación de la cadena “aa” en la gramática transformada es:
Sb=>BS=>BA=>aA=>aa
Los movimientos para la aceptación de dicha cadena son:
(1,q0,Λaaρ)|--(1,q1,Λaaρ)|--(2,q1,Λaaρ)|--(1,5p1,Λaaρ)
|--(2,q2,ΛaAρ)|--(1,q2,ΛaAρ)|--(0,q2,ΛaAρ)|--(1,q0,ΛaAρ)|--(1,q1,ΛaAρ)
|--(1,3p1,ΛaAρ)|--(1,3q1,ΛBAρ)|--(2,3p2,ΛBAρ)
|--(2,q2,ΛBAρ)|--(1,q2,ΛBAρ)|--(0,q2,ΛBAρ)|--(1,q0,ΛBAρ)|--(1,q1,ΛBAρ)|--(2,q1,ΛBAρ)
|--(2, 2p1,ΛBAρ)|--(2,q2,ΛBSρ)|--(1,q2,ΛBSρ)|--(0,q2,ΛBSρ)|--(1,q0,ΛBSρ)|--(1,q1,ΛBSρ)
|--(1,1p1,ΛBSρ)|--(1,1q1,ΛSSρ)|--(2,1p2,ΛSSρ)|--(2,q2,ΛSbρ)
|--(1,q2,ΛSbρ)|--(0,q2,ΛSbρ)|--(1,q0,ΛSbρ)|--(1,p1,ΛSbρ)
|--(2,p2,ΛSbρ)|--(3,p2,ΛSbρ)|--(2,qf,ΛSbρ)
Construcción de una GSC a partir de un ALL

Sea A un ALL, entonces podemos construir una GSC G tal que L(G)=T(A)-{λ}.
En efecto, sea el ALL A=(K,Σ ∪ Γ ∪ {Λ,ρ},δ,q0,{qf}) construimos así la GSC G=(N,Σ,P,S):
N = {S,Z,X}
∪ N1 donde N1={ aq / a∈(Σ∪Γ), q∈K }
∪ N2 donde N2={ [a / a∈(Σ∪Γ) } ∪ { a] / a∈(Σ∪Γ) }
∪ N3 donde N3={ [aq / a∈(Σ∪Γ), q∈K } ∪ { a]q / a∈(Σ∪Γ), q∈K }
∪ N4 donde N4={ (aq / a∈(Σ∪Γ), q∈K } ∪ { a)q / a∈(Σ∪Γ), q∈K }
∪ N5 donde N5={ a / a∈Σ }
Nótese que “aq”, “[a”, “a]”, “[aq”, “a]q”, “(aq”, “a)q” y “a” son –cada uno- un único símbolo de
N.
P:
1) S --> Z
S --> X
252
2) Z --> cZ c∈(Σ∪Γ∪N2)
Z --> Zc c∈(Σ∪Γ∪N2)
Z --> bqf b∈(Σ∪Γ∪N2)
Z --> a)qf a∈(Σ∪Γ)
Z --> (aqf a∈(Σ∪Γ)
3) Si q ρ L p es una regla de A
b]p --> b)q b∈(Σ∪Γ)
4) Si q Λ R p es una regla de A
[bp --> (bq b∈(Σ∪Γ)
5) Si q a L p es una regla de A
bpa --> baq b∈(Σ∪Γ)
bpa] --> ba]q b∈(Σ∪Γ)
[bpa --> [baq b∈(Σ∪Γ)
[bpa] --> [ba]q b∈(Σ∪Γ)
(ap --> [aq
6) Si q a R p es una regla de A
abp --> aqb b∈(Σ∪Γ)
[abp --> [aqb b∈(Σ∪Γ)
ab]p --> aqb] b∈(Σ∪Γ)
[ab]p --> [aqb] b∈(Σ∪Γ)
a)p --> a]q
7) Si q a b p es una regla de A
bp --> aq
[bp --> [aq
b]p --> a]q
8) [aq0 --> a a∈Σ
ab --> ab a,b∈Σ
ab] --> ab a,b∈Σ
9) Sea W={a / a∈T(A)} (nótese que W es finito)
X --> a a∈W
Las producciones de 9 son necesarias puesto que las producciones de 2 a 8 sólo generan –en
G- cadenas de 2 o más símbolos (que son aceptadas por A).
Ejemplo:
Sea el ALL A=({q0,qf},{a,b} ∪ Γ ∪ {Λ,ρ},δ,q0,{qf}) (en este caso Γ=∅) δ:
q0 ρ L qf
q 0 Λ R qf
q 0 a L q0
q 0 a L qf
q 0 a R qf
q0 a b qf
253
Sólo para tener un ejemplo más abarcador este ALL tiene varias cuádruplas que hacen
finalmente lo mismo, debiera ser claro que T(A)={λ}∪{aw / w∈Σ*}
Construimos así la GSC G=(N,{a,b},P,S):

N = {S,Z,X}
∪ { aq0, aqf, bq0, bqf }
∪ { [a, [b, a], b] }
∪ { [aq0, [bq0, [aqf, [bqf , a]q0, b]q0, a]qf, b]qf }
∪ { (aq0, (bq0, (aqf, (bqf , a)q0, b)q0, a)qf, b)qf }
∪ { a, b }
P:
1) S --> Z
S --> X
2)
Z --> aZ Z --> Za Z --> aqf Z --> a)qf Z --> (aqf
Z --> bZ Z --> Zb Z --> bqf Z --> b)qf Z --> (bqf
Z --> [aZ Z --> Z[a Z --> [aqf
Z --> [bZ Z --> Z[b Z --> [bqf
Z --> a]Z Z --> Za] Z --> a]qf
Z --> b]Z Z --> Zb] Z --> b]qf
3) De q0 ρ L qf
a]qf --> a)q0
b]qf --> b)q0
4) De q0 Λ R qf
[aqf --> (aq0
[bqf --> (bq0
5) De q0 a L q0
aq0 a --> a aq0
bq0 a --> b aq0
aq0 a] --> a a]q0
bq0 a] --> b a]q0
[aq0 a --> [a aq0
[bq0 a --> [b aq0
[aq0 a] --> [a a]q0
[bq0 a] --> [b a]q0
(aq0 --> [aq0
De q0 a L qf
aqf a --> a aq0
bqf a --> b aq0
aqf a] --> a a]q0
bqf a] --> b a]q0
[aqf a --> [a aq0
254
[bqf a --> [b aq0
[aqf a] --> [a a]q0
[bqf a] --> [b a]q0
(aqf --> [aq0
6) De q0 a R qf
a aqf --> aq0 a
a bqf --> aq0 b
[a aqf --> [aq0 a
[a bqf --> [aq0 b
a a]qf --> aq0 a]
a b]qf --> aq0 b]
[a a]qf --> [aq0 a]
[a b]qf --> [aq0 b]
a)qf --> a]q0
7) De q0 a b qf
bqf --> aq0
[bqf --> [aq0
b]qf --> a]q0
8)
[aq0 --> a aa --> aa a a] --> aa

[bq0 --> b ab --> ab a b] --> ab
ba --> ba b a] --> ba
bb --> bb b b] --> bb
9) X --> a pues W={a}
Unión
Los lenguajes sensibles al contexto son cerrados respecto de la operación unión.
Sean G1=(N1,T1,P1,S1) y G2=(N2,T2,P2,S2) dos GSC’s en forma normal tales que L(G1)=L1 y
L(G2)=L2 con (N1∩Ν2)={}, S∉(N1∪N2), entonces podemos construir una GSC G tal que
L(G)=L1∪L2.
La construcción y la demostración son prácticamente las mismas que para GLC’s.
Construimos así la GSC G=(N1∪N2∪{S},T1∪T2,{S-->S1}∪{S-->S2}∪P1∪P2,S).
Nótese que si las GSC’s no están en forma normal la construcción puede dar lugar a cosas
erróneas:
Sea G1=({S1},{a},{S1-->a},S1) y G2=({S2},{b,d},{S2-->b,a-->d},S2). Es claro que ambas son
GSC’s, que L(G1)={a} y que L(G2)={b}, siguiendo la construcción indicada tenemos que
G=({S,S1,S2},{a,b,d},{S-->S1,S-->S2,S1-->a,S2-->b,a-->d},S) que genera L(G)={a,b,d} que
evidentemente no es la unión deseada.
255
Concatenación
Los lenguajes sensibles al contexto son cerrados respecto de la operación concatenación.
Sean G1=(N1,T1,P1,S1) y G2=(N2,T2,P2,S2) dos GSC’s tales que L(G1)=L1 y L(G2)=L2 con
(N1∩Ν2)={}, S∉(N1∪N2), entonces podemos construir una GSC G tal que L(G)=L2.L1.
Necesitamos más requerimientos sobre G1 y G2 para aplicar la construcción vista en las
GLC’s, pues hacerlo directamente acarrea errores como se muestra a continuación.
Sean las GSC’s G1=({S1},{a},{S1-->a},S1) y G2=({S2},{a,b,d},{S2-->b,aS2-->ad},S2). Nótese
que L(G1)={a} y L(G2)={b}. Siguiendo directamente la construcción mencionada, tenemos
que G=({S,S1,S2},{a,b,d},{S-->S1S2,S1-->a,S2-->b,aS2-->ad},S) que genera L(G)={ab,ad} que
evidentemente no es la concatenación deseada, incluso bajo el hecho de las dos gramáticas
iniciales están en forma normal.
Lo que sucede es que los contextos, que se consideran en la parte izquierda de las
producciones (para aplicarlas), no están siendo diferenciados, es decir, “se mezclan”.
Debemos pues diferenciarlos y una forma que no resta generalidad al enunciado es exigir que
las dos gramáticas iniciales G1 y G2 sean tales que tengan sólo No Terminales en la parte
izquierda de sus producciones, si a ello le sumamos que N1 y N2 son disjuntos entonces la
posibilidad de mezcla desaparece.
Construimos así la GSC G=(N1∪N2∪{S},T1∪T2,{S-->S1S2}∪P1∪P2,S).
Ejemplo:
Sean las GSC’s G1=({S1},{a},{S1-->a},S1) y G2=({S2},{a,b,d},{S2-->b,aS2-->ad},S2).
Como G2 no cumple el requerimiento, construimos G’ a partir de G2 tal que L(G’)=L(G2)
como ya se sabe:
G’=({S2,Xa,Xb,Xd},{a,b,d},{S2-->Xb,XaS2-->XaXd,Xa-->a,Xb-->b,Xd-->d},S2)
Finalmente construimos así la GSC G=({S,S1,S2,Xa,Xb,Xd},{a,b,d},P,S)
P:
S-->S1S2
S1-->a
S2-->Xb
XaS2-->XaXd
Xa-->a
Xb-->b
Xd-->d
Cruz de Kleene
Los lenguajes sensibles al contexto son cerrados respecto de la operación Cruz de Kleene.
Al igual que en el anterior caso es posible que al aplicar directamente la solución para GLC’s
los contextos, que se consideran en la parte izquierda de las producciones (para aplicarlas), no
se diferencien, es decir, “se mezclen”, como mostramos a continuación incluso si la GSC
inicial tiene sólo No Terminales en la parte izquierda de sus producciones.
Sea la GSC G1=({S1,A},{a,b},{S1-->A,AS1-->Ab,A-->a},S1). Nótese que L(G1)={a}.
256
Siguiendo directamente la construcción mencionada, tenemos que
G=({S,S1,A},{a,b},P,S)
P:
S-->S1S
S-->S1
S1-->A
AS1-->Ab
A-->a
Que permite la derivación S=>S1S=>S1S1=>AS1=>Ab=>ab de la cadena “ab”que
evidentemente no está en la cruz de Kleene deseada.
Para evitar estos problemas recurrimos a la siguiente ingeniosa solución.
Sea G1=(N1,T1,P1,S1) una GSC que tiene sólo No Terminales en la parte izquierda de sus
producciones tal que L(G1)=L1, con S∉N1, entonces podemos construir una GSC G tal que
L(G)=L1+ así:
A partir de G1 obtenemos la GSC G2=(N2,T1,P2,S2) que es prácticamente la misma que G1
salvo que los nombres de las No Terminales tienen el subíndice 2 de manera que (N1∩N2)={}
y S∉N2. Es claro que L(G2)=L1=L(G1).
Ahora, con G1 y G2, construimos G así:
G=(N1∪N2∪{S},T1,{S-->S1S2S,S-->S1S2,S-->S1}∪P1∪P2,S).
De manera que tendremos derivaciones que comiencen así S=>+S1S2S1S2...S1S2(S1), cada
símbolo S1 (o S2) derivará una cadena de L1, y como N1∩N2 no hay posibilidad de mezcla.
Ejemplo:
Sea las GSC G1=({S1,A},{a,b},{S1-->A,AS1-->Ab,A-->a},S1).
Construimos así la GSC G2=({S2,A2},{a,b},{S2-->A2,A2S2-->A2b,A2-->a},S2).
Y así la la GSC G=({S,S1,A,S2,A2},{a,b},P,S)
P:
S-->S1S2S
S-->S1S2
S-->S1
S1-->A
AS1-->Ab
A-->a
S2-->A2
A2S2-->A2b
A2-->a
Intersección
Los lenguajes sensibles al contexto son cerrados respecto de la operación intersección.
Sean A1=(K1,Σ1 ∪ Γ1 ∪ {Λ,ρ},δ1,q0,{qf}) y A2=(K2,Σ2 ∪ Γ2 ∪ {Λ,ρ},δ2,p0,{pf}) dos ALL’s
tales que T(A1)=L1 y T(A2)=L2 con (K1∩Κ2)={} y rh∉(K1∪K2), entonces podemos construir
un ALL A tal que T(A)=L1∩L2.
257
La idea de la construcción es que el ALL A actúe primero como A1 y si la cadena es aceptada
por este primer ALL luego actúe como A2 con la misma cadena. Como sólo tenemos una cinta
para la cadena de entrada, es usual copiar dicha cadena en una “cinta auxiliar” y si A1 acepta
la entrada, reponer dicha cadena de la cinta auxiliar a la cinta de entrada del ALL A. Ello se
hace de la siguiente ingeniosa manera utilizando la única cinta que tenemos en A:
Cada símbolo de entrada ai en la cinta, se reemplaza por el (nuevo) símbolo ici, por ejemplo si
en la cinta tenemos la entrada aba=a1a2a1, se la reemplaza por 1c12c21c1 (la negrita es sólo para
diferenciar el símbolo del centro). Luego se construye a partir de A1 un conjunto de
cuádruplas que trabajan de manera semejante a δ1 pero sobre los superíndices i de los
símbolos icj. He aquí la simulación de dos cintas: los superíndices trabajan como lo símbolos
de la cinta “de arriba” y los subíndices actúan como la “cinta auxiliar de abajo”. Todo lo que
hace A1 se hace en la “cinta de arriba”. Si A1 llega a su estado final, pasamos al estado inicial
de A2 y, o bien trabajamos en la “cinta de abajo” o bien reponemos la entrada original
cambiando cada símbolo icj por aj.
Nótese que además de los símbolos ici necesitamos otros del tipo icj.
Construimos así el ALL A=(K1∪K2∪{r0,r1,r2,r3},Σ,δ,r0,{pf})

Sea Σ1∪Σ2∪Γ1∪Γ2={a1,...,an}.
Σ = Σ1 ∪ Σ2 ∪ Γ1 ∪ Γ2 ∪ {Λ,ρ} ∪ { icj / i=1,...,n; j=1,...,n }
δ:
r0 ai ici r1 i=1,..,n Van cambiando los símbolos de la cadena de entrada
i
r1 ci R r0 i=1,..,n de izquierda a derecha uno a uno, creando las “dos cintas”.
r 0 ρ L r2 Cuando termina vuelve el puntero
r2 ici L r2 i=1,..,n al principio de la entrada
r2 Λ R q 0 para empezar como A1.
qh icj L qk j=1,..,n si qh ai L qk está en δ1 simulan A1

qh icj R qk j=1,..,n si qh ai R qk está en δ1 en la cinta
qh icg jct qk g=1,..,n si qh ai aj qk está en δ1 superior
t=1,..,n
qh ρ L qk si qh ρ L qk está en δ1
q h Λ R qk si qh Λ R qk está en δ1
qf icj R qf g=1,..,n Si A1 llegó al estado final

t=1,..,n avanzamos hasta el final de la cinta
q f ρ L r3
r3 icj aj r3 g=1,..,n Reponemos la entrada original almacenada
t=1,..,n en la “cinta inferior”
r3 aj L r3 j=1,..,n
r3 Λ R p 0 Y empezamos el trabajo de A2
258
ph ai L pk si ph ai L pk está en δ2 Es decir,
ph ai R pk si ph ai R pk está en δ2 copiar
ph ai aj pk si ph ai L pk está en δ2 A2
ph ρ L pk si ph ρ L pk está en δ2
p h Λ R pk si ph Λ R pk está en δ2
Ejemplo:
Sea el ALL A1=({q0,q1,qf},{a,b}∪{Λ,ρ},δ1,q0,{qf})
δ1:
q0 a R q1
q1 b R q1
q1 ρ L qf
Sea el ALL A2=({p0,pf},{a,b}∪{Λ,ρ},δ2,p0,{pf})
δ2:
p0 a R p0
p0 b R p0
p0 ρ L pf
Construimos así el ALL A=({q0,q1,qf,p0,pf,r0,r1,r2,r3},Σ,δ,r0,{pf})
Σ={a,b}∪{Λ,ρ}∪{1c1,1c2,2c1,2c2}
δ:
r0 a 1c1 r1 q0 1c1 R q1 qf 1c1 R qf p0 a R p0
r0 b 2c2 r1 q0 1c2 R q1 qf 1c2 R qf p0 b R p0
r1 1c1 R r0 q1 2c1 R q1 qf 2c1 R qf p0 ρ L pf
2
2
r1 c2 R r0 2
q1 c2 R q1 q f c2 R q f
r 0 ρ L r2 q1 ρ L qf q f ρ L r3
1
r2 c1 L r2 r3 1c1 a r3
r2 2c2 L r2 r3 1c2 b r3
r3 2c1 a r3
r2 Λ R q 0
r3 2c2 b r3
r3 a L r3
r3 b L r3
r3 Λ R p 0
Complemento
Immerman demostró en 1987 que los lenguajes sensibles al contexto son cerrados respecto de
la operación complemento. La prueba de ello en términos de cuádruplas es demasiado extensa
para describirse. Sin embargo, presentaremos la idea subyacente a este resultado en forma de
un procedimiento más parecido al lenguaje natural. Lo central de dicho procedimiento es
entender que cada instrucción del procedimiento puede ser traducida a cuádruplas y cada
cálculo quepa en la longitud de la cinta de entrada del ALL A’ (con la entrada w).
259
Recordemos también que es posible simular más de una cinta de trabajo en un sola cinta,
como muestra el caso de la intersección (donde el nodeterminismo se nota bien al elegir una
de entre varias producciones representadas por cuádruplas); se necesitan varias cintas para
varios contadores y contenedores de cadenas en lo que sigue.
Dado el ALL A -T(A)=L- se construiye A’ de manera tal que en lugar de almacenar todas las
d.i. de A, simplemente las contemos (posiblemente almacenando una d.i. a la vez). Ello es
posible pues para la cinta conteniendo Λwρ, con |w|=n y |K|=k estados hay un número finito
t = |Λwρ|*k*n|w| de d.i.. Podemos limitar el tiempo de corrida de A –con la entrada w- a t, pue
cualquier serie de movimientos de largo mayor a t repetirá alguna d.i. necesariamente.
Sea I la d.i. inicial de A y sea m el número de d.i. alcanzables desde I.
Primero supondremos que tenemos calculado –en alguna cinta de A’- el valor de m, luego
indicaremos cómo puede calcularse.
El siguiente procedimiento de A’ acepta cadenas cuando A las rechaza:
r=0
Para todas las t d.i.:
Sea C la d.i. en actual consideración
Simule nodeterminísticamente una serie de movimientos de I a C -en A-
(quizás limitando el tiempo de corrida de A)
Si ello es posible:
Si C incluye al estado final de A rechace w
Si no r=r+1
Si r=m entonces acepte w, en otro caso rechace w
Si A acepta w, A’ encontrará nodeterminísticamente la serie de movimientos hasta llegar a la
d.i. de aceptación y rechazará w. En otro caso, A’ encontrará nodeterminísticamente todas las
m d.i. alcanzables desde I y la última condición del procedimiento hará que acepte w.
Para el cálculo de m diremos que mj es el número de d.i. alcanzables desde I en a lo más j
pasos. Es claro que m0=1 y que mt=m –que es lo que se desea calcular-.
El siguiente procedimiento calcula mj+1 a partir de mj.
mj+1=0
Sea C la d.i. en actual consideración
b=0
r=0
Sea D la d.i. en actual consideración
Simule nodeterminísticamente una serie de movimientos de I a D en a lo más j pasos
Si ello es posible:
r=r+1
Si D=C o C se alcanza a partir de D en 1 movimiento
b=1
Si r<mj rechace este cálculo
mj+1=mj+b
260
La condición r<mj garantiza que hayamos considerado todas las d.i. D alcanzables desde I en j
movimientos, cuando dicha condición se cumple significa que se ha calculado bien el valor de
b, que será 1 si C es alcanzable desde I en a lo más j+1 movimientos, y será 0 en otro caso.
PROBLEMAS DE DECISIÓN
Presentaremos ahora algunos resultados conocidos para lenguajes sensibles al contexto.
Pertenencia de una cadena a un lenguaje sensible al contexto

El problema siguiente es decidible: ¿pertenece la cadena w a L(G) donde G es una GSC?
En efecto, sea G una GSC, dado que en sus producciones cada parte izquierda es –en longitud-
menor o igual que su parte derecha, resulta que cualquier derivación que empiece en S, si
hacemos S=u1 hablamos de u1=>u2=>u3=>...=>un, es tal que |u1|≤|u2|≤...≤|un|. Además no es
posible que las formas sentenciales de una derivación tenga la misma longitud infinitamente
puesto que sólo hay un número finito de No Terminales y de Terminales.
Ello nos ofrece un procedimiento para determinar la pertenencia o no de w al lenguaje:
A partir de S derivamos todas las formas sentenciales de longitud 1 (si ello es posible, nótese
que S se incluye por sí misma), a partir de ellas todas las formas sentenciales de longitud 2, y
así sucesivamente hasta derivar todas las formas sentenciales de longitud |w|. Luego vemos si
w está en este último grupo, si es así w∈L(G) en otro caso w∉L(G).
Ciertamente este es un procedimiento costoso computacionalmente pero, cuando menos
teóricamente, es efectivo.
Algunos otros problemas de decisión

Para G una GSC, el problema de determinar si L(G)={} es indecidible. En efecto, si el
problema fuera decidible, dado que una GLC es una GSC, podemos partir de dos GLC’s,
convertirlas en GSC’s (no hay que hacer cambio alguno), obtener los ALL’s asociados,
obtener el ALL que acepte la intersección y verificar si este último ALL acepta el vacío o no;
lo que solucionaría el problema de determinar si la intersección de dos lenguajes libres de
contexto es vacía, cosa que –como se mencionó en el anterior capítulo- es indecidible.
Presser menciona que el problema de determinar si L(G) es infinito se muestra indecidible en
el trabajo de Landweber.
Finalmente el problema de saber si los ALL no determinísticos son equivalentes a los ALL
determinísticos continúa abierto.
Lenguajes no sensibles al contexto

Mostraremos que hay –por lo menos- un lenguaje (recursivo) que no es sensible al contexto.
Trabajemos con el alfabeto T={a} y pensemos en todas las GSC’s que tienen este conjunto de
Terminales, es decir, en adelante cualquier mención a una GSC supondrá que ésta trabaja con
T={a} como conjunto de Terminales. Sin pérdida de generalidad supongamos que todas estas
gramáticas tienen sus No Terminales renombrados como X1, X2, etc. (X1 denota al símbolo
raíz).
261
Seguidamente lo que haremos será representar cada una de las GSC’s por una sola cadena en
el alfabeto B={0,1} (aquí pensamos básicamente en la representación del conjunto de
producciones, pero es fácil generalizar ello a la descripción de toda la gramática), para ello
utilizamos los siguientes reemplazos (el “;” está pensado como separador de producciones):
a se reemplaza con 0
--> se reemplaza con 01
; se reemplaza con 011
Xi se reemplaza con 01i+2
No todas las cadenas de B* representan GSC’s, pero dada una de estas cadenas hay a lo más
una GSC representada por ella.
Ahora podemos ordenar lexicográficamente todas las cadenas de B* y por tanto ordenar todas
las GSC’s.
Sea Lj el lenguaje generado por la j-ésima GSC de esta ordenación y sea L={aj / aj∉Lj}.
L no es sensible al contexto. En efecto, supongamos que lo sea, es decir hay una GSC que
genera L; por lo tanto dicha GSC debe estar en la ordenación mencionada, digamos que es la
k-ésima GSC de esta ordenación, es decir, L=Lk. Pero entonces resulta que
ak∈L si y sólo si ak∉Lk por la forma de L
si y sólo si ak∉L pues Lk=L
Esta contradicción prueba nuestra afirmación.
Se puede decir más aún, L así definido es recursivo (véase el siguiente capítulo). En efecto,
dada la cadena “aj” podemos determinar si está o no en L así: primero ubicamos en la
ordenación la j-ésima GSC, luego dado que esta gramática es recursiva podemos observar si aj
está o no en Lj, si no lo está aj es de L, en otro caso no.
262
CAPÍTULO 14. RELACIONES Y CONVERSIONES ENTRE NIVELES DE LA
JERARQUÍA DE CHOMSKY
Todos los lenguajes regulares son libres de contexto

En efecto, las GR’s cumplen la definición de las GLC’s, es más podemos decir que –vistas
como GLC’s- están en FNG.
Alternativamente mostraremos la construcción de un APe.f. a partir de un AFN.
Dado una AFN A’, podemos construir un APe.f. A tal que T(A’)=T(A).
En efecto, sea el AFN A’=(K, Σ, d, q1, F), construimos así el APe.f. A:
A=(K, Σ, {Z}, δ, q1, Z, F)
δ: (qj,Z)∈δ(qi,a,Z) si qj∈d(qi,a)
Nótese que aquí el estado inicial del APe.f. es q1 y que el único símbolo de la pila no se
mueve ni cambia nunca.
Ejemplo:
A partir del siguiente AFN A’=({q1,q2},{a,b},d,q1,{q2})
d:
d(q1,a)={q1,q2}
d(q2,b)={q1,q2}
Construimos así el AP e.f. A=({q1,q2},{a,b},{Z},δ,q1,Z,{q2})
δ:
δ(q1,a,Z)={(q1,Z),(q2,Z)}
δ(q2,b,Z)={(q1,Z),(q2,Z)}
Mencionemos además que hay lenguajes libres de contexto que no son regulares, por ejemplo
{aibi / i>0}.
Todos los lenguajes libres de contexto son sensibles al contexto

En efecto, las GLC’s cumplen la definición de las GSC’s, es más podemos decir que –vistas
como GSC’s- están en forma normal.
Alternativamente mostraremos de manera indirecta cómo construir un ALL a partir de un
autómata de pila: Sin pérdida de generalidad supongamos que tenemos un APθ A’ a partir de
A’ sabemos que puede construirse una GLC G’, también se sabe que desde G’ podemos
construir una GSC G (es prácticamente la misma), finalmente con G podemos construir un
ALL como se indica en el anterior capítulo.
Mencionemos además que hay lenguajes sensibles al contexto que no son libres de contexto,
por ejemplo {aibici / i>0}.
Aunque no las exponemos agregaremos que todas las GSC’s cumplen la definición de unas
gramáticas denominadas de tipo 0.
Jerarquía de Chomsky
Se conoce como Jerarquía de Chomsky a una categorización por niveles de los lenguajes y sus
gramáticas y autómatas asociados. La más común es la siguiente:
263
L3: Lenguajes tipo 3 o regulares, soportados por los autómatas finitos y las gramáticas
regulares, por ejemplo {ai / i>0}.
L2: Lenguajes tipo 2 o libres (independientes) de contexto, soportados por los autómatas de
pila y las gramáticas libres de contexto, por ejemplo {aibi / i>0}.
L1: Lenguajes tipo 1 o sensibles al contexto, soportados por los autómatas limitados
linealmente y las gramáticas sensibles al contexto, por ejemplo {aibici / i>0}.
L0: Lenguajes tipo 0 o recursivamente enumerables, soportados por las gramáticas tipo 0 y las
máquinas de Turing. Es más usual estudiar estos desde la perspectiva de las máquinas de
Turing y la computabilidad, que se constituyen en un capítulo fundamental de la teoría de la
computación más allá de los lenguajes formales.
La jerarquía mencionada es esta:
L3_L2_L1_L0
Algunas investigaciones han agregado tipos (o familias) de lenguajes entre estas cuatro
clásicas, por ejemplo los lenguajes libres de contexto determinísticos L’ son tales que
L3_L’_L2.
Construcción de una Gramática de tipo 1,2 ó 3 cuyo símbolo raíz no aparezca en

ninguna parte derecha de las producciones
La construcción dada para gramáticas tipo 3 sirve bien aquí.
Sea G=(N,T,P,S) -S’∉N- una gramática de tipo 1, 2 ó 3 tal que L(G)=L y G incluye a su
símbolo raíz S en la parte derecha de alguna(s) de sus producciones, podemos construir así
una gramática G’ de tipo 1, 2 ó 3 correspondientemente tal que G’ no incluya a su símbolo
raíz en la parte derecha de ninguna de sus producciones y L(G’)=L(G):
G’=(N∪{S’},T,P’,S’)
P’ = P ∪ { S’ --> α / S --> α ∈ P }
Es obvio que S’ no aparecerá en ninguna parte derecha porque S’ no es un símbolo de G
L(G) es recursivo para G una gramática de tipo 1, 2 ó 3

Cuando decimos que L(G) es recursivo queremos indicar que el problema de determinar si
una cadena dada está o no en L(G) (membresía) es decidible. Ya hemos mostrado cómo
determinar si la cadena w está o no en L(G) cuando G es una gramática de tipo 3, 2 ó 1.
El procedimiento visto para las GSC’s sirve bien para los otros tipos, esta es una consecuencia
de la propiedad de no decrecimiento de las formas sentenciales que se van derivando.
Variantes
Para las gramáticas y –en particular- los autómatas presentados, se han sugerido y estudiado
una cantidad importante de variantes. Por ejemplo controlando el orden en que se utilizan las
producciones como en las gramáticas denominadas atributivas. O bien dando o quitando
flexibilidad a los autómatas ya sea en el manejo de la cinta de entrada o en otros componentes
de los mismos, por ejemplo autómatas de pila con más de una pila, con un sólo símbolo en la
pila (counter pushdown), autómatas finitos que pueden ir a derecha o izquierda en la cinta de
entrada (bidireccionales), y un largo etcétera.
264
Sólo a título de ejemplo daremos una descripción de uno de ellos, invitando al(a la) lector(a) a
indagar en los otros casos:
Autómatas finitos probabilísticos (AFP)

Un AFP es una séxtupla A=(K,Σ,δ,Q0,F,ε)
K, Σ, y F tienen la misma interpretación que en los autómatas finitos (K={q0,...,qn}).
δ:K X Σ-->[0,1]n+1 define las reglas de probabilidades de transición. Así cada regla es del tipo
δ(qi,a)=[p0(qi,a),...,pn(qi,a)], pj(qi,a) es la probabilidad de pasar del estado qi al estado qj con el
símbolo a (Σpj(qi,a)=1).
Q0=[p0,...,pn] es el vector distribución inicial que describe la probabilidad pi de que el estado
de inicio sea qi (Σpj=1), es decir, todos los estados (con pj>0) son probables estados iniciales.
ε es el punto de corte que permite discernir cuándo una cadena es aceptada o no.
Dada δ podemos construir una matriz M denominada matriz de probabilidades de transición
para cada a∈Σ así (es usual que al escribir un AFP se presenten directamente las matrices):
 p0(q0,a) ... pn(q0,a) 
M(a) =  ... ... ... 
 p0(qn,a) ... pn(qn,a) 
M(az)= M(a) X M(z), así cuando w=a1...am con m>0, M(w)=M(a1) X...X M(am).
Interesa saber la probabilidad pf(w) de terminar en un estado final partiendo de algún estado
inicial con la cadena w, misma que calcularemos así:
Construimos el vector columna F=[f1 ... fn]T (la T indica transposición) con fj=1 si qj∈F,
fj=0 en otro caso.
pf(w)= Q0 X M(w) X F
El lenguaje aceptado por el AFP se define así T(A)={ w∈Σ* / pf(w)>ε }
Qj = Q0 X M(w) es la distribución j originada por la cadena w a partir del vector distribución
inicial. La siguiente distribución Qj+1 originada por la cadena z a partir de la distribución Qj
será Qj+1 = Qj X M(z). De manera que dada una cadena, no tenemos una secuencia de estados
sino una secuencia de distribuciones.
Nótese que si Q0=[1,0,...,0] y cada fila de las matrices M(ai) tiene sólo un 1 y el resto ceros, el
AFP no es otra cosa que un AFD.
Ejemplo:
Sea el siguiente AFP A=({q0,q1},{a,b},δ,Q0,{q1},ε=0.8)
δ:
0.7 0.3 0.4 0.6
M(a)=   M(b)=  
0.6 0.4 0.6 0.4
Q0=[0.5 0.5]
265
Veamos qué pasa con la cadena w=abb:
F=[0 1] T
0.7 0.3 0.4 0.6 0.4 0.6 0.508 0.492
M(abb)=M(a) X M(b) X M(b)=  X X = 
0.6 0.4 0.6 0.4 0.6 0.4 0.504 0.496
0.508 0.492 T
pf(abb)=Q0 X M(w) X F=[0.5 0.5] X   X [0 1] =0.494
 0.504 0.496
Como pf(abb) no es mayor que el punto de corte ε=0.8, la cadena w no es aceptada.
266
BIBLIOGRAFÍA
Brookshear Glenn. “Teoría de la computación”. Addison-Wesley. Priemra edición. 1993.
Brzozowski Janusz. “Derivatives of regular expressions”. Journal of the ACM. Vol. 11, No. 4,
pp. 481-494. 1964.
Davis, Martin; Sigal Ron; Weyuker Elaine. “Computability, complexity and languages”.
Academic Press. Segunda edición. 1994.
Fernandez Gregorio; Sáez Fernando. “Fundamentos de informática”. Alianza. Primera

edición. 1987.
García Pedro et al. “Teoría de autómatas y lenguajes formales”. Alfaomega. Primera edición.
2001.
Ginzburg A. “A procedure for checkin equality of regular expressions”. Journal of the ACM
Vol 14, No. 2, pp. 355-362. 1967.
Hopcroft, John; Ullman Jeffrey. “Introducción a la teoría de autómatas, lenguajes y

computación”. Continental. Primera edición. 1997.
Immerman Neil. “Nondeterministic space is closed under complementation” SIAM Journal of

Computer, pp. 935-938. 1988.
Kelley Dean. “Teoría de autómatas y lenguajes formales”. Prentice Hall. Primera edición
1995.
Martin, John. “Introduction to languages and the theory of computation”. McGraw-Hill.

Tercera edición. 2003.
Presser, Leon; Cárdenas Alfonso; Marín Miguel. “Ciencias de la computación” Vol. II

Lenguajes, traductores y aplicaciones. Limusa. Primera edición. 1972.
267
ÍNDICE
AFD, 33
AFN, 48
Alfabeto, 1
ALL, 242
Ambigüedad, 158
APe.f., 169
APθ, 169
Árboles, 154
Arden, 75
Autómata finito determinístico, 33
Autómatas de pila, 169
Autómatas finitos determinísticos, 33
Autómatas finitos probabilísticos, 265
Autómatas limitados linealmente, 242
Brzozowski, 108
Cabeza de la parte derecha, 165
Cadena, 1
Cerradura, 128, 215, 245
Clausura reflexiva transitiva, 7
Cociente, 6
Complemento, 6, 134, 259
Concatenación, 3, 4, 131, 216, 256
Cruz de Kleene, 6, 219, 256
Cuasi-gramáticas libres de contexto, 204
CYK, 233
Chomsky, 162
Derivadas, 65
Descripción instantánea, 38, 39, 169
Determinístico, 33, 34, 48, 176, 177, 178, 179
Diferencia, 6, 133
Earley, 141
Ecuaciones, 75
Equivalencia, 145
Estrella, 5
Estrella de Kleene, 5, 66, 112, 128, 135, 232
Expansión, 164
Expresiones regulares, 62
FNCH, 186
FNG, 191
FNK, 242
Forma normal, 162, 242
Ginzburg, 145
GLC, 152
GLC limpia, 180
268
Glushkov, 101
Gramática libre de contexto, 152
Gramática regular lineal derecha, 8
Gramática regular lineal izquierda, 20
Gramáticas LL y LR, 239
Gramáticas regulares, 8
Greibach, 162
GRLD, 23
GRLI, 23
GSC, 241
Igualdad, 2
Immerman, 259
Inclusión, 144
Intersección, 4, 134, 222, 223, 226, 257
Inversa, 2
Inverso, 5
Jerarquía de Chomsky, 263
Kleene, 100
Kuroda, 242
L(G) lenguaje generado, 14
Lema de bombeo, 43, 165
Lenguaje, 2
Lenguaje regular, 26
Lenguajes sensibles al contexto, 241
Longitud, 2
McNaughton, 101
Minimización, 118
Moore, 145
Myhill-Nerode, 45
No determinístico, 48
No terminales inaccesibles, 161
No terminales inútiles, 161
Ogden, 167
Paso de derivación, 13
Poda, 164
Potencia, 3
Prefijo, 3
Problemas de decisión, 141, 233, 261
Producciones borradoras, 161
Producciones renombradoras, 161
Recursivo por izquierda, 165
Regla de transición, 33
Reinicializable, 87
Símbolo, 1
Subcadena, 4
Sufijo, 4
Suma directa, 145
269
T(A): lenguaje aceptado, 40
Thompson, 104
Transiciones vacías, 52
Unión, 4, 128, 215, 255
Yamada, 101
λ-AFN, 52
λ-cierre, 53
270

LF PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

LF PDF

Încărcat de

Drepturi de autor:

Formate disponibile

LENGUAJES FORMALES

(Gramáticas y Autómatas en Informática)

Resta agradecer a la Universidad Mayor de San Andrés, a la Facultad de Ciencias Puras y

Los desaciertos son mi responsabilidad: me adelanto en agradecer a quienes hagan notarlos,

Cadena o Hilera o Palabra

Operaciones con cadenas

Inversa o Reversa o Transpuesta:

Potencia enésima de una cadena:

Por la propiedad 3 de la concatenación, |wn| = n|w|, la longitud de la potencia n de w es n

Número de ocurrencias de un símbolo dado:

Operaciones con lenguajes

Estrella o clausura de Kleene:

Lenguaje Universal sobre el alfabeto T :

Cociente de un lenguaje (por una palabra y entre lenguajes):

Relación de equivalencia y partición de un conjunto:

Sea R definida sobre T+={a,b}+ así:

Clausura reflexiva transitiva de una relación:

Para el caso de gramáticas, utilizaremos dos alfabetos frecuentemente:

Los siguientes son ejemplos de alfabetos (para diferenciarlos utilizamos subíndices):

GRAMÁTICAS REGULARES LINEALES DERECHAS

Una producción de una GRLD es un par ordenado (α,β).

La siguiente es una Gramática Regular Lineal Derecha (GRLD) G:

El siguiente es un mal ejemplo de Gramática Regular Lineal Derecha (GRLD) G:

El siguiente es un mal ejemplo de Gramática Regular Lineal Derecha (GRLD) G:

El siguiente es un mal ejemplo de Gramática Regular Lineal Derecha (GRLD) G:

La siguiente es una Gramática Regular Lineal Derecha (GRLD) G:

Mecanismo de funcionamiento de las GRLD’s

1) aaaXbbb => aaabXbbb pues

2) abXba => abbYba pues

3) YaScYbS => YaSccbS pues

4) Sba => aXba pues

S => aX utilizando la primera producción

En rigor, lo que llamamos un paso de derivación no es sino el establecimiento de una relación

Cadenas generables por la GRLD G

En el ejemplo de la GRLD G de arriba podemos escribir lo siguiente:

L(G) lenguaje generado por una GRLD

Llegamos así a otro problema central en GRLD’s:

Sea la GRLD G=({S,X}, {a,b}, P, S)

Sea la GRLD G=({S,X,Y}, {a,b}, P, S)

Sea la GRLD G=({S,X,Y}, {a,b}, P, S)

Sea la GRLD G=({S}, {a}, P, S)

Sea la GRLD G=({S,X}, {a,b}, P, S)

Sea la GRLD G=({S,X,Y}, {a,b,c}, P, S)

Sea la GRLD G=({S,X,Y}, {a,b,c}, P, S)

Sea la GRLD G=({S,X}, {a,b}, P, S)

Dado un lenguaje escribir las producciones

Construya una GRLD G que genere L={aub / u ∈ {a,b}*}

En las producciones es posible que no se utilicen algunos Terminales o algunos No

¿Cuántos No Terminales/Terminales deben tener la gramáticas? Desde 1 hasta n (finito)

Construya una GRLD G que genere L={aub / u ∈ {a,b}* }

GRAMÁTICAS REGULARES LINEALES IZQUIERDAS

Una producción de una GRLI es un par ordenado (α,β).

Sea la siguiente Gramática Regular Lineal Izquierda G=({S,X,Y}, {a,b,c}, P, S)

Sea la siguiente Gramática Regular Lineal Izquierda G=({S,X,Y}, {a,b}, P, S)

La siguiente GRLI de la que sólo mostramos P genera L(G)={oruro}

La derivación de la cadena oruro sería así:

Sea la GRLD G=({S}, {a}, P, S)

Sea la GRLI G=({S,X,Y}, {a,b}, P, S)

Sea la GRLD G=({S,X,Y}, {a,b}, P, S)

Sea la GRLI G=({S}, {0,1}, P, S)

Sea la GRLD G=({S}, {0,1,2,3,4,5,6,7,8,9}, P, S)

Sea la GRLI G=({S,X,Y}, {a,b}, P, S)

Sea la GRLD G=({S,X}, {a,b,2}, P, S)

En realidad δ* es una función, δ: K X Σ---> K, cuya definición recursiva es

ii) δ(q1,b) = δ(δ(q1,λ),b) por definición tomando u = λ

iii) δ(q1,ba) = δ(δ(q1,b),a) por definición, u = b

iv) δ(q1,bab) = δ(δ(q1,ba),b) por definición, u = ba

v) δ(q1,baba) = δ(δ(q1,bab),a) por definición, u = bab

En realidad d* es una función, d: K X Σ---> 2K, cuya definición recursiva es