Índice

Unidad 1: Introducción a la teoría de la computación......................................................................4

Máquinas Abstractas.........................................................................................................................4
Gramáticas formales..........................................................................................................................4
Teoría de los lenguajes y las gramáticas formales.............................................................................4
Características y formalismos de las máquinas abstractas................................................................5
Jerarquía de maquinas.......................................................................................................................6
Isomorfismo entre gramáticas y autómatas..................................................................................6
Jerarquía de Chomsky y relaciones....................................................................................................6
¿Para qué sirven las maquinas abstractas?.......................................................................................7
Compiladores e Interpretes...............................................................................................................7
Conceptos relacionados:................................................................................................................7
Tipos de compiladores...................................................................................................................8
Compiladores e interpretes...........................................................................................................8
Notación T.....................................................................................................................................8
Contexto del Compilador...............................................................................................................9
Estructura y componentes de un compilador..............................................................................10
Análisis léxico...............................................................................................................................10
Análisis sintáctico.........................................................................................................................10
Análisis semántico.......................................................................................................................11
Generación de código intermedio...............................................................................................11
Optimización de código...............................................................................................................11
Generación del programa objeto.................................................................................................11
Gestor de la tabla de símbolos....................................................................................................11
Identificación y gestión de errores..............................................................................................11
Errores de programación.............................................................................................................11
Unidad 2: Gramáticas y Lenguajes Formales...................................................................................12
Símbolos, alfabetos, palabras y reglas de escritura.........................................................................12
Lenguajes y operaciones..................................................................................................................13
Lenguaje......................................................................................................................................13
Operaciones con lenguajes..........................................................................................................13
Gramática Formal............................................................................................................................14
Lenguaje formal generado por una gramática formal.....................................................................14
Jerarquía de Chomsky y relaciones..................................................................................................14
Lenguajes regulares.........................................................................................................................15

1
 Expresiones regulares en forma recursivas.................................................................................15
Lenguajes independientes del contexto (LIC)..................................................................................16
Gramática Limpia.........................................................................................................................16
Gramática bien formada..............................................................................................................16
Análisis Sintáctico............................................................................................................................17
Árbol de derivación......................................................................................................................17
Ambigüedad....................................................................................................................................17
Recursión.........................................................................................................................................17
Eliminación de Recursión en un paso..........................................................................................18
Eliminación de Recursión en más de un paso..............................................................................18
Factorización por izquierda.........................................................................................................18
Forma normal de Chomsky (FNC)....................................................................................................19
Forma normal de Greibach (FNG)....................................................................................................19
Lenguajes Regulares........................................................................................................................20
Expresiones Regulares en formas recursivas...............................................................................20
Unidad 3: Máquinas Secuenciales y Autómatas Finitos Deterministas...........................................22
Maquinas secuenciales....................................................................................................................22
Características de las maquinas secuenciales..............................................................................22
Máquina de Mealy...........................................................................................................................22
Máquina de Moore..........................................................................................................................23
Autómatas Finitos............................................................................................................................23
Autómata Finito Determinista Traductor.....................................................................................23
Autómata Finito Determinista Reconocedor...............................................................................23
Operación....................................................................................................................................24
Configuración o Descripción Instantánea........................................................................................24
Movimiento...................................................................................................................................24
Extensión al tratamiento de palabras..........................................................................................24
Aceptación de palabras y lenguajes.................................................................................................25
Accesibilidad entre estados.............................................................................................................25
Autómatas conexos.....................................................................................................................25
Equivalencia entre estados..............................................................................................................25
Equivalencia de longitud “k” entre estados.................................................................................25
Equivalencia entre autómatas.....................................................................................................26
Conjunto cociente...........................................................................................................................26
Minimización de autómatas............................................................................................................26
Autómatas finitos bidireccionales...................................................................................................26

2
 Aceptación de cadena..................................................................................................................27
Definición de configuración o descripción instantánea...............................................................27
Gramáticas Regulares y autómatas finitos.......................................................................................27
Lenguaje reconocido por el AFDB................................................................................................28
Unidad 4: Autómatas finitos no deterministas...............................................................................29
Autómata Finito No Determinista....................................................................................................29
Transiciones Lambda.......................................................................................................................29
Extensión al tratamiento de palabras..............................................................................................29
Equivalencia con autómatas finitos deterministas..........................................................................30
Teorema 1:..................................................................................................................................30
Teorema 2:..................................................................................................................................30
Gramáticas regulares y autómatas finitos.......................................................................................30
Definición de gramática regular a partir de AFD..........................................................................30
Definición de autómatas a partir de gramáticas regulares..........................................................31
Conversión de gramática lineal por izquierda a lineal por derecha.............................................31
Método o algoritmo de Thompson..................................................................................................32

3
 RESUMEN SINTAXIS Y SEMÁNTICA DE LOS LENGUAJES
Unidad 1: Introducción a la teoría de la computación

Máquinas Abstractas
Las maquinas abstractas son autómatas, o sea dispositivos formales capaces de exhibir conductas
que han sido previamente determinadas, y también conceptualizaciones que se utilizan para el
diseño, implementación y evaluación de algoritmos, el análisis de su complejidad, la evaluación de
los recursos necesarios para determinado computo, la simulación de su comportamiento sobre
nuevos microprocesadores, incluso todavía no construidos, la identificación de eventuales conflictos
en procesos concurrentes o paralelos, etc.

La palabra abstractas proviene del hecho que estas máquinas no necesariamente existen como
objetos materiales.

Se tratan de sistemas reactivos que operan en respuesta a los sucesivos estímulos recibidos del
exterior, que llevan a los mismos a adoptar condiciones características que son denominadas
estados y eventualmente a enviar una respuesta al medio exterior, por ello también se las suele
llamar máquinas de estados y se encuadran como de estímulo-respuesta.

Gramáticas formales
Primero que nada, se define a una gramática común como un “conjunto de normas y reglas para
hablar y escribir correctamente una lengua”

Una gramática formal es un conjunto de reglas para reescribir cadenas de caracteres, junto con un
símbolo inicial desde el cual debe comenzar la reescritura.

Por lo tanto, una gramática formal generalmente se piensa como una generadora de lenguajes. Sin
embargo, a veces también puede ser usada como la base para un "reconocedor": una función que
determina si una cadena cualquiera pertenece a un lenguaje o es gramaticalmente incorrecta.

Teoría de los lenguajes y las gramáticas formales

La teoría de los lenguajes y las gramáticas formales se vio revolucionada por el lingüista
norteamericano Noam Chomsky en 1956, cuando estableció las bases de la lingüística matemática y
proporcionó una herramienta que fue inmediatamente aprovechada en la formalización de los
entonces incipientes lenguajes de computación. A partir de allí, los lenguajes de computación
experimentaron gran rapidez en su evolución, hasta alcanzar un nivel de abstracción que hoy
permite la especificación de los datos, funciones y su control en forma independiente de los
computadores que tendrán a cargo la ejecución de los procesos. Estos son los denominados
lenguajes de alto nivel y constituyen las herramientas cotidianas de desarrollo e implementación de
sistemas.

4
Características y formalismos de las máquinas abstractas
Alan Turing, creador de la máquina de Turing en 1936, fue el precursor de la ciencia de la
computación.

Algunas características comunes y formalismos de las maquinas abstractas son:

- Reconocen que el tiempo avanza y lo hace en forma discreta, es decir, de intervalos en

intervalos
- En cada intervalo la máquina se encuentra en un cierto y único estado. El conjunto de sus
estados posibles es finito y esta agrupado en un conjunto o alfabeto de estados.
- La máquina recibe estimulo del medio exterior (cinta de entrada), lee un símbolo de
entrada y el conjunto de todos los símbolos reconocidos por la máquina es agrupado en un
conjunto llamado alfabeto de entrada.
- En algunos casos graban símbolos que actúan sobre el medio exterior sobre una cinta de
salida.
- Las lecturas y grabaciones en cinta son realizada por cabezales apropiados, que se mueven
en distintos sentidos dependiendo de la máquina.
- La función de transición define para cada símbolo de entrada y para cada estado posible el
próximo estado a ser adoptado

Si la función de transición definiera el próximo estado de la máquina para cada símbolo de

