lenguajes regulares

Transcripción

lenguajes regulares
TEORÍA DE LOS LENGUAJES DE PROGRAMACIÓN
TEMA 3:
LENGUAJES REGULARES
Tema 3 – Lenguajes regulares: Objetivos
2
Objetivos:


Comprender los fundamentos de los lenguajes regulares

Conocer los mecanismos regulares

Entender la transformación entre mecanismos regulares

Aplicación de los mecanismos regulares

Conocer las expresiones regulares como denotadoras de lenguajes regulares

Conocer a los autómatas regulares como reconocedores de lenguajes regulares

Simulación e implementación de los autómatas regulares
.
Teoría de los lenguajes de programación -Tema3
Tema 3 – Lenguajes regulares.
3
3.1 Lenguaje regular
3.2 Expresiones regulares
3.3 Aplicación de las expresiones regulares
3.4 Autómatas finitos
3.5 Definición formal
3.6 Autómatas finitos equivalentes
3.7 Autómatas completos
3.8 Autómatas conexos
3.9 Transformación entre mecanismos regulares
3.10 Simulación de un autómata finito
Teoría de los lenguajes de programación -Tema3
1.1 Lenguajes regulares - Mecanismos regulares
4







Lenguaje regular - es un lenguaje formal que puede ser definido por un mecanismo
regular
Son mecanismos regulares: las expresiones regulares, las gramáticas regulares ( de
tipo 3) y los autómata finitos (o regulares).
El léxico de un lenguaje de programación: es un lenguaje regular y como tal se
puede definir por medio de un mecanismo regular.
Los lenguajes regulares - son importantes ya sea desde un punto de vista teórico
como práctico.
Teórico - los lenguajes regulares forman el menor conjunto de lenguajes formales
que es cerrado con respecto de los operadores (´*´, ´.´ , ´|´)
Práctico – los lenguajes regulares pueden ser especificados por mecanismos
regulares que permiten simplificar y facilitar la construcción de analizadores
léxicos (AL);
Analizador léxico- programa que analiza un texto y extrae los lexemas de que
consta
Teoría de los lenguajes de programación -Tema3
1.2 Lenguajes regulares – Expresiones regulares
5



Expresión regular

Una expresión regular es una notación (descripción), que permite de manera
precisa y finita especificar los lenguajes regulares.

También puede definirse como un metalenguaje para especificar lenguajes
regulares.
Descripción de las expresiones regulares básicas:

El símbolo φ es una expresión regular que describe el lenguaje { }

El símbolo ε es una expresión regular que describe el lenguaje { ε }

Para ∀ a ∈ Σ, a es una expresión regular que describe el lenguaje { a }
Construcción de las expresiones regulares
Al ser los lenguajes regulares el menor conjunto que es cerrado con respecto de los
operadores (´*´, ´.´ , ´|´) y, sabiendo que las expresiones regulares básicas son: φ, ε
y a , ∀ a ∈ Σ podemos afirmar que la construcción de las expresiones regulares se
pueden realizar a partir de la relación entre los operadores anteriores y los
operandos que forman las expresiones regulares básicas (φ, ε, a).
Teoría de los lenguajes de programación -Tema3
1.2 Lenguajes regulares – Expresiones regulares
6
Operaciones con expresiones regulares

Sean α, β dos expresiones regulares:

α | β es una expresión regular, que denota el lenguaje L(α|β)= L(α)|L(β)
a|ε es una expresión regular, que denota el lenguaje L(a|ε)= (a)|L(ε)={a}|{ε}={a,ε}

α . β es una expresión regular, que denota el lenguaje L(α.β)= L(α).L(β)
a . ε es una expresión regular, que denota el lenguaje L(a.ε)=L(a).L(ε)={a}.{ε}={a}

α* es una expresión regular, que denota el lenguaje L(α*)= (L(α))*
a* es una expresión regular, que denota el lenguaje L(a*)= (L(a))*={a}*={ε, a, ..}
Teoría de los lenguajes de programación -Tema3
1.2 Lenguajes regulares – Expresiones regulares
7
Precedencia entre operadores
Los operadores tienen el siguiente orden de precedencia en su ejecución, de mayor a
menor: `*´, `.´ y `|´ , siendo (`.´, `|´ ) binarios mientras que (`*´) es unario y precede
al operando.
a.b|c*
Esta precedencia puede ser modificada con el uso de los paréntesis (), teniendo mayor
precedencia desde el interior hacia el exterior.
a.(b|c*)

Lenguaje denotado o descrito por una expresión regular:
Toda expresión regular α está definida sobre un alfabeto Σ, y denota o describe un
lenguaje L (α) ⊆ Σ*
Ejemplo:

L(a.b|c*)=L(a.b) | L(c*)= L(a).(b)|(L(c))*={a}.{b}|{ε, c, cc,.}={ab, ε, c, cc,...}

