Teora de Autmatas

La computacin, muy avanzada hoy en da, sienta sus bases sobre una slida plataforma
desarrollada con mucho esfuerzo e investigacin, un rea importante es el trabajo con
los lenguajes de programacin, cuyas races estn en la teora de autmatas y lenguajes
formales. Esta asignatura forma parte del rea fundamental de la carrera de Ingeniera
en Informtica correspondiente al sexto semestre. Esta asignatura tiene su importancia
en que seala los aspectos bsicos de los lenguajes computacionales, as como nos
muestra de manera general el trabajo interno de los sistemas de computacin en lo
referente al tratamiento de cadenas y lenguajes, los contenido que se cubren son
principalmente los autmatas finitos, autmatas de pila, lenguajes independientes de
contexto, maquinas de turing como reconocedores de lenguajes. Sea bienvenido al
presente curso y no dude en contactar a su profesor en caso de necesitar resolver
cualquier inquietud. Saludos y xitos!!!

Tabla de contenidos

1 Objetivo General
2 Objetivos Especificos

3 Bibliografia

4 Desarrollo del Aprendiza

o

4.1 Capitulo 1: Automatas Finitos

4.1.1 Datos Generales

4.1.2 DESARROLLO

4.1.3 Construccin de autmatas

4.1.4 Transformacin de un AFN en un AFD.

4.2 Capitulo 2 Expresiones y Lenguajes Regulares

4.2.1 Datos Generales

4.2.2 Conversin de una expresin regular en autmata finito

4.2.3 Algoritmo de transformacin de una expresin regular en un

AFN

4.3 Capitulo 3 Analisis Lexico

4.4 Capitulo 4 Automatas a Pila

4.3.1 Datos Generales

4.4.1 Datos Generales

4.5 Capitulo 5 Lenguajes Independientes de Contexto

4.5.1 Datos Generales

4.6 Capitulo 6 Maquinas de Turing

4.6.1 Datos Generales

4.6.2 Construccin de mquinas de turing

Objetivo General
Dar al estudiante una visin global del trabajo de los autmatas y su aplicacin en los
lenguajes de programacin.

Objetivos Especificos

Conocer como funcionan los lenguajes.

Especificar lenguajes regulares y autmatas finitos para reconocimiento.

Escribir programas de reconocimiento lxico.

Especificar lenguajes independientes de contexto y autmatas de pila para

reconocimiento.

Construir mquinas de turng para reconocer lenguajes.

Escribir gramticas de contexto libre.

Escribir programas de anlisis sintctico

Bibliografia
Texto Base
Hopcroft, J., et All, Introduccin a la Teora de Autmatas, Lenguajes y
Computacin, Segunda Edicin, Adison Wesley, Madrid, 2002
Este libro tiene un espectro amplio en cuanto a que cubre desde los detalles hasta
aspectos avanzados de cada tema, est expresado en trminos sencillos y solo en casos
necesarios recurre a expresar con formalismos los diferentes aspectos que trata.
Texto Complementario
Kelley, D. Teoria de Autmatas y Lenguajes Formales, Prentice Hall, Madrid
1995Escogido por los temas que cubre y principalmente por la amplia gama de
ejercicios que resuelve y plantea, ofrece un capitulo especial (el nmero cero) dedicado
a aquellos que tienen problemas con las matemticas necesarias para abordar la materia.
Su metodologa la basa en definiciones cortas, ejercicios resueltos con explicaciones
detalladas y muchos ejercicios planteados.

Construccin de autmatas
Disear un AFD que acepte identificadores que inicien siempre con un guin bajo y
luego puedan contener letras o dgitos.
Inicialmente debemos asociar la condicin inicial al estado inicial, esto significa que
desde el primer estado al segundo estado nicamente puede existir una transicin que
etiquetada con guin bajo

Una vez en el estado dos, se puede avanzar hacia el estado tres con una transicin
etiquetada con letra (L) o con digito (D).

Ahora es necesario que la cadena pueda tener mas letras o ms dgitos, esto se puede
conseguir haciendo que desde el estado 3 salga una arista etiquetada con letra (L) hacia
otro estado (que puede ser el mismo estado 3). Lo mismo hay que hacer para reconocer
ms dgitos.

Desarrollemos ahora otro autmata que reconozca cadenas de letras (sobre el alfabeto
{a,b}) en las que nunca puedan ir dos as seguidas
La condicin inicial no esta asociada al estado inicial, el autmata puede empezar con
una letra a o con una letra b

Ahora puede tener otra letra b con la que regresa al estado 1. Note que siempre termina
en el estado 2.

Es posible construir autmatas que tengan

transiciones vacas, es decir que sus aristas no tienen como etiqueta smbolos del
alfabeto del autmata, en su lugar tienen vaco (), generalmente las transiciones vacas
se utilizan para unir autmatas, como en el caso de la figura 2.19 de la pgina 81 del
texto base.
Transformacin de un AFN en un AFD.
El procedimiento consiste en agrupar los conjuntos de estados que tengan entradas y
salidas (aristas) comunes, para ello se crea una tabla de transiciones (representacin del
AFD), esta matriz (llamada Matriz_de_D) tiene como ndices el conjunto de estados
(con aristas comunes) y los elementos del alfabeto.
Son necesarias tres operaciones cuyos resultados se requieren al aplicar el algoritmo de
transformacin:
Cerradura- de s.- Equivale al conjunto de estados del AFN que se pueden alcanzar desde s sin consumir smbolos de la entrada (o lo que es lo mismo con transiciones-e). Esta
operacin devuelve un conjunto de elementos (estados).
Cerradura-e de T.- Sea T un conjunto de estados, esta operacin equivale al conjunto de
estados del AFN que se pueden alcanzar desde cada s en T sin consumir smbolos de la
entrada (o lo que es lo mismo con transiciones-e). Esta operacin devuelve un conjunto
de elementos (estados).
Mueve (T, a).- Equivale al conjunto de estados que se pueden alcanzar con un smbolo a
(arista etiquetada con a ) desde algn estado s de T. Esta operacin devuelve un
conjunto de elementos (estados).
En caso de tener problemas, recuerde que s es un estado; T es un conjunto de estados en
donde cada uno en su momento se representa por s; a es un smbolo que etiqueta una
arista que va desde un estado a otro.
Por conveniencia se denominan el AFN como N y el AFD como D.
Algoritmo 1. Inicio 2. A = Cerradura- de s0 /* Cerradura vaca del estado inicial del
AFN */ 3. Agregar A al conjunto Estados_de_D /* Se crea un conjunto con el elemento
A */ 4. Para cada conjunto del conjunto Estados_de_D /* Se recorre ese conjunto */ 5. T
= Conjunto del conjunto Estados_de_D /* Se toma un elemento */ 6. Para cada
elemento del alfabeto 7. a := elemento del alfabeto 8. U = Cerradura-e (mueve(T, a)) 9.
Si U no est en Estados_de_D 10. Agregar U a Estados_de_D 11. FinSi 12.
Matriz_de_D[T, a] := U 13. FinPara 14. FinPara 15. Fin_del_algoritmo
Como ejercicio vamos a tomar el diagrama del autmata no determinista siguiente:
Insertar Grafica

A=Cerradura vacia de S0
A={0}

Del estado 0 solo se puede llegar a

0
sin consumir smbolos de entrada

Estados_de_D={A}
T=A={0}

T=A={0}

a = a

a = b

U=Cerrad-vacia(Mueve(T,a))

U=Cerrad-vacia(Mueve(T,a))

U=Cerrad-vacia(Mueve(0,a))

U=Cerrad-vacia(Mueve(0,b))

U=Cerrad-vacia(1)

U=Cerrad-vacia(vacio)

U={1,2,3,5,8}=B

U=vacio; no se lo considera

a b
A B
B
Se llena la
matriz con las
entradas
(A,a)=B

Estados_de_D={A, B}
T=B={1,2,3,5,8}

T=B={1,2,3,5,8}

a = a

a = b

U=Cerrad-vacia(Mueve(T,a))

U=Cerrad-vacia(Mueve(T,a))

a b
A B
B CD