entrada y para cada estado posible, se trataría de una función total o completa. Es decir, para
cada elemento del dominio representado por el producto cartesiano de las entradas y los
estados, está definido el correspondiente elemento del codominio, que es un próximo estado. En
muchos casos esto no resulta práctico ya que resulta innecesario definir la función de transición
para condiciones en las que la máquina no se va a encontrar nunca, entonces se admite que se
trate de una función parcial.
Nada impide que a todas las condiciones no definidas de una función de transición parcial se les
asigne un estado de error, lo que convierte a la función de transición en completa.

Clasificación maquinas abstractas

Traductoras: Son aquellas que establecen una
relación entre las cadenas de entrada y las
cadenas de salida.
Autómatas finitos: Comienzan su operación en
un estado inicial y completa su ciclo arribando
a un estado de aceptación que ha sido
oportunamente identificado.
Autómatas deterministas: Contemplan un
único próximo estado a partir de cada estado
posible y cada símbolo del alfabeto de entrada.
Reconocedoras: Su misión es validar o aceptar
ciertas cadenas de entrada arribando a estados
finales definidos como de aceptación sin producir
ninguna cadena de salida
Maquinas secuenciales: no tienen previsto estado
de aceptación es decir operan en forma
ininterrumpida sin reconocer condiciones
específicas para iniciar y terminar su actividad.
Autómatas no deterministas: Puede tener más de
un próximo estado a partir de cada estado y
símbolo de entrada, también la posibilidad de
transitar sin leer símbolo de entrada

Ser puede notar que los AFD son un caso particular de los AFND

5
Jerarquía de maquinas

La máquina de Turing es capaz de resolver todo problema que tenga solución y, por lo tanto,
representa el límite natural de lo computable.

Isomorfismo entre gramáticas y autómatas

Las gramáticas son metalenguajes destinado a la generación de los lenguajes formales y las
máquinas abstractas son modelos de entidades reconocedoras de esos lenguajes

Jerarquía de Chomsky y relaciones

Relaciones entre máquinas y tipos de gramáticas según jerarquía de Chomsky
Gramática Lenguajes Máquinas
Sin restricciones Sin restricciones o de Tipo 0 Máquina de Turing
Sensible al contexto Sensible al contexto o de Tipo 1 Autómata linealmente acotado
Independiente del contexto Libre de contexto o de Tipo 2 Autómata a pila
Regulares Regular o de Tipo 3 Autómata Finito

6
¿Para qué sirven las maquinas abstractas?
Para la construcción de compiladores (destinados a convertir programas escritos en algún lenguaje
de nivel superior en otros programas en lenguaje máquina), modelado de sistemas, implementación
de algoritmos e identificación de patrones y virus informáticos

Compiladores e Interpretes
Un compilador es una herramienta de desarrollo de software destinada a traducir un programa
escrito en un lenguaje de alto nivel (programa fuente) en otro programa escrito en un lenguaje
maquina (programa objeto)

Al inicio las computadoras se programaban con códigos binarios que representaban instrucciones
individuales reconocidas por la unidad central de proceso, estos eran denominados lenguajes de
primera generación, cuya utilización era difícil, muy susceptible a errores y con alto costo de
mantenimiento.

Posteriormente se comenzaron a utilizar las llamadas abreviaturas nemónicas, dando lugar a los
lenguajes de segunda generación o ensambladores. Destacaba la facilidad de uso y costo de
mantenimiento, pero requería alto conocimiento de arquitectura y máquina.

Finalmente se crearon los lenguajes de tercera generación o de alto nivel, que generaban un mayor
nivel de abstracción, apropiado para la especificación de datos, funciones y su control, todo ello en
forma independiente de la máquina.

Conceptos relacionados:
• Editor de programas
• Compilación: Se refiere al proceso de convertir un programa fuente en un programa
objeto
• Intérprete: Se denomina así a una herramienta o módulo que interpreta y ejecuta
las sentencias de un programa fuente una tras otra, sin generar un programa
objeto
• Preprocesador: Es un módulo que tiene la finalidad de modificar o completar al
programa fuente previo a ser leído por el compilador
• Conversor Fuente-Fuente: Tiene por finalidad la conversión de un programa fuente
desde un lenguaje de alto nivel a otro
• Ensamblador: Se denomina así a un compilador que tiene por lenguaje fuente a uno de
da
2 generación
• Administrador de librerías: Es una herramienta que permite gestionar en una librería
las partes de un sistema que han sido compiladas por separado y que están
destinadas a integrar una aplicación
• Depurador: Es un módulo usado para facilitar las pruebas y eliminar errores de
los programas
• Enlazador: Tiene la misión de construir el programa ejecutable a partir del programa
objeto
• Librería de enlace dinámico: Se trata de librerías que en lugar de ser
incorporadas al programa ejecutable por el enlazador son incorporadas a la
aplicación en tiempo de ejecución cuando son necesarias.

7
Tipos de compiladores
• Compilador cruzado: Es el compilador que genera programas objeto que están
destinados a ser ejecutados en computadoras diferentes de aquel en el que se lo ha
compilado
• Autocompilador: Es un compilador en que su propio programa fuente está escrito
en el mismo lenguaje que el de los programas fuentes que admite
• Metacompilador: Se trata de un compilador capaz de admitir programas fuentes
escritos en diversos lenguajes.
• Decompilador: Tiene como misión convertir programas escritos en lenguaje
máquina a programas fuentes de lenguajes de alto nivel
• Compilador optimizador: Los objetivos principales son la reducción de tamaño
del programa, reducción de la demanda de memoria y la rapidez de operación.
• Compilador intérprete: Se trata de compiladores que generan los programas
objeto en un lenguaje intermedio, que luego son interpretados en el momento
de la ejecución. Ambiente integrado de desarrollo (IDE): Son sistemas
interactivos que incorporan al compilador servicios complementarios.

Compiladores e interpretes

Los interpretes tuvieron mucha vigencia en los inicios de la computación (debido a la reducida
memoria de las computadoras) y la están volviendo a recuperar recientemente (Debido a su
facilidad de portabilidad). La ventaja que ofrecían era la posibilidad de leer y ejecutar los programas
en forma progresiva, sin necesidad de cargar en la memoria al programa fuente completo ni generar
luego en memoria un programa objeto, pero esto disminuía la rapidez de la ejecución. Luego
superado el problema de la memoria tomaron importancia los compiladores ya que al revisar y
tratar al programa fuente en forma integral, generando diagnóstico de errores completo que
agilizaban el desarrollo de programas y evitaban errores de sintaxis o semánticas en la ejecución.

Notación T
Todo compilador involucra 3 lenguajes de programación

1- El del programa fuente “F” que se desea compilar

2- El del programa objeto “O” que se desea generar

3- El lenguaje de implantación “I”, o sea en el que el compilador fue escrito

8
Contexto del Compilador
El contexto del compilador incluye los diversos recursos necesarios para hacer posible la generación
de programas ejecutables a partir de los correspondientes programas fuente. La totalidad de los
componentes incluidos en el contexto de un compilador forman parte de los Ambientes integrados
de desarrollo (IDE). IDE son herramientas que permiten editar, compilar, corregir, depurar , detener
y ejecutar un programa.

9
wEstructura y componentes de un compilador

Etapas de la compilación

- Etapa de Análisis: Se divide el programa fuente en sus elementos componentes y se crea

una representación intermedia
- Etapa de Síntesis: Se reconstruye el programa objeto a partir de esta representación
intermedia.

Análisis léxico
También se denomina análisis lineal o de exploración y el módulo destinado a esta tarea es
denominado analizador lexicográfico o scanner. En esta fase, la cadena de caracteres que
constituye el programa fuente es leída carácter a carácter, para identificar y agrupar sus
componentes léxicos. Éstos, son secuencias de caracteres que tienen un significado colectivo
denominados tokens. Luego, una cadena de caracteres específica que se ajuste al patrón léxico
de un cierto tipo de token es denominada lexema.
Análisis sintáctico
Se reciben las secuencias de componentes léxicos que fueron identificadas en la fase anterior
para comprobar que las sentencias sean sintácticamente correctas. Es decir, se debe verificar que
todas las sentencias pueden haber sido generadas por la gramática del lenguaje fuente. Los
lenguajes de programación son generados por gramáticas libres de contexto, y éstos son
reconocidos por los autómatas con pila, por ende, todo analizador sintáctico tiene una capacidad
computacional equivalente a la de un autómata con pila.