L(a.(b|c*))=L(a) L(b|c*)= L(a).L( (b)|(L(c)*)={a}.({b}|(L(c))*)={a}.({b}| {ε, c, cc,…})
=ab, a, ac, acc,…}

Teoría de los lenguajes de programación -Tema3
1.2 Lenguajes regulares – Expresiones regulares
8

Equivalencia entre expresiones regulares
Dos o más expresiones regulares se dice que son equivalentes, si describen el
mismo lenguaje..
ab|c*⇔ab|c.c*| ε
Mientras que un lenguaje regular puede ser denotado por mas de una
expresión regular, una expresión regular sólo denota a un lenguaje regular
Teoría de los lenguajes de programación -Tema3
1.2 Lenguajes regulares – Expresiones regulares
9

Propiedades de los operadores que pueden formar parte de una ER
Existen una serie de propiedades asociadas a los operadores de una ER
Propiedades que permiten la transformación de una ER a otra equivalente.

Propiedades que cumple el operador (|) unión de ER :
Sean α , ϐ, δ ∈ ER, se cumplen las siguientes propiedades:

Operación cerrada α | ϐ = δ

P. idempotente
α|α=α

P. conmutativa
α|ϐ=ϐ|α

P. asociativa
α | (ϐ | δ) = ( α | ϐ ) | δ

E. neutro
α|φ=φ|α
Teoría de los lenguajes de programación -Tema3
3. 2Lenguajes regulares – Expresiones regulares
10

Propiedades que cumple el operador (.) concatenación de ER :
Sean α , ϐ, δ ∈ ER, se cumplen las siguientes propiedades :



Operación cerrada α . ϐ = δ
P. asociativa
α . (ϐ . δ) = ( α . ϐ ) . δ
α.ε =ε|α=α

E. neutro

P distributiva
α . (ϐ | δ) = ( α . ϐ )|( α. δ)
(α | ϐ) δ = ( α . δ) |( ϐ . δ)
Propiedades de la operación estrella (*)
ε *= ε ; ϕ*= ε ; α . α* = α*. Α = α*
α*. α* = α* ; (α*)* = α* ; (α| ε )* = α*
(α | ϐ)* = (ϐ*| α*)*
(α | ϐ)* = ( α*. ϐ*)* = ( α*. ϐ)* α*
α ( ϐ α)* = ( α. ϐ)* α
Teoría de los lenguajes de programación -Tema3
3.2 Lenguajes regulares - Expresiones regulares
11
Expresiones regulares extendidas


Con el fin de simplificar la representación de las expresiones regulares se pueden
utilizar otros operadores, entre los que podemos destacar: +, ?, y [ ]

α+ es una nueva expresión regular, que denota el lenguaje L(α+)= (L(α))+

a+ es una expresión regular, que denota el lenguaje L(a+)=(L(a))+={a}+={a, aa,..

α? es una nueva expresión regular, que denota el lenguaje L(α?)= (L(α))?=L(α)|ε

a? es una expresión regular, que denota el lenguaje L(a? )= (L(a))?=L{a}|{ε}={a|ε}

[α] es una nueva expresión regular, que denota el lenguaje L([α] )=(L([α] ))={α1,α2,..}

[a-z] es una nueva expresión regular, que denota el lenguaje L([a-z] )= (L[a,b,..])
Teoría de los lenguajes de programación -Tema3
3.2 Lenguajes de regulares -Expresiones regulares
12
Otras propiedades
ϕ* = ε ; ε | α+= α* ; α*. Α = α+
α+? = α* ; α*?= α* ; α*| α+ = α* ; (α* α+) = α+
( α+)* = α*
(α*)+ = α*
α ? = ( α| ε )
α* = α0| α1| α2| ……αn| αn+1 α*
α* = ε | α α*
Teoría de los lenguajes de programación -Tema3
3.2 Lenguajes regulares – Expresiones regulares
13


Definiciones regulares
Es una forma de denominar una expresión regular.
A veces es conveniente darle un nombre significativo a una expresión o subexpresiones y
poder utilizar dichos nombres como si fueran símbolos para hacerla más legible
Una definición regular defi es una secuencia de definiciones de la forma:
def1→exp1
def2→exp2
………….
defn→expn
las expi están definidas sobre Σ ∪ { def1 def2…. defn}
Describir con palabras qué lenguaje representan las siguientes er:
Identificador → (letra | numero) (letra | numero| _)*
letra → a| b| ........z| A|.......| Z
numero → 0| 1.....| 9
Teoría de los lenguajes de programación -Tema3
3.3 Ejemplos
14
Lenguajes que denotan las siguientes expresiones regulares:

0* - Cadenas de ceros de cualquier longitud

(0|1)*- Cadenas binarias de 0 y 1 de cualquier longitud

(10)* - Cadenas binarias donde cada 1 va seguido de un 0, ó es ε

(0|1)*1(1|0)* - Cadenas binarias con al menos un 1

(1|10)* - Cadenas binarias que no tienen 2 ceros consecutivos, ó es ε

1(0|1)*1 - Cadenas binarias que empiezan y terminan en 1

1*01*01* - Cadenas binarias que tienen dos ceros

(0|1)*00(1|0)* - Cadenas binarias que tienen la subsecuencia 00
Dada la descripción de los siguientes lenguajes definidos sobre el alfabeto Σ={0, 1}),
encontrar las expresiones regulares que los denotan.