Se llena la
U=Cerrad-vacia(Mueve(1,2,3,5,8, U=Cerrad-vacia(Mueve(1,2,3,5,8, matriz con
a))
b))
las entradas
U=Cerrad-vacia(4,9)
U=Cerrad-vacia(6)
(B,a)=C y
U={2,3,4,5,7,8,9}=C

U={2,3,5,6,7,8}=D

(B,b)=D

Estados_de_D={A, B, C, D}
a b
T=C={2,3,4,5,7,8,9}

T=C={2,3,4,5,7,8,9}

a = a

a = b

U=Cerrad-vacia(Mueve(T,a))

U=Cerrad-vacia(Mueve(T,a))

U=Cerradvacia(Mueve(2,3,4,5,7,8,9, a))

U=Cerradvacia(Mueve(2,3,4,5,7,8,9, b))

Se llena la
matriz con

U=Cerrad-vacia(4,9)

U=Cerrad-vacia(6,10)

U={2,3,4,5,7,8,9}=C (se repite)

U={2,3,5,6,7,8,10}=E

las entradas
(C,a)=C y

A B
B CD
C CE

(C,b)=E
Estados_de_D={A, B, C, D, E}
T=D={2,3,5,6,7,8}

T=D={2,3,5,6,7,8}

a b
A B

B CD
a = a

a = b

U=Cerrad-vacia(Mueve(T,a))

U=Cerrad-vacia(Mueve(T,a))

C CE
D CD

U=Cerrad-vacia(Mueve(2,3,5,6,7,8, U=Cerrad-vacia(Mueve(2,3,5,6,7,8 Se llena la

matriz con
a))
b))
U=Cerrad-vacia(4,9)

U=Cerrad-vacia(6)

U={2,3,4,5,7,8,9}=C (se repite)

U={2,3,5,6,7,8}=D (se repite)

las entradas
(D,a)=C y
(D,b)=D

Estados_de_D={A, B, C, D, E}
a b
T=E={2,3,5,6,7,8,10}

T=E={2,3,5,6,7,8,10}

a = a

a = b

U=Cerrad-vacia(Mueve(T,a))

U=Cerrad-vacia(Mueve(T,a))

U=Cerradvacia(Mueve(2,3,5,6,7,8,10, a))

U=Cerradvacia(Mueve(2,3,5,6,7,8,10, b))

U=Cerrad-vacia(4,9)

U=Cerrad-vacia(6)

U={2,3,4,5,7,8,9}=C (se repite)

U={2,3,5,6,7,8}=D (se repite)

A B
B CD
C CE
D CD
E CD
Se llena la
matriz con
las entradas
(E,a)=C y
(E,b)=D

Al graficar la matriz, el autmata resultante es el siguiente:

Capitulo 2 Expresiones y Lenguajes Regulares

Conversin de una expresin regular en autmata finito

Como conclusin de lo hasta ahora visto, es posible expresar mediante una expresin
regular un lenguaje regular, por lo que ahora nos vamos a centrar en un proceso de
transformacin de una expresin regular a un autmata finito no determinista. El
algoritmo que se presenta ms adelante, se basa en el orden que tiene la construccin de
la expresin regular y toma cada uno de sus componentes por separado, construyendo
un AFN para cada componente; estos AFN se unifican en el mismo orden en que se
expresa la expresin regular, dando como resultado un AFN que reconoce el lenguaje
que genera la expresin regular en cuestin.
Algoritmo de transformacin de una expresin regular en un AFN

Para cada uno de los componentes sintcticos de la E-R ejecutar los pasos uno y dos
Paso uno) Para (vaco) construya el autmata correspondiente.

Paso dos) Para cada smbolo a independiente de la expresin regular construya su

autmata correspondiente.

En los dos casos i es el estado inicial y f el estado final o de aceptacin de la

subexpresin.
Combinar los autmatas resultantes de acuerdo a las guas del paso tres.
Paso tres) Si Se tiene dos AFN para las expresiones s y t
a) Para la expresin s . t construya el autmata finito siguiente:
Insertar Imagen
d) Para la expresin regular (s) (entre parntesis) utilice el AFN que diagram para s
Ejemplo: Para la expresin regular a (a + b)* ab obtener el AFN
Paso uno y paso dos)
Las expresiones que forman parte de la expresin regular son:
1. a
2. a
3. b
4. a
5. b
Note que para cada componente se requiere un AFN independiente.
Autmata para el componente 1

