S ISTEMAS DE

R AZONAMIENTO L ÓGICO
Inteligencia Artificial

Universidad Nacional del Santa

Facultad de Ingeniería
E.A.P. de Ingeniería de Sistemas e Informática
24/03/2009
 24-3-2009

Contenido
1 Introducción.......................................................................................................................... 3
2 Indización, Recuperación y Unificación .............................................................................. 5
2.1 Implantación de Oraciones y Términos ...................................................................... 5
2.2 Guardar y Recoger ....................................................................................................... 5
2.3 Indización Basada en Tablas ....................................................................................... 6
2.4 Indización Basada en Árboles ..................................................................................... 7
2.5 El Algoritmo de Unificación ........................................................................................ 9
3 Sistemas de Programación Lógicos ................................................................................... 10
3.1 El Lenguaje Prolog ..................................................................................................... 10
3.2 Implantación .............................................................................................................. 11
3.3 Compilación de Programas Lógicos .......................................................................... 13
3.4 Otros Lenguajes de Programación ............................................................................ 14
3.5 Recursos Avanzados de Control ................................................................................ 15
4 Demostradores de Teoremas ............................................................................................. 17
4.1 Diseño de un Verificador de Teoremas ..................................................................... 17
4.2 Ampliación de Prolog ................................................................................................. 18
4.3 Los Verificadores de Teoremas como Auxiliares ...................................................... 19
4.4 Aplicaciones Prácticas de los Demostradores de Teoremas .................................... 20
5 Sistemas de Producción por Encadenamiento Hacia Adelante ...................................... 21
5.1 Fase de Cotejo ............................................................................................................ 22
5.2 Fase de Solución de Conflictos .................................................................................. 23
5.3 Aplicaciones Prácticas de los Sistemas de Producción ............................................ 23
6 Sistemas de Marco y Redes Semánticas ........................................................................... 24
6.1 Sintaxis y Semántica de las Redes Semánticas ....................................................... 25
6.2 Herencia con Excepciones.......................................................................................... 26
6.3 Herencia Múltiple ...................................................................................................... 27
6.4 Herencia y Cambio ..................................................................................................... 28
6.5 Implantación de Redes Semánticas .......................................................................... 29
6.6 Expresividad de las Redes Semánticas .................................................................... 31
7 Lógicas para la Descripción ............................................................................................... 31
7.1 Aplicaciones Prácticas de las Lógicas de Descripción .............................................. 33
8 Manejo de Retractaciones, Suposiciones y Explicaciones ............................................... 33
9 Resumen ............................................................................................................................. 36
10 Bibliografía y Linkografía ................................................................................................. 36

1
 24-3-2009

TABLA DE FIGURAS
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

2
 24-3-2009

SISTEMAS DE RAZONAMIENTO LÓGICO

Inteligencia Artificial

1 INTRODUCCIÓN
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

3
 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: KL-
ONE, 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.

4
 24-3-2009

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:

𝐴, ∼ 𝐵, ∼ 𝐶, 𝐷

5
 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))

1 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).

6
 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 Positivo Negativo Conclusión Premisa

Hermano Hermano(Ricardo, ~Hermano(Ann, Hermano(x, Hermano(x,
Juan) Sam) y) ∧ y) ∧
Hermano(Ted, Masculino(y) Masculino(y)
Jack) ⟹ ⟹
Hermano(Jack, Hermano(y, Hermano(y,
Bobbie) x) x)
Hermano(x,
y) ⟹
Masculino(x)
Masculino Masculino(Jack) ~Masculino(Ann) Hermano(x, Hermano(x,
Masculino(Ted) … y) ⟹ y) ∧
… Masculino(x) Masculino(y)
⟹
Hermano(y,
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

7
 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?
Hermano

¿Primer
argumento?
012-34-5678

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

8
 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

9
 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 encuen-
tra 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.

10
 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

3 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.

11
 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-HACIA-
ATRÁ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 UNIFICAR-
VAR, 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,

13
 24-3-2009
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

14
 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

15
 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.

16
 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

18
 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

19
 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

20
 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.

21
 24-3-2009

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.

4 Rete es red en latín.

22
 24-3-2009

D A=D añadir E

A B A=B C añadir D

A(1), A(2) B(2), B(3), B(4) A(2) C(5) D(2)

B(2)

E borrar A

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

23
 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.

5 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.

24
 24-3-2009

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 y
𝑆𝑢𝑏𝑐𝑜𝑛𝑗𝑢𝑛𝑡𝑜
, 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

6 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 ().

25
 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.

26
 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

27
 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

8 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.

28
 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 Memo y
𝐴𝑚𝑖𝑔𝑜
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.

29
 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-Mi-
Cuadra-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.

30
 24-3-2009

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.

31
 24-3-2009
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

9 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.

32
 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.

33
 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

34
 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

35
 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.

9 RESUMEN
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

BIBLIOGRAFÍA
 Russell, S., & Norvig, P. (2004). Inteligencia Artificial: Un Enfoque Moderno.
Madrid: Prentice Hall.

LINKOGRAFÍA
 http://es.wikipedia.org/wiki/Razonamiento_automatizado
 http://www.mitecnologico.com/Main/SistemasDeRazonamientoLogico
 http://www.angelfire.com/falcon/popikpe/cap_diez.htm

36