Asignatura: Teora de la Computacin

Unidad 1: Lenguajes Regulares

Tema 1: Autmatas de Estados Finitos

Autmatas de Estados Finitos

Definicin de Autmatas de estados finitos:

Tipo Lenguaje Mquina Gramtica G = (V,T,P,S)
Gramtica Regular
3 Lenguaje Regular Autmata finito A aB, A a
(A,B en V y a en T)

Autmata de Estados Finitos (AF): Describen, reconocen y definen a los Lenguajes Regulares.
Modelo Matemtico de un sistema con estados y salidas discretas.

Tipos de Autmatas Finitos:

- Autmata Finito Determinista (AFD). No pueden estar en ms de un estado
simultneamente.

- Autmata Finito No Determinista (AFN). Puede estar en varios estados al mismo tiempo.

Definicin de Autmatas de estados Finitos Deterministas (AFD):

Un AFD es una quntupla A = (Q , , , q0 , F)

Siendo:
Q = conjunto finito de estados.
= conjunto finito de smbolos del alfabeto.
q0 = es el estado inicial (denotado con flecha ) a inicio
F = conjunto de estados finales (o estados de aceptacin). F Q
= La funcin de transicin entre estados
: Q x Q
Por ejemplo: si p y q estan en Q y a en ,
Se define la transicin (q,a) = p.
En la figura se observa como hay una transicin de q a p
dado a. Es decir, existe un arco etiqueta a entre q u p.

Los estados de aceptacin se denotan grficamente con un doble crculo y en la

tabla de transicin con asterisco al lado del estado. Por ejemplo si r esta en F debe
ser denotado con doble circulo como se observa en la figura.

Nota: En los AFD debe cumplirse que: Para toda a que esta en existe exactamente una
transicin de salida de cada estado.

Prof. Hilda Contreras Teora de la Computacin - Pregrado 1

Notacin para la Funcin de Transicin: Se tiene tres formas para presentar la funcin de
transicin cualquiera de ellas es suficiente para completar el diseo del AFD. Estas son:
a) Diagrama de Transicin

b) Funcin de transicin

c) Tabla de Transiciones: Representacin Tabular

Ejemplo: Dado el lenguaje L = { x | x en {0,1} y x comienza con 0 }, es decir todas las cadenas
binarias que comienzan con 0. El AFD que lo reconoce es el siguiente:

M = (Q ,, , q0 , F)

= {0,1}, F = {q1}, Q={q0,q1,q2}

0 1

--> q0 q1 q2

*q1 q1 q1

q2 q2 q2

Funcin de transicin

(q0,0) = q1

(q0,1) = q2

(q1,0) = q1

(q1,1) = q1

(q2,0) = q2

(q2,1) = q2

Las tres representaciones de la funcin de transicin son equivalentes, y cada suficiente para
dar el AF. Puede escoger una representacin pero comprendiendo la relacin entre ellas.

Prof. Hilda Contreras Teora de la Computacin - Pregrado 2

Ejecucin de un Autmatas de estados finitos determinista AFD:
Para la ejecucin formal de un AFD se utiliza la definicin de la funcin de transicin extendida
sobre cadenas

= Q x * Q

1) (q,) = q
2) Para todo w en * y a en (q,wa) = ((q,w),a)

Por ejemplo: Dado el AFD anterior que reconoce el lenguaje L = { x | x en {0,1} y x comienza
con 0 } , pruebe si las cadenas w1 = 010 y w2 = 101 estn en el lenguaje L

(q0,010) = ((q0,01),0) = ( ((q0,0),1),0) = ( ( ((q0,),0),1),0)

( ( (q0,0),1),0) ( (q1,1),0) (q1,0) = q1 Acepto al terminar de procesar la
cadena y quedar en un estado de aceptacin (esta en F)

(q0,101) = ((q0,10),1) = ( ((q0,1),0),1) = ( ( ((q0,),1),0),1)

( ( (q0,1),0),1) ( (q2,1),0) (q2,0) = q2 No acepto al terminar de procesar la
cadena y quedar en un estado que no es de aceptacin.

Lenguaje aceptado por un AFD.

Dado M = (Q ,, , q0 , F) un AFD, el lenguaje L aceptado por M est definido por:

L(M)= { w | w en * y (q0,w) pertenece a F }

Nota: el lenguaje de M, es un conjunto de cadenas w que llevan al autmata M desde q0 a un

