Autómatas Finitos (AF)

-- Introducción --

Índice

1 Definición formal
2 Representación gráfica
2.1 AF como Grafo
2.2 Función de transición
3 Comportamiento
4 Tipos de AFs
4.1 AF Determinístico (AFD)
4.1 AF No Determinístico (AFN)
5 Programa Java de un AFD
6 Bibliografía

Un Autómata Finito (AF) o máquina de estado finito es un modelo matemático para un

sistema reconocedor de lenguajes que realiza cómputos en forma automática leyendo cadenas
de símbolos provenientes de una cinta de entrada infinita para producir una salida que consiste
en informar si reconoce una cadena. El AF realiza los cómputos mediante una función de
transición que lo define y la cinta de entrada se encuentra dividida en celdas que contienen de
a un símbolo a la vez. El AF lee la cinta de entrada de izquierda a derecha de a un símbolo a la
vez.

Es de anotar, que la cinta de entrada es independiente del autómata y que su función es

únicamente el almacenamiento de símbolos. La representación simplificada de un AF se
muestra a continuación.

Figura 1. Representación simplificada de un AF

Definición formal

Un autómata finito es una 5-tupla con los siguientes componentes:

AF P = (Q, Σ, q0, δ, F) donde:

Q : Conjunto finito de los estados que lo componen

∑ : Conjunto de símbolos del alfabeto de entrada que son reconocidos .
q0 : Estado inicial, donde q0 Є Q
δ : Función de transición, donde δ: Q X ∑  Q
F : Conjunto de estados finales o de aceptación, donde F Є Q.

Representación gráfica

AF como Grafo
Un AF es un grafo finito que empieza en un estado inicial y tiene una serie de transiciones de
estado en estado definidas por la función de transición, hasta que llega a uno o más estados
de aceptación. Es de anotar, que un estado de aceptación de un AF no es necesariamente
absorbente, es decir que puede salir de este tipo de estado con transiciones si así lo permite su
función de transición.

Por definición, un AF es un reconocedor de lenguajes por lo cual para plantearlo es necesario

determinar inicialmente que tipo de cadenas de caracteres reconocerá, lo cual se asocia
directamente con el alfabeto de símbolos ∑ que las componen. En este contexto, el lenguaje a
reconocer por parte de un AF puede ser generado por medio de una expresión o definición
regular, como se muestra a continuación:

Ejemplo 1. Plantear un AF que reconozca las cadenas generadas por la definición

regular id  letra(letra|dígito)*

Inicialmente se debe identificar el alfabeto de entrada ∑ sobre el cual se basa la

definición regular y que será adoptado por el AF. En este caso ∑ = {letra, digito}.
Luego, hay que tener claridad sobre el lenguaje generado por la definición
regular. En este caso, el lenguaje generado está compuesto por cadenas "que
 inician con una letra seguida de cualquier combinación de letras y/o dígitos de
longitud variable". Un AF para id que reconoce el lenguaje descrito es:

id  letra(letra|dígito)*

Definición: P = ({0, 1, 2, 3}, {digito, letra}, 0, δ, {1, 2, 3})

Como se pude observar de la gráfica el AF presenta varias características que pueden

ser generalizadas:

 Tiene un único estado de inicio, en esta caso el estado 0.

 Tiene varios estados intermedios: 0, 1, 2, 3.
 Los estados 1, 2 y 3 que tienen una representación diferente indican varios
estados finales, de los cuales pueden haber más transiciones.
 Las transiciones ocurren únicamente con presencia de una letra o un dígito, es
decir en los símbolo de ∑.
 Los estados 2 y 3 presentan transiciones sobre sí mismos, y sobre símbolos de
∑.
 La función δ: Q X ∑  Q indica que las transiciones deben ser definidas por la
pareja ordenada (estado, símbolo) la cual permite identificar a su vez al estado
al cual se efectúa dicha transición. Como se indica en el grafo, del estado 0
únicamente es posible una transición hacia el estado 1 con el símbolo letra, lo
cual se puede indicar como (0, letra)  1. En este caso obsérvese que la
transición (0, digito)  1 no está definida, por lo cual no se indica en el grafo.
Función de transición

En forma semejante a como un grafo es la representación gráfica de una matriz o lista de

adyacencia, un AF es la representación gráfica de una función de transición, que relaciona
como se constituyen sus cómputos. A continuación se relaciona la función de transición del
autómata en referencia.

Función de transición δ AF
Símbolo de
entrada Є ∑
Estado
letra digito
0 1 error
1 2 3
2 2 3
3 2 3

Como se pude observar de la gráfica el AF y la función de transición:

 Todos los estados del autómata que se representan en la columna "Estado", son únicos
y se grafican en el AF.
 Todas las transiciones se efectúan con un único símbolo que debe pertenecer a ∑. En
el AF los símbolos se muestran identificados en cada arco.
 La función δ: Q x ∑  Q indica las transiciones (estado, símbolo)  estado válidas en
el AF. Obsérvese que la transición (0, letra)  1 es una transición válida, la cual se
indica en la función de transición y en el AF. Por el contrario, la transición (0, digito) no
se encuentra definida, y se identifica en la función de transición con "error" y no se
muestra en al AF.
 La función δ define al AF.

Comportamiento

El comportamiento de un AF hace referencia al proceso de identificación de una cadena de

caracteres e informar si la reconoce de acuerdo a su función de transición, es decir a cómo
computa.
En este contexto, definimos el cómputo de un AF con las siguientes acciones que efectúa sobre
la cadena de entrada. Luego el AF, una vez inicializado su estado en 0:

 Lee un carácter en la posición actual de la cinta de entrada

 Avanza una celda a la derecha en la cinta de entrada
 Cambia de estado con el símbolo leído