Cadenas binarias que acaben en 0 - (1|0)*0

Cadenas con sólo un 0 - 1*01*

Cadenas binarias que no contienen "000" - ((1*|0)(1*|0)1)* , (1|01|001)*(0|00|є

Cadenas que si tienen un 1 va precedido y seguido de un 0 - (0+1)*0+

Cadenas que tienen un número impar de 1´s - 0*1(0*10*1)*0*
Teoría de los lenguajes de programación -Tema3
3.4 Lenguajes regulares – Autómatas regulares
15

Un autómata es una máquina abstracta reconocedora de lenguajes formales

Representación conceptual
<---------- entrada --------->
|<-----x --->|
--------
a
a
b
-
--Control de estados
Estado
------
δ
A B
Estados
-
-----
Función de
transición
<---------memoria ------ ->
Teoría de los lenguajes de programación -Tema3
3.4 Lenguajes regulares – Autómatas
16





Conceptualmente- es un modelo que simula una relación de tres componentes:

Entrada

Memoria

control
Situaciones en un autómata

Situación inicial

Situación de aceptación (o de reconocimiento)

Movimiento en un autómata
Lenguaje reconocido por un autómata
Tipos de autómatas - atendiendo a los movimientos que se pueden dar en una situación

Deterministas

No deterministas
Tipos de autómatas - atendiendo a los lenguajes que reconocen

Autómata finito (regular)

Autómata de pila

Autómata acotados linealmente

Máquinas de Turíng
Teoría de los lenguajes de programación -Tema3
3.4 Lenguajes regulares - Autómata
17


Es un modelo que simula una máquina abstracta que acepta (o reconoce) las
palabras de un lenguaje regular.
Representación conceptual
<---------- entrada --------->
|<-----x --->|
--------
a
a
b
-
--Control de estados
Estado
δ
Estado(s)
Lógica de las palabras
Función de
transición
Los estados hacen de memoria
Relaciona estado con entradas
Teoría de los lenguajes de programación -Tema3
3.5 Lenguajes regulares – Autómatas finitos determinista
18
Definición formal AFD

Es aquel que ante una determinada entrada sólo se puede transitar a un estado
Un AFD se define mediante una quíntupla AF=(Σ, Q, δ, q0, F), donde:
- Σ : alfabeto de las palabras a reconocer por el autómata
- Q: conjunto de estados, es un conjunto finito no vacío
- δ: Q x Σ → Q, función de transición,
que transforma el par ordenado (qi, a) → qj
- q0 ∈ Q, estado inicial (estado de partida)
- F ⊆ Q: conjunto no vacío de estados finales o de aceptación

Dado el siguiente lenguaje L = {anbm | n, m>0}, especificar un AFD que lo reconozca:
AF= (Σ={a, b}, Q={ q0, q1, q2}, δ, q0, F={ q2}),
(q1, b) → {q2}
δ: (q0, a) → {q1}
(q2, b) → {q2}
(q1, a) → {q1}
Teoría de los lenguajes de programación -Tema3
3.5 Lenguajes regulares -Representación gráfica de los AF
19


Representación gráfica de los AF
Para mejorar la legibilidad y visibilidad de los autómatas se pueden utilizar dos tipos de
representaciones gráficas : los diagramas de transición o las tablas de transición:
Diagramas de transición
Un diagrama de transiciones, es un grafo dirigido, en el que:

Los nodos se representan por un círculo, que se etiquetan con los estados q∈Q

Habrá arcos etiquetados con a desde el nodo qi al qj, si existe la función δ(qi, a)→qj

El estado inicial tiene un arco entrante no etiquetado →

Los estados finales qf ∈ F se señalan por doble circulo
Ejemplo de AFD representado por un diagrama de transición,
que reconoce el lenguaje : L = {anbm | n, m>0}
a
a
q0
b
b
q1
q2
Teoría de los lenguajes de programación -Tema3
3.5 Lenguajes regulares –AF Representación gráfica
20

Tablas de transición
Representación tabular que relaciona dos componentes: entradas y estados

Cada fila corresponde a un estado q∈Q

Cada columna corresponde a un símbolo de entrada a∈ Σ

La fila asociada al estado inicial tiene una →

Las filas asociadas a los estados finales tienen el símbolo *
En la posición (q, a), q ∈ Q y a∈ Σ está el estado que determine la función δ (q, a)
Ejemplo de un AFD representado por una de transición, que reconoce el lenguaje :
L = {an bm | n,m>0}
entradas
a
estados
b
q0
q1
--
q1
q1
q2
* q2
--
q2
Teoría de los lenguajes de programación -Tema3
3.5 Lenguajes regulares. Lenguaje reconocido por un AFD
21

Lenguaje reconocido por un autómata finito deterministaConjunto de palabras que partiendo del una situación inicial, se llega a una situación final en
cero o más movimientos.

Movimiento en un AFD : es el paso de un estado a otro.
(qi, x) → (qj, y) ⇔ ∃ (qi,a) → (qj) ; x=ay , a ∈ Σ (qi, x=aab) → (qj, ab)
Lenguaje={ x |x ∈Σ*, (qi , x)→*(qf, ε), qf ∈F } AFD
Ejemplo:
(q0, abb)→(q1, bb)→….→(q2 ,ε)
a
q0
lenguaje reconocido
a
q1
b
b
q2
L = {anbm | n,m>0}
Teoría de los lenguajes de programación -Tema3
3.5 Lenguajes regulares- AFND
22


Los AFND es una extensión de los AFD que tiene la capacidad de transitar a más de
un estado para una misma entrada.
Un AFND se define mediante una quíntupla AF=(Σ , Q, δ, q0, F), donde:
- Σ : alfabeto de las palabras de lenguaje a reconocer
- Q : conjunto de estados, es un conjunto finito no vacío,
- δ : Q x Σ → P (Q), representa subconjunto de estados de Q.
Función de transición, que transforma el par ordenado (qi, a)→{qj,..}
- q0 ∈ Q, estado inicial
- F ⊆ Q: conjunto no vacío de estados finales o de aceptación
Dado el lenguaje L = {anbm | n, m>0}, especificar un AF que lo reconozca:
AF=(Σ={a,b}, Q={ q0, q1, q2}, δ, q0, F={ q2}),
(q0, a) → {q1} ⇒ (q0, a) → {q0, q1}
δ : (q0, a) → {q0}
(q1, b) → {q1} (q1, b) → {q2} ⇒ (q1, b) → { q1,q2}
a
b
q0
q2
q1
a
b
Teoría de los lenguajes de programación -Tema3
3.5 Lenguajes regulares - AFND
23


Lenguaje reconocido por un autómata finito no determinista
Conjunto de palabras que partiendo del una situación inicial, se llega a un
estado final en cero o más movimientos.
Movimiento: es el paso de un estado a otro.
(qi, x) → (qj, y) (qk, y) ⇔ ∃ (qi, a) → {qj, qk} x=ay , a ∈ Σ
(qi, x=aab) → (qj, ab)
→ (qk, ab)
Ejemplo :
(q0, abb)→(q0, bb)→↳
→(q1, bb)→….(q2, ε)
Lenguaje={ x | x ∈ Σ*, (qi, x)→*(qf, ε) ∩ F≠Φ} AFND
otra representación de reconocimiento
L(A)={ x | x ∈ Σ*, δ*(qi. x) ∩ F ≠ Φ }
a
q0
b
a
q1
b
q2
Teoría de los lenguajes de programación -Tema3
3.5 Lenguajes regulares – AFND con transiciones vacías
24
Definición formal AFND-ε
Una extensión de los AF que permite transiciones vacías.
Las transiciones vacías permiten realizar movimientos sin lectura de la entrada.
Un AFND_ε se definen mediante una quíntupla AF=(Σ , Q, δ, q0, F), donde:
- Σ : alfabeto de las palabras a reconocer
- Q : conjunto de estados, es un conjunto finito no vacío,
- δ : Q x {Σ ∪ε}→ P (Q) función de transición, que transforma el par
(qi, ε)→{qj,..}
P (Q), representa subconjunto de estados de Q, función de transición
- q0 ∈ Q, estado inicial
- F ⊆ Q: conjunto de estados finales o de aceptación
Sea el autómata
AF=(Σ={a,b}, Q={ q0, q1, q2, q3}, δ, q0, F={ q3})
(q0, a) → {q1} (q2, b) → {q3}
(q1, a) → {q1} (q3, b) → {q3}
(q1, ε) → {q2}
a
q0
a
q1
b
b
ε
q2
q3
Teoría de los lenguajes de programación -Tema3
3.5 Lenguajes regulares - Lenguaje reconocido por un autómata
25

Lenguaje reconocido por un autómata finito no determinista con transiciones vacías
Conjunto de palabras que partiendo del una situación inicial, se llega a un estado final en
cero o más movimientos.
Movimiento: es el paso de una situación a otra.
(qi, x) → (qj, y) ⇔ ∃ (qi, ε) → (qj) x = ay , a ∈ {Σ∪ ε}
(qi, x=aab)) → (qj, aab)→
→ (qi, aab)
Ejemplo :
(q0, aabb)→(q1, abb)→ q1, bb) →….(q2, ε)
→(q2, abb)→…..
Lenguaje={ x |x ∈Σ*, (qi. x)→*(qf, ε) ∩ F≠Φ} AFND-ε
Lenguaje={ x |x ∈Σ*, δ*(qi.x) ∩ F≠Φ} AFND-ε
Los AFND-ε facilitan la programación del AFND, están estrechamente relacionados con ER
Teoría de los lenguajes de programación -Tema3
3.6 Lenguajes regulares- Autómatas finitos equivalentes
26
Autómatas equivalentes
Dos o más autómatas A1, A2,.., son equivalentes A1≈A2≈..
lenguaje, es decir L(A1)= L(A2)=….
si aceptan el mismo
Los AF ya sean deterministas o no deterministas tienen la misma potencia de
reconocimiento de lenguajes, en el sentido que cualquier lenguaje regular puede se
reconocido por un AF



Desde el punto de vista práctico - es conveniente que el autómata sea
determinista el proceso es directo más simple de implantar y más rápido ,
Desde el punto de vista teórico - son interesante los no deterministas porque
permiten modelar el algoritmo de búsqueda y retroceso,
También son importantes y de gran utilidad los AFND con transiciones vacías
sobre la teoría de lenguajes formales
Teoría de los lenguajes de programación -Tema3
3.7 Lenguajes regulares - Autómatas completos
27
Autómatas completos
Se dice que un autómata finito es completo cuando para todos los estados se dan todas
las transiciones.
∀ a ∈ Σ , ∀ qi, qj ∈ Q ∃ (qi, a) → (qj) | (qi, abb) → (qj, bb)
Cualquier autómata finito no completo puede hacerse completo, poniendo un estado de
error o estado trampa, al cual transitan todas las transiciones no permitidas en el
reconocimiento del lenguaje
Dado el lenguaje L={an bm | n, m>0}, especificar un AFD completo que lo reconozca:
AF=(Σ={a, b}, Q={ q0, q1, q2,, qerror}, δ, q0, F={ q2})
(q0, b) → {qerror}
(q0, a) → {q1}
(q1, b) → {q2}
(q1, a) → {q1}
(q2, a) → {qerror}
(q2, b) → {q2}
a
a
q0
b
b
q1
b
qe
q2
a
a, b
Obtención del AF que reconoce el lenguaje complementario de uno dado
Teoría de los lenguajes de programación -Tema3
3.8 Lenguajes regulares - Autómata conexo
28
Autómata conexo
Un autómata finito es conexo cuando desde el estado inicial en cero o más
movimientos se llega a todos los estados.
qi (estado inicial) (qi, x) →* (qj) ∀ qj ∈ Q
todos los AF visto hasta hora son conexos
Convertir un AF dado en otro equivalente que sea conexo, consiste en quitarle los
estados inaccesibles
a
a
q0
b
a
a
b
q2
q1
b
a
q0
q1
b
qe
a, b
Teoría de los lenguajes de programación -Tema3
qe
a, b
3.9 Lenguajes regulares - Equivalencia entre AFN y AFD
29
Transformación de AFND en AFD
Un lenguaje L que puede ser reconocido por un AFND, puede encontrarse un AFD
equivalente que reconozca el mismo lenguaje.
Un AFD es un caso particular de un AFND, puesto que (qi, a) → |(qj)|=1, a ∈ Σ
∀|qj|∈ Q
En un AFND ∃ (qi, a) → |(qj, qk,…)| ≥1, a ∈ Σ , {qi, qj, qk} ∈ Q
Para evitar el no determinismo hay que unir los estados a los que se llega con una misma
entrada (qi, a) →{qj, qk,…},
los estados (qj, qk,…) que se llega con la entrada a, formarán un estado del AFD
Mueve (qi, a)={qj, qk,..}=Ai, los estados que forman Ai mantien las relaciones de
transición con el resto de los estados. Mueve (q0, a)={q1, q2,..}=Ai,
q1
a
…..
a
Ai
…..
a
q0
q2
b
q3
…..
q0
b
…..
q3
…..
Teoría de los lenguajes de programación -Tema3
3.9 Lenguajes regulares - Transformación de AFND- ε en AFD
30
Transformación de AFND- ε en AFD
Dado un AFND puede considerarse un caso restringido de un AFND-ε, δ(qi, ε)=ϕ ∀
qi∈Q
Un lenguaje reconocido por un AFND puede ser reconocido por un AFND-ε equivalente.
∃ δ(qi, ε) = {qj, qk,..}, estados {qi, qj, qk,..} se puede llegar sin leer nada de la
entrada, es decir se pueden agrupar en un estado del AFD para evitar el no
determinismo
Se utiliza la operación cierre, para agrupar todos los estados. Cierre-ε (q) estados
alcanzables desde el estado q, a través de transiciones vacías.
Cierre- ε (q)= { p | δ(q, ε) →* δ(p, ε) , q∈Q }
q1
ε
q0
a
b
q2
q3
…..
…..
…..
q01
a
b
…..
q2
q3
Teoría de los lenguajes de programación -Tema3
…..
…..
3.9 Lenguajes regulares - Transformación de AFN en AFD
31
Transformación de AFN en AFD - método de los subconjuntos
Se trata de agrupar estados del AFN para evitar el no determinismo producido por las
condiciones vista anteriormente
Un AFND se caracteriza por cumplir algunas de las siguientes condiciones:
- Existen estados que ante una determinada entrada aєΣ van a más de un estado {qi,qj .},
estados que se pueden agrupar (AFND)
(qi, a) → {qi, qj …}=Ai
- Existen transiciones vacías, todos los estados unidos por transiciones vacías se pueden
agrupar (AFND- ε)
(qi, ε ) → (qi, qj ) ; (qj, ε ) → (qk, ql ) => { qi, qj ,qk, ql}=Ai
a
q1
q3
b
a
q5
b
ε
q0
q7
b
a
q2
ε
q4
q6
ε
Teoría de los lenguajes de programación -Tema3
3.9 Lenguajes regulares - Transformación de AFN en AFD
Obtención del AFD:
- Estado inicial será el conjunto de estados alcanzables a través de transiciones vacías del
estado inicial del AFND Cierre_ ε (q0)={q0,…}=A0 A0 es un estado no tratado del AFD
Un estado Ai es no tratado cuando no se han comprobado las entradas para los estados del
AFND que lo componen.
- Mientras que existan estados no tratados hacer:
Elegir un estado no tratado Ai y ∀ aєΣ hacer:
- Mov (Ai,a)={}=Aj {estados alcanzables desde los estados del AFND que forman Ai y la
entrada a }
- Cierre_ε (Aj)= Ak {estados que se pueden sumar a los anteriores al estar unidos por
transiciones vacías}
- Se obtiene un estado Ak, que de no estar tratado lo incluiremos en el conjunto de los no
tratados
a
Estados AFD
A0
{q0}
b
{q1, q2 ,q4, q6}=A1
-----
A1
{q1, q2 ,q4,q q6}
A2
{ q0, q3, q7}
{q1, q2 ,q4, q6, 5}=A3
-----
A3
{q1, q2 ,q4, q6, q5}
-----
{ q0, q3, q7}=A2
-----
{q0, q3,q7}=A2
Teoría de los lenguajes de programación -Tema3
3.9 Lenguajes regulares - Transformación de AFN en AFD
33
Construcción del AFD buscado:



El estado inicial del AFD será aquel que contenga el estado inicial del AFND
Todos los estados Ai del AFD mantienen las entradas que tienen los estados del
AFND
Los estados finales del AFD serán aquellos que contengan algún estado final del
AFND
b
q0
q1
a
b
q3
q5
a
Teoría de los lenguajes de programación -Tema3
3.9 Lenguajes regulares - Transformación de AFD a AFD mínimo
34
Transformación de AFD a AFD mínimo – creando clases de equivalencia:
Se trata de agrupar estados que tienen el mismo comportamiento. (estados que
tienen las mismas funciones)
Dos o más estados {qi, qj,.. }tienen el mismo comportamiento, cuando esos estados
para las mismas entradas ∀ a є Σ transitan a los mismos estados o grupos de
estados
(qi, a) → {qk} (qi, b) → {ql} {qi, qj} tienen el mismo comportamiento
(qj, a) → {qk} (qj, b) → {ql}
(qi, a) → {Gk} (qi, b) → {Gl} {qi, qj} tienen el mismo comportamiento
(qj, a) → {Gk} (qj, b) → {Gl}
b
q0
a
q1
b
q3
q5
a
Teoría de los lenguajes de programación -Tema3
3.9 Lenguajes regulares -Transformación de AFD a AFD mínimo
35
Transformación de AFD a AFD
a
a
q1
a b
q0
q3
q2
b
q0
a b
q3
q2
q1,q2 tienen el mismo comportamiento
a
q1
q0
b
q3
q1q2
a
(q1, a) → {q3} ; (q2, a) → {q3} ⇒ (q12, a) → {q3}
a
a
q0
a
q1q2
a
(q1, a) → {q3} ; (q2, a) → {q3}
q1,q2 no tienen el mismo comportamiento
Teoría de los lenguajes de programación -Tema3
q3
3.9 Lenguajes regulares - Obtención del AFD mínimo:
36
Obtención del AFD mínimo:
- Se crea una partición inicial del conjunto de estados en dos grupos: finales y no finales
P0 :
G0={estados no finales} G1={estados finales}
- Por cada grupo de comportamiento de una partición hacer:
Dos o más estados pertenecientes al mismo grupo, seguirán en el mismo grupo si
tienen el mismo comportamiento
(Gi, a)→Gn
(Gi, b)→Gm
Gi se mantiene como un grupo
En otro caso el grupo se divide en tantos subgrupos como comportamiento distintos
existan
(Gi, a)→Gn, Gm ⇒ Gi=Gi1, Gi2
Gi se divide en dos subgrupos
- El proceso anterior se repetirá hasta que no se creen más subgrupos en las particiones
que se van obteniendo
Teoría de los lenguajes de programación -Tema3
3.9 Lenguajes regulares - Obtención del AFD mínimo
37
Construcción del AFD buscado:



El estado inicial del AFD mínimo será aquel grupo que contenga el estado
inicial del AFD
Todos los grupos obtenidos en la última partición serán estados del AFD
mínimo, estados que mantienen las entradas de los estados del AFD de
partida
Los estados finales del AFD mínimo serán aquellos grupos formados por
estados finales del AFD de partida
b
a
q0
q1
b
q3
q5
a
b
q0
q1
a
Teoría de los lenguajes de programación -Tema3
3.9 Lenguajes regulares- Equivalencia entre AF y gramáticas de tipo 3
38
Equivalencia entre AF y gramáticas de tipo 3
Por tratarse de dos mecanismos regulares que permiten especificar lenguajes regulares,
se puede establecer una transformación de uno al otro, nada mas que cambiando de
forma de representación.
- Trata de adaptar la representación del AF a la gramática de Tipo 3 de la siguiente
forma:
A=(Σ, Q, δ, q0, F) => G=(Σ, N, S, P)

A cada estado del AF se le hace corresponder un elemento no terminal de la
gramática

Al estado inicial le corresponde el símbolo inicial

Las transiciones se transforman en producciones de la siguiente forma:
(qi, a) → {qj} Ai→aAj Ai,AjєN qi↔Ai ; qj↔Aj
∀ qf є F
Af→ε
AfєN
qf↔Af
(qi, ε) → {qj} Ai→Aj Ai,AjєN qi↔Ai ; qj↔Aj

Ai→Aj es una producción que no corresponde a las gramáticas de tipo 3, para
evitarla sustituimos a Aj por las partes derechas de producciones donde Aj figure como
parte izquierda
Teoría de los lenguajes de programación -Tema3
3.9 Lenguajes regulares- Equivalencia entre AF y gramáticas de tipo 3
39
A=( Σ={a, b},Q={q0, q1, q2}, δ, q0, F={q2})
Δ: (q0, a) → {q1} , (q1, ε) → {q2} , (q1, b) → {q1} ,
(q2, a) → {q2} ,
(q2, b) → {q1}
G = (Σ={a, b},N={A0,A1,A2}, A0,P)
P : A0→aA1 , A1→A2|bA1 , A2→bA1|aA2|ε
A0→aA1 , A1→ bA1|aA2|ε , A2→bA1|aA2|ε
Teoría de los lenguajes de programación -Tema3
3.9 Lenguajes regulares -Equivalencia entre gramáticas de tipo 3 en AF
40
Equivalencia entre gramáticas de tipo 3 en AF
Proceso es inverso al apartado anterior en donde ahora conocemos la representación
de la gramática y hay que obtener la del AF
G=(Σ, N, S, P) => A=(Σ, Q, δ, q0,F)



A cada elemento no terminal de la gramática se le hace corresponder un estado del
AF
Al símbolo inicial le corresponde el estado inicial
Las producciones se transforman en transiciones de la siguiente forma:
Ai→aAj (qi, a) → {qj} Ai, AjєN qi↔Ai ; qj↔Aj
Para las producciones Ai→a se crea un único estado final qf al que se llega desde
el estado qi y la entrada a
Ai→a (qi, a) → {qf} qf є F
Para cada una de las producciones
como final
Ai→ ε qiєF qi↔Ai
Ai→ ε se pone el estado qi asociado a Ai
Teoría de los lenguajes de programación -Tema3
3.9 Lenguajes regulares - Equivalencia entre gramáticas de tipo 3 en AF
41
G= (Σ={a, b}, N={ A0, A1, A2 }, A0, P)
P : { A0→aA1
A1→ bA1| aA2| b| ε
A2→bA1| aA2| a |ε }
A= ( Σ={a,b}, Q={ q0, q1, q2, qf}, δ, q0, F={q1, q2, qf })
Δ : (q0, a) → {q1}
(q1, a) → {q2} , (q1, b) → {q1} , (q1, b) → {qf}
(q2, a) → {q2} , (q2, b) → {q1}, (q2, a) → {qf}
Teoría de los lenguajes de programación -Tema3
3.9 Lenguajes regulares - Equivalencia entre AFD y ER
42
Equivalencia entre AFD y ER
Para conocer este tipo de equivalencias hay que plantear el AFD como un sistema de
ecuaciones.
La forma de plantear el sistema de ecuaciones es similar al propuesto de pasar de AF a
gramática de tipo 3, con las siguientes diferencias en su representación:

La flecha separadora de las producciones se sustituye por el símbolo =

La barra de alternativa | se sustituye por un +
Los elementos no terminales se renombran por x para adecuarlo a la
representación de un sistema de ecuaciones q0
AFD => G A0→aA0 |ε => x0 = ax0 + ε
x0= ax0 + ε ; x0 representa una expresión regular (ER) que denota el lenguaje a
reconocer desde q0 o a generar desde A0

Aplicando la regla de inferencia de ER ω = α* β = α ω | β o lo que denominamos
ecuación característica (o fundamental) x = A* B = Ax + B
x0=ax0+ε => aplicando e.c. a*.ε=a*
Teoría de los lenguajes de programación -Tema3
3.9 Lenguajes regulares - Paso de ER a AFND - Método de Thompson
43
AF equivalente a la ER ε
AF equivalente a la ER a
a
ε
q0
•
q0
q1
q1
alternativa
ε
q1
AF(α)
ε
q2
q0
q5
ε
•
q3
AF(β)
ε
q4
concatenación
q0
AF(α)(
q1
ε
q2
AF(β)
Teoría de los lenguajes de programación -Tema3
q3
3.9 Lenguajes regulares - Paso de ER a AFND
44

Α*
ε
ε
AF(α)
q1
q0
ε
q2
ε

Α+
ε
q1
AF(α)
q2
Teoría de los lenguajes de programación -Tema3
q3
3.9 Lenguajes regulares - Paso de ER a AFND
45

Ejemplo - transformación de la ER a.(b|c*)* en el AFN siguiente :
a
ε
AF(b|c*)
AF (b|c*)*
ε
ε
ε
AF(b|c*)
AF (b|c*)
ε
ε
ε
AF (b)
ε
AF (c*)
ε
ε
b
ε
ε
c
ε
Teoría de los lenguajes de programación -Tema3
3.10 Lenguajes regulares - Implementación de un AFD
46
El fin de un AF es el del reconocimiento de un lenguaje, habrá que implementar
dicho autómata para realizar su reconocimiento.
A continuación se describen dos formas de simular la implementación de los AF
Simulación por medio del diagrama de transiciones
•
Posicionarse en el estado inicial qi
•
Leer el primer carácter de la entrada a
•
Mientras ( no sea fin de palabra) hacer
•
Moverse a un estado dependiendo de la entrada y estado actual qi,a →qj
•
Leer el siguiente carácter b
•
Si el estado es final entonces palabra reconocida qi∈F
•
Sino error la palabra no es reconocida. “error”
-
Simulación por medio de la tabla de transiciones
Posicionarse en el estado inicial qi
•
Repetir
•
Leer el primer carácter de la entrada a
•
Obtener siguiente estado [ estado actual, entrada leída] [qi,a]=qj
•
Hasta estado final o error
Teoría de los lenguajes de programación -Tema3
3.10 Lenguajes regulares - Simulación AF - Diagrama de transición
47
FUNCTION AFD_palabra (palabra:string): boolean;
VAR estado, posición:INTEGER; error:BOOLEAN;
BEGIN
estado:=0; error:=false; posición:=1;
REPEAT
CASE palabra [posicion] OF
'a': CASE estado OF
'0','1': estado:=1;
ELSE error:=true
a
END;
a
q0
q1
‘b': CASE estado OF
'1‘, ‘2’:estado:=2;
ELSE error:=true
END;
ELSE error:=true
END;
posicion:=posicion+1;
UNTIL error OR(Length (palabra)<posicion);
IF error THEN AFD_ident:=false
ELSE AFD_ident:=(estado=1)
Teoría de los lenguajes de programación -Tema3
END;
b
b
q2
3.10 – lenguajes regulares - Simulación de tabla de transición
48
FUNCTION AFD_palabra (palabra:string): boolean;
VAR
estado,posición:INTEGER;
BEGIN
estado:=1; posición:=1;
REPEAT
entrada:= palabra[posicion];
estado:=Tabla [estado,entrada] ;
posicion:=posicion+1;
UNTIL ((estado=2) AND (Length (palabra)) < posicion)) OR (estado=0)
IF estado=0 THEN AFD_palabra:=false
ELSE AFD_palabra:=(estado=1)
END;
entradas
a
estados
b
q0
q1
--
q1
q1
q2
* q2
--
q2
Teoría de los lenguajes de programación -Tema3
3.10 Lenguajes regulares -Módulo selector
49
FUNCTION Reconocer_palabra (palabra:string):string; (*módulo selector*)
FUNCTION Es_trivial:boolean; (*components que no necesitan un AFD para su reconocimiento*)
BEGIN
Es_trivial=((palabra='main') OR (palabra='is') OR (palabra='function') OR (palabra='mod') OR
(palabra='(') OR (palabra=',') OR (palabra='=') OR (palabra='<') OR (palabra='>=') OR
…)
END;
BEGIN
IF Es_trivial THEN componente:=palabra
ELSE CASE palabra[1] OF
'a'..'z': IF AFD_id THEN componente :='Identificador' ELSE error_lexico (1);
'0'..'9': IF AFD_cte_real THEN componente :='Cte_real'
ELSE IF AFD_cte_ent THEN componente pieza:='Cte_ent'
ELSE error_lexico(2);
'”' IF AFD_cadena THEN componente := 'Cadena' ELSE error_lexico(3);
‘{‘ : begin AFD_saltarComentarios;
ELSE error_lexico(4);
END END;
Teoría de los lenguajes de programación -Tema3

Documentos relacionados