Documentos de Académico
Documentos de Profesional
Documentos de Cultura
NotasLenguajesFormalesAutomatas Camarena
NotasLenguajesFormalesAutomatas Camarena
INDICE
INTRODUCCIN..................................................................................................................3
Objetivos :...........................................................................................................................3
Justificacin :......................................................................................................................3
Usuarios:.............................................................................................................................3
Definiciones bsicas:...........................................................................................................4
AUTOMATAS FINITOS........................................................................................................4
Figura 1 Autmata finito del Ejemplo 1..................................................................................5
AUTOMATAS FINITOS INDETERMINISTAS...................................................................6
Figura2. Autmata Finito Indeterminista................................................................................7
EQUIVALENCIA ENTRE AUTOMATAS FINITOS DETERMINISTAS E
INDETERMINSTAS..........................................................................................................7
AF's CON TRANSICIONES .........................................................................................9
EXPRESIONES REGULARES...........................................................................................12
Autmatas Finitos deterministas de dos direcciones: (2DFA)..........................................16
PROPIEDADES DE LOS LENGUAJES REGULARES...............................................20
Algoritmo de minimizacin..................................................................................................21
Implementacin.....................................................................................................................21
Interfaz de usuario......................................................................................................................................23
INTRODUCCIN
La teora de autmatas y lenguajes formales son la herramienta matemtica que ha
permitido el desarrollo de compiladores, interpretes, editores e impresores de cdigo,
verificadores de cdigo y otras herramientas CASE (Ingeniera de Software Asistido por
computadora de acuerdo a sus siglas en ingls). La Materia de Lenguajes Formales y
Autmatas introduce conceptos abstractos un tanto complicados para los estudiantes de
Ingeniera, los libros de texto tradicionales para esta materia han sido escritos por
renombrados Matemticos dedicados al desarrollo de las ciencias de la computacin como
Jeffrey Ullman o Alfred V. Aho. Estas Notas fueron escritas con el afn de presentar los
conceptos de una forma ms accesible para estudiantes de Ingeniera con respecto a los
Libros Tradicionales que adems de ser difciles de conseguir, tienen un precio alto. Estas
notas incluyen ejemplos sencillos y el diseo de un software que se solicita a los
estudiantes lo desarrollen a la mitad del curso. Finalmente se presenta un simulador de
Maquinas de Turing para que puedan implementar y probar mquinas de Turing diseadas
por ellos mismos para el final del curso.
Objetivos :
1.- Conocer las tcnicas de construccin de Autmatas finitos, autmatas de pila y
Maquinas de Turing para resolver cuando una secuencia de smbolos forma parte de un
lenguaje regular, libre del contexto o recursivamente enumerables respectvamente.
2.- Implementar funciones computables mediante la mquina de Turing
Justificacin :
La Teora de Lenguajes Formales y Autmatas es la Base para desarrollo de Compiladores,
interpretes, verificadores de Software y Traductores.
Usuarios:
Estudiantes de Ingeniera en Computacin de la Facultad de Ingeniera Elctrica
Definiciones bsicas:
Un alfabeto es el conjunto de caracteres o smbolos que se utilizan en un lenguaje. A
estos smbolos les llamaremos Variables terminales o simplemente terminales.
Una cadena o cuerda consiste de la concatenacin de terminales.
La concatenacin es la operacin de poner un terminal enseguida de otro, esta
obviamente no es una operacin conmutativa aunque s es asociativa.
Un Lenguaje es un conjunto de cuerdas formadas concatenando terminales de manera que
es un subconjunto de la cerradura de alfabeto bajo la operacin de concatenacin.
Una gramtica es el conjunto de reglas que definen si una cadena pertenece al Lenguaje o
no.
AUTOMATAS FINITOS
Un Autmata finito (AF) es una mquina de estados que determina si una cadena
pertenece a o no al Lenguaje. Para decidir si la cadena pertenece al lenguaje lee los
caracteres que la forman de izquierda a derecha (A esto se le llama "La entrada") y con esta
informacin decide si debe permanecer en el estado en el que se encuentre o cambiarse a
otro estado. El AF tiene un solo estado inicial que es el estado en el que se encuentra cundo
empieza a leer la entrada y puede tener varios estado finales. Si cuando termine de leer la
entrada se encuentra en uno de estos estados finales, entonces la entrada es una cadena que
pertenece al Lenguaje. Si cuando termine de leer la entrada no queda el autmata en uno de
los estados finales, entonces la entrada no es una cadena que forme parte del lenguaje.
Formalmente, Un Autmata finito es un quinteto ordenado
(Q, , , q0 , F )
Donde:
Q.- Denota al conjunto de estados del AF
.-Denota al alfabeto
: (Qx) Q .-Mapeo de transicin entre estados
q0 .- Estado inicial
F.- Conjunto de estados finales
La parte medular del autmata radica en el mapeo de transicin entre estados. Se trata
de una serie de reglas que indican cuando el autmata cambia de un estado a otro
dependiendo del terminal ledo de la entrada. Estas son de la forma
(q, a ) p
Esta regla nos indica que si el autmata se encuentra en el estado q y en la entrada est
leyndose el terminal 'a', se debe cambiar al estado p.
Ejemplo: El lenguaje formado por todas las cadenas formadas de 0's y 1's donde no
existan dos 0's juntos se puede expresar de manera exhaustiva.
L={0,1,01,10,11,010,011,101,110,111,0101,1010,0111,1011,1101,1110,1111,...}
Cuando se describe un lenguaje de esta forma, se procura poner primero la cadena de
longitud cero (Tambin conocida como cadena vaca o ) si es que esta forma parte del
lenguaje, luego se listan las cadenas de longitud uno, enseguida todas las de longitud dos y
as sucesivamente.
Para identificar cuando una cadena de cierta longitud pertenece a este lenguaje se puede
utilizar el siguiente AF.
( q0 ,0) q1 ; ( q0 ,1) q2 ; (q1 ,0) q3 ; (q1 ,1) q2 ; ( q2 ,0) q1 ; ( q2 ,1) q2 ; (q3 ,0) q3 ; (q3 ,1) q
Sin embargo, existen autmatas finitos en los que no cumple con los requisitos para
poderla llamar funcin, es entonces simplemente una relacin entre el conjunto de parejas
ordenadas del conjunto Qx y el conjunto 2Q . Por eso le llamamos mapeo.
Los autmatas finitos indeterministas no saben en todos los estados a que estado se deben
cambiar al leer algn terminal de la entrada de forma inequvoca. Por ejemplo,
( q, a ) { p, m, n}
Ejemplo 2 Un Autmata finito Indeterminista que reconoce cadenas de 0's y 1's que
tengan al menos dos 1's consecutivos en alguna parte, es decir, el lenguaje:
L={11,011,110,111,0011,0110,0111,1100,1101,1110,1111,...}
( p,0) { p}; ( p,1) { p, q}; (q,1) {m}; (m,0) {m}; (m,1) {m};
M (Q, , , q0 , F )
Se convierte en el AF determinista
M ' (Q' , , ' ' , [q0 ], F ' )
Donde:
Q ' 2Q
Donde :
' ([ p ],0) [ p ]
' ([ p ],1) [ p, q ]
' ([ p, q ],0) [ p, m]
Puesto que
' ([ p, q ],1) [ p, q, m]
Para llevar el rastro de las transiciones que dar qualquier AF se puede generalizar
para que pueda recibir cadenas. A este mapeo modificado le llamamos y se define como
: Qx * 2 Q
De manera que:
({q1 , q 2 ,.., q n }, w) (q1 , w) ( q 2 , w) .. (q n , w)
Donde:
' ( q, a ) ( q, a ) q Q
Lo cual quiere decir que el estado q del autmata M' tendr las mismas transiciones a
otros estados como el del autmata M mas las transiciones hacia las que se puede ir del
estado q en M utilizando solamente transiciones-
10
Adems
F {q0 } si CERRADURA _ (q 0 ) F {}
F
de lo contrario
F'
( q1 ,.) {q 2 }
(q1 , E ) {q 3 , q 4 }
(q1 ,0 9) {q1 , q 2 }
(q 2 , E ) {q3 , q 4 }
(q 2 ,0 9) {q 2 }
(q 3 , ) {q 4 }
( q3 ,) {q 4 }
( q3 ,0 9) {q 5 }
(q 4 ,0 9) {q5 }
( q5 ,0 9) {q5 }
11
EXPRESIONES REGULARES
Sean L1 y L2 conjuntos de cadenas de * , la concatenacin de L1 y L2 denotada
L1 L2 es el conjunto:
L1 L2 {xy | x L1 y y L2 }
Ejemplo 6:
Si L1 {11,00} y L2 {010,11}
Entonces L1 L2 {00010,11010,0011,1111}
Tambin se puede concatenar un Conjunto consigo mismo, en cuyo caso decimos
LL L2 .
Definimos la cerradura de Kleene de un conjunto de la siguiente manera:
L*
i 0
Donde L0 { }
Es decir, el conjunto formado por cualesquier numero de concatenaciones de cadenas del
conjunto L.
La cerradura positiva se define como :
12
i 1
Entonces: L L* { }
Las expresiones regulares y los conjuntos que estas denotan se pueden definir
recursvamente como sigue:
la cadena a como expresion regular denota al conjunto {a} , es decir el conjunto formado
exclusvamente por la cadena a
Si r y s son expresiones regulares, que denotan a los conjuntos R y S respectvamente,
entonces (r+s), (rs) y r* son expresiones regulares que denotan a los conjuntos R S , RS
y R * respectvamente.
Para ahorrar parentesis, se define la jerarqua de operadores como sigue:
a) La cerradura tiene mayor jerarqua que la concatenacin.
b) La concatenacin tiene mayor jerarqua que la union.
Ejemplo 7. La exrpresin regular que denota el lenguaje del ejemplo 2, es decir aquel
que tiene al menos dos unos consecutivos es:
(0+1)*11(0+1)*
A partir de expresiones regulares es posible cosntruir un NFA con transiciones- de la
siguiente manera:
Si a se utiliza como expresin regular que denota al Lenguaje que consta de
solamente la cadena a de un solo smbolo (precsamente a ) entonces el autmata que
reconoce ese lenguage es el que se muestra aqu:
Si r es una expresion regular que denota al mismo lenguaje que el que reconoce el
autmata M y s es otra expresin regular que denota al mismo lenguaje que el que reconoce
el autmata N, entonces el Autmata que reconoce el lenguaje que genera la expresion
regular (r+s) es:
13
Si r es una expresion regular que denota al mismo lenguaje que el que reconoce el
autmata M y s es otra expresin regular que denota al mismo lenguaje que el que reconoce
el autmata N, entonces el Autmata que reconoce el lenguaje que genera la expresion
regular (rs) es:
Si r es una expresion regular que denota al mismo lenguaje que el que reconoce el
autmata M, entonces el autmata que reconoce el lenguaje denotado por r * es:
Ejemplo
El autmata que reconoce el lenguaje denotado por la expresin regular (0+1)*1 es
14
Para obtener una expresion regular equivalente a un FA, se procede como sigue:
Definiendo rijk como la expresin regular que produce el lenguaje consistente de la
cadenas que llevaran al autmata del estado i al j sin atravesar ningn estado superior al k.
Entonces, la expresin regular que buscamos es:
rijn
jF
Donde:
i.- Estado inicial del autmata
n .- Nmero de estados del autmata
Es decir, la union de reglas que generan cadenas que llevaran al autmata del estado
inicial a algn estado final, permitiendose cruzar cualquier estado.
Para calcular cualquier
rn
ij
r k r k 1 ( r k 1 )* r k 1 r k 1
ij
ik
kk
kj
ij
r 0 a si (i, a ) j
ij
r 0 si (i, ) j
ij
r0
ij
15
M (Q, , , q 0 , F )
Donde: : Q Q {L, R}
De manera que un 2DFA es un DFA que despues de cambiar de un estado a otro, se
puede mover a la izquierda en la cinta de entrada en lugar de hacerlo siempre hacia la
derecha como los FA's convencionales.
Una descripcin instantnea (ID) del 2DFA tiene la forma xqy donde x es la parte de la
cadena de entrada que se encuentra a la iquierda de la "cabeza" de lectura del autmata, q
es el estado en el que se encuentra el sutmata y y es la parte de la cadena de la entrada que
est a la derecha de la cabeza de lectura. El carcter que leer el autmata es entonces el
primero de y.
Entre dos instantneasconsecutivas se utiliza el smbolo
una ID a otra en un solo paso
I k 1
Ik
*
Usamos
para indicar que de una instantnea se puede llegar a otra en varios pasos
L(M ) {w | q0 w wp y p F )
Ej. El siguiente 2DFA reconoce cadenas formadas de 0's y 1's donde no haya dos 1's
consecutivos. Para hacerlo, recorre la cadena de entrada de iquierda a derecha y al
encontrar el primer 1 cambia al estado q1 para "recordar" que ya encontr un 1 y esta
buscando el segundo 1 recorriendo la cadena de entrada a la derecha. Al encontrar el
segundo 1 cambia al estado q 2 y cambia de sentido buscando ahora hacia la izquierda al
menos un 0, si lo encuentra regresa al estado inicial q 0 y continua su recorrido hacia la
derecha. Todos los estados son finales, es:
a) (q0 ,0) (q 0 , R)
c) (q1 ,0) (q1 , R )
e) ( q 2 ,0) ( q 0 , R )
b) (q 0 ,1) (q1 , R )
d) (q1 ,1) ( q 2 , L)
f) (q 2 ,1) (q 2 , L)
16
0q 0 100101
0100q1101
01001q 2 01
010q 2 0101
01q1 00101
0100q 0 101
0100101q1
010010q 0 1
010q1 0101
01001q1 01
q0
q0
q1
q1
q1
q2
q0
q1
q1
q2
q0
q1
Los estados "Derechos" son aquellos a los que la transicin hacia ellos tiene implcito un
avance hacia la derecha y los "Izquierdos" son los que al hacer una transicin hacia ellos
simpre se hace un avance hacia la izquierda.
Decimos que la secuencia q1 , q 2 ,..., q k verifica por la derecha a la secuencia
p1 , p 2 ,..., pl bajo el smbolo b cuando se asegura la posibilidad de que esas dos
secuencias se ubicaran a la izquierda y derecha respectvamanete bajo el smbolo b en el
diagrama de transiciones de estados para alguna cadena que forme parte del lenguaje que
reconoce el autmata comenzando por la derecha. Decimos que la verifica por la izquierda
si se comienzara por la izquierda.
Para averiguar cuales secuencias verifican a cuales bajo el smbolo b podemos seguir el
siguiente procedimiento recursivo:
Base: La cadena nula concuerda por la iquierda y por la derecha a la cadena nula
17
q1
18
q 0 , q 2 , q1
q1 , q 2 , q 0
Base
Base
(1), Regla 2 y (a)
(1), Regla 2 y (c)
(2), Regla 3 y (e)
(5), Regla 2 y (c)
Concordancias por
la derecha bajo 0
Concordancias
por la derecha
bajo 1
[q 0 ]
[q 0 ]
[ q1 ]
[ q1 ]
[ q1 ] ,
[ q1 , q 2 , q 0 ]
[ q 0 , q 2 , q1 ]
[ q1 , q 2 , q 0 ]
[ q1 ]
19
20
Algoritmo de minimizacin
( p, a ) l
Implementacin
Para el diseo e implementacin se consideran dos cosas, las estructuras de datos
para apoyar la solucin del problema, es decir la implementacin del algoritmo, y el diseo
de la interfaz de usuario tanto para la entrada de datos como para la presentacin de
resultados. El lenguaje utilizado para la implementacin fue java, ya que provee la facilidad
necesaria para manejar el uso de memoria dinmica requerida en las estructuras de datos.
Para la implementacin de la interfaz tambin provee las herramientas necesarias para tener
una flexibilidad aceptable tanto en la entrada como en la salida de datos.
Para representar el autmata original se utiliza una matriz de m x n, donde m es el
nmero de estados y por tanto los renglones de la matriz; n es el nmero de smbolos en el
alfabeto (las columnas), as pues se puede tener:
q0
.
.
qn
s1
qi
qi
qi
qi
qi
qi
qi
qi
sn
qi
qi
qi
qi
es posible tener ms de un par (qi,qj) asociado, es decir una lista que contiene pares (qi,qj).
Por otro lado, dada la forma del algoritmo solo se requiere de una matriz triangular inferior
sin la diagonal principal, por lo que una matriz cuadrada resultara un desperdicio de
memoria, por lo tanto se utiliza una lista que almacene dicha lista de pares asociados
adems de otra informacin como el hecho de saber si el par (p,q) esta marcado o no y por
supuesto que estados son p y q. De manera grfica podemos visualizar estas estructuras de
la siguiente forma:
qi,qj
1
p, q
marca
qi,qj
qi,qj
2
p, q
marca
qi,qj
p, q
marca
qi,qj
p, q
marca
qi,qj
qi,qj
p, q
marca
p, q
marca
qi,qj
qi,qj
qi,qj
qi,qj
qi,qj
Interfaz de usuario
Para la interfaz de usuario se consideran dos aspectos, la entrada y la presentacin
de resultados. La siguiente figura muestra como y donde deben introducirse los datos que
definen el Autmata Finito Determinista. El Applet cuenta con campos de edicin para
introducir: el conjunto de estados (Q), el conjunto de smbolos (S), el estado inicial (q0), el
conjunto de estados finales (F),y finalmente la funcin de transicin (Delta).
22
Como se puede apreciar el formato para definir los conjuntos es el mismo, las
etiquetas correspondientes a los estados o smbolos estn separados por comas y finalmente
por punto y coma, el nico campo que no requiere de punto y coma es el del estado inicial,
ya que solo existe uno para los AFD. Las transiciones deben estar separadas tambin por
punto y coma, en ellas se indica, entre parntesis, el estado coma el smbolo seguido de un
igual y despus el estado al que se llega.
La interfaz cuenta con dos botones, el primero de ellos (Minimizar el autmata), es
el encargado de iniciar el procesamiento de los datos y aplicar el algoritmo para
posteriormente mostrar el resultado. El segundo botn, permite cargar un ejemplo.
La salida se muestra en la siguiente figura, en ella se puede apreciar la tabla de
transiciones del autmata, as como los estados equivalentes y la matriz de equivalencia
final. Parar tener una mejor apreciacin se muestran los respectivos autmatas, el que se
produce mediante la tabla de transiciones y el que queda despus de aplicar el algoritmo de
la minimizacin. Para tener una mejor referencia de las transiciones, cada estado tiene un
color diferente, generado aleatoriamente, y tambin sus transiciones son del color
correspondiente al estado.
23
24
Donde A V y (V T ) *
Como el nmero de reglas de produccin es finito, las gramticas libres del contexto son
la mejor manera de describir lenguajes libres del contexto, los cuales son normalmente
conjunto infinitos, para saber si una cadena forma parte de un lenguaje podemos verificar si
se puede derivar a partir del smbolo inicial de la gramtica, es decir
*
L { | S
T *}
Observe que en las reglas de produccin usamos la flecha sencilla o delgada, mientras
que en las derivaciones utilizamos la flecha doble o gruesa.
Ejemplo, la siguiente gramtica describe el Lenguaje que consiste de todas las cadenas
hechas con ceros y unos que son palndromos:
G=({A},{0,1},P,A)
Donde P consiste de las siguientes CINCO reglas de produccin
A 0A0
A 1A1
A 0 |1|
Observe que la ltima lnea tiene realmente 3 reglas de produccin ya que la barra
vertical debe leerse como o, es decir, la ltima linea dice que la Variable A produce 1 o
bien 0 o finalmente la cadena vaca.
A veces obviamos la especificacin como G=({A},{0,1},P,A), y escribimos
directamente las reglas de produccin, en cuyo caso la variable que est a la izquierda de la
25
Este lenguaje por cierto no puede describirse mediante ninguna expresin regular, si
bien las gramticas regulares pueden denotar a los lenguajes regulares, las expresiones
regulares no pueden denotar a todos los lenguajes libres del contexto, ya que estos son un
superconjunto de los lenguajes regulares.
Veamos otro ejemplo de lenguaje que no puede ser descrito por ninguna expresin
regular, se trata de una gramtica que denota al conjunto de cadenas que son expresiones
algebraicas que utilizan solo a las variables algebraicas x y y.
EEE
EEE
E E/E
E E*E
E (E )
E x| y
Aqu G=({E},{+,-,*,/,(,)x,y},P,E), se trata pues de otro ejemplo donde solo se usa una
varible, este tipo de gramticas casi simpre presentan un problema que describiremos mas
adelante.
Hagamos una derivacin de la cadena x+y*x
E E E E E * E x E* x y * E x y * x
Cuando es posible realizar dos derivaciones distintas de una misma cadena, decimos que
la grampatica es AMBIGUA, la ambigedad presenta muchos problemas en la prctica,
puesto que en una aplicacin real, por ejemplo una calculadora pudiera decirnos que 3+2*3
es igual a quince en lugar de nueve ya que las gramticas como estas no proporcionan
informacin acerca de la jerarqua de operadores
26
bien, de la forma
A a donde a T
Ejemplo, convirtamos la gramtica siguiente a la FNC
A 0 A0 | 1A1 | 0 | 1
Solucin:
La primera regla de produccin A 0A0 la podemos cambiar por las tres
siguientes
A CB
B AC
C0
Las ltimas dos reglas s cumplen con la FNC, entonces la gramtica normalizada
queda:
A CB | UD | 0 | 1
B AC
C0
D AU
U 1
27
A a donde a T y V *
Es decir, todas las reglas deben de tener exactamente un terminal y este debe estar al
principio de la cadena, despus puede sigue una cadena opcional de variables de cualquier
longitud.
Para convertir una gramtica a la FNG, primero se convierte a la FNC y despus se
les asigna un orden a las variables comenzando por el smbolo inicial y luego conforme
aparecen las variables en las reglas se les va asignando un nmero mayor. Entonces, se
deben modificar las reglas de produccin para que en todas se cumpla que si Ai A j
entonces i sea menor o igual a j.
Considere por ejemplo la siguiente Gramtica, la cual ya se encuentra en la FNC:
S AA | 0
A SS | 1
Como la tercera regla no cumple la condicin de que la primera variable del lado
derecho de la regla de produccin sea mayor o igual a la variable que se encuentra del lado
izquierdo de la regla, debemos de cambiar la gramtica:
A1 A2 A2 | 0
A2 A2 A2 A1 | 0 A1 | 1
A A 1 | A 2 | ... | A r | 1 | 2 | ... | s
28
B 1 | 2 | ... | r | 1 B | 2 B | ... | r B
AUTOMATAS DE PILA
A diferencia de los autmatas finitos, estos autmatas s tienen memoria, de hecho, la
tienen organizada como su nombre lo indica de manera que el primer elemento en
almacenarse es el ltimo en recuperarse (FILO por sus siglas en ingls). Utilizan esta
memoria por ejemplo para recordar si queda algn parntesis sin cerrarse, lo cual escapa de
las capacidades de los autmatas finitos. Formalmente, un autmata de pila es:
M (Q, , , , q 0 , Z 0 , F )
Donde:
Q.- Denota al conjunto de estados
.-Denota al alfabeto de la cinta de entrada
.-Denota al alfabeto de la pila
: (Q ) Q * .- Control finito
q0 .- Estado inicial
Z 0 .- Smbolo inicial del stack
29
varias reglas
(q1 ,1, A) (q1 , UA) A
(q1 , x, A) (q 2 , A) A Deja el stack sin modificar pero se cambia de estado
(q 2 ,1, U ) (q1 , )
Verifica el uno leido despues de la x con otro uno leido antes de la
x
(q 2 ,0, C ) (q1 , )
Verifica el cero leido despues de la x con otro cero leido antes de la
x
(q 2 , , Z 0 ) (q 3 , ) Se cambia la estado final para reconocer la cadena
El autmata es M ({q 0 , q1 , q 2 , q3 }, {0,1, x}, {Z 0 , C , U }, , q 0 , Z 0 , {q3 })
Los autmatas de pila pueden reconocer al igual que los autmatas finitos por el hecho
de que al terminar de barrer la cadena que se encuentra en la cinta de entrada, el autmata
quede en un estado final, sin embargo, podemos optar por disear un autmata que no tenga
estados finales, sino que acepte una cadena como perteneciente al lenguaje por el hecho de
que al terminar de barrer la cadena que se encuentra en la cinta de entrada, el autmata
termine con la pila vaca. Esto se indica diciendo
F={}
Es decir, el conjunto de estados finales es un conjunto vaco
En realidad los dos tipos de autmatas de pila son equivalentes puesto que si se cuenta
con un autmata de pila que reconoce por estado final, lo podemos convertir a uno que
30
reconoce por stack vaco simplemente agregando reglas que tengan por efecto vaciar el
stack para cada estado final, esto es:
(q, , A) (q e , ) q F , A
( q e , , A) ( q e , ) A
smbolo R al stack
( q, , R ) ( q f , )
estado final
El autmata resultante sera evidentemente
M (Q {q i , q f }, , {R}, ' , q i , Z 0 , {q f })
Por supuesto, ' es igual a mas las reglas nuevas que acabamos de precisar.
Los autmatas de pila pueden ser indeterministas en cuyo caso
: (Q ) 2 Q
A diferencia de lo que ocurre con los autmatas finitos, donde los autmatas deterministas
y los indeterministas son equivalentes, los autmatas de pila indeterministas son mas
poderosos que los deterministas, para ejemplificar este hecho, mostraremos un autmata de
pila indeterminista que reconoce palindromos hechos con ceros y unos el cual sale del
alcance de los deterministas, recuerde que el ejemplo del autmata de pila determinista que
expusimos y que reconoce palindromos hechos de ceros y unos requera de una x que
indicaba el centro de la cadena.
El problema de no saber donde est el centro del palindromo implica que no sabemos si
el autmata debe empezar a sacar elementos del stack o los debe de seguir introduciendo,
en un autmata indeterminista esto no es problema pues se le dice al autmata que explore
ambas posibilidades. El autmata queda entonces:
31
(q 0 ,1, Z 0 ) {( q0 , UZ 0 )}
(q 0 ,0, Z 0 ) {( q 0 , CZ 0 )}
(q1 ,0, A) {( q1 , CA), ( q 2 , )} A Explora ambas posibilidades (indeterminismo)
(q1 ,1, A) {( q1 , UA), (q 2 , )} A Explora ambas posibilidades (indeterminismo)
(q 2 ,1, U ) {( q1 , )}
(q 2 ,0, C ) {(q1 , )}
( q 2 , , Z 0 ) {( q 2 , )}
Siempre y cuando ( q1 , B1 B2 Bm ) ( q, a, A)
Como caso particular Si m=0, la regla de produccin sera [q, A, q1 ] a
MAQUINAS DE TURING
Las mquinas de Turing (MT) son como los autmatas finitos de 2 sentidos, solo que a
diferencia de estos, las MTs pueden no solo leer de la cinta sino tambin escribir en ella,
como los autmatas de stack pueden almacenar datos pero en una memoria que no est
organizada en forma de pila sino que es una memoria de acceso secuencial. Formalmente,
Una Mquina de Turing es
32
M = (Q, , , , q0, B, F)
Donde:
Q.- Denota al conjunto de estados de la MT
.-Denota al alfabeto de la cinta al inicio
.-Denota al alfabeto de la cinta en cualquier momento, obviamente
: (Q ) (Q {L, R}) .-Control finito
q0 .- Estado inicial
F.- Conjunto de estados finales
B.- Smbolo que representa al Blanco en la cinta
Por ejemplo, Diseemos una Mquina de Turing que reconozca el siguiente lenguaje:
{0n1n0n | n 1}
Estrategia de solucin.
Por cada cero (0) en la cinta de entrada vamos a escribir una C, y por cada uno
(1) una U, de tal forma que, si finalmente todos los ceros y todos los unos en la cinta
han sido sustituidos por una C o una U, respectivamente, la cadena en la cinta es
aceptada. La forma de sustituir estar dada de la siguiente manera:
(1) El primer cero de izquierda a derecha sustituirlo por C
33
0
(q1,C,R)
(q1,0,R)
(q3,C,L)
(q7,0,L)
(q7,0,L)
1
(q2,U,R)
(q2,1,R)
(q4,1,L)
(q4,1,L)
(q1,U,R)
(q2,C,R)
(q3,C,L)
(q5,C,R)
(q5,C,R)
(q4,U,L)
(q4,U,L)
(q5,U,R)
(q6,B,R)
(q0,C,R)
34
original, aplicar el producto sobre ambas cantidades, dicho producto se realiza mediante la
copia de n veces n. De forma general podramos ver la operacin de n 2 como una sucesin
de pasos de la siguiente manera:
Contenido de la cinta:
01 02 0n-1 0n B B
(1.b) Adems de la P, copiar uno a uno los ceros del lado izquierdo del 1 al lado
derecho del mismo, para esto marcar con un 2 el cero a copiar, y recorrer hasta
encontrar un blanco para ponerlo ah.
P1 02 0n-1 0n
01 B
01 02 0n-1 0n B
01 02 0n-1 0n B
1er segmento de 0s
01 02 0n-1 0n 1
2 segmento de 0s
El primer segmento de ceros nos va a servir para saber las veces que faltan de
copiarse los ceros del segundo segmento a partir del ultimo blanco, cada vez que se
36
01 02 0n-1 0n 1
(3) Finalmente solo resta poner un blanco sobre el 2 segmento de ceros incluyendo los
unos que lo delimitan y tendremos en la cinta tan solo n x n = n2 en unario.
Definicin formal
Sea M = (Q, , , , q0, B, F)
La Mquina de Turing que computa
n2
Entonces:
Q = {q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11, q12, q13, q14, q15, q16, q17, q18, q19, q20, q21,}
= {0}
= {0, 1, 2, P, B}
q0 = q0
F = {q20}
=
q0
q1
q2
q3
q4
q5
0
(q1,P,R)
(q1,0,R)
(q2,0,L)
(q3,0,R)
(q4,0,L)
(q3,2,R)
B
(q2,1,L)
(q3,P,R)
(q3,1,R)
(q4,1,L)
(q6,1,L)
(q4,0,L)
(q5,2,R)
(q5,P,R)
37
(1)
q6
q7
q8
q9
q10
Q11
q12
q13
q14
q15
q16
q17
q18
q19
q20
q21
(q6,0,L)
(q7,0,R)
(q8,0,L)
(q9,0,R)
(q11,2,R)
(q11,0,R)
(q12,0,L)
(q7,P,R)
(q7,1,R)
(q8,1,L)
(q10,1,R)
(q13,1,L)
(q11,1,R)
(q12,1,L)
(q14,1,R)
(q8,1,L)
(q9,B,R)
(q12,0,L)
(q10,2,R)
(q13,0,L)
(q15,0,L)
(q16,1,L)
(2)
(q17,0,L)
(q17,0,L)
(q19,B,R)
(q18,B,R)
(q21,B,R)
(q19,B,R)
(q20,B,R)
(q9,B,R)
38
((Q7 0) (R Q7))
((Q7 1) (R Q7))
((Q7 B) (1 Q_8))
((Q_8 1) (L Q8))
((Q8 0) (L Q8))
((Q8 1) (L Q8))
((Q8 P) (B Q_9))
((Q_9 B) (R Q9))
((Q9 0) (R Q9))
((Q9 1) (R Q10))
((Q10 0) (2 Q_11))
((Q_11 2) (R Q11))
((Q10 1) (L Q13))
((Q11 0) (R Q11))
((Q11 1) (R Q11))
((Q11 B) (0 Q_12))
((Q_12 0) (L Q12))
((Q12 0) (L Q12))
((Q12 1) (L Q12))
((Q12 2) (R Q10))
((Q13 2) (0 Q_13))
((Q_13 0) (L Q13))
((Q13 1) (R Q14))
((Q14 0) (L Q15))
((Q15 1) (L Q16))
((Q16 0) (L Q17))
((Q16 B) (R Q18))
((Q17 0) (L Q17))
((Q17 B) (R Q21))
((Q18 1) (B Q_19))
((Q_19 B) (R Q19))
((Q19 0) (B Q_19))
((Q19 1) (B Q_20))
((Q_20 B) (R Q20))
((Q21 0) (B Q_9))
))
(SETQ
(SETQ
(SETQ
(SETQ
39
BIBLIOGRAFIA
[1] Suzanne Britton and Michael Britton. Turing machine simulator.
<http://www.igs.net/~tril/tm/tm.html>,December 2003.
[2] John E. Hopcroft y Jeffrey D. Ullman. Introduction to Automata Theory,
Languages and Computation. Addison-Wesley, 1979.
40
[3] Trillo Miguel Angel. Tesis de Licenciatura. Simulador de una Maquina de Turing en
LISP. 1995
[4] Alfred V. Aho y Jeffrey D. Ullman. Foundations of Computer Science. W.h. Freeman &
Company. 1994
[5] Hein, James. Concrete Structures, Logic and Computability. Jones and Bartlett
Publishers. 1995
41