estado de aceptacin. Si L es un L(M) para algn AFD M, entonces decimos que L es un
Lenguaje Regular.

Nota importante: Para poder verificar si la cadena w esta (es aceptada) o no (no es
aceptada) en L se debe terminar de procesarse la cadena w.

Ejemplo: Dado el lenguaje L = { w | w tiene un nmero par de ceros y unos }

L = { 00, 11, 1100, 0011, 0101, 1010, 001010, }

M = (Q, , , q0, F)

= {0,1} , Q = {q0,q1,q2,q3}

F = { q3 }

Para la cadena 0101 probar el AFD

(q0,0101) = ((q0,010),1) = (
((q0,01),0),1) = ( ( ((q0,0),1),0),1) =
( ( ( ((q0,),0),1),0),1)
( ( ( (q0,0),1),0),1) ( ( ( (q1,1),0),1) ( (q3,0),1) (q2,1) = q0, Acepto al
terminar de procesar la cadena y quedar en un estado de aceptacin q0 (q0 esta en F es
verdadero)

Ejercicios AFD:
Para = {0,1} construya un AFD que acepte los siguientes lenguajes:

Prof. Hilda Contreras Teora de la Computacin - Pregrado 3

 a) El conjunto de cadenas que tiene 011 como subcadena.

b) El conjunto de todas las cadenas cuyo tercer elemento desde el extremo izquierdo sea
un 1.

c) El conjunto de cadenas en las que el nmero de ceros es divisible por 3.

d) El conjunto de cadenas que terminan con 01.

e) El conjunto vaco.

f) El conjunto de la cadena vaca.

g) Elabore un algoritmo para implementar el funcionamiento de un AFD en un

computador (debe reflejar el estado, la funcin de transicin y simular el
funcionamiento y definicin del AFD). Nota: El compilador de un lenguaje de
programacin implementa AFD.

Autmata Finito No Determinista AFND.

Son autmatas de estados finitos que tienen la capacidad de estar en ms de un estado
simultneamente. Ventaja: son ms compactos, flexibles y fciles de disear que los AFD
permiten cero, una o ms transiciones de salida de un estado para el mismo smbolo. No hay
que considerar todos los casos en cada estado.
Q
La diferencia con AFD es la funcin : Q x 2 tambin : Q x Q*
En la figura (q,a) = {p, r}
A=(Q ,, , q0, F)
: Q x Q*
(q,a) = R , R Q , (q,a) = {p, r}

Funcin de Transicin Extendida:

= Q x * Q*

1) (q,) = {q}
2) (q,xa) = { r | para algn p en (q,x), (p,a) = r }

Sea w de la forma w = xa donde a es el smbolo final (sufijo de longitud 1) de w y x el resto de

w.

Entonces:

.
.
.

Extensin para Q* x

Prof. Hilda Contreras Teora de la Computacin - Pregrado 4

 1) (P,w) =

Lenguaje aceptado por un AFN.

Dado M = (Q, , , q0 , F) un AFN, el lenguaje L aceptado por M est definido por:

L(M)= { w | w en * y (q0,w) F}

Es el conjunto de cadenas pertenecientes a * tal que ejecutar el AFN desde el estado inicial
q0 con la cadena w, la funcin de transicin extendida (q0,w) contiene al menos un estado
de aceptacin (es diferente del vaco la interseccin con F).

Ejemplo:
Dado el lenguaje L= { x | x en {0,1} y termina en 01}, hallar el AFN que lo reconozca
L={ 01, 0001, 101, 1001, 10101, }

A = (Q, , , q0, F)
Q = { q0, q1, q2 }
= { 0,1 }
F = {q2}

1 0 1 0 1

Para las cadenas w1 = 01 y w2 = 10101 se muestra la ejecucin formal a partir de la funcin de

transicin extendida:

(q0,01) = ((q0,0),1) = ( ((q0,), 0),1) ((q0, 0),1) ({q0, q1},1) = (q0,1) U (q1,1) =
{q0} U {q2} = {q0,q2} , Acepto porque {q0,q2} {q2} , es decir al menos uno de los
estados del autmata, luego de procesar la cadena, es de aceptacin

(q0,10101) = ((q0,1010),1) = ((((((q0,),1),0),1),0),1)