10
Análisis semántico
Se revisa al programa fuente, para reunir información sobre los tipos de las variables que será
utilizada en la fase posterior de generación de código intermedio. Incluyen la detección y
comunicación de numerosos errores que corresponden a comprobación de tipos, coherencia en
los argumentos, potenciales errores en tiempo de ejecución, etc.
Generación de código intermedio
Prepara al programa fuente para ser convertido en un nuevo programa escrito en un lenguaje
elemental que es normalmente denominado lenguaje intermedio. La tendencia fue adoptar un
lenguaje universal denominado Uncol (Universal Compiler Oriented Language).
Optimización de código
Esta fase realiza una mejora en la calidad y eficiencia del código intermedio, pero difícilmente
permita alcanzar un código óptimo. Las mejoras refieren a la calidad de la implementación del
programa desde un punto de vista lógico, mejoras particulares para el mejor aprovechamiento
global de cierta máquina, direccionamientos, etc.
Generación del programa objeto
Se toma como entrada a la representación intermedia y se produce un programa objeto
equivalente que debe ser correcto, eficiente, apropiado a la máquina en la que se va a operar y
apto para dar lugar a un ejecutable compatible con el entorno (SO). Se encarga de la selección de
instrucciones de máquina de destino, asignación de registros de memoria y otros recursos,
administración de la memoria para datos y programa.
Gestor de la tabla de símbolos
Es en realidad un administrador de una base de datos que contiene los identificadores del
programa fuente y sus atributos.
Identificación y gestión de errores
El gestor de errores, activo en las fases de análisis, detecta los errores, los asocia a determinada
línea del programa fuente e intenta su recuperación con la finalidad de proseguir con la terea de
compilación. Para esta última tarea, el registrador dispone de un corrector lexicográfico, un
corrector sintáctico, y un corrector semántico que operan según la fase en la que fue reportada
la irregularidad.
Errores de programación
Verificación: comprobación que el producto está construido correctamente

Validación: comprobación que el producto construido es el correcto.

Puede haber errores lexicográficos, sintácticos, semánticos, por falla del compilador y de
ejecución.

11
 RESUMEN SINTAXIS Y SEMÁNTICA DE LOS LENGUAJES
Unidad 2: Gramáticas y Lenguajes Formales

Símbolos, alfabetos, palabras y reglas de escritura

Se denomina alfabeto a cualquier conjunto finito y no vacío de símbolos. Para denotarlos usamos
letras griegas mayúsculas (mayormente Σ). Una producción o regla de escritura es un par ordenado
de palabras (a, b) definido sobre Σ. Escribimos las producciones a := b diciendo ‘a’ produce ‘b’

Palabra: Una palabra definida sobre un alfabeto Σ es cualquier secuencia finita de símbolos de Σ
escritos uno a continuación del otro. Las palabras formadas con símbolos de algún alfabeto pueden a
su vez concatenarse entre ellas para formar nuevas palabras. Se indica el resultado de esta
operación entre palabras con α.β o simplemente αβ.

Partes de una palabra: Una palabra cualquiera puede dividirse en sus símbolos constituyentes y
hasta en subpalabras. Supongamos una cadena puede escribirse como concatenación de otras tres
w=ayB , se dice entonces que α es un prefijo de ω, que β es un sufijo de ω y que γ es una subpalabra
de ω. De un sufijo o prefijo de una palabra se dice que es propio si NO es la misma palabra en
cuestión o la palabra vacía.

Derivación directa: Operación que aplica una sola producción a una palabra obteniendo una nueva
palabra y se simboliza: δ → φ

Derivación: Operación de aplicar una secuencia finita de producciones a una cadena δ dada para
obtener otra cadena φ y se simboliza δ →* φ . Es decir que existen cadenas α 0α1… Tales que δ = α0 →
α1 →… → αn → αn+1 = φ

Derivación por derecha: Cuando durante el proceso de derivación, cada vez que puede optarse por
una producción a aplicar se efectúa el reemplazo posible más a la derecha en la cadena.

Derivación por izquierda: Cuando durante el proceso de derivación, cada vez que puede optarse por
una producción a aplicar se efectúa el reemplazo posible más a la izquierda en la cadena.

Derivación mixta: Cuando durante el proceso de derivación cada vez que puedo optarse por una
producción a aplicar se efectúa tanto reemplazos por izquierda como por derecha.

Reducción directa: Operación inversa de una derivación directa. Se denota δ  φ , o sea que φ
puede reducirse a δ, si existe una producción que aplicada a δ la transforma en φ

Reducción: Cuando se hacen múltiples reducciones directas para descubrir o revertir una derivación
completa. Se denota δ * φ . Es decir que existen cadenas α0α1… Tales que δ = α 0  α1
… αn  αn+1 = φ

12
Lenguajes y operaciones
Lenguaje
Un lenguaje definido sobre un alfabeto es un conjunto de palabras construidas con los símbolos de
ese alfabeto. En símbolos, si Σ es un alfabeto y L es un lenguaje definido sobre Σ, entonces:

𝐿 ⊆ Σ∗
Algunos conceptos de conjuntos adaptados al contexto de lenguajes son los que siguen:

• Un lenguaje 𝐿1 definido sobre Σ es subconjunto de otro 𝐿2 si toda palabra de 𝐿1 es

también palabra de 𝐿2:

𝐿1 ⊆ 𝐿2 ⇔ ∀𝛼 ∈ 𝛴∗: 𝛼 ∈ 𝐿1 → 𝛼 ∈ 𝐿2

• Un lenguaje definido sobre 𝐿1 definido sobre Σ es un subconjunto propio de otro 𝐿2 si

toda palabra de 𝐿1 es también palabra de 𝐿2 y existe al menos una palabra del segundo
que no es elemento del primero:
𝐿1 ⊂ 𝐿2 ⇔ (∀ 𝛼 ∈ Σ∗: 𝛼 ∈ 𝐿1 → 𝛼 ∈ 𝐿2) ∧ ( ∃𝛽 ∈ Σ∗⁄𝛽 ∈ 𝐿2 ∧ 𝛽 ∉ 𝐿1)

• Un lenguaje L definido sobre Σ es igual a otro lenguaje L si tienen exactamente las ₁ ₂

mismas palabras:

𝐿1 = 𝐿2 ⇔ [ ∀𝛼 ∈ 𝛴∗ ∶ 𝛼 ∈ 𝐿1 ⇔ 𝛼 ∈ 𝐿2]

⇔ [ 𝐿1 ⊆ 𝐿 2 ∧ 𝐿 2 ⊆ 𝐿 1 ]

• El conjunto vacío Ø es un lenguaje llamado lenguaje vacío, tiene cardinalidad cero y es

el único con esta propiedad, independientemente del alfabeto sobre el cual esté
definido.
• {λ} el conjunto vacío cuyo único elemento es la cadena vacía, es también un lenguaje
único e independiente del alfabeto de definición. Debe notarse que su cardinalidad es
uno, por lo cual es bien distinto del lenguaje vacío definido anteriormente.
Operaciones con lenguajes

Unión: 𝐿1 ∪ 𝐿2 = {𝛼⁄𝛼 ∈ L1 ∨ 𝛼 ∈ 𝐿2}

Intersección: 𝐿1 ∩ 𝐿2 = {𝛼⁄𝛼 ∈ 𝐿1 ∧ 𝛼 ∈ 𝐿2}

Resta: 𝐿1 − 𝐿2 = {𝛼⁄𝛼 ∈ 𝐿1 ∧ 𝛼 ∉ 𝐿2}

Concatenación: 𝐿1 . 𝐿2 = {𝜇 = 𝛼𝛽⁄𝛼 ∈ 𝐿1 ∧ 𝛽 ∈ 𝐿2}

Complemento: 𝐿1 = {𝛼⁄𝛼 ∈ Σ∗ ∧ 𝛼 ∉ 𝐿1}

13
Gramática Formal
Una gramática formal G es una cuádrupla (Σ T, ΣN, S, P), en la cual sus cuatro componentes
representan:

ΣT: Es el alfabeto de los símbolos terminales.

ΣN: Es el alfabeto de símbolos no terminales, es un conjunto de variables o símbolos auxiliares.

S ∈ ΣN: Se le llama axioma de la gramática, es el símbolo inicial de la gramática que pertenece a los
símbolos no terminales por lo cual debe ser distinguido.

P: Es un conjunto de producciones de la forma α := β, donde ambas palabras están compuestas de

símbolos terminales y no terminales, pero con la condición que α debe contener al menos un
símbolo no terminal.

Podemos afirmar que ΣT ∩ ΣN = ∅ porque los símbolos no terminales son también llamados
auxiliares ya que sirven para armar las producciones, pero nunca aparecerán en las cadenas del
lenguaje definido en la gramática. Por eso se exige que el alfabeto de símbolos terminales sea
disjunto con el de terminales.