Para el AF definido en el presente ejemplo, sea la cadena "cuenta1". Verificar que el AF de id

la reconoce. El modelo simplificado del autómata presentada en la Figura 1, instanciándolo a
este ejemplo se convierte en:

El proceso de reconocimiento se basa en la pareja (estado, símbolo) de la siguiente manera:

Estado Símbolo de
#Itera actual Transición Acepta
Entrada
1 0 c 1 si
2 1 u 2 si
3 2 e 2 si
4 2 n 2 si
5 2 t 2 si
6 2 a 2 si
7 2 1 3 si

La 5-tupla (Q, Σ, q0, δ, F) para este AF id es: id = ({0, 1, 2, 3}, {letra, digito}, 0, δ, {1, 2, 3})

donde δ:
 Símbolo de
entrada
Estado
letra digito
0 1 --
1 2 3
2 2 3
3 2 3

Ejemplo 2. Plantear un AF que reconozca las cadenas generadas por la definición regular
id  letra(letra|dígito)*

Función de transición δ
Símbolo de
Estado entrada Є ∑
letra digito
0 1 error
1 1 1

El modelo simplificado del autómata presentada en la Figura 1, instanciándolo a este ejemplo

se convierte en:
El proceso de reconocimiento se basa en la pareja (estado, símbolo) de la siguiente manera:

Símbolo de
#Itera Estado Entrada Transición Acepta
1 0 c 1 si
2 1 u 1 si
3 1 e 1 si
4 1 n 1 si
5 1 t 1 si
6 1 a 1 si
7 1 1 1 si

La 5-tupla (Q, Σ, q0, δ, F) para este AF id es: id = ({0, 1}, {letra, digito}, 0, δ, {1})

donde δ:

Símbolo de
Estado entrada
letra digito
0 1 error
1 1 1

A pesar de que los dos autómatas analizados tienen estructuras diferentes, son equivalentes
debido a que reconocen el mismo lenguaje.

Tipos de AFs

Los AFs pueden ser determinísticos (AFD) o no determinísticos (AFN), donde el término "no
determinístico" significa que en un estado se pude dar el caso de tener más de una transición
para el mismo símbolo de entrada1 además de poder presentar transiciones con Є. Un AFD por
su parte, pude dar reconocedores más rápidos y directos que su versión de AFN, aunque el
primero puede ser mucho mayor. Esta diferencia se indica en la función de transición δ, la cual
como para un AFD es δ: Q x ∑  Q donde el rango Q toma un solo estado. Por su parte, δ
para un AFN es δ: Q x ( ∑ U Є )  Q donde el rango Q puede tomar más de un estado, es
decir un subconjunto de Q. En este contexto se considera que un AFD es un caso especial de
AFN.
Como ya se anotó anteriormente, el lenguaje a reconocer por parte de un AF puede ser
generado por medio de una expresión o definición regular. En este sentido, realmente la
creación de un AF a partir de una expresión o definición regular da como resultado un AFN.
Luego, por facilidad de programación y por razones de velocidad de computo, un AFN se debe
convertir por su equivalente AFD el cual se programa en un lenguaje. Es de anotar, que el AF
que se ha relacionado anteriormente como ejemplo es realmente un AFD.

Programa Java de un AFD

El siguiente programa en Java y codificado en Eclipse corresponde al AFD proveniente de la

definición regular id  letra (letra|digito)* que se muestra a continuación, junto con su δ.

Expresión Regular: AFD: Función de transición δ:

id  letra(letra|digito)* Símbolo de
entrada Є ∑
Estado
letra digito
0 1 --
1 1 1

El programa correspondiente al AFD es:

public class ClaseDePrueba {

public static void main(String[] args) {

new Algoritmo("cuenta1");
}
}

La cadena de entrada se pasa como parámetro al constructor de la clase algoritmo.

public class Algoritmo {

String lexema;
int estado;
boolean estadoAcepta;
int estadoError;
int inicioCadena;
int posLectura[ ];

public Algoritmo(String cadena){

 posLectura = new int[1];
lexema=cadena;
estadoAcepta=false;
estado=0;
estadoError=0;
posLectura[0]=0;
proceso();
}

public void proceso(){

boolean valido;
int inicioCadena=1;

valido = automataID();

System.out.println("Cadena: "+lexema);

if (valido) System.out.println("El lexema "+lexema+" es ID");

else {
estado=0;

valido=automataOperaMate();

if (valido){
for(int k=inicioCadena-1;k<posLectura[0];k++)
System.out.print(lexema.charAt(k));
System.out.println(" es ID ");
System.out.print(lexema.charAt(posLectura[0])+" es OPMAT");
}
else
System.out.println("error lexico en " +lexema.charAt(posLectura[0]));
}
}

boolean automataID(){

char caracter;

for (int i=inicioCadena;i<lexema.length();i++){

caracter=lexema.charAt(i);
if(Character.isLetter(caracter) && estado==0){
estado=1;
estadoAcepta=true;
}
else
if(Character.isLetterOrDigit(caracter) && estado==1){
estado=1;
estadoAcepta=true;
}
else{
estadoAcepta=false;
posLectura[0]=i;
break;
}
}
return estadoAcepta;
}

boolean automataOperaMate(){

if (estado==0 && lexema.charAt(posLectura[0])=='/') return true;

else return false;
}
}
Bibliografía

[1] Aho, a. V., Sethi, R., & Ullman, J. D. (2008). Compiladores: principios, técnicas y
herramientas. Pearson Educación.
[2] Hopcrof J., Motwani R. & Ullman J. (2007). Teoría de autómatas, lenguajes y computación.
Ed. Pearson Addison Wesley.
[3] Louden, K. C. (2005). Construcción de compiladores. Principios y prácticas.

------------ Fin de documento.