(((((q0,1),0),1),0),1) (((({q0},0),1),0),1) ((({q0,q1},1),0),1)
({q0,q1},1) = (q0,1) U (q1,1) = {q0} U {q2} = {q0,q2}
(({q0,q2},0),1)
({q0,q2},0) = (q0,0) U (q2,0) = {q0,q1} U = {q0,q1}
({q0,q1},1) = (q0,1) U (q1,1) = {q0} U {q2} = {q0,q2}, acepto porque {q0,q2} {q2} , es
decir al menos uno de los estados es de aceptacin de F

Ejercicios AFN:

Prof. Hilda Contreras Teora de la Computacin - Pregrado 5

Construya un AFN que acepte los siguientes lenguajes:
a) Conjunto de cadenas basadas en ={a,b,c} cuyo ltimo smbolo no haya aparecido
antes en la misma entrada.

b) Conjunto de 0 y 1 que contenga 2 ceros separados por un nmero de posiciones

mltiplo de 3. Ntese que 0 es un mltiplo de 3 valido.

Equivalencia entre AFD y AFN:

- Todo Lenguaje Regular puede describirse con ambos AFN y AFD.

- Generalmente un AFN es ms fcil de capturar, y un AFD es mas fcil de implementar.

- Tienen casi el mismo nmero de estados. El AFD ms grande puede tener 2n estados y el
AFN mas pequeo solo tiene n estados.

Teorema: Si L es aceptado por un AFN entonces existe un AFD que acepta L (es decir, ambos
aceptan la misma clase de lenguaje).

Algoritmo para la Construccin de Subconjuntos:

Este algoritmo permite a partir de un AFN obtener un AFD equivalente que reconoce el mismo
lenguaje. Su nombre se debe a que se intenta construir todos los subconjuntos del conjunto de
estados del AFN.
AFN N = (QN ,, N, q0 , FN)
AFD D = (QD ,, D, {q0} , FD)
Tal que L(N) = L(D) (el lenguaje reconocido por el autmata N sea el mismo que el lenguaje
reconocido por el autmata D, por tanto sean equivalentes)

Algoritmo:
- son iguales de N y D.
*
- QD es el conjunto de los subconjuntos de QN, (QD ) conjunto potencia. No todos los
estados de QD son accesibles desde q0, esos son eliminados.

- FD es el conjunto de subconjuntos S de QN (S QN) tal que S FN . Es decir

FD contiene todos los conjuntos de estados de N que incluyen al menos un estado de

aceptacin de N.

- Para todo S QN y a en , entonces D(S,a) =

Ejemplo: Dado N = (QN ,, N, q0 , FN) un AFN, ={0,1} y QN = {q0,q1,q2}, FN = {q2}

N 0 1
q0 {q0,q1} {q0}
q1 {q1}
q3

Prof. Hilda Contreras Teora de la Computacin - Pregrado 6

Obtener D un AFD tal que L(N) = L(D) a travs del algoritmo de construccin de subconjuntos

D = (QD ,, D, {q0} , FD)

QD = ( , {q0}, {q1}, {q2}, {q0,q1}, {q0,q2}, {q1,q2}, {q0,q1,q2}}
FD = ({q2}, {q0,q2}, {q1,q2}, {q0,q1,q2}}

D({q0},0) = N(q0,0) = {q0,q1}

D({q0},1) = N(q0,1) = {q0}
D({q0,q1},0) = N(q0,0) U N(q1,0) =
D({q0,q1},1) = N(q0,1) U N(q1,1) =
D({q0,q1},1) = N(q0,1) U N(q1,1) =
D({q0,q2},0) = N(q0,0) U N(q2,0) =
D({q0,q2},1) = N(q0,1) U N(q2,1) =
{q0,q1} U = {q0,q1}
{q0} U {q2} = {q0,q2}
{q0} U {q2} = {q0,q2}
{q0,q1} U = {q0,q1}
{q0} U = {q0}

Para w= 10101 en *
D({q0},10101) = D (D({q0},1010),1) = D (D (D (D (D (D({q0},),1),0),1),0),1)
D (D (D (D (D ({q0},1),0),1),0),1) = D (D (D (D (D ({q0},1),0),1),0),1) = D (D (D
(D({q0},0),1),0),1) = D (D (D ({q0,q1},1),0),1) = D (D ({q0,q2},0),1) = D ({q0,q1},1) = {q0,q2}
Acepto porque {q0,q2} esta en FD

La demostracin de este algoritmo esta en el libro [1]: Se demuestra por induccin sobre el
tamao de w, donde el caso base N(q0, ) = D({q0}, ) y para el caso inductivo N(q0, w) =
D({q0}, w)

