Source: https://www.scribd.com/document/13720677/Sistemas-de-Razonamiento-Logico
Timestamp: 2018-12-17 03:47:05+00:00

Document:
Informe sobre Sistemas de Razonamiento Lógico
S ISTEMAS DE R AZONAMIENTO L ÓGICO
Universidad Nacional del Santa Facultad de Ingeniería E.A.P. de Ingeniería de Sistemas e Informática 24/03/2009
1 2 Introducción.......................................................................................................................... 3 Indización, Recuperación y Unificación .............................................................................. 5 2.1 2.2 2.3 2.4 2.5 3 Implantación de Oraciones y Términos ...................................................................... 5 Guardar y Recoger ....................................................................................................... 5 Indización Basada en Tablas ....................................................................................... 6 Indización Basada en Árboles ..................................................................................... 7 El Algoritmo de Unificación ........................................................................................ 9
Sistemas de Programación Lógicos ................................................................................... 10 3.1 3.2 3.3 3.4 3.5 El Lenguaje Prolog ..................................................................................................... 10 Implantación .............................................................................................................. 11 Compilación de Programas Lógicos .......................................................................... 13 Otros Lenguajes de Programación ............................................................................ 14 Recursos Avanzados de Control ................................................................................ 15
Demostradores de Teoremas ............................................................................................. 17 4.1 4.2 4.3 4.4 Diseño de un Verificador de Teoremas ..................................................................... 17 Ampliación de Prolog ................................................................................................. 18 Los Verificadores de Teoremas como Auxiliares ...................................................... 19 Aplicaciones Prácticas de los Demostradores de Teoremas .................................... 20
Sistemas de Producción por Encadenamiento Hacia Adelante ...................................... 21 5.1 5.2 5.3 Fase de Cotejo ............................................................................................................ 22 Fase de Solución de Conflictos .................................................................................. 23 Aplicaciones Prácticas de los Sistemas de Producción ............................................ 23
Sistemas de Marco y Redes Semánticas ........................................................................... 24 6.1 6.2 6.3 6.4 6.5 6.6 Sintaxis y Semántica de las Redes Semánticas ....................................................... 25 Herencia con Excepciones.......................................................................................... 26 Herencia Múltiple ...................................................................................................... 27 Herencia y Cambio ..................................................................................................... 28 Implantación de Redes Semánticas .......................................................................... 29 Expresividad de las Redes Semánticas .................................................................... 31
Lógicas para la Descripción ............................................................................................... 31 7.1 Aplicaciones Prácticas de las Lógicas de Descripción .............................................. 33
Manejo de Retractaciones, Suposiciones y Explicaciones ............................................... 33 Resumen ............................................................................................................................. 36 Bibliografía y Linkografía ................................................................................................. 36
Figura 1. Indización basada en una tabla correspondiente a un conjunto de oraciones lógicas. .......................................................................................................................................... 7 Figura 2. Una indización basada en árbol organiza la base de conocimiento en una serie anidada de embrolladas tablas.. ................................................................................................. 8 Figura 3. El algoritmo de unificación. ........................................................................................ 9 Figura 4. Pseudocódigo que representa el resultado obtenido al compilar el predicado de Miembro ...................................................................................................................................... 14 Figura 5. Bosquejo del demostrador de teoremas OTTER.. .................................................... 18 Figura 6. Una red rete. .............................................................................................................. 23 Figura 7. Red basada en marco y traducción de esta a lógica de primer orden.. ................... 26 Figura 8. Tipos de vínculos en las redes semánticas y su respectivo significado .................. 27 Figura 9. Ejemplo de inferencias conflictivas de rutas de herencia múltiples. ..................... 28 Figura 10. Rutinas básicas para verificación de herencia y relación en una sencilla red semántica libre de excepciones.. ............................................¡Error! Marcador no definido. Figura 11. Sintaxis de las descripciones de un subconjunto del lenguaje CLASSIC. ........... 32
Se ha mencionado anteriormente lo conveniente que es construir agentes que funcionen como sistemas de razonamiento: sistemas que representen explícitamente el conocimiento y puedan efectuar razonamientos sobre éste. La principal ventaja de estos sistemas es su alto grade de modularidad. Es posible independizar la estructura de control del conocimiento, con lo que cada porción del conocimiento mantiene total independencia entre sí. La anterior facilita experimentar con el sistema y modificarlo, haciendo a este más fácil explicar sus funciones a otro agente y también, como veremos en la parte 6, facilita el autoaprendizaje del sistema. En este capítulo se pasará de las palabras a los hechos, por decirlo de alguna forma, y hablaremos de los diversos procedimientos para poner en práctica estas funciones en un sistema real y eficiente. Los sistemas de razonamiento automático vienen en diversos colores y sabores, cada uno diseñado específicamente para diversos tipos de problemas. Se les clasifica en cuatro grupos principales:  Demostradores de teoremas y lenguajes de programación 1ógicos: En los demostradores de teoremas se utiliza la resolución (o algún otro procedimiento de inferencia completa) para demostrar oraciones expresadas en lógica de primer orden total, frecuentemente en trabajos de razonamiento matemático y de tipo científico. También se les emplea para responder preguntas: la demostración de una oración que contiene variables sirve como respuesta a una pregunta debido a que concretiza las variables. Los lenguajes de programación lógicos se caracterizan por restringir la lógica, lo que impide el manejo completo de la negación, la disyunción y/o la igualdad. Por lo general utilizan el encadenamiento hacia atrás, y a veces pueden incluir algunas características no lógicas de los lenguajes de programación (por ejemplo, entrada y salida). Ejemplos de demostradores de teoremas son: SAM, AURA. OTTER. Ejemplos de los lenguajes de programación 1ógica son: Prolog, MRS, LIFE.  Sistemas de producción: Al igual que en el caso de los lenguajes de programación, estos sistemas utilizan la implicación como elemento primario de la representación. El consecuente de cada implicación se interpreta como recomendación de la acción, y no como mera conclusión lógica. Entre las acciones figuran inserciones y eliminaciones de la base de conocimientos así como entrada y salida. Los sistemas de producci6n funcionan con una estructura de control de encadenamiento hacia adelante. Algunos de ellos cuentan con un mecanismo de resolución de conflictos para decidir qué acción emprender cuando son varias las que se recomienda realizar. Ejemplos: OPS-5, CLIPS, SOAR.  Sistemas de cuadro y redes semánticas: En estos sistemas se aplica la metáfora de que los objetos son nodos en una gráfica, de que estos nodos se organizan de acuerdo con una estructura taxonómica y de que los vínculos que existen entre los nodos representan relaciones binarias. En los sistemas de cuadro, las relaciones binarias se consideren como ranuras de un cuadro que se llenan mediante otra; en cambio, en las redes semánticas, se consideran como flechas
24-3-2009 entre un nodo y otro. De la elección entre la metáfora del cuadro y la metáfora de la red semántica dependerá que el dibujo de las redes resultantes se realice como cajas de nido o como gráficas, aunque el significado e implantación de ambos tipos de sistemas pueda ser idéntico. En este capítulo al hablar de una "red semántica" se quiere decir "red semántica o sistema de cuadro". Ejemplos de los sistemas de cuadro: OWL, FRAIL, KODIAK. Ejemplos de redes semánticas: SNEPS, NETL, Gráficas Conceptuales.  Sistemas lógicos por descripción: Estos sistemas son la consecuencia de la evolución de las redes semánticas, al ser presionadas para formalizar el significado de las redes, sin dejar de poner énfasis en la estructura taxonómica como principio rector. La idea consiste en emplear como medio de expresión y de razonamiento las definiciones complejas de objetos y clases, así como sus relaciones entre ellos. La lógica de la descripción se conoce a veces como lógica terminológica, debido a la atención puesta en la definición de términos. Los trabajos más recientes se han enfocado al compromiso entre la expresividad del lenguaje y la complejidad para el computo de ciertas operaciones. Ejemplos: KLONE, CLASSIC, LOOM. En este capítulo veremos cómo implantar cada uno de los cuatro tipos de sistemas anteriores y cómo enfrentar cada una de las siguientes tareas: 1. Incorporar algo nuevo a la base de conocimientos, sea esto una percepción, o un hecho deducido mediante la inferencia. A esta función se le designa como DECIR. 2. Dados una base de conocimientos y un nuevo hecho, deducir algunos de los hechos implicados por la conjunción de la base de conocimientos y del nuevo hecho. En un sistema de encadenamiento hacia adelante, lo anterior forma parte de DECIR. 3. Decidir si una consulta está implicada por la base de conocimientos. A esta función la designamos como PREGUNTAR. Cada versión de PREGUNTAR da resultados distintos, que pueden ir desde simplemente confirmar que la consulta sí está implicada hasta producir un conjunto de todas las posibles sustituciones que validan la consulta. 4. Decidir si una consulta esta almacenada explícitamente en la base de conocimientos: una versión restringida de PREGUNTAR. 5. Quitar una oración de la base de conocimientos. Es importante diferenciar entre corregir una oración que se ha demostrado ser falsa, olvidarse de una oración que ya no es útil (quizás porque sólo tuvo importancia en el pasado) y actualizar la base de conocimientos para reflejar un cambio en el mundo, al tiempo que se conserva el recuerdo de cómo era el mundo en el pasado (En algunos sistemas es posible establecer esta diferencia; otros dependen del ingeniero de conocimiento para que las cosas marchen bien.) Todos los sistemas basados en el conocimiento recurren a la operación fundamental de recuperar oraciones que satisfagan ciertas condiciones, por ejemplo, buscar una oración atómica que logre la unificación mediante una consulta, o encontrar una implicación, que tenga una oración atómica determinada como una de sus premisas. Empezaremos, pues, por las técnicas que permiten mantener una base de conocimientos en una forma tal que apoye la recuperación eficiente.
2 INDIZACIÓN, RECUPERACIÓN Y UNIFICACIÓN
Las funciones DECIR y PREGUNTAR, en general, pueden realizar complicados razonamientos por medio del encadenamiento hacia adelante y hacia atrás, o mediante la resolución. En esta sección nos ocuparemos de dos funciones más sencillas que las anteriores mediante las que se implanta lo referente a DECIR y PREGUNTAR y que se concentran directamente en la implantación física de la base de conocimientos. Denominaremos a estas funciones como ALMACENAR y RECOGER. También explicaremos como implantar un algoritmo de unificación, otro componente básico de los sistemas basados en el conocimiento.
2.1 Implantación de Oraciones y Términos
El primer paso para construir un sistema de razonamiento consiste en definir los tipos de datos de las oraciones y los términos. Lo anterior implica definir tanto la sintaxis de las oraciones (el formato de cómo se interactúa con el usuario en el nivel lógico) como la representación interna en donde el sistema guardará y manejará las oraciones a nivel de implantación. Para cada aspecto de las oraciones pueden corresponder diversas representaciones internas. Por ejemplo, puede haber una forma que permitir al sistema imprimir oraciones y otra para representar oraciones que se han convertido a su forma de cláusula. Nuestro tipo básico para datos representará la aplicación de un operador (como un predicado, un signo de función o un conector lógico) a una lista de argumentos (como términos u oraciones). A este tipo general para datos lo denominaremos COMPUESTO. Cuenta con campos para el operador (OP) y argumentos (ARGS). Por ejemplo, sea c el compuesto 𝑃 𝑥 ∧ 𝑄 𝑥 ; entonces 𝑂𝑃 𝑐 =∧ y 𝐴𝑅𝐺𝑆 𝑐 = 𝑃 𝑥 , 𝑄 𝑥 .
2.2 Guardar y Recoger
Ahora que ya contamos con un tipo de datos para oraciones y términos, tenemos que guardar un conjunto de oraciones en una base de conocimientos, lo que implica la capacidad de guardarlas de manera que se puedan recuperar de manera eficiente. RECOGER se caracteriza por la localización de oraciones en la base de conocimientos que unifican con la consulta, o que por lo menos tienen la misma estructura sintáctica. PREGUNTAR tiene a su cargo la estrategia de la inferencia, cuyo resultado final es una serie de solicitudes enviadas a RECOGER. El costo de cómputo de la injerencia esta determinado básicamente por dos aspectos: la estrategia de búsqueda utilizada por PREGUNTAR y las estructuras de datos utilizadas para implantar RECOGER. La invocación GUARDAR(BC,S) lo que hace es añadir todos los conjuntos de la oración S a la base de conocimientos BC. La manera más sencilla de lograrlo consiste en implantar la base de conocimientos como un arreglo o lista vinculada de coyuntos. Por ejemplo, luego de: DECIR 𝐵𝐶, 𝐴 ∧∼ 𝐵 DECIR 𝐵𝐶, ∼ 𝐶 ∧ 𝐷 La BC contendrá una lista con los elementos: 𝐴, ∼ 𝐵, ∼ 𝐶, 𝐷
24-3-2009 La invocación RECOGER(BC,Q) tiene que recorrer todos los elementos de la base de conocimientos, uno a la vez, hasta que logre dar can un conjunto que coincida con Q, o hasta llegar al final. De esta forma, RECOGER emplea un tiempo O(n) en un elemento n de la BC. GUARDAR emplea un tiempo O(l) para añadir un conjunto a la BC, pero si queremos estar seguros de que no se añadirá ninguna duplicación, entonces GUARDAR será también O(n). Lo anterior no resulta práctico cuando lo que se desea es realizar inferencias serias.
2.3 Indización Basada en Tablas
EI método más recomendable consiste en implantar la base de conocimientos como tabla de dispersión.1 Si sólo se manejaran oraciones literales de base 2 para implantar GUARDAR, bastaría que cuando una determinada P guarde el valor verdadero en la tabla de dispersión con la llave P, y cuando reciba ~P, guardara falso con la llave P. Luego, mediante RECOGER se consultaría la tabla y tanto RECOGER como GUARDAR serian 0(l). Este método tiene dos desventajas: no maneja oraciones complejas que no sean las de negación ni tampoco maneja las variables que puedan contener las oraciones. Por ello, RECOGER no podrá localizar "una implicación cuyo consecuente sea P", como se le requeriría en un algoritmo de encadenamiento hacia atrás; tampoco podrá localizar Hermano(Ricardo, Juan) cuando se le haga la consulta ∃𝑥 Hermano(Ricardo. x). La solución reside en lograr que GUARDAR mantenga una tabla más compleja. Suponemos que las oraciones se pueden convertir a su forma normal. (Utilizamos la forma normal implicativa). Las llaves para la tabla son signos de predicado y los valores que se guardan en cada llave constaran de cuatro componentes:     Una lista de literales positivas correspondientes al signo de predicado. Una lista de literales negativas. Una lista de oraciones en las que el predicado está en la conclusión. Una lista de oraciones en las que el predicado está en la premisa.
Por ejemplo, en la base de conocimiento Hermano(Ricardo, Juan) Hermano(Eduardo, Jaime) ∧ Hermano(Jaime, Roberto) ~Hermano(Ana, Samuel) Hermano(x, y) ⟹ Masculino(x) Hermano(x, y) ∧ Masculino(y) ⟹ Hermano(y, x) Masculino(Jaime) ∧ Masculino(Eduardo) ∧ … ∧ ~Masculino(Ana) ∧ … La tabla de la base de conocimientos sería como la mostrada en la Figura 1. Suponga que ahora formulamos la consulta PREGUNTAR(BC, Hermano(Jaime, Eduardo))
Las tablas de dispersión son estructuras de datos para guardar y recuperar información que se indica por medio de llaves fijas. Para efectos prácticos, se considera que en la tabla de dispersión los tiempos de almacenamiento y recuperación son constantes, aún cuando en dicha tabla exista una gran cantidad de elementos. 2 Recuérdese que las literales de base no tienen variables. Pueden ser oraciones atómicas como Hermano(Ricardo, Juan) o una oración atómica negada como ~Hermano(Ana, Victoria).
24-3-2009 y que PREGUNTAR utiliza el encadenamiento hacia atrás. Lo primero sería invocar RECOGER para encontrar una literal positiva que coincida con la consulta. Como eso no funciona, se invoca RECOGER para localizar una implicación en la que Hermano sea el consecuente. Éste es encontrado y luego de aplicar la sustitución adecuada, el antecedente se convierte ahora en la nueva meta, y se reanuda el procedimiento. Como en la lógica de primer orden el predicado de una consulta siempre está fijo, el sencillo recurso de dividir la base de conocimientos por predicado permite disminuir considerablemente el costo de la recuperación. Pero, ¿por qué detenerse en el predicado? Clave Hermano Positivo Hermano(Ricardo, Juan) Hermano(Ted, Jack) Hermano(Jack, Bobbie) Negativo ~Hermano(Ann, Sam) Conclusión Hermano(x, y) ∧ Masculino(y) ⟹ Hermano(y, x) Premisa Hermano(x, y) ∧ Masculino(y) ⟹ Hermano(y, x) Hermano(x, y) ⟹ Masculino(x) Hermano(x, y) ∧ Masculino(y) ⟹ Hermano(y, x)
Masculino(Jack) Masculino(Ted) …
~Masculino(Ann) …
Hermano(x, y) ⟹ Masculino(x)
Figura 1. Indización basada en una tabla correspondiente a un conjunto de oraciones lógicas.
2.4 Indización Basada en Árboles
La indización basada en tablas es ideal cuando son varios los signos de predicado y sólo unas cuantas cláusulas por signo. Sin embargo, hay aplicaciones en las que son muchas las cláusulas por signa de predicado. Por ejemplo, en el caso de una base de conocimientos, como la de la Oficina de Censos de Estados Unidos en donde se utilizan los números de afiliación al seguro social para representar a las personas, la consulta Hermano(012-34-5678, x) implicaría una búsqueda a través de millones de literales Hermano. Para que la búsqueda pueda ser eficiente, es necesario indizar tanto argumentos como los signos de predicado mismos. Una forma de hacerlo sería modificar la entrada de la tabla correspondiente a Hermano de manera que cada entrada sea una tabla por sí misma, indizada por e1 primer argumento, en vez de hacerlo mediante una lista. Para responder a la consulta Hermano(012-34-5678, x), consultamos primero 1a tabla de predicado en el sitio correspondiente a Hermano, y luego buscamos tal entrada en 012-34-5678. Ambas consultas consumen una pequeña cantidad de tiempo, por lo que la completa realización de RECOGER es eficiente. Podemos concebir el procedimiento de búsqueda de la coincidencia de una literal como a ir bajando por un árbol, en donde la rama en cada punto es determinada por el signo en el punto correspondiente de la oración de consulta (Figura 2). La indización basada en árbol es una forma de la indización combinada, en tanto que básicamente elabora una llave combinada a partir de los signos de predicado y de argumento de la consulta. Desafortunadamente, no es de mucha ayuda cuando uno
24-3-2009 de los signos de la secuencia es una variable, puesto que en tal caso es necesario recorrer cada una de las ramas. Sup6ngase que nuestra base de conocimiento censal tiene como predicado Contribuyente con cuatro argumentos: persona, c6digo postal, ingreso neto redondeado al valor de millar más cercano y numere de dependientes. Por ejemplo: Contribuyente(012-34-5678, 02138, 32000, 10) Supóngase que deseamos localizar todas aquellas personas con código postal 02138 que tienen exactamente 10 dependientes: RECOGER(Contribuyente(p, 02138, i, 10)) Existen decenas de miles de personas con ese código postal y cientos de miles de personas que tienen 10 dependientes, pero posiblemente sólo unos cuantos reúnan ambas características. Para localizarlos, sin excesivo esfuerzo, necesitamos de un índice combinado que se base tanto en el segundo como en el cuarto argumentos. Si tuviéramos que revisar todos los posibles conjuntos de posiciones de variables, tendríamos 2n índices combinados, en donde n es la cantidad de posiciones de signo en las oraciones que se están almacenando. Cuando en las oraciones existen términos complejos, n crece enormemente. Hasta cierto punto, la memoria adicional necesaria para los índices y el trabajo extra que GUARDAR debe hacer pesan más que los beneficios. Podemos adoptar una política fija, como sería la de mantener índices sólo para las llaves que están formadas por un predicado además del argumento respectivo, o decidirnos por usar una política de adaptación que produzca índices que satisfagan las demandas del tipo de consulta que está siendo formulada.
¿Predicado?
¿Primer argumento?
Figura 2. Una indización basada en árbol organiza la base de conocimiento en una serie anidada de embrolladas tablas. Cada nodo del árbol es una confusa tabla indizada por el valor correspondiente a una determinada posición de oración.
En la estrategia de indización cruzada se indizan entradas en diversos sitios; cuando se hace una consulta, la recuperación se realiza en la parte que ofrece más posibilidades. Supóngase que tenemos la consulta RECOGER(Contribuyente(p, 02138, 20000, 3)) y los cuatro tipos de índices disponibles en Contribuyente, además, separadamente, las cuatro posiciones del argumento. Una oración correspondiente a la consulta será indicada bajo el rubro Contribuyente(_, 02138, _, _), Contribuyente(_, _, 20000, _) y
24-3-2009 funcion UNIFICAR(x, y) responde con una sustitución para hacer que x e y sean idénticas, de ser posible UNIFICAR-INTERNO(x, y, {})
funcion UNIFICAR-INTERNO(x, y, θ) responde con una sustitución para que x e y sean idénticas (tomando como base θ). entradas: x, una variable, una constante, una lista o un compuesto y, una variable, una constante, una lista o un compuesto θ, la sustitución que se haya configurado hasta ese momento si θ = falla entonces responder con falla o bien, si x = y entonces responder con θ o bien, si VARIABLE?(x) entonces responder con UNIFICAR-VAR(x, y, θ) o bien, si VARIABLE?(y) entonces responder con UNIFICAR-VAR(x, y, θ) o bien, si COMPUESTO?(x) y COMPUESTO?(y) entonces responder con UNIFICAR-INTERNO(ARGS[x], ARGS[y], UNIFICAR-INTERNO(OP[x], OP[y], θ)) O bien, si LISTA?(x) y LISTA(y) entonces responder con UNIFICAR-INTERNO(REST[x], REST[y], UNIFICAR-INTERNO(PRIMERO[x], PRIMERO[y], θ)) o bien, responder falla
función UNIFICAR-VAR(var, x, θ) responde con una sustitución entradas: var, una variable x, cualquier expresión θ, la sustitución construida hasta ese momento si {var/val} ∈ θ entonces responder con UNIFICAR-INTERVALO(val, x, θ) o bien, si {x/val} ∈ θ entonces responder UNIFICAR-INTERNO(var, val, θ) o bien, si var esta presente en alguna parte de x /* verificar */ entonces responder con falla o bien, responder con sumar {x/var} a θ
Figura 3. El algoritmo de unificación. El algoritmo compara las estructuras de las entradas, elemento por elemento. La sustitución θ, que es el argumento de UNIFICAR-INTERNO, se construye sobre la marcha y sirve para asegurarse de que comparaciones posteriores sean consistentes con las vinculaciones que se hubieran establecido previamente.
Contribuyente(_, _, _, 3). Por lo general, lo mejor es buscar a través de la menor de este grupo de oraciones.
2.5 El Algoritmo de Unificación
Sabemos cómo combinar dos aseveraciones como Conoce(Juan, x) ⟹ Odia(Juan, x) Conoce(Juan, Juana) para inferir Odia(Juan, Juana). La llave de esta inferencia Modus Ponens consiste en unificar Conoce(Juan, x) y Conoce(Juan, Juana). Esta unificación da como resultado la sustitución {x/Juana}, que se aplica a Odia(Juan, x) para producir la solución Odia(Juan, Juana). Hemos visto cómo, al emplear juiciosamente la indización, es posible disminuir la cantidad de invocaciones al algoritmo de unificación; aun así, dicha cantidad puede todavía seguir siendo bastante grande. Por ello es necesario que los algoritmos de
24-3-2009 unificación sean eficientes. El algoritmo que se muestra en la Figura 3 tiene una sencillez razonable. Explora una y otra vez dos expresiones simultáneamente; sobre la marcha va construyendo un unificador, pero falla si en algún momento se encuentra con dos puntos de la estructura que no coincidan. Desafortunadamente, uno de sus pasos es costoso. La verificación de ocurrencia consume un tiempo que corresponde linealmente al tamaño de la expresión que se esté revisando; además, se efectúa por cada variable encontrada. Resulta así que la complejidad temporal del algoritmo es O(n2) veces el tamaño de las expresiones que se desea unificar. Más adelante veremos cómo lograr que estos algoritmos sean más eficientes, al eliminar la necesidad de representaciones explicitas de las sustituciones. En la sección 3.4 veremos cómo ampliar la unificación de manera que nos permita manejar más información además de la de igualdad.
3 SISTEMAS DE PROGRAMACIÓN LÓGICOS
Nuestra atención pasará ahora de los detalles de la implantación de una base de conocimientos a la comparación de las diversas maneras de construir y utilizar tal base de conocimientos. Empezaremos por la programación lógica. Hemos visto que el método declarativo ofrece muchas ventajas para la construcción de sistemas inteligentes. La programacion lógica se esfuerza porque todas las tareas de programación cuenten con estas ventajas. Todo computo puede considerarse como un proceso en que se hacen explicitas las consecuencias de haber escogido un determinado programa para una maquina en especial y de haber proporcionado ciertas entradas. La programación lógica considera al programa y a sus entradas como aseveraciones lógicas acerca del mundo, y al procedimiento de hacer explícitas las consecuencias como un proceso de inferencia. La relación entre lógica y algoritmo esta resumida en la ecuación de Robert Kowalski: Algoritmo = Lógica + Control Los lenguajes de programación permiten escribir algoritmos al complementar las oraciones lógicas con información para control del procedimiento de inferencia. Prolog ha sido hasta ahora el lenguaje de programación lógica que más se ha utilizado para lo anterior. Sus usuarios ascienden a cientos de miles. Se le utiliza fundamentalmente como un lenguaje rápido para elaborar prototipos y en tareas donde hay que manejar signos, como en el diseño de compiladores y en el análisis gramatical del lenguaje natural. También se le ha utilizado en el diseño de aplicaciones de sistemas expertos en las áreas legal, financiera y otras.
3.1 El Lenguaje Prolog
En cuanto base de conocimientos lógica, el programa Prolog tiene las siguientes características:  El programa consta de una secuencia de oraciones, que guardan una relación implícita de coyunción. Todas las variables tienen cuantificación universal implícita y cuando las variables aparecen en oraciones distintas se consideran como diferentes.  Se aceptan únicamente oraciones en forma de clausula de Horm. Es decir, las oraciones son atómicas, o bien una implicación que no tiene antecedentes negados y un consecuente atómico.
24-3-2009  Los términos pueden ser signos de constante, variables o términos funcionales.  En una consulta puede haber conjunciones, disyunciones, variables y términos funcionales.  En vez de utilizar antecedentes negados en sus implicaciones, en Prolog se emplea un operador de negación como falla: una meta no P se considera demostrada si el sistema no logra demostrar P.  Todos los términos diferentes desde el punto de vista sintáctico se considera como que refieren a objetos diferentes. Es decir, no es posible afirmar que A=B o que A=F(x), en donde A es una constante. Es posible afirmar que x=B o que x=F(y), en donde x es una variable.  Se cuenta con una gran cantidad de predicados incorporados para aritmética, de entrada/salida y diversas funciones del sistema y de la base de conocimientos. Las literales que hacen uso de estos predicados se “demuestran” mediante la ejecución del código en vez de hacerlo por inferencia adicional. En la notación de Prolog (Donde los nombre en mayúsculas representas variables), la meta X es 4+3 se alcanza cuando X se vincula a 7. Por el contrario, no es posible demostrar la meta 5 es X+Y, puesto que las funciones integradas no tienen facultad para la resolución arbitraria de ecuaciones3. El siguiente es un ejemplo del empleo del programa Prolog en la relación Miembro, expresados ambos en notación normal de lógica de primer orden y en formato que utiliza Prolog: ∀ 𝑥, 𝑙 𝑀𝑖𝑒𝑚𝑏𝑟𝑜 𝑥, 𝑥 𝑙 ∀ 𝑥, 𝑦, 𝑙 𝑀𝑖𝑒𝑚𝑏𝑟𝑜 𝑥, 𝑙 => 𝑀𝑖𝑒𝑚𝑏𝑟𝑜 𝑥, 𝑦 𝑙 𝑚𝑖𝑒𝑚𝑏𝑟𝑜 𝑋, [𝑋|𝐿 . 𝑚𝑖𝑒𝑚𝑏𝑟𝑜 𝑋, [𝑌|𝐿 ∶ − 𝑚𝑖𝑒𝑚𝑏𝑟𝑜 𝑋, 𝐿 .
Como ya se dijo en capítulos anteriores, en la representación correspondiente a Prolog el consecuente o cabeza, está del lado izquierdo; los antecedentes o cuerpo, a la derecha. Una clausula en Prolog se leería como “Para demostrar (la cabeza), demuestre (el cuerpo)”. Con el fin de mantener este tipo de lectura intuitiva junto con nuestra notación lógica, nos comprometeremos a escribir las clausulas de Prolog empleando una implicación en sentido izquierdo. Por ejemplo, la segunda clausula de la definición de Miembro se convierte en: 𝑀𝑖𝑒𝑚𝑏𝑟𝑜 𝑥, 𝑦 𝑙 <= 𝑚𝑖𝑒𝑚𝑏𝑟𝑜 𝑥, 𝑙 .
La definición de Miembro puede servir para responder a diversos tipos de consultas. Puede utilizarse para confirmar que 𝑀𝑖𝑒𝑚𝑏𝑟𝑜 2, [1,2,3] es verdadera. Además puede enumerar los tres valores de x que hagan verdadera a 𝑀𝑖𝑒𝑚𝑏𝑟𝑜 𝑥, [1,2,3] . También pueden buscar el valor de x tal que 𝑀𝑖𝑒𝑚𝑏𝑟𝑜 2, [1, 𝑥, 3] es verdadera. También puede servir para enumerar las listas para las cuales 𝑀𝑖𝑒𝑚𝑏𝑟𝑜 𝑙, 𝑙𝑖𝑠𝑡𝑎 es verdadera.
3.2 Implantación
Los diseñadores de Prolog realizaron su implantación con el fin de contar con un modelo sencillo y de rápida ejecución:  Todas las inferencias se realizan por encadenamiento hacia atrás, con búsqueda preferente por profundidad. Es decir cuando en el proceso de demostración de
Conviene advertir que de proporcionársele los axiomas correspondientes a la adición, estas metas se pueden resolver con el programa Prolog, mediante la inferencia.
24-3-2009 una oración se tope con un callejón sin salida, Prolog retrocederá al paso inmediato anterior que ofrezca opciones.  El orden de búsqueda a través de los conjuntos de un antecedente es siempre de izquierda a derecha, y las clausulas de la base de conocimientos se aplican en orden, de la primera a la ultima.  La verificación de ocurrencia se omite en la rutina de unificación. Aunque la omisión de la verificación de ocurrencia podría restar confiabilidad a Prolog, en la práctica los errores se producen muy rara vez. El empleo de la búsqueda preferente por profundidad no permite a Prolog ser completo, debido a las rutas infinitas que crean las oraciones circulares. Los programadores deberán tener presente las grande ventajas de Prolog es que el modelo de ejecución es lo suficientemente sencillo como para que un programador con la capacitación necesaria pueda incorporar información de control y producir así un programa eficiente. Como en el caso de nuestro algoritmo de ENACXEDNAMIENTO-HACIA-ATRÁS, Prolog encuentra todas las soluciones correspondientes a una consulta, pero no las agrupa en un conjunto, más bien toca al programa del usuario decidir lo que hará con cada solución conforme esta es enumerada. Lo más común es imprimir las respuestas. De hecho, el nivel superior de Prolog realiza lo anterior de manera automática. Una consulta como por ejemplo: Miembro (loc(X,X),[loc(1,1),loc(2,1),loc(2,2)])? Da como resultado que el usuario tenga ante sí una salida de dos piezas, “X=1” y “X=2”. La ejecución de un programa Prolog se realiza de dos maneras: por interpretación y por compilación. De esta última se hablara en la sección siguiente. La interpretación consiste básicamente en la ejecución del algoritmo de ENCADENAMIENTO-HACIAATRÁS, en donde el programa es la base de conocimientos. Lo de “básicamente” es debido a que los interpretadores de Prolog cuentan con diversas mejoras diseñadas para lograr un máximo de velocidad. Aquí consideraremos solo dos. La primera consiste en que en vez de construir la lista de todas las respuestas posibles para cada submeta, antes de proceder con la siguiente, los intérpretes de Prolog generan una respuesta y una “promesa” para generar el resto una vez que la respuesta en cuestión haya sido explorada totalmente. A esta promesa se le denomina punto de elección. Una vez que la búsqueda preferente por profundidad concluye su exploración de las posibles soluciones aportadas por la respuesta en cuestión y retrocede al punto de elección, este se expande para producir así una nueva respuesta para la submeta y el nuevo punto de elección. Esta manera de proceder permite ahorrar tiempo y espacio. Constituye también un interfaz muy sencillo para la depuración, puesto que en todo momento solo se trabaja con una sola ruta de solución. Segunda. La Sencilla implantación del ENACADENAMIENTO-HACIA-ATRÁS invierte bastante tiempo en la generación de sustituciones y en aplicarlas a las listas de consulta. Prolog elimina la necesidad de un tipo de datos de sustitución al implementar variables lógicas capaces de recordar su vinculación actual. En todo instante, las variables de un programa están vinculadas o desvinculadas a cierto valor. En conjunto, tales variables y valores definen de manera implícita una 12
24-3-2009 sustitución. Desde luego, se produce solo una sustitución a la vez, pero no necesitamos más. La sustitución es la correcta para la ruta actual en el árbol de búsqueda. La ampliación de la ruta solo puede añadir nuevas vinculaciones de variables, puesto que si se intentara añadir una vinculación distinta a una variable que ya esté vinculada, dará como resultado una falla en la unificación. Si llegara a fallar una ruta de la búsqueda, Prolog retrocederá a un punto de elección previo, y posiblemente allí deba desvincular algunas variables. Para ello, es necesario que lleve un registro de todas las variables vinculadas en una pila que se conoce con el nombre de pista. Conforme se va vinculando cada nueva variable mediante UNIFICARVAR, la variable se va empujando a la pila de la pista. Cuando falla una meta y es el momento de retroceder a un punto de elección previo, se produce la desvinculación de cada una de las variables al tiempo que se le retira de la pista.
3.3 Compilación de Programas Lógicos
Ateniéndose a las directrices de la subsección anterior, es posible obtener un razonablemente eficiente intérprete de Prolog. Sin embargo, la interpretación de programas en cualquier lenguaje, Prolog incluido, necesariamente resulta más lento que la ejecución de código compilado. La razón es que el intérprete se comporta siempre como si nunca hubiese visto el programa antes. El intérprete de Prolog debe recuperar las base de datos para encontrar oraciones que satisfagan la meta y un análisis de la estructura de la oración para decidir que submetas generar. Toda la parte medular, para trabajo pesado, de la programación de Prolog se realiza mediante código compilado. La gran ventaja de la compilación es que cuando llega el momento de ejecutar el procedimiento de inferencia, se utilizan rutinas de inferencia específicamente diseñadas para las oraciones de la base de conocimientos. Prolog básicamente lo que hace es generar un demostrador de teoremas en miniatura para cada predicado diferente, con lo que se elimina mucho del exceso de interpretación. También permite la codificación abierta de la rutina de unificación por cada invocación distinta, lo que ahorra el tener que analizar explícitamente la estructura de los términos. El conjunto de instrucciones de las computadoras actuales resulta muy pobre en relación con la semántica en Prolog, por lo que la mayoría de los compiladores de Prolog realizan una compilación en un lenguaje intermedio en vez de hacerlo directamente en lenguaje de máquina. El lenguaje intermedio más popular es el Warren Abstract Machine, o WAM, nombrado así en honor de David H.D. Warren, uno de los autores de la implantación del primer compilador Prolog. El WAN es un conjunto de instrucciones abstractas utilizable en Prolog, y que se puede interpretar o traducir a lenguaje de máquina. Existen otros compiladores que traduce Prolog a un lenguaje de alto nivel tal como Lisp o C, y utilizan dicho compilador para traducir a lenguaje de máquina. Por ejemplo, la definición del predicado Miembro se compilaría como el código mostrado en la figura siguiente: Hay varios puntos que conviene aclarar:  En vez de tener que buscar en la base de conocimientos clausulas Miembro, las clausulas quedan incorporadas en el procedimiento y las inferencias se efectúan tan solo con invocar el procedimiento.  Como se menciono anteriormente, las vinculaciones de la variable en curso se guardan en una pista. Durante el primer paso del procedimiento se guarda el estado actual de la pista, de manera que si llegara a fallar la primera clausula,
procedimiento MIEMBRO(elemento, lista, continuacion) pista  APUNTADOR-PISTA-GLOBAL() si UNIFICAR([elemento/NUEVA-VARIABLE()],lista) entonces LLAMAR(continuación) RESTABLECER-PISTA(pista) resto  NUEVA-VARIABLE() si UNIFICAR(lista, [NUEVA-VARIABLE()|resto]) entonces MIEMBRO(elemento, resto, continuacion)
Figura 4. Pseudocódigo que representa el resultado obtenido al compilar el predicado de Miembro. La función NUEVA-VARIABLE produce una nueva variable, diferente de todas las que se hayan usado hasta ese momento. El procedimiento LLAMAR (continuación) sigue la ejecución con la continuidad especificada
tal estado de pista pueda recuperarse mediante RESTAURAR-PISTA. La acción anterior cancelara todas las vinculaciones generadas por la primera invocación de UNIFICAR.  La parte más engañosa es el empleo de continuaciones para implantar puntos de elección. Podría considerarse la continuación como si se empaquetaran un procedimiento y una lista de argumentos, los que en conjunto definen lo que debe hacerse a continuación cada vez que se alcanza la meta actual. No basta con regresar de un procedimiento como Miembro cuando se alcance la meta, puesto que es posible lograrla de diversas maneras, y es necesario explorar cada una de ellas. El argumento de continuación sirve para resolver este problema, puesto que se puede invocar cada vez que se alcance la meta. En el código Miembro, si elemento unifica con el primer elemento de la lista, entonces el predicado Miembro ha tenido éxito. Entonces LLAMAMOS (invocamos) la continuación, con las vinculaciones correspondientes en la pista, para ahora realizar lo que proceda. Por ejemplo, si la invocación a Miembro proviniese de un nivel superior, la continuación imprimirá las vinculaciones de las variables. Antes del trabajo de Warren sobre la compilación de la inferencia en Prolog, la programación lógica resultaba excesivamente lenta para su uso generalizado. Los compiladores diseñados por Warren y otros permitió a Prolog alcanzar velocidades de hasta 50000 ILPS (inferencias lógicas por segundo en estaciones de trabajo promedio modelo 1990. En fechas más recientes, la aplicación de la moderna tecnología de compilación, incluidos inferencia de tipo, codificación abierta y análisis de flujo de datos entre procedimientos ha permitido a Prolog alcanzar velocidades de varios millones de ILPS, lo que hace competir con C en cuanto a diversos aspectos estándar. Desde luego que el hecho de poder escribir un planificador o un analizador de lenguaje natural en unas cuantas decenas de líneas de Prolog, hacen que este sea más preferible que C en la realización de los prototipos de gran parte de los proyectos de investigación de IA de escala reducida.
3.4 Otros Lenguajes de Programación
Si bien Prolog es la norma aceptada en la programación lógica, existen muchos otros sistemas bastante útiles que básicamente lo que hacen es ampliar de una u otra manera el modelo fundamental de Prolog. Resulta obvio emprender la exploración de Prolog a través del paralelismo de Prolog a través del paralelismo. La primera, conocida como paralelismo-O, surge de la posibilidad de que una meta unifique con diversas y diferentes literales e implicaciones de la base de conocimientos. Cada una de ellas produce una rama
24-3-2009 independiente en el espacio de búsqueda y es susceptible de generar una solución potencial; todas estas ramas pueden ser resueltas en paralelo. La segunda, conocida como paralelismo-Y, proviene de la posibilidad de resolver cada uno de los coyuntos del cuerpo de una implicación en paralelo. El paralelismo Y es más difícil de lograr, puesto que las soluciones de toda la conjunción exigen la vinculación consistente de todas las variables. Cada rama conjuntiva debe comunicarse con las otras ramas para garantizar así una solución global. Son muchos los proyectos que han tenido éxito en el logro de cierto grado de inferencia paralela, pero el más avanzado quizá sea el proyecto PIM (Parallel Interfence Machine, Maquina de inferencia paralela), parte del proyecto Sistemas de Computo Quinta Generación, de Japón. PIM ha logrado alcanzar velocidades de hasta 64 millones de ILPS. No solo se puede acelerar a Prolog, sino también enriquecerlo, al generalizar el concepto de la vinculación de una variable. Las variables lógicas de Prolog son muy útiles porque permiten al programador generar la solución parcial de un problema, dejando desvinculadas algunas variables y proporcionando posteriormente los valores correspondientes a dichas variables. Desafortunadamente no existe una forma para que Prolog especifique las restricciones de los valores: por ejemplo, afirmar que 𝑋 < 3, y posteriormente, durante el cómputo, calcular el valor exacto de X. El formalismo de la programación lógica por restricción (PLR) amplia los conceptos de variable y unificación con el fin de poder incorporar tales restricciones. Considere la definición siguiente de un triangulo, que se basa en la longitud de cada uno de sus tres lados: 𝑇𝑟𝑖𝑎𝑛𝑔𝑢𝑙𝑜 𝑥, 𝑦, 𝑧 ⟸ 𝑥 > 0 ∧ 𝑦 > 0 ∧ 𝑧 > 0 ∧ 𝑥 + 𝑦 > 𝑧 ∧ 𝑦 + 𝑧 > 𝑥 ∧ 𝑥 + 𝑧 > 𝑦 Sea mediante Prolog o PRL, esta definición puede servir para confirmar 𝑇𝑟𝑖𝑎𝑛𝑔𝑢𝑙𝑜(3, 4, 5) produce la vinculación especificada por la restricción 𝑥 > 1 ∧ 𝑥 < 9 ; Si se hubiera hecho en Prolog, la consulta habría fallado. Así como se imponen restricciones aritméticas a las variables, también se pueden emplear restricciones lógicas. Por ejemplo, imponer el que una variable determinada se refiera a una Persona. En Prolog normal, lo anterior solo se puede hacer insertando el coyunto Persona (p) al cuerpo de una clausula. Luego, cuando se utilice la clausula, el sistema intentara resolver la parte restante de la clausula teniendo a p vinculado con cada una de las distintas personas de la base de conocimientos. En el caso de lenguajes como Login y Life, la implantación de literales que contienen predicados de tipo, como es el caso de Persona, se hace en calidad de restricciones. Por lo tanto, 𝑃𝑒𝑟𝑠𝑜𝑛𝑎(𝑝) significa sencillamente que la variable p está restringida a ser una persona; no generara vinculaciones alternas para p. El empleo de tipos simplifica los programas, y el de restricciones acelera su ejecución.
3.5 Recursos Avanzados de Control
Regresando a nuestra base de conocimientos censal, tomemos por ejemplo la consulta “¿Cuál es el ingreso de la esposa del presidente” Lo anterior se expresaría en Prolog de la manera siguiente: 𝐼𝑛𝑔𝑟𝑒𝑠𝑜(𝑠, 𝑖) ∧ 𝐶𝑎𝑠𝑎𝑑𝑜(𝑠, 𝑝) ∧ 𝑂𝑐𝑢𝑝𝑎𝑐𝑖ó𝑛(𝑝, 𝑃𝑟𝑒𝑠𝑖𝑑𝑒𝑛𝑡𝑒) El cómputo de esta consulta podría resultar costoso, puesto que hay que enumerar todos los pares de ingreso de las personas, luego recoger el cónyuge correspondiente a cada persona (excepto en el caso de los que no están casados, o dar varias vueltas
24-3-2009 cuando alguien ha estado casado varias veces) y por ultimo buscar en las personas cuya ocupación ha sido la de presidente. Para responder con eficiencia a consultas conjuntivas como ésta, muchas veces es mejor dedicar previamente cierto tiempo a reorganizar los coyuntos, lo que disimulara el tiempo necesario de cómputo. En el caso de esta consulta, sería mejor ordenarla como sigue: 𝑂𝑐𝑢𝑝𝑎𝑐𝑖ó𝑛(𝑝, 𝑃𝑟𝑒𝑠𝑖𝑑𝑒𝑛𝑡𝑒) ∧ 𝐶𝑎𝑠𝑎𝑑𝑜(𝑠, 𝑝) ∧ 𝐼𝑛𝑔𝑟𝑒𝑠𝑜(𝑠, 𝑖) Se obtendría la misma respuesta, pero sin ninguna regresión, suponiendo que los predicados Ocupación y Casado se están indizando mediante su respectivo segundo argumento. Este procedimiento de reordenamiento es un ejemplo de meta razonamiento, o del razonamiento acerca del razonamiento. Como en el caso de la búsqueda por satisfacción de restricciones, la heurística que estamos empleando para la ordenación de los coyuntos consiste en colocar en primer lugar aquellos con más restricciones. En este caso es evidente que solo una p satisface Ocupación (p, Presidente), pero no siempre es igual de fácil anticipadamente predecir cuantas soluciones habrá para un predicado. Y, aun si lo fuera, no sería practico probar todas las n. Permutaciones de una conjunción de n lugares, cuando tal n es grande. Lenguajes como MRS permite al programador escribir meta reglas para decidir que coyuntos son los que hay que probar primero. Por ejemplo el usuario podría definir una regla en donde se afirme que la meta que implica menos variables es la que debe probarse primero. En algunos sistemas, en vez de reordenar los coyuntos, se modifica la manera como se efectúa la reversión. Por ejemplo, si se desea encontrar a todas aquellas personas x que vengan de un mismo poblado en calidad de presidente. Un ordenamiento ineficiente de esta consulta seria: 𝑅𝑒𝑠𝑖𝑑𝑒𝑛𝑡𝑒(𝑝, 𝑐𝑖𝑢𝑑𝑎𝑑) ∧ 𝑅𝑒𝑠𝑖𝑑𝑒𝑛𝑡𝑒(𝑥, 𝑐𝑖𝑢𝑑𝑎𝑑) ∧ 𝑂𝑐𝑢𝑝𝑎𝑐𝑖𝑜𝑛(𝑝, 𝑃𝑟𝑒𝑠𝑖𝑑𝑒𝑛𝑡𝑒) En Prolog se intentaría resolver lo anterior mediante la enumeración de todos los residentes p de cualquier población, luego enumerar todos los residentes c de dicha población y luego verificar si p es el presidente. Cuando la meta Ocupación (p, Presidente) falla, Prolog regresa al punto de elección más reciente, que es la meta Residente(x, población). A esto se le conoce como reversión cronológica; si bien es sencilla, a veces resulta ineficiente. Es evidente que el generar una nueva x de nada servirá para que p ¡se convierta en presidente! Mediante la técnica de salto reversivo se evita tener que hacer repeticiones inútiles. En este problema en particular, mediante el salto reversivo se retrocede dos pasos hasta llegar a Residente (p, poblado) y se genera una nueva vinculación para p. El determinar donde dar el salto reversivo durante la compilación no es difícil para un compilador que conserva información sobre el flujo de datos. A veces, además del salto reversivo a un sitio razonable, el sistema guarda la combinación de variables que causaron el ir a un callejón sin salida, con el fin de no repetirlas nuevamente en otra rama de la búsqueda. A lo anterior se le conoce como reversión dirigida por dependencia. En la práctica, la cantidad que implica el almacenamiento de todos los callejones sin salida resulta excesivamente grande, como en el caso de la búsqueda heurística, muchas veces la memoria es una restricción más importante que la del tiempo. En la práctica, son más los sistemas de salto reversivo que los sistemas dirigidos por dependencia.
24-3-2009 El ultimo tipo de meta razonamiento es el más complicado; consiste en la capacidad de recordar una inferencia previamente calculada, en vez de calcularla de nuevo. Esto es muy importante, pues la mayoría de los sistemas de razonamiento lógico reciben una serie de consultas relacionadas entre sí. Por ejemplo, un agente basado en la lógica PREGUNTA con frecuencia a su base de conocimientos: “¿y ahora, que debo hacer?” Para responder esta pregunta se necesita de submetas semejantes o idénticas a las respondidas poco antes. El agente podría ir guardando todas las conclusiones que pueda demostrar, pero esto llegaría a consumir toda la memoria. Debe haber un criterio que permita decidir qué conclusiones vale la pena guardar y cuales hay que ignorar, sea porque volverlas a calcular no sea difícil o porque no hay muchas probabilidades de que se vuelvan a plantear.
4 DEMOSTRADORES DE TEOREMAS
Los demostradores de teoremas (conocidos también como razonadores automatizados) se diferencian en dos aspectos de los lenguajes de programación lógica. En primer lugar, la mayoría de los lenguajes de programación lógicos sólo manejan clausulas de Horn, en tanto que los demostradores de teoremas si aceptan la lógica de primer orden. En segundo lugar, los programas de Prolog combinan lógica y control. El que un programador escoja entre escribir 𝐴 ⟸ 𝐵 ∧ 𝐶 en vez de 𝐴 ⟸ 𝐶 ∧ 𝐵 afectará la ejecución del programa. En el caso de los demostradores de teoremas, el usuario puede utilizar cualquiera de las 2 anteriores, o alguna como −𝐵 ⟸ 𝐶 ∧ −𝐴 y todos los resultados serán exactamente los mismos. Pero para funcionar eficientemente, los demostradores de teoremas necesitan todavía controlar la información para operar eficientemente, no es parte de la representación del conocimiento mismo. Buena parte del trabajo de investigación en los demostradores de teoremas se concentra en hallar estrategias de control de utilidad general. Se habló de tres estrategias genéricas; preferencia por la unidad, resolución de entrada lineal y conjunto de apoyo.
4.1 Diseño de un Verificador de Teoremas
En esta sección hablaremos del demostrador de teoremas OTTER (Organized Technique for Theorem proving and Effective Research; Técnicas organizadas para la demostración de teoremas e investigación efectiva), con atención especial a su estrategia y control. Al preparar un problema para someterlo a OTTER, el usuario debe dividir el conocimiento cuatro partes:  Un conjunto de cláusulas conocido como conjunto de apoyo (o cda), que defiende los hechos importantes relacionados con el problema. En cada paso de resolución se resuelve un miembro del conjunto de apoyo en relación con otro axioma, por lo que la búsqueda se enfoca al conjunto de apoyo.  Un conjunto de axiomas utilizables que no pertenezcan al conjunto de apoyo. Ofrecen conocimiento de apoyo relacionado con el área del problema. El límite entre qué se considera parte del problema (y por lo tanto en cda) y qué es fondo de apoyo (y por lo tanto en los axiomas utilizables) dependerá de lo que decide el usuario.  Un conjunto de ecuaciones conocido como reelaboraciones o demoduladores. Si bien los demoduladores son ecuaciones, siempre se aplican de izquierda a derecha. Por lo tanto, definen una forma canónica para simplificación de términos. Por ejemplo, el demodulador 𝑥 + 0 = 𝑥 afirma que todos los términos que tengan la forma 𝑥 + 0 deben desplazarse por el término 𝑥. 17
24-3-2009 procedimiento OTTER(sos, usable) entradas: sos, un conjunto de apoyo –clausulas que definen el problema (una variable global) usable, conocimiento previo potencialmente relevante al problema repetir clausula  el miembro mas ligero de sos mover clausula de sos a usable PROCESS(INFER(clausula, usable), sos) hasta sos = [] o ha sido encontrada una refutación
funcion INFER(clausula, usable) devuelve clausulas resolver clausula con cada miembro de usable devuelve la clausula resultante después de aplicar FILTER
procedimiento PROCESS(clausula, sos) para cada clausula en clausulas hacer clausula SIMPLIFY(clausula) intercalar literales idénticas descartar clausula si esta es una tautología sos  [clausula | sos] si clausula no tiene literales entonces se ha encontrado una refutación si clausula tiene una literal entonces buscar una unidad de refutación fin
Figura 5. Bosquejo del demostrador de teoremas OTTER. El control heurístico se utiliza para elegir la cláusula más "ligera", y también en la función FILTRAR para evitar tomar en cuenta cláusulas que no son interesantes.
 Un conjunto de parámetros y cláusulas que definen la estrategia de control. En particular, el usuario especifica la función heurística que sirve para controlar la búsqueda y la función de filtrado que elimina algunas submetas por considerarlas sin relevancia. OTTER opera mediante la resolución continua de un elemento del conjunto de apoyo comparándolo con uno de los axiomas utilizables. A diferencia de Prolog, utiliza una modalidad de búsqueda preferente por lo mejor. Su función heurística determina el "peso" de cada una de las cláusulas, y da preferencia a las más ligeras. Qué tipo de heurística se utilizará exactamente, depende del usuario; pero, por lo general, el peso de una cláusula se correlaciona con su tamaño y/o dificultad. Las cláusulas unitarias generalmente se consideran como muy ligeras, tanto que la búsqueda puede ser vista como una generalización de la estrategia de preferencia por la unidad. En cada uno de los pasos, OTTER desplaza la cláusula "más ligera" del conjunto de apoyo a la lista de lo utilizable, y añade a ésta algunas consecuencias inmediatas de la resolución de la cláusula más ligera con elemento de la lista utilizable. OTTER se interrumpe cuando topa con una refutación o cuando ya no quedan cláusulas en el conjunto de apoyo. El algoritmo se muestra con más detalle en la Figura 5.
4.2 Ampliación de Prolog
Otra forma de construir un demostrador de teoremas consiste en empezar por un compilador de Prolog y ampliarlo hasta convertirlo en un sólido y completo razonador de lógica de primer orden. Justamente fue éste el método adoptado en el Demostrador
24-3-2009 de Teoremas con Tecnología Prolog, DTTP (Prolog Technology Theorem Prover, PTTP). En DTTP son cinco los cambios más importantes que se efectuaron a Prolog para devolverle integridad y expresividad.  La verificación de ocurrencia se devolvió a la rutina de unificación con el fin de hacerla más sólida.  La búsqueda preferente por profundidad se sustituye por una búsqueda de profundización iterativa. Queda así completa la estrategia de búsqueda y sólo implica más tiempo en un factor constante.  Aceptar y literales negadas (como –P(x)). En la implantación hay dos rutinas distintas, una para demostrar P y otra para demostrar –P.  Una cláusula que conste de n átomos se guarda en n reglas distintas. Por ejemplo, 𝐴 ⟸ 𝐵 ∧ 𝐶 también se puede guardar como −𝐵 ⟸ 𝐶 ∧ −𝐴 y también como −𝐶 ⟸ 𝐵 ∧ −𝐴. la técnica anterior, conocida como fijación, significa que sólo se requiere unificar la meta actual con la cabeza de cada una de las cláusulas, y aún así permite el adecuado manejo de la negación.  La inferencia se completa (incluso en cláusulas que no sean de Horn) por la adición de la regla de resolución de entrada lineal: si la meta actual se unifica con la negación de una de las metas de la pila, se puede considerar que la meta está resuelta. Se trata de un razonamiento por contradicción. Supóngase qué estamos tratando de demostrar P y que la meta actual es –P. Equivale a decir que −𝑃 ⟹ 𝑃, lo cual enlaza P. No obstante lo anterior, DTTP no pierde aquellas propiedades que dotan a Prolog de su rapidez. Las unificaciones se siguen efectuando por modificación directa de las variables, la desvinculación se efectúa resolviendo la pista durante la reversión. La estrategia de búsqueda sigue basada en la resolución de la entrada, lo que significa que toda resolución se realiza por referencia a una de las cláusulas dadas en el planteo original del problema (no es una cláusula derivada). Esto permite compilar todas las cláusulas en el planteo original del problema. La principal desventaja de DTTP es que el usuario tiene que renunciar a todo control sobre la búsqueda de soluciones. El sistema utiliza las reglas de inferencia, tanto en su forma original como en su forma contrapositiva. Esto podría dar lugar a búsquedas no intuitivas. Por ejemplo, supongamos que tenemos la regla: 𝑓 𝑥, 𝑦 = 𝑓 𝑎, 𝑏 ⟸ 𝑥 = 𝑎 ∧ (𝑦 = 𝑏)
En cuanto regla de Prolog, lo anterior sería una forma razonable para demostrar que dos términos f son idénticos. Pero en el caso de DTTP se generaría también lo contrapositivo: 𝑥 ≠ 𝑎 ⇐ 𝑓 𝑥, 𝑦 ≠ 𝑓 𝑎, 𝑏 ∧ (𝑦 = 𝑏)
Al parecer, se trata de una manera en donde se desperdician recursos para demostrar que algunos de dos términos, x y a, son diferentes.
4.3 Los Verificadores de Teoremas como Auxiliares
Hasta ahora, hemos concebido un sistema de razonamiento como un agente independiente que tiene que tomar decisiones y actuar por sí mismo. Otra aplicación de los demostradores de teoremas es como auxiliares, para dar consejo, por ejemplo, a un matemático. En este caso, el matemático actúa como un supervisor que establece
24-3-2009 la relación entre la estrategia para definir qué hay que hacer y entre el pedir al demostrador de teoremas que se ocupe de los detalles. Esto es de ayuda hasta cierto punto en el caso de problemas de semidecidibilidad, pues permite al supervisor cancelar una consulta y probar otro método en caso de que dicha consulta esté consumiendo demasiado tiempo. El demostrador de teoremas también puede operar como verificador de demostraciones, en donde un humano propone la demostración en función de una serie de pasos muy amplios; cada una de las inferencias necesarias para demostrar que cada paso es sólido quedan a cargo del sistema. Un razonador socrático es un demostrador de teoremas cuya función PREGUNTAR está incompleta, pero que siempre logra llegar a la solución si se le plantea una serie de preguntas adecuadas. Es decir, los razonadores socráticos son buenos auxiliares, siempre y cuando esté presente un supervisor que efectúe la serie de invocaciones correcta a PREGUNTAR. ONTIC es un ejemplo de sistema de razonamiento socrático en las matemáticas.
4.4 Aplicaciones Prácticas de los Demostradores de Teoremas
Los demostradores de teoremas han producido novedosos descubrimientos matemáticos. El programa SAM (Semi – Automated Mathematics; matemáticas semiautomatizadas) fue el primero que demostró una premisa de la teoría de la retículas. Mediante el programa AURA se ha dado respuesta a preguntas abiertas en diversas áreas de las matemáticas. El demostrador de teoremas de Boyer - Moore se ha utilizado y ampliado durante muchos años. Lo empleó Natarajan Shankar para producir la primera y totalmente rigurosa demostración formal del teorema de Incompletez de Gödel. El programa OTTER es uno de los demostradores de teoremas más sólidos; se le ha utilizado para resolver diversas preguntas abiertas en lógica de combinaciones y alcanza aproximadamente 2000 ILPS en una estación de trabajo modelo 1990. Los demostradores de teoremas se utilizan en problemas relacionados con la verificación y síntesis tanto de hardware como software, pues en ambos dominios es posible contar con formas de hacer axiomas correctos. En el caso del software, mediante los axiomas se definen las propiedades de todos los elementos sintácticos del lenguaje de programación. (El razonamiento acerca de programas es muy semejante al razonamiento sobre acciones en los cálculos de situación). La verificación de un algoritmo se realiza demostrando que sus salidas cumplen con las especificaciones de todas las entradas. De esta forma es como se han verificado el algoritmo público RSA de cifrado de llaves y el algoritmo de cotejo de cadenas de Boyer - Moore. En el caso de hardware, los axiomas describen las interacciones que tienen lugar entre señales y elementos de circuito. Mediante AURA se verificó el diseño de un sumador de 16 bits. Con los razonadores lógicos diseñados especialmente para la verificación serán revisado CPU completas, incluidas sus características de sincronización. El demostrador de teoremas MRS se ha utilizado para diagnosticar sistemas de cómputo utilizando especificaciones estructurales y conductuales. La síntesis formal de los algoritmos fue una de las primeras aplicaciones de los demostradores de teoremas, como lo bosquejara Cordell Green, quien se apoyó en las ideas previamente propuestas por Simon. La idea consiste en demostrar un teorema a efecto de que "existe un programa p que satisface cierta especificación". Si se ha restringido la demostración para que sea constructiva, es posible extratar el
24-3-2009 problema. No obstante que aún no se cuenta con una síntesis deductiva, como se llama, para la programación de propósito general, la síntesis deductiva guiada a mano ha producido buenos resultados en el diseño de diversos algoritmos nuevos y complejos. La síntesis de programas de propósito especial es también un área activa de investigación. En el área de la síntesis de hardware, el demostrador de teoremas AURA también se ha aplicado al diseño de circuitos más compactos que todos los diseños anteriores. En el caso de muchos diseños de circuitos, basta con la lógica proporcional, ya que el conjunto de proposiciones de interés está limitado por el conjunto de elementos del circuito. Ahora es técnica establecida la aplicación de la inferencia proposicional para la síntesis del hardware, y se le utiliza en muchas aplicaciones de gran escala.
5 SISTEMAS DE PRODUCCIÓN POR ENCADENAMIENTO HACIA ADELANTE
Prolog y la mayoría de los lenguajes de programación tienen encadenamiento hacía atrás. Una vez que se plantea una consulta, realizan la búsqueda para una demostración constructiva que establezca alguna sustitución que satisfaga la consulta. Una alternativa es el método de encadenamiento hacía adelante, en el cual no existen consultas. En vez de ello, se aplica a la base de conocimientos reglas de inferencia, lo que producen nuevas aseveraciones. Éste procedimiento se repite indefinidamente, o hasta que se logra satisfacer cierto criterio de paro. Éste procedimiento es adecuado en el diseño de un agente: en cada ciclo, se incorporan las percepciones a la base de conocimientos y se ejecuta el encadenamiento hacía adelante, el cual elige qué acción realizar de acuerdo con un conjunto de reglas condición – acción. Teóricamente, sería imposible implantar un sistema de producción mediante el demostrador de teoremas, y para ellos utilizaría la resolución para efectuar el encadenamiento hacía adelante en una base de conocimientos completa de primer orden. Sin embargo, un lenguaje más restringido permitiría mayor eficiencia puesto que el factor de ramificación se reduce. Un sistema de producción típico se caracterizaría por lo siguiente:  El sistema mantiene una base de conocimiento conocida como memoria de trabajo. En ella se guarda un conjunto de literales positivas que no tienen variables.  El sistema mantiene también una memoria de reglas independiente. Esta contiene un conjunto de reglas de inferencia de la forma 𝑝1 ∧ 𝑝2 … ⇒ 𝑎𝑐𝑡1 ∧ 𝑎𝑐𝑡2 …, en donde las 𝑝𝑖 son literales y las 𝑎𝑐𝑡𝑖 son acciones que se emprenden cuando todas las 𝑝𝑖 se satisfacen. Entre las acciones permitidas están el añadir y eliminar elementos de la memoria de trabajo, así como algunas otras (tales como la impresión de un valor).  En cada ciclo, el sistema calcula el subconjunto de reglas cuyo lado izquierdo se satisface con el contenido actual de la memoria de trabajo. A lo anterior se le conoce como fase de cotejo.  El sistema decide entonces cuál de la reglas se va a ejecutar. A esto se le conoce como fase de resolución de conflictos.  El paso final de cada ciclo consiste en ejecutar la(s) acción(es) de la(s) regla(s) elegida(s). A esto se le conoce como fase de actuación.
5.1 Fase de Cotejo
La unificación enfrenta el problema del cotejo de un par de literales, cada una de las cuales puede contener variables. La unificación podría servir como método directo de implantación de un sistema de producción de encadenamiento hacía adelante, sin embargo, resulta poco eficiente. Si en la memoria de trabajo hay w elementos y r reglas, cada una de éstas con n elementos en el lado izquierdo, y para resolver el problema se necesitan c ciclos, entonces el algoritmo de cotejo intuitivo debe realizar w.r.n.c unificaciones. En un sistema experto simple puede haber w = 100, r = 200, n = 5, c = 1000, por lo que estamos hablando de cien millones de unificaciones. El algoritmo rete4 empleado en el sistema de producción OPS – 5 fue el primero en abordar seriamente este problema. Para comprender en qué consiste, utilicemos el siguiente ejemplo. Supongamos que tenemos la siguiente memoria de reglas: 𝐴(𝑥) ∧ 𝐵(𝑥) ∧ 𝐶(𝑦) ⇒ añadir 𝐷(𝑥) 𝐴(𝑥) ∧ 𝐵(𝑦) ∧ 𝐷(𝑥) ⇒ añadir E(𝑥) 𝐴(𝑥) ∧ 𝐵(𝑥) ∧ 𝐸(𝑥) ⇒ borrar 𝐴(𝑥) Y la siguiente memoria de trabajo: {A(1), A(2), B(2), B(3), B(4), C(5)} El algoritmo rete lo que hace primero es compilar la memoria de reglas en la red mostrada en la Figura 6. En este diagrama, los nodos circulares representan ocasiones en que se han recogido (no unificaciones) en la memoria de trabajo. El nodo A, se recogen y guardan los elementos de la memoria de trabajo A(1), A(2). Los nodos cuadrados indican unificaciones. De las seis posibles combinaciones A x B en el nodo A = B, sólo A(2) y B(2) satisface la unificación. Por último, las cajas rectangulares indican acciones. En la memoria inicial de trabajo, la regla ”Sumar D” es la única que aplica, lo que da por resultado la incorporación de la oración D(2) a la memoria de trabajo. Una de las ventajas más obvias de la red rete es que elimina la duplicación en las reglas. Las tres reglas empiezan por una conjunción de A y B, y la red permite compartir esa parte. La segunda ventaja de las redes rete es el poder eliminar con el tiempo la duplicación. La mayoría de los sistemas de producción efectúan sólo unos cuantos cambios a la base de conocimientos durante cada uno de los ciclos. Es decir, la mayoría de las pruebas que se efectúen en el ciclo t + 1 producirán el mismo resultado que en el ciclo t. La red rete se modifica después de una incorporación o una eliminación, pero sí los cambios son muy pocos, el costo de cada actualización resulta pequeño en comparación con la tarea de mantener completamente actualizado el indizado de la información. La red representa pues el estado intermedio que se guarda en el proceso de probar la satisfacción de un conjunto de conyuntos. En este caso, el incorporar D(2) producirá la activación de la regla “añadir E”, pero no tiene efecto alguno en el resto de la red. Por otra parte, el incorporar o eliminar una A tendrá un efecto mayor, efecto que debe propagarse en gran parte de la red.
Rete es red en latín.
añadir E
B(2), B(3), B(4)
añadir D D(2)
Figura 6. Una red rete. Los círculos representan las pruebas de predicado. El cuadrado que contiene, por ejemplo A = B, representa la restricción de que las soluciones de las pruebas A y B deben ser iguales. Los rectángulos son acciones.
5.2 Fase de Solución de Conflictos
En algunos sistemas de producción se ejecutan todas las reglas que pasan la fase del cotejo. En otros sistemas de producción tales reglas se consideran sólo como sugerencias; la fase de resolución de conflictos sirve para decidir cuál de las sugerencias se va a aceptar. A esta fase se le puede considerar como la estrategia de control. Alguna de las estrategias que sean utilizados son las siguientes:  No duplicación: No aplique dos veces la misma regla a los mismos argumentos.  Novedad: Prefiera aquellas reglas que se refieren a elementos de la memoria de trabajo de reciente creación.  Especificidad: Dé preferencia a aquellas reglas que sean más específicas. Por ejemplo, la segunda de las dos reglas siguientes es la que se preferiría: Mamífero(x) ⇒ añadir Piernas(x,4) Mamífero(x) ∧ Humano(x) ⇒ añadir Piernas(x,2)  Prioridad de operación: Prefiera aquellas acciones que tienen mayor prioridad, según lo especificado por cierto sistema de calificación. Por ejemplo, la segunda de las reglas siguientes posiblemente es la que tenga más alta prioridad: TableroDeControl(p) ∧ Polvoso(p) ⇒ Acción(Desempolvar(p)) TableroDeControl(p) ∧ LámparaDeFusiónEncendida(p) ⇒ Acción(Evacuar)
5.3 Aplicaciones Prácticas de los Sistemas de Producción
Los sistemas de producción basados en el encadenamiento hacía adelante constituyen los fundamentos de buena parte de los primeros trabajos en IA. En particular, el sistema XCON (originalmente denominado R1) se construyó utilizando una arquitectura para sistema de producción (basada en reglas). XCON contiene varios miles de reglas que sirve para diseñar las configuraciones de los componentes de computadoras para los clientes de Digital Equipment Corporation. Fue uno de los primeros innegables éxitos comerciales del naciente campo de los sistemas expertos. Son muchos los sistemas que se han construido utilizando la misma tecnología básica, y que sea implantado con el lenguaje propósito general OPS – 5. Se ha invertido mucho trabajo en el diseño de algoritmos de cotejo para lenguajes de sistemas de
24-3-2009 producción, como ya hemos visto; se ha probado también realizar implantaciones en hardware paralelo. Los sistemas de producción gozan también de gran aceptación en las arquitecturas cognoscitivas, es decir, modelo de razonamiento humano, como son ACT y SOAR. En estos sistemas, la memoria de trabajo del sistema imita la memoria humana de corto plazo, y las producciones forman parte de la memoria de largo plazo. Tanto ACT como SOAR cuentan con complejos mecanismos para la resolución de conflictos y para guardar los resultados de costosos razonamientos en forma de nuevas producciones, las que pueden utilizarse para evitar el razonamiento en situaciones futuras.
6 SISTEMAS DE MARCO Y REDES SEMÁNTICAS
En 1896, siete años después de que Peano creara lo que actualmente es la notación normalizada de la lógica de primer orden, Charles Peirce propuso una notación gráfica denominada gráficas existenciales, a las que se refirió como "la lógica del futuro", Se inició así el prolongado debate entre los partidarios de la "lógica" y los de las "redes semánticas", Desafortunadamente, este debate trajo consigo el perder de vista la unidad básica de este campo. Actualmente se acepta que toda red semántica o sistema de cuadro también puede definirse como oraciones de una lógica, y la mayoría está de acuerdo en que ésta sea la lógica de primer orden. 5 Lo importante en todo lenguaje de representación reside en la comprensión de la semántica y en la teoría de la demostración; los detalles de la sintaxis son menos importantes. El que en lenguaje se utilicen cadenas Onadas y vínculos, y el que se le llame red semántica o lógica, es irrelevante para su significado o para su implantación. Aclarado lo anterior, agregaremos que el formato de un lenguaje puede tener un efecto significativo en cuanto a claridad para un lector humano. La comprensión de algunas cosas se facilita mediante la notación gráfica; algunas otras son más claras cuando aparecen como cadenas de caracteres. Afortunadamente , no es necesario decidirse en definitiva por una u otra; el profesional en IA diestro es capaz de traducir en ambos sentidos las notaciones y elige aquella que mejor se adapta a sus necesidades del momento; lo que no puede es obtener intuiciones de otras notaciones. Algunos sistemas, como el sistema CYC cuenta con los dos tipos de interfaces. Además del atractivo de esos bonitos diagramas nodo-vínculo, las redes semánticas han tenido aceptación por la misma razón que Prolog se usa más que los demostradores de teoremas de lógica de primer orden: porque el modelo de ejecución de la mayoría de los formalismos de la red semántica es muy sencillo. Aunque un, programador llegue a construir una red muy grande, aún así puede hacerse una buena idea de qué consultas pueden ser eficientes, puesto que (a) es fácil visualizar los pasos que se darán en el procedimiento de inferencia y (b) porque el lenguaje de la consulta es tan sencillo que impide formular consultas complicadas. Posiblemente ésta sea la razón de que muchos de los investigadores pioneros en la ontología del sentido común sintieron más confianza de trabajar con sus teorías mediante el método de la red semántica.
Existen algunos problemas relacionados con el manejo de las excepciones, aunque, con un poco de cuidado, a éstas también se les puede encontrar una solución.
6.1 Sintaxis y Semántica de las Redes Semánticas
En las redes semánticas la atención está puesta en las categorías de los objetos y las relaciones que existen entre éstos. En ellas es muy natural establecer vínculos como: 𝐺𝑎𝑡𝑜𝑠 𝑆𝑢𝑏𝑐𝑜𝑛𝑗𝑢𝑛𝑡𝑜 𝑀𝑎𝑚𝑖𝑓𝑒𝑟𝑜𝑠
para afirmar que los gatos son mamíferos. Desde luego, se trata de una forma sencilla de expresar la oración lógica 𝐺𝑎𝑡𝑜𝑠 ⊂ 𝑀𝑎𝑚𝑖𝑓𝑒𝑟𝑜𝑠, pero cuando las redes semánticas se utilizaron por vez primera en IA (alrededor de 1961). Este tipo de expresión no gozaba de aceptación generalizada; se pensaba que para utilizar la lógica era necesario escribir: ∀ 𝑥 𝐺𝑎𝑡𝑜(𝑥) ⟹ 𝑀𝑎𝑚𝑖𝑓𝑒𝑟𝑜𝑠(𝑥) y que producía una respetuosa intimidación. Se consideraba también que ∀ 𝑥 no daba lugar a excepciones, en tanto que 𝑆𝑢𝑏𝑐𝑜𝑛𝑗𝑢𝑛𝑡𝑜
era una expresión más benevolente.6
Ahora se reconoce que la semántica es más importante que la notación. En la figura 10.7se ofrece un ejemplo de una red basada en marco típica, y una traducción de la red en lógica de primer orden. Esta red puede servir para responder a la pregunta: "¿Cuántas piernas tiene Opus?"; siguiendo la cadena de vínculos que van de 𝑆𝑢𝑏𝑐𝑜𝑛𝑗𝑢𝑛𝑡𝑜
𝑀𝑖𝑒𝑚𝑏𝑟𝑜
, de Opus a Pingüinos a Pájaros, y concluyendo así que los pájaros tienen
dos piernas. El anterior es un ejemplo de herencia. Esto es muy sencillo, pero ¿qué sucede, por ejemplo, cuando hay dos cadenas diferentes para dos números distintos de piernas? Es irónico, pero las redes semánticas a veces adolecen de una semántica clara. Muchas veces el usuario tiene que inducir la semántica de un lenguaje a partir del comportamiento del programa que lo implantó. Por ello, los usuarios tienden a considerar las redes semánticas a nivel de implantación, no a nivel lógico o a nivel de conocimiento. Para definir la semántica de lenguaje de red semántica sencilla es necesario proponer los equivalentes en lógica de primer orden de las aseveraciones que se hagan en el lenguaje de red. Primero se define la versión en donde no hay excepciones. Además de los vínculos 𝑀𝑖𝑒𝑚𝑏𝑟𝑜
y 𝑆𝑢𝑏𝑐𝑜𝑛𝑗𝑢𝑛𝑡𝑜
, podemos ver que se necesitan por lo menos otros tres
vínculos: uno para expresar que entre dos objetos, A y B, existe una relación R; otro para afirmar que R se cumple en todos los elementos de la clase A y del objeto B; y otro más que afirme que R se cumple en todos los elementos de A y algún elemento de B. En la Figura 8 se presenta un resumen de los cinco tipos de vínculo estándar 7. Conviene aclarar que un demostrador de teoremas o un lenguaje de programación lógica es capaz de utilizar las traducciones lógicas de los vínculos para efectuar una herencia mediante inferencia lógica común. En un sistema de red semántica se
En muchos sistemas, el nombre EsUn se asigna tanto al subconjunto como a las vinculaciones para indicar pertenencia a un conjunto, al igual de cómo se emplea en español: “un gato es un mamífero” y “Fifi es un gato”. Lo anterior da lugar a la producción de incongruencias, como lo señaló Drew McDermott en su artículo “Artificial Intelligence Meets Natural Stupidity” (“La Inteligencia Artificial se encuentra con la tontería natural”). Para algunos sistemas fue imposible diferenciar entre las propiedades de los miembros de una categoría determinada y las propiedades de la categoría como un todo. 7 Porque aseveraciones como A 𝐵 son tan frecuentes, hemos empleado la abreviación Rel(R, A, B) como azúcar sintáctica para realizar la traducción lógica ().
24-3-2009 emplean algoritmos de propósito especial para recorrer los vínculos. y por ello puede ser más rápido que la inferencia lógica general.
6.2 Herencia con Excepciones
Como vimos en el capitulo anterior, las clases naturales están llenas de excepciones. En el diagrama de la Figura 7 se afirma que los mamíferos tienen cuatro piernas, pero también se afirma que los murciélagos, que lambien son mamíferos, tienen dos piernas. De acuerdo con la semántica lógica directa, lo anterior es una contradicción. Para resolver el problema, se modifica la traducción semántica de un vinculo R que está dentro de una caja, de A a B para indicar así que todos los miembros de A deben tener una relación R con B a menos que exista una A' para lo cual Rel(R, A,. B'). De esta manera, en la Figura 7 se afirmará, sin dar lugar a contradicciones, que los murciélagos tienen dos piernas, no cuatro. Observe que Rel(R, A, B) ya no significa que todas las A están relacionadas con B mediante R;sino que B es el valor por omisión de la relación R para los miembros de A; pero los valores por omisión pueden resultar invalidados por alguna otra información.
Figura 7. Red basada en marco y traducción de esta a lógica de primer orden. Los nombres de relación que aparecen dentro de las cajas corresponden a las relaciones que se aplican a todos los miembros del conjunto de objetos.
24-3-2009 Una forma intuitiva de manejar la herencia con excepciones seria recorriendo los vinculas de un diagrama, pero también es posible y muy instructivo definir la semántica correspondiente mediante lógica de primer orden. El primer paso en una traducción lógica consiste en reificar las relaciones: una relación R se convierte en un objeto, no en un predicado. Es decir, Rel(R, A, B) es simplemente una oración atómica común, no la abreviación de una oración compleja. Significa también que ya no es posible escribir R(x. B), puesto que R es un objeto, no un predicado. Mediante Val(R, xB) indicamos que el equivalente de una relación R(x, B) está expresado de manera explícita en la red semántica y que SeCumple(R, x, B) significa que es posible inferir R(x, B). Podemos así definir SeCumple para decir que una relación R se cumple en x y en b si existe un predicado explícito Val, o si existe una Rel en alguna clase padre p de la cual x es un elemento, y no existe Rel ni tampoco una clase i interpuesta. (Se considera que existe una clase i interpuesta si x es un elemento de i y si i es un sub. conjunto de p.) Es decir: ∀ 𝑟, 𝑥, 𝑏 𝑆𝑒 𝑐𝑢𝑚𝑝𝑙𝑒 𝑟, 𝑥, 𝑏 ⟺ 𝑉𝑎𝑙 𝑟, 𝑥, 𝑏 ∀(∃ 𝑝 , 𝑥 ∈ 𝑝 ⋀ 𝑅𝑒𝑙 𝑟, 𝑝, 𝑏 ⋀ ∼ 𝑅𝑒𝐼𝑛𝑡𝑒𝑟𝑣𝑖𝑒𝑛𝑒(𝑥, 𝑝, 𝑟) ) ∀ 𝑥, 𝑝, 𝑟 𝑆𝑒 𝑐𝑢𝑚𝑝𝑙𝑒 𝑥, 𝑝, 𝑟 ⟺ ∃ 𝑖 𝑄𝑢𝑒𝐼𝑛𝑡𝑒𝑟𝑣𝑖𝑒𝑛𝑒 𝑥, 𝑖, 𝑝 ⋀ ∃ 𝑏 ′ 𝑅𝑒𝑙 𝑟, 𝑖, 𝑏′ ∀ 𝑎, 𝑖, 𝑝 𝐼𝑛𝑡𝑒𝑟𝑣𝑖𝑒𝑛𝑒 𝑥, 𝑖, 𝑝 ⟺ 𝑥 ∈ 𝑖 ⋀(𝑖 ⊂ 𝑝) Tipo de vinculo 𝐴 𝑆𝑢𝑏𝑐𝑜𝑛𝑗𝑢𝑛𝑡𝑜 𝐵
Semántica 𝐴 ⊂ 𝐵 𝐴 ∈ 𝐵 𝑅 𝐴, 𝐵 ∀ 𝑥 ∈ 𝐴 ⟹ 𝑅 𝑥, 𝐵 ∀ 𝑥 ∃ 𝑦 , 𝑥 ∈ 𝐴 ⟹ 𝑦 ∈ 𝐵 ∧ 𝑅(𝑥, 𝑦)
Ejemplo 𝐺𝑎𝑡𝑜𝑠 ⊂ 𝑀𝑎𝑚𝑖𝑓𝑒𝑟𝑜𝑠 𝑀𝑒𝑚𝑜 𝜖 𝐺𝑎𝑡𝑜𝑠 𝑀𝑒𝑚𝑜 𝑃𝑎𝑗𝑎𝑟𝑜𝑠 𝑃𝑎𝑗𝑎𝑟𝑜𝑠 𝐸𝑑𝑎𝑑 𝐴 𝑀𝑖𝑒𝑚𝑏𝑟𝑜 𝐴
𝐴 𝐴 𝑅
𝐵 𝐵
12 2 2 𝑃𝑖𝑒𝑟𝑛𝑎𝑠 𝑅 𝑃𝑎𝑑𝑟𝑒
Figura 8. Tipos de vínculos en las redes semánticas y su respectivo significado
Nótese que el símbolo ⊂ significa el subconjunto correspondiente (por ejemplo. 𝑖 ⊂ 𝑝 Significa que si i es un subconjunto de p y que no es igual a p). El paso siguiente consiste en reconocer que es importante no sólo saber qué relaciones existen en Rel y Val, sino también qué relaciones no existen. Supóngase que estamos tratando de encontrar la n que satisface SeCumple(Piernas, Opus, n). Conocemos Rel(Piernas, Pájaro, 2) y sabemos que Opus es un pájaro; sin embargo, la definición de SeCumple no basta para inferir algo, a menos que podamos demostrar que no existe Rel(Piernas, i, b) correspondiente a i =Pingüinos o cualquier otra categoría interpuesta. Si la base de conocimiento contiene únicamente átomos positivos de Rel (es decir, Rel(Piernas, Pájaros, 2) y Rel(Moscas, Pájaros,T), entonces no podemos hacer nada. Por lo tanto en una traducción de una red semántica como la de la Figura 7 deberán estar presentes oraciones en las que se afirme que las relaciones Rel y Val mostradas son las únicas válidas: ∀ 𝑟, 𝑎, 𝑏 𝑅𝑒𝑙 𝑟, 𝑎, 𝑏 ⟺ 𝑟, 𝑎, 𝑏 ∈ 𝑉𝑖𝑣𝑜, 𝐴𝑛𝑖𝑚𝑎𝑙, 𝑇 , 𝑀𝑜𝑠𝑐𝑎𝑠, 𝐴𝑛𝑖𝑚𝑎𝑙, 𝐹 , … … . ∀ 𝑟, 𝑎, 𝑏 𝑉𝑎𝑙 𝑟, 𝑎, 𝑏 ⟺ 𝑟, 𝑎, 𝑏 ∈ { 𝐴𝑚𝑖𝑔𝑜, 𝑂𝑝𝑢𝑠, 𝑀𝑒𝑚𝑜 , 𝐴𝑚𝑖𝑔𝑜, 𝑀𝑒𝑚𝑜, 𝑂𝑝𝑢𝑠 , … … . }
6.3 Herencia Múltiple
En algunos sistemas de redes semánticas existe la herencia múltiple, es decir, cuando un objeto pertenece a más de una categoría, y por tanto, hereda propiedades de varias
24-3-2009 rutas. En algunos casos esto opera sin mayor problema. Por ejemplo, algunas personas podrían pertenecer tanto a las categorías de Multimillonario como a la de JugadorDePolo, en cuyo caso podemos inferir que son ricos y que pueden montar un caballo. Sin embargo, puede suceder que dos rutas de herencia produzcan respuestas conflictivas. En la Figura 9 se muestra un ejemplo de una dificultad semejante. Opus es un pingüino, por lo que sólo "emite" graznidos. Opus es un personaje de una tira cómica, por lo tanto habla en español.8 En la sencilla traducción lógica presentada antes, podríamos haber inferido las dos conclusiones, las que, con el apropiado conocimiento de base, nos habría hecho llegar a una contradicción. Sin información adicional que indique cierta preferencia por una ruta, no hay manera de resolver el conflicto.
Figura 9. Ejemplo de inferencias conflictivas de rutas de herencia múltiples.
6.4 Herencia y Cambio
Las bases de conocimiento no son de mucha utilidad para los agentes a menos que exista la posibilidad de ampliarlas. Los sistemas basados en la lógica de primer orden se valen de DECIR para incorporar una nueva oración a la base de conocimientos y, además, se cuenta con la propiedad de la mono tonicidad: si P se deduce de BC, entonces también se aumenta por DECIR(BC,S). Es decir: 𝑆𝑖 𝐵𝐶 ⊢ 𝑃 𝑒𝑛𝑡𝑜𝑛𝑐𝑒𝑠 𝐵𝐶 ∧ 𝑆 ⊢ 𝑃 La herencia que no tiene excepciones se considera no monotónica: en la red semántica de la Figura 7 se deduce que Memo tiene cuatro piernas; pero, si se incorpora la nueva aseveración Rel(Piernas. Galos. 3), ya no se cumple que Memo tiene cuatro piernas. Hay dos métodos para resolver lo anterior. Primero, cambiar de lógica de primer orden a lógica no monotónica, que explícitamente maneja valores por omisión. En la lógica monotónica se puede afirmar que una proposición P debe ser considerada como verdadera hasta que mediante evidencia adicional se demuestre que P es falsa. Si bien se ha llevado a cabo bastante trabajo teórico en esta área, la repercusión que hasta el momento ha ejercido en los
Al ejemplo clásico de conflicto por herencia múltiple se le conoce como “diamante de Nixon”. El conflicto surge porque Richard Nixon era un cuáquero (por lo tano, pacifista) y republicano (por lo tanto, no es pacifista). Por las controversias a que puede dar lugar este ejemplo, evitaremos trabajar con este ejemplo. Para otro ejemplo común se utiliza un pájaro de nombre Tweety (Gorjeador), del que cuanto menos se diga, mejor.
24-3-2009 sistemas prácticos ha sido menor que la de otros métodos, por lo que no nos referiremos a dichos trabajos en este capítulo. Segundo, manejar la incorporación de una nueva aseveración como RETRACTAR seguida de DECIR. Considerando cómo se ha definido Rel, lo anterior tiene sentido. No se formulan aseveraciones de la forma DECIR(BC,REL(R, A, 8)). En vez de ello, se hace una aseveración equivalente amplia, como la siguiente: 𝐷𝐸𝐶𝐼𝑅(𝐵𝐶, ∀ 𝑟, 𝑎, 𝑏 𝑅𝑒𝑙(𝑟, 𝑎, 𝑏) ⟺ ⋯ ) En donde los puntos suspensivos (…...) representan todas las Rel posibles. Así que para incorporar Rel(Piernas, Gatos, 3), sería necesario eliminar la anterior aseveración de equivalencia y sustituirla por una nueva. Una vez codificada la base de conocimientos al haber eliminado una oración de ella (no sólo por la adición de una nueva) no es de sorprender la no monotonía resultante. En la sección 8 se hablará de las maneras de implantar RETRACTAR.
6.5 Implantación de Redes Semánticas
Una vez definido el significado de nuestras redes, podemos proceder a implantar la red. Desde luego que es posible implantarla mediante un demostrador de teoremas o con un lenguaje de programación lógica, lo que en algunos casos es la mejor opción. Sin embargo, en el caso de redes cuya semántica es sencilla, es posible utilizar una implantación más directa. El nodo de una red se representa mediante una estructura de datos, en la que hay campos para las conexiones taxonómicas básicas: de qué categorías se es miembro, qué elementos contiene, cuáles son los subconjuntos y supraconjuntos inmediatos. También cuenta con campos para otras relaciones en las que participa. Los campos RELS-ENTRADA y RELS-SALIDA se ocupan de vínculos comunes (no encajonados), en tanto que los campos TODAS-LAS- RELS-ENTRADA y TODAS-LAS-RELS-SALlDA se ocupan de los vínculos encajonados. La siguiente es la definición del tipo de datos de los nodos: tipo de datos NODO–SEMI–RED componentes: NOMBRE, MIEMBROS, ELEMENTOS, SUPERS, SUBS, RELS–ENTRADA, RELS–SALIDA, TODAS–RELS–ENRADA, TODAS–RELS–SALIDA Cada uno de los cuatro campos-REL está organizado en una tabla indizada por la relación. Mediante la función CONSULTA (llave, tabla) encontramos el valor asociado con una llave de la tabla. Por ejemplo si tenemos los vínculos 𝐴𝑚𝑖𝑔𝑜
𝐴𝑚𝑖𝑔𝑜
Esteban, entonces CONSULTAR (Amigo, RELS-SALIDA( opus) producirá el
conjunto {Memo, Esteban}. El código de la ¡Error! No se encuentra el origen de la referencia. implanta todo lo necesario con el fin de PREGUNTAR a la red qué subconjunto, membrecía u otras relaciones son las que prevalecen entre dos objetos. Cada una de las funciones sencillamente va recorriendo los vínculos que corresponda hasta encontrar lo que busca, o hasta que sale de los vínculos. El código no puede manejar vínculos encerrados dos veces en caja, ni tampoco las excepciones. Por otra parte, no se muestra el código que DICE a la red acerca de las nuevas relaciones, puesto que es muy directo.
24-3-2009 funcion MIEMBRO?(elemento, categoria) devuelve Verdadero o Falso por cada c de MEMBRESIAS[elemento] hacer si SUBCONJUNTO?(c, categoria) entonces devolver Verdadero devolver Falso
funcion SUBCONJUNTO?(sub, super) devuelve Verdadero o Falso si sub = super entonces devolver Verdadero por cada c de SUPERS[sub] hacer si SUBCONJUNTO?(c, super) entonces devolver Verdadero devolver Falso
función RELACIONADO–CON?(fuente, relación, destino) devuelve Verdadero o Falso si la relación aparece en RELS–SALIDA(fuente) entonces devolver MIEMBRO([relación, destino], RELS–SALIDA(nodo)) o bien, por cada c de MEMBRESIAS(fuente) hacer si TODO-RELACIONADO-CON?(c, relación, destino) entonces devolver Verdadero fin devolver Falso
funcion TODO-RELACIONADO-CON?(fuente, relación, destino) devuelve Verdadero o Falso si la relación aparece en TODAS-RELS–SALIDA(fuente) entonces devolver MIEMBRO([relación, destino], TODAS-RELS–SALIDA(nodo)) o bien, por cada c de SUPERS(categoria) hacer si TODO-RELACIONADO-CON?(c, relación, destino) entonces devolver Verdadero fin devolver Falso
Figura 10. Rutinas básicas para verificación de herencia y relación en una sencilla red semántica libre de excepciones. Nótese que la función MIEMBRO? aquí se define para que opere en nodos de red semánticos, en tanto que la función MIEMBRO es una utilería que opera en conjuntos.
El código se puede ampliar con otras funciones para dar respuesta a otras preguntas. Un problema que surge en este caso es que es muy fácil dejarse llevar por las estructuras de datos y olvidar su semántica fundamental. Por ejemplo, definimos una función CANTIDAD–DE–SUBTIPOS, mediante la cual se obtiene la longitud de la lista de la ranura SUBS. En el caso de la Figura 7. CANTIDAD–DE– SUBTIPOS(Animal) = 2. Aunque ésta sea la respuesta a la pregunta del usuario, su estatus lógico es dudoso. En primer lugar, es muy probable que haya especies de animales que no estén representadas en la base de conocimientos. Segundo, es posible que algunos nodos estén denotando el mismo objeto. Quizás Perro y Dog sean dos nodos entre los que exista un vínculo de igualdad. ¿Se les debe considerar como dos o uno? Por último, ¿Perro-Con-Orejas-Negras es un tipo de animal? ¿Y Perro-En-MiCuadra-EI-Jueves-Pasado? Aunque no resulta difícil responder a estas preguntas con base en lo que está guardado en la base de conocimientos, es preferible contar con una semántica clara, pues de esta manera las respuestas dadas a las preguntas se refieren al mundo no al estado actual de la representación interna.
6.6 Expresividad de las Redes Semánticas
Las redes de las que hemos hablado hasta ahora están excesivamente limitadas en cuanto a su expresividad. Por ejemplo, no es posible representar una negación (Opus no anda en bicicleta), una disyunción (Opus aparece tanto en el Times como en el Dispatch), ni una cuantificación (todos los amigos de Opus son personajes de tira cómica). Este tipo de construcciones son fundamentales en muchos dominios. En algunas redes semánticas se amplía la notación de manera que puedan trabajar con lógica de primer orden. Es lo que se hizo en las gráficas existenciales de Peirce, redes semánticas fragmentadas (Hendrix, 1975) y en SNEPS (Shapiro,1979). En un método de uso más frecuente se conservan las limitaciones en cuanto a expresividad y para cubrir los vacios se utiliza la vinculación al procedimiento. Ésta es una técnica en la que una función escrita en lenguaje de programación se guarda en calidad de valor de una determinada relación y sirve para responder las invocaciones PREGUNTAR correspondientes a dicha relación (a veces, también se invoca DECIR). ¿Qué nos pueden ofrecer las redes semánticas a cambio de la falta de expresividad? Se van mencionado ya dos ventajas: son capaces de capturar la información de herencia de manera modular; además, su sencillez facilita mucho su comprensión. La tercera ventaja es su eficiencia: puesto que la inferencia se efectúa al seguir vínculos, en vez de recuperar oraciones de una base de conocimientos y realizar unificaciones, necesitan de sólo unos cuantos ciclos de máquina por paso de inferencia. Pero si observamos el tipo de cálculos realizados por los programas Prolog, nos daremos cuenta de que no hay mucha diferencia. Un programa Prolog compilado para un conjunto de oraciones de subconjunto y de membrecía de conjunto, combinadas con las propiedades generales de las categorías, realizan los mismos cálculos de una red semántica.
7 LÓGICAS PARA LA DESCRIPCIÓN
La sintaxis de la lógica de primer orden está hecha para facilitar algo acerca de los objetos. Las lógicas de descripción están diseñadas para concentrarse en categorías y sus definiciones. Constituyen un medio modernamente complejo para definir categorías en función de relaciones existentes, con mucha mayor expresividad de los lenguajes de red semánticos típicos. Las principales tareas de inferencia son la subsuposición (verificar que una categoría sea subconjunto de otra con base en sus definiciones) y la clasificación (verificar que un objeto pertenezca a una categoría). En algunas lógicas de descripción, los objetos se consideran además como categorías definidas por la descripción del objeto y (supuestamente) constituidas exclusivamente por un solo miembro. Esta manera de considerar a la representación constituye un importante distanciamiento del punto de vista centrado en el objeto, más compatible con la sintaxis de la lógica de primer orden.
El lenguaje CLASSIC es un ejemplo típico de una lógica de descripción. En la Figura 11. Sintaxis de las descripciones de un subconjunto del lenguaje CLASSIC.
Concepto → | | | | | | |
Objeto | NombredeConcepto Y(Concepto, ...) Todo(NombrePapel, Concepto) PorLoMenos(NumeroEntero, NombrePapel) CuantoMas(NumeroEntero, NombrePapel) Llena(NombrePapel, NombreIndividual) MismoQue(Ruta, Ruta) UnoDe(NombreIndividual, ...)
Ruta → [NombrePapel, ...] se muestra la sintaxis de la descripción de CLASSIC. 9 Por ejemplo, para expresar que los solteros son adultos que no están casados, escribiríamos: 𝑆𝑜𝑙𝑡𝑒𝑟𝑜 = 𝑌(𝑁𝑜𝐶𝑎𝑠𝑎𝑑𝑜, 𝐴𝑑𝑢𝑙𝑡𝑜, 𝑀𝑎𝑠𝑐𝑢𝑙𝑖𝑛𝑜)
Figura 11. Sintaxis de las descripciones de un subconjunto del lenguaje CLASSIC.
El equivalente de lo anterior en lógica de primer orden seria: ∀𝑥 𝑆𝑜𝑙𝑡𝑒𝑟𝑜 𝑥 ⟺ 𝑁𝑜𝐶𝑎𝑠𝑎𝑑𝑜 𝑥 ∧ 𝐴𝑑𝑢𝑙𝑡𝑜 𝑥 ∧ 𝑀𝑎𝑠𝑐𝑢𝑙𝑖𝑛𝑜 𝑥 Observe que la lógica de la descripción realmente permite efectuar operaciones lógicas directas en los predicados, en vez de tener que crear primero oraciones que se unen mediante conectores. Toda descripción en CLASSIC se puede expresar mediante lógica de primer orden, pero algunas descripciones resultan más directas expresadas en CLASSIC. Por ejemplo, para describir el conjunto de hombres que por lo menos tengan tres hijos, estén desempleados y cuya esposa es doctora, y que además tengan como máximo dos hijas, ambas profesoras de física o química escribíamos: 𝑌(𝐻𝑜𝑚𝑏𝑟𝑒, 𝑃𝑜𝑟𝐿𝑜𝑀𝑒𝑛𝑜𝑠(3, 𝐻𝑖𝑗𝑜𝑠), 𝐶𝑢𝑎𝑛𝑡𝑜𝑀𝑎𝑠(2, 𝐻𝑖𝑗𝑎𝑠), 𝑇𝑜𝑑𝑜𝑠(𝐻𝑖𝑗𝑜, 𝑌(𝐷𝑒𝑠𝑒𝑚𝑝𝑙𝑒𝑎𝑑𝑜, 𝐶𝑎𝑠𝑎𝑑𝑜, 𝑇𝑜𝑑𝑜𝑠(𝐸𝑠𝑝𝑜𝑠𝑎, 𝐷𝑜𝑐𝑡𝑜𝑟𝑎))), 𝑇𝑜𝑑𝑜𝑠(𝐻𝑖𝑗𝑎, 𝑌(𝑃𝑟𝑜𝑓𝑒𝑠𝑜𝑟𝑎, 𝑆𝑎𝑡𝑖𝑠𝑓𝑎𝑐𝑒(𝐷𝑒𝑝𝑎𝑟𝑡𝑎𝑚𝑒𝑛𝑡𝑜, 𝐹í𝑠𝑖𝑐𝑎, 𝑄𝑢í𝑚𝑖𝑐𝑎))) Quizás el aspecto más importante de la lógica de descripciones sea el énfasis que se pone en la tratabilidad de la inferencia. Los problemas se resuelven mediante su descripción y cuestionando si se le puede subsumir mediante una de varias categorías posibles de solución. En los sistemas promedio de lógica de primer orden, muchas veces es imposible predecir cuál va a ser el tiempo necesario para hallar la solución. Frecuentemente se deja al usuario diseñar la representación que permita evitar aquellos conjuntos de oraciones que probablemente sean las causantes de que el sistema emplee varias semanas en resolver un problema. El énfasis en la lógica de descripciones, por otra parte, es garantizar que la prueba de subsuposición pueda ser resuelta en un tiempo que sea una función polinómica del tamaño de la descripción del problema. El lenguaje CLASSIC satisface esta condición y, hasta la fecha, es el lenguaje más completo que es capaz de hacerlo. En principio, lo anterior parecería hasta que uno se da cuenta que entraña dos consecuencias: los problemas difíciles no se pueden formular, o ¡requieren de descripciones de varias extensiones exponenciales! A pesar de lo anterior, los resultados obtenidos en la tratabilidad arrojan luz sobre qué tipos de estructuras causan problemas, y esto ayuda al usuario a comprender el comportamiento de las
Observe que el lenguaje no nos permite limitarnos a afirmar que un concepto o una categoría es subconjunto de otro. Lo anterior es deliberado; la subsuposición entre categorías debe obtenerse a partir de ciertos aspectos de las descripciones de las categorías. De no ser así, seguramente algo está faltando en las descripciones.
24-3-2009 diversas representaciones. Por ejemplo, la lógica de descripciones por lo general carece de la negación y de la disyunción. Ambas fuerzan a los sistemas lógicos de primer orden a producir análisis de cada caso de tipo exponencial si es que se desea garantizar la completez. Por la misma razón se les ha excluido de Prolog. CLASSIC acepto solo una variable limitada de la disyunción, las estructuras SatisfaceQue y UnaDe, que permiten aplicar la disyunción en unos individuos específicamente designados, pero no en las descripciones. En el caso de las descripciones disyuntivas, las definiciones anidadas dan lugar fácilmente a una cantidad exponencial de rutas alternas, en las que una categoría subsuma a otra.
7.1 Aplicaciones Prácticas de las Lógicas de Descripción
Puesto que aúnan una clara semántica a operaciones lógicas sencillas, las lógicas por descripción han gozado de mucha popularidad en las comunidades de IA, tanto la teórica como la práctica. Entre las aplicaciones figura la administración financiera, las interfaces de bases de datos y los sistemas de información de software. Gracias a la gradual ampliación de la clase de lenguajes tratables y a una mejor comprensión de qué tipo de estructuras causan la intratabilidad, la eficiencia de la descripción de los sistemas lógicos ha mejorado notablemente desde la década pasada.
8 MANEJO DE RETRACTACIONES, SUPOSICIONES Y EXPLICACIONES
Hasta ahora se ha hablado mucho de DECIR y PREGUNTAR, pero muy poco de RETRACTAR. La mayoría de los sistemas de razonamiento lógico, independientemente de cómo se les haya implantado, guardan relación con RETRACTAR. Como hemos visto, existen tres motivos para retractar una oración. Puede ser que un hecho haya perdido su importancia y deseamos eliminarlo y así liberar espacio para otros fines. Puede ser que el sistema esté llevando un control del estado actual del mundo (y no le importe lo que haya sucedido en el pasado) y que el mundo esté evolucionando. O puede ser que el sistema dé por sentado (o concluya) que un hecho fue verdad, pero ahora se desea suponer (o concluye) que en realidad es falso. En cualquier caso, deseamos tener capacidad para retractar una oración de la base de conocimientos sin introducir inconsistencia alguna, y también deseamos que la interacción con la base de conocimientos en cuanto un todo sea eficiente (el ciclo de invocaciones a DECIR, PREGUNTAR y RETRACTAR). No se necesita mucha experiencia para ver en donde está el problema. Primero, es importante diferenciar entre RETRACTAR(BC, P) y DECIR (BC, ~P). Suponiendo que en la base de conocimientos esté ya P, el introducir mediante DECIR a ~P nos permitirá concluir tanto P como ~P, en tanto que la eliminación de P utilizando RETRACTAR nos permitirá concluir ni P ni ~P. En segundo lugar, si el sistema realiza algún encadenamiento hacia delante, RETRACTAR tiene más trabajo que realizar. Supóngase que a la base de conocimientos se le dijo P y que P  Q, y se utilizó parar inferir Q e incorporarla a la base de conocimientos. Entonces RETRACTAR(BC, P) deberá eliminar tanto a P como a Q para mantener la consistencia de la base de conocimientos. Sin embargo, si existe alguna otra razón independiente para creer Q (quizá se aseveró tanto R como R  Q), entonces no será necesario eliminar Q. Al procedimiento que consiste en llevar un control de qué proposiciones adicionales hay que retractar cuando se retracta P se le conoce como mantenimiento de la verdad.
24-3-2009 El método más sencillo de mantenimiento de la verdad consiste en el empleo de la reversión cronológica. En este método se lleva un control del orden en el que se incorporan las oraciones a la base de conocimientos numerándoles de P1 a Pn. Al invocar RETRACTAR (Pi) el sistema regresa al estado justo antes de que se incorporara Pi. Si así se desea, se puede incorporar de nuevo las oraciones de la P i+1 a la Pn. Este procedimiento es sencillo y garantiza la consistencia de la base de conocimientos, pero también implica que la retracción sea O(n), en donde n es el tamaño de la base de conocimientos. Sería preferible un método más eficiente, en el que no fuera necesario duplicar todo el trabajo que implica ir de Pi+1 a Pn. Un sistema de mantenimiento de la verdad, o SMV es un programa que lleva el control de las dependencias presentes entre las oraciones con el fin de hacer más eficiente la retractación (y en algunas otras operaciones). Un sistema SMV realizar cuatro importantes funciones. La primera consiste en que permite la reversión controlada por dependencia, lo que posibilita evitar la ineficiencia de la reversión cronológica. Una segunda e igualmente importante función es ofrecer explicaciones de las proposiciones. Una demostración es un tipo de explicación, si se pregunta “Explique por qué considera que P es verdad”, la prueba de P será una buena explicación. Si no es posible dar una demostración, una buena explicación sería aquella en la que figuran suposiciones. Por ejemplo, si preguntamos “Explique por qué no arranca el carro”, quizás no haya evidencias suficientes para demostrar nada, pero una buena explicación sería: “Si damos por hecho que el auto tiene combustible, que éste llega a los cilindros, entonces la ausencia de actividad que se ha observado demuestra que debe haber una falla en el sistema eléctrico”. Técnicamente, la explicación E de una oración P se define como una conjunto de oraciones tales que E implique a P. Las oraciones de E deben ser ciertas (es decir, están en la base de conocimientos) o se sabe que son suposiciones que el solucionador de problemas ha hecho. Para evitar que toda la base de conocimientos sea una explicación, insistiremos en que E sea mínima, es decir, que no haya un subconjunto de E que también sea una explicación. La capacidad para manejar suposiciones y explicaciones es crucial para la tercera función de un SMV: el razonamiento por omisión. En un sistema taxonómico que puede manejar excepciones, el decir que Opus es un pingüino no sanciona la inferencia irrefutable de que Opus tiene dos piernas, puesto que toda información adicional sobre Opus invalidaría la creencia deducida. Un SMV puede deducir la explicación de que Opus, en cuanto que es un pingüino, tiene dos piernas siempre y cuando no sea un pingüino anormal. En este caso, la falta de anormalidad se convierte en suposición explicita. Por último, los SMV ayudan a manejar las inconsistencias. Si la incorporación de P a la base de conocimientos produce una contradicción lógica, un SMV es útil para señalar la explicación de lo que es la contradicción. Existen diversos tipos de SMV. El más sencillo es el sistema de mantenimiento de la verdad basado en la justificación o SMVJ. En este caso, en cada una de las oraciones de la base de conocimientos se indica cual justificación identifica las oraciones a partir de la cual la primera se infirió, si es que existen. Por ejemplo si Q se infiere mediante Modus Ponens de P, el conjunto de oraciones {P, P  Q} serviría de justificación de la oración Q. Algunas oraciones tienen más de una justificación. Éstas sirven para efectuar retractaciones selectivas. Si luego de incorporar Pi a través de Pn, obtendremos la invocación de RETRACTAR (Pi), y el SMVJ eliminará de la base de
24-3-2009 conocimientos justo las oraciones para las que Pi es la parte requerida de todas las justificaciones. Así, si la única justificación de una oración Q fuese {Pi, Pi  Q} se le elimina; si tuviera además la justificación {Pi, Pi V R  Q} también se eliminaría; pero si también tuviera la justificación {R, Pi V R  Q}; entonces se conservaría.
En la mayoría de las implantaciones de SMVJ, se supone que las oraciones consideradas una vez, posiblemente se vuelvan a tomar en consideración. Por ello, en vez de eliminar la oración de la base de conocimientos cuando pierde su justificación, lo único que se hace es marcar la oración como fuera de la base de conocimientos. Si una aseveración posterior le devuelve la justificación, marcamos la oración como que nuevamente esté dentro. De esta manera, los SMVJ, supondremos primero (es decir, aseveramos) que el auto tiene combustible y que llega a los cilindros. A estas oraciones se les etiquetará como dentro. Suponiendo que se cuenta con el conocimiento de base adecuado, la oración que representa el hecho de que el carro no arranca se etiquetará como fuera. Ahora podemos decir una explicación al SMVJ. Por otra parte, si resultase que las suposiciones hechas no fuesen suficientes (es decir, si no producen un “el carro no arranca” estado dentro), debemos retractar las suposiciones originales y formular otras nuevas. Todavía tenemos pendiente un problema de búsqueda: el SMV solo hace parte del trabajo. Los SMVJ fueron el primer tipo de SMV, pero el tipo más popular es el SMVS, o sistema de mantenimiento de la verdad basado en suposiciones. La diferencia reside en que SMVJ representa un estado consistente del mundo a la vez. El mantener la justificación le permitirá a usted pasar rápidamente de un estado a otro, efectuando solo unas cuantas retractaciones y aseveraciones, pero representando solo un estado a la vez. Un SMVS representa todos los estados que se han considerado, simultáneamente. Mientras que un SMVJ se limita a etiquetar cada una de las oraciones como dentro o fuera, el SMVS lleva el control, por cada oración, de qué suposiciones harán que la oración sea verdadera. Es decir, cada oración tiene una etiqueta que está formada por un conjunto de suposiciones. La oración se cumple sólo en aquellos casos en los que todas las suposiciones de uno de los conjuntos de suposición se cumplen. Para resolver problemas mediante SMVS, se pueden hacer suposiciones (como Pi o “combustible en el auto”) en el orden que prefiramos. En vez de retractar las suposiciones cuando falla una línea de razonamiento, solo afirmamos todas las suposiciones que nos interesen, incluso si unas contradicen a otras. Luego procedemos a verificar una oración en particular para definir las condiciones en las que si se cumple. Por ejemplo, la etiqueta en la oración Q sería {{Pi}, {R}}, lo que significa que Q es verdad bajo el supuesto de que Pi es verdad o bajo el supuesto de que R es verdad. Una oración en la que uno de sus conjuntos de supuestos sea un conjunto vacio, necesariamente es verdadera; verdadera por no tener ninguna suposición. Por otra parte, una oración que no tenga conjuntos de suposición sencillamente es falsa. Los algoritmos empleados en la implantación de los sistemas de mantenimiento de la verdad son un poco complicados y no hablaremos de ellos aquí. La complejidad de cómputo del problema de mantenimiento de la verdad es por lo menos tan grande como la inferencia proposicional, es decir, de dificultad NP. Por ello, no es de esperar que el mantenimiento de la verdad sea una panacea (excepto en problemas pequeños y triviales). Pero cuando se utiliza con cuidado (por ejemplo, cuando existe la opción
24-3-2009 respaldada por un conocimiento acerca de lo que es un hecho que no es posible retractar), un SMV puede ser parte importante de un sistema lógico.
Este trabajo ha servido para establecer la conexión entre los fundamentos conceptuales de la representación del conocimiento y el razonamiento, y el mundo práctico de los sistemas de razonamiento reales. Se pone énfasis en el hecho de que una auténtica comprensión de estos sistemas sólo se puede lograr cuando se trabaja con ellos. Se han explicado las técnicas de implantación y las características de los cuatro tipos más importantes de sistemas de razonamiento lógico:     Sistemas de programación lógica y demostradores de teoremas. Sistemas de producción Redes semánticas Lógicas de descripción
Hemos visto que existe un compromiso entre la expresividad de un sistema y su eficiencia. La compilación puede ayudar a elevar la eficiencia al aprovechar el hecho de que el conjunto de oraciones se determina por adelantado. La facilidad de uso se favorece mediante una semántica clara para el lenguaje de representación y simplificando el modelo de ejecución de manera que el usuario pueda hacerse una buena idea de los cálculos necesarios para realiza una inferencia.
10 BIBLIOGRAFÍA Y LINKOGRAFÍA
 Russell, S., & Norvig, P. (2004). Inteligencia Artificial: Un Enfoque Moderno. Madrid: Prentice Hall.
 http://es.wikipedia.org/wiki/Razonamiento_automatizado  http://www.mitecnologico.com/Main/SistemasDeRazonamientoLogico  http://www.angelfire.com/falcon/popikpe/cap_diez.htm
Documents Similar To Sistemas de Razonamiento Lógico

References: resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución