Lenguajes regulares

Lenguajes Formales y Autómatas
2. Lenguajes Regulares
TEMA 1. Lenguajes Regulares
1. Expresiones Regulares (ER)
2. Autómatas Finitos Deterministas (AFD)
3. Autómatas Finitos No Deterministas (AFND)
1
Lenguajes Formales y Autómatas
2. Lenguajes Regulares
1. Expresiones Regulares (ER)
Las expresiones regulares definen la notación que se usa para describir
lenguajes regulares. Si el lenguajes no es regular no podemos describirlo.
-
Expresiones regulares básicas
•
•
•
-
λ describe Lλ = { λ }
Φ describe LΦ = { } (lenguaje vacío)
Sea a ∈ ∑, a describe La = {a}
Operadores para expresiones regulares
•
Concatenación: α ·β , cuyo resultado describe Lα · β = Lα ·Lβ
•
Asociativa, α ·( β ·χ ) = (α ·β )·χ
No conmutativa en general, ∃α , β / α ·β ≠ β ·α
Elemento neutro, λ ·α = α ·λ = α
Elemento anulador, Φ·α = α ·Φ = Φ
Distributiva respecto a la unión, α ·( β + γ ) = α ·β + α ·γ
Unión: α + β , cuyo resultado describe Lα + β = Lα U Lβ
•
Asociativa, (α + β ) + γ = α + ( β + γ )
Conmutativa, α + β = β + α
Elemento neutro, α + Φ = Φ + α = Φ
Idempotencia, α + α = α
∞
Clausura: α * , cuyo resultado describe Lα * = ( Lα )* = U Liα
i =0
λ =λ
Φ* = λ
α * = λ + α ·α *
α ·α * = α * ·α
α * ·α * = α *
(α * )* = α *
(α * + β * ) * = (α + β )*
(α + β )* = (α * ·β * )*
α * = (λ + α + α ·α +···+α ···α * )
*
n-1 veces
La prioridad entre los operadores anteriores, de mayor a menor es:
clausura (*), concatenación(·) y unión(+).
2
Lenguajes Formales y Autómatas
2. Lenguajes Regulares
Ejemplo:
00 
→ L00 = L0 ·L0 = {0}·{0} = {00}
0 +1
→ L0+1 = L0 U L1 = {0} U {1} = {0,1}
(0 + 1)* 
→ L( 0+1)* = ( L0+1 )* = {0,1}* = {λ ,0,1,00,01,10,11}
0 + 1* 
→ L0 U ( L1 ) * = {λ ,0,1,11,111,...}
■
CONCLUSIÓN: todos los lenguajes finitos son regulares
Ejemplo: lenguaje NO regular
L = {a n ·b n | n ≥ 0} 
→{λ , ab, aabb,...}
■
Ejemplo práctico: Encontrar una ER que represente los identificadores de un
lenguaje de programación.
Definimos dos macros para facilitar el trabajo:
letra = a + b +···+ z + A + B +···+ Z
dígito = 0 + 1 +···+9
{letra}·({letra} + {digito}) *
Restringimos ahora el problema a representar identificadores de 4 caracteres:
{letra}·({letra} + {digito} + λ )·({letra} + {dígito} + λ )·({letra} + {dígito} + λ )
■
-
Equivalencia
Dos expresiones regulares, e1 ,e2 , son equivalentes ( e1 ≡ e2 ) si definen el
mismo lenguaje ( Le1 = Le2 )
3
Lenguajes Formales y Autómatas
2. Lenguajes Regulares
2. Autómatas Finitos Deterministas (AFD)
Se define un Autómata Finito Determinista como una tupla de 5 elementos
( ∑, Q , δ , q 0 , F )
∑ : alfabeto
Q : conjunto finito y no vacío de estados
δ : función de transición, δ : Q × ∑ 
→ Q
q0 : estado inicial, q0 ∈ Q
F : conjunto de estados finales o de aceptación, F ⊆ Q
L
w0
Qi
w1
w2
w2
MC
Ejemplo:
ADF1 = ({0,1},{q0 , q1 ,}, δ ,{q0 })
δ ( q 0 ,0 ) = q 0
δ (q0 ,1) = q1
δ (q1 ,0) = q1
δ (q1 ,1) = q0
■
-
Tabla de transiciones
δ
···a ∈ ∑···

→ q0
λ q ∈Q
i
···
≡
* Con este símbolo marcaremos los estados finales
4
Lenguajes Formales y Autómatas
2. Lenguajes Regulares
Ejemplo: con el autómata del ejemplo anterior tendríamos,
δ
qo
q1
1
q1
qo
0
qo
q1
■
-
Diagrama de transiciones
Ejemplo: con el autómata anterior tendríamos,
0
0
1
q0
q1
1
Detecta un lenguaje con un número par de 1’s.
■
-
Función de transición extendida a palabra
δ : Q × ∑* 
→ Q
Definición recursiva:
δ * (q, λ ) = q∀q ∈ Q
 *
δ (q,α ·ω ) = δ * (δ (q,α ), ω )
α ∈∑
ω ∈ ∑*
Ejemplo:
δ (q1 ,011) = δ * (δ (q1 ,0),11) = δ * (δ (q1 ,1),1) = δ * (δ (q0 ,1), λ ) = q1
aw
q1
aw
q0
a
q1
■
El lenguaje reconocido por el Autómata Finito Determinista será:
L( AFD) = {ω | ω ∈ ∑ * yδ * (q0 , ω ) ∈ F }
-
Equivalencia de Autómatas Finitos Deterministas
Dos AFD son equivalentes si reconocen el mismo lenguaje.
5
Lenguajes Formales y Autómatas
-
2. Lenguajes Regulares
Autómatas Finitos Deterministas Conexos
•
Accesibilidad entre estados: pΑq
Desde q puedo llegar a p si y sólo si existe una palabra tal que
esa palabra lleva de q a p.
pΑq ⇔ ∃ω ∈ ∑ * | δ * (q, ω ) = p
* Aquellos estados que no son accesibles desde el estado inicial
pueden ser eliminados del AFD.
•
Parte conexa
Todos aquellos estados del AFD que son accesibles desde el
estado inicial.
Ejemplo:
0
Parte conexa
0
1
q0
q1
1
PC = {q0 , q1}
0
1
q2
■
Por tanto, definimos Autómata Finito Determinista Conexo como aquél
que tiene todos sus estados accesibles desde el estado inicial, es decir,
que carece de parte no conexa.
Se define AFD conexo equivalente como aquel autómata que se obtiene
eliminando la parte no conexa
Cualquier Autómata Finito Determinista puede ser representado por el siguiente
programa:
estado q0
símbolo siguiente_símbolo()
mientras símbolo
estado δ (estado_símbolo)
símbolo siguiente_símbolo()
fmientras
si (estado ∈ F)
aceptada()
|otras:
no_aceptada()
fsi
6
Lenguajes Formales y Autómatas
2. Lenguajes Regulares
3. Autómatas Finitos No Deterministas (AFND)
Estos autómatas se caracterizan, fundamentalmente, por poder encontrarse en
varios estados al mismo tiempo.
Pueden ser obtenidos modificando el AFD.
Qi
-
MC
Autómata Finito No Determinista
Este tipo de máquinas permite, con la entrada de un símbolo, cambiar a
varios estados al mismo tiempo.
ADFND (∑, Q, δ , q0 , F )
Cambia la función de transición
δ :Q×∑ 
→ Ρ(Q) Va a “partes de Q”
Ejemplo:
y
x
q0
x
q1
Supongamos la entrada xyy, la traza sería la siguiente,
q0
x
x
q0
q1
y
q1
y
q1
La palabra xyy es aceptada si uno de los estados es final.
■
•
Función de transición extendida a palabra
δ * :Q×∑ 
→ Ρ(Q)
Definición recurrente:
δ * (q, λ ) = {q}∀q ∈ Q

δ * (q, ω ·α ) = U δ ( p, α )

p∈δ * ( q ,ω )
,α ∈ ∑
ω ∈ ∑*
7
Lenguajes Formales y Autómatas
2. Lenguajes Regulares
Ejemplo: con el autómata del ejemplo anterior
δ * (q0 , xyx)
q0
x
x
q0
q1
y
q1
x
M
//Estado muerto
(*)
*
Uδ ( p, x) = δ (q0 , xy) = Uδ ( p, y ) = δ (q0 , x) =
δ * (q0 , xyx) =
p∈δ * ( q0 , xy )
=
p∈δ * ( q0 , x )
Uδ ( p, x) = δ (q , x) = {q , q }
0
0
1
p∈δ * ( q0 ,λ )
q0
Uδ ( p, y ) = δ (q , y) U δ (q , y) = {q }
(*)
0
1
1
p∈δ * ( q0 , x )
⇒ δ * (q0 , xyx) =
U δ ( p, x) = δ ( q , x) = Φ
1
p∈δ * ( q , xy ) ={ q1 }
■
•
Lenguaje definido por un AFND
L( AFND ) = {ω ∈ ∑ * | δ * (q0 , ω ) I F ≠ Φ}
Ejemplo:
El autómata del ejemplo anterior reconoce el lenguaje cuya expresión
regular es x·x*·y*
Ejemplo:
a, b
q0
a
q1
b
q2
a
q3
b
a, b
q1
Este autómata realiza una búsqueda de la subcadena “abab” para cada
símbolo que le entra.
■
8
Lenguajes Formales y Autómatas
-
2. Lenguajes Regulares
Autómata Finito No Determinista con transiciones vacías (λ-AFND)
Permiten cambiar el estado cuando la entrada es vacía. Este tipo de
autómata nos permite “fundir” estados.
λ − AFND (∑, Q,δ , q0 , F )
δ : Q × (∑ U{λ}) 
→ Ρ(Q)
•
λ – cierre: Ρ(Q) 
→ Ρ(Q) (λ - clausura)
Indica en qué otros estados se encuentra el autómata sin leer
nada.
Ejemplo:
q1
λ
q0
λ − cierre({q0 }) = {q0 , q1 , q2 }
λ − cierre({q1 , q3 }) = {q1 , q3 , q2 }
λ
λ
a
q3
q2
■
Reglas para el cálculo del λ-cierre
S ⊆Q
1)∀q ∈ S , q ∈ λ − cierre( S )
2)∀q ∈ λ − cierre( S ), δ (q, λ ) ∈ λ − cierre( S )
λ − cierre( S )
•
Función de transición extendida a palabra
Definición recursiva:
δ * (q, λ ) = λ − cierre({q})∀q ∈ Q



 *


=
−
δ
(
q
,
w
,
a
)
λ
cierre
δ
(
p
,
a
)
U

 *

 p∈δ ( q ,w)


Ejemplo:
x
q0
y
λ
q1
9
Lenguajes Formales y Autómatas
2. Lenguajes Regulares


δ ( p, y )  = λ − cierre(δ (q0 , y ) U δ (q1 , y ) ) = {q1}
U
 p∈δ * ( q , xx )

0


δ * (q0 , xxy) = λ − cierre


1)δ * (q0 , xx) = λ − cierre U δ ( p, x)  = {q0 , q1}
 p∈δ *q , x )

0




2)δ * (q0 , x) = λ − cierre U δ ( p, x)  = λ − cierre(δ (q0 , x) U δ (q1 , x) ) =
 p∈δ * ( q ,λ )

0


= λ − cierre({q0 }) = {q0 , q1}
Reconoce el lenguaje cuya expresión regular es x*·y*
■
•
Lenguaje reconocido por λ – AFND
L(λ − AFND ) = {ω ∈ ∑ * | δ * (q0 , ω ) I F ≠ Φ}
Los tres tipos de autómatas vistos hasta ahora tienen la misma capacidad de
reconocimiento: SÓLO RECONOCEN LENGUAJES REGULARES.
10
Lenguajes Formales y Autómatas
2. Lenguajes Regulares
ALGORITMO PARA OBTENER UN AFD A PARTIR DE UN AFND
La estrategia a seguir para obtener un AFD a partir de un AFND es simulando
el comportamiento del AFND. Los estados del AFD vendrán etiquetados con un
conjunto de estados del AFND, por ejemplo si nos encontramos en un estado
C1 en el AFD etiquetado con {q0, q1, q2} significa que cuando el AFND ha
leído la misma porción de la cadena de entrada se encuentra en los estados
q0, q1 y q2 a la vez.
Algoritmo:
Entrada: AFND(E,Q,d,q0,F)
Salida: AFD(E,Q',d',C0,F')
1) El estado inicial del AFD C0 se etiqueta con los estados en los que
se encuentra el AFND al iniciar su ejecución, es decir, d(q0, λ), o lo
que es lo mismo {q0}.
2) El resto de estados del AFD se obtienen a partir del estado inicial
aplicando la función de transición d'. d' se define de la siguiente
forma: d'(Ci,a) = Cj . De manera que si el Ci viene etiquetado con el
conjunto de estados {qi, qi+1, .... ,qi+n} Cj vendrá etiquetado con los
estados d(qi,a)Ud(qi+1,a)U···Ud(qi+n,a)
3) Los estados finales del AFD serán aquellos que estén etiquetados
con al menos un estado final del AFND
11