DEFINICIÓN FORMAL DE UN AFP

Transcripción

1 Los AUTÓMATAS FINITOS CON PILA además de reconocer a los Lenguajes Regulares, tienen la capacidad de reconocer a los LICs, como las expresiones aritméticas y las sentencias de un Lenguaje de Programación. Un LIC es un Lenguaje Formal que es generado por una GIC. noterminal (terminal + noterminal)* L1 = a n b n / n 1. Este lenguaje es un LIC, no es un LR. L1 que puede ser generado por una GIC con estas producciones: S -> asb ab. Esta potencialidad extra del AFP se es porque tiene una memoria en forma de PILA. DEFINICIÓN FORMAL DE UN AFP Un AFP está constituido por: a) un flujo de entrada, infinito en una dirección, que contiene la secuencia de caracteres que debe analizar, similar a un AF; b) un control finito formado por estados y transiciones etiquetadas, similar a un AF; y c) una pila abstracta, que establece la gran diferencia con los AFs. Esta pila se representa como una secuencia de símbolos o caracteres tomados de cierto alfabeto, diferente al alfabeto sobre el que se construye un LIC reconocido por un AFP. En la pila, el primer carácter de la secuencia es el que se encuentra en el tope de la pila (esto es solo una convención). Formalmente un AFP es una 7-upla M = (E, A, A', T, e0, p0, F), donde: a) E es un conjunto finito de estados b) A es el alfabeto de entrada, cuyos caracteres se utilizan para formar la cadena a analizar c) A' es el alfabeto de la pila d) e0 es el estado inicial e) p0 es el símbolo inicial de la pila, el que indica que la pila no tiene símbolos f) F es el conjunto de estados finales g) T es la función T: E x (A ε) x A' -> conjuntos finitos de E x A'* T(4,a,Z) = (4,RPZ), (5,ε) se lee así: si el AFP se encuentra en el estado 4, en el tope de la pila tiene el símbolo Z y lee el carácter a del flujo de entrada, entonces se queda en el estado 4 y agrega RP a la pila, ó (aquí está el no-determinismo del AFP) se mueve al estado 5 y quita el símbolo Z que está en el tope de la pila. Un AFP puede reconocer un LIC de dos maneras: a) por estado final, como en los AFs; b) por pila vacía AUTÓMATA FINITO CON PILA DETERMINÍSTICO (AFPD) AFPD está formado por una colección de estos ocho elementos: Un alfabeto de entrada A. Son los símbolos con los que se forman las palabras del LIC a reconocer. Hay un símbolo especial al que llamaremos fdc (fin de cadena), que solo puede aparecer al final de la cadena en estudio para indicar su terminación. Un flujo de entrada infinito en una dirección, que contiene la cadena a analizar. Un alfabeto A de símbolos de la pila. Hay un símbolo especial, al que llamaremos, $, que indica pila lógicamente vacía.

2 Una pila (stack) infinita en una dirección. Inicialmente la pila está vacía, lo que se indica mediante el símbolo especial $ en el tope de la pila. Un conjunto finito y no vacío de estados E. Un estado inicial (único). Un conjunto de estados finales o de aceptación. Una función de transiciones entre los estados Supongamos el lenguaje infinito L= a n b n / n>0 El autómata dispone de una cinta lectora, la memoria (que el AF no tiene) la implementa en una estructura de tipo pila. Las transiciones se etiquetan con la terna de valores: (Carácter consumido, lo que se mete en la pila, lo que se saca de la pila) En caso de no meter en la pila o no sacar de la misma, se representa con Ԑ. a/ԑ/a consume a, no saca nada de la pila, mete a b/a/ԑ consume b, saca una a de la pila, no mete nada a/ԑ/ԑ consume a, no mete ni saca en/de la pila Traza de ejecución Digrafo a Digrafo b Por leer Estado Pila Por leer Estado Pila aabb q Ԑ aabb q1 Ԑ abb q aԑ abb q1 aԑ bb q aaԑ bb q1 aaԑ b q aԑ b q2 aԑ Ԑ q Ԑ Ԑ q2 Ԑ Reconoce Reconoce Por leer Estado Pila Por leer Estado Pila abab q Ԑ abab q1 Ԑ bab q aԑ bab q1 aԑ ab q Ԑ ab q2 Ԑ b q aԑ b q2???? Ԑ q Ԑ Reconoce y no debería hacerlo No reconoce y es correcto

3 LA TABLA DE MOVIMIENTOS (TM) La TM en un AFP o en un AFPD es similar a la Tabla de Transiciones en un Autómata Finito. La diferencia radica en que en la TM no podemos hablar solo de estado ; debemos hablar del par estado y símbolo en el tope de la pila. AFPD que reconoce al lenguaje L1 = a n b n / n 1: TM a b fdc e0,$ e1,r$ e1,r e1,rr e2, e2,r e2, e2,$ e3,$ AFPDs Y EXPRESIONES ARITMÉTICAS Las expresiones aritméticas que utilicen paréntesis para determinar un orden de evaluación, constituyen un LIC existente en la inmensa mayoría de los Lenguaje de Programación. Por lo tanto, se podrá construir un AFPD que las reconozca, es decir: que determine si una secuencia de caracteres, que constituye una supuesta expresión aritmética, es sintácticamente correcta o no. Sea el LIC de todas las expresiones aritméticas cuyo único operando es 4, los operadores son + (suma) y * (producto), y puede haber paréntesis. La Tabla de Movimientos que define a este AFPD será: TM 4 +,* ( ) fdc e0,$ e1,$ e0,r$ e0,r e1,r e0,rr e1,$ e1,$ e0,$ e3,$ e1,r e1,r e0,r e2, e2,$ e0,$ e3,$ e2,r e0,r e2, e3,$

4 /* Programa que utiliza una Maquina de Turing */ #include <stdio.h> #include <ctype.h> #include <string.h> #include <stdlib.h> #define NUMESTADOS 10 #define NUMCOLS 7 #define ACEPTADA 1 #define RECHAZADA 0 #define D 1 #define I 2 int columna(int c); int verifica(char *s); int mturing(char *cadena); /**************************************************************/ /* Elemento de la Matriz de transiciones de la maq. de Turing */ typedef struct int marca; int movera; int estadosiguiente; elementomatriz; /*******************************************************************/ /* Funcion Principal que lee una cadena de la linea de comandos y decide si pertenece al lenguaje, utilizando la maq. de Turing */ int main(int argc, char *argv[]) if ( argc == 1 ) printf("debe ingresar una Cadena en Linea de Comandos\n"); return EXIT_FAILURE; if ( argc!= 2 ) printf("cantidad de Argumentos Incorrecta\n"); return EXIT_FAILURE; if (!verifica(argv[1]) ) printf("los Caracteres de la Cadena No pertenecen al Alfabeto\n"); return EXIT_FAILURE;

5 if ( mturing(argv[1]) ) printf("la Cadena ingresada pertenece al Lenguaje\n"); else printf("la Cadena ingresada No pertenece al Lenguaje\n"); return 0; /********************************************/ /* Funcion que implementa la maq. de Turing */ int mturing(char *cadena) static elementomatriz tabla[numestados][numcols] = 'X', D, 1, 0, 0, 9, 0, 0, 9, 0, 0, 9, 'Y', D, 6, 0, 0, 9, 0, 0, 9, 'a', D, 1, 'Y', D, 2, 0, 0, 9, 0, 0, 9, 'Y', D, 4, 0, 0, 9, 0, 0, 9, 0, 0, 9, 'b', D, 2, 'Z', I, 3, 0, 0, 9, 0, 0, 9, 'Z', D, 5, 0, 0, 9, 'a', I, 3, 'b', I, 3, 0, 0, 9, 'X', D, 0, 'Y', I, 3, 'Z', I, 3, 0, 0, 9, 0, 0, 9, 'Y', D, 2, 0, 0, 9, 0, 0, 9, 'Y', D, 4, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 'Z', I, 3, 0, 0, 9, 0, 0, 9, 'Z', D, 5, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 'Y', D, 6, 'Z', D, 7, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 'Z', D, 7, 0, I, 8, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9, 0, 0, 9 ; int estadoactual = 0; int movera = D; char *punterocar = cadena; int caracter = *punterocar; while ( caracter ) *punterocar = tabla[estadoactual][columna(caracter)].marca; movera = tabla[estadoactual][columna(caracter)].movera; estadoactual = tabla[estadoactual][columna(caracter)].estadosiguiente; if ( movera == D ) ++punterocar; if ( movera == I ) --punterocar; caracter = *punterocar; estadoactual = tabla[estadoactual][columna(caracter)].estadosiguiente; if ( estadoactual == 8 ) return ACEPTADA; else return RECHAZADA;

6 /********************************************************************/ /* Funcion que retorna la columna de la matriz que corresponde al caracter leido */ int columna(int c) switch ( c ) case 'a' : return 0; case 'b' : return 1; case 'c' : return 2; case 'X' : return 3; case 'Y' : return 4; case 'Z' : return 5; case '\0' : return 6; /********************************************************************/ /* Funcion que verifica si los caracteres de la cadena pertenecen al alfabeto */ int verifica(char *s) size_t n = strlen(s); if ( s[n - 1] == '\n' ) s[n - 1] = '\0'; for ( ; *s; ++s ) if (!(*s == 'a' *s == 'b' *s == 'c' ) ) return 0; return 1;