Automatas Finitos con Transiciones espontneas (AFN-)

Es un AFN que permite transiciones para . Antes los AF no se movan con la cadena vaca, es
decir N(q, ) = {q} y D(q, ) = q, los AF se quedaban en el mismo estado. Ahora con AFN- se
tienen transicin espontneas sin recibir o procesar ningn smbolo de la entrada. Se aplica si
no pertenece al conjunto de smbolos .
Utilidad:
- Facilidad de Programacin.

- Relacin directa con las expresiones regulares (equivalencia demostrada formalmente)

Un AFN- es una quntupla: A=(Q ,, , q0, F)

Siendo:
Q = conjunto finito de estados.
= conjunto finito de smbolos del alfabeto.
q0 = es el estado inicial (denotado con flecha ) a inicio
F = conjunto de estados finales (o estados de aceptacin). F Q
= La funcin de transicin entre estados : Q x U {} Q*

Prof. Hilda Contreras Teora de la Computacin - Pregrado 7

 n m p
Ejemplo: Dado L = { 0 1 2 | n,m,p 0 }, el lenguaje de todas las cadenas de 0, 1 o ms ceros
n m p
(0 ) seguidas de 0, 1 o ms unos (1 ), y seguidas de 0, 1 o ms dos (2 ).
Los siguientes autmatas reconocen a L:

AFN :

AFN- : Probando la cadena 002

1 0

Nota: en la tabla de transicin puede o no

asumirse la transicin espontnea de . Es decir,
(q,) = {q}. Por ejemplo en el estado q2, puede
ser pero sin embargo tambin es U {q2}

Ejecucin de un AFN-:
Dada una cadena y un AFN-, para reconocer dicha cadena se debe aplicar la funcin
Extendida para cadena ^: Q x * Q*

Donde ^(q,w) es el conjunto de todos los estados pi tal que se puede ir de q a cada pi por un
camino etiquetado w que puede incluir arcos etiquetados . Para calcular este camino es
necesario definir el trmino -clausura de un estado.

-clausura (q) = es el conjunto de todos los estados a los cuales se puede llegar a partir de q
siguiendo un camino de arcos etiquetados con nicamente.

Definicin recursiva de -clausura (q):

Base: -clausura(q) = q , es decir por definicin (q,) = q, podemos imaginarnos un
bucle de un estado a si mismo etiquetado
Paso inductivo:
Si es la funcin de transicin de AFN- y p est en la -clausura(q), es decir (q,)=p
entonces la -clausura(q) tambin contiene los estados (p,). Ver siguiente figura

Prof. Hilda Contreras Teora de la Computacin - Pregrado 8

 ^
Definir :

1) ^(q0,) = -clausura(q0)

2) Para todo w en * y a en ^(q,wa) = -clausura(P), Donde:

-clausura(P) = { p | para algn r en ^(q,w), p en (r,a) } Nota: aplicar -clausura a cada p.

R es subconjunto de Q:

3) (R,a) =

4)

^
Entonces (q,w) = ^(q,x) = {r1,r2,...,rk} con w = xa .

Prof. Hilda Contreras Teora de la Computacin - Pregrado 9

 y

Ejemplo: Dada la cadena w= 02 determinar si pertenece o no al lenguaje reconocido por el

siguiente AFN-

-clausura(q0) = { q0,q1,q2}
-clausura(q1) = {q1,q2}
-clausura(q2) = {q2}

^(q0,02) = -clausura((^(q0,0),2)) = -clausura((-clausura((^(q0,),0)),2))

= -clausura((-clausura(({q0,q1,q2},0)),2)) ya ^(q0,) = -clausura(q0) = {q0,q1,q2}

= -clausura((-clausura({q0}),2)) ya ({q0,q1,q2},0) = {q0 } U U = {q0 }

= -clausura(({q0,q1,q2},2)) ya -clausura({q0}) = -clausura(q0 ) = {q0,q1,q2}

= -clausura({q2}) ya ({q0,q1,q2},2) = U U {q2} = {q2 }

= {q2 } Acepto la cadena w 02 ya que ^(q0,02) F

Lenguaje Aceptado por un AFN- :

Dado un AFN- E=(Q ,, , q0 , F) el L(E) se define como:

L(E)= { w | ^(q0,w) F}

Equivalencia AFN- con AFD (construccin de subconjuntos de )