Lenguaje formal generado por una gramática formal

Dada una gramática formal se llama lenguaje formal generado por G al conjunto de todas las
cadenas de símbolos terminales que puedan derivarse desde el axioma S utilizando las reglas de
producción de P, en símbolos

Lenguaje Generado por G: L(G) = {α ∈ ΣT*/ S * α}

Durante la derivación de una cadena del lenguaje descripto por G se generan cadenas intermedias, a
estas cadenas se las denomina forma sentencial o metapalabra, es decir a una cadena de terminales
y no terminales en símbolo

Forma sentencial (metapalabra): αI ∈ (ΣT ∪ ΣN )*

La cadena final de terminales a las que se llega con la derivación desde el axioma recibe el nombre
de sentencia o palabra generada por la gramática.

2 gramáticas son equivalentes si y solo si generan el mismo lenguaje

G1 ≡ G2  L(G1) = L(G2)

Jerarquía de Chomsky y relaciones

Gramática / Lenguajes Máquinas Producciones
Sin restricciones o de Máquina de αAβ := γ α,β,γ ∈ (ΣT ∪ ΣN )*, A ∈ ΣN
Tipo 0 (O estructurado Turing
por frases) (O sin restricciones)
Sensible al contexto o Autómata S:= λ o
de Tipo 1 linealmente αAβ := αγβ α,β ∈ (ΣT ∪ΣN ) *, A ∈ ΣN , γ ∈ (ΣT ∪ΣN )+
acotado
Libre de contexto o de Autómata a pila S:= λ o
Tipo 2 A:= α A ∈ ΣN , α∈ (ΣT ∪ΣN)+
Regular o de Tipo 3 Autómata Finito S:= λ o A:= aB o
A:= Ba A:=a A,B ∈ ΣN , α ∈ ΣT

14
Tipo 0: Son los más generales en la jerarquía de Chomsky, están descriptos por las reglas de
reescrituras menos restrictivas. Pueden contener cualquier cadena de terminales o no terminales
tanto en lado izquierdo como el derecho, con al menos un símbolo no terminal del lado izquierdo. Si
en una gramática existe al menos una producción de α:=β siendo la cadena alfa de mayor longitud
que la del lado derecho Beta (regla compresora) entonces la gramática es de tipo 0, salvo la regla
lambda.

Aquella producción cuya parte derecha está formada por menos símbolos que la parte izquierda es
una regla compresora.

Tipo 1: Permiten el reemplazo contextual de símbolos no terminales. La cadena γ debe por lo menos
tener largo unitario, por lo cual en estas reglas siempre la cadena del lado izquierdo es de largo igual
o menor que la cadena del lado derecho. La única regla compresora es la regla lambda.

Tipo 2: La sintaxis de la mayoría de los lenguajes de programación se describe con este tipo
gramática. El símbolo no terminal A puede ser reemplazado por la cadena α de terminales y no
terminales. La única regla compresora es la regla lambda.

Tipo 3: Son los lenguajes que tienen producciones más restringidas dentro de la jerarquía de
Chomsky.

Hay que

Lenguajes regulares
Son los lenguajes más restringidos en la jerarquía de Chomsky, pero ampliamente utilizados en
informática.

Admiten la siguiente definición recursiva:

A) Cualquier lenguaje finito (con un número natural de cadenas) L 1 definido sobre algún
alfabeto es regular
B) Si L1 y L2 son lenguajes regulares, entonces también lo son su unión L 1 U L2 Y concatenación L1
° L2
C) Si L1 es un lenguaje regular, entonces su estrella de Kleene L 1*, también es un lenguaje
regular.
D) Solo son lenguajes regulares los construidos con las reglas anteriores.

Expresiones regulares en forma recursivas

Es una forma más compacta de especificar lenguajes regulares que las gramáticas tipo 3 de Chomsky
ya citadas. Se definen las expresiones regulares recursivamente como sigue:

Base de recursión: Sea Σ un alfabeto; entonces:

a) Ø es una expresión regular que denota al lenguaje vacío: 𝐿(∅) = ∅

b) λ es una expresión regular que denota al lenguaje cuyo único elemento es la cadena
vacía
𝐿(𝜆) = {𝜆}
c) Cualquier símbolo 𝒂 del alfabeto Σ es una expresión regular que denota al lenguaje
cuya única palabra es la de largo unitario formada por ese símbolo 𝐿(𝑎) = {𝑎}.

Paso recursivo: Si E y F son expresiones regulares entonces

15
 d) 𝐸 + 𝐹 es una expresión regular que denota al lenguaje unión de los lenguajes
denotados por E y por F : 𝐿 (𝐸 + 𝐹 ) = 𝐿( 𝐸 ) ∪ 𝐿 (𝐹 )

e) 𝐸. 𝐹 es una expresión regular que denota al lenguaje concatenación de los

lenguajes denotados por E y por F: 𝐿 (𝐸. 𝐹 ) = 𝐿 (𝐸 ). 𝐿( 𝐹 )
f) 𝐸 ∗ es una expresión regular que denota al lenguaje formado por la estrella de Kleene
del lenguaje denotado por E: 𝐿(𝐸 ∗) = [𝐿(𝐸)]∗
g) (𝐸) es una expresión regular que denota al mismo lenguaje denotado por E: 𝐿 (( 𝐸 )) =
𝐿 ( 𝐸)

h) Solo son expresiones regulares las construidas con los pasos a) y g).

Lenguajes independientes del contexto (LIC)

Gramática Limpia
Una gramática se dice limpia si y solo si no tiene reglas innecesarias, símbolos inaccesibles ni
símbolos superfluos

Regla innecesaria: A:=A

Símbolo inaccesible: Símbolos terminales y no terminales de la gramática que no pueden ser
alcanzados desde el axioma por alguna derivación valida.
Símbolo superfluo: ySímbolo no terminal que no permite generar desde él al menos una cadena
vacía o de solo símbolos terminales.
Gramática bien formada
Una gramática se dice bien formada si y solo si está limpia y no tiene reglas no generativas ni de
redenominación

Sea la regla A:=λ no siendo A el axioma, es una regla compresora (no pueden existir reglas
compresoras en gramáticas independientes del contexto). Para quitar una regla no generativa:

a) Para cada producción X :=α A β que contenga el no terminal A en el lado derecho, agregar la
regla de reescritura X :=α β que se obtiene de reemplazar A por la cadena vacía.
b) Luego eliminar del conjunto de producciones A:=λ, ya que todos los efectos que produciría la
misma, han sido incluidos explícitamente como producciones en el paso anterior.

Si tenemos producciones del tipo A:=B donde A y B son símbolos no terminales, esta producción,
llamada regla de redenominación dice que el no terminal A puede ser reescrito como B en cualquier
contexto donde se encuentre. Para eliminar estas reglas:

a) Por cada regla B:=αexistente en la gramática, agregar una regla 𝐴: = 𝛼 lo cual hace explícita
como producción la posible derivación en dos pasos 𝐴 → 𝐵 → 𝛼
b) Luego puede eliminarse A:=B del conjunto de producciones y la gramática obtenida será
equivalente a la original.

Análisis Sintáctico
Para saber si una palabra α pertenece a un lenguaje debemos encontrar una derivación 𝑆 →∗ 𝑎 que,
aplicando una cantidad finita de producciones de la gramática, logre transformar el axioma de esta
en la cadena de terminales bajo análisis.

16
Árbol de derivación
Un árbol de análisis sintáctico tendrá:

- El axioma S de la gramática como raíz.

- Símbolos no terminales de ΣN como nodos internos.

- Para el nodo interno del no terminal A, si 𝐴: = 𝑎1𝑎2 … 𝑎k es la producción usada, se tendrán k

nodos hijos etiquetados con los símbolos del lado derecho en el orden en el que aparecen.

- Símbolos terminales de ΣT como hojas.

Ambigüedad
Se dice que una cadena es ambigua si puede ser generada por derivaciones que admiten distintos
arboles de derivación.

Si una gramática permite esto también se dice que ella misma es ambigua y que genera su lenguaje
en forma ambigua. Inherentemente Ambiguos se refieren a si existen algunos LIC que pueden ser
generados por gramáticas ambiguas

Existen algunos lenguajes independientes del contexto que solo pueden ser generados por
gramáticas ambiguas. Se los denomina lenguajes inherentemente ambiguos.

Recursión

