Metodo Arbol LFP A+

UNIVERSIDAD DE SAN CARLOS DE GUAEMALA
FACULTAD DE INGENEIRA
INGENIERIA EN CIENCIAS Y SISTEMAS
LENGUAJES FORMALES Y DE PROGRAMACION
SECCOIN A+
ING. Otto A. Rodríguez Acosta
METODO DEL ARBOL PARA ENCONTRAR UN DFA MINIMO
Este método es el método más utilizado actualmente porque tiene la gran ventaja
que da como resultado un DFA mínimo. Para su ejecución se construye un árbol.
Se explicara el método mediante un ejemplo utilizando la expresión regular
siguiente:
(a|b)* abb
1. Agregar estado de aceptación (#)
El estado de aceptación se representa con el símbolo # y se coloca al final

de la expresión. Representa el punto en el cual se acepta la expresión
como valida, es decir que pertenece al lenguaje. La expresión regular
queda:
(a|b)*abb#
2. Dibujar el árbol de la expresión
Para dibujar el árbol se debe tomar cada símbolo de izquierda a derecha y

de dos en dos colocando un operador para cada símbolo. (En el caso del
operador * este solamente tiene un sub-árbol, por lo que se tomara
solamente uno) Los paréntesis se ignoran. Por definición, en un árbol,
cada nodo tiene un o más sub-árboles. A cada sub-árbol se le llamara c1
y/c2 respectivamente.
(Nota: Investigar sobre la estructura de datos de árbol)
Para (a|b)*abb# se tiene

SECCOIN A+
-------------------------------------------------------------------------------------------------------
Árbol de la expresión (a|b)*abb#
3. Numerar cada hoja del árbol

Se debe colocar a cada hoja del árbol un numero, iniciando con 1 de
izquierda a derecha hasta llegar al estado de aceptación (#). Se debe
asegurar que solamente se numeren las hojas del árbol que no tienen
épsilon (ε valor nulo). A cada hoja del árbol se le llama nodo-i donde i =
1, 2,..n y n es el último nodo hoja del árbol. En el caso del ejemplo,
ningún nodo tiene ε (Epsilón). El árbol queda así:
---------------------------------------------------------------------------------------------------------------------------------- 2
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
Árbol de la expresión numerado
A partir del árbol se pueden identificar los diferentes nodos que lo

componen:
Nodos i: Hojas del árbol numeradas que tienen un símbolo diferente de ε

(Epsilon)
Nodos ε (épsilon): Hoja del árbol que contiene valor nulo ε (Epsilon).
Nodos | (ó): Nodo del árbol que tiene el operador | y que siempre tiene
dos sub árboles (c1 y c2).
Nodo . (Concatenación): Nodo que tiene el operador de concatenación (.)
y tiene dos sub-árboles (c1 y c2).
---------------------------------------------------------------------------------------------------------------------------------- 3
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
Nodos *: Nodo que contiene el operador *. Solamente tiene un sub árbol

(c1).
Tipos de nodos para la expresión (a|b)*abb#
4. Aplicar las funciones Anulable() , PrimeraPos() y UltimaPos() a cada

nodo del árbol.
Anulable () : Esta función retorna verdadero si existe la posibilidad de que

no venga ningún símbolo en un nodo. En otras palabras, retorna falso si
estamos seguros de que siempre viene un valor en el nodo.
---------------------------------------------------------------------------------------------------------------------------------- 4
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
Por ejemplo, si viene una ‘a’ sabemos que siempre viene una a y por
consiguiente no existe ninguna posibilidad de que no venga nada, pues,
viene la ‘a’. Esto significa que para ese nodo la función debe retornar
falso. En caso contrario, si el nodo es ε (Epsilon) esto significa que no
viene nada, y entonces la función retornara verdadero.
PrimeraPos (): Esta función retorna un conjunto de símbolos que indican

el valor que debe venir de primero para que los símbolos a evaluar
pertenezcan al lenguaje. Por ejemplo, si viene la expresión regular c a b
(c seguido de a seguido de b) entonces lo primero que debe venir para que
sea correcta la evaluación es una c. Esto significa que la función
PrimeraPos debe retornar el conjunto {c}. Si la expresión Regular es (a|b)
c (a ó b seguido de c) esto significa que debe venir una a ó debe venir un
b para que sea correcto. En este caso La función PrimeraPos debe
retornar el conjunto {a, b} porque ambos símbolos pueden venir primero.
De esa manera se debe evaluar para todos las operaciones de la
expresión regular.
UltimaPos (): Esta función retorna un conjunto de símbolos que indican el

valor que debe venir de ultimo para que los símbolos a evaluar pertenezcan
al lenguaje. Por ejemplo, si viene la expresión regular c a b (c seguido a
seguido de b) entonces lo último que debe venir para que sea correcta la
evaluación es una b. Esto significa que la función UltimaPos debe retornar
una b. Si la expresión Regular es c (a|b) esto significa que debe venir de
ultimo una a ó debe venir un b para que sea correcto. En este caso La
función UltimaPos debe retornar el conjunto {a, b} porque ambos
símbolos pueden venir de último. De esa manera se debe evaluar para
todos las operaciones de la expresión regular.
Para aplicar las funciones se necesita identificar que valores deben retornar
dependiendo del tipo de nodo que se tenga. La siguiente tabla indica los
valores de las funciones para cada nodo.
---------------------------------------------------------------------------------------------------------------------------------- 5
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
TABLA DE EVALUACION DE FUNCIONES

Nodo Anulable() PrimeraPos() UltimaPos()
Nodo i Es cualquier hoja Lo primero que Lo último que

numerada viene de un viene de un
diferente de ε,  por símbolo es ese símbolo es ese
lo que siembre hay símbolo símbolo.
un valor, lo que
{i} {i}
significa que es no
anulable. Por ejemplo para Por ejemplo para
el nodo numerado el nodo numerado
Falso
i=1 seria { 1 } i=1 seria { 1 }
Nodo ε ε  Indica que no Si no viene nada, Si no viene nada,

viene ningún valor. lo primero que lo ultimo que
Si no viene nada viene es “nada”. viene es “nada”.
entonces anulable El conjunto que El conjunto que
debe retornar representa nada representa nada
verdadero. es el vacío. es el vacío.
φ φ
Verdadero
Nodo | (ó) El valor de El valor de primera El valor de última

anulable depende posición puede ser posición puede
de si son el de c1 o el de c2 ser el de c1 o el
anulables c1 o c2 o los dos, para de c2 o los dos,
bajo la siguiente esto se hace la para esto se hace
regla: con uno de unión de los la unión de los
los dos que sea conjuntos. Por lo conjuntos. Por lo
anulable el tanto es: tanto es:
resultado es
PrimeraPos(c1) U UltimaPos(c1) U
anulable.
Anulable(c1) or PrimeraPos(c2) UltimaPos(c2)
anulable (c2)
---------------------------------------------------------------------------------------------------------------------------------- 6
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
Nodo El * significa que Para cada valor Para cada valor

asterisco (*) se repite 0 o más repetido, lo repetido, lo ultimo
veces. El 0 implica primero que viene que viene siempre
que existe la siempre es el es el mismo valor
posibilidad que no mismo valor antes que se repite. Por
se repita ni una de repetirse. Por consiguiente la
ves. Entonces no consiguiente la ultima posición es:
viene nada, por primera posición
consiguiente es:
siempre es
verdadero.
UltimaPos(c1)
Verdadero PrimeraPos(c1)
Nodo Punto El valor de Lo primero que Lo último que

(.) anulable depende viene es c1 viene es c2
de si son siempre que se siempre que se
esté seguro que c1 esté seguro que
anulables c1 y c2.
viene, es decir, si c2 viene, es decir,
Con uno que no c1 no es anulable si c2 no es
sea anulable ya entonces la anulable,
existe un valor, por primara posición entonces la ultima
consiguiente los es c1. Si c1 es posición es c2. Si
dos deben ser anulable entonces c1 es anulable
anulables para que puede no estar. Si entonces puede
no esta entonces no estar. Si no
sea anulable. La
la primero Pos esta entonces la
regla es la seria la unión de ultima Pos seria la
siguiente: c1 con c2. La regla unión de c1 con
Anulable(c1) and es: c2. La regla es:
anulable (c2)
IF IF
ANULABLE(C1) ANULABLE(C1)
THEN THEN
PrimeraPos(c1) U PrimeraPos(c1) U
PrimeraPos(c2) PrimeraPos(c2)
ELSE
ELSE PrimeraPos(c1)
PrimeraPos(c1)
---------------------------------------------------------------------------------------------------------------------------------- 7
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
5. Aplicar a cada nodo del árbol las reglas definidas en la tabla anterior.
a. Nodos i
Para todas los nodos i Anulable es falso, primera y última posiciones es
igual a i.
Se coloca primera posición al lado izquierdo, ultima posición al lado
derecho y anulable encima del nodo. Esto queda entonces:
Árbol de anulable, primera y última posiciones para nodos i.
b. Nodos ε
No existe ningún nodo ε por lo tanto no se realiza nada para este tipo de
nodo.
---------------------------------------------------------------------------------------------------------------------------------- 8
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
c. Nodo |
Calcular Anulable, para lo cual se aplica la formula Anulable (c1) OR
Anulable (c2).
Para Primera y última posiciones, se hace la unión de primeraPos (c1)
con PrimperaPos(c2) es decir, PrimeraPos(c1) U PrimeraPos(c2) y de
igual manera para la ultima Posición, UltimaPos(c1) U UltimaPos(c2).
Primero se definen C1 y C2. Para este caso C1 es el nodo 1 con

símbolo a, C2 es el nodo 2 con símbolo b. Entonces Anulable(c1) =
Falso y Anulable (c2) = Falso, Falso or Falso = Falso. Entonces, el
nodo | es falso.
PrimeraPos(c1) U PrimeraPos(c2) = {1} U {2} = { 1, 2}

UltimaPos(c1) U UltimaPos(c2) = {1} U {2} = { 1, 2}
d. Nodo *
Para el nodo asterisco solamente se tiene un sub-arbol C1, por lo que

C1 en el ejemplo es el sub-árbol del nodo |.
El nodo asterisco siempre es Verdadero para la función anulable.
La primera posición siempre es la primera posición de C1. De igual
manera la última posición siempre es la última posición de el nodo C1 (
---------------------------------------------------------------------------------------------------------------------------------- 9
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
nodo | en el ejemplo). Por lo tanto PrimeraPos(*) = {1,2}

UltimaPos(*)={1,2}
e. Nodo . (concatenación)
De igual forma se aplican las operaciones específicas para este nodo.

En el ejemplo, C1 para el primer punto es el nodo * y c2 es el nodo 3.
De igual manera se aplica para el resto de nodos.
Lo que se debe validar en el caso de la primera y última posiciones es si
el nodo c1 (para primera) o c2 (para ultima) son anulables o no (es decir
tienen Verdadero en su valor de anulable). Si es así se debe hacer la
unión de los Primeros (o últimos) de c1 y c2 de lo contrario (es falso) no
se hace la unión y se pone únicamente la primera o última posición
dependiendo del caso que sea.
Entonces anulable(c1) = Verdadero

Entonces PrimeraPos(.) = {1,2} U {1,2}
El árbol queda:
---------------------------------------------------------------------------------------------------------------------------------- 10
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
El resto de nodos punto se trabajan de la misma forma, para quedar con

el árbol completo como se presenta a continuación.
Árbol completo de aplicación de funciones anulables, primeras y últimas posiciones
6. Aplicar la función siguiente
La función siguiente indica que valor le sigue a cada símbolo. Es decir, que
valor se espera que siga a cada símbolo. Los valores siguientes se
calculan llenando una tabla del nodo i y el valor siguiente de i hasta i=n
---------------------------------------------------------------------------------------------------------------------------------- 11
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
I Siguiente(i)
Esta función se aplica para los nodos punto (.) y nodos asterisco bajo las
siguientes reglas:
• Para cada Nodo asterisco (*) en el árbol.
Siguiente de nodo asterisco = Siguiente(nodo *) = siguiente(*) se calcula

con la siguiente regla : Para cada símbolo en la última posición del nodo *
le sigue el conjunto en la primera posición del nodo *.
La última posición del nodo * es {1, 2} esto significa que al 1 le sigue la
primera posición del nodo * o sea {1,2} y al 2 le sigue la primera posición
del nodo * {1.2}
---------------------------------------------------------------------------------------------------------------------------------- 12
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
i Siguiente(i)
1 1,2 a 1 le sigue
{1,2}
2 1,2 A 2 le sigue
{1,2}
• Para cada nodo punto (.) en el árbol
A cada símbolo en la Última posición de C1 de un nodo punto (.)

le sigue la primera posición de C2 del nodo punto.
Por ejemplo.
A 1 y 2 le sigue 3 porque ultimaPos(c1) = {1,2}
PrimeraPos(c2)=3
---------------------------------------------------------------------------------------------------------------------------------- 13
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
i Siguiente(i)
1 1,2,3 a 1 le sigue
{1,2} Se
agrega el 3
2 1,2,3 A 2 le sigue
{1,2} Se
agrega el 3
Se aplica el mismo procedimiento para todos los nodos punto.

---------------------------------------------------------------------------------------------------------------------------------- 14
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
A 3 le sigue 4 A 4 le sigue 5 A 5 le sigue 6
i Siguiente(i)
1 1,2,3 a 1 le sigue
{1,2} Se
agrega el 3
2 1,2,3 A 2 le sigue
{1,2} Se
agrega el 3
3 4
4 5
5 6
7. Reducción del Autómata
El siguiente paso es el proceso de reducción del autómata.
El estado inicial (So) es siempre la Primera posición de la raíz del Árbol.
So = PirmaraPos(Raiz) = {1,2,3} donde 1= a , 2 = b y 3 =a (estos valores

se obtienen del numero que tiene cada símbolo en el árbol)
So = {1,2,3}
Se aplica la función siguiente a cada símbolo:
Siguiente(a) = siguiente (1) U siguiente (3) Estos son los dos símbolos que
tienen el símbolo a. Se realiza la operación de unión de los conjuntos de
siguiente(1) con siguiente(3)
---------------------------------------------------------------------------------------------------------------------------------- 15
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
Siguiente(a) = siguiente(1) U siguiente(3) ( Tomando los valores de la

tabla) siguiente(1)={1,2,3} siguiente(3)={4}
= {1,2,3} U {4} = {1,2,3,4}
Se busca si el conjunto {1,2,3,4} en cada conjunto de los estados definidos.

Si no existe este es un nuevo estado. En el ejemplo, solamente existe el
estado So = {1,2,3} que no es igual a {1,2,3,4} por lo tanto {1,2,3,4} es un
conjunto nuevo y se convierte en el estado S1. Esto significa que del
estado So con una a se va al estado S1.
S1 = {1,2,3,4} Dado que este salió del esto So esto significa que
Del estado So con una a se va al estado S1
Para el estado So aun falta realizar el 2 con símbolo b
Siguiente (b) = siguiente(2) = {1,2,3}
Se verifica si este conjunto ya existe en alguno de los estados existentes

(So y S1). En efecto, ya existe en el estado So
Por lo que significa que del estado So con una b se va al mismo estado So
Con esto ya se hizo el estado So completo. Se verifica si hace falta hacer

algún estado, si no hace falta ninguno, ahí termina el proceso. Si hace falta
se repite el procedimiento hasta que ya no falte ninguno. Aun falta evaluar
el estado S1.
---------------------------------------------------------------------------------------------------------------------------------- 16
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
S1 = {1.2.3.4}
1=a, 2=b, 3=a, 4=b
Con a: Siguiente(a) = siguiente (1) U siguiente (3) = {1,2,3} U {4} = {1,2,3,4}
Este estado ya existe, es S1, por lo que de S1 con a se va a S1
Con b: Siguiente (b) = siguiente (2) U siguiente (4) = {1, 2,3} U {5} = {1, 2, 3,5}
Este es un conjunto nuevo y no existe en ningún estado, por lo que se crea un

nuevo estado. S2
Del estado S1 con una b se va al estado S2. {1,2,3,5} = S2
Se terminan todos los símbolos de S1 por lo que se verifica si hay algún estado
aun sin trabajar. Aun falta el estado S2.
S2 = {1,2,3,5}
1=a, 2=b, 3=a, 5=b
Con a: siguiente(a) = siguiente(1) U siguiente(3) = {1,2,3,4} este conjunto ya

existe es s1 por lo que de S2 con una a se va a S1
---------------------------------------------------------------------------------------------------------------------------------- 17
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
Con b: siguiente(b) = siguiente(2) U siguiente(5) = {1,2,3,6} Este es un conjunto

nuevo S3= {1,2,3,6}
Se termina S2 y se procede a trabajar S3
S3= {1,2,3,6}
1=a, 2=b, 3 =a 6=#
6 es estado de aceptación por lo que no se procesa.
Con a : Siguiente(a)= siguiente(1) U siguiente(3) = { 1,2,3,4 } Este es un conjunto

que ya existe es s1
Con b: siguiente (2) = { 1,2,3} = So
Como 6 es estado de aceptación, no se procesa. No existen mas estados que

procesar entonces aquí termina el proceso
Se verifica cada estado y se busca cuales tienen en su conjunto el símbolo de

aceptación # (en este ejemplo el 6). Estos estados son estados de aceptación y
por consiguiente se les pone con doble círculo. El que tiene es S3. Esto porque
S3= 1,2,3,6} y 6=# por lo tanto el estado S3 se representa con un doble circulo.
---------------------------------------------------------------------------------------------------------------------------------- 18
SECCOIN A+
SECCOIN A+
-------------------------------------------------------------------------------------------------------
Este es un DFA Mínimo
DFA mínimo para (a|b)* abb
A partir del DFA se puede formar la matriz de transiciones de la siguiente forma
a b
So S1 So
S1 S1 S2
S2 S1 S3
S3 S1 So
Derechos reservados
Prohibida su copia total o parcial sin autorización del autor
---------------------------------------------------------------------------------------------------------------------------------- 19
SECCOIN A+

Metodo Arbol LFP A+

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Metodo Arbol LFP A+

Caricato da

Copyright:

Formati disponibili

UNIVERSIDAD DE SAN CARLOS DE GUAEMALA

METODO DEL ARBOL PARA ENCONTRAR UN DFA MINIMO

1. Agregar estado de aceptación (#)

El estado de aceptación se representa con el símbolo # y se coloca al final

2. Dibujar el árbol de la expresión

Para dibujar el árbol se debe tomar cada símbolo de izquierda a derecha y

Para (a|b)*abb# se tiene

Árbol de la expresión (a|b)*abb#

3. Numerar cada hoja del árbol

Árbol de la expresión numerado

A partir del árbol se pueden identificar los diferentes nodos que lo

Nodos i: Hojas del árbol numeradas que tienen un símbolo diferente de ε

Nodos *: Nodo que contiene el operador *. Solamente tiene un sub árbol

Tipos de nodos para la expresión (a|b)*abb#

4. Aplicar las funciones Anulable() , PrimeraPos() y UltimaPos() a cada

Anulable () : Esta función retorna verdadero si existe la posibilidad de que

PrimeraPos (): Esta función retorna un conjunto de símbolos que indican

UltimaPos (): Esta función retorna un conjunto de símbolos que indican el

TABLA DE EVALUACION DE FUNCIONES

Nodo i Es cualquier hoja Lo primero que Lo último que

Nodo ε ε  Indica que no Si no viene nada, Si no viene nada,

Nodo | (ó) El valor de El valor de primera El valor de última

Nodo El * significa que Para cada valor Para cada valor

Nodo Punto El valor de Lo primero que Lo último que

Árbol de anulable, primera y última posiciones para nodos i.

Primero se definen C1 y C2. Para este caso C1 es el nodo 1 con

PrimeraPos(c1) U PrimeraPos(c2) = {1} U {2} = { 1, 2}

Para el nodo asterisco solamente se tiene un sub-arbol C1, por lo que

nodo | en el ejemplo). Por lo tanto PrimeraPos(*) = {1,2}

De igual forma se aplican las operaciones específicas para este nodo.

Entonces anulable(c1) = Verdadero

El resto de nodos punto se trabajan de la misma forma, para quedar con

Árbol completo de aplicación de funciones anulables, primeras y últimas posiciones

6. Aplicar la función siguiente

• Para cada Nodo asterisco (*) en el árbol.

Siguiente de nodo asterisco = Siguiente(nodo *) = siguiente(*) se calcula

• Para cada nodo punto (.) en el árbol

A cada símbolo en la Última posición de C1 de un nodo punto (.)

Se aplica el mismo procedimiento para todos los nodos punto.

A 3 le sigue 4 A 4 le sigue 5 A 5 le sigue 6

7. Reducción del Autómata

El siguiente paso es el proceso de reducción del autómata.

El estado inicial (So) es siempre la Primera posición de la raíz del Árbol.

So = PirmaraPos(Raiz) = {1,2,3} donde 1= a , 2 = b y 3 =a (estos valores

Se aplica la función siguiente a cada símbolo:

Siguiente(a) = siguiente(1) U siguiente(3) ( Tomando los valores de la

= {1,2,3} U {4} = {1,2,3,4}

Se busca si el conjunto {1,2,3,4} en cada conjunto de los estados definidos.

Del estado So con una a se va al estado S1

Para el estado So aun falta realizar el 2 con símbolo b

Siguiente (b) = siguiente(2) = {1,2,3}

Se verifica si este conjunto ya existe en alguno de los estados existentes

Con esto ya se hizo el estado So completo. Se verifica si hace falta hacer

1=a, 2=b, 3=a, 4=b

Con a: Siguiente(a) = siguiente (1) U siguiente (3) = {1,2,3} U {4} = {1,2,3,4}

Este estado ya existe, es S1, por lo que de S1 con a se va a S1

Este es un conjunto nuevo y no existe en ningún estado, por lo que se crea un

Del estado S1 con una b se va al estado S2. {1,2,3,5} = S2

1=a, 2=b, 3=a, 5=b

Con a: siguiente(a) = siguiente(1) U siguiente(3) = {1,2,3,4} este conjunto ya

Con b: siguiente(b) = siguiente(2) U siguiente(5) = {1,2,3,6} Este es un conjunto

Se termina S2 y se procede a trabajar S3

1=a, 2=b, 3 =a 6=#

Nodos : Nodo que contiene el operador . Solamente tiene un sub árbol

Siguiente de nodo asterisco = Siguiente(nodo ) = siguiente() se calcula