Teorema: Si L es aceptado por un AFN con transiciones entonces L es aceptado por un AFN
sin -transiciones.

(Equivalencia Eliminacin de -transiciones)

Teorema: Un lenguaje L es aceptado por un AFN- si y solo si es aceptado por un AFD.

Algoritmo para pasar de un AFD a un AFN-

E es AFN- y A es AFD L(E) = L(A) es decir E^(q0E,w) = D^(q0D,w) para todo w en L

E (AFN-) = (QE,,E, q0E,FE)

D (AFD) = (QD,,D, q0D,FD)

q0D = -clausura(q0E)
QD = QE *, es decir el conjunto de
subconjuntos de QE
FD = { s | s en QD y S FE }
D (S,a) para todo a en y S en QD =

Prof. Hilda Contreras Teora de la Computacin - Pregrado 10

 =

{ }=

Ejemplo: Dado el AFN- E halle un AFD equivalente.

E = (Q, , , q0, F)
Q = {q0,q1,q2}
= {0,1,2}
F = {q2}

D =( , , , )
( )=

( )=

( )=

Prof. Hilda Contreras Teora de la Computacin - Pregrado 11

AFD: Se ve cada estado como un Conjunto de etiqueta.
AFN: Se interpreta el contenido de la etiqueta de cada estado.
Hay dos formas de interpretar la construccin de subconjuntos- , una para crear un AFD y
otra AFN. La idea es llegar a un AF ms fcil de implementar los cuales son AFD.

Ejercicios:
1. Obtenga un diagrama de transicin de un AFN que acepte las cadenas de 0s y 1s que
tengan 2 ceros separados por una cadena cuya longitud es 3i para algn i 0.Usando
el algoritmo visto en clase, convierta este autmata en un AFD.

2. Obtenga un autmata finito (de cualquier tipo) para reconocer los siguientes lenguajes:
cadenas acabadas en 00
cadenas con dos unos consecutivos
cadenas que no contengan dos unos consecutivos
cadenas con dos ceros consecutivos o dos unos consecutivos
cadenas con dos ceros consecutivos y dos unos consecutivos
cadenas acabadas en 00 o 11
cadenas con un 1 en la antepenltima posicin
cadenas de longitud 4

1. El conjunto de enteros y nmeros en punto flotante. Usando el = { +, 0, 1, 2, 3, 4, 5, 6, 7,

8, 9, E, . }

2. Construir un AFD equivalente a los siguientes autmatas :

a) M1 = ({p,q,r,s}, {0,1}, , p, {s}) donde est dada por :

0 1
p {p, q} {p}
q {r} {r}
r {s} {}
*s {s} {s}

b) M2 = ({p,q,r,s},{0,1}, , p,{q,s}) donde est dada por:

0 1
p {q, s} {q}
*q {r} {q,r}
r {s} {p}
*s {} {p}

1. Dado el siguiente AFN- E, aplicando el procedimiento de construccin de subconjunto,

convertir a un AFD

E = (Q, , , p, F)

Q = { p, q, r }
= { a, b, c }
F={r}

a b c
p {p} {q} {r}

Prof. Hilda Contreras Teora de la Computacin - Pregrado 12

 q {p} {q} {r}
* r {q} {r} {p}

2. Obtener a partir de los siguientes AFND-, un AFD equivalente.

a) M1 = ( {q0,q1,q2,q3,q4}, {a,b}, , q0, { q4 } ) donde est dada por:

a b
q0 {q1,q2} {q1,q3} {}
q1 {} {} {q3}
q2 {q4} {} {}
q3 {} {q4} {}
q4 {} {} {}

b) M2 = ( {q0,q1,q2,q3} , {a,b,c} , , q0 , {q3} ) donde est dada por :

a b c
q0 {q0,q1} {} {} {q2}
q1 {} {q1,q3} {} {}
q2 {} {q2} {} {q3}
q3 {} {} {q3} {}

Preguntas
Determine las diferencias entre un AFD y un AFN.

Cundo usar cada uno de estos autmatas?

Puede obtener un AFND algortmicamente a partir de un AFD?, por qu?

Piense en aplicaciones de la vida real que pueden ser vistos como AF.

Referencias
[1] John E. Hopcroft, Rajeev Motwani, Jeffrey D. Ullman. (2002), Introduccin a la Teora de
Autmatas y Lenguajes Formales. PrenticeHall.

Prof. Hilda Contreras Teora de la Computacin - Pregrado 13