Una producción de una gramática independiente de contexto G=(ΣT, ΣN, S,P) se dice que es recursiva
si el no terminal de su lado izquierdo se encuentra también en el lado derecho.

A := aAb

Donde A ∈ ΣN y α,β ∈ (ΣT ∪ΣN )*

Recursión en un paso es cuando la gramática tiene solo una regla de reescritura recursiva.

Recursión en más de un paso es una gramática que tiene un no terminal del lado izquierdo de la
producción y que al derivarse lo hace en una cadena que lo contenga. Es decir que al derivar
inicialmente la regla aparezca el mismo no terminal en el lado derecho que en el lado izquierdo.

Si una gramática tiene recursión entonces tiene infinitas cadenas.

Si en A := aAb la cadena a es vacía entonces la regla es recursiva por izquierda. Si b es vacía entonces
la regla es recursiva por derecha.

Eliminación de Recursión en un paso

Sea G=(ΣT, ΣN, S,P) una gramática independiente del contexto y A ∈ ΣN para el cual existen reglas de
reescritura recursivas por la izquierda y algunas producciones no recursivas por izquierda.

A := Aβ1 | Aβ2 |….|Aβn | α1 | α2 |….|αn

Donde

Aβ1 | Aβ2 |….| Son recursivas por izquierda

α1 | α2 |….|αn No son recursivas

17
Con α , β ∈ (ΣT ∪ΣN )+

Siempre se puede obtener una gramática equiválete sin recursión izquierda haciendo:

a) Crear un nuevo símbolo no terminal “X” y agregarlo al alfabeto no terminales Σ N=ΣN∪{X}

b) Eliminar todas las producciones en P para el no terminal A
c) Agregar al conjunto P las producciones:
 A := α1X| α2X|….|αnX| α2 |….|αn
 X := β1X| β2X|….|βnX | β1 | β2 |….|βn
La nueva gramática G´=(ΣT, Σ´N, S,P´)

Eliminación de Recursión en más de un paso

Sea G=(ΣT, ΣN, S,P) una GIC y A ∈ ΣN para el cual existen reglas de reescritura recursivas por la
izquierda en más de un paso:

Siempre se puede obtener una gramática equivalente sin recursión izquierda haciendo lo siguiente

a) Asignar un orden cualquiera a los símbolos no terminales A 1 | A2 |….|An

b) Para cada i= 1,2,3,…n hacer:
a. Para cada j=1,2,3…k hacer:
Si i<>j reemplazar cada Ai :=Ajβ en P por Ai := α1β|α2β|….|αnβ| donde αn son
los lados derechos de todas las producciones de Aj
b. Eliminar recursión por izquierda en un paso.

Factorización por izquierda

Es el caso de dos o más producciones que inicien con una parte común: 𝐴 ∶= 𝛼𝛽 𝑦 𝐴 ∶= 𝛼𝛾
En este caso el proceso de análisis sintáctico no tiene en claro cuál de las dos producciones
utilizar durante una derivación, aun sabiendo que tiene que emparejas una parte de la cadena
bajo análisis con α. Sin embargo, si se crea un nuevo no terminal X y se reemplazan las
anteriores producciones por: 𝐴 ≔ 𝛼𝑋 𝑦 𝑋 ≔ 𝛽 | 𝛾 procedimiento no tiene ahora dudas de
lo que debe utilizar, la primera producción primero, y recién al terminar de emparejar α con la
cadena bajo análisis, deberá decidir con cuál de las producciones de X continúa el análisis de la
cadena bajo estudio.

Forma normal de Chomsky (FNC)

Una gramática se dice que está en FNC si y solo si, todas sus producciones tienen en el lado
derecho dos símbolos no terminales, o un solo símbolo terminal o la cadena vacía:
𝐴: = 𝐵𝐶 ó 𝐴: = 𝑎 ó 𝑆: = 𝜆
Para llevar una gramática a FNC:
a) Transformar G en una gramática bien formada, esto es, limpia y sin reglas no generativas
ni de redenominación.

b) Para cada símbolo terminal 𝑎 ∈ 𝛴𝑇, crear un nuevo símbolo no terminal 𝑋a y una
nueva producción 𝑋a ∶= 𝑎

18
 c) Para cada producción de la gramática que contenga en su lado derecho tanto símbolos
no terminales como símbolos terminales, reemplazarla por una nueva que tenga en su
lugar del terminal 𝒂 su correspondiente nuevo terminal 𝑋a, es decir 𝐴: = 𝛼𝑎𝛽 → 𝐴: =
𝛼𝑋𝑎𝛽 . Al terminar con estos pasos se tendrá una gramática equivalente con
producciones que solo contienen en su lado derecho un solo símbolo terminal (es decir,
que es está en FNC) o una cadena de dos o más símbolos no terminales. Si tiene dos no
terminales, entonces ya está en FNC, caso contrario:
d) Para cada producción con más de dos símbolos no terminales en su lado derecho,
digamos
𝐴: = 𝐵𝜂 donde 𝜂 contiene dos o más no terminales, crear un nuevo símbolo no
terminal X y reemplazar la producción por el par 𝐴: = 𝐵𝑋 y 𝑋 ∶= 𝜂.

Forma normal de Greibach (FNG)

Una gramática independiente del contexto está en FNG si y solo si todas sus producciones inician
su lado derecho con un símbolo terminal al que le sigue, opcionalmente, una cadena de símbolos
no terminales de cualquier largo: 𝐴: = 𝑎𝜂 ó 𝑆: = 𝜆
Para llevar una gramática a FNG:
a) Transformar G en una gramática bien formada
b) Quitar la recursividad izquierda de la gramática
c) Asignar un orden cualquiera a los símbolos no terminales de la gramática
d) Separar las producciones del conjunto P en tres grupos:
a. Grupo 1: todas las producciones que comiencen con un terminal y si existiere en
G, la regla lambda 𝑆: = 𝜆

b. Grupo 2: producciones 𝐴i ∶= 𝐴𝑗 𝛼 y con el símbolo 𝐴i anterior a 𝐴j

en el ordenamiento dado (i < j)

c. Grupo 3: producciones 𝐴i ∶= 𝐴j𝛼 y con el símbolo 𝐴i posterior a

𝐴j en el ordenamiento dado (i > j)

El caso i = j no puede darse porque se ha eliminado la recursión por izquierda

anteriormente.
e) Para cada producción del tercer grupo 𝐴i ∶= 𝐴𝑗 𝛼 iniciando por aquellas con el subíndice
i más pequeño, reemplazarlas por 𝐴i ∶= 𝛿1𝛼|𝛿2𝛼| … | 𝛿h𝛼 donde los 𝛿 son los lados
derechos de todas las producciones de 𝐴j. Al terminar este proceso, todas las
producciones pertenecerán al grupo 1 o 2.
f) Repetir el proceso anterior para las producciones del segundo grupo. Al terminar, todas
las producciones serán del grupo 1, por lo cual todas iniciarán con un símbolo terminal.
g) Para cada símbolo terminal 𝑎 ∈ ΣT que esté en el lado derecho de las producciones
resultantes, pero no al inicio de estas, crear un nuevo símbolo no terminal 𝑋a y una nueva
producción 𝑋a ∶= 𝑎.

19
h) Para cada producción de la gramática que contenga en su lado derecho, luego del primer
símbolo terminal, tanto símbolos no terminales como símbolos terminales, reemplazarla
por una nueva que tenga en lugar del terminal no inicial 𝒂 su correspondiente no
terminal 𝑋a.

20
 RESUMEN SINTAXIS Y SEMÁNTICA DE LOS LENGUAJES
Unidad 3: Máquinas Secuenciales y Autómatas Finitos Deterministas

Maquinas secuenciales
Son maquinas abstractas porque no necesariamente existen como objetos materiales, son
conceptualizaciones que se utilizan para el diseño, implementación y evaluación de algún problema
de software o hardware.
Al mismo tiempo son maquinas de estados debido a que pueden encuadrarse como de estímulo-
respuesta. El comportamiento depende tanto del estímulo recibido como del estado en el que se
encuentra en ese momento.

En 1938 Claude Shannon comenzó a aplicar la lógica matemática en el análisis de circuitos

electrónicos combinatorios y secuenciales. Una maquina combinatoria es aquella cuyo resultado
depende únicamente de las entradas al sistema. En cambio, en una maquina secuencial la salida
depende tanto de sus entradas como de los estados anteriores (Es decir que tiene memoria)

Características de las maquinas secuenciales