Autmata para el componente 2

Autmata para el componente 3

Autmata para el componente 4

Autmata para el componente 5

Paso 3)
Combinacin de los autmatas a + b

Obtencin de (a U b)*

Concatenacin de a con (a U b)*

Concatenacin de a (a U b)* con a

Capitulo 3 Analisis Lexico

Para el desarrollo de este capitulo, no hace falta trabajar con el texto gua, trabajaremos
nicamente con la gua didctica, pero es necesario que primero lea el anexo A.
Inicialmente veremos que es el anlisis lxico, para lo cual es necesario comprender
cual es el trabajo de un compilador y cuales son sus partes: Un compilador es un
programa que convierte un programa escrito en un lenguaje de alto nivel en un
programa en cdigo objeto y luego en ejecutable. Ejemplo: Cuando usted escribe un
programa en lenguaje C++, antes de hacerlo funcionar(correr) debe convertirlo en

ejecutable, para ello utiliza un compilador. El compilador se encarga de verificar que no

tenga errores y luego lo convierte en ejecutable (con extensin .EXE)
El compilador cumple los siguientes tres pasos:
1. Verificacin de errores del programa fuente(cdigo de alto nivel)

Verificacin de errores lxicos q Verificacin de errores sintcticos q

Verificacin de errores semnticos
Transformacin del cdigo de alto nivel en cdigo objeto

Transformacin del cdigo objeto en cdigo maquina(ejecutable)

Lo anterior significa que el compilador esta formado por los siguientes mdulos:

Modulo lxico.- Encargado de verificar que no existan errores lxicos

Modulo sintctico.- Encargado de verificar que no existan errores sintcticos

Modulo semntico.- Encargado de verificar que no existan errores semnticas

Modulo generador de cdigo objeto.- Encargado de convertir el programa fuente

en programa objeto(cdigo ensamblador)

Encadenador.- Encargado de convertir el programa objeto en cdigo o maquina

programa ejecutable(unos y ceros)

Esquema de mdulos de un compilador

Como conclusin podemos anotar que el analizador lxico (o modulo lxico) se encarga
de verificar que todas las palabras escritas en el programa fuente pertenezcan al
lenguaje de alto nivel en el que se escribe el programa. Ejemplo: Dado el programa
int main() {
int b=10;
cout << a+b;
retur 0;
}
El analizador lxico debe detectar que a+b es un error lxico porque a no ha sido
declarada como variable.

De igual forma en la lnea retur 0, el analizador lxico detectar que retur no es una
palabra reservada (le falta una n al final)
Ya sabemos cual es la tarea de un analizador lxico, ahora veamos cuales son sus etapas.
Una vez escrito un programa fuente, para compilarlo(transformarlo), es necesario
abrirlo y empezar a leerlo, luego se deben ir concatenando (uniendo) cada uno de sus
caracteres para formar cadenas y a su vez hay que comprobar que cada cadena
pertenezca al lenguaje en cuestin. Suponga que el lenguaje en cuestin es C++.
Entonces hay que verificar que cada una de las cadenas del programa fuente sea una
palabra reservada o un identificador. Observemos el programa:
1.

int main() {

2.

int b=10;

3.

cout << a+b;

4.

return 0;

5.

En la lnea 1 del archivo (quiero decir del programa) se van uniendo los caracteres i, n y
finalmente la t para formar la cadena int (sabemos que la cadena termina en t por el
espacio que le sigue separador) y luego hay verificar si esta cadena es una palabra
reservada de C++ o es un identificador, caso contrario tendremos un error de tipo lxico.
De igual manera procedemos con la cadena main, en lo que respecta a los parntesis, el
analizador debe ser lo suficientemente inteligente como para entender que son smbolos
independientes de la cadena main y cuando los reconozca, debe retornar un indicador
adecuado que permita saber que se reconoci un parntesis.
Para comparar, es necesario que las palabras reservadas estn guardadas en alguna
estructura, conceptualmente se maneja el termino tabla de smbolos, en ella se guardan
las palabras reservadas y los identificadores(variables) que se declaran, cuando el
analizador lxico forma una cadena, esta se compara con los elementos almacenados en
esta tabla de smbolos. Primero se busca si es palabra reservada, si no es, se busca si es
alguna variable ya declarada.
Resumiendo, podemos decir que las etapas del anlisis lxico son:

Apertura del archivo.

Lectura de sus caracteres.

Concatenacin de caracteres.

Comparacin de las cadenas que se forman con los elementos de la tabla de

smbolos.

Retorno de un indicador de la cadena reconocida, tambin llamado token.

Especificacin de componentes lxicos

Cuando se disea un lenguaje de programacin, es necesario definir cuales sern las

palabras reservadas, que forma tendrn los identificadores, que formato tendrn los
valores numricos, etc. Esto depende del tipo de aplicacin que se le vaya a dar al
lenguaje de programacin, por ejemplo si se quiere construir un lenguaje C++, ser
necesario incluir palabras como int, main, return, etc. Se debe definir que los
identificadores inicien con una letra o con un nmero o con guion bajo y luego puedan
contener letras o nmeros, as mismo los valores numricos deben iniciar con un
nmero, luego debe n tener un punto decimal y luego pueden tener ms nmeros.
Las palabras reservadas sern fijas, pero los identificadores y valores numricos pueden
ser especificados con una expresin regular. Observe el siguiente ejemplo:
l d _ (l d ) (l d _)
Con esta expresin regular estamos indicando que los identificadores pueden iniciar con
una letra o con un digito o con un guion bajo, luego deben tener una letra o un digito y
despus pueden tener letras, dgitos o guiones bajos.
En el caso de los valores numricos, se puede especificar su formato con la siguiente
expresin regular:
(d+.d+) (d+)
Estamos indicando que pueden empezar con uno o mas nmeros, seguidos de un punto
decimal y luego tener mas dgitos, o tambin pueden ser solamente nmeros(sin punto
decimal).
Recuerde que el smbolo (lnea) significa o (para escoger una u otra opcin).
En el siguiente cuadro se indica la diferencia entre lexema y componente lxico y token:
En el siguiente cuadro se indica la diferencia entre lexema y componente lxico y token:
Lexema

Componente Lexico Token

Velocidad ID

ID

10

NUM

NUM

Int

int

Int

Observe que el lexema es la cadena que se encuentra en el archivo fuente, el

componente lxico es una clasificacin a la que pertenece el lexema y finalmente el
token es el valor que retorna el analizador lxico una vez que reconoci un lexema. El
token tambin puede ser un cdigo que el diseador le asigne a cada componente lxico.
Concluyendo, los componentes lxicos se especifican a travs de expresiones regulares,
las mismas que luego deben ser programadas en el analizador lxico.
Reconocimiento de componentes lxicos
Con el fin de facilitar el entendimiento, vamos a dividir el reconocimiento de
componentes lxicos en categoras (esto no es normal, sin embargo es til), las
categoras en las que podemos trabajar son:

Palabras reservadas

identificadores

Valores numricos

En todos los casos vamos a utilizar una tabla de smbolos (TDS), esta es una estructura
que permite guardar informacin acerca de los componentes lxicos. Normalmente es
una lista ligada con algunos atributos, observe la siguiente figura:

Lista ligada que representa una tabla de simbolos

La TDS es una estructura donde normalmente estn guardadas todas las palabras
reservadas del lenguaje de programacin que se construye. El campo com_lex es el
espacio en donde se guardan todas las palabras reservadas o los identificadores que
forman parte del programa, el campo valor sirve para guardar los valores que puedan ir
tomando las variables y el campo tipo sirve para indicar el tipo de dato que le
corresponde a cada variable. En trminos generales lo que el analizador lxico hace es
formar una cadena con los caracteres del programa fuente y compararla con cada una de
los nodos de la estructura. Normalmente la bsqueda (para la comparacin), se da a
travs de algn tipo de hash o utilizando en lugar de una lista ligada un rbol B, con lo
que se acelera la bsqueda. Para reconocer las palabras reservadas, el diseador del
lenguaje de programacin puede optar por una expresin regular como la siguiente:
letra+
Que significa que una palabra reservada puede estar formada por una o mas letras.
Esta expresin regular transformada en seudocdigo puede quedar como sigue:
Abrir archivo fuente Mientras no sea fin de archivo /*****Con las siguientes 4 lneas
vamos a formar la cadena sea la palabra reservada
Vaciar la variable c /* inicializarla con vaci
Leer el siguiente carcter

Si el carcter es una letra

Mientras el carcter es diferente de espacio
Agregar el carcter a c /* c es una variable */
Leer el siguiente carcter
Fin mientras
Fin si
/*****Ahora lo vamos a buscar en la TDS
Si el valor de c se halla en la TDS
Retornar c /* que es el token de la palabra reservada
Si no
Retornar ID /* que es el token para un identificador
Fin si
Fin mientras
Cerrar archivo
Como recordaran, el modulo lxico reconoce cadenas y retorna el token (smbolo) que
las identifica, en el seudocdigo anterior se retorna ID en el caso de las palabras
reservadas y se retorna la cadena misma, es decir la palabra reservada, en este caso es
igual al token.
Para reconocer identificadores, podemos utilizar la siguiente expresin regular:
Ld _ (Ld)(Ld_)
Note que el smbolo significa o
Se puede empezar con letras, dgitos o guin bajo, como segundo carcter del
identificador puede ir una letra o un digito y de ah en adelante puede ir una letra, un
digito o un guin bajo. Esa expresin regular puede representarse en pseudocdigo
como se muestra a continuacin.
Abrir archivo fuente
Mientras no sea fin de archivo /*****Con las siguientes 4 lneas vamos a formar la
cadena sea la palabra reservada
Vaciar la variable c /* inicializarla con vaci
Leer el siguiente carcter

Si el carcter es una letra o un digito o un guion bajo

Mientras el carcter es letra o es digito o es guion bajo
Agregar el carcter a c /* c es una variable */
Leer el siguiente carcter
Fin mientras
Fin si /*****Ahora lo vamos a buscar en la TDS
Si el valor de c se halla en la TDS
Retornar c /* que es el token de la palabra reservada
Si no
Retornar ID /* que es el token para un identificador
Fin si
Fin mientras
Cerrar archivo
Con el cdigo escrito podemos notar que no existe una forma de asegurarnos que el
segundo carcter no sea un guin bajo, por lo que en ocasiones el cdigo es algo mas
difcil de implementar. Ante esto surge la necesidad de programar un autmata como
veremos a continuacin.

Autmata para reconocer identificadores en C++

Observe que el reconocimiento inicia en el estado cero y desde ah se puede leer una
letra o un digito (un nmero) o un guin bajo, se llega al estado uno y desde ah leyendo
letra o digito se traslada al estado dos, en donde se pueden leer letras dgitos o guiones,
en cualquier caso sern identificadores vlidos. Este autmata se puede programar,
observe el siguiente procedimiento:

Inicio
Abrir archivo
Variable estado igual cero (estado=0)
Variable c igual vaco (c=)
Mientras no sea fin de archivo y c sea diferente de espacio
Leer el siguiente carcter en c
En caso de que estado
Sea cero y c sea letra o digito o guin
Estado es igual a uno
Sea uno y c sea letra o digito
Estado es igual a dos
Sea dos y c sea letra o digito o guin
Estado es igual a dos
En cualquier otro caso Error lxico y terminar
Fin de caso
Fin mientras
Retornar ID
Cerrar archivo
Fin
Es posible programar autmatas para cualquier expresin regular, sin embargo cuando
se trata de lenguajes de programacin complejos, podemos hallarnos con dificultades en
el reconocimiento de los componentes lxicos. A continuacin se presenta un algoritmo
tomado del texto Compiladores tcnicas y herramientas del Dr. Alfred Aho, el mismo
que resume de manera sencilla los diferentes aspectos que se deben tomar en cuenta al
implementar un analizador lxico.
function analex: integer;
var buflex array[0..100] of char /* arreglo de longitud 100
c char;
begin

loop begin
lee un carcter en c
if c es un espacio en blanco o un smbolo tab then
no hacer nada;
else if c es un carcter de lnea nueva then
numlinea :=numlinea + 1;
else if c es un digito then begin
asignar a valcomplex el valor de este y los dgitos siguientes;
return NUM;
end
else if c es una letra then begin
poner c y las letras y dgitos sucesivos en buflex;
buscar buflex en la TDS
if buflex no esta en la TDS then begin
insertar buflex en la TDS
return ID
end
end
else begin
asignar NINGUNO a valcomplex;
return el numero entero del carcter c;
end
end
end
La tarea es hacer funcionar de forma manual este algoritmo utilizando un archivo que
contenga cadenas de caracteres.

Capitulo 4 Automatas a Pila

Capitulo 5 Lenguajes Independientes de Contexto

Capitulo 6 Maquinas de Turing

Construccin de mquinas de turing

A continuacin se presentan ejemplos de construccin de mquinas de turing: Escriba
una mquina de Turn que reconozca cadenas de unos y ceros alternados que siempre
inicien en uno y siempre terminen en cero (01)+
La recomendacin est en iniciar definiendo la funcin de trancisin, luego se pueden
definir los elementos restantes de la mquina:
La maquina siempre inicia en el estado q0, y la cadena que reconoce, siempre inicia con
0:
(q0, vacio) =
Inicio del trabajo de la mquina
(q1, vacio, D)
(q1, 0) = (q2, 0, Inicia reconociendo el cero de la cadena, lo escribe en la cinta y se
D)
mueve hacia la derecha
(q2, 1) = (q1, 1, Cuando encuentra un uno, regresa al estado q1 para volver a reconocer
D)
un cero
En el estado q1 puede encontrar el smbolo en blanco que indica que la
(q1, blanco) =
cadena se termino, en ese caso regresa una posicin y se mueve al estado
(q3, blanco, I)
3 en donde se reconoce la cadena.
Note que en el estado q1 puede reconocer un cero lo que indica que
la cadena continua o puede encontrar un smbolo en blanco lo que

indica que la cadena termina

Ahora definimos los elementos restantes de la mquina:
Estados = {q0, q1, q2, q3}
Alfabeto de la cinta = {0,1, blanco}
Alfabeto = {0,1,}
Estado inicial = {q0}
Estado final = {q3}
Diseemos ahora una mquina que acepte comentarios en lenguaje c, recuerde que los
comentarios en lenguaje c son de este tipo:
/* Aqu va el comentario */
El contenido del comentario puede ser cualquier smbolo, al que llamaremos c
Este smbolo no puede ser el *
Igualmente definamos primero la funcin de transicin:
(q0, vacio) = (q1,
vacio, D)

Inicio del trabajo de la mquina

(q0, vacio) = (q1,

vacio, D)

Inicio del trabajo de la mquina

(q1, /) = (q2, /, D)

Inicia reconociendo el / de la cadena, lo escribe en la cinta y se

mueve hacia la derecha

(q2, *) = (q3, *, D)

Cuando encuentra un *, avanza para seguir el reconocimiento

(q3,c) = (q3, c, D)

En el estado q3 puede estar leyendo muchos smbolos cualquiera a

excepcin del *

(q3,*) = (q4, *, D)

Cuando en el estado q3 encuentra un *, se prepara para a

continuacin recibir un /

(q4,/) = (q5, /, D)

Cuando en q4 recibe un /, se prepara para terminar de reconocer la

cadena

(q5, blanco) = (q6,

blanco, I)

En el estado q5 puede encontrar el smbolo en blanco que indica

que la cadena se termino.

Ahora si completamos la mquina

Estados = {q0, q1, q2, q3,q4,q5,q6}

Alfabeto de la cinta = {/,*,c,blanco}

Alfabeto = {/.*,c}
Estado inicial = {q0}
Estado final = {q6}
JC T/mc-16-02-07-39