1- Su salida depende de sus entradas Y de sus estados anteriores

2- Reconocen que el tiempo avanza de forma discreta (En intervalos)

3- En cada intervalo de tiempo una maquina se encuentra en un cierto y único estado.

4- El conjunto de estados posibles es finito

5- Recibe información o estimulo del medio exterior (Cinta de entrada)

6- Puede actuar grabando símbolos en una cinta de salida

7- Operan ininterrumpidamente. No tienen estado de inicio ni aceptación

8- Su comportamiento esta definido por su función de transición

9- Generalmente establecen una relación entre las cadenas de entrada y las cadenas de salida

Máquina de Mealy
Es una maquina secuencial y traductora. Su definición formal es

ME = (ΣE, ΣS, Q, f, g)

ΣE : Alfabeto de símbolos de entrada

Σs : Alfabeto de símbolos de salida

Q: Conjunto finito y no vacio de estados posibles

f: Función de transición, f: Q x Σ E →Q

g: Función de salida, g: Q x ΣE → ΣS

21
Máquina de Moore
Se diferencia de la máquina de Mealy únicamente en su función de salida, ya que ésta solo depende
del estado actual y no de la entrada en ese instante, es decir:

𝑀𝑂 = (𝛴E , 𝛴𝑆 , 𝑄, 𝑓 , 𝑔)

Donde la función de transición f no cambia y en g hay una relación directa entre el estado en
cada intervalo de tiempo y el símbolo de salida: 𝑓 ∶ 𝑄𝑥 𝛴𝐸 → 𝑄 𝑔: 𝑄 → 𝛴𝑆

Debe recordarse que la máquina de Moore incorpora un retardo entre la entrada y la salida,
si en un instante de tiempo t el autómata se encuentra en un estado 𝑞t ∈ 𝑄 es:

𝑠t = 𝑔(𝑞t)

Y como este último estado fue a su vez alcanzado en una transición anterior:

𝑞t = 𝑓(𝑞t–1, 𝑒t–1)

Se puede apreciar la relación directa entre la salida actual y la anterior, que es:

𝑠t = 𝑔(𝑓(𝑞t–1, 𝑒t–1))

Puede demostrarse que para toda máquina de Moore hay una máquina de Mealy capaz de tener el
mismo desempeño y recíprocamente. Lo primero es obvio, ya que solo basta plantear una máquina
de Mealy que en cada estado prevea la misma salida para todos los símbolos de entrada. Lo
opuesto, obtener una máquina de Moore a partir de una de Mealy, no es tan obvio y requiere mayor
esfuerzo.

Autómatas Finitos
Son maquinas secuenciales, con un estado final y uno o más estados finales. Tienen un conjunto
finito de estados y leen/escriben en una cinta. Son reconocedores de lenguajes y traductores.

Autómata Finito Determinista Traductor

AFDt = (ΣE , ΣS , Q, q0, F, f, g)

ΣE : Alfabeto de símbolos de entrada

Σs : Alfabeto de símbolos de salida
Q: Conjunto finito y no vacío de estados posibles
q0: Estado inicial de operación, pertenece a Q
F: Conjunto no vacío de estados finales, pertenece a Q
f: Función de transición, f: Q x Σ E →Q
g: Función de salida, g: Q x ΣE → ΣS
Autómata Finito Determinista Reconocedor
AFD = AFDr = (ΣE , Q, q0, F, f)

ΣE : Alfabeto de símbolos de entrada

22
Q: Conjunto finito y no vacío de estados posibles
q0: Estado inicial de operación, pertenece a Q
F: Conjunto no vacío de estados finales, pertenece a Q
f: Función de transición, f: Q x Σ E →Q
f tiene que estar completa o definirse un estado de error
Al autómata finito determinista reconocedor lo llamamos solamente autómata finito determinista
Operación
Dada una cadena de entrada a, en cada instante de tiempo lee un carácter de entrada. Cuando a fue
leído completamente, la entrada será λ. La maquina solo acepta una cadera cunado se llega a un
estado final y cuando se lee toda la cadena.

Configuración o Descripción Instantánea

Es un par

Kt = (q, B) Donde q pertenece a Q y B pertenece a x Σ E*

B es la cadena pendiente a ser leida, entonces:

- K0 = (q0, a), es la configuración inicial

- Kn = (qf, λ), qf pertenece a F, n = |a| es la configuración inicial

Movimiento:

(p, aB) |---- (q, B) si esta definida q = f(p,a)

Movimiento de aceptación:

(q0, a) |----* (qn, λ)

Movimiento
El tránsito de una configuración a otra es denominado movimiento, es decir que si existe la
transición 𝑞 = 𝑓(𝑝, 𝑎), el movimiento del estado p al q, leyendo el símbolo de entrada a, puede
representarse:

(𝑝, 𝑎𝛽) ⊢ (𝑞, 𝛽)

El movimiento desde la configuración inicial a la final es representado:

(𝑞 0𝛼) ⊢∗ (𝑞 ,𝑛𝜆)
donde ⊢∗ equivale a una cantidad finita de movimiento que es igual al largo |α| de la cadena de
entrada.

Extensión al tratamiento de palabras

La función de transición f puede ser extendida para describir lo que ocurre a partir de cada estado si
en lugar de recibir símbolos aislados se recibe una secuencia concatenada de los símbolos de
entrada.

𝑓e ∶ 𝑄𝑥 𝛴E∗ → 𝑄
E

23
Considerando que la cadena 𝛼 = 𝑎𝑏𝑐𝑑𝑒 puede ser expresada como 𝛼 = 𝑎𝛽 con 𝛽 = 𝑏𝑐𝑑𝑒:

𝑓e(𝑞, 𝛼) = 𝑓e(𝑞, 𝑎𝛽) = 𝑓e(𝑓 (𝑞, 𝑎), 𝛽)

Se obtiene un proceso recursivo que finaliza al completarse la lectura de α, situación donde ocurre
𝑓e(𝑞, 𝜆) = 𝑞.

Este concepto también puede aplicarse para extender la función de salida de las máquinas
secuenciales de Mealy o Moore y del autómata finito traductor.

Aceptación de palabras y lenguajes

Si en el movimiento desde la configuración inicial hasta la final, representada por

(𝑞0, 𝛼) ⊢∗ (𝑞n , 𝜆) se verifica que 𝑞n ∈ 𝐴 se dice que la cadena α ha sido reconocida o aceptada. El
AFD 0reconocedor𝑛 llega a la conclusión de aceptar o rechazar la cadena de entrada luego de efectuar
un número finito de transiciones o movimientos a partir de su configuración inicial. Es decir que la
aceptación de una cadena por parte de un AFD requiere la completa lectura de la cadena de entrada
y el arribo a un estado de aceptación.

Se dice que un lenguaje L es aceptado por un autómata finito si todas las palaras que lo componen
conducen a estados de aceptación.

Accesibilidad entre estados

En un AFD, se dice que un estado p es accesible desde otro estado q y se representa pAq si existe
una palabra de símbolos de entrada que haga transitar el autómata desde el estado q hasta el p.

𝑝𝐴𝑞 ↔ ∃𝛼 ∈ ΣE∗ ⁄𝑓e (𝑞, 𝛼) = 𝑝, 𝑐𝑜𝑛 𝑝, 𝑞 ∈ 𝑄

E
Autómatas conexos
Si todos los estados de un autómata son accesibles desde su estado inicial se dice que el mismo es
conexo.

Un AFD es conexo  ∀ pi ∈ Q : pi A q0

Equivalencia entre estados

Dos estados p y q de un AFD se dicen que son equivalentes pEq si desde cualquiera de ellos se
aceptan y rechazan exactamente las mismas cadenas de símbolos de entrada:

𝑝𝐸𝑞 ⇔ [∀𝛼 ∈ ΣE∗ : 𝑓e(𝒑, 𝛼) ∈ 𝐴 ↔ 𝑓e(𝒒, 𝛼) ∈ 𝐴]

E
Esta relación de equivalencia satisface las propiedades reflexiva, simétrica y transitiva en Q.

Es imposible distinguir entre dos estados equivalentes, lo que lleva a denominarlos indistinguibles.

Equivalencia de longitud “k” entre estados

Dos estados p y q de un AFD son equivalentes de longitud k, lo que se representa 𝑝𝐸𝑘𝑞 si son
equivalentes para todas las cadenas de largo menor o igual a k.

Equivalencia entre autómatas

Dos AFD denominados 𝐴1 y 𝐴2 se dice que son equivalentes y se representa 𝐴1𝐸𝐴2 si ambos aceptas
las mismas palabras o sentencias. Se deduce que dos AFD son equivalentes si lo son sus estados
iniciales, que son equivalentes si y solo si aceptan el mismo lenguaje:

24
 𝐴1𝐸𝐴2 ⇔ 𝐿(𝐴1) = 𝐿 (𝐴2).

Conjunto cociente
Conjunto que tiene por elementos a todas las clases de equivalencia o subconjuntos de estados
equivalentes entre sí que puedan distinguirse en el conjunto de estados Q. Por ser la base de este
agrupamiento la relación de equivalencia entre estados E, el conjunto cociente se denota Q/E. La
definición de equivalencia entre dos estados no proporciona un procedimiento para saber si dos
estados p y q son equivalentes, ya que hay infinitas sentencias 𝛼 ∈ ΣE*. Para superar esta dificultad,
se recurre a un procedimiento práctico incremental que comienza con un particionamiento Q que es
sucesivamente revisado con cadenas progresivamente más largas. Así, el conjunto de cociente inicial
tiene dos elementos, un subconjunto que contiene a los estados de aceptación P 20 y otro
subconjunto con los estados restantes P10. Los siguientes conjuntos cocientes Q/Ek+1 se definen
dividiendo las clases Pik de Q/Ek las veces que sea necesario hasta que, para todo símbolo 𝛼 ∈ ΣE y
para todo par de estados p, q de las clases Pik queden definidos movimientos que conduzcan a
elementos de las mismas clases Q/EK+1. Esto se repite hasta obtener Q/Ek+1 = Q/Ek.

Minimización de autómatas
Autómata que cumple correctamente su función con la menor cantidad posible de estados. Para
minimizar un autómata se recurre al concepto de conjunto cociente visto con anterioridad, es decir,
a la partición del conjunto de estados Q producida por la relación de equivalencia E, que tiene por
elementos a las clases de equivalencia, donde se agrupan todos los estados equivalentes o
indistinguibles entre sí.

El autómata mínimo equivalente a uno dado tendrá como estados a cada una de las partes o clases
de estados equivalentes del autómata original (es decir, su conjunto de estados será Q/E), aquella
clase que contenga el estado inicial original será su estado inicial, las que contengan algún estado de
aceptación del autómata original serán sus estados de aceptación; su función de transición se
construirá en base a la del autómata original.

Autómatas finitos bidireccionales

Otorgando al AFD la capacidad de decidir el sentido del movimiento del cabezal en cada intervalo de
tiempo queda conceptualmente definido el AFDB. En la definición del autómata se debe incorporar
una función de movimiento. Se incorporan, además, dos símbolos especiales que identifican el inicio
y el final del intervalo de cinta de entrada a ser analizado.

Esto da como resultado las siguientes características:

- Cada símbolo de entrada puede ser leído varias veces

- No hay ninguna condición que identifique el fin de la lectura de la cadena
- No es posible anticipar la cantidad de intervalos de tiempo requeridos para evaluar la
cadena
- El concepto de cadena que resta de ser leída desaparece

Una consecuencia puede ser que ocurra que ciertas cadenas de entrada lleven al AFDB a un ciclo
cerrado que no conduzca a nada, es decir, un ciclo infinito.

𝐴𝐹𝐵𝐷 = (ΣE, Γ, 𝑄, 𝑞0, 𝐴, 𝑓)

ΣE : Alfabeto de símbolos de entrada
Γ: Alfabeto de cinta Γ = ΣE⋃{⊢, ⊣}
Q: Conjunto finito y no vacío de estados posibles

25
q0: Estado inicial de operación, pertenece a Q
A: Conjunto de estados de aceptación A ⊆ Q
f: Función de transición, f: 𝑄𝑥Γ → 𝑄𝑥{𝐼, 𝑁, 𝐷}

Aceptación de cadena
Una cadena es aceptada por un AFDB cuando

- Alcanzo un estado de aceptación

- Ha sido leída por lo menos una vez
- Se alcanzo el estado de aceptación y el cabezal de lectura esta a la derecha de la cadena de
entrada

Aceptar una cadena necesita una cantidad de intervalos de tiempo mayor o igual al largo de la
cadena de entrada. Si fuera igual seria parecido al AFD

Definición de configuración o descripción instantánea

Tiene 3 componentes:

- Estado actual
- Contenido de la cinta de entrada
- Posición de cabezal (Se adopta la convención de que le símbolo de inicio de la cinta está en
la posición 0 y el contador se incrementa hacia la derecha, lo que implica que el primer
carácter de la cadena de entrada está en la posición 1)

- 𝐾t = (𝑞, ⊢ 𝛼 ⊣, 𝑘 ) o kt = δq β

Entonces, la configuración inicial será: 𝐾0 = (𝑘0, ⊢ 𝛼 ⊣ ,0) o 𝐾0= q0 α

y la configuración final: 𝐾A = (𝑞A , ⊢ 𝛼 ⊣, 𝑛) 𝑑𝑜𝑛𝑑𝑒: 𝑞𝐴 ∈ 𝐴 𝑦 𝑛 = |𝛼| + 1. O kA = α qA

El lenguaje reconocido por un autómata bidireccional M puede definirse como:

𝐿(𝑀) = {𝛼⁄𝛼 ∈ ΣE* 𝑦 𝑞0𝛼 ⊢* 𝛼𝑞A, 𝑞A ∈ 𝐴}

Gramáticas Regulares y autómatas finitos

Definición de Autómata a partir de gramáticas regulares

Dada la gramática regular G = (ΣT , ΣN , S, P) el autómata finito que acepta el mismo lenguaje que
genera la gramática será

AF = (ΣT , ΣNU{A}, S, {A}, f)

Donde A es un nuevo símbolo que no estaba en Σ N y f(X,a) = Y si X:=aY esta en P y f(X,a)=A si X:=a
esta en P, con X,Y,S∈ΣN, a∈ΣT

La regla de producción S:= λ incorpora la transición f(S, λ)=A

Definición de gramáticas regulares a partir de Autómata

26
Dado un AFD= (Σ, Q, q0, A, f), la gramática que genera el mismo lenguaje que acepta el autómata
será G=(Σ, Q, q0, P), donde el conjunto de reglas de reescritura queda definido como

P = {X := aY / f(X,a) = Y} U {X := a / f(X,a) = Y, Y∈A}

Y se agrega q0 := λ si q0∈A ; X, Y, q0 ∈ Q , a∈Σ, A ⊆ Q

Lenguaje reconocido por el AFDB

El lenguaje L que es aceptado por un autómata finito bidireccional M puede definirse en símbolos
como:

𝐿(𝑀) = {𝛼⁄𝛼 ∈ Σ∗ E 𝑦 𝑞0𝛼 ⊢∗ 𝛼𝑞A, 𝑞A ∈ 𝐴}

27
 RESUMEN SINTAXIS Y SEMÁNTICA DE LOS LENGUAJES
Unidad 4: Autómatas finitos no deterministas

Autómata Finito No Determinista

Quedan definidos como:

AFND = (ΣE, Q, q0, A, f)

La diferencia es que la definición de las transiciones deja de ser una función de estados a estados y
pasa a ser una relación de transición

f:Q X ΣE  P(Q)

Donde P(Q) es el conjunto de todos los subconjuntos que se pueden formar con los elementos del
conjunto Q.

Esta indeterminación, no significa incertidumbre o aleatoriedad en el desempeño final del autómata.

Más bien significa incertidumbre en cuanto al esfuerzo requerido al evaluar una cierta cadena. Esto
es así porque la operación del autómata implica una búsqueda exhaustiva en un árbol de
posibilidades que será más frondoso según sea mayor la cantidad de próximos estados posibles en
cada transición, llamada factor de ramificación FR, donde FR = |f(q, e)| donde

q ∈ Q, e ∈ ΣE. El tiempo para resolver este tipo de problemas es exponencial.

La flexibilidad que ofrece el no determinismo es de gran ayuda en el diseño de autómatas destinados

a reconocer lenguajes complejos. Se obtienen diseños más simples a costa de algoritmos menos
eficientes.

Transiciones Lambda
La definición de AFND puede ampliarse para incluir transiciones de un estado a otro que no
dependen de ninguna entrada, las que son denominadas transiciones lambda

Función de transición: f:Q X (ΣE U {λ })→ P(Q)

Conjunto T denominado relación de transición λ

T= {(p,q) / q ∈ f(p, λ) U {(q,q)/q ∈Q}

Es decir que utilizando notación de relaciones

(p,q) ∈ T ,si q ∈ f(p, λ) y se representa pTq

(q,q) ∈ T, ya que ∀ q ∈ Q: q ∈ f(p, λ) y se representa qTq

Cierre transitivo de la relación T*=T U {(p,q)/pTr ∧ rTq}

Extensión al tratamiento de palabras

Si en vez de recibir símbolos aislados recibimos una secuencia concatenada la función de transición
puede ser extendida a:

𝑓e = 𝑄𝑥 (ΣE ∪ {𝜆})∗ → 𝑃(𝑄)

28
Equivalencia con autómatas finitos deterministas
Teorema 1:
Todo AFND- 𝜆 puede ser redefinido como un AFND equivalente y para ellos se deben eliminar sus
transiciones 𝜆. Se procede a redefinir el conjunto de estados de aceptación A’ y la función de
transición a f’, mediante los siguientes pasos:
a. Para todo par de estados distintos relacionados por transiciones 𝜆
(𝑝𝑇∗𝑞, 𝑝 ≠ 𝑞) y para cada transición 𝑟 = 𝑓(𝑞, 𝑒) donde 𝑒 ≠ 𝜆, es decir,
𝑟 = 𝑓(𝑓(𝑝, 𝜆∗), 𝑒) se define una nueva transición 𝑟 = 𝑓(𝑝, 𝑒). Se incorporan las nuevas
transiciones a f.
b. Para todo par de estados distintos relacionados por transiciones 𝜆 (𝑞𝑇 ∗𝑟, 𝑞 ≠ 𝑟) y
para cada 𝑞 = 𝑓(𝑝, 𝑒) donde 𝑒 ≠ 𝜆, es decir 𝑟 = 𝑓(𝑓(𝑝, 𝑒), 𝜆∗), se define la nueva
transición
𝑟 = 𝑓(𝑝, 𝑒). Se incorporan las nuevas transiciones en f.
c. En caso de existir una transición lambda desde el estado inicial a un estado de aceptación
(𝑞0𝑇∗𝑟, 𝑟 ∈ 𝐴) hacer 𝑞0 ∈ 𝐴.
d. Eliminar todas las transiciones 𝜆, lo que implica eliminar la columna 𝜆 de la tabla de f.
Teorema 2:
Por cada AFND siempre existe un AFD que acepta el mismo lenguaje y estos dos autómatas se
dice que son equivalentes.

a. Reconocer el estado inicial 𝐶0 = {𝑞0}

b. Definir los nuevos estados 𝐶i = 𝑓 u (𝐶k , 𝑒) para todo 𝑒 ∈ ΣE 𝑦 𝑘 < 𝑖.
c. Para todos los casos en que 𝐶i = { … , 𝑞n, … } 𝑦 𝑞n ∈ 𝐴 se reconoce que 𝐶i ∈ 𝐴u.

Teorema: Dado un AFNDM = (ΣE, Q, q0, A, f ), existe un AFD M’ tal que: L(M)=L(M’).

Gramáticas regulares y autómatas finitos

Definición de gramática regular a partir de AFD
El autómata debe ser un AFD, y la gramática debe ser bien formada y regular por derecha.

Dado 𝐴𝐹𝐷 = (ΣE, 𝑄, 𝑞0, 𝐴, 𝑓)

𝐺𝑅 = (Σ, 𝑄, 𝑆, 𝑃)

𝐹 = 𝑃 = { 𝑋 ≔ 𝑎𝑌⁄𝑓(𝑋, 𝑎) = 𝑌} ∪ { 𝑋 ≔ 𝑎⁄𝑓(𝑋, 𝑎) = 𝑌, 𝑌 ∈ 𝐴}

Y se agrega 𝑞0 ∶= 𝜆 𝑠𝑖 𝑞0 ∈ 𝐴 ; 𝑋, 𝑌, 𝑞0 ∈ 𝑄, 𝑎 ∈ Σ, 𝐴 ⊆ 𝑄 .

Definición de autómatas a partir de gramáticas regulares

Dado:

29
 𝐺 = (ΣT, ΣN, 𝑆, 𝑃)

𝐴𝐹 = (ΣT, ΣN ∪ {𝐴}, 𝑆, {𝐴}, 𝑓)

Donde A es un nuevo símbolo que no estaba en Σ N y 𝑓(𝑋, 𝑎) = 𝑌 𝑠𝑖 𝑋 ≔ 𝑎𝑌 está en P y

𝑓 (𝑋, 𝑎) = 𝐴 𝑠𝑖 𝑋 ≔ 𝑎 está en P, con𝑋, 𝑌, 𝑆 ∈ ΣN 𝑎 ∈ ΣT.

La regla de producción 𝑆 ≔ 𝜆 incorpora la transición 𝑓(𝑆, 𝜆) = 𝐴.

Conversión de gramática lineal por izquierda a lineal por derecha

Paso 1: Convertir la gramática dada a otra equivalente que no sea recursiva en el axioma. Para ello,
se debe incorporar un nuevo símbolo no terminal B y modificar las reglas de producción según se
describe:

- Por cada regla 𝑆 ≔ 𝛼, se crea una nueva regla 𝐵 ≔ 𝛼.

- Cada regla de la forma 𝐴 ≔ 𝑆𝑎 debe ser reemplazada por 𝐴 ≔ 𝐵𝑎 donde 𝑆, 𝐴, 𝐵 ∈ ΣN, 𝑎 ∈ ΣT
𝑦 𝛼 es una cadena válida.

Paso 2: Se debe construir un grafo con las siguientes instrucciones:

- Los nodos del grafo se identifican con los símbolos no terminales de la gramática y se incluye
un nodo adicional identificado con 𝜆.
- Por cada regla de la forma 𝐴 ≔ 𝐵𝑎 se dibuja un arco desde el nodo A al nodo B que es
identificado con la etiqueta 𝑎.
- Por cada regla de la forma 𝐴 ≔ 𝑎, se incluye un arco desde el nodo A al nodo 𝜆 identificado
con 𝑎.
- Para la regla 𝑆 ≔ 𝜆 se incorpora un arco sin etiqueta desde el nodo S al nodo 𝜆.

Paso 3: Se construye un nuevo grafo a partir del grafo anterior según se indica:

- Se intercambian los identificadores de los nodos S y 𝜆

- Se cambia el sentido de todos los arcos

Paso 4: A partir del nuevo grafo, se obtiene la gramática lineal por derecha siguiendo los siguientes
pasos:

- Los alfabetos de símbolos terminales y no terminales son los mismos de la gramática original
lineal por izquierda
- Por cada arco dirigido etiquetado con 𝑎 desde el nodo B al nodo A, se incorpora a la nueva
gramática la regla de producción 𝐵 ≔ 𝑎𝐴
- Por cada arco dirigido etiquetado con 𝑎 desde el nodo B al nodo 𝜆, se incorpora la regla de
producción 𝐵 ≔ 𝑎
- En caso de un arco sin etiqueta desde el nodo S al nodo 𝜆, se incorpora a la gramática la
regla 𝑆 ≔ 𝜆

Método o algoritmo de Thompson

El método que se presenta traduce cada parte de la definición de una expresión regular en un
autómata que acepta el mismo lenguaje denotado por ella, de tal forma que el autómata finito
quede definido al analizar la expresión parte por parte.

30
 Para ∅ :

 Para 𝜆:

 Para 𝑎 ∈ ΣE:

 El lenguaje unión L€ y L(F) denotado por la expresión regular E+F, será reconocido por
el autómata construido de la siguiente forma:
- Quitar la característica de inicial de los estados iniciales de 𝐴𝐹E 𝑦 𝐴𝐹F
- Crear un nuevo estado inicial 𝑞0 y relacionarlo mediante transiciones 𝜆 con
antiguos estados iniciales 𝐴𝐹E y 𝐴𝐹F
- Quitar característica de aceptación.
- Crear nuevo estado de aceptación 𝑞A y agregar desde cada antiguo estado
de aceptación de 𝐴𝐹E 𝑦 𝐴𝐹F una transición 𝜆 hacia él.

 De forma análoga (pero en vez de paralelo, en serie) podemos reconocer E.F:

 Finalmente, para la estrella de Kleene de una expresión regular 𝐸 ∗, que representa al

lenguaje [𝐿(𝐸)]∗, se construye el siguiente autómata finito.

31