Prolo PDF

Alejandro Guerra-Hernandez
Metodologas de Programacion I
Programacion Logica
5 de noviembre de 2009
Departamento de Inteligencia Artificial

Sebastian Camacho No. 5, Xalapa, Ver.,
Mexico 91000
Indice general
1. Introduccion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1. Breve historia de la programacion logica. . . . . . . . . . . . . . . . . . . . . . . . 1
1.2. Una breve introduccion a Prolog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.1. Hechos y relaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.2. Reglas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.3. Definicion de reglas recursivas . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3. Como computa Prolog una solucion? . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.4. Organizacion del curso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Parte I Formalismos
2. Logica de Primer Orden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.1. Introduccion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2. Sistemas formales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.3. El lenguaje de la logica de primer orden . . . . . . . . . . . . . . . . . . . . . . . . 23
2.3.1. Sintaxis de la logica de primer orden . . . . . . . . . . . . . . . . . . . . 25
2.4. La semantica de la logica de primer orden . . . . . . . . . . . . . . . . . . . . . . 26
2.4.1. Teora de modelo de la logica de primer orden . . . . . . . . . . . . 27
2.5. Inferencia en la logica de primer orden . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.6. Substituciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3. Clausulas y Programas Definitivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

3.1. Clausulas definitivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.2. Programas definitivos y Metas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.3. El modelo mnimo de Herbrand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.3.1. Resultados concernientes a los modelos de Herbrand . . . . . . 39
3.3.2. Construccion del modelo mnimo de Herbrand . . . . . . . . . . . . 41
4. Principio de Resolucion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.1. Introduccion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.2. Que es un procedimiento de prueba? . . . . . . . . . . . . . . . . . . . . . . . . . . 44
V
VI Indice general
4.3. Pruebas y programas logicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

4.4. Substitucion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.5. Unificacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4.6. Resolucion-SLD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4.6.1. Propiedades de la resolucion-SLD . . . . . . . . . . . . . . . . . . . . . . 55
5. Negacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
5.1. Introduccion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
5.2. La complecion de un programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
5.3. Resolucion SLDNF para programas definitivos . . . . . . . . . . . . . . . . . . 62
5.4. Programas Logicos Generales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
5.5. Resolucion SLDNF para programas generales . . . . . . . . . . . . . . . . . . . 67
6. Corte y Aritmetica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
6.1. Corte: podando el arbol-SLD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
6.2. Aritmetica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Parte II Prolog
7. Introduccion a Prolog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
8. Estrategias basicas de resolucion de problemas . . . . . . . . . . . . . . . . . . . . 85

8.1. Introduccion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
8.2. Busqueda primero en profundidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
8.3. Busqueda primero en amplitud . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
8.4. Busqueda primero el mejor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
9. Sistemas Expertos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
9.1. Introduccion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
9.2. Caractersticas de los SE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
9.2.1. Razonamiento basado en metas . . . . . . . . . . . . . . . . . . . . . . . . 101
9.2.2. Incertidumbre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
9.2.3. Razonamiento guiado por los datos . . . . . . . . . . . . . . . . . . . . . 102
9.3. Usando la maquina de inferencia de Prolog . . . . . . . . . . . . . . . . . . . . . 103
9.3.1. Reglas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
9.3.2. Reglas para relaciones jerarquicas . . . . . . . . . . . . . . . . . . . . . . 104
9.3.3. Reglas para otras relaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
9.4. Interfaz del usuario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
9.5. Un Shell simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
9.5.1. REPL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
9.6. Encadenamiento haca atras con incertidumbre . . . . . . . . . . . . . . . . . . 111
9.6.1. Factores de certidumbre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
9.6.2. Factores de certidumbre a la MYCIN . . . . . . . . . . . . . . . . . . . 114
9.6.3. Formato de las reglas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
9.6.4. La maquina de inferencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
9.6.5. Interfaz con el usuario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Indice general VII
10. Arboles de Decision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

10.1. Representacion de los arboles de decision . . . . . . . . . . . . . . . . . . . . . . 121
10.2. Problemas apropiados para la aplicacion de arboles de decision . . . . 123
10.3. El algoritmo basico de aprendizaje de arboles de decision . . . . . . . . . 124
10.3.1. Que atributo es el mejor clasificador? . . . . . . . . . . . . . . . . . . 124
10.3.2. Entropa y ganancia de informacion . . . . . . . . . . . . . . . . . . . . . 126
10.4. Espacio de hipotesis en el aprendizaje inductivo de arboles de
decision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
10.5. Sesgo inductivo en el aprendizaje de arboles de decision . . . . . . . . . . 128
10.5.1. Sesgo por restriccion y sesgo por preferencia . . . . . . . . . . . . . 129
10.5.2. Porque preferir hipotesis mas compactas? . . . . . . . . . . . . . . . 129
10.6. Consideraciones sobre el aprendizaje inductivo de arboles de
decision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
10.6.1. Evitando un sobreajuste con los datos de entrenamiento . . . . 130
10.6.2. Incorporando valores contnuos . . . . . . . . . . . . . . . . . . . . . . . . 132
10.6.3. Medidas alternativas para la seleccion de atributos . . . . . . . . 133
10.7. Implementacion el Prolog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
10.7.1. Atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
10.7.2. Distribucion de clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
10.7.3. El mejor atributo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
10.7.4. El arbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
10.7.5. Imprimiendo el arbol construido. . . . . . . . . . . . . . . . . . . . . . . . 139
10.7.6. Ejecutando todo el experimento . . . . . . . . . . . . . . . . . . . . . . . . 140
10.7.7. Predicados auxiliares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
11. Planeacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

11.1. Acciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
11.2. Analisis medios-fines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
11.3. Metas protegidas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
11.4. Aspectos procedimentales de la busqueda en amplitud . . . . . . . . . . . . 149
11.5. Regresion de metas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
11.6. Combinando planeacion medios fines con primero el mejor . . . . . . . 154
11.7. Variables y planes no lineales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
11.7.1. Acciones y metas no instanciadas . . . . . . . . . . . . . . . . . . . . . . . 159
11.7.2. Planes no lineales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Referencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Acronimos
Implicacion material
CWA Suposicion del mundo cerrado (Closed World Assumption).
fbf Formula bien formada (wff - well formed formula).
FOL Logica de primer orden (First-Order Logic).
FOPC Calculo de predicados en primer orden (First-Order Predicate Calculus).
IA Inteligencia Artificial.
LFOL El lenguaje de la logica de primer orden.
MGU Unificador mas general (Most General Unifier).
NAF Negacion por fallo finito (Negation as Finite Failure).
R Funcion de seleccion en la resolucion-SLD.
ssi Si y solo si.
WAM Maquina abstracta de Warren (Warren Abstract Machine).
U Universo de discurso. En ciertas ocasiones se presentara como D (domi-
nio).
IX
Captulo 1
Introduccion
Resumen El tema de este curso de metodologas de programacion es la programa-

cion logica. En este captulo se presenta un panorama general de este paradigma de
programacion, con el objetivo de que ustedes puedan responder a Porque y para
que es necesario estudiar a la programacion logica en un curso de su maestra en
Inteligencia Artificial (IA)? Para ello, se revisaran algunas notas historicas sobre los
origenes de la programacion logica y Prolog, su lenguaje de programacion mas co-
nocido; se experimentara con el uso de Prolog; y se revisara brevemente cuales son
los fundamentos teoricos del paradigma. Finalmente, el captulo ofrece la organiza-
cion del material que revisaremos en el resto del curso.
1.1. Breve historia de la programacion logica.
La historia reciente, y a la francaise, de la programacion logica comienza en

julio de 1970 en Montreal, Canada, donde Alain Colmerauer, Philippe Roussel y
Robert Pasero [4] trabajaban en un proyecto sobre traduccion automatica y procesa-
miento del lenguaje natural. El sistema en cuestion inclua analizadores sintacticos
y generadores de frases para el frances. Un estudiante de Colmerauer, decidio tra-
bajar sobre la demostracion automatica de teoremas, con base en el trabajo sobre el
principio de resolucion de Alan Robinson [15]. La conjuncion de estos trabajos dio
como resultado una interfase entre el frances y las formulas logicas del demostrador
de teoremas que permita interacciones como que se muestra en el cuadro 1.1.
Este sistema haca uso de constantes para designar elementos (Tom, Jerry, Max,
Queso); para designar conjuntos (Gatos, Ratones, Ratones que comen queso, etc.);
y relaciones binarias (Matar, Comer, Gustar, No gustar). Las constantes, junto con
los smbolos funcionales T he, Subset, y True, especificaban un lenguaje de formu-
las logicas. Mientras se segua trabajando en la demostracion de teoremas en este
lenguaje, aparecio la referencia obligada al trabajo de Robert Kowalski [7] sobre
el metodo conocido como resolucion-SL, que como veremos, es fundamental en el
lenguaje Prolog.
1
2 1 Introduccion
Usuario > Los gatos matan ratones.

Usuario > Tom es un gato al que no le gustan los ratones
que comen queso.
Usuario > Jerry es un raton que come queso.
Usuario > Max no es un gato.
Usuario > Que hace Tom?
Computadora > A Tom no le gustan los ratones que comen
queso.
Computadora > Tom mata ratones.
Usuario > Quien es un gato?
Computadora > Tom.
Usuario > Que come Jerry?
Computadora > Queso.
Usuario > Que come Tom?
Computadora > Lo que comen los gatos a los que no les gustan
los ratones que comen queso.
Cuadro 1.1 Sistema de lenguaje natural de Alain Colmerauer et al. [4].
En realidad, la creacion de este paradigma de programacion tiene una larga his-

toria mas universal, cuya mayor parte transcurre en los dominios de la logica ma-
tematica y recientemente en el de las ciencias de la computacion. La programacion
logica se basa en la sintaxis de la logica de primer orden, originalmente propues-
ta por Gottlob Frege en la segunda mitad del siglo XIX y modificada a su forma
actual por Giuseppe Peano y Bertrand Russell. En la decada de los anos treinta,
Kurt Goedel y Jacques Herbrand estudiaron la nocion de computabilidad basada
en derivaciones. Su trabajo puede verse como el origen de la computacion como
deduccion. Ademas, Herbrand discutio en su tesis doctoral un conjunto de reglas
para manipular ecuaciones algebraicas en terminos que pueden verse ahora como un
bosquejo de la unificacion. Treinta anos mas tarde, Alan Robinson [15] publico su
artculo fundacional sobre la demostracion automatica. En este trabajo se introduce
el principio de resolucion, la nocion de unificacion y un algoritmo de unificacion.
Y es que, si bien el paradigma de la programacion logica tiene sus races en la
demostracion automatica de teoremas, de donde tomo la nocion de deduccion, pre-
senta una novedad importante: en el proceso de demostracion algunos valores seran
computados. Pero otro paso era necesario para vislumbrar como es posible computar
en este marco.
En 1974, Robert Kowalski [6] introduce la nocion de programas logicos con una
forma restringida de resolucion. La sintaxis propuesta por Kowalski era mas res-
tringida que la de Robinson, pero tena un efecto colateral sobre la forma de una
substitucion satisfactoria. Esta substitucion puede verse como el resultado de una
computacion, y en consecuencia, ciertas formulas logicas (clausulas de Horn) pue-
den interpretarse como programas. El trabajo de Kowalski termino un debate del
todo relevante para nosotros: dadas las metas de la inteligencia artificial El cono-
cimiento debe representarse de forma declarativa o procedimental? Si la forma
declarativa era la adecuada, tal como defenda John McCarthy [8], la realizacion
de la inteligencia artificial pasaba por representar el conocimiento en calculo de
predicados e implementar procedimientos de prueba eficientes sobre este lenguaje;
1.2 Una breve introduccion a Prolog 3
Si la forma procedimental era la adecuada, entonces tal realizacion pasaba por la

implementacion de procedimientos organizados como una sociedad de agentes que
compiten y cooperan, tal como lo resume Marvin Minsky [9]. Los programas logi-
cos de Kowalski tienen evidentemente una interpretacion declarativa, pero tambien
procedimental.
Entre 1971 y 1973 Kowalski y Colmeraruer colaboraron intensamente, conclu-
yendo con la creacion de Prolog en 1973. Prolog puede verse como la realizacion
practica del concepto de programa logico. Aunque sus inicios estuvieron enfocados
al procesamiento del lenguaje natural, pronto se encontro que Prolog poda ser usado
como un lenguaje de programacion de proposito general. Originalmente, Prolog fue
implementado por Philippe Roussel como un interprete escrito en Algol-W. Un paso
adelante fue logrado por David H. Warren [20] quien propuso en 1983 una maquina
abstracta, ahora conocida como WAM (Warren Abstract Machine). La WAM cuen-
ta con un conjunto de instrucciones para compiladores de Prolog independientes de
la maquina y se convirtio en el estandar para la implementacion de Prolog y otros
lenguajes logicos de programacion.
De esta breve historia (para una version mas detallada ver J.A. Robinson [16])
podemos extraer algunas consideraciones sobre este curso:
La programacion logica es una herramienta y un sujeto de estudio de la inteli-
gencia artificial.
La logica de primer orden es fundamental para entender este paradigma de pro-
gramacion.
La programacion logica es un paradigma de programacion, que difiere de otros
paradigmas, como la programacion imperativa (Algol, C, Pascal, etc.), la orien-
tada a objetos (Simula, Smalltalk, Eiffel, C++, Java, etc.), o la funcional (ML,
Haskell, Lisp, etc.).
Prolog 6= programacion logica, pero es su realizacion practica mas usada en la
actualidad.
1.2. Una breve introduccion a Prolog
Prolog es la realizacion mas utilizada del paradigma de programacion logica.

Escribir un programa en Prolog tiene menos que ver con la tarea de especificar un
algoritmo, como es el caso de la programacion imperativa; y mas con la especifi-
cacion de los objetos y las relaciones entre ellos, que ocurren en el contexto de un
problema. En particular, tiene que ver con la especificacion de las relaciones que
conforman la solucion deseada del problema. Veamos un ejemplo basado en la ge-
nealoga de una familia [1].
4 1 Introduccion
1.2.1. Hechos y relaciones
La figura 1.1 muestra una relacion familiar, donde las flechas X Y indican
que X es progenitor Y . El hecho de que Tom sea progenitor de Bob 1 se escribe en
Prolog: progenitor(tom,bob).
pam tom
bob liz
ann pat
jim
Figura 1.1 Una relacion familiar.
Hemos escogido progenitor como el nombre de una relacion que tiene a tom
y bob como argumentos. Por razones que explicaremos mas adelante, escribimos
los nombres como tom con minuscula inicial. Para indicar que esta relacion tiene
dos argumentos escribimos progenitor/2 y decimos que progenitor tiene aridad 2.
El arbol familiar completo puede definirse como un programa en Prolog:
1 progenitor(pam,bob).
2 progenitor(tom,bob).
3 progenitor(tom,liz).
4 progenitor(bob,ann).
5 progenitor(bob,pat).
6 progenitor(pat,jim).
Este programa consta de seis clausulas. Cada una de estas clausulas declara un
hecho sobre la relacion progenitor. Por ejemplo, progenitor(tom,bob) es un
caso particular de la relacion progenitor. Una relacion esta definida por el conjunto
de todos sus casos.
Podemos editar un archivo con este programa Prolog y llamarlo clase01.pl.
Para utilizar este programa es necesario invocar a Prolog, por ejemplo, si usamos
1 Decid usar una familia gringa, porque nuestros bellos nombres como Mara del Pilar, no caben
en un grafo facil de leer. Si usted quiere llamar a Tom, Pancho; eso, como veremos, no cambia en
nada la historia que voy a contar (a condicion de que Pancho sea siempre Pancho).
SWI Prolog, en una terminal invocaramos swipl (o pl en algunos sistemas ope-

rativos):
> swipl
Welcome to SWI-Prolog (Multi-threaded, 32 bits, Version 5.6.64)
Copyright (c) 1990-2008 University of Amsterdam.
SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is free
software, and you are welcome to redistribute it under certain
conditions.
Please visit http://www.swi-prolog.org for details.
For help, use ?- help(Topic). or ?- apropos(Word).
?-
El smbolo ?- es el indicador de que Prolog espera una instruccion. Si tenemos

un archivo llamado clase01.pl con el conjunto de casos que define la relacion
progenitor, podemos consultarla desde SWI Prolog:
?- [clase01].
% clase01 compiled 0.00 sec, 168 bytes
Yes
?-
Prolog responde que el programa clase01 ha sido compilado (Saban ustedes

que el codigo de Prolog es compilado?) y espera una nueva instruccion. La instruc-
cion puede ser la pregunta Es progenitor Bob de Pat?
?- progenitor(bob,pat).
Yes
a lo que Prolog respondera Yes, al encontrar que ese hecho se encuentra en nuestro
programa. Si preguntamos Es Liz progenitora de Pat? obtendremos como respuesta
No, porque nuestro programa no menciona nada (Haban escuchado el termino
supuesto del mundo cerrado?) acerca de que Liz sea progenitora de Pat:
?- progenitor(liz,pat).
No
Lo mismo sucede con la siguiente consulta, pues Ben no es siquiera un objeto

conocido por nuestro programa, esto es, Ben no aparece en ninguna parte de nuestro
codigo:
?- progenitor(tom,ben).
No
Una pregunta mas interesante sobre la relacion progenitor es Quien es el proge-

nitor de Liz? Lo cual puede preguntarse como:
?- progenitor(X,liz).
X = tom
Yes
6 1 Introduccion
Prolog computa un valor para X tal que la relacion progenitor se cumple. Si

preguntamos por los hijos de Bob, tendremos varas respuestas posibles. Para obte-
nerlas todas, es necesario teclear ; y - o Enter despues de cada respuesta de
Prolog:
?- progenitor(bob,X).
X = ann ;
X = pat ;
No
Prolog nos da las respuestas ann, pat y al no haber mas respuestas posibles,
responde No.
Es posible plantear preguntas mas complicadas a nuestro programa, por ejemplo
Quien es abuelo/a de Jim? Como nuestro programa no conoce directamente la rela-
cion abuelo/2, esta pregunta debe descomponerse en dos preguntas como lo muestra
la figura 1.2:
1. Quien es el progenitor de Jim? Asumamos que es alguien Y .
2. Quien es el progenitor de Y? Asumamos que es alguien X.
progenitor
Y abuelo
progenitor
jim
Figura 1.2 La relacion abuelo expresada como una composicion de dos relaciones progenitor.
La secuencia de preguntas en Prolog es como sigue:
?- progenitor(Y,jim), progenitor(X,Y).
Y = pat
X = bob
Yes
Si invertimos el orden de las dos preguntas, el resultado sigue siendo el mismo:
?- progenitor(X,Y), progenitor(Y,jim).
X = bob
Y = pat
Yes
Podemos preguntar tambien Quien es nieto de Tom?:
?- progenitor(tom,X), progenitor(X,Y).
X = bob
Y = ann ;
X = bob
Y = pat ;
No
Otra pregunta interesante sera Tienen Ann y Pat progenitores en comun? Esto
puede descomponerse nuevamente en dos preguntas:
1. Quien es el progenitor X de Ann?
2. Es X (el mismo) progenitor de Pat?
?- progenitor(X,ann), progenitor(X,pat).
X = bob ;
No
?-
Resumiendo:
Es sencillo definir en Prolog una relacion, como progenitor/2, especificando las

n-tuplas de objetos que satisfacen la relacion (n, conocido como aridad, es el
numero de argumentos de la relacion, para progenitor n = 2).
El usuario puede plantear facilmente preguntas a Prolog sobre las relaciones de-
finidas en un programa.
Un programa Prolog consiste de clausulas. Cada clausula termina con un punto.
Los argumentos de una relacion pueden ser: objetos concretos o constantes como
tom y ann; objetos generales o variables como X e Y.
Las preguntas planteadas a Prolog consisten en una o mas metas. Una secuencia
de metas como progenitor(X,ann), progenitor(X,pat) significa
la conjuncion de las metas: X es progenitor de ann y X es progenitor de pat.
La respuesta a una pregunta puede ser positiva o negativa, dependiendo de si la
meta se puede satisfacer o no. En el caso de una respuesta positiva, se dice que
la meta fue satisfecha y tuvo exito. En cualquier otro caso se dice que la meta no
fue satisfecha y fallo.
Si varias respuestas satisfacen una pregunta, Prolog encontrara tantas como el
usuario quiera.
1.2.2. Reglas
Nuestro ejemplo puede extenderse en muchas formas interesantes. Definamos

las relaciones mu jer/1 y hombre/1, para poder expresarnos sobre el genero de los
miembros de nuestra familia ejemplar:
8 1 Introduccion
1 mujer(pam).
2 mujer(liz).
3 mujer(pat).
4 mujer(ann).
5 hombre(tom).
6 hombre(bob).
7 hombre(jim).
Las relaciones unarias (n = 1) se usan normalmente para expresar propiedades de

los objetos. Las relaciones binarias (n = 2) definen relaciones entre pares de objetos.
La clausula mujer(pam) establece que Pam es una mujer. La misma informacion
podra definirse como una relacion genero/2 como genero(pam,mujer).
Nuestra siguiente extension al programa sera definir la relacion vastago/2 como
la inversa de la relacion progenitor/2. Para ello podemos definir explcitamente
las tuplas que satisfacen esta relacion, por ejemplo: vastago(liz,tom, etc. Sin
embargo, se puede obtener una definicion mas elegante si tomamos en cuenta que la
relacion vastago/2 es la inversa de progenitor/2 y que progenitor/2 ya fue definida.
La alternativa se basa en el siguiente enunciado logico: Para todo X y para todo Y ,
Y es un vastago de X si existe un X que es progenitor de un Y . Esta formulacion
es muy parecida al formalismo usado en Prolog. La clausula correspondiente es la
siguiente:
1 vastago(Y,X) :- progenitor(X,Y).
La clausula puede leerse tambien como: Si X es un progenitor de Y enton-

ces Y es un vastago de X. A este tipo de clausulas se les conoce como reglas.
Existe una diferencia fundamental entre los hechos y las reglas. Un hecho como
progenitor(tom,liz) es algo que es siempre, incondicionalmente, verdade-
ro. Las reglas especifican cosas que son ciertas si alguna condicion se satisface. Por
ello decimos que las reglas tienen:
Una parte condicional (el lado derecho de la regla o cuerpo de la regla).
Una conclusion (el lado izquierdo de la regla o cabeza de la regla).
Que hace Prolog cuando se le plantea una meta como la siguiente?
?- vastago(liz,tom).
No existe ningun hecho sobre vastagos en nuestro programa, por lo tanto, la

unica alternativa es considerar la aplicacion de la regla sobre los vastagos. La regla
es general, en el sentido que es aplicable a cualquier objeto X e Y, por lo que puede
ser aplicada a constantes como liz y tom. Para aplicar la regla a liz y a tom es
necesario substituir Y por liz y X por tom. Con tal substitucion, obtenemos un
caso especial de nuestra regla:
vastago(liz,tom) :- progenitor(tom,liz).
La parte condicional de la regla es ahora:
progenitor(tom,liz).
Ahora Prolog tratara de encontrar si esta condicion es verdadera, de forma que la

meta inicial:
vastago(liz,tom).
ha sido substituida por una sub-meta progenitor(tom,liz). Esta nueva

sub-meta puede satisfacerse facilmente a partir de los hechos conocidos por el pro-
grama, lo cual significa que la conclusion de la regla tambien es verdadera, y Prolog
responde con exito:
?- vastago(liz,tom).
Yes
Especifiquemos ahora la relacion madre/2 a partir del siguiente enunciado logi-

co: Para toda X e Y , X es madre de Y si X es progenitor de Y y X es mujer. Esto se
traduce a Prolog como:
1 madre(X,Y) :- progenitor(X,Y), mujer(X).
La coma en el cuerpo de la regla, indica una conjuncion: ambas condiciones

deben ser verdaderas para que la conclusion lo sea.
Las relaciones abuela/2 y hermana/2 pueden definirse como:
1 abuela(X,Y) :- progenitor(X,Z), progenitor(Z,Y), mujer(X).

2 hermana(X,Y) :- progenitor(Z,X), progenitor(Z,Y), mujer(X).
Observen, en el caso de hermana/2, la manera de especificar que X e Y tienen un

mismo progenitor. La condicion de esta regla se lee: existe un Z que es progenitor de
X y el mismo Z es progenitor de Y y X es mujer. Graficamente la relacion hermana/2
se muestra en la figura 1.3. Ahora podemos preguntar:
?- hermana(ann,pat).
Yes
Tras nuestra primer pregunta sobre esta relacion, podemos concluir que su defi-
nicion es correcta, pero tiene un sutil error que se revela al preguntar:
?- hermana(X,pat).
X = ann ;
X = pat ;
No
10 1 Introduccion
progenitor
mujer
X progenitor
hermana
Figura 1.3 La relacion hermana.
Es correcto que Pat sea su propia hermana? Ese es el comportamiento que es-
perabamos de la definicion de hermana/2, y se debe a que no hay nada que diga que
X e Y deben ser diferentes! Esto se puede corregir definiendo hermana como:
1 hermana(X,Y) :-
2 progenitor(Z,X),
3 progenitor(Z,Y),
4 mujer(X),
5 dif(X,Y).
De forma que:
?- hermana(X,pat).
X = ann ;
No
Resumiendo:
Los programas Prolog pueden extenderse facilmente agregando nuevas clausulas.

Las clausulas en Prolog son de tres tipos: hechos, reglas y metas.
Los hechos declaran cosas que son verdaderas siempre, incondicionalmente.
Las reglas declaran cosas que son verdaderas dependiendo de ciertas condicio-
nes.
Por medio de las preguntas el usuario puede computar que cosas son verdaderas.
Las clausulas de Prolog tienen cabeza y cuerpo. El cuerpo es una lista de metas
separadas por comas. Las comas implican conjuncion.
Los hechos son clausulas con el cuerpo vaco; las preguntas tienen la cabeza
vaca; y las reglas tienen cabeza y cuerpo.
En el curso de una computacion, las variables pueden ser substituidas por otros
objetos.
Las variables se asumen cuantificadas universalmente. La cuantificacion existen-
cial solo es posible en las variables que aparecen en el cuerpo de una clausula. Por
ejemplo la clausula tiene hijo(X) :- progenitor(X,Y) puede leerse

como: Para todo X, X tiene un hijo si existe un Y y X es progenitor de Y .
1.2.3. Definicion de reglas recursivas
Agreguemos una relacion nueva a nuestro programa: la relacion ancestro/2. Esta

relacion sera definida en terminos de la relacion progenitor/2. La definicion com-
pleta puede expresarse por medio de dos reglas. La primera definiendo al ancestro
inmediato (progenitor) y la segunda a los ancestros no inmediatos. Decimos que al-
guien X es ancestro indirecto de alguien Z, si hay una cadena de progenitores desde
X hasta Z, como lo ilustra la figura 1.4. En nuestro ejemplo de la figura 1.1, Tom es
ancestro directo de Liz e indirecto de Pat.
progenitor
progenitor ancestro
X
ancestro
progenitor
progenitor
Y Y
Figura 1.4 La relacion ancestro en terminos de progenitor directo e indirecto.
La primera regla es muy sencilla y se expresa en Prolog como:
1 ancestro(X,Z) :- progenitor(X,Z).
La segunda regla es mas complicada porque las cadenas de progenitores presen-

tan un problema: no sabemos cuantas veces hay que aplicar la relacion progenitor!
Un primer intento podra ser algo como:
1 ancestro(X,Z) :-
2 progenitor(X,Z).
3 ancestro(X,Z) :-
4 progenitor(X,Y),
12 1 Introduccion
5 progenitor(Y,Z).
6 ancestro(X,Z) :-
7 progenitor(X,Y0),
8 progenitor(Y0,Y1),
9 progenitor(Y1,Z).
10 ...
Lo cual resulta en un programa largo y, peor aun, que solo funciona para un
numero limitado de ancestros, en el ejemplo: padres, abuelos y bisabuelos. Es decir,
esta definicion de ancestro/2 es correcta pero incompleta.
Existe una formulacion elegante y completa de la relacion ancestro/2, comple-
ta en el sentido que puede computar cualquier ancestro, independientemente de la
longitud de la cadena de progenitores que deba aplicarse. La idea central es definir
ancestro en terminos de si misma:
1 ancestro(X,Z) :-
2 progenitor(X,Z).
3
4 ancestro(X,Z) :-
5 progenitor(X,Y),
6 ancestro(Y,Z).
Ahora podemos preguntar De quien es ancestro Pam?
?- ancestro(pam,X).
X = bob ;
X = ann ;
X = pat ;
X = jim ;
No
O Quienes son los ancestros de Jim?
?- ancestro(X,jim).
X = pat ;
X = pam ;
X = tom ;
X = bob ;
No
Resumiendo:
Las reglas recursivas definen conceptos en terminos de ellos mismos.
Estan definidas por al menos dos casos: uno terminal (no recursivo) y la llamada
recursiva.
Una relacion recursiva define intenSionalmente un concepto.
intenSional 6= intenCional.
1.3 Como computa Prolog una solucion? 13
1.3. Como computa Prolog una solucion?
Una pregunta a Prolog es siempre una secuencia de una o mas metas. Para res-
ponder, Prolog trata de satisfacer estas metas. Que significa satisfacer una meta?
Satisfacer una meta implica demostrar que la meta es verdadera, asumiendo que
las relaciones en el programa logico son verdaderas. Satisfacer una meta significa
entonces demostrar que la meta es una consecuencia logica de los hechos y reglas
definidas en un programa. Si la pregunta contiene variables, Prolog necesita tambien
encontrar cuales son los objetos particulares (que remplazaran a las variables) para
los cuales la meta se satisface. La asignacion de valores a variables es mostrada al
usuario. Si Prolog no puede demostrar para alguna asignacion de valores a variables,
que las metas siguen logicamente del programa, la respuesta a la pregunta sera No.
En terminos matematicos, la interpretacion de un programa en Prolog es como
sigue: Prolog acepta hechos y reglas como un conjunto de axiomas, y el usuario
plantea preguntas como un teorema; entonces Prolog trata de probar este teorema,
es decir, demostrar que el teorema se sigue logicamente de los axiomas.
Veamos un ejemplo clasico. Sean los axiomas:
Todos los hombres son falibles.
Socrates es un hombre.
Un teorema que logicamente sigue de estos dos axiomas es:
Socrates es falible.
El primer axioma puede reescribirse como: Para toda X, si X es un hombre,
entonces X es falible. El ejemplo puede entonces traducirse a Prolog como sigue:
1 falible(X) :- hombre(X).
2 hombre(socrates).
?- falible(socrates)
Yes
Un ejemplo mas complicado, tomado de la familia de la figura 1.1, es la meta: ?-

ancestro(tom,pat). Sabemos que progenitor(bob,pat) es un hecho.
Podemos derivar entonces que ancestro(bob,pat). Observen que este hecho
derivado no puede ser encontrado explcitamente en nuestro programa sobre la fa-
milia, pero puede derivarse a partir de los hechos y reglas en el programa. Un paso
en la inferencia de este tipo, puede ser escrito como: progenitor(bob,pat)
ancestro(bob,pat).
El proceso completo de inferencia en dos pasos puede escribirse como:
14 1 Introduccion
progenitor(bob, pat) ancestro(bob, pat)

progenitor(tom, bob) ancestro(bob, pat) ancestro(tom, pat)
A este tipo de secuencias se les conoce como secuencias de prueba Como en-
cuentra Prolog una secuencia de prueba?
Prolog encuentra la secuencia de prueba en orden inverso al que acabamos de
presentar. En lugar de comenzar con los hechos simples especificados en el progra-
ma, Prolog comienza con las metas y, usando reglas, substituye la meta actual por
sub-metas, hasta que estas llegan a resolverse por hechos simples. Dada la pregunta:
?- ancestro(tom,pat).
Prolog tratara de satisfacer esta meta. Para ello, tratara de encontrar una clausula
en el programa, a partir de la cual la meta dada pueda seguirse logicamente. Obvia-
mente, las unicas reglas acerca de la relacion ancestro/2 son:
1 ancestro(X,Z) :-
2 progenitor(X,Z).
3
4 ancestro(X,Z) :-
5 progenitor(X,Y),
6 ancestro(Y,Z).
Decimos que la cabeza de estas reglas coincide o corresponde (match) con la

meta planteada. Las reglas representan formas alternativas en las que Prolog pue-
de resolver la meta. Prolog intentara resolver la pregunta con la primer clausula que
aparece en el programa (lneas 1 y 2). Puesto que la meta es ancestro(tom,pat),
las variables de la regla pueden ser substituidas conforme a X/tom y Z/pat. La
meta original ancestro(tom,pat), es entonces remplazada por la sub-meta
progenitor(tom,pat). El paso consistente en usar una regla para transformar
una meta en una sub-meta, se muestra graficamente en la figura 1.5.
ancestro(tom, pat)
ancestro(X,Z) :- progenitor(X,Z)
progenitor(tom, pat)
Figura 1.5 El primer paso de la ejecucion. La meta de arriba es verdadera si la meta de abajo es
verdadera.
1.3 Como computa Prolog una solucion? 15
Como no hay una clausula en el programa que coincida con la nueva sub-meta
progenitor(tom,pat), la sub-meta falla. Ahora Prolog vuelve atras (back-
track) para evaluar de forma alternativa su meta original. Ahora intentara la segun-
da clausula del programa (lneas 46). Como antes, las variables de la meta toman
los valores: X/tom y Z/pat. Pero Y no toma valor alguno aun. La meta es rem-
plazada por las sub-metas: progenitor(tom,Y), ancestro(Y,pat). La
ejecucion de este nuevo paso se muestra en la figura 1.6.
ancestro(tom,pat)
ancestro(X,Z) :-
ancestro(X,Z) :- progenitor(Z,X)
progenitor(X,Y), ancestro(Y,Z)
progenitor(tom,Y)
progenitor(tom,pat)
ancestro(Y,pat)
No
Figura 1.6 El segundo paso de la ejecucion. Dos sub-metas son generadas.
Enfrentado ahora el problema de resolver dos sub-metas, Prolog intentara satis-

facer la primer sub-meta definida en el programa (Porque?). La primer sub-meta se
resuelve facilmente pues coincide con uno de los hechos del programa. Esto obli-
ga a que Y tome el valor de bob, de forma que la segunda sub-meta se vuelve
ancestro(bob,pat).
Para satisfacer esta sub-meta, Prolog usara nuevamente la primer clausula del
programa (lneas 1 y 2). Como en este paso se hace una nueva llamada a esta re-
gla, en realidad Prolog utiliza variables diferentes a la llamada del paso anterior,
renombrando las variables como sigue:
1 ancestro(X,Z) :- progenitor(X,Z).
Lo cual conduce a la substitucion de variables: X/bob y Z/pat. La meta es

remplazada por progenitor(bob,pat). Esta meta es satisfecha porque coin-
cide con uno de los hechos del programa. Graficamente este proceso se muestra en
la figura 1.7.
Con esta explicacion, estudien la siguiente sesion en Prolog:
?- trace.
Yes
[trace] ?- ancestro(tom,pat).
Call: (7) ancestro(tom, pat) ? creep
Call: (8) progenitor(tom, pat) ? creep
Fail: (8) progenitor(tom, pat) ? creep
Redo: (7) ancestro(tom, pat) ? creep
Call: (8) progenitor(tom, _L345) ? creep
Exit: (8) progenitor(tom, bob) ? creep
Call: (8) ancestro(bob, pat) ? creep
16 1 Introduccion
ancestro(tom,pat)
ancestro(X,Z) :-
ancestro(X,Z) :- progenitor(Z,X)
progenitor(X,Y), ancestro(Y,Z)
progenitor(tom,Y)
progenitor(tom,pat)
ancestro(Y,pat)
No
Y = bob progenitor(tom,bob)
ancestro(bob,pat)
ancestro(X,Z) :-
progenitor(Z,X)
progenitor(bob,pat)
Yes
Figura 1.7 El segundo paso de la ejecucion. Dos sub-metas son generadas.
Call: (9) progenitor(bob, pat) ? creep

Exit: (9) progenitor(bob, pat) ? creep
Exit: (8) ancestro(bob, pat) ? creep
Exit: (7) ancestro(tom, pat) ? creep
Yes
1.4. Organizacion del curso
Durante el curso revisaremos tanto el fundamento teorico de la programacion

logica, como el uso de Prolog para resolver problemas propios de la inteligencia
artificial. La razon de esto debe ser evidente ya: estamos ante una herramienta que es
a su vez sujeto de estudio de la IA. Este texto de apoyo esta dividido en dos partes:
Fundamentos teoricos y Prolog; sin que esto implique que ambos aspectos seran
revisados estrictamente en este orden. Hay un tercer componente que se cubrira con
lecturas complementarias y el desarrollo de un proyecto final: las aplicaciones de la
programacion logica.
Con respecto a los fundamentos teoricos, iniciaremos con un recordatorio de la
logica de primer orden (captulo 2). Posteriormente revisaremos los conceptos de
clausula y programa definitivos (captulo 3) y el principio de resolucion (captulo
4). Continuaremos con el concepto de negacion (captulo 5) y cerraremos la primera
1.4 Organizacion del curso 17
parte del curso con algunas consideraciones sobre el corte y la aritmetica (captulo
6).
La segunda parte inicia con una introduccion menos breve sobre el lenguaje
(captulo 7) y continua con una serie de aplicaciones de Prolog a problemas pro-
pios de la IA: busquedas en espacios de soluciones (captulo 8), sistemas expertos
(captulo 9), induccion de arboles de decision (captulo 10), y planeacion (captulo
11).
De ser posible, concluiremos el curso con algunos aspectos de meta-programacion,
programacion por restricciones y programacion de agentes.
Parte I
Formalismos
Captulo 2
Logica de Primer Orden
Resumen En terminos generales, la Programacion Logica concierne al uso de la

logica para representar y resolver problemas. Mas adelante precisaremos que, en
realidad, usaremos una logica restringida a clausulas de Horn y la resolucion como
regla de inferencia [11]. Por ahora, este captulo introduce los conceptos de la logica
de primer orden necesarios para abordar los aspectos formales de la Programacion
Logica. Para ello, se adopta un enfoque basado en sistemas formales, que nos per-
mita describir el lenguaje, la teora del modelo y la teora de prueba de la logica
de primer orden. Con este aparato, se introducen los conceptos de unificacion y
resolucion como regla de inferencia.
2.1. Introduccion
Cuando describimos situaciones de nuestro interes, solemos hacer uso de enun-

ciados declarativos. Decimos que estos enunciados son declarativos en el sentido
lingustico del termino, esto es, se trata de expresiones del lenguaje natural que son
o bien verdaderas, o bien falsas; en contraposicion a los enunciados imperativos
e interrogativos. La logica proposicional es declarativa en este sentido, las propo-
siciones representan hechos que se dan o no en la realidad. La logica de primer
orden tienen un compromiso ontologico mas fuerte [17], donde la realidad impli-
ca ademas, objetos y relaciones entre ellos. Consideren los siguientes ejemplos de
enunciado declarativo:
1. Julia es madre y Luis es hijo de Julia.

2. Toda madre ama a sus hijos.
donde el enunciado (1) se refiere a los objetos de discurso Julia y Luis, usando pro-
piedades de estos objetos, como ser madre; as como relaciones entre estos, como
hi jo. El enunciado (2) se refiere a relaciones que aplican a todas las madres, en tanto
que objetos de discurso. A esto nos referimos cuando hablamos de representacion
21
22 2 Logica de Primer Orden
de un problema en el contexto de la Programacion Logica, a describir una situacion

en terminos de objetos y relaciones entre ellos.
Si se aplican ciertas reglas de razonamiento a tales representaciones, es posible
obtener nuevas conclusiones. Esto concierne a la resolucion de problemas en Pro-
gramacion Logica. Por ejemplo, conociendo (1) y (2) es posible inferir (va Modus
Ponens) que:
3. Julia ama a Luis.
La idea central de la programacion logica es describir los objetos que conforman
un universo de discurso, personas en el ejemplo; as como las relaciones entre
ellos, siguiendo con el ejemplo hi jo y madre; y computar tales descripciones para
obtener conclusiones como (3). Al describir el problema que queremos resolver,
tambien podemos hacer uso de funciones, relaciones en las cuales solo hay un valor
dada una entrada. Por ejemplo, madre de puede representarse como una funcion
(todo hijo tiene una sola madre), pero hijo de no. Esto se ilustra en la grafica 2.1.
madre de maria
luis
madre de
pedro juana
maria hijo de luis

hijo de
juana pedro
Figura 2.1 La relacion madre de es una funcion; mientras que hijo de no lo es.
Como en todo sistema formal, es necesario especificar cuidadosamente la sin-

taxis de tales enunciados declarativos, es decir, que expresiones pertenecen al len-
guaje de la logica de primer orden, y cuales no; la semantica de estas expresiones,
es decir que hace que una expresion sea verdadera o falsa; as como las reglas de
razonamiento que permiten concluir (3) a partir de (1) y (2). Tales cuestiones son el
tema de estudio de la logica matematica.
Esta sesion del curso introduce los elementos de la logica de primer orden, nece-
sarios para abordar la resolucion como regla de inferencia en logica de primer orden
y su uso en el lenguaje de programacion Prolog. El material aqu presentado esta ba-
sado principalmente en los textos de Michael R. Genesereth y Nils J. Nilsson [5],
captulo 2; y el de Ulf Nilsson y Jan Maluszynski [12], captulo 1. Una lectura com-
plementaria a estos textos son los captulos 8 y 9 del texto de Stuart Russell y Peter
Norvig [17].
2.3 El lenguaje de la logica de primer orden 23
2.2. Sistemas formales
La especificacion cuidadosa de la sintaxis y semantica de la logica de primer

orden, se consigue definiendo a esta ultima como un sistema formal. Para ello, es
necesario considerar tres aspectos:
Languaje. Este elemento esta asociado a la sintaxis de la logica de primer orden
y de los programas logicos. El lenguaje de un sistema formal esta dado por un
conjunto de smbolos conocido como alfabeto y una serie de reglas de cons-
truccion o sintacticas. Una expresion es cualquier secuencia de smbolos perte-
necientes al alfabeto (primarios). Cualquier expresion es, o no es, una formula
bien formada (fbf). Las formulas bien formadas son las expresiones que pueden
formarse con los smbolos del alfabeto a partir de las reglas de construccion y
por tanto, pertenecen al languaje de la logica de primer orden.
Teora de modelo. Este elemento esta asociado a la semantica de la logica de
primer orden. La teora del modelo establece la interpretacion de las fbfs en un
sistema formal. Su funcion es relacionar las fbfs con alguna representacion sim-
plificada de la realidad que nos interesa, para establecer cuando una fbf es falsa y
cuando verdadera. Esta version de realidad corresponde a lo que informalmente
llamamos modelo. Sin embargo, en logica, el significado de modelo esta nti-
mamente relacionado con el lenguaje del sistema formal: si la interpretacion M
hace que la fbf 1 sea verdadera, se dice que M es un modelo de o que M
satisface , y se escribe M |= . Una fbf es valida si toda interpretacion es un
modelo para ella.
Teora de prueba. Este elemento esta asociado con el razonamiento deductivo.
La teora de la prueba tiene como objetivo hacer de cada enunciado matemati-
co una formula demostrable y rigurosamente deducible. Para ello, la actividad
matematica debera quedar reducida a la manipulacion de smbolos y sucesio-
nes de smbolos regulada por un conjunto de instrucciones dadas al respecto. La
construccion de tal teora implica, ademas del lenguaje del sistema formal, un
subconjunto de fbf que tendran el papel axiomas en el sistema, y un conjunto
de reglas de inferencia que regulen diversas operaciones sobre los axiomas. Las
fbf obtenidas mediante la aplicacion sucesiva de las reglas de inferencia a partir
de los axiomas se conocen como teoremas del sistema.
2.3. El lenguaje de la logica de primer orden
Basicamente, la logica de primer orden, tambien conocida como calculo de pre-

dicados, introduce un conjunto de smbolos que nos permiten expresarnos acerca
1 El smbolo se usa aqu como una variable meta-logica, es decir, una variable que tiene como
referente el lenguaje del sistema formal mismo, y por lo tanto, no forma parte del lenguaje del
sistema en si. Se usaran letras griegas como variables meta-logicas.
de los objetos en un dominio de discurso dado. El conjunto de todos estos ob-

jetos se conoce como universo de discurso (U ). Los miembros del universo de
discurso pueden ser objetos concretos, ej., un libro, un robot, etc; abstractos, ej.,
numeros; e incluso, ficticios, ej., unicornios, etc. Un objeto es algo sobre lo cual
queremos expresarnos. Como ejemplo, consideren el multi citado mundo de los
bloques [5] que se muestra en la figura 2.2. El universo de discurso para tal esce-
nario es el conjunto que incluye los cinco bloques, la el brazo robotico y la mesa:
{a, b, c, d, e, brazo, mesa}.
Brazo robtico
A D
B C
Mesa
Figura 2.2 El mundo de los bloques, usado para ejemplificar el calculo de predicados.
Una funcion es un tipo especial de relacion entre los objetos del dominio de
discurso. Este tipo de relaciones mapea un conjunto de objetos de entrada a un
objeto unico de salida. Por ejemplo, es posible definir la funcion parcial sombrero
que mapea un bloque al bloque que se encuentra encima de el, si tal bloque existe.
Las parejas correspondientes a esta funcion parcial, dado el escenario mostrado en la
figura 2.2 son: {(b, a), (c, d), (d, e)}. El conjunto de todas las funciones consideradas
en la conceptualizacion del mundo se conoce como base funcional.
Un segundo tipo de relacion sobre los objetos del dominio de discurso son los
predicados. Diferentes predicados pueden definirse en el mundo de los bloques, ej.,
el predicado sobre que se cumple para dos bloques, si y solo si el primero esta inme-
diatamente encima del segundo. Para la escena mostrada en la figura 2.2, sobre/2 se
define por los pares {(a, b), (d, c), (e, d)}. Otro predicado puede ser libre/1, que se
cumple para un bloque si y solo si este no tiene ningun bloque encima. Este predica-
do tiene los siguientes elementos {a, e}. El conjunto de todos los predicados usados
en la conceptuacion se conoce como base relacional.
Para universos de discurso finitos, existe un lmite superior en el numero posible
de predicados n-arios que pueden ser definidos. Para un universo de discurso de
cardinalidad b (cardinalidad es el numero de elementos de un conjunto), existen bn
distintas n-tuplas. Cualquier predicado n-ario es un subconjunto de estas bn tuplas.
n
Por lo tanto, un predicado n-ario debe corresponder a uno de maximo 2(b ) conjuntos
posibles.
Ademas de las funciones y predicados, la flexibilidad de la logica de primer
orden resulta del uso de variables y cuantificadores. Las variables, cuyos valores
2.3 El lenguaje de la logica de primer orden 25
son objetos del universo de discurso, se suelen representar por cualquier secuencia
de caracteres que inicie con una mayuscula. El cuantificador para todo () nos
permite expresar hechos acerca de todos los objetos en el universo del discurso, sin
necesidad de enumerarlos. Por ejemplo, toda madre . . . El cuantificador existe
() nos permite expresar la existencia de un objeto en el universo de discurso con
cierta propiedad en partcular, por ejemplo, X libre(X) enLaMesa(X) expresa
que hay al menos un objeto que no tiene bloques sobre el y aue se encuentra sobre
la mesa.
2.3.1. Sintaxis de la logica de primer orden
Los smbolos primarios de la logica de primer orden se obtienen al considerar un

conjunto numerable de variables, smbolos de predicado y smbolos de funciones.
Se asume que los miembros del conjunto Var toman valores en el universo de dis-
curso. Asociado a cada predicado y funcion, hay un numero natural conocido como
su aridad, que expresa su numero de argumentos. Los predicados de aridad 0 se
asumen como variables proposicionales. Las funciones de aridad 0 se asumen como
constantes. Considerando los operadores logicos y los cuantificadores, tenemos que
los smbolos primarios o alfabeto del lenguaje de la logica de primer orden son los
que se muestran en la tabla 2.1
Conjunto de constantes: Const

Conjunto de variables: Var
Conjunto de predicados: Pred
Conjunto de funciones: Func
Operadores monarios: (negacion)
Operadores binarios: (disyuncion)
Cuantificadores: (cuantificador universal)
Parentesis: (, )
Cuadro 2.1 Alfabeto del lenguaje de la logica de primer orden.
El lenguaje del calculo de predicados LFOL se especifica recursivamente como

sigue: Primero definimos un conjunto de terminos del lenguaje Term, como la union
de constantes y variables Const Var; as como la aplicacion de las funciones en
Func a una secuencia de terminos, cuyo tamano queda determinado por la aridad de
la funcion. Recuerden que las funciones de aridad cero representan constantes. Las
siguientes reglas sintacticas expresan que los terminos son fbf en el lenguaje:
Sintaxis 1 Si Const, entonces Term

Sintaxis 2 Si Var, entonces Term
Sintaxis 3 Si /n Func, entonces (1 , . . . , n ) Term ssi i=1,...,n Term.
Al igual que en el caso de las funciones, la sintaxis de los predicados involucra la

aridad del predicado y que sus argumentos sean a su vez terminos. Recuerden que
los predicados de aridad cero se interpretan como variables proposicionales:
Sintaxis 4 Si /n Pred, entonces (1 , . . . , n ) LFOL ssi i=1,...,n Term.
La sintaxis de la negacion y la disyuncion se definen como:
Sintaxis 5 Si LFOL , entonces LFOL
Sintaxis 6 Si LFOL y LFOL , entonces ( ) LFOL
La sintaxis del cuantificador universal es como sigue:
Sintaxis 7 Si LFOL y X Vars es una variable que ocurre en , entonces
X LFOL
Las definiciones de la conjuncion, la implicacion material, la equivalencia mate-
rial, verdadero y falso, son como en la logica proposicional:
Definicion 1 (conjuncion) ( ) =de f ( );
Definicion 2 (implicacion material) ( ) =de f ( );
Definicion 3 (equivalencia material) ( ) =de f (( ) ( ));
Definicion 4 (falso) f =de f ;
Definicion 5 (verdadero) t =de f f
La definicion del cuantificador existencial es la siguiente:
Definicion 6 (cuantificador existencial) X =de f (X )
Siendo estrictos, el cuantificador propiamente dicho, es el smbolo de cuantifica-
dor seguido de una variable, puesto que X y Y tienen significados diferentes. En
una fbf de la forma X , se dice que la fbf esta en el alcance del cuantificador
X. En tal caso, se dice que la ocurrencia de X en esta acotada, en caso contrario
se dice que la ocurrencia de la variable es libre. Por ejemplo, en X sobre(X,Y )
la variable X esta acotada, mientras que Y esta libre. Un termino sin variables se
conoce como termino de base.
2.4. La semantica de la logica de primer orden
Antes de introducir las definiciones formales de la semantica de la logica de pri-

mer orden, consideremos algunas expresiones posibles en esta logica, usando como
ejemplo el mundo de los bloques (Figura 2.2). Si queremos expresar que al menos
algun bloque no tiene nada encima, podemos usar los predicados bloque/1 y libre/1
en la siguiente expresion: X bloque(X) libre(X). Esta fbf expresa que existe un
2.4 La semantica de la logica de primer orden 27
X tal que X es un bloque y X esta libre (no tiene otro bloque encima). Observen que
cuando usamos cuantificadores, siempre tenemos en mente el universo de discurso
en cuestion o dominio. El dominio puede especificarse en termino de conjuntos.
Luego, si el dominio D es el conjunto de constantes {a, b, c, d, e, brazo, mesa}, po-
demos decir que B D = {a, b, c, d, e} es el conjunto de bloques en D. Entonces,
es posible plantear una expresion equivalente a X bloque(X) libre(X), usando la
fbf X libre(x), si especificamos que libre/1 tiene como dominio B.
Una interpretacion del predicado libre/1 es un subconjunto de B tal que si un
bloque esta libre, pertenece a este subconjunto. Para un predicado de aridad dos,
como sobre/2 cuyo dominio son los bloques B B, podemos decir que su interpre-
tacion es un subconjunto de B B. En general, para un predicado de aridad n, su
interpretacion es un subconjunto en Dn .
2.4.1. Teora de modelo de la logica de primer orden
Para obtener un modelo para el lenguaje LFOL formamos el par M = hD,V i,

donde D es el universo de discurso, ej. cualquier coleccion de objetos sobre la que
queremos expresarnos, y la interpretacion V es una funcion, tal que:
Para cualquier predicado de aridad n, V () regresa las n-tuplas que correspon-
den a la interpretacion del predicado. En el ejemplo, siguiendo nuevamente la
figura 2.2, consideren el predicado sobre/2. Su interpretacion es un subconjunto
de D2 = D D. Para la escena mostrada, V (sobre) = {(a, b), (e, d), (d, c)}.
Para una constante, la funcion V regresa la misma constante, ej. V (a) = a.
Algunas veces la expresion V () se abrevia V . Una posible interpretacion V
para la escena del mundo de los bloques mostrada en al figura 2.2, es:
aV = a
bV = b
cV = c
dV = d
eV = e
sobreV = {(a, b), (e, d), (d, c)}
enLaMesaV = {b, c}
libreV = {a, e}
porEncimaV = {(a, b), (e, d), (e, c), (d, c)}
Todo esto puede especificarse formalmente con la siguiente definicion:

Definicion 7 (Interpretacion) Una interpretacion V , con respecto a un dominio de

discurso D, es una funcion que satisface las siguientes propiedades: i) Si Const,
Entonces V () = ; ii) Si /n Pred, Entonces V () Dn .
Observen que las variables no estan incluidas en la interpretacion. Interpretar las

variables de manera independiente a otros smbolos en el lenguaje, es una practica
aceptada. Decimos que U es una asignacion de variables basada en el modelo
M = hD,V i si para todo Var, U() Term. Por ejemplo, en el mundo de los
bloques X U = a, es una asignacion de variables. Esta abreviatura a veces se expande
como U = {X\a} y se conoce como substitucion.
Una interpretacion V y una asignacion de variables U pueden combinarse en una
asignacion conjunta TVU que aplica a los terminos de primer orden en general. La
asignacion de terminos T dadas la interpretacion V y la asignacion de variables
U, es un mapeo de terminos a objetos del universo de discurso que se define como
sigue:
Semantica 1 Si Const, entonces TVU () = V ().

Semantica 2 Si Var, entonces TVU () = U().
Semantica 3 Si Term y es de la forma (1 , . . . , n ); y V () = g; y TVU (i ) =
xi , entonces TVU ((1 , . . . , n )) = g(x1 , . . . , xn ).
El concepto de satisfaccion guarda una relacion importante con las interpre-

taciones y las asignaciones. Por convencion, el hecho de que el enunciado sea
satisfecho bajo una interpretacion V y una asignacion U, se escribe:
|=V [U]
Entonces podemos escribir M |= VU () para expresar que es verdadera en
el modelo M = hD,V i cuando las variables en toman valores de acuerdo a la
asignacion U. Por ejemplo, M |= VU (sobre(X, b)) si X\a U.
En realidad, la nocion de satisfaccion vara dependiendo de la clase del enunciado
. As tenemos que una interpretacion V y una asignacion de variables U satisfacen
una ecuacion, si y solo si la correspondiente asignacion de terminos TVU mapea los
terminos igualados a un mismo objeto. Cuando este es el caso, los terminos se dicen
correferenciados:
Semantica 4 M |=V ( = )[U] ssi TVU () = TVU ( ).

Para el caso de un enunciado atomico que no sea una ecuacion, la satisfaccion se
cumple si y solo si la tupla formada por los objetos designados por los terminos en
el enunciado, es un elemento de la relacion designada por la relacion constante:
Semantica 5 M |=V (1 , . . . , n )[U] ssi (TVU (1 ), . . . , TVU (n )) V () .
Consideren como ejemplo la interpretacion V definida para el mundo de los bo-

ques. Puesto que la constante a designa al bloque a y la constante b al bloque b, y
2.5 Inferencia en la logica de primer orden 29
el par ordenado (a, b) es miembro del conjunto que interpreta la relacion sobre, en-
tonces es el caso que |=V sobre(a, b)[U], por lo cual podemos decir que sobre(a, b)
es verdadera en esa intepretacion.
Evidentemente:
Semantica 6 M |=V ()[U] ssi M 6|=V [U].

y:
Semantica 7 M |=V ( )[U] ssi M |=V [U] o M |= [U].
Un enunciado cuantificado universalmente se satisface, si y solo si el enunciado

bajo el alcance del cuantificador, se satisface para todas las asignaciones posibles de
la variable cuantificada. Un enunciado cuantificado existencialmente se satisface,
si y solo si el enunciado bajo el alcance del cuantificador es satisfecho por una
asignacion de variables.
Semantica 8 M |=V X [U], ssi para toda en el universo de discurso, es el caso

que M |=V [U 0 ], donde U 0 (X) = y U 0 () = U() para toda 6= X.
Debido a la ultima condicion en esta regla, se dice que U 0 es una asignacion X-
alternativa a U. La regla semantica tambien puede leerse como: M |=V X [U] si
para toda asignacion de variables X-alternativa U 0 , M |=V [U 0 ].
Si una interpretacion V safisface a un enunciado para toda asignacion de varia-
bles, se dice que V es un modelo de . Un enunciado se dice satisfacible si existe
alguna interpretacion y asignacion de variables que lo satisfaga. De otra forma, se
dice que el enunciado es insatisfacible. Una fbf es valida si y solo si se satisface
en toda intepretacion y asignacion de variables. Las fbf validas lo son en virtud de
su estructura logica, por lo que no proveen informacion acerca del dominio descrito.
Por ejemplo p(X) p(X) es una fbf valida.
2.5. Inferencia en la logica de primer orden
Volvamos al ejemplo de la introduccion:

1. Toda madre ama a sus hijos.
2. Julia es madre y Luis es hijo de Julia.
Conociendo (1) y (2) es posible concluir que:

3. Julia ama a Luis.
Podemos formalizar este ejemplo en Logica de Primer Orden como sigue:
1. X Y madre(X) hi jo de(Y, X) ama(X,Y )
2. madre( julia) hi jo de(luis, julia)
3. ama( julia, luis)

Una vez que hemos formalizado nuestros enunciados, el proceso de inferencia
puede verse como un proceso de manipulacion de fbf, donde a partir de formulas
como (1) y (2), llamadas premisas, se produce la nueva fbf (3) llamada conclusion.
Estas manipulaciones se pueden formalizar mediante reglas de inferencia. Entre
las reglas de inferencia de la logica de primer orden encontramos:
Modus Ponens. O regla de eliminacion de la implicacion. Esta regla dice que
siempre que las fbfs de la forma y pertenezcan a las premisas o sean
concluidas a partir de ellas, podemos inferir :

( E)

Eliminacion de cuantificador universal. Esta regla expresa que siempre que
una fbf de la forma X pertenezca a las premisas o sea concluida a partir de
ellas, una nueva fbf puede ser concluida al remplazar todas las ocurrencias libres
de X en por algun termino t que es libre con respecto a X (todas las variables
en t quedan libres al substituir X por t. La regla se presenta como sigue:
X(X)
(E)
(t)
Introduccion de conjuncion. Cuando las fbf y pertenezcan a las premisas
o sean concluidas a partir de ellas, podemos inferir :

(I)

La correctez de estas reglas puede ser demostrada directamente a partir de la
definicion de la semantica de las fbf en LFOL . El uso de las reglas de inferencia
puede ilustrarse con el ejemplo formalizado. Las premisas son:
1. XY madre(X) hi jo de(Y, X) ama(X,Y )
2. madre( julia) hi jo de(luis, julia)
Al aplicar la eliminacion de cuantificador universal (E) a (1) obtenemos:
3. Y (madre( julia) hi jo de(Y, julia) ama( julia,Y )
Al aplicar nuevamente (E) a (3) obtenemos:

4. madre( julia) hi jo de(luis, julia) ama( julia, luis)
Finalmente, al aplicar Modus Ponens a (2) y (4):
5. ama( julia, luis)
2.6 Substituciones 31
La conclusion (5) ha sido obtenida rigurosamente, aplicando las reglas de infe-

rencia. Esto ilustra el concepto de derivacion. El hecho de que una formula sea
derivable a partir de un conjunto de formulas se escribe ` . Si las reglas de
inferencia son consistentes (sound), siempre que ` entonces |= . Esto es,
si nuestra logica es consistente, cualquier fbf que puede ser derivada de otra fbf, es
tambien una consecuencia logica de esta ultima.
Definicion 8 (Consistencia y completitud) Un conjunto de reglas de inferencia se
dice consistente si, para todo conjunto de fbf cerradas (sin ocurrencia de variables
libres) y cada fbf cerrada , siempre que ` se tiene que |= . Las reglas
de inferencia se dicen completas si ` siempre que |= .
2.6. Substituciones
Formalmente, como ya se menciono, una substitucion es un mapeo de las varia-

bles del lenguaje a los terminos del mismo:
Definicion 9 (Substitucion) Una substitucion es un conjunto finito de pares de la
forma {X1 /t1 , . . . , Xn /tn } donde cada tn es un termino y cada Xn es una variable, tal
que Xi 6= ti y Xi 6= X j si i 6= j. La substitucion vaca se denota por .
Asumamos que Dom({X1 /t1 , . . . , Xn /tn }) denota al conjunto {X1 , . . . , Xn }, tam-

bien conocido como dominio; y Range({X1 /t1 , . . . , Xn /tn }) denota al conjunto
{t1 , . . . ,tn }, tambien conocido como rango. Entonces la regla anterior expresa que
las variables en el dominio de una substitucion son unicas y no incluyen la substitu-
cion de la variable por si misma.
La aplicacion X de la substitucion a la variable X se define como:

t Si X/t
X =
X En otro caso
observen que para las variables no incluidas en Dom( ), aparece como la funcion
identidad. Es importante extener el concepto de substitucion a las fbf:
Definicion 10 (Aplicacion) Sea una substitucion {X1 /t1 , . . . , Xn /tn } y una fbf.
La aplicacion es la fbf obtenida al remplazar simultaneamente ti por toda ocu-
rrencia de Xi en (1 i n). se conoce como un caso (instance) de .
Ejemplos:
ama(X,Y ) madre(X){X/ julia,Y /luis} = ama( julia, luis) madre( julia)
p( f (X, Z), f (Y, a)) {X/a,Y /Z,W /b} = p( f (a, Z), f (Z, a))
p(X,Y ) {X/ f (Y ),Y /b} = p( f (Y ), b)
Definicion 11 (Composicion) Sean y dos substituciones de la forma:
= {X1 /s1 , . . . Xm /sm } = {Y1 /t1 , . . .Yn /tn }

La composicion se obtiene a partir del conjunto:
{X1 /s1 , . . . Xm /sm ,Y1 /t1 , . . .Yn /tn }

de la manera siguiente: eliminar todas las Xi /si para las que Xi = si (1 i m)
y eliminar tambien aquellas Y j /t j para las cuales Y j Dom( ) (1 j n).
Por ejemplo:
{X/ f (Z),Y /W }{X/a, Z/a,W /Y } = {X/ f (a), Z/a,W /Y }

Definicion 12 (Substitucion idempotente) Una substitucion se dice idempoten-
te si = .
Se puede probar que una substitucion es idempotente si y solo si Dom( )

Range( ) = 0,
/ es decir si el dominio y el rango de la substitucion son disjuntos.
Otras propiedades de las substituciones son:
Definicion 13 (Propiedades de las substituciones) Sean , y substituciones y
sea F una fbf. Entonces:
E( ) = (E )
( ) = ( )
= =
Observen que, aunque las substituciones son asociativas, estas no son conmuta-
tivas.
Las substituciones son importantes para definir una regla de inferencia de espe-
cial relevancia para nosotros, conocida como la regla de resolucion. Con las defi-
niciones introducidas en este captulo podemos abordar el tema de los programas
logicos definitivos.
Captulo 3
Clausulas y Programas Definitivos
Resumen La idea central de la programacion logica es usar la computadora para

obtener conclusiones a partir de descripciones declarativas, como las introducidas
en el captulo anterior. Estas descripciones, llamadas programas logicos, consisten
en un conjunto finito de formulas bien formadas (fbfs) de la logica de primer or-
den. La idea central tiene sus races en la demostracion automatica de teoremas,
sin embargo, pasar de la demostracion automatica de teoremas experimental a la
programacion logica aplicada, requiere mejoras con respecto a la eficiencia del sis-
tema propuesto. Tales mejoras se logran imponiendo restricciones sobre las fbfs del
lenguaje utilizado, de forma que podamos usar una poderosa regla de inferencia
conocida como principio de resolucion-SLD. Este captulo introduce el concepto
de clausula y programa logico definitivos. Mas adelante se introducira el concepto
menos restrictivo de programas generales, pero el paso por los programas definiti-
vos es necesario para comprender las bases teoricas de Prolog. El aparato tecnico
aqu presentado se basa principalmente en el texto de Nilsson et al. [12].
3.1. Clausulas definitivas
Consideremos una clase especial de enunciados declarativos del lenguaje natural,

que utilizamos para describir hechos y reglas positivos. Un enunciado de este tipo
puede especificar:
Que una relacion se mantiene entre elementos del universo de discurso (hechos).
Que una relacion se mantiene entre elementos del universo de discurso, si otras
relaciones se mantienen (reglas).
Consideren los siguientes enunciados en lenguaje natural:
1. Antonio es hijo de Juan.
2. Ana es hija de Antonio.
3. Juan es hijo de Marcos.
33
34 3 Clausulas y Programas Definitivos
4. Alicia es hija de Juan.

5. El nieto de una persona es el hijo del hijo de esa persona.
Estos enunciados pueden formalizarse en dos pasos. Primero, procedemos con
las fbf atomicas que describen hechos:
1. hijo de(antonio, juan)
2. hijo de(ana,antonio)
3. hijo de(juan,marcos)
4. hijo de(alicia,juan)
El ultimo enunciado puede aproximarse como: Para toda X e Y , X es nieto de

Y si existe alguna Z tal que Z es hijo de Y y X es hijo de Z. En logica de primer
orden, esto se escribira (observen que la implicacion esta invertida () a la usanza
de Prolog):
XY (nieto de(X,Y ) Z(hi jo de(Z,Y ) hi jo de(X, Z)))

Usando las equivalencias de la logica de primer orden (en particular
; y la equivalencia entre cuantificadores X X), esta fbf puede
escribirse de diversas maneras:

XY Z(nieto de(X,Y ) (hi jo de(Z,Y ) hi jo de(X, Z)))
XY Z(nieto de(X,Y ) (hi jo de(Z,Y ) hi jo de(X, Z)))
Observen que estas fbf estan cerradas (no contienen variables fuera del alcance
de los cuantificadores) bajo el cuantificador universal. Ademas, la regla tiene la
siguiente estructura:
0 1 n (n 0)
Los bloques de construccion i de estas fbf, se conocen como literales.
Definicion 14 (Literal) Una literal es un atomo o la negacion de un atomo. Una

literal positiva es un atomo. Una literal negativa es la negacion de un atomo.
Un ejemplo de literal positiva es hi jo de( juan, marcos). Un ejemplo de literal
negativa es hi jo de( juan, alicia). Si p y q son predicados y f es un functor, en-
tonces p(X, alicia) y q(Y ) son literales positivas. q(alicia, f (Y )) es una literal
negativa.
Definicion 15 (Clausula) Una clausula es una disyuncion finita de cero o mas li-
terales.
3.2 Programas definitivos y Metas 35
Definicion 16 (Clausula definitiva) Una clausula se dice definitiva, si tiene exac-

tamente una literal positiva.
0 1 n (n 0)
lo cual es equivalente a la forma general de fbf que nos interesaba:
0 1 n (n 0)
Si n = 0 tenemos por definicion que la literal 0 sera una literal positiva, por
lo que la clausula definitiva toma la forma de un hecho. El cuerpo vaco puede
representarse por el conectivo nulo , que es verdadero en toda interpretacion (por
simetra tambien se asume un conectivo nulo 2, que es falso en toda interpretacion).
Si n > 0 la clausula definitiva toma la forma de una regla, donde 0 se conoce como
cabeza de la regla; y la conjuncion 1 n se conoce como cuerpo de la regla.
El ejemplo de la relacion nieto de/2 y la regla que lo define, muestra que las
clausulas definitivas usan una forma restringida de cuantificacion existencial, las
variables que ocurren solo en el cuerpo de la clausula estan cuantificadas existen-
cialmente en el cuerpo de la clausula (el mismo ejemplo muestra que esto equivale
a que tales variables esten cuantificadas universalmente sobre toda la fbf).
3.2. Programas definitivos y Metas
La definicion de programa definitivo es ahora directa:
Definicion 17 (Programa definitivo) Un programa definitivo es un conjunto finito

de clausulas definitivas.
Si una clausula tiene solo literales negativas, estamos hablando de una meta de-
finitiva:
Definicion 18 (Meta definitiva) Una clausula sin literales positivas es una meta
definitiva.
1 n (n 1)
Definicion 19 (Clausula de Horn) Una clausula de Horn es una clausula definitva
o una meta definitiva.
Observen que a partir de estas definiciones, la clausula vaca 2 1 es una meta

definitiva y, por lo tanto, una clausula de Horn.
Adoptar a las clausulas de Horn para abordar los programas y metas definitivos,
constituye una restriccion. Por ejemplo, no podemos expresar p(a) p(b). Esta per-
dida en expresividad se ve compensada por la ganancia en tratabilidad. Debido a
su estructura restringida, las clausulas de Horn son mas faciles de manipular que
1 En realidad, la clausula vaca tiene la forma 2 que equivale a 2.

las clausulas generales. En particular, esto es cierto para la deduccion basada en

resolucion-SLD, que resulta completa para las clausulas de Horn.
El significado logico de las metas puede explicarse haciendo referencia a la fbf
equivalente cuantificada universalmente:
X1 . . . Xm (1 n )
donde las Xi son todas variables que ocurren en la meta. Esto es equivalente a:
X1 . . . Xm (1 n )
Esto puede verse como una pregunta existencial que el sistema tratara de negar,
mediante la construccion de un contra ejemplo. Esto es, el sistema tratara de encon-
trar terminos ti . . .tm tales que las fbf obtenidas a partir de 1 m al remplazar
la variable Xi por ti (1 i m) son verdaderas en todo modelo del programa. Es
decir, el sistema construira una consecuencia logica del programa que es un caso de
la conjuncion de todas las submetas de la meta.
Al dar una meta definitiva, el usuario selecciona un conjunto de conclusiones
a ser construdas. Este conjunto puede ser finito o infinito. El problema de como
construir tal conjunto lo veremos al tratar la resolucion SLD.
Ejemplo 1 Tomando en cuenta los hechos y reglas sobre una familia presentados
al principio de esta sesion, el usuario podra estar interesado en las siguientes
consultas (se muestra tambien la meta definitiva correspondiente):
Consulta Meta definitiva
Es Ana hija de Antonio? hi jo(ana, antonio)
Quien es nieto de Ana? nieto(X, ana)
De quien es nieto Antonio? nieto(antonio, X)
Quien es nieto de quien? nieto(X,Y )
Las respuestas obtenidas seran:
Puesto que la primer meta no contiene variables, la respuesta sera Si (Yes).
Puesto que el programa no contiene informacion sobre los nietos de Ana, la
respueta a la segunda consulta es No (o ninguno).
Puesto que Antonio es nieto de Marcos, la respuesta obtenida sera X = marcos.
La consulta final obtiene tres respuestas: X = antonio Y = alicia, X = alicia Y =
marcos, X = ana Y = juan.
Es posible hacer consultas mas elaboradas como Hay alguna persona cuyos
nietos son Antonio y Alicia?
nieto(antonio, X) nieto(alicia, X)
cuya respuesta esperada es X = marcos.
3.3 El modelo mnimo de Herbrand 37
3.3. El modelo mnimo de Herbrand
Los programas definitivos solo pueden expresar conocimiento positivo, tanto los
hechos, como las reglas, nos dicen que elementos de una estructura estan en una
relacion, pero no nos dicen cuales no. Por lo tanto, al usar el lenguaje de los pro-
gramas definitivos, no es posible construir descripciones contradictorias, es decir,
conjuntos de fbf no satisfacibles. En otras palabras, todo programa definitivo tiene
un modelo. Recordemos que una interpretacion que hace verdadera una fbf es su
modelo:
Definicion 20 (Modelo) Sea una fbf y V una interpretacion. V es un modelo de

si |=V .
Definicion 21 Sea un conjunto finito de fbf y V una interpretacion. V es un mo-
delo de si |=V para toda .
Existe una clase interesante de interpretaciones, llamadas de Herbrand en honor

del frances Jacques Herbrand. En esta seccion estudiaremos algunas propiedades
de los modelos de Herbrand que explican porque son utiles y necesarios en el con-
texto de la programacion logica. Ademas, los modelos de Herbrand proveen una
semantica natural para los programas definitivos.
Comenzaremos definiendo el Universo y la Base de Herbrand:
Definicion 22 (Universo y Base de Herbrand) Sea L un alfabeto de primer orden

que contiene al menos un smbolo de constante (|Const| 1). El Universo de Her-
brand UL es el conjunto de todos los terminos formados con las constantes y func-
tores de L. La Base de Herbrand BL es el conjunto de todos los atomos que pueden
formarse con los predicados y los terminos en el Universo de Herbrand UL .
El universo y la base de Herbrand se definen normalmente para un programa

dado. En ese caso, se asume que el alfabeto L consiste exactamente de aquellos
smbolos que aparecen en el programa. Se asume tambien que el programa tiene al
menos una constante (de otra forma el dominio estara vaco).
Ejemplo 2 Consideren el siguiente programa definitivo
= {impar(s(0)), impar(s(s(X))) impar(X)}
Si restringimos el lenguaje L a los smbolos que aparecen en este programa defini-

tivo, tenemos que el universo de Herbrand es:
UL = {0, s(0), s(s(0)), s(s(s(0))), . . . }

Puesto que el programa solo incluye al predicado impar, la base de Herbrand
se define como:
BL = {impar(0), impar(s(0)), impar(s(s(0))), . . . }

Ejemplo 3 Consideren este otro programa = {p(a), q(a, f (b), q(X, X) p(X)}.
Sea L es lenguaje de primer orden dado por los smbolos en . El Universo de
Herbrand UL es el conjunto infinito:
UL = {a, b, f (a), f (b), f ( f (a)), f ( f (b)), . . . }

Y la base de Herbrand es:
BL = {p(a), p(b), q(a, b), p( f (a)), p( f (b)), q(a, f (a)), q(a, f (b)), . . . }
Lo que hace especial a una intrepretacion de Herbrand es que se toma el conjunto

de todos los terminos sin variables (UL ) como el dominio de la interpretacion. El
mapeo de los terminos a los elementos del dominio es tal que, cada termino sin
variables es mapeado al elementos correspondiente en el dominio. De forma que
cada termino sin variables en el lenguaje, se refiere a si mismo en el dominio.
Definicion 23 (Interpretacion de Herbrand) Sea L un lenguaje de primer orden.
V es una interpretacion de Herbrand de L si y solo si:
El dominio de V es UL .
Para cada constance c L, V (c) = c.
Para cada functor f /n L, se tiene un mapeo V ( f ) de ULn a UL definido por
V ( f )(t1 , . . . ,tn ) = f (t1 , . . . ,tn ).
Para cada predicado p/n L, V (p) ULn .
La funcion J f mapea t1 , . . . ,tn al termino f (t1 , . . . ,tn ) en el Universo de Herbrand
UL .
Definicion 24 (modelo de Herbrand) Sea L un lenguaje de primer orden, un
conjunto de fbf en L, y V una interpretacion de Herbrand de L. Si V es un modelo
de , se dice que es un modelo de Herbrand de .
Observen que una interpretacion de Herbrand V esta completamente especificada
por el conjunto de todas las BL que son verdaderas bajo V . Podemos por lo
tanto representar cualquier interpretacion de Herbrand economicamente como un
subconjunto (denotado por tambien V ) de BL . En otras palabras, una interpretacion
de Herbrand, es un subconjunto de la Base de Herbrand.
Ejemplo 4 Consideren el programa en el ejemplo 2. Una posible interpretacion
de este programa es imparV = {hs(0)i, hs(s(s(0)))i}. Una intepretacion de Her-
brand se puede especificar mediante una familia de tales relaciones (una por cada
smbolo de predicado).
Ejemplo 5 Consideren ahora algunas interpretaciones de Herbrand de tal y co-
mo se definio en el ejemplo 3:
V1 = {p(a), p(b), q(a, b, ), q(b, b)}

V2 = {p(a), q(a, a), q(a, f (b))}
V3 = {p( f ( f (a))), p(b), q(a, a), q(a, f (b))}
V4 = {p(a), p(b), q(a, a), q(b, b), q(a, f (b))}
V2 y V4 son modelos de Herbrand de = {p(a), q(a, f (b), q(X, X) p(X)}. V1

y V3 no lo son.
3.3.1. Resultados concernientes a los modelos de Herbrand
Las interpretaciones y los modelos de Herbrand tienen dos propiedades atracti-

vas. La primera es pragmatica: para poder determinar si una interpretacion de Her-
brand V es un modelo de una fbf cuantificada universalmente , es suficiente ve-
rificar si es verdadera en V , para todas las asignaciones posibles de las variables
de .
La segunda razon para considerar las interpretaciones de Herbrand es mas teori-
ca. Para el lenguaje restringido de clausulas definitivas, si queremos verificar que
una fbf atomica es consecuencia de un programa definitivo basta con verificar
que todo modelo de Herbrand de es tambien un modelo de Herbrand de .
Para entrar en detalles, es necesaria la siguiente proposicion:
Proposicion 1 Sea un conjunto de clausulas en un lenguaje de primer orden L.

Entonces tiene un modelo, si y solo si tiene un modelo de Herbrand.
La prueba de esta proposicion es como sigue: Supongamos que tiene un mode-
lo M. Si definimos una interpretacion V de Herbrand tal que V ((t1 , . . . ,tn )) define
solo aquellas extensiones de que son validas en M), tenemos que V es un modelo
de Herbrand de . Dicho de otra forma, un modelo de Herbrand, es un modelo.
Observen que esta proposicion es verdadera solo para conjuntos de clausulas.
Por ejemplo, consideren a L como un lenguaje de primer orden formado por los
smbolos en = {X p(X), p(a)}. Claramente tiene un modelo, pero este no
es un modelo de Herbrand. La razon es el dominio de la interpretacion. En una
interpretacion de Herbrand, el dominio es UL = {a}, y necesitamos dos constantes
al menos en UL para construir un modelo de .
Hemos mencionado la importancia del concepto de implicacion logica (o con-
secuencia logica). Es comun que a partir de un conjunto y una fbf , queremos
encontrar si |= . Esto es cierto si cada modelo de es tambien un modelo de .
Lo interesante viene ahora:
Proposicion 2 Sea un conjunto de fbf y una fbf. Sea S = {}. Entonces

|= si y solo si S no tiene modelo de Herbrand.
La prueba de esta proposicion es como sigue: |= si y solo si {} no

es satisfacible. Esto es, si S es no satisfacible, lo cual es cierto solo si S no tiene
modelos y por lo tanto, no tiene modelo de Herbrand.
Lo que esta proposicion nos dice es que si queremos probar que |= , solo
debemos considerar modelos de Herbrand de la forma S. Aunque el numero de in-
terpretaciones de Herbrand es normalmente infinito, la tarea de investigar interpre-
taciones de Herbrand es mas tratable que la de investigar cualquier interpretacion
arbitraria, puesto que nos restringimos a un dominio unico definitivo por el Univer-
so de Herbrand UL .
Observen que la base de Herbrand de un programa definitivo es siempre un
modelo de Herbrand del programa. Sin embargo, es un modelo nada interesante,
esto es, cada predicado n-ario en el programa es interpretado como la relacion n-
aria completa sobre el dominio de los terminos cerrados. Que es lo que hace a un
modelo de programa interesante? En lo que sigue demostraremos la existencia de
un modelo mnimo unico, llamado el modelo mnimo de Herbrand de un progra-
ma definitivo. Luego mostraremos que este modelo contiene toda la informacion
positiva presente en el programa.
Los modelos de Herbrand de un programa definitivo son subconjuntos de su base
de Herbrand. Por lo tanto, la inclusion en conjuntos establece un orden natural en
tales modelos. Para poder demostrar la existencia de modelos mnimos con respecto
a la inclusion es suficiente demostrar que la interseccion de todos los modelos de
Herbrand es tambien un modelo de Herbrand.
Teorema 1 (Interseccion de modelos) Sea M una familia no vaca de modelos
T
de
Herbrand de un programa definitivo . Entonces la interseccion V = M es un
modelo de Herbrand de .
La demostracion es como sigue: Supongamos que V no es un modelo de . Por
lo tanto existe una una clausula sin variables en , de la forma:
0 1 , . . . , n (n 0)
que no es verdera en V . Esto mplica que V contiene a 1 , . . . n , pero no a 0 .
Luego, 1 , . . . , n son miembros de toda interpretacion en la familia M. Mas impor-
tante aun, debe existir un modelo Vi M tal que 0 6 Vi , de forma que la clausula
0 1 , . . . , n (n 0) no es verdadera en ese Vi . Por lo tanto Vi no es un modelo
del programa , lo que contradice nuestro supuesto.
Al tomar la interseccion de todos los modelos de Herbrand (se sabe que todo
programa definitivo tiene un modelo de Herbrand BL ) de un programa definitivo,
obtenemos el modelo mnimo de Herbrand el programa.
Ejemplo 6 Sea el programa definitivo {masculino(adan), f emenino(eva)} con
su interpretacion obvia. tiene los siguientes modelos de Herbrand:
{masculino(adan), f emenino(eva)}
{masculino(adan), masculino(eva), f emenino(eva)}
{masculino(adan), masculino(eva), f emenino(adan)}

{masculino(adan), masculino(eva), f emenino(eva), f emenino(adan)}
No es complicado confirmar que la interseccion de estos modelos produce un
modelo de Herbrand. Sin embargo, todos los modelos salvo el primero, contienen
atomos incompatibles con el significado esperado del programa. Observen tambien
que la interseccion de todos los modelos nos lleva a un modelo que corresponde con
el significado esperado.
Este ejemplo nos muestra la conexion entre los modelos mnimos de Herbrand y
el modelo intentado de un programa definitivo. Este modelo es una abstraccion del
mundo a ser descrita por el programa. El mundo puede ser mas rico que el modelo
mnimo de Herbrand. Por ejemplo hay mas f ememinos que eva. Sin embargo, aque-
lla informacion que no se provea explcitamente (hechos) o implcitamente (reglas)
no puede ser obtenida como respuesta a una meta. Las respuestas corresponden a
las consecuencias logicas del programa.
Teorema 2 El modelo mnimo de Herbrand M de un programa definitivo es el
conjunto de todas las consecuencias logicas atomicas de base del programa. Esto
es: M = { B | |= }.
La prueba de este teorema pasa por demostrar que M { BL | |= } y que
M { B | |= }.
3.3.2. Construccion del modelo mnimo de Herbrand
La pregunta que emerge es Como podemos construir el modelo mnimo de Her-

brand? o Como puede aproximarse sucesivamente por medio de la enumeracion
de sus elementos? La respuesta a estas preguntas se da mediante una aproximacion
de punto fijo (el punto fijo de una funcion f : D D es un elemento x D tal que
f (x) = x) a la semantica de los programas definitivos.
Un programa definitivo esta compuesto de hechos y reglas. Es evidente que todos
los hechos deben incluirse en cualquier modelo de Herbrand. Si la interpretacion V
no incluye el hecho del programa , entonces V no es un modelo de Herbrand de
.
Ahora consideremos una regla de la forma 0 1 , . . . , n (n > 0). La regla
especifica que siempre que 1 , . . . , n son verdaderas, tambien lo es 0 . Esto es,
tomando cualquier asignacion de valores que haga que la regla no tenga varia-
bles sin valor (0 1 , . . . , n ) : Si la interpretacion V incluye a 1 , . . . n ,
debera incluir tambien a 0 para ser un modelo.
Consideren ahora el conjunto V1 de todos los hechos sin variables de el programa.
Es posible utilizar cada regla para aumentar V1 con nuevos elementos que necesa-
riamente pertenencen a todo modelo. De modo que se obtiene un nuevo conjunto
V2 que puede usarse para generar mas elementos que pertenecen a todo modelo.
El proceso se repite mientras puedan generarse nuevos elementos. Los elementos

agregados a Vi+1 son aquellos que se siguen inmediatamente de Vi .
La construccion as obtenida puede formalizarse como la iteracion de una trans-
formacion T sobre las interpretaciones de Herbrand de un programa . La opera-
cion se llama operador de consecuencia inmediata y se define como sigue:
Definicion 25 (Operador de consecuencia inmediata) Sea ground( ) el conjun-
to de todas las clausulas con valores asignados a todas sus variables en . T es
una funcion sobre las interpretaciones de Herbrand de definida como sigue:
T (V ) = {0 | 0 1 , . . . , n ground( ) {1 , . . . , n } V }
Para los programas definitivos, se puede mostrar que existe una interpretacion
mnima V tal que T (V ) = V y que V es identica al modelo mnimo de Herbrand
de . Mas aun, el modelo mnimo de Herbrand es el limite de la creciente, posible-
mente infinita, secuencia de iteraciones:
/ T (0),
0, / T (T (0)),
/ ...
Existe una notacion estandar para denotar a los miembros de esta secuencia de
interpretaciones construdas a partir de :
T 0 = 0/
T (i + 1) = T (T i)

[
T n = T i
i=0
Ejemplo 7 Tomando como el programa de impar (ej. 2, tenemos:
T 0 = 0/
T 1 = {impar(s(0))}
T 2 = {impar(s(0)), impar(s(s(s(0))))}
..
.
T m = {impar(sn (0)) | n {1, 3, 5, . . . }}
Como mencionamos, el conjunto construdo de esta manera es identico al modelo

mnimo de Herbrand de .
Teorema 3 Sea un programa definitivo y V su modelo mnimo de Herbrand.
Entonces:
V es la interpretacion mnima de Herbrand tal que T (V ) = V .
V = T n.
Captulo 4
Principio de Resolucion
Resumen Este captulo introduce el mecanismo de inferencia utilizado por la ma-

yora de los sistemas de programacion logica. Si seguimos considerando Prolog des-
de la perspectiva de los sistemas formales, hemos descrito ya su lenguaje y su teora
de modelo; ahora describiremos su teora de prueba. El mecanismo en cuestion es
un caso particular de la regla de inferencia llamada principio de resolucion [15].
La idea es acotar el uso de este principio a programas definitivos, dando lugar a la
resolucion-SLD [7]. Este principio constituye el fundamento de la semantica opera-
cional de los programas definitivos. La resolucion-SLD se demostrara correcta con
respecto a la teora del modelo descrita en la clase anterior.
4.1. Introduccion
La programacion logica concierne el uso de la logica (restringida a clausulas)

para representar y resolver problemas. Este uso es ampliamente aceptado en Inteli-
gencia Artificial (IA), donde la idea se resume como sigue: Un problema o sujeto
de investigacion puede describirse mediante un conjunto de formulas bien formadas
(fbf), de preferencia en forma de clausulas. Si tal descripcion es lo suficientemente
precisa, la solucion al problema o la respuesta a la pregunta planteada en la investi-
gacion, es una consecuencia logica del conjunto de fbf que describen el problema.
Por lo tanto, encontrar que fbf son consecuencia logica de un conjunto de fbf ,
es crucial para muchas areas de la IA, incluyendo la programacion logica. De forma
que nos gustara tener un procedimiento, algortmico, que nos permita establecer si
|= es el caso, o no. Este es el tema del presente captulo: un metodo decidible
conocido como principio de resolucion [15].
En el caso de la logica proposicional, la implicacion logica es decidible, es decir,
existe un algoritmo que puede resolver el problema (contestar si o no para cada caso
particular |= ). Si n es el numero de atomos distintos que ocurren en estas fbf,
el numero de interpretaciones posibles es finito, de hecho es 2n . Un algoritmo para
43
44 4 Principio de Resolucion
computar |= simplemente busca si es verdadero en todos los modelos de .

Que sucede en el contexto de la logica de primer orden?
La intuicion nos dice que el procedimiento de decision de la logica proposicional
no es adecuado en primer orden, pues en este caso podemos tener una cantidad
infinita de dominios e interpretaciones diferentes. Lo que es peor, el teorema de
Church [2, 19], muestra que la logica de primer orden es indecidible:
Teorema 4 (Church) El problema de si |= , cuando es un conjunto finito
arbitrario de fbf, y es una fbf arbitraria, es indecidible.
Observen que el problema es indecidible para conjuntos arbitrarios de fbf y para

una fbf arbitraria. No existe un algoritmo que en un numero finito de pasos, de la
respuesta correcta a la pregunta Es una consecuencia logica de ?
Existen, sin embargo, procedimientos conocidos como procedimientos de prue-
ba que pueden ser de gran ayuda para computar este problema. La idea es que
cuando es el caso que |= , existen procedimientos que pueden verificarlo en
un numero finito de pasos. Por ello suele decirse que la logica de primer orden es
semi-decidible. Aunque parecera trivial, siendo que |= , preguntar |= ?, en
realidad tal trivialidad es aparente. Podemos hacer la pregunta al procedimiento sin
que nosotros sepamos que ese es el caso, y obtendremos una respuesta en un numero
finito de pasos. Pero si es el caso que 6|= obtendremos la respuesta no (en el
mejor de los casos) o el procedimiento no terminara nunca. Esto es infortunado y,
peor aun, inevitable.
Esta sesion introduce el procedimiento de prueba utilizado ampliamente en la
programacion logica: el principio de resolucion propuesto por J.A. Robinson [15]. Si
bien este procedimiento esta orientado a un lenguaje mas expresivo que los progra-
mas logicos definitivos, nosotros nos concentraremos en una version del principio
que aplica a programas definidos y se conoce como resolucion-SLD [7] (resolucion
lineal con funcion de seleccion para clausulas definitivas).
4.2. Que es un procedimiento de prueba?
Hasta este momento, hemos abordado informalmente el concepto de procedi-

miento de prueba como la manera de generar la prueba de que una fbf es conse-
cuencia logica de un conjunto de fbf . Las fbf en se conocen como premisas y
es la conclusion de la prueba.
La prueba suele consistir de un pequeno numero de transformaciones en los cua-
les nuevas fbf son derivadas de las premisas y de fbf previamente derivadas. Derivar
una fbf implica construirla a partir de las premisas y otras fbf derivadas, siguien-
do alguna regla de inferencia. Toda regla de inferencia formaliza alguna forma
natural de razonamiento. Por ejemplo, el modus ponens es usado comunmente en
matematicas, su expresion es:
4.3 Pruebas y programas logicos 45
,

donde la lnea superior expresa las premisas y la lnea inferior la conclusion.
Es posible ligar varias aplicaciones del modus ponens para construir una prueba.
Por ejemplo, si tenemos el programa logico = {p(a), q(b) p(a), r(b) q(b)}
es posible derivar la fbf r(b) como sigue:
1. Derivar q(b) a partir de p(a) y q(b) p(a).

2. Derivar r(b) a partir de q(b) y r(b) q(b).
La secuencia anterior es una prueba de que r(b) puede ser derivada de .
Es evidente que si usamos modus ponens, la conclusion es una consecuencia
logica de las premisas: { , } |= . A esta propiedad del modus ponens se le
conoce como consistencia (soundness). En general un procedimiento de prueba es
consistente si todas las fbf que pueden ser derivadas de algun conjunto de fbfs
usando el procedimiento, son consecuencias logicas de . En otras palabras, un pro-
cedimiento de prueba es consistente si y solo si solo permite derivar consecuencias
logicas de las premisas.
Una segunda propiedad deseable de los procedimientos de prueba es su comple-
tez. Un procedimiento de prueba es completo si toda fbf que es una consecuencia
logica de las premisas , puede ser derivada usando el procedimiento en cuestion. El
modus ponens por si mismo, no es completo. Por ejemplo, no existe secuencia algu-
na de aplicaciones del modus ponens que deriven la fbf p(a) de = {p(a) p(b)},
cuando es evidente que |= p(a).
La regla es completa, pero no valida. !Nos permite extraer cualquier conclu-
sion, a partir de cualquier premisa! Esto ejemplifica que obtener completitud es
sencillo, pero obtener completitud y correctez, no lo es.
4.3. Pruebas y programas logicos
Recordemos que los enunciados en los programas logicos tienen la estructura

general de la implicacion logica:
0 1 , . . . , n (n 0)
donde 0 , . . . , n son fbfs atomicas y 0 puede estar ausente (para representar
clausulas meta). Consideren el siguiente programa definitivo que describe un
mundo donde los padres de un recien nacido estan orgullosos, Juan es el padre de
Marta y Marta es una recien nacida:
orgulloso(X) padre(X,Y ), recien nacido(Y ).

padre(X,Y ) papa(X,Y ).
padre(X,Y ) mama(X,Y ).
papa( juan, marta).
recien nacido(marta).
Observen que el programa describe unicamente conocimiento positivo, es decir,

no especifica quien no esta orgulloso. Tampoco que significa para alguien no ser
padre.
Supongamos que deseamos contestar la pregunta Quien esta orgulloso? Esta
pregunta concierne al mundo descrito por nuestro programa, esto es, concierne al
modelo previsto para . La respuesta que esperamos es, por supuesto, juan. Ahora,
recuerden que la logica de primer orden no nos permite expresar enunciados inte-
rrogativos, por lo que nuestra pregunta debe formalizarse como una clausula meta
(enunciado declarativo):
orgulloso(Z).
que es una abreviatura de Zorgulloso(Z) (una clausula definitiva sin cabeza), que
a su vez es equivalente de:
Z orgulloso(Z).
cuya lectura es Nadie esta orgulloso, esto es, la respuesta negativa a la consulta
original Quien esta orgulloso? La meta ahora es probar que este enunciado es
falso en todo modelo del programa y en particular, es falso en el modelo previsto
para , puesto que esto es una forma de probar que |= Z orgulloso(Z). En ge-
neral para todo conjunto de fbf cerradas y una fbf cerrada , tenemos que |=
si {} es no satisfacerle (no tiene modelo).
Por lo tanto, nuestro objetivo es encontrar una substitucion tal que el con-
junto {orgulloso(Z) } sea no satisfacerle, o de manera equivalente, |=
Z orgulloso(Z) .
El punto inicial de nuestro razonamiento es asumir la meta G0 Para cualquier
Z, Z no esta orgulloso. La inspeccion del programa revela que una regla describe
una condicion para que alguien este orgulloso:
orgulloso(X) padre(X,Y ), recien nacido(Y ).

lo cual es logicamente equivalente a:
(orgulloso(X) (padre(X,Y ) recien nacido(Y )))

Al renombrar X por Z, eliminar el cuantificador universal y usar modus ponens
con respecto a G0 , obtenemos:
4.3 Pruebas y programas logicos 47
(padre(Z,Y ) recien nacido(Y ))

o su equivalente:
padre(Z,Y ), recien nacido(Y ).

al que identificaremos como G1 . Un paso en nuestro razonamiento resulta en rem-
plazar la meta G0 por la meta G1 que es verdadera en todo modelo {G0 }. Ahora
solo queda probar que {G1 } es no satisfacible. Observen que G1 es equivalente
a la fbf:
ZY (padre(Z,Y ) recien nacido(Y ))

Por lo tanto, puede probarse que la meta G1 es no satisfacible para , si en
todo modelo de hay una persona que es padre de un recien nacido. Entonces,
verificamos primero si hay padres con estas condiciones. El programa contiene la
clausula:
padre(X,Y ) papa(X,Y ).
que es equivalente a:
(padre(X,Y ) papa(X,Y ))
por lo que G1 se reduce a:
papa(Z,Y ), recien nacido(Y ).

que identificaremos como G2 . Se puede mostrar que no es posible satisfacer la nueva
meta G2 con el programa , si en todo modelo de hay una persona que es papa de
un recien nacido. El programa declara que juan es padre de marta:
papa( juan, marta).

as que solo resta probar que marta no es una recien nacida no se puede satisfacer
junto con :
pero el programa contiene el hecho:
equivalente a recien nacido(marta) f lo que conduce a una refutacion.
Este razonamiento puede resumirse de la siguiente manera: para probar la exis-
tencia de algo, suponer lo contrario y usar modus ponens y la regla de eliminacion
del cuantificador universal, para encontrar un contra ejemplo al supuesto.
Observen que la meta definitiva fue convertida en un conjunto de atomos a ser
probados. Para ello, se selecciono una fbf atomica de la meta p(s1 , . . . , sn ) y una
clausula de la forma p(t1 , . . . ,tn ) A1 , . . . An para encontrar una instancia comun de

p(s1 , . . . , sn ) y p(t1 , . . . ,tn ), es decir, una substitucion que hace que p(s1 , . . . , sn )
y p(t1 , . . . ,tn ) sean identicos. Tal substitucion se conoce como unificador. La nue-
va meta se construye remplazando el atomo seleccionado en la meta original, por
los atomos de la clausula seleccionada, aplicando a todos los atomos obtenidos de
esta manera.
El paso de computacion basico de nuestro ejemplo, puede verse como una regla
de inferencia puesto que transforma formulas logicas. Lo llamaremos principio de
resolucion SLD para programas definitivos. Como mencionamos, el procedimiento
combina modus ponens, eliminacion del cuantificador universal y en el paso final
un reductio ad absurdum.
Cada paso de razonamiento produce una substitucion, si se prueba en k pasos que
la meta definida en cuestion no puede satisfacerse, probamos que:
(A1 , . . . Am )1 . . . k
es una instancia que no puede satisfacerse. De manera equivalente, que:
|= (A1 Am )1 . . . k
Observen que generalmente, la computacion de estos pasos de razonamiento no
es determinista: cualquier atomo de la meta puede ser seleccionado y pueden haber
varias clausulas del programa que unifiquen con el atomo seleccionado. Otra fuente
de indeterminismo es la existencia de unificadores alternativos para dos atomos. Es-
to sugiere que es posible construir muchas soluciones (algunas veces, una cantidad
infinita de ellas).
Por otra parte, es posible tambien que el atomo seleccionado no unifique con
ninguna clausula en el programa. Esto indica que no es posible construir un contra
ejemplo para la meta definida inicial. Finalmente, la computacion puede caer en un
ciclo y de esta manera no producir solucion alguna.
4.4. Substitucion
Una substitucion remplaza variables por terminos, por ejemplo, podemos rem-
plazar la variable X por el termino f (a) en la clausula p(X) q(X), y as obtener la
nueva clausula p( f (a))q( f (a)). Si asumimos que las clausulas estan cuantificadas
universalmente, decimos que esta substitucion hace a la clausula original, menos
general. Mientras que la clausula original dice que V (p(X)) = t y que V (q(X)) = t
para cualquier X en el dominio, la segunda clausula dice que esto solo es cierto
cuando cuando V (X) = f (a). Observen que la segunda clausula es consecuencia
logia de la primera: p(X) q(X) |= p( f (a)) q( f (a))
Definicion 26 (Substitucion) Una substitucion es un conjunto finito de la forma:
{X1 /t1 , . . . , Xn /tn }, (n 0)

4.4 Substitucion 49
donde las Xi son variables, distintas entre si, y los ti son terminos. Decimos que
ti substituye a Xi . La forma Xi /ti se conoce como ligadura de Xi . La substitucion
se dice se dice de base (grounded) si cada termino ti es un termino base (no incluye
variables)..
La substitucion dada por el conjunto vaco, se conoce como substitucion de

identidad o substitucion vaca y se denota por . La restriccion de sobre un
conjunto de variables Var es la substitucion {X/t | X Var}.
Ejemplo 8 {Y /X, X/g(X,Y )} y {X/a,Y / f (Z), Z/( f (a), X1 /b} son substituciones.
La restriccion de la segunda substitucion sobre {X, Z} es {X/a, Z/ f (a)}.
Definicion 27 (Expresion) Una expresion es un termino, una literal, o una conjun-
cion o disyuncion de literales. Una expresion simple es un termino o una literal.
Observen que una clausula es una expresion. Las substituciones pueden aplicarse
a las expresiones, lo que significa que las variables en las expresiones seran rempla-
zadas de acuerdo a la substitucion.
Definicion 28 Sea = {X1 /t1 , . . . , Xn /tn } una substitucion y una expresion. En-
tonces , la ocurrencia (instance) de por , es la expresion obtenida al substi-
tuir simultaneamente Xi por ti para 1 i n. Si es una expresion de base, se
dice que es una ocurrencia base y se dice que es una substitucion de base para
. Si = {1 , . . . , n } es un conjunto finito de expresiones, entonces denota
{1 , . . . , n }.
Ejemplo 9 Sea la expresion p(Y, f (X)) y sea la substitucion {X/a,Y /g(g(X))}.
La ocurrencia de por es = p(g(g(X)), f (a). Observen que X e Y son si-
multaneamente remplazados por sus respectivos terminos, lo que implica que X en
g(g(X)) no es afectada por X/a.
Si es una expresion cerrada que no es un termino, por ejemplo, una literal, o
una conjuncion o disyuncion de literales, y es una substitucion, lo siguiente se
cumple:
|=
por ejemplo: p(X) q(Y ) |= p(a) q(Y ) donde hemos usado la substitucion
{X/a}.
Podemos aplicar una substitucion y luego aplicar una substitucion , a lo cual
se llama composicion de las substituciones y . Si ese es el caso, primero se
aplica y luego . Las composiciones pueden verse como mapeos del conjunto de
variables en el lenguaje, al conjunto de terminos.
Definicion 29 (Composicion) Sean = {X1 /s1 , . . . , Xm /sm } y = {Y1 /t1 , . . .Yn /tn }
dos substituciones. Consideren la secuencia:
X1 /(s1 ), . . . , Xm /(sm ),Y1 /t1 , . . . ,Yn /tn

Si se borran de esta sencuencia las ligaduras Xi /si cuando Xi = si y cualquier

ligadura Y j /t j donde Y j {X1 , . . . , Xm }. La substitucion consistente en las ligaduras
de la secuencia resultante es llamada composicion de y , se denota por .
Ejemplo 10 Sea = {X/ f (Y ), Z/U} y = {Y /b,U/Z}. Construimos la secuen-

cia de ligaduras X/( f (Y ) ), Z/(u) ,Y /b,U/Z lo cual es X/ f (b), Z/Z,Y /b,U/Z.
Al borrar la ligadura Z/Z obtenemos la secuencia X/ f (b),Y /b,U/Z = .
Definicion 30 (Ocurrencia) Sean y dos substituciones. Se dice que es una
ocurrencia de , si existe una substitucion , tal que = .
Ejemplo 11 La substitucion = {X/ f (b),Y /a} es una ocurrencia de la substitu-

cion = {X/ f (X),Y /a}, puesto que {X/b} = .
Algunas propiedades sobre las substituciones incluyen:
Proposicion 3 Sea una expresion, y sea , y substituciones. Las siguientes
relaciones se cumplen:
1. = =
2. ( ) = ( )
3. ) = ( )
4.5. Unificacion
Uno de los pasos principales en el ejemplo de la seccion 4.3, consistio en ha-

cer que dos fbf atomicas se vuelvan sintacticamente equivalentes. Este proceso se
conoce como unificacion y posee una solucion algortmica.
Definicion 31 (Unificador) Sean y terminos. Una substitucion tal que y

sean identicos ( = ) es llamada unificador de y .
Ejemplo 12
uni f ica(conoce( juan, X), conoce( juan, maria)) = {X/maria}
uni f ica(conoce( juan, X), conoce(Y, Z)) = {Y / juan, X/Z}

= {Y / juan, X/Z,W /pedro}
= {Y / juan, X/ juan, Z/ juan}
Definicion 32 (Generalidad entre substituciones) Una substitucion se dice mas

general que una substitucion , si y solo si existe una substitucion tal que = .
Definicion 33 (MGU) Un unificador se dice el unificador mas general (MGU)
de dos terminos, si y solo si es mas general que cualquier otro unificador entre
esos terminos.
4.5 Unificacion 51
Definicion 34 (Forma resuelta) Un conjunto de ecuaciones {X1 = t1 , . . . , Xn = tn }

esta en forma resuelta, si y solo si X1 , . . . , Xn son variables distintas que no ocurren
en t1 , . . . ,tn .
Existe una relacion cercana entre un conjunto de ecuaciones en forma resuelta y

el unificador mas general de ese conjunto: Sea {X1 = t1 , . . . , Xn = tn } un conjunto de
ecuaciones en forma resuelta. Entonces {X1 /t1 , . . . , Xn /tn } es un MGU idempotente
de la forma resuelta.
Definicion 35 (Equivalencia en conjuntos de ecuaciones) Dos conjuntos de ecua-
ciones E1 y E2 se dicen equivalentes, si tienen el mismo conjunto de unificadores.
La definicion puede usarse como sigue: para computar el MGU de dos terminos
y , primero intente transformar la ecuacion { = } en una forma resuelta
equivalente. Si esto falla, entonces mgu(, ) = f allo. Sin embargo, si una forma
resuelta {X1 = t1 , . . . , Xn = tn } existe, entonces mgu(, ) = {X1 /t1 , . . . , Xn /tn }. Un
algoritmo para encontrar la forma resuelta de un conjunto de ecuaciones es como
sigue:
Algoritmo 1 Unifica(E)
1: function U NIFICA(E) . E es un conjunto de ecuaciones
2: repeat
3: (s = t) seleccionar(E)
4: if f (s1 , . . . , sn ) = f (t1 , . . . ,tn ) (n 0) then
5: remplazar (s = t) por s1 = t1 , . . . , sn = tn
6: else if f (s1 , . . . , sm ) = g(t1 , . . . ,tn ) ( f /m 6= g/n) then
7: return(fallo)
8: else if X = X then
9: remover la X = X
10: else if t = X then
11: remplazar t = X por X = t
12: else if X = t then
13: if subtermino(X,t) then
14: return(fallo)
15: else remplazar todo X por t
16: end if
17: end if
18: until No hay accion posible para E
19: end function
Ejemplo 13 El conjunto { f (X, g(Y )) = f (g(Z), Z)} tiene una forma resuelta, pues-
to que:
{X = g(Z), g(Y ) = Z}
{X = g(Z), Z = g(Y )}
{X = g(g(Y )), Z = g(Y )}
Ejemplo 14 El conjunto { f (X, g(X), b) = f (a, g(Z), Z)} no tiene forma resuelta,
puesto que:
{X = a, g(X) = g(Z), b = Z}
{X = a, g(a) = g(Z), b = Z}
{X = a, a = Z, b = Z}
{X = a, Z = a, b = Z}
{X = a, Z = a, b = a}
f allo
Ejemplo 15 El conjunto { f (X, g(X)) = f (Z, Z)} no tiene forma resuelta, puesto
que:
{X = Z, g(X) = Z}
{X = Z, g(Z) = Z}
{X = Z, Z = g(Z)}
f allo
Este algoritmo termina y regresa una forma resuelta equivalente al conjunto
de ecuaciones de su entrada; o bien regresa fallo si la forma resuelta no existe.
Sin embargo, el computar subtermino(X,t) (verificacion de ocurrencia) hace que
el algoritmo sea altamente ineficiente. Los sistemas Prolog resuelven este proble-
ma haciendo caso omiso de la verificacion de ocurrencia. El standard ISO Prolog
(1995) declara que el resultado de la unificacion es no decidible. Al eliminar la ve-
rificacion de ocurrencia es posible que al intentar resolver X = f (X) obtengamos
X = f ( f (X)) = f ( f ( f . . . )). En la practica los sistemas Prolog no caen en este
ciclo, pero realizan la siguiente substitucion {X/ f ()}. Si bien esto parece resolver
el problema de eficiencia, generaliza el concepto de termino, substitucion y unifica-
cion al caso del infinito, no considerado en la logica de primer orden, introduciendo
a su vez inconsistencia.
4.6. Resolucion-SLD
El metodo de razonamiento descrito informalmente al inicio de esta sesion, puede

resumirse con la siguiente regla de inferencia:
(1 i1 i i+1 m ) (0 1 n )
(1 i1 1 n i+1 m )
o, de manera equivalente, usando la notacion de los programas definitivos:
4.6 Resolucion-SLD 53
1 , . . . , i1 , i , i+1 , . . . , m 0 1 , . . . , n
(1 , . . . , i1 , 1 , . . . , n , . . . , m )
donde:
1. 1 , . . . , m son fbf atomicas.
2. 0 1 , . . . , n es una clausula definitiva en el programa (n 0).
3. MGU(i , 0 ) = .
La regla tiene dos premisas: una meta y una clausula definitivas. Observen que
cada una de ellas esta cuantificada universalmente, por lo que el alcance de los
cuantificadores es disjunto. Por otra parte, solo hay un cuantificador universal para
la conclusion, por lo que se requiere que el conjunto de variables en las premisas
sea disjunto. Puesto que todas las variables en las premisas estan cuantificadas, es
siempre posible renombrar las variables de la clausula definitiva para cumplir con
esta condicion.
La meta definida puede incluir muchas fbf atomicas que unifican con la cabeza de
alguna clausula en el programa. En este caso, es deseable contar con un mecanismo
determinista para seleccionar un atomo i a unificar. Se asume una funcion que
selecciona una submeta de la meta definida (funcion de seleccion).
La regla de inferencia presentada es la unica necesaria para procesar programas
definitivos. Esta regla es una version de la regla de inferencia conocida como prin-
cipio de resolucion, introducido por J.A. Robinson en 1965. El principio de resolu-
cion aplica a clausulas. Puesto que las clausulas definitivas son mas restringidas que
las clausulas, la forma de resolucion presentada se conoce como resolucion-SLD
(resolucion lineal para clausulas definitivas con funcion de seleccion).
El punto de partida de la aplicacion de esta regla de inferencia es una meta defi-
nida G0 :
1 , . . . , m (m 0)
De esta meta, una submeta i sera seleccionada, de preferencia por una funcion
de seleccion. Una nueva meta G1 se construye al seleccionar una clausula del pro-
grama 0 1 , . . . , n (n 0) cuya cabeza 0 unifica con i , resultando en 1 . G1
tiene la forma:
(1 , . . . , i1 , 1 , . . . , n , . . . , m )1
Ahora es posible aplicar el principio de resolucion a G1 para obtener G2 , y as su-
cesivamente. El proceso puede terminar o no. Hay dos situaciones donde no es po-
sible obtener Gi+1 a partir de Gi :
1. cuando la submeta seleccionada no puede ser resuelta (no es unificable con la
cabeza de una clausula del programa).
2. cuando Gi = 2 (meta vaca = f).
Definicion 36 (Derivacion-SLD) Sea G0 una meta definitiva, un programa defi-
nitivo y R una funcion de seleccion. Una derivacion SLD de G0 (usando y R) es
una secuencia finita o infinita de metas:
0 n1
G0 G1 . . . Gn1 Gn
Para manejar de manera consistente el renombrado de variables, las variables en
una clausula i seran renombradas poniendoles subndice i.
Cada derivacion SLD nos lleva a una secuencias de MGUs 1 , . . . , n . La com-
posicion
(
1 2 . . . n si n > 0
=
si n = 0
de MGUs se conoce como la substitucion computada de la derivacion.
Ejemplo 16 Consideren la meta definida orgulloso(Z) y el programa discutido
en la clase anterior.
G0 = orgulloso(Z).
0 = orgulloso(X0 ) padre(X0 ,Y0 ), recien nacido(Y0 ).
La unificacion de orgulloso(Z) y orgulloso(X0 ) nos da el MGU 1 = {X0 /Z}.
Asumamos que nuestra funcion de seleccion es tomar la submeta mas a la izquierda.
El primer paso de la derivacion nos conduce a:
G1 = padre(Z,Y0 ), recien nacido(Y0 ).

1 = padre(X1 ,Y1 ) papa(X1 ,Y1 ).
En el segundo paso de la resolucion el MGU 2 = {X1 /Z,Y1 /Y0 } es obtenido. La
derivacion continua como sigue:
G2 = papa(Z,Y0 ), recien nacido(Y0 ).

2 = papa( juan, marta).
G3 = recien nacido(marta).
3 = recien nacido(marta).
G4 = 2
la substitucion computada para esta derivacion es:
1 2 3 4 = {X0 /Z}{X1 /Z,Y1 /Y0 }{Z/ juan,Y0 /marta}

= {X0 / juan, X1 / juan,Y1 /marta, Z/ juan,Y0 /marta}
Las derivaciones SLD que terminan en la meta vaca (2) son de especial impor-
tancia pues corresponden a refutaciones a la meta inicial (y proveen las respuestas a
la meta).
Definicion 37 (Refutacion SLD) Una derivacion SLD finita:

4.6 Resolucion-SLD 55
0 n1
G0 G1 . . . Gn1 Gn
donde Gn = 2, se llama refutacion SLD de G0 .

Definicion 38 (Derivacion fallida) Una derivacion de la meta definitiva G0 cuyo
ultimo elemento no es la meta vaca y no puede resolverse con ninguna clausula del
programa, es llamada derivacion fallida.
Definicion 39 (Arbol-SLD) Sea un programa definitivo, G0 una meta definitiva,
y R una funcion de seleccion. El arbol-SLD de G0 (usando y R) es un arbol
etiquetado, posiblemente infinito, que cumple las siguientes condiciones:
La raz del arbol esta etiquetada por G0 .

Si el arbol contiene un nodo etiquetado como Gi y existe una clausula renom-
brada i tal que Gi+1 es dervidada de Gi y i via R, entonces el nodo
etiquetado como Gi tiene un hijo etiquetado Gi+1 El arco que conecta ambos
nodos esta etiquetado como i .
Por ejemplo:
orgulloso(Z)
padre(Z,Y0 ), recien nacido(Y0 )
papa(Z,Y0 ), recien nacido(Y0 ) mama(Z,Y0 ), recien nacido(Y0 )
recien nacido(marta)
4.6.1. Propiedades de la resolucion-SLD
Definicion 40 (Consistencia) Sea un programa definitivo, R una funcion de se-

leccion, y una substitucion de respuesta computada a partir de y R para una
meta 1 , . . . , m . Entonces ((1 m ) ) es una consecuencia logica del
programa .
Definicion 41 (Complecion) Sea un programa definitivo, R una funcion de se-

leccion y 1 , . . . , m una meta definitiva. Si |= ((1 m ) ), entonces
existe una refutacion de 1 , . . . , m va R con una substitucion de respuesta
computada , tal que (1 m ) es un caso de (1 m ) .
Captulo 5
Negacion
Resumen Si los programas definitivos representan unicamente conocimiento posi-

tivo sobre un problema Como es que se pueden computar consecuencias logicas
negativas? Este captulo introduce los conceptos de supuesto del mundo cerrado
(CWA) y su forma mas relajada, conocida como negacion por fallo finito (NAF),
para introducir el manejo de conocimiento negativo en los programas definitivos. Se
introducen tambien los conceptos de complecion de programa y resolucion-SLDNF.
Finalmente abordaremos el concepto de programas generales y la resolucion para
este tipo de programas.
5.1. Introduccion
Los programas definitivos expresan conocimiento positivo, en el sentido que los

hechos y las reglas describen que ciertos objetos estan en cierta relacion con otros.
Las relaciones se hacen explcitas en el modelo mnimo de Herbrand el conjunto
de todas las consecuencias atomicas de base de un programa. Por ejemplo, conside-
ren el siguiente programa :
sobre(X,Y ) en(X,Y ).
sobre(X,Y ) en(X, Z), sobre(Z,Y ).
en(c, b).
en(b, a).
El modelo mnimo de Herbrand para este programa es el siguiente:
{en(b, a), en(c, b), sobre(b, a), sobre(c, b), sobre(c, a)}
Observen que ni el programa, ni el modelo mnimo de Herbrand, incluyen in-
formacion negativa del tipo: a no esta sobre b, o b no esta sobre c. Sin embargo,
57
58 5 Negacion
nosotros usamos informacion negativa implcita en algunos casos. Por ejemplo, si

cuando buscamos un boleto de autobus, nos encontramos con que no aparecen sa-
lidas a Mexico a las 10:12 am, asumimos que tal salida no existe. La ausencia de
informacion se asume como evidencia de lo contrario. Esto es posible porque, como
en el caso de autobus, asumimos que toda la informacion disponible esta a nuestro
alcance.
La idea anterior se puede formular con la suposicion del mundo cerrado
(Closed-World Assumption) o CWA, una pseudo-regla de inferencia que expresa:
6`
(CWA)

Si una fbf atomica de base (sin variables) , no puede derivarse del programa
siguiendo las reglas de inferencia del sistema, entonces puede derivarse .
En el caso de los sistemas correctos y completos, la condicion 6` es equiva-
lente a 6|= . Como este es el caso para la resolucion-SLD, la condicion puede ser
remplazada por 6 M . Por ejemplo, la fbf sobre(b, c) no puede ser derivada por re-
solucion-SLD a partir del programa (vean el arbol de derivacion en la figura 5.1).
En realidad sobre(b, c) no puede ser derivada por ningun sistema correcto, puesto
que no es una consecuencia logica de . Dada la completitud de la resolucion-SLD,
se sigue que 6|= sobre(b, c) y usando la CWA inferimos que sobre(b, c).
sobre(b, c)
en(b, c) en(b, Z0 ), sobre(Z0 , c)
sobre(a, c)
en(a, c) en(a, Z2 ), sobre(Z2 , c)
Figura 5.1 Arbol de derivacion-SLD fallido
En contra de lo que podra ser nuestra primera intuicion, existen problemas aso-
ciados a la CWA. El principal tiene que ver con que la no-derivabilidad para los
programas definitivos es no decidible en el caso general. Esto es, no es posible de-
terminar si la pseudo-regla asociada al CWA aplica o no. Una version mas debil de
la suposicion de mundo cerrado, se logra si asumimos que es derivable a partir
del programa si la meta tiene un arbol-SLD finito que falla. A esta regla se
le conoce como negacion como falla (finita) (NAF).
Es necesario contrastar la NAF con la CWA, que tambien puede verse como
una negacion por falla, pero infinita. Para ilustrar la diferencia entre los dos enfo-
5.2 La complecion de un programa 59
ques extendamos el programa con la siguiente clausula evidentemente verdadera

sobre(X,Y ) sobre(X,Y ).
El arbol-SLD de la meta sobre(b, c) sigue sin contener refutaciones, pero aho-
ra es infinito. Por lo tanto no podemos concluir que sobre(b, c) usando NAF, pero
si usando CWA.
Pero el problema mas serio con estos enfoques es que son incorrectos, sobre(b, c)
no es una consecuencia logica del programa . En lo general, cualquier sistema que
permita inferir literales negativas a partir de un programa definitivo, es incorrec-
to. La razon es que la base de Herbrand del programa B , en el cual todas las fbf
atomicas cerradas son verdaderas, es siempre un modelo de .
Existen dos aproximaciones a la solucion de estos problemas: ver los programas
como resumenes de programas mas extensos que validan las literales negativas; o
redefinir la nocion de consecuencia logica de forma que solo algunos modelos del
programa (el mnimo de Herbrand, por ejemplo) sean tomados en cuenta. En ambos
casos, el efecto es descartar algunos modelos del programa que no son interesantes.
Primero justificaremos la regla NAF en terminos de la complecion de los programas
definitivos y posteriormente, extenderemos el lenguaje de los programas definitivos
para incluir en ellos literales negativas en la cabeza y cuerpo de las clausulas.
5.2. La complecion de un programa
La idea que presentaremos a continuacion se debe a K. Clark [3] y se basa en que

cuando uno escribe un programa definitivo , en realidad quiere expresar algo mas
que su conjunto de clausulas definitivas. El programa deseado puede formalizarse
como la complecion de . Consideren la siguiente definicion:
sobre(X,Y ) en(X,Y ).
sobre(X,Y ) en(X, Z), sobre(Z,Y ).
Estas reglas especifican que un objeto esta sobre un segundo objeto, si el primer
objeto esta encima del segundo (1) o si el objeto esta sobre otro objeto que a su vez
esta encima del segundo (2). Esto tambien puede escribirse como:
sobre(X,Y ) en(X,Y ) (en(X, Z), sobre(Z,Y ))

Ahora, Que sucede si remplazamos la implicacion por la equivalencia logica?
sobre(X,Y ) en(X,Y ) (en(X, Z), sobre(Z,Y ))

Esta fbf expresa que X esta sobre Y si y solo si una de las condiciones es verda-
dera. Esto es, si ninguna de las condiciones se cumple, se sigue que X no esta sobre
Y ! Esta es la intuicion seguida para explicar la negacion como falla.
60 5 Negacion
Desafortunadamente, combinar clausulas definitivas como en el ejemplo anterior,

solo es posible para clausulas con cabezas identicas. Por ejemplo:
en(c, b).
en(b, a).
Por una simple transformacion, el programa puede ser escrito como:
en(X1 , X2 ) X1 = c, X2 = b
en(X1 , X2 ) X1 = b, X2 = a
Las clausulas pueden combinarse en una sola formula, donde la implicacion es

remplazada por la equivalencia logica.
en(X1 , X2 ) (X1 = c, X2 = b) (X1 = b, X2 = a)

La lectura logica de esta fbf es que X1 esta en X2 si y solo si X1 = c y X2 = b o
si X1 = b y X2 = a. Esta transformacion se puede realizar sobre un programa logico
definitivo y el resultado se conoce como complecion de .
Definicion 42 (Complecion) Sea un programa logico definitivo. La complecion

comp( ) de es el conjunto de formulas obtenido a partir de las siguientes tres
transformaciones:
1. Para cada smbolo de predicado remplazar la clausula de la forma:
(t1 , . . . ,tm ) 1 , . . . , n (n 0)
por la formula:
(X1 , . . . , Xm ) Y1 , . . . ,Yi (X1 = t1 , . . . , Xm = tm , 1 , . . . , n )
donde las Yi son todas variables en y las Xi son variables unicas que no apa-
recen en .
2. Para cada smbolo de predicado remplazar todas las fbf:
(X1 , . . . , Xm ) 1
..
.
(X1 , . . . , Xm ) j
por la formula:
5.2 La complecion de un programa 61
X1 , . . . , Xm ( (X1 , . . . , Xm ) 1 , . . . , j si j > 0
X1 , . . . , Xm ( (X1 , . . . , Xm )) si j = 0
3. Finalmente el programa se extiende con los siguientes axiomas de igualdad libre,

que definen las igualdades introducidas en el paso 1:
(X = X)
(X = Y Y = X)
(X = Y Y = Z X = Z)
(X1 = Y1 Xn = Yn f (X1 , . . . , Xn ) = f (Y1 , . . . ,Yn ))
(X1 = Y1 Xn = Yn ( (X1 , . . . , Xn ) (Y1 , . . . ,Yn ))
( f (X1 , . . . , Xn ) = f (Y1 , . . . ,Yn ) X1 = Y1 Xn = Yn )
( f (X1 , . . . , Xm ) = g(Y1 , . . . ,Yn ))(Si f /m 6= g/n)
(X = t)(Si X es un subtermino propio de t)
Estas definiciones garantizan que la igualdad (=) sea una relacion de equivalen-
cia; que sea una relacion congruente; y que formalice la nocion de unificacion. Las
primeros cinco definiciones se pueden abandonar si se especifica que = representa
la relacion de identidad .
Ejemplo 17 Consideremos la construccion de comp( ) tal y como se definio ante-
riormente. El primer paso produce:
sobre(X1 , X2 ) X,Y (X1 = X, X2 = Y, en(X,Y ))

sobre(X1 , X2 ) X,Y, Z (X1 = X, X2 = Y, en(Z,Y ), sobre(Z,Y ))
en(X1 , X2 ) (X1 = c, X2 = b)
en(X1 , X2 ) (X1 = b, X2 = a)
dos pasos mas adelante obtenemos:
X1 , X2 (sobre(X1 , X2 X,Y (. . . ) X,Y, Z(. . . ))

X1 , X2 (en(X1 , X2 ) (X1 = c, X2 = b) (X1 = b, X1 = a))
y el programa se termina con las definiciones de igualdad como identidad y unifi-

cacion.
La complecion comp( ) de un programa definitivo preserva todas las literales

positivas modeladas por . Esto es, si |= entonces comp( ) |= . Tampoco se
agrega informacion positiva al completar el programa: Si comp( ) |= entonces
|= . Por lo tanto, al completar el programa no agregamos informacion positiva
al mismo, solo informacion negativa.
62 5 Negacion
Como sabemos, no es posible que una literal negativa pueda ser consecuencia
logica de un programa definitivo. Pero al substituir las implicaciones en por equi-
valencias en comp( ) es posible inferir informacion negativa a partir del programa
completado. Esta es la justificacion de la regla NAF, cuyas propiedades de consis-
tencia se deben a K. Clark [3]:
Teorema 5 (Consistencia de la NAF) Sea un programa definitivo y una
meta definitiva. Si tiene un arbol-SLD finito fallido, entonces comp( ) |=
().
La consistencia se preserva aun si no es de base. Por ejemplo, en(a, X)

falla de manera finita y por lo tanto, se sigue que comp( ) |= (en(a, X)). La
completitud de la NAF tambien ha sido demostrada:
Teorema 6 (Completitud de la NAF) Sea un programa definitivo. Si comp( ) |=
() entonces existe un arbol finito fallido para la meta definitiva .
Observen que solo enuncia la existencia de un arbol-SLD finito fallido. Como se

ha mencionado, un arbol-SLD puede ser finito bajo ciertas reglas de computacion
e infinito bajo otras. En particular, el teorema de completitud no es valido para
las reglas de computacion de Prolog. La completitud funciona para una subclase
de derivaciones-SLD conocidas como justas (fair), las cuales o bien son finitas o
garantizan que cada atomo en la derivacion (u ocurrencia de este), es seleccionado
eventualmente por las reglas de computacion. Un arbol-SLD es justo si todas sus
derivaciones son justas. La NAF es completa para arboles-SLD justos. Este tipo
de derivaciones se pueden implementar facilmente: selecciona la sub-meta mas a
la izquierda y agrega nuevas submetas al final de esta (busqueda en amplitud). Sin
embargo, pocos sistemas implementan tal estrategia por razones de eficiencia.
5.3. Resolucion SLDNF para programas definitivos
En el captulo 4 presentamos el metodo de resolucion-SLD, utilizado para probar

si una literal positiva cerrada es consencuencia logica de un programa. En la seccion
anterior afirmamos que tambien las literales negadas pueden derivarse a partir de la
terminacion de programas logicos definitivos. Combinando la resolucion SLD y la
negacion como fallo finito (NAF), es posible generalizar la nocion de meta definitiva
para incluir literales positivas y negadas. Tales metas se conocen como generales.
Definicion 43 (Meta general) Una meta general tiene la forma:
1 , . . . n (n 0)
donde cada i es una literal positiva o negada.

La combinacion de la resolucion SLD y la NAF se llama resolucion SLDNF.
5.3 Resolucion SLDNF para programas definitivos 63
Definicion 44 (Resolucion SLDNF para programas definitivos) Sea un pro-

grama definitivo, G0 una meta general y R una funcion de seleccion (tambien co-
nocida como regla de computacion). Una derivacion SLDNF de G0 usando R, es
una secuencia finita o infinita de metas generales:
0 n1
G0 G1 . . . Gn1 Gn
i
donde Gi Gi+1 puede ocurrir si:
1. la literal R-seleccionada en Gi es positiva y Gi+1 se deriva de Gi y i por un
paso de resolucion SLD;
2. la literal R-seleccionada en Gi es negativa () y la meta tiene un arbol
SLD fallido y finito y Gi+1 se obtiene a partir de Gi eliminando (en cuyo caso
i , corresponde al marcador especial FF).
Cada paso en una derivacion SLDNF produce una substitucion, en el caso 1 un
MGU y en el caso 2, la substitucion vaca .
Entonces, una literal negativa es demostrada si tiene un arbol SLD finito
que falla. Por dualidad, falla de manera finita si es demostrada. Ademas de
la refutacion y de la derivacion infinita, existen dos clases de derivaciones SLDNF
completas dada una funcion de seleccion:
1. Una derivacion se dice (finitamente) fallida si (i) la literal seleccionada es positi-
va y no unifica con ninguna cabeza de las clausulas del programa, o (2) la literal
seleccionada es negativa y tiene un fallo finito.
2. Una derivacion se dice plantada (stuck) si la sub-meta seleccionada es de la
forma y tiene un fallo infinito.
Ejemplo 18 Considere el siguiente programa:
en(c, b)
en(b, a)
La meta en(X,Y ), en(Z, X) tiene una refutacion-SLDNF con la substitucion

computada {X/c,Y/b}:
64 5 Negacion
G = en(X,Y ), en(Z, X).

G0 = en(X,Y ).
0 = en(c, b).
0 = {X/c,Y /b}
G1 = en(Z, X)0 = en(Z, c)

1 = FF
1 =
G2 = 2
= 0 1 = {X/c,Y /b}
En cambio, si la funcion de seleccion hubiera computado las clausulas de abajo

haca arriba 0 = en(b, a) la derivacion hubiera sido fallida (a ustedes probarlo).
Como es de esperarse, la resolucion-SLDNF es consistente, despues de todo, la
resolucion-SLD y la NAF son consistentes.
Teorema 7 (Consistencia de la resolucion-SLDNF) Sea un programa definiti-

vo y 1 , . . . , n una meta general. Si 1 , . . . , n tiene una refutacion SLDNF
con una substitucion computada , comp( ) |= (1 , . . . , n ).
Sin embargo, la resolucion-SLDNF no es completa aunque pudieramos haber
esperado lo contrario. La resolucion SLDNF no es completa a pesar de que la re-
solucion-SLD y la NAF si lo son. Un simple contra ejemplo es en(X,Y ) que
corresponde a la consulta Hay algunos bloques X e Y, tal que X no esta en Y?
Uno esperara varias respuestas a esta consulta, por ejemplo, el bloque a no esta en-
cima de ningun bloque, etc.
Pero la derivacion SLDNF de en(X,Y ) falla porque la meta en(X,Y ) tiene
exito (puede ser demostrada). El problema es que nuestra definicion de derivacion
fallida es demasiado conservadora. El exito de en(X,Y ) no significa necesaria-
mente que no halla un bloque que no este en otro bloque, solo que existe al menos
un bloque que no esta en otro.
El problema tiene su origen en que la NAF, en contraste con la resolucion SLD,
es solo una prueba (test). Recuerden que dada la definicion de la resolucion SLDNF
y la consistencia y completitud de la NAF, tenemos que en(X,Y ) tiene exito si
y solo si () en(X,Y ) tiene asociado un arbol SLD fallido y finito; o si y solo si
comp( ) |= (en(X,Y )). Por lo tanto, la meta general en(X,Y ) no debe leerse
como una consulta cuantificada existencialmente, sino como una prueba universal:
Para todo bloque X e Y, No esta X en Y?.
Esta ultima consulta tiene una respuesta negativa en el modelo deseado del pro-
grama, puesto que el bloque b esta en el bloque a. El problema anterior se debe a
la cuantificacion de las variables en la literal negativa. Si replanteamos la consulta
5.4 Programas Logicos Generales 65
anterior como en(a, b) entonces la resolucion SLDNF alcanza una refutacion

puesto que en(a, b) falla con una derivacion finita.
Algunas veces se asume que la funcion de seleccion R permite seleccionar una
literal negativa si la literal no tiene variables libres o si tiene asociada
una substitucion computada vaca. Estas funciones de seleccion se conocen como
seguras (safe).
5.4. Programas Logicos Generales
Con los desarrollos anteriores estamos en posicion de extender el lenguaje de los

programas definitivos para incluir clausulas que contienen literales tanto positivas
como negativas en su cuerpo. Estas fbf se llaman clausulas generales y a los pro-
gramas generales que ellas forman, se les conoce a veces como programas logicos
normales.
Definicion 45 (Clausula General) Una clausula general es una fbf de la forma
A0 1 , . . . , n donde A0 es una fbf atomica y 1 , . . . , n son literales (n 0).
Definicion 46 (Programa General) Un programa logico general es un conjunto
finito de clausulas generales.
Ahora podemos extender nuestro programa del mundo de los bloques con las
siguientes relaciones:
base(X) en(Y, X), en la mesa(X).

en la mesa(X) no en la mesa(X).
no en la mesa(X) en(X,Y ).
en(c, b).
en(b, a).
La primer clausula especifica que un bloque es base si esta sobre la mesa y tiene
otro bloque encima. La segunda clausula indica que cuando no es cierto que un blo-
que no esta sobre la mesa, entonces esta sobre la mesa. La tercera clausula especifica
que un bloque que esta sobre otro, no esta sobre la mesa.
Parece claro, pero la pregunta que deberamos hacernos es que tipo de sistema
de prueba queremos para los programas logicos generales y cuales seran las aproxi-
maciones logicas a las sutilezas, algunas ya discutidas, introducidas por este tipo de
lenguajes.
Observen que aunque el lenguaje fue enriquecido, no es posible de cualquier for-
ma que una literal negativa sea consecuencia logica de un programa dado. La razon
es la misma que para los programas definidos, la base de Herbrand de un programa
, B es un modelo de en el que todas las literales negativas son falsas. Al igual
que con los programas definidos, la pregunta es entonces como lograr inferencias
66 5 Negacion
negativas consistentes. Afortunadamente el concepto de complecion de programa

puede aplicarse tambien a los programas logicos generales.
Ejemplo 19 La complecion de gana(X) mueve(X,Y ), gana(Y ) contiene la fbf:
X1 (gana(X1 ) X,Y (X1 = X, mueve(X,Y ), gana(Y )))

Desafortunadamente, la complecion de los programas normales puede ocasionar
paradojas. Consideren la clausula general p p, su complecion incluye p p.
La inconsistencia del programa terminado se debe a que p/0 esta definida en termi-
nos de su propio complemento.
Una estrategia de programacion para evitar este problema consiste en componer
los programas por capas o estratos, forzando al programador a referirse a las nega-
ciones de una relacion hasta que esta ha sido totalmente definida. Se entiende que
tal definicion se da en un estrato inferior a donde se presenta la negacion. En la de-
finicion del programa estratificado usaremos p para referirnos al subconjunto de
clausulas en que tienen a p como cabeza.
Definicion 47 (Programa Estratificado) Un programa general se dice estratifi-

cado si y solo si existe al menos una particion 1 n de tal que :
1. Si p(. . . ) q(. . . ), i entonces q 1 i ;
2. Si p(. . . ) q(. . . ), i entonces q 1 i1 .
Por ejemplo, el siguiente programa esta estratificado:
2 :

1 :
en(c, b).
en(b, a).
La complecion de un programa estratificado es siempre correcta (Apt, Blair y

Walker, 1988). Sin embargo, observen que determinar si un programa es estrati-
ficado o no, es decidible; pero determinar si la complecion de un programa es o
no decidible, es incorrecto. Por lo tanto, hay programas generales no estratificados,
cuya terminacion es consistente.
5.5 Resolucion SLDNF para programas generales 67
5.5. Resolucion SLDNF para programas generales
Hemos revisado el caso de la resolucion-SLDNF entre programas definitivos y

metas generales. Informalmente podemos decir que la resolucion-SLDNF combina
la resolucion SLD con los siguientes principios:
1. tiene exito si tiene un arbol-SLD finito que falla.
2. falla finitamente si y solo si tiene una refutacion-SLD.
El paso de programas definitivos a programas generales, es complicado. Para pro-
bar , debe de existir un arbol finito fallido para . Tal arbol puede contener
nuevas literales negativas, las cuales a su vez deben tener exito o fallar finitamente.
Esto complica considerablemente la definicion de la resolucion-SLDNF para pro-
gramas generales. Por ejemplo, es posible llegar a situaciones paradojicas cuando
los predicados estan definidos en terminos de sus propios complementos. Conside-
ren el programa no estratificado:

Dada la meta inicial , se puede construir una derivacion . La
derivacion puede extenderse hasta una refutacion si falla finitamente. De mane-
ra alternativa, si tiene una refutacion, entonces la derivacion falla. Helas! esto
es imposible pues la meta no puede tener una refutacion y fallar finitamente al
mismo tiempo.
En lo que sigue, definiremos las nociones de derivacion-SLDNF y arbol-SLDNF,
de manera similar a la derivacion-SLD y a los arboles-SLD. La idea se concreta
en el concepto de bosque-SLDNF: un conjunto de arboles-SLDNF cuyos nodos
esta etiquetados con metas generales.
Definicion 48 (Bosque SLDNF) Sea un programa general, G0 una meta gene-
ral, y R una funcion de seleccion. El bosque SLDNF de G0 (usando y R) es el
bosque mas pequeno, tal que:
1. G0 es la raz del arbol.
2. Si G es un nodo en el bosque cuya literal seleccionada es positiva, entonces para
cada clausula tal que G0 puede ser derivada de G y (con MGU ), G tiene un
hijo etiquetado G0 . Si no existe tal clausula, entonces G tiene un hijo etiquetado
FF (falla finita);
3. Si G es un nodo del bosque cuya literal seleccionada es de la forma (G es
de la forma 1 , . . . , Li1 , i , Li+1 , . . . , n ), entonces:
El bosque contiene un arbol cuyo nodo raz es .
Si el arbol con raz tiene una hoja etiquetada como 2 con la substitucion
computada vaca , entonces G tiene un solo hijo etiquetado FF;
Si el arbol con raz es finito y tiene todas sus hojas etiquetadas FF,
entonces G tiene un solo hijo etiquetado (con substitucion asociada vaca )
como 1 , Li1 , Li+1 , . . . , n .
68 5 Negacion
Observen que la literal negativa seleccionada falla solo si tiene una

refutacion con la substitucion computada vaca . Como veremos mas adelante,
esta condicion que no era necesaria cuando definimos la resolucion-SLDNF para
programas definitivos, es vital para la correctez de esta resolucion en los programas
generales.
Los arboles del bosque-SLDNF son llamados arboles-SLDNF completos; y la
secuencia de todas las metas en una rama de un arbol-SLDNF con raz G es llamada
derivacion-SLDNF completa de G (bajo un programa y una funcion de seleccion
R). El arbol etiquetado por G0 es llamado arbol principal. Un arbol con la raz
es llamado arbol subsidiario si es una literal seleccionada en el bosque (el arbol
principal puede ser a su vez subsidiario).
Ejemplo 20 Consideren el siguiente programa general estratificado :

encima(X,Y ) en(X,Y ).
encima(X,Y ) en(X, Z), encima(Z,Y ).
en(c, b).
en(b, a).
El bosque-SLDNF para la meta base(X) se muestra en la figura 5.2. El

arbol principal contiene una derivacion fallida y una refutacion con la substitucion
computada {X/a}.
Las ramas de un arbol-SLDNF en un bosque-SLDNF representan todas las
derivaciones-SLDNF completas de su raz, con base en la funcion de seleccion dada.
Hay cuatro clases de derivaciones-SLDNF completas:
1. derivaciones infinitas;
2. derivaciones finitas fallidas (terminan en FF);
3. refutaciones (terminan en 2); y
4. derivaciones plantadas (si ninguno de los casos anteriores aplica).
Ejemplo 21 Consideren el siguiente programa:
termina(X) ciclo(X).
ciclo(X) ciclo(X).
El bosque-SLDNF para el ejemplo anterior se muestra en la figura 5.3. El bos-

que incluye una derivacion plantada para termina(X) y una derivacion infinita para
ciclo(X). Esto ilustra una de las razones por las cuales una derivacion se planta: uno
de sus arboles subsidiarios contiene solo derivaciones fallidas o infinitas.
5.5 Resolucion SLDNF para programas generales 69
base(X).
en(Y0 , X), en la mesa(X).
en la mesa(b). en la mesa(a).
no en la mesa(b). en la mesa(a).
FF 2
no en la mesa(b). no en la mesa(a).
en(b,Y0 ). en(a,Y0 ).
2 FF
Figura 5.2 Bosque-SLDNF para la meta base(X).
ciclo(X).
paro(X). ciclo(X).
ciclo(X).
Figura 5.3 Bosque-SLDNF para la meta paro(X).
El siguiente programa tambien conduce a una derivacion plantada (ciclo en el

computo de la negacion):
parado ja(X) ok(X).

ok(X) parado ja(X).
Intenten construir el bosque-SLDNF de este programa y observaran tambien que

en este caso, la arbol principal es a su vez un arbol subsidiario.
La ultima razon para que una derivacion quede plantada es ilustrada por el si-
guiente programa:
70 5 Negacion
top(X) bloqueado(X).
bloqueado(X) en(Y, X).
en(a, b).
Es evidente que top(a) debera poder derivarse de este programa. Sin embargo, el
arbol-SLDNF de la meta top(X) no contiene refutaciones. De hecho, esta meta
se planta aun cuando bloqueado(X) tiene una refutacion. La razon de esto es
que bloqueado(X) no tiene ninguna derivacion que termine con una substitucion
computada vaca. A la meta top(X), Prolog no responde b, sino que todos
los bloques no estan en el tope de la pila! Esto se debe a la implementacion de
la mayora de los Prolog. La definicion que dimos aqu de resolucion-SLDNF es
correcta.
Teorema 8 (Correctez de la resolucion-SLDNF) Sea un programa general y
1 , . . . , n una meta general. Entonces:
Si 1 , . . . , n tiene una substitucion de respuesta computada , entonces
comp( ) |= (1 n ).
Si 1 , . . . , n tiene un arbol-SLDNF finito que falla, entonces comp( ) |=
((1 n )).
La definicion de bosque-SLDNF no debe verse como una implementacion de la
resolucion-SLDNF, solo representa el espacio ideal de computacion donde la co-
rrectez puede ser garantizada.
Captulo 6
Corte y Aritmetica
Resumen La computacion de un programa logico requiere la construccion y reco-

rrido de un arbol-SLD. Esto no es necesariamente la forma mas eficiente de compu-
tacion, por lo que en esta clase abordaremos dos extensiones de la programacion
logica, implementadas en ISO Prolog, para acelerar las computaciones realizadas:
el corte y la aritmetica. Por simplicidad, la presentacion se basa en los programas
logicos definitivos, aunque los temas discutidos son aplicables a las derivaciones y
arboles-SLDNF.
6.1. Corte: podando el arbol-SLD
El arbol-SLD de una meta definitiva puede tener muchas ramas que conducen al
fallo de la meta y muy pocas, o una sola rama, que conducen al exito. Por ello, el pro-
gramador podra querer incluir informacion de control en sus programas, para evitar
que el interprete construya ramas fallidas. Observen que esta meta-informacion se
basa en la semantica operacional del programa, por lo que el programador debe sa-
ber como se construyen y se recorren los arboles-SLD. El predicado !/0 denota la
operacion de corte, y puede utilizarse como una literal en las metas definitivas. Su
presencia impide la construccion de ciertos sub-arboles.
Un interprete de Prolog recorre los nodos de un arbol-SLD primero en profun-
didad. El orden de las ramas corresponde al orden textual de las clausulas en el
programa. Cuando una hoja es alcanzada, el proceso de backtracking es ejecutado.
El proceso termina cuando no es posible hacer backtracking (todos los sub-arboles
de la raz del arbol han sido visitados).
Ejemplo 22 Asumamos el siguiente programa que define que el padre de una per-
sona es su antecesor hombre:
71
72 6 Corte y Aritmetica
padre(X,Y ) progenitor(X,Y ), hombre(X).

progenitor(ben jamin, antonio).
progenitor(maria, antonio).
progenitor(samuel, ben jamin).
progenitor(alicia, ben jamin).
hombre(ben jamin).
hombre(samuel).
El arbol-SLD de la meta padre(X, antonio) se muestra en la figura 6.1. Bajo la

funcion de seleccion implementada en Prolog, encontrara la solucion X/ben jamin.
El intento por encontrar otra solucion con X/maria, mediante el backtracking, fa-
llara puesto que maria no satisface el predicado hombre/1.
padre(X, antonio)
progenitor(X, antonio), hombre(X).
hombre(ben jamin). hombre(maria)
Figura 6.1 Arbol de derivacion-SLD para la meta padre(X, antonio)
Para detallar la semantica del corte, es necesario introducir algunos conceptos

auxiliares. En un arbol-SLD, cada nodo ni corresponde a una meta Gi de una deri-
vacion-SLD y tiene un atomo seleccionado asociado i :
0 n1
G0 G1 . . . Gn1 Gn
Asumamos que para cierto nodo nk , k no es una sub-meta de la meta ini-

cial. Entonces k es un atomo i del cuerpo de una clausula de la forma 0
1 , . . . , i , . . . , n cuya cabeza 0 unifica con la sub-meta seleccionada en algun no-
do n0< j<k , es decir un nodo entre la raz del arbol y el nodo nk . El nodo n j se conoce
como el origen de k y se denota como origen(k ).
El predicado de corte ! se procesa como un atomo ordinario situado en el cuer-
po de una clausula. Sin embargo, cuando el corte es seleccionado para computar la
resolucion, este tiene exito inmediatamente (con la substitucion vaca como resul-
tado). El nodo donde ! fue seleccionado es llamado el nodo de corte. Un nodo de
corte puede ser visitado nuevamente durante el backtracking. En este caso, el cur-
so normal del recorrido del arbol es alterado (por definicion el recorrido continua
6.1 Corte: podando el arbol-SLD 73
en el nodo superior a origen(!). Si el corte ocurre en la meta inicial, la ejecucion

simplemente termina.
Ejemplo 23 La formulacion del problema padre, nos dice que a lo mas existe una
solucion para nuestra meta. cuando la solucion se encuentra, la busqueda puede
deternerse pues ninguna persona tiene mas de un padre. Para forzar esta situacion,
el predicado de corte se agrega al final de padre/2:
padre(X,Y ) progenitor(X,Y ), hombre(X), !.
Observen que el programa modificado en el ejemplo anterior solo puede compu-

tar un elemento de la relacion padre/2. El corte detendra la busqueda despues de
encontrar la primer respuesta para la meta padre(X,Y ). El origen del corte es
la raz del arbol, por lo que la busqueda termina despues de hacer backtracking al
nodo de corte. La otra rama del arbol no es recorrida. El arbol-SLD del programa
que incluye el corte se muestra en la figura 6.2.
padre(X, antonio)
progenitor(X, antonio), hombre(X), !.
hombre(ben).
Figura 6.2 Arbol de derivacion-SLD para la meta padre(X, antonio) con las ramas fallidas
podadas.
Observen que la version modificada con el corte, no puede usarse para computar
mas de un elemento de la relacion es padre de. El corte detendra la busqueda
despues de encontrar la primer respuesta a la meta definitiva.
A partir de la definicion del corte, se sigue que los efectos del operador son:
1. Divide el cuerpo de la meta en dos partes, separando la ejecucion de la recon-
sideracion despues de exito de !/0 , no es posible hacer backtracking haca
las literales a la izquierda del corte. Sin embargo, a la derecha del corte todo
funciona de manera usual.
2. Poda las ramas sin explorar directamente bajo origen(!). En otras palabras, no
habra mas intentos de unificar la sub-meta seleccionada de origen(!) con el resto
de las clausulas del programa.
El corte es controvertido. La intencion al introducir el corte, es poder controlar la

ejecucion de los programas, sin cambiar su significado logico. Por tanto, la lectura
logica del corte es verdadero. Operacionalmente, si el corte remueve solo ramas
fallidas del arbol-SLD, no tiene influencia en el significado logico de un progra-
ma. Pero el corte puede remover tambien ramas exitosas del arbol-SLD, atentando
contra la completitud de los programas definitivos, o la correctez de los programas
generales.
Ejemplo 24 Es bien sabido que los padres de un recien nacido estan orgullosos.
La proposicion puede representarse con la siguiente clausula definitiva:
orgulloso(X) padre(X,Y ), recienNacido(Y ).

consideren las siguiente clausulas adicionales:
padre(X,Y ) progenitor(X,Y ), hombre(X).

progenitor( juan, maria).
progenitor( juan, cristina).
hombre( juan).
recienNacido(cristina).
La respuesta a la meta orgulloso( juan) es Si, puesto que como describi-

mos, juan es padre de cristina, que es un recien nacido. Ahora, si remplazamos la
primera clausula, con su version que utiliza corte:
padre(X,Y ) progenitor(X,Y ), hombre(X), !.
Y preguntamos nuevamente a Prolog, si
orgulloso( juan).
la respuesta sera No. Esto se debe a que la primer hija de juan en el programa
es maria. Una vez que esta respuesta se ha encontrado, no habra mas intentos de
satisfacer la meta en origen(!). No se consideraran mas hijos de juan en la solucion
computada.
El programa del ejemplo anterior se ha vuelto incompleto, algunas respuestas co-
rrectas no pueden ser computadas. Mas grave aun es el caso de las metas generales,
donde se puede llegar a resultados incorrectos, por ejemplo, orgulloso( juan)
tendra exito en la version de nuestro programa que utiliza corte.
Hasta ahora hemos distinguido dos usos del corte: eliminar ramas fallidas en el
arbol-SLD; y podar ramas exitosas. Eliminar ramas fallidas se considera una practi-
ca sin riesgo, porque no altera las respuestas producidas durante la ejecucion de un
programa. Tales cortes se conocen como cortes verdes. Sin embargo, este uso del
operador corte, esta ligado al uso particular de un programa. Como se ilustra en
6.1 Corte: podando el arbol-SLD 75
los ejemplos anteriores, para algunas metas, el operador solo eliminara ramas falli-
das; pero para otras podara ramas exitosas. Cortar ramas exitosas se considera una
practica de riesgo. Por eso, tales cortes se conocen como cortes rojos.
Ejemplo 25 Consideremos un ejemplo de corte verde. Si en el ejemplo anterior ma-

ria es una recien nacida, agregaramos la clausula recienNacido(maria) a nuestro
programa. Entonces la meta orgulloso(X) nos dira que X/X/ juan esta orgu-
lloso. Esto es, juan tiene una doble razon para estar orgulloso. Pero a nosotros nos
basta con saber solo una vez, que orgulloso esta juan. Para evitar que Prolog nos
de la respuesta dos veces, definiramos:
orgulloso(X) padre(X,Y ), recienNacido(Y ), !.

Ejemplo 26 Ahora consideren un ejemplo de corte rojo:
min(X,Y, X) X < Y, !.
min(X,Y,Y ).
Aparentemente nuestro programa es correcto. De hecho, el programa respondera

de manera correcta a metas como min(2, 3, X) respondiendo que Si para X/2;
y para min(3, 2, X) respondera que Si para X/2. Sin embargo el programa
no es correcto. Consideren la meta min(2, 3, 3) y veran que Prolog respondera
Si. La razon de esto es que la segunda clausula dice: el menor de X e Y es siempre
Y . El corte esta eliminando algunas ramas fallidas, que seran utiles en la definicion
de min. La definicion correcta, usando corte, sera:
min(X,Y, X) X < Y, !.
min(X,Y,Y ) X Y.
Un comentario final. El corte puede usarse para implementar la negacion en Pro-

log. Consideren las siguientes clausulas donde f ail es un predicado de Prolog que
carece de definicion y no puede ser definido por el usuario:
not(estudiante(X)) estudiante(X), !, f ail.

not(estudiante(X).
Esta definicion descansa enteramente en la semantica operacional de Prolog. Es-

to es, las sub-metas se deben resolver de izquierda a derecha, y las clausulas se
buscan en el orden en que aparecen en el texto del programa. Si queremos saber
si juan no es un estudiante, le meta a adoptar es not(estudiante( juan)). Ahora,
hay dos casos a considerar: Si la meta estudiante( juan) tiene exito, el opera-
dor de corte eliminara la segunda clausula y la meta original fallara; Si la meta
not(estudiante( juan)) falla, la segunda clausula sera intentada en el backtra-
cking y la meta negada tendra exito.
Podemos definir not/1 haciendo uso del meta-predicado estandar de Prolog
call/1:
not(X) call(X), !, f ail.

not(X).
El argumento a call/1 debe ser un atomo de base, de otra forma, el computo produce
substituciones y la implementacion resulta logicamente incorrecta.
Usar cortes aleatoriamente, para intentar obtener respuestas correctas a un pro-
blema, es una de las fuentes principales de errores entre los novatos de la programa-
cion logica. Antes de intentar usar un corte, intenten escribir programas logicamente
correctos.
6.2. Aritmetica
Hemos demostrado que los programas definitivos pueden describir cualquier re-
lacion computable. Esto es, cualquier maquina de Turing puede codificarse como
un programa logico definitivo. Esto significa que, desde el punto de vista teorico, la
programacion logica es tan expresiva como otros paradigmas de programacion. La
resolucion y la busqueda exhaustiva, proveen una herramienta universal de compu-
tacion.
Desafortunadamente, desde el punto de vista practico, esta no es la mejor forma
de computar todo. Consideren las operaciones aritmeticas sobre los numeros na-
turales. Existen implementaciones en hardware extremadamente eficientes de tales
operaciones. As que es deseable que Prolog tenga acceso a las operaciones del pro-
cesador y su aritmetica de maquina. El problema es Cuando es posible hacer cosas
parecidas sin destruir la naturaleza declarativa de los programas logicos?
Observen primero que las operaciones como suma/2 y multiplicacion/2 pueden
describirse facilmente en un programa definitivo. Los numeros naturales pueden
describirse mediante terminos de base. Una forma estandar de hacer esto es utilizar
la constante 0 para representar el cero, y el functor unario s/1 para representar el
sucesor de un numero. Los numeros naturales consecutivos estan representados por:
0, s(0), s(s(0)), . . .
Las operaciones de adicion y multiplicacion son funciones binarias sobre los
numeros naturales. Los programas logicos proveen unicamente un formalismo para
representar relaciones. Sin embargo, una funcion binaria puede verse como una re-
lacion ternaria consistente en todas las tripletas hX,Y, Zi tal que Z es el resultado de
aplicar la funcion a X e Y .
Ahora, es bien sabido que las operaciones de adicion y multiplicacion se carac-
terizan por los axiomas de Peano:
6.2 Aritmetica 77
0+X = X
s(X) +Y = s(X +Y )
0X = 0
s(X) Y = (X Y ) +Y
Estos axiomas relacionan argumentos y resultados de las operaciones. En forma

de programa logico definitivo, se formularan como sigue:
suma(0, X, X).
suma(s(X),Y, s(Z)) suma(X,Y, Z).
mult(0, X, 0).
mult(s(X),Y, Z) mult(X,Y,W ), suma(W,Y, Z).
El programa puede usarse, por ejemplo, para sumar dos y tres:
suma(s(s(0)), s(s(s(0))), X)
que dara como resultado si para X/s(s(s(s(s(0))))). Un arbol de refutacion-SLD

es construido para obtener este resultado.
El programa puede usarse tambien para computar resta y una forma limitada
de division. Por ejemplo: suma(X, s(s(0)), s(s(s(0)))) representa la resta de tres
menos dos, dando como resultado Si para X = s(0).
Cuando comparamos estos ejemplos con la practica comun en programacion,
resulta evidente que:
La representacion de los numeros naturales como terminos de base no es adecua-
da para los humanos.
Las computaciones de la aritmetica no hacen uso del hardware, por lo que resul-
tan lentas: Sumar X e Y requiere X + 1 llamada a suma.
No es posible construir expresiones aritmeticas, puesto que suma/3 y mult/3
representan relaciones.
El primer problema se puede resolver facilmente introduciendo arreglos sintacti-

cos: sn (0) = n. Tambien se conocen tecnicas para compilar expresiones aritmeti-
cas a codigo ensamblador. El principal problema es como incorporar expresiones
aritmeticas sin destruir el significado declarativo de los programas.
Asumamos que las expresiones aritmeticas apareceran como terminos en los
programas definitivos. Las respuestas de estos programas deberan tomar en con-
sideracion la equivalente entre expresiones aritmeticas. Por ejemplo, consideren la
siguiente regla para computar impuestos: si el ingreso anual es mayor que 150000
dolares, entonces el impuesto es 30 %, en otro caso se cobrara el 25 % del ingreso
menos 30000 dolares.
impuesto(Ingresos, 0,5 Ingresos) Ingresos > 150000.

impuesto(Ingresos, 0,25 (Ingresos 30000)) Ingresos 150000.
Por lo tanto, una persona que gana 130000 dolares debera obtener para la meta
impuesto(130000, 25000) una respuesta de Si. Pero estas reglas no pueden
usarse para encontrar una refutacion a la meta, ya que ninguna cabeza de regla
unifica con la sub-meta de la meta. La razon es que la unificacion estandar es muy
debil, como para darse cuenta que 25000 y 0.25*(130000-30000) son equivalentes.
Por lo tanto, la equivalencia debe describirse mediante axiomas de igualdad para
la aritmetica, los cuales no han sido incluidos en el programa anterior.
De esta discusion se sigue que es necesaria una extension al concepto de pro-
grama logico. Para nuestro ejemplo, el programa debera consistir de dos partes: un
conjunto de clausulas definitivas P, y un conjunto de axiomas de igualdad E, descri-
biendo la equivalencia entre los terminos. Este tipo de programas ha sido estudiado
en la literatura, donde el resultado mas importante es el concepto de unificacion ge-
neralizada, asociada a una teora de igualdad E y llamada E-unificacion. Lo que
sigue es una breve introduccion a este tema.
Una teora de igualdad en clausulas definitivas es un conjunto (posiblemente
infinito) de clausulas definitivas, donde cada atomo es de la forma s = t y s y t son
terminos. Algunas veces, la forma de las clausulas se restringe a hechos.
Un programa definitivo con igualdad es un par P, E donde P es un programa
definitivo, que no contiene ocurrencias del predicado = /2 y E es una teora de
igualdad en clausulas definitivas.
Sea E una teora de igualdad en clausulas definitivas. Una substitucion es un
E-unificador de los terminos s y t, si y solo si s = t es una consecuencia logica
de E.
Ejemplo 27 Sea E una teora de igualdad que expresa las equivalencias propias
de las expresiones aritmeticas. Consideren las expresiones:
t1 := (2 X) + 1
t2 := Y + 2
Por ejemplo, la substitucion = {Y /(2 X 1)} es un E-unificador de t1 y t2 .

Ahora, para un programa dado P, E y una meta 1 , . . . , n la refutacion de la
meta puede construirse de la misma manera que para los programas definitivos, con
la diferencia de que utilizaremos E-unificacion, en lugar de la unificacion normal.
Encontrar E-unificadores puede verse como la resolucion de ecuaciones en un
algebra definida por los axiomas de igualdad. Se sabe que el problema de la E-
unificacion es en general indecidible. Aun siendo decidible para alguna teora E,
pueden existir muchas soluciones a una ecuacion dada. La situacion donde existe
un unificador mas general, suele ser rara. Todo esto significa que, aun cuando es
posible construir E-unificadores, una nueva fuente de indeterminismo se introduce
con ellos.
6.2 Aritmetica 79
Asumamos ahora que una teora de igualdad E describe todas las funciones ex-
ternas, incluidas las operaciones aritmeticas, usadas en un programa logico. Esto
significa que para cualquier par de terminos de base s y t, cuyos functores principa-
les denoten funciones externas, la formula s = t es una consecuencia logica de E, si
y solo si, la invocacion de s regresa el mismo resultado que la invocacion de t. Para
terminos base, la E-unificacion es decidible. Esto puede ser explotado de la siguiente
manera: cuando una llamada a una funcion externa es encontrada como termino a E-
unificar, es invocada y su forma reducida es unificada por el procedimiento normal.
Observen que las funciones externas solo pueden ser invocadas sobre argumentos de
base. Si algunas variables de la funcion externa no tienen valores, la llamada externa
provocara un error y no se encontrara un E-unificador.
Esta idea es incorporada en el ISO Prolog. Los enteros son representados por
numerales como 0, 1, 2006, etc. Tambien existe un soporte limitado para numeros
reales como 3.14, 0.333, etc. Logicamente, los numerales son constantes. Un nume-
ro limitado de functores con notacion infija estan predefinidos en Prolog: +, -, *, /
(division en reales), // (division entera), mod, etc.
Dos predicados predefinidos se ocupan de la E-unificacion. El predicado =:= /2
checa si dos terminos de base son E-unificables. Por ejemplo, la meta 2 3 =:=
2 + 4 responde Si con la substitucion vaca computada. Si los argumentos no son
terminos de base, Prolog aborta la ejecucion del programa con un mensaje de error.
El predicado is/2 unifica el primer argumento con la forma reducida del segun-
do. Por ejemplo X is 2 + 2 responde Si con la substitucion {X/4}. El primer
argumento puede no ser una variable, en lo que constituye un caso especial de la
E-unificacion =:= /2. Por ejemplo, X + 1 is 2 + 3 falla aunque exista un E-
unificador {X/4}.
Otros predicados estandar incluyen = \ = /2 que checa cuando dos terminos no
son E-unificables. El lenguaje tambien provee predicados para comparar numeros,
como >,<, y .
Parte II
Prolog
Captulo 7
Introduccion a Prolog
Este captulo constituye una gua rapida al lenguaje prolog.
83
Captulo 8
Estrategias basicas de resolucion de problemas
Resumen En este captulo revisaremos los conceptos de espacio de soluciones y

busquedas en espacios de soluciones. Se revisara la representacion de estos espacios
en Prolog y se ejemplificara el uso de estrategias como las busquedas primero en
profundidad, primero en amplitud y guiadas por funciones de utilidad.
8.1. Introduccion
Esta sesion la dedicaremos a estudiar un esquema general de representacion de

problemas y sus soluciones, ampliamente utilizado en la Inteligencia Artificial. Con-
sideremos el ejemplo mostrado en la figura 8.1. El problema a resolver consiste en
encontrar un plan para colocar los cubos en una configuracion determinada, par-
tiendo de una configuracion inicial. Solo un bloque puede moverse a la vez y las
acciones del brazo son del tipo pon A en la mesa, pon B en C, etc. Dos con-
ceptos aparecen en esta descripcion: i) Situaciones o estados del problema; y ii)
acciones, o movimientos legales, que transforman un estado del problema en otro.
C A
?
A B
B C
Figura 8.1 Un problema de ordenamiento de bloques.
Estados y acciones configuran un grafo dirigido conocido como espacio de esta-

dos (Fig. 8.2. El problema de encontar un plan para acomodar los cubos es equiva-
lente a encontrar un camino en este grafo, entre un nodo representado el estado ini-
85
86 8 Estrategias basicas de resolucion de problemas
cial del problema y un nodo representando la solucion final, un nodo meta. Como
podemos representar tal grafo en Prolog?
Figura 8.2 Espacio de estados para el problema de ordenamiento de bloques.
El espacio de estados sera representado por una relacion s(X,Y ) que sera verda-
dera si existe un movimiento valido en el espacio de estados del nodo X al nodo
Y . El nodo Y recibe el nombre de sucesor de X. Si existe un costo asociado a las
acciones esto puede representarse por un tercer argumento de s, s(X,Y,Costo).
Esta relacion puede ser especificada extensionalmente por un conjunto de hechos.
Sin embargo, para cualquier problema interesante, esto es irrealizable. La relacion
s es normalmente definida intensionalmente mediante un conjunto de reglas que
computan el sucesor de un nodo dado.
Otro detalle importante tiene que ver con la representacion de los estados del pro-
blema, los nodos. La representacion debe de ser compacta y permitir la computacion
eficiente de los nodos sucesores; y posiblemente el costo asociado a las acciones.
Tomemos como ejemplo el mundo de los bloques. Cada estado del problema
puede ser representado por una lista pilas. Cada pila a su vez puede ser representada
por una lista de bloques. El tope de cada pila es el primer elemento de cada lista
de bloques. La pila vaca esta representada por la lista vaca. As, el estado inicial
mostrado en la figura 8.1 es la lista: [[c,b,a],[],[]] (suponemos, que en la
mesa solo hay espacio para 3 pilas de bloques).
Una meta es cualquier arreglo con los bloques en el orden deseado. Existen tres
soluciones en este caso:
[[a,b,c],[],[]],
[[],[a,b,c],[]] o
[[],[],[a,b,c]].
La relacion sucesor puede programarse de acuerdo a la siguiente regla: el
Estado2 es sucesor de Estado1 si hay dos pilas Pila1 y Pila2 en Estado1 y el
tope de la pila Pila1 puede moverse a Pila2. Esto se traduce a Prolog como:
8.2 Busqueda primero en profundidad 87
1 s(Pilas, [Pila1, [Tope1|Pila2] | OtrasPilas ]) :-

2 quitar([Tope1|Pila1], Pilas, Pilas1),
3 quitar(Pila2, Pilas1, OtrasPilas).
4
5 quitar(X, [X|Ys], Ys).
6 quitar(X, [Y|Ys], [Y|Ys1]) :-
7 quitar(X,Ys,Ys1).
La relacion s nos permite verificar si un nodo es sucesor de otro, por ejemplo:
1 ?- s([[b],[a,c],[]],[[],[b,a,c],[]]).
2 Yes
3 ?- s([[b],[a,c],[]],[[],[a,b,c],[]]).
4 No
Para representar los estados meta usamos:
1 meta(Estado) :-
2 member([a,b,c],Estado).
Un predicado solucion/2 se usa para plantear las metas, por ejemplo: solu-
cion([[c,a,b],[],[]],Sol). La solucion sera encontrada buscando en el espacio de esta-
dos del problema.
8.2. Busqueda primero en profundidad
Dada la formulacion de un problema en terminos de su espacio de estados, exis-

ten diversas estrategias para encontrar un camino solucion. Dos estrategias basica
son las busquedas primero en profundidad y primero en amplitud. En esta seccion
implementaremos la busqueda primero en profundidad.
Comenzaremos con una idea simple. Para encontrar un camino solucion Sol, de
un nodo dado N a un nodo meta:
Si N es un nodo meta, entonces Sol = [N], o
Si existe un nodo sucesor N1 tal que existe un camino Sol1 de N1 al nodo meta,
entonces Sol = [N|Sol1].
Lo cual traduce a Prolog como:
1 solucion(N,[N]) :-
2 meta(N).
3
4 solucion(N, [N|Sol1]) :-
5 s(N,N1),
6 solucion(N1,Sol1).
De forma que para computar la solucion al problema de los bloques, preguntamos

a Prolog:
?- solucion([[c,b,a],[],[]],Sol).
Sol = [[[c, b, a], [], []],
[[b, a], [c], []],
[[a], [b, c], []],
[[], [a, b, c], []]]
Yes
La solucion se computa como sigue. En un principio, el estado inicial N =

[[c, b, a][][]], por lo que el programa se pregunta si N es una meta. La clausula meta/1
funciona verificando si la solucion [a, b, c] es miembro del estado N. Como esta meta
falla, Prolog intentara satisfacer su meta inicial con la segunda clausula solucion/2.
Esto implica generar un sucesor de N (llamada a s(N, N1)). As que se computa
N1 = [[b, a], [c], []] y se verifica si esto es una solucion. Como la meta falla, se gene-
ra un sucesor de N1 y as hasta llegar a [[], [a, b, c], []].
Este proceso puede seguirse detalladamente utilizando el traceador grafico de
SWI-Prolog. Para ello invoquen la meta guitracer. Al trazar una funcion veran una
ventana como la mostrada en la figura 8.3. La ventana superior izquierda muestra
las substituciones computadas, la derecha las pilas formadas, y la inferior muestra
el codigo del programa que esta siendo trazado.
Figura 8.3 Traza grafica de SWI-Prolog.

8.3 Busqueda primero en amplitud 89
Una primera mejora a este algoritmo, consiste en evitar que los nodos visitados
vuelvan a ser expandidos, evitando as caer en ciclos. La idea es llevar un registro
de los nodos visitados. El resultado se da del nodo final haca el estado inicial:
1 solucion2(Nodo,Sol) :-
2 primeroProfundidad([],Nodo,Sol).
3
4 primeroProfundidad(Camino, Nodo, [Nodo|Camino]) :-
5 meta(Nodo).
6
7 primeroProfundidad(Camino, Nodo, Sol) :-
8 s(Nodo,Nodo1),
9 not(member(Nodo1, Camino)),
10 primeroProfunidad([Nodo|Camino],Nodo1,Sol).
Finalmente, para evitar caer en busquedas infinitas sobre ramas no ciclicas, es

posible establecer un limite a la profunidad de la busqueda. Para ello definiremos
primeroProfundidad2/3, donde el tercer argumento es la profunidad maxima de la
busqueda.
1 solucion3(Nodo,Sol,MaxProf) :-
2 primeroProfundidad2(Nodo,Sol,MaxProf).
3
4 primeroProfundidad2(Nodo,[Nodo],_) :-
5 meta(Nodo).
6
7 primeroProfundidad2(Nodo,[Nodo|Sol],MaxProf):-
8 MaxProf > 0,
9 s(Nodo,Nodo1),
10 Max1 is MaxProf-1,
11 primeroProfundidad2(Nodo1,Sol,Max1).
8.3. Busqueda primero en amplitud
En contraste con la busqueda primero en profundidad, la estrategia de busqueda

primero en amplitud elige visitar primero los nodos que estan mas cercanos a la raz,
por lo que el arbol de busqueda crece mas en amplitud, que en profundidad.
Esta estrategia de busqueda es mas complicada de programar. La razon de ello es
que debemos mantener un conjunto de nodos candidatos alternativos, no unicamente
un nodo como lo hacamos al buscar en profundidad. Ademas, debemos mantener
los caminos, si queremos obtenerlos como parte de la solucion computada. De forma
que:
?- primeroEnProfundidad(Caminos,Sol).
es verdadera, si y solo si algun camino miembro del conjunto de candidatos

Caminos, puede extenderse hasta un nodo meta. Sol es el camino solucion.
El conjunto Caminos sera representado como listas de caminos, donde cada ca-
mino se representara como una lista de nodos en el orden inverso en que fueron
visitados. Esto es, la cabeza de la lista que representa un camino tendra el ultimo
nodo generado; y el ultimo nodo en la lista sera el estado inicial de la busqueda. Al
iniciar Caminos tiene un solo camino candidato: [[NodoInicial]].
El algoritmo de la busqueda primero en amplitud puede describirse como sigue,
dado un conjunto de caminos candidatos:
Si el primer camino contiene un nodo meta como su cabeza, entonces esta es la

solucion al problema. De otra forma
Eliminar el primer camino del conjunto de caminos candidatos y generar el con-
junto de todas las posibles extensiones de un paso de este camino. Agregar este
conjunto de extensiones al final del conjunto de candidatos. Ejecutar la busqueda
primero en amplitud en este nuevo conjunto de caminos candidatos.
Para generar las extensiones de un solo paso, dado un camino, podemos usar el
predicado predefinido bago f Veamos el programa:
1 %% % solucion(Inicio,Sol) Sol es un camino (en orden inverso)

2 %% % de Inicio a una meta
3
4 solucion(Inicio,Sol) :-
5 primeroEnAmplitud([[Inicio]],Sol).
6
7 %% % primeroEnAmplitud([Camino1,Camino2,...],Sol) Sol es una

8 %% % extension haca la meta de alguno de los caminos
9
10 primeroEnAmplitud([[Nodo|Camino]|_],[Nodo|Camino]) :-
11 meta(Nodo).
12
13 primeroEnAmplitud([Camino|Caminos],Sol) :-
14 extender(Camino,NuevosCaminos),
15 append(Caminos,NuevosCaminos,Caminos1),
16 primeroEnAmplitud(Caminos1,Sol).
17
18 extender([Nodo|Camino],NuevosCaminos) :-
19 bagof([NuevoNodo,Nodo|Camino],
20 (s(Nodo,NuevoNodo), not(member(NuevoNodo, [Nodo|
Camino]))),
21 NuevosCaminos),
22 !.
23
24 %% % Si extender falla, Camino no tiene sucesores (lista vaca)
25
26 extender(Camino_,[]).
Si aplicamos este programa de busqueda al programa del mundo de los cubos,

obtendremos:
8.3 Busqueda primero en amplitud 91
?- solucion([[c,b,a],[],[]],Sol).
Sol = [[[], [a, b, c], []], [[a], [b, c], []],
[[b, a], [c], []], [[c, b, a], [], []]]
Yes
Si queremos buscar en el espacio del grafo de la figura 8.4, codificamos los su-
cesores y las metas como sigue:
1 s(a,b).
2 s(a,c).
3 s(b,d).
4 s(b,e).
5 s(d,h).
6 s(e,i).
7 s(e,j).
8 s(c,f).
9 s(c,g).
10 s(f,k).
11
12 meta(j).
13 meta(f).
b c
d e f g
h j i k
Figura 8.4 Grafico de un espacio de estados: las metas son f y j.
y buscamos las soluciones:
?- solucion(a,Sol).
Sol = [f, c, a] ;
Sol = [j, e, b, a] ;
No
Observen que al realizarse la busqueda primero en amplitud, la primer solucion

encontrada involucra la meta f mas cercana al nodo raz.
8.4. Busqueda primero el mejor
Un programa de busqueda primero el mejor, puede verse como una mejora a la

busqueda primero en amplitud. El algoritmo de primero el mejor comienza tambien
con un nodo inicial y mantiene una lista de caminos candidato. La busqueda por
amplitud siempre elige para expandir el camino candidato mas corto y la busqueda
primero el mejor afina esta estrategia.
Asumamos que una funcion costo es definida para los arcos de un espacio de
estados de un problema. De forma que c(n, n0 ) es el costo de moverse de un nodo n
al nodo n0 en el espacio de estados.
Sea el estimador heurstico una funcion f tal que para cada nodo n en el espacio
de estados, f (n) estima la dificultad de llegar a n. De acuerdo a esto, el nodo
mas promisorio sera aquel que minimice f . Usaremos aqu una forma especial de la
funcion f que nos llevara al bien documentado algoritmo A*. f (n) sera construida
para estimar el costo del mejor camino solucion entre un nodo inicial s y un nodo
meta, con la restriccion de que el camino pase por el nodo n. Supongamos que tal
camino existe y que un nodo meta que minimiza su costo es t. Entonces el estimado
de f (n) puede calcularse como la suma de dos terminos:
f (n) = g(n) + h(n)

donde g(n) es el estimado del costo de un camino optimo de s a n; y h(n) es el
estimado del costo de un camino optimo de n a t (Fig. 8.5).
g(n)
n n' n''
h(n)
Figura 8.5 Estimado heurstico f (n) = g(n) + h(n).
Cuando un nodo n es encontrado en el proceso de busqueda, tenemos la siguiente

situacion: un camino de s a n debio ser encontrado, y su costo puede computarse co-
mo la suma del costo de cada arco en el camino. Este camino no es necesariamente
un camino optimo entre s y n (puede haber caminos mejores no cubiertos aun por la
busqueda), pero su costo puede servir como un estimador g(n) del costo mnimo de
8.4 Busqueda primero el mejor 93
ir de s a n. El otro termino, h(n), es mas problematico, porque el espacio entre n y t

no ha sido explorado aun, por lo que su valor es una verdadera adivinanza heursti-
ca, resuelta con base en el conocimiento general del algoritmo sobre la estructura
particular del problema a resolver. Como h depende del dominio del problema, no
existe un metodo universal para su construccion. Asumamos por el momento que
una funcion h nos es dada y concentremonos en los detalles del programa primero
el mejor.
7
e
2
s 5
2
f 4
5 a
2
2
2 b g
4 c 2
4
2
3
t
3
3 d
Figura 8.6 Mapa entre ciudades, sus distancias por carretera, y sus distancias lneales a la meta
(cuadros).
Como ejemplo consideren el siguiente problema. Dado un mapa (Fig. 8.6), la

tarea es encontrar la ruta mas corta entre una ciudad inicial s y una ciudad meta t. Al
estimar el costo del resto del camino de la ciudad X a la meta, usamos simplemente
la distancia lineal denotada por dist(X,t). Entonces:
f (X) = g(X) + h(X) = g(X) + dist(X,t)

En este ejemplo, podemos imaginar la busqueda de primero el mejor consistente
de dos procesos, cada uno de ellos explorando uno de los dos caminos alternativos:
el proceso 1 para el camino va a y el proceso 2 para el camino va e. En los pasos
iniciales el proceso 1 esta mas activo porque los valores f en ese camino son mas
bajos que los del otro. En el momento en que el proceso 1 llega a c y el proceso 2
sigue en e, la situacion cambia:
f (c) = g(c) + h(c) = 6 + 4 = 10

f (e) = g(e) + h(e) = 2 + 7 = 9
De forma que f (e) < f (c) y ahora el proceso 2 procede al nodo f y el proceso 1
espera. Pero entonces:
f ( f ) = 7 + 4 + 11
f (c) = 10
f (c) < f ( f )
por lo que el proceso 2 es detenido y se le permite al proceso 1 continuar, pero solo
hasta el nodo d ya que f (d) = 12 > 11. El proceso 2 continua corriendo hasta llegar
a la meta t (Fig. 8.7).
f(a)=2+5=7
e a
f(e)=2+7=9 f(b)=4+4=8
b
f(c)=6+4=10
f
f(f)=7+4=11
c
f(g)=9+2=11
g d
f(t)=11+0=11
Figura 8.7 La busqueda en el mapa de las ciudades.
Este proceso de busqueda parte del nodo inicial (la ciudad s) y genera nuevos
nodos sucesores, expandiendose siempre en la direccion mas promisora de acuerdo
a los valores de la funcion f . Esto genera un arbol que crece hasta llegar a un nodo
meta. Este arbol sera representado en nuestro programa de busqueda primero el
mejor por terminos de dos formas:
1. l(N, F/G) representa una hoja del arbol, donde N es un nodo en el espacio de
estados, G es g(N) y F es f (N) = G + h(N).
2. t(N, F/G, Subs) representa un nodo interno del arbol, con una lista de subarboles
Subs no vacos. F es el valor f actualizado de N. El valor para f del sucesor mas
prometedor de N. La lista Subs se ordena de acuerdo al valor creciente de los
valores para f de los subarboles.
Por ejemplo, consideren nuevamente la busqueda ilustrada en la figura 8.7. En el

momento en que el nodo s es expandido, el arbol de busqueda consta de tres nodos:
el nodo s y sus hijos a y e. En nuestro programa, este arbol se representa como:
t(s,7/0,[l(a,7/2),l(e,9/2)]
El valor f para s es 7, esto es, el valor mas promisorio de los hijos de s (a). El
arbol crece expandiendo el nodo mas primisorio. El mas cercano competidor de a
es e con un f valor de 9. Se permite que a crezca mientras su f valor no exceda 9.
Por lo tanto los nodos b y c son generados, pero c tiene un f valor de 10, lo cual
excede el umbral de crecimiento fijado en 9. En ese momento no se permite que a
crezca mas. En ese momento el arbol es:
t(s,9/0,[l(e,9/2),t(a,10/2,[t(b,10/4,[l(c,10/6)])])])
Observen que ahora el valor f del nodo a es 10, mientras que el del nodo e es
9. Estos valores se actualizaron porque fueron generados los nodos b y c. Ahora el
nodo sucesor mas promisorio de s es s es e con un valor f de 9.
La actualizacion de los f valores es necesaria para permitir al programa reco-
nocer el subarbol mas promisorio en cada nivel del arbol de busqueda (esto es, el
subarbol que contiene la hoja mas promisoria). Esta modificacion de los estimados
de f , nos lleva a la generalizacion de la definicion de f que extiende su defincion de
nodos a arboles. Para una hoja n del arbol, mantenemos la definicion original:
f (n) = g(n) + h(n)

Para un subarbol T , cuya raz es n y tiene como subarboles S1 , S2 , . . . :
f (T ) = mn f (Si )
i
El programa que implementa la busqueda primero el mejor es como sigue. Pri-

mero definimos una funcion interfaz, que encuentre la solucion Sol a partir de un
estado inicial Inicio. Para ello solucion/2 llama a expandir/6:
1 solucion(Inicio,Sol) :-
2 expandir([],l(Inicio,0/0),9999,_,si,Sol).
El predicado expandir/6 se encarga de hacer crecer el arbol de busqueda. Sus

argumentos incluyen:
El Camino recorrido, inicialmente vaco;
El Arbol actual de busqueda, inicialmente una hoja con el nodo Inicio y valor de
0 para F y G;
El Umbral o limite para la expansion del arbol ( f -valor maximo), para este ejem-
plo 9999 es suficiente (ningun costo en el arbol sera mayor que este valor);
El Arbol1 expandido bajo el Umbral (en consecuencia el f -valor de este arbol

es mayor, al menos que se halla encontrado la solucion). Originalmente se pasa
una variable anonima en la llamada;
La bandera Solucionado que puede tomar los valores si, no, o nunca;
y la solucion, si existe, al problema regresado en la variable Sol.
El crecimiento del arbol se programa por casos. El caso mas simple corresponde
a aquel donde arbol de busqueda es una hoja, y su Nodo es una meta del espacio
de estados. En ese caso [Nodo|Camino] es la solucion Sol buscada. Observen la
bandera Solucionado = si.
1 expandir(Camino,l(Nodo,_),_,_,si,[Nodo|Camino]) :-
2 meta(Nodo).
El segundo caso corresponde a un arbol de busqueda que es una hoja, cuyo Nodo
no es una meta del espacio de estados y tiene un f -valor menor (o igual) que el
Umbral. Para ello se generan los arboles sucesores del arbol de busqueda actual
(Arboles) usando el predicado listaSucc/3. El arbol debe expandir/6 o fallar con
Solucionado = nunca.
1 expandir(Camino,l(Nodo,F/G),Umbral,Arbol1,Solucionado,Sol) :-
2 F =< Umbral,
3 (bagof(M/C, (s(Nodo,M,C), (not(member(M,P)))), Succ),
4 !,
5 listaSucc(G,Succ,Arboles),
6 mejorF(Arboles,F1),
7 expandir(Camino,t(N,F1/G,Arboles),
8 Umbral,Arbol1,Solucionado,Sol)
9 ;
10 Solucionado=nunca).
El tercer caso es parecido, pero el Nodo es interno.
1 expandir(Camino,t(Nodo,F/G,[Arbol|Arboles]),
2 Umbral,Arbol1,Solucionado,Sol) :-
3 F =< Umbral,
4 mejorF(Arboles,MejorF),
5 min(Umbral,MejorF,Umbral1),
6 expandir([Nodo|Camino],Arbol,
7 Umbral1,Arbol1,Solucionado1,Sol),
8 continuar(Camino,t(Nodo,F/G,[Arbol1|Arboles]),
9 Umbral,Arbol1,Solucionado1,Solucionado,Sol).
El caso cuatro cubre los puntos muertos, cuando no hay solucion al problema:
1 expandir(_,t(_,_,[]),_,_,nunca,_) :- !.
El caso cinco define la situacion cuando el f -valor es mayor que el Umbral y se

inhibe el crecimiento del arbol:
1 expandir(_,Arbol,Umbral,Arbol,no,_):-
2 f(Arbol,F),F>Umbral.
continuar/7 decide como procede la busqueda de acuerdo al arbol expandido. Si

una solucion Sol se ha encontrado, se regresa este valor. En cualquier otro caso, la
expansion continua dependiendo del valor de Solucionado (no o nunca).
1 continuar(_,_,_,_,si,si,Sol).
2
3 continuar(Camino,t(Nodo,F/G,[Arbol1|Arboles]),
4 Umbral,Arbol1,no,Solucionado,Sol) :-
5 insert(Arbol1,Arboles,NodoArboles),
6 mejorF(NodoArboles,MejorF),
7 expandir(Camino,t(Nodo,F/G,NodoArboles),
8 Umbral,Arbol1,Solucionado,Sol).
9
10 continuar(Camino,t(N,F/G,[_|Arboles]),
11 Umbral,Arbol1,nunca,Solucionado,Sol) :-
12 mejorF(Arboles,MejorF),
13 expandir(Camino,t(N,MejorF/G,Arboles),
14 Umbral,Arbol1,Solucionado,Sol).
Las siguientes funciones son auxiliares:
1 listaSucc(_,[],[]).
2
3 listaSucc(G0, [N/C|NCs], Arboles) :-

4 G is G0+C,
5 h(N,H),
6 F is G+H,
7 listaSucc(G0,NCs,Arboles1),
8 inserta(l(N,F/G,Arboles1),Arboles).
9
10 inserta(Arbol,Arboles,[Arbol|Arboles]) :-
11 f(Arbol,F), mejorF(Arboles,F1),
12 F =< F1, !.
13
14 inserta(Arbol,[Arbol1|Arboles], [Arbol1|Arboles1]) :-
15 inserta(Arbol,Arboles,Arboles1).
16
17 f(l(_,F/_),F).
18
19 f(t(_,F/_,_),F).
20
21 mejorF([Arbol|_],F) :-
22 f(Arbol,F).
23
24 mejorF([],9999).
25
26 min(X,Y,X) :-
27 X =< Y, !.
28
29 min(_,Y,Y).
Captulo 9
Sistemas Expertos
Resumen En este captulo abordaremos uno de los productos tpicos de la Inte-

ligencia Artificial: los Sistemas Expertos. Normalmente, usamos herramientas de
desarrollo conocidas con shells para construir este tipo de sistemas, pero si nece-
sitamos configurar un shell para una aplicacion en particular, es necesario conocer
como es que un sistema experto se construye desde cero. El captulo constituye el
segundo ejemplo del uso de Prolog para resolver problemas tpicos de la Inteligencia
Artificial
9.1. Introduccion
Los sistemas expertos (SE) son aplicaciones de computo que involucran expe-
riencia no algortmica, para resolver cierto tipo de problema. Por ejemplo, los siste-
mas expertos se usan para el diagnostico al servicio de humanos y maquinas. Existen
SE que juegan ajedrez, que planean decisiones financieras, que configuran compu-
tadoras, que supervisan sistemas de tiempo real, que deciden polticas de seguros, y
llevan a cabo demas tareas que requieren de experiencia humana.
Los SE incluyen componentes del sistema en s e interfaces con individuos con
varios roles. Esto se ilustra en la figura 9.1. Los componentes mas importantes son:
Base de conocimientos. La representacion declarativa de la experiencia, muchas
veces en forma de reglas IF-THEN.
Almacen de trabajo. Los datos especficos al problema que se esta resolviendo.
Maquina de inferencia. El codigo central del SE que deriva recomendaciones con
base en la base de conocimientos y los datos especficos del problema.
Interfaz del usuario. El codigo que controla el dialogo entre el usuario y el SE.
Para entender un SE es necesario entender tambien el rol de los usuarios que
interaccionan con el sistema:
Experto del Dominio. El o los individuos que son los expertos en resolver el
problema que el SE intentara resolver.
99
100 9 Sistemas Expertos
Usuario
Experto en
el Dominio
Interface con
el Usuario
Experiencia
Mquina de Ingeniero en
Ingeniero del Inferencia Sistemas
Conocimieno
Base de Almacn de
Conocimiento Trabajo
Figura 9.1 Componentes de un sistema experto e interfases humanas
Ingeniero de Conocimiento. El individuo que codifica el conocimiento de los

expertos en forma declarativa, para que pueda ser usado por el SE.
Usuario. El individuo que consultara el SE para obtener los consejos que espe-
rara de un experto del dominio.
Muchos SE se producen en ambientes de desarrollo conocidos como shells. Un
shell es un sistema que contiene la interfaz del usuario, un formato de conocimiento
declarativo para la base de conocimientos y una maquina de inferencia. El ingeniero
de conocimiento usa el shell para construir un SE que resuelve problemas en un
dominio particular.
Si el sistema se construye desde cero, o utilizando shells configurados para cierto
tipo de aplicaciones, otro individuo entra en escena:
Ingeniero de Sistemas. La persona que construye la interfaz del usuario, disena

el formato declarativo de la base de conocimientos, e implementa la maquina de
inferencia adivinan cual es su rol?
En realidad eso depende de la talla del proyecto: El ingeniero de conocimiento
y el ingeniero del sistema, pueden ser la misma persona. El diseno del formato
de la base de conocimientos y su codificacion estan ntimamente relacionados. Al
proceso de codificar el conocimiento de los expertos, se le conoce como ingeniera
del conocimiento. Siendo esta una tarea complicada, se espera el uso de los shells
haga posible la reutilizacion del conocimiento codificado. En estas sesiones nos
concentraremos en la programacion en Prolog de los SE al margen del uso de las
shells.
9.2 Caractersticas de los SE 101
9.2. Caractersticas de los SE
Los SE poseen las siguientes caractersticas, en menor o mayor grado:
Razonamiento guiado por las metas y encadenamiento hacia atras. Una tecnica
de inferencia que usa las reglas IF-THEN para descomponer las metas en sub-
metas mas faciles de probar.
Manejo de incertidumbre. La habilidad del SE para trabajar con reglas y datos
que no son conocidos con precision.
Razonamiento guiado por los datos y encadenamiento hacia adelante. Una tecni-
ca de inferencia que usa las reglas IF-THEN para deducir soluciones a un pro-
blema a partir de los datos iniciales disponibles.
Representacion de datos. La forma en que los datos especficos a un problema
dado, son almacenados y accesados por el SE.
Interfaz del usuario. La parte del SE que se usa para una interaccion mas amiga-
ble con el usuario.
Explicacion. La habilidad del SE para explicar sus procesos de razonamiento y
su uso en el computo de recomendaciones.
9.2.1. Razonamiento basado en metas
El encadenamiento hacia adelante, o razonamiento basado en metas, es una for-

ma eficiente de resolver problemas que pueden ser modelados como casos de se-
leccion estructurada; donde la meta del SE es elegir la mejor opcion de entre varias
posibilidades enumeradas. Por ejemplo, los problemas de identificacion caen en esta
categora. Los problemas de diagnostico tambien caben aqu, pues se trata de elegir
el diagnostico adecuado.
El conocimiento se codifica en reglas que describen como es que cada caso po-
sible podra ser seleccionado. La regla rompe el problema en sub-problemas. Por
ejemplo, las siguientes reglas formaran parte de un SE para identificar aves:
1 IF
2 familia es albatros AND
3 color es blanco
4 THEN
5 ave es albatros laysan.
6
7 IF
9 color es negro
10 THEN
11 ave es albatros de pies negros.
El sistema puede usar otras reglas para resolver las sub-metas planteadas por las
reglas de alto nivel, por ejemplo:
1 IF
2 orden es tubonasales AND
3 tamano es grande AND
4 alas es grandes anguladas
5 THEN
6 familia es albatros.
9.2.2. Incertidumbre
Es muy comun en la resolucion de problemas de seleccion estructurada, que la

respuesta final no es conocida con total certeza. Las reglas del experto pueden ser
vagas, o el usuario puede estar inseguro sobre sus respuestas. Esto es facilmente
observable en el diagnostico medico. Los SE normalmente usan valores numericos
para representar certidumbre. Existen diveras maneras de definirlos y usarlos en el
proceso de razonamiento.
9.2.3. Razonamiento guiado por los datos
Para muchos problemas no es posible enumerar las soluciones alternativas a las

preguntas planteadas con antelacion. Los problemas de configuracion caen en esta
categora. El encadenamiento hacia adelante, o razonamiento guiado por los datos,
usa reglas IF-THEN para explorar el estado actual en la solucion del problema y
moverse a estados mas cercanos a la solucion.
Un SE para acomodar el mobiliario puede tener reglas para la ubicacion de un
mueble en particular. Una vez que un mueble ha sido colocado, se puede proceder
con los demas. La regla para colocar la TV enfrente del sofa es como sigue:
1 IF
2 no_colocada tv AND
3 sofa en pared(X) AND
4 pared(Y) opuesta a pared(X)
5 THEN
6 colocar tv en pared(Y).
Esta regla toma un estado del problema con la television no situada y regresa un
estado nuevo, donde la television ya ha sido colocada. Puesto que la television ya
ha sido colocada en su lugar, esta regla no volvera a ser disparada por el SE. Otras
reglas seran usadas para colocar el resto de los muebles hasta terminar.
9.3 Usando la maquina de inferencia de Prolog 103
9.3. Usando la maquina de inferencia de Prolog
Como pueden haber adivinado, Prolog posee una maquina de inferencia por en-
cadenamiento haca atras. Esta maquina puede usarse parcialmente para implemen-
tar algunos SE. Las reglas de Prolog seran usadas para representar conocimiento
y su maquina de inferencia sera usada para derivar conclusiones. Otras partes del
sistema, como la interfaz con el usuario deberan escribirse usando Prolog.
Usaremos el problema de identificacion de aves norteamericanas para ilustrar la
construccion de un SE con Prolog. La experticia del SE se basa en un subconjunto de
las reglas reportadas en Birds of North America de Robbins, Bruum, Zim y Singer.
Las reglas del SE estaran disenadas para ilustrar como se pueden representar varios
tipos de conocimiento, en vez de buscar una identificacion precisa de las aves.
9.3.1. Reglas
Las reglas de un SE normalmente toman el siguiente formato:
1 IF
2 primera premisa AND
3 segunda premisa AND
4 ...
5 THEN
6 conclusion
La parte IF de la regla se conoce con el lado izquierdo de la regla (LHS), y la parte

del THEN se conoce como el lado derecho de la regla (RHS). Esto es equivalente a
la semantica de la regla Prolog:
1 conclusion :-
2 primera premisa,
3 segunda premisa,
4 ...
Esto puede ser confuso pues la regla en prolog dice mas THEN-IF que IF-THEN.
Retomemos los ejemplos anteriores, si queremos representar en Prolog la regla:
1 IF
3 color es blanco
4 THEN
5 ave es albatros laysan
Tendramos que escribir:

1 ave(albatros_laysan) :-
2 familia(albatros),
3 color(blanco).
Las siguientes reglas distinguen entre dos tipos de albatros y cisne. Todas son
clausulas del predicado ave/1:
1 ave(albatros_laysan) :-
3 color(blanco).
4 ave(albatros_patas_negras) :-
6 color(obscuro).
7 ave(cisne_silbador) :-
8 familia(cisne),
9 voz(suave_musical).
10 ave(cisne_trompetero) :-
11 famila(cisne),
12 voz(alta_trompeta).
Para que estas reglas tengan exito al distinguir un ave, necesitamos almacenar
hechos acerca del ave que deseamos identificar con el SE. Por ejemplo, si agregamos
estos hechos al programa:
1 familia(albatros).
2 color(obscuro).
Ahora podemos usar la pregunta siguiente:
1 ?- ave(X).
2 X = albatros_patas_negras
3 Yes
Observen que aun en esta etapa temprana tenemos un SE completo, donde la

experticia consiste en distinguir entre cuatro aves. La interfaz con el usuario es el
REPL de Prolog y los datos de entrada se almacenan directamente en el programa.
9.3.2. Reglas para relaciones jerarquicas
El siguiente paso sera representar la naturaleza jerarquica del sistema de clasifi-

cacion de un ave. Esto incluira reglas para identificar la familia y el orden del ave.
Continuando con el albatros y el cisne, los predicados para orden/1 y f amilia/1
son:
1 orden(nariz_tubular) :-
2 fosas(externas_tubulares),
9.3 Usando la maquina de inferencia de Prolog 105
3 habitat(mar),
4 pico(gancho).
5 orden(acuatico) :-
6 patas(membrana),
7 pico(plano).
8 familia(albatros) :-
9 orden(nariz_tubular),
10 tamano(grande),
11 alas(muy_largas).
12 familia(cisne) :-
13 orden(acuatico),
14 cuello(largo),
15 color(blanco),
16 vuelo(pesado).
Ahora el SE puede identificar al albatros a partir de observaciones fundamentales

sobre el ave. En la primer version, f amilia/0 fue implementada como un hecho.
Ahora f amilia/1 es implementada como una regla. Los hechos del SE ahora reflejan
mas datos primitivos:
1 fosas(externas_tubulares).
2 habitat(mar).
3 pico(gancho).
4 tamano(grande).
5 alas(muy_largas).
6 color(obscuro).
La consulta siguiente reporta:
1 ?- ave(X).
2 X = albatros_patas_negras
3 Yes
9.3.3. Reglas para otras relaciones
El ganso canadiense puede usarse para agregar complejidad al sistema. Debido a

que esta ave pasa los veranos en Canada y los inviernos en los Estados Unidos, su
identificacion se ve afectada por donde ha sido vista y en que estacion. Dos reglas
seran necesarias para cubrir estas situaciones:
1 ave(ganso_canadiense) :-
2 familia(ganso),
3 estacion(invierno),
4 pais(estados_unidos),
5 cabeza(negra),
6 pecho(blanco).
7 ave(ganso_canadiense) :-
8 familia(ganso),
9 estacion(verano),
10 pais(canada),
11 cabeza(negra),
12 pecho(blanco).
Estas metas pueden hacer referencia a otros predicados en una jerarqua diferen-
te:
1 pais(estados_unidos) :- region(oeste_medio).
2 pais(estados_unidos) :- region(sur_oeste).
3 pais(estados_unidos) :- region(nor_oeste).
4 pais(estados_unidos) :- region(atlantico_medio).
5 pais(canada) :- provincia(ontario).
6 pais(canada) :- provincia(quebec).
7
8 region(nueva_inglaterra) :-
9 estado(X),
10 member(X,[massachusetts, vermont, connecticut, maine]).
11
12 region(sur_oeste) :-
13 estado(X),
14 member(X,[florida, mississippi, alabama, nueva_orleans]).
Otras aves necesitaran de predicados multiples para ser identificada. Por ejemplo,
el Mallard (Anas platyrhynchos), o pato comun del norte, macho tiene la cabeza
verde con un anillo blanco; la hembra tiene la cabeza cafe moteada:
1 ave(mallard):-
2 familia(pato),
3 voz(graznido),
4 cabeza(verde).
5 ave(mallard) :-
6 familia(pato),
7 voz(graznido),
8 cabeza(cafe_moteada).
Basicamente, cualquier situacion del libro de las aves norte americanas puede
ser expresado facilmente en Prolog. Las reglas expresadas forman la base de cono-
cimientos del SE. El unico punto debil del programa es su interfaz con el usuario,
que requiere que los datos sean introducidos como hechos del programa.
9.4 Interfaz del usuario 107
9.4. Interfaz del usuario
El sistema puede mejorarse considerablemente si proveemos una interfaz para

el usuario, que pregunte por la informacion cuando esto sea necesario, en lugar de
forzar al usuario a introducirla como hechos del programa.
Antes de pensar en un predicado pregunta, es necesario entender la estructura de
los datos que seran preguntados. Todos los datos, manejandos hasta ahora, han sido
de la forma atributovalor. Por ejemplo, los atributos del pato del norte Mallard, son
mostrados en la figura 9.1.
atributo valor
familia pato
voz graznido
cabeza verde
Cuadro 9.1 Atributos valor para el mallard
Esta es una de las representaciones mas simples usadas en los SE, pero es su-
ficiente para muchas aplicaciones. Existen representaciones mas expresivas, como
los tripletes objetoatributovalor, o las redes semanticas, o los marcos.
Como estamos programando en Prolog, la riqueza del lenguaje puede usarse di-
rectamente en el SE. Por ejemplo, los pares atributovalor han sido representados
como predicados unarios de la forma atributo(valor): familia(pato), voz(graznido),
cabeza(verde). Pero en region/1 usamos la membresia en listas para su definicion.
Usaremos el predicado pregunta para determinar con ayuda del usuario, cuando
un par atributovalor es verdadero. El SE debe modificarse para determinar que
atributos son verificables por el usuario. Esto se logra con reglas para los atributos
que llaman a pregunta:
1 come(X) :- pregunta(come,X).
2 pies(X) :- pregunta(pies,X).
3 alas(X) :- pregunta(alas,X).
4 cuello(X) :- pregunta(cuello,X).
5 color(X) :- pregunta(color,X).
Ahora, si el SE tiene como meta probar color(blanco), llamara a pregunta/2

en lugar de consultar su base de conocimientos. Si pregunta(color, blanco) tiene
exito, entonces color(blanco) tambien lo tiene. La version mas simple de pregunta
es como sigue:
1 pregunta(Atrib,Val):-
2 write(Atrib:Val),
3 write(? ),
4 read(si).
El predicado read/1 tendra exito solo si el usuario responde si y falla si el

usuario responde cualquier otra cosa. Ahora el programa puede ser ejecutado sin
datos de trabajo iniciales. La misma llamada a ave/1 inicia la consulta al SE.
1 ?- ave(X).
2 fosas_nasales : externas tubulares ? si.
3 habitat : mar ? si.
4 pico : ganchudo ? si.
5 tamano : grande ? si.
6 alars : largas ? si.
7 color : blanco ? si.
8 X = albatros_laysan
9 Yes.
El problema con este enfoque es que si el usuario responde no a la ultima pre-

gunta, la regla para ave(albratros laysan) falla, llevandonos a un backtracking. De
esta manera el SE nos preguntara nuevamente informacion que ya sabe. De alguna
manera deberamos implementar un predicado pregunta que recuerde lo pregunta-
do.
Definiremos un nuevo predicado conocido/3 que nos ayude a recordar las res-
puestas del usuario. Las respuestas no se guardaran directamente en memoria, sino
que seran guardadas dinamicamente con asserta/1 cuando pregunta provea infor-
macion nueva para el SE:
1 pregunta(A,V) :- conocido(si,A,V), !.
2
3 pregunta(A,V) :- conocido(_,A,V), !, fail.

4
5 pregunta(A,V) :-
6 write(A:V),
7 write? : ),
8 read(Resp),
9 asserta(conocido(Resp,A,V)),
10 Resp == si.
Tambien es posible utilizar menues contextuados para el caso de atributos multi-

variados. La idea es que para atributos de un solo valor, la interfaz por el usuario
pregunte una sola vez:
1 pregunta(A,V) :-
2 not(multivariado(A)),
3 conocido(si,A,V2),
4 V \== V2,
5 !,
6 fail.
Una gua sobre los valores validos para un atributo se implementa con el predi-
cado menu pregunta que trabaja de manera analoga a pregunta:
9.5 Un Shell simple 109
1 tamano(X) :-
2 menu_pregunta(tamano, X, [grande, mediano, pequeno]).
3 color(X) :-
4 menu_pregunta(color,X,[blanco,verde,cafe,negro]).
La definicion de menu pregunta/3 es:
1 menu_pregunta(A,V,MenuLista) :-
2 write(Cual es el valor para ,
3 write(A), write(? ), nl,
4 write(MenuLista),nl,
5 read(Resp),
6 checar(Resp,A,V,MenuLista),
7 asserta(conocido(si,A,X)),
8 X == V.
9
10 checar(X,A,V,MenuLista) :-
11 member(X,MenuLista), !.
12
13 checar(X,A,V,MenuLista) :-
14 write(Ese valor no es valido, intente nuevamente), nl,
15 menu_pregunta(A,V,MenuLista).
9.5. Un Shell simple
El ejemplo de identificacion de aves tiene dos partes: una base de conocimientos,

que incluye la informacion especfica sobre las aves; y los predicados para controlar
la interfaz con el usuario. Al separar estas dos partes, podemos crear un shell de SE.
Con ello podemos crear un nuevo SE que identifique, por ejemplo, peces y reutilizar
la parte de control de la interfaz.
Un cambio mnimo es necesario para separar las dos partes de nuestro SE. Ne-
cesitamos un predicado de alto nivel que inicie el proceso de identificacion. Puesto
que no sabemos de antemano lo que el SE va a identificar, el shell buscara satisfa-
cer un predicado llamado meta. Cada base de conocimiento debera tener definido
meta/1, por ejemplo, para el caso de identificacion de aves tendramos:
1 meta(X) :- ave(X).
como primer predicado en la base de conocimientos aves.

El shell tendra un predicado solucion/0 que llevara a cabo labores de manteni-
miento del SE, para luego resolver la meta/1:
1 solucion :-
2 abolish(conocido,3),
3 define(conocido,3),
4 meta(X),
5 write(La respuesta es: ), write(X), nl.
6
7 solucion :-
8 write(No se encontro una respuesta.), nl.
El predicado Prolog abolish/2 se usa para eliminar los hechos definidos previa-
mente con conocido/3, cada vez que una consulta se va a ejecutar. Esto permite al
usuario ejecutar solucion multiples veces en una sola sesion. El predicado de f ine/2
permite indicarle a Prolog que conocido estara definido en el SE, de forma que no
cause error la primera utilizacion de este predicado. Este predicado puede variar
dependiendo de la version de Prolog utilizada.
De esta manera tenemos que el SE ha sido dividido en dos partes. Los predicados
en el shell son:
solucion,
pregunta,
menu pregunta,
los predicados auxiliares de estos.
Los predicados en la base de conocimientos son:
meta,
las reglas sobre el conocimiento del SE,
las reglas sobre los atributos provistos por el usuario,
las declaraciones de los atributos multi-variados.
Para usar este shell en Prolog, tanto el shell como la base de conocimientos deben
ser cargados:
1 ?- consult(shell).
2 yes
3 ?- consult(aves.kb).
4 yes
5 ?- solucion.
6 fosas_nasales : externas_tubulares ? ...
9.5.1. REPL
El shell puede ser mejorado construyendo un ciclo de comandos read-eval-print

loop. Para ello definiremos el predicado se:
1 se :-
2 bienvenida,
9.6 Encadenamiento haca atras con incertidumbre 111
3 repeat,
4 write(> ),
5 read(X),
6 do(X),
7 X == quit.
8
9 bienvenida :-
10 write(Este es el shell de su SE.), nl,
11 write(Escriba: cargar, consultar, o salir en el promt.), nl
12
13 do(cargar) :-
14 cargar_bd, !.
15
16 do(consultar) :-
17 solucion, !.
18
19 do(salir).
20
21 do(X) :-
22 write(X),
23 write( no es un comando valido.), nl,
24 fail.
25
26 cargar_bd :-
27 write(Nombre del archivo: ),
28 read(F),
29 reconsult(F).
La arquitectura obtenida de esta forma se muestra en la figura 9.2.
9.6. Encadenamiento haca atras con incertidumbre
Como hemos mencionado, el encadenamiento haca adelante resulta conveniente

cuando los problemas a resolver son del tipo seleccion estructurada, como en el
ejemplo de la clasificacion de aves. Sin embargo, en ademas de que hemos asumido
que la informacion completa esta disponible para resolver el problema, tambien
hemos asumido que no hay incertidumbre, ni el los datos provistos por el usuario,
ni en las reglas de los expertos. Por ejemplo, el albatros puede ser observado en la
bruma, con lo que sera difcil precisar si su color es blanco u obscuro. Es de esperar
que un SE que maneje incertidumbre, pueda contender con este tipo de problemas.
Desarrollaremos un shell que permita manejar reglas con incertidumbre y enca-
denamiento de ellas haca atras. Evidentemente, este SE tendra un formato de reglas
propio, diferente a las reglas de Prolog, y por lo tanto, una maquina de inferencia
propia.
Interfaz del Usuario
se
pregunta
menu_pregunta
Mquina de inferencia
solucion
cargar
Base de Conocimientos Memoria de trabajo
meta conocido
reglas
mulivaluado
preguntado
Figura 9.2 El shell del SE.
9.6.1. Factores de certidumbre
La forma mas comun de trabajar con la incertidumbre consiste en asignar un fac-

tor de certidumbre a cada pieza de informacion en el SE. La maquina de inferencia
debera mantener los factores de incertidumbre conforme el proceso de inferencia se
lleve a cabo.
Por ejemplo, asumamos que los factores de certidumbre (precedidos por cf) son
enteros entre -100 (definitivamente falso) y +100 (definitivamente verdadero). La si-
guiente base de conocimientos en formato del SE esta disenada para diagnosticar un
auto que no enciende. Esto ilustra el comportamiento de los factores de certidumbre:
1 GOAL problema.
2
3 RULE 1
4 IF not arranca AND
5 bateria_mala
6 THEN problema is bateria.
7
8 RULE 2
9 IF luces_debiles
10 THEN bateria_mala cf 50.
11
12 RULE 3
13 IF radio_debil
14 THEN bateria_mala cf 50.

15
16 RULE 4
17 IF arranca AND
18 olor_gasolina
19 THEN problema is fuga cf 80.
20
21 RULE 5
22 IF arranca AND
23 indicador_gasolina is vacio
24 THEN problema is tanque_vacio cf 90.
25
26 RULE 6
27 IF arranca AND
28 indicador_gasolina is bajo
29 THEN problema is tanque_vacio cf 30.
30
31 ASK arranca
32 MENU (si no)
33 PROMPT Su motor arranca? .
34
35 ASK luces_debiles
36 MENU (si no)
37 PROMPT Sus luces estan debiles? .
38
39 ASK radio_debile
40 MENU (si no)
41 PROMPT Su radio esta debil? .
42
43 ASK olor_gasolina
44 MENU (si no)
45 PROMPT Huele a gasolina?.
46
47 ASK indicador_gasolina
48 MENU (vacio, medio, lleno)
49 PROMPT Que indica al aguja de gasolina? .
Por el momento la inferencia usara encadenamiento haca atras, similar al que

usa Prolog. La regla GOAL indica que el proceso buscara un valor para problema.
La regla 1 causara que la sub-meta bateria mala sea procesada, etc. Observen que
las reglas especifican tambien factores de certidumbre. Las reglas 2 y 3 proveen evi-
dencia de que la batera esta en mal estado, pero ninguna es conclusiva al respecto.
Un dialogo con este sistema sera como sigue:
1 consultar, reiniciar, cargar, listar, trazar, como, salida

2 : consultar
3 Su motor arranca?
4 : si
5 Huele a gasolina?
6 : si
7 Que indica la aguja de la gasolina?
8 : vacio
9 problema-tanque-vacio-cf-90
10 problema-fuga-cf-80
11 problema resuelto
Observen que a diferencia de Prolog, el sistema no se detiene al encontrar el

primer posible valor para problema. En este caso se computan todos los valores
razonables para problema y se reporta el valor de certidumbre asociado a estas
soluciones. Recordemos que estos factores de certidumbre no son probabilidades,
solo ponderan de alguna manera las respuestas.
De igual manera, el usuario podra ofrecer factores de certidumbre sobre sus
respuestas, por ejemplo:
1 : consultar
2 ...
3 Huele a gasolina?
4 si cf 50
5 ...
Existen diversas maneras de capturar el concepto de factor de certidumbre, pero

todas ellas deben de confrontar las mismas situaciones basicas:
Reglas cuyas conclusiones son inciertas,
Reglas cuyas premisas son inciertas,
Datos provistos por el usuario inciertos,
Combinacion de premisas inciertas con conclusiones inciertas,
Actualizar los factores de incertidumbre en los datos almacenados en el espacio
de trabajo,
Establecer un umbral sobre el cual las premisas se consideran conocidas.
9.6.2. Factores de certidumbre a la MYCIN
MYCIN, uno de los SE mas conocidos en IA, introduce factores de certidumbre

disenados para producir resultados intuitivos desde la perspectiva de los expertos.
Revisemos el uso de estos factores por casos. El mas simple, sera aquel donde las
premisas son totalmente ciertas:
1 arranca cf 100.
2 olor_gas cf 100.
disparan la regla 4 y por tanto, problema fuga cf 80 debera agregarse al al-

macen de trabajo. Sin embargo, este es un caso poco probable. Normalmente no
estamos totalmente seguros de las premisas de una regla y lo normal sera tener
hechos como:
1 arranca cf 80.
2 olor_gas cf 50.
Cuando esto sucede, la incertidumbre en las premisas de la regla debe combinarse

con las de la conclusion de la misma de la siguiente manera:
CF = CFregla mnCF premisa/100

Dado el ejemplo, la regla 4 se activara con un c f = 50 (el mnimo de las dos
premisas) y dada la formula anterior, agregaramos problema fuga cf 40 al
almacen de trabajo.
Para que una regla dispare, su factor de certidumbre debe superar un umbral que
normalmente se fija en 20. As que bajo la definicion anterior, la regla 4 disparara.
Si tuviesemos olor gas cf 15, entonces la regla no disparara.
Ahora consideren el caso donde hay mas de una regla que da soporte a cierta
conclusion. En ese caso, cada una de las reglas que disparan contribuira al factor de
certidumbre de la conclusion. Si una regla dispara y la conclusion ya se encontraba
en el almacen de trabajo, las siguientes reglas aplican:
CF(X,Y ) = X +Y (100 X)/100. Ambos X,Y > 0

CF(X,Y ) = X +Y /1 mn(|X|, |Y |). Uno de X,Y < 0
CF(X,Y ) = CF(X, Y ). Ambos X,Y < 0
Por ejemplo, si disparamos la regla 2 (luces debiles) con su premisa sin incerti-
dumbre, tendramos que agregar al almacen de trabajo bateria mala cf 50.
Luego si disparamos la regla 3 (radio debil), el factor de certidumbre de este hecho
debe modificarse a bateria mala cf 75. Lo cual resulta intuitivo (hay mas
evidencia de que la batera tiene problemas). Lo que tambien resulta intuitivo es que
necesitamos programar nuestra propia maquina de inferencia.
9.6.3. Formato de las reglas
Como programaremos nuestra propia maquina de inferencia, podemos elegir la

estructura de hechos y reglas. Las reglas tendran la estructura general:
regla(Nombre, Premisas,Conclusion).
El Nombre opera solo como un identificador de la regla. El lado izquierdo de
la misma Premisas implica al lado derecho Conclusion (conclusion). Como usare-
mos encadenamiento haca atras, cada regla sera usada para validar una pieza de
informacion, de manera el RHS contiene una meta con su factor de certidumbre
asociado:
conclusion(Meta,CF).
mientras que las premisas toman la forma de una lista de metas:
premisas(ListaMetas).
Las metas seran representadas, para comenzar, como pares atributovalor:
av(Atributo,Valor).
cuando Atributo y Valor son atomos, la estructura general de las reglas se ve
como:
1 regla(Nombre,
2 premisas( [av(A1,V1), av(A2,V2), ... ] ),
3 conclusion(av(Attr,Val), CF)).
Por ejemplo, la regla 5 quedara representada como:
1 regla(5,
2 premisas([av(arranca,si), av(indicador_gasolina,vacio)]),
3 conclusion(av(problema,fuga), 80)).
Estas reglas no son faciles de leer, pero tienen una estructura adecuada para ser
procesadas por Prolog. Otras herramientas de Prolog como las gramaticas de clausu-
la definitivas (DCG) o la definicion de operadores, puede ayudarnos a simplificar
esta representacion.
9.6.4. La maquina de inferencia
Dado el formato de las reglas del SE deseamos que la inferencia tome en cuenta
los siguientes aspectos:
Combine los factores de certidumbre como se indico anteriormente.

Mantenga el espacio de trabajo con la informacion actualizada con las nuevas
evidencias obtenidas.
Encontrar toda la informacion acerca de un atributo en particular cuando se pre-
gunte por el, y poner esa informacion en el espacio de trabajo.
Primero, los hechos seran almacenados en la memoria de trabajo de Prolog, con
el siguiente formato:
1 hecho(av(A,V),CF).
De forma que un predicado meta/2 hara la llamada para resolver un problema

dado en estos terminos. Por ejemplo, en el caso del arranque del auto, tendramos
como meta:
1 ?- meta(av(problema,X),CF).
El predicado meta/2 debe de contender con tres casos:

El atributovalor se conoce de antemano;
Existen reglas para deducir el atributovalor;
Se debe preguntar al usuario.
El sistema puede disenarse para preguntar al usuario automaticamente por el va-
lor de un atributo, ante la ausencia de reglas; o bien, se puede declarar que atributos
pueden ser preguntados al usuario. Este ultimo enfoque hace que el manejo de la
base de conocimientos sea mas explcito y provee mayor control sobre los dialogos
usuario SE. Podemos definir un predicado pregunta/2 para declarar el atributo a
preguntar y la frase para ello:
1 pregunta(pais_residencia,En que pas vive? ).
Veamos ahora los tres casos para meta/2. El primero de ellos ocurre cuando la
informacion ya esta en la memoria de trabajo:
1 meta(av(Atr,Val),CF) :-
2 hecho( av(Atr,Val), CF),
3 !.
El segundo caso se da cuando el valor del atributo no se encuentra en la memoria

de trabajo, pero el es posible preguntar por ello al usuario:
1 meta(av(Atr,Val), CF) :-
2 \+ hecho( av(Atr,_),_),
3 pregunta(Atr,Msg),
4 preguntar(Atr,Msg),
5 !,
6 meta(av(Atr,Val), CF).
Para ello, el predicado preguntar/2 interroga al usuario. El usuario responde con

un valor para la atributo Atr y un factor de certidumbre asociado CF. El mensaje
Msg da la informacion necesaria para guiar al usuario en estas consultas:
1 preguntar(Atr,Msg) :-
2 write(Msg),
3 read(Val),
4 read(CF),
5 asserta(fact(av(Atr,Val),CF)).
El tercer caso para meta/2 es cuando el valor del atributo es desconocido, pero
se puede deducir usando las reglas definidas en el sistema, en ese caso la llamada
es:
1 meta(Meta,CFactual) :-
2 buscaReglas(Meta,CFactual).
Esta llamada hace uso de la maquina de inferencia que disenaremos para nuestro
SE con incertidumbre. El factor de certidumbre se etiqueta como actual, porque es
posible que cambie de valor al ir aplicando las reglas definidas en el sistema.
El predicado buscaReglas/2 se encarga de encontrar aquellas reglas cuya con-
clusion unifica con la Meta en cuestion y de actualizar el factor de certidumbre con
base en las premisas de estas reglas. Si la Meta es un hecho conocido, no hay nada
que hacer, solo regresar true:
1 buscaReglas(Meta,CFactual) :-
2 regla(N, premisas(ListaPremisas),
3 conclusion(Meta,CF)),
4 probar(ListaPremisas,Contador),
5 ajustar(CF,Contador,NuevoCF),
6 actualizar(Meta,NuevoCF,CFactual),
7 CFactual == 100,
8 !.
9
10 buscaReglas(Meta,CF) :-
11 hecho(Meta,CF).
Dada una lista de premisas pertenecientes a una regla encontrada para satisfacer
la Meta del SE, es necesario que buscaReglas/2 las pruebe. Para ello definimos
probar/2:
1 probar(ListaPremisas, Contador) :-
2 probAux(ListaPremisas, 100, Contador).
3
4 probAux([],Contador,Contador).
5 probAux([Premisa1|RestoPremisas],ContadorActual,Contador) :-
6 meta(Premisa1,CF,Cont),
7 Cont >= 20,
8 probAux(RestoPremisas,Cont,Contador).
El ajuste de los factores de certidumbre se lleva a cabo de la siguiente manera:
1 ajustar(CF1, CF2, CF) :-

2 X is CF1 * CF2 / 100,
3 int_redondear(X,CF).
4
5 int_redondear(X,I) :-
6 X >= 0,
7 I is integer(X + 0.5).
9 int_redondear(X,I) :-
10 X < 0,
11 I is integer(X - 0.5).
La actualizacion de la memoria de trabajo se lleva a cabo de la siguiente manera:
1 actualizar(Meta,NuevoCF,CF) :-
2 hecho(Meta,ViejoCF),
3 combinar(NuevoCF,ViejoCF,CF),
4 retract(hecho(Meta,ViejoCF)),
5 asserta(hecho(Meta,CF)),
6 !.
7
8 actualizar(Meta,CF,CF) :-
9 asserta(hecho(Meta,CF)).
10
11 combinar(CF1, CF2, CF) :-

12 CF1 >= 0,
13 CF2 >= 0,
14 X is CF1 + CF2*(100 - CF1)/100,
16
17
18 combinar(CF1,CF2,CF) :-
19 CF1 < 0,
20 CF2 < 0,
21 X is -( -CF1-CF2*(100+CF1)/100),
23
24 combinar(CF1,CF2,CF) :-
25 (CF1 < 0 ; CF2 < 0),
26 (CF1 > 0 ; CF2 > 0),
27 abs_minimum(CF1,CF2,MCF),
28 X is 100 * (CF1 + CF2) / (100 - MCF),
9.6.5. Interfaz con el usuario
La interfaz con el usuario es muy parecida a la definida en la seccion anterior. Se

incluyen predicados auxiliares necesarios en su definicion:
1 se :-
2 repeat,
3 write(consultar, cargar, salir), nl,
4 write(: ),
5 read_line(X),
6 ejec(X),
7 X == salir.
8
9 ejec(consultar) :-
10 metas_principales,
11 !.
12
13 ejec(cargar) :-
14 cargar_reglas,
15 !.
16
17 ejec(salir).
18
19 %% % Auxiliares
20
21 metas_principales :-
22 meta_principal(Atr),
23 principal(Atr),
24 imprime_meta(Atr),
25 fail.
26 metas_principales.
27
28 principal(Atr) :-
29 meta(av(Atr,Val,CF)),
30 !.
31 principal(_) :- true.
32
33 imprime_meta(Atr) :-
34 nl,
35 hecho(av(Atr,Val), CF),
36 CF >= 20,
37 salidap(av(Atr,Val),CF), nl
38 fail.
39 imprime_meta(Atr) :-
40 write (Meta: ), write(Attr), write( solucionada.),
41 nl, nl.
42
43 salidap(av(Atr,Val),CF) :-
44 output(Atr,Val,ListaImprimir),
45 write(Atr-cf-CF),
46 imprimeLista(ListaImprimir), !.
47 salidap(av(Atr,Val),CF) :-
48 write(Atr-Val-cf-CF).
49
50 imprimeLista([]).
51 imprimeLista([X|Xs]) :-
52 write(X),
53 imprimeLista(Xs).
Captulo 10
Arboles de Decision
Resumen En este captulo abordaremos la solucion de problemas en el contexto del

aprendizaje automatico, ejemplificado con el algoritmo ID3 [13] (Inductive Dicoto-
mizer). Este algoritmo induce arboles de decision a partir de ejemplos conformados
como un conjunto de pares atributovalor, para predecir el valor de uno de los atri-
butos, conocido como la clase. El aprendizaje de arboles de decision es una de las
tecnicas de inferencia inductiva mas usadas. Se trata de un metodo para aproximar
funciones de valores discretos, capaz de expresar hipotesis disyuntivas y robusto
al ruido en los ejemplos de entrenamiento. La descripcion que se presenta en este
captulo, cubre una familia de algoritmos para la induccion de arboles de decision
que incluyen ID3 y C4.5 [14]. Estos algoritmos llevan a cabo su busqueda de hipote-
sis en un espacio completamente expresivo, evitando as los problemas mencionados
con respecto a espacios de hipotesis incompletos. Como veremso, el sesgo inductivo
en este caso, consiste en la preferencia por arboles pequenos, sobre arboles grandes.
Un arbol as aprendido, puede representarse tambien como un conjunto de reglas
si-entonces, mas faciles de entender para un usuario.
10.1. Representacion de los arboles de decision
La figura 10.1 muestra un arbol de decision tpico. Cada nodo del arbol esta con-
formado por un atributo y puede verse como la pregunta: Que valor tiene este
atributo en el caso a clasificar? Las ramas que salen de los nodos, corresponden a
los posibles valores del atributo correspondiente.
Un arbol de decision clasifica a un caso, filtrandolo de manera descendente, has-
ta encontrar una hoja, que corresponde a la clasificacion buscada. Consideren el
proceso de clasificacion del siguiente caso, que describe un da en partcular:
h cielo = soleado,temperatura = caliente, humedad = alta, viento = f uerte i
121
122 10 Arboles de Decision
Atributo
Cielo Clase
Valor
nublado
soleado lluvioso
Hmedad si Viento
alta normal fuerte dbil
no si no si
Figura 10.1 Un ejemplo de arbol de decision para el concepto buen da para jugar tenis. Los
nodos representan un atributo a ser verificado por el clasificador. Las ramas son los posibles
valores para el atributo en cuestion. Los textos en crculos, representan las clases consideradas,
i.e., los valores posibles del atributo objetivo.
Como el atributo Cielo, tiene el valor soleado en el caso, este es filtrado haca
abajo del arbol por la rama de la izquierda. Como el atributo Humedad, tiene el
valor alta, el ejemplo es filtrado nuevamente por rama de la izquierda, lo cual nos
lleva a la hoja que indica la clasificacion del caso: Buen da para jugar tenis = no.
El Algoritmo 2, define computacionalmente esta idea.
Algoritmo 2 El algoritmo clasifica, para arboles de decision

1: function C LASIFICA(Ej, Arbol)
Require: E j: un ejemplo a clasificar, Arbol: un arbol de decision
Ensure: Clase: la clase del ejemplo
2: Clase tomaValor(raiz(Arbol), E j);
3: if hoja(raz(Arbol)) then
4: return Clase
5: else
6: clasi f ica(E j, subArbol(Arbol,Clase));
7: end if
8: end function
La funcion toma-valor encuentra el valor de un atributo, en el caso que se

esta clasificando. El predicado hoja es verdadero si su argumento es un nodo ter-
minal del arbol y falso si se trata de un nodo interno. La funcion sub-arbol se
mueve por la rama del arbol que corresponde al valor del atributo probado en el ca-
so. De esta forma, obtiene un sub-arbol. En nuestro ejemplo, a partir del nodo raz
cielo, esta funcion obtiene el sub-arbol que resulta de moverse por la rama soleado,
etc.
En general, un arbol de decision representa una disyuncion de conjunciones de
restricciones en los posibles valores de los atributos de los casos. Cada rama que va
10.2 Problemas apropiados para la aplicacion de arboles de decision 123
de la raz del arbol a una hoja, representa una conjuncion de tales restricciones y el
arbol mismo representa la disyuncion de esas conjunciones. Por ejemplo, el arbol
de la figura 10.1, puede expresarse como sigue:
(cielo = soleado humedad = normal)

(cielo = nublado)
(cielo = lluvia viento = d ebil)
10.2. Problemas apropiados para la aplicacion de arboles de

decision
Aun cuando se han desarrollado diversos metodos para la induccion de arboles

de decision, y cada uno de ellos ofrece diferentes capacidades, en general estos al-
goritmos son apropiados para solucionar problemas de aprendizaje conocidos como
problemas de clasificacion. Estos problemas presentan las siguientes caractersticas:
Ejemplos representados por pares atributo-valor. Los casos del problema estan
representados como un conjunto fijo de atributos, por ejemplo Cielo y sus valo-
res, por ej. Soleado. El caso mas sencillo es cuando cada atributo toma valores de
un pequeno conjunto discreto y cada valor es disjunto, por ejemplo {Soleado, Nu-
blado, Lluvia}. Existen extensiones para trabajar con atributos de valores reales,
por ejemplo, Temperatura expresado numericamente.
La funcion objetivo tiene valores discretos. El arbol de decision de la Figura 10.1,
asigna una clasificacion binaria, por ejemplo si o no a cada caso. Un arbol de de-
cision puede ser extendido facilmente, para representar funciones objetivos con
mas de dos valores posibles. Una extension menos simple consiste en conside-
rar funciones objetivo de valores discretos, por ello la aplicacion del metodo en
dominios discretos es menos comun.
Se necesitan descripciones disyuntivas. Como se menciono, los arboles de deci-
sion representan naturalmente conceptos disyuntivos.
Ruido en los ejemplos de entrenamiento. El metodo es robusto al ruido en los
ejemplos de entrenamiento, tanto errores de clasificacion, como errores en los
valores de los atributos.
Valores faltantes en los ejemplos. El metodo puede usarse aun cuando algunos
ejemplos de entrenamiento tengan valores desconocidos para algunos atributos.
Al igual que en el punto anterior, esto se debe a que el algoritmo computa es-
tadsticas globales que minimizan el impacto del ruido o falta de informacion de
un ejemplo.
10.3. El algoritmo basico de aprendizaje de arboles de decision
La mayora de los algoritmos para inferir arboles de decision son variaciones de

un algoritmo basico que emplea una busqueda descendente (top-down) y egosta
(greedy) en el espacio de posibles arboles de decision. La presentacion de estos
algoritmos se centra en ID3 y C4.5.
El algoritmo basico ID3, construye el arbol de decision de manera descendente,
comenzando por preguntarse: Que atributo debera ser colocado en la raz del arbol?
Para responder esta pregunta, cada atributo es evaulado usando un test estadstico
para determinar que tan bien clasifica el solo los ejemplos de entrenamiento. El me-
jor atributo es seleccionado y colocado en la raz del arbol. Una rama y su nodo
correspondiente es entonces creada para cada valor posible del atributo en cuestion.
Los ejemplos de entrenamiento son repartidos en los nodos descendentes de acuer-
do al valor que tengan para el atributo de la raz. El proceso entonces se repite con
los ejemplos ya distribuidos, para seleccionar un atributo que sera colocado en cada
uno de los nodos generados. Generalmente, el algoritmo se detiene si los ejemplos
de entrenamiento comparten el mismo valor para el atributo que esta siendo proba-
do. Sin embargo, otros criterios para finalizar la busqueda son posibles: i) Covertura
mnima, el numero de ejemplos cubiertos por cada nodo esta por abajo de cierto
umbral; ii) Pruebas de significancia estadstica usando 2 para probar si las distri-
buciones de las clases en los sub-arboles difiere significativamente. Aunque, como
veremos, la poda del arbol se prefiere a las pruebas de significancia. Este algoritmo
lleva a cabo una busqueda egosta de un arbol de decision aceptable, sin reconside-
rar nunca las elecciones pasadas (backtracking). Una version simplificada de el se
muestra en el Algoritmo 3.
10.3.1. Que atributo es el mejor clasificador?
La decision central de ID3 consiste en seleccionar que atributo colocara en cada

nodo del arbol de decision. En el algoritmo presentado, esta opcion la lleva a cabo
la funcion mejor-particion, que toma como argumentos un conjunto de ejem-
plos de entrenamiento y un conjunto de atributos, regresando la particion inducida
por el atributo, que solo, clasifica mejor los ejemplos de entrenamiento. Considere
los ejemplos de entrenamiento del cuadro 10.1 para el concepto objetivo: buen da
para jugar tenis? El encabezado del cuadro indica los atributos usados para describir
estos ejemplos, siendo jugar-tenis? el atributo objetivo.
Si queremos particionar este conjunto de ejemplos con respecto al atributo tem-
peratura, obtendramos:
?- partition(temperatura, Ejemplos).
Ejemplos= [[temperatura [frio 5 6 7 9]
[caliente 1 2 3 13]
[templado 4 8 10 11 12 14]]
10.3 El algoritmo basico de aprendizaje de arboles de decision 125
Algoritmo 3 El algoritmo ID3

1: function ID3(Ejs, Atbs, Clase)
2: Arbol 0; / De f ault claseMayoria(E js);
3: if E js = 0/ then
4: return De f ault;
5: else if mismoValor(E js,Clase) then
6: return Arbol tomaValor( f irst(E js).Clase);
7: else if Atbs = 0/ then
8: return Arbol valorMasComun(E js,Clase);
9: else
10: Me jorParticion Me jorParticion(E js, Atbs);
11: Me jorAtributo f irst(Me jorParticion);
12: Arbol Me jorAtributo;
13: for all ParticionE js rest(Me jorParticion) do
14: ValoAtributo f irst(ParticionE js);
15: SubE js rest(ParticionE js);
16: agregarRama(Arbol, alorAtributo, ID3(SubE js, {Atbs \
Me jorAtributo},Clase));
17: end for
18: return Arbol
19: end if
20: end function
Da Cielo Temperatura Humedad Viento Jugar-tenis?

1 soleado calor alta debil no
2 soleado calor alta fuerte no
3 nublado calor alta debil si
4 lluvia templado alta debil si
5 lluvia fro normal debil si
6 lluvia fro normal fuerte no
7 nublado fro normal fuerte si
8 soleado templado alta debil no
9 soleado fro normal debil si
10 lluvia templado normal debil si
11 soleado templado normal fuerte si
12 nublado templado alta fuerte si
13 nublado calor normal debil si
14 lluvia templado alta fuerte no
Cuadro 10.1 Conjunto de ejemplos de entrenamiento para el concepto objetivo jugar-tenis? en

ID3, por Tom M. Mitchel [10].
Lo que significa que el atributo temperatura tiene tres valores diferentes en el

conjunto de entrenamiento: fro, caliente, y templado. Los casos d5, d6, d7, y d9,
tienen como valor del atributo temperatura= fro. La funcion mejor-particion en-
cuentra el atributo que mejor separa los ejemplos de entrenamiento de acuerdo al
atributo objetivo. En que consiste una buena medida cuantitativa de la bondad de un
atributo? Definiremos una propiedad estadstica llamada ganancia de informacion.
10.3.2. Entropa y ganancia de informacion
Una manera de cuantificar la bondad de un atributo en este contexto, consiste en

considerar la cantidad de informacion que proveera este atributo, tal y como esto
es definido en teora de informacion por Claude E. Shannon [18]. Un bit de infor-
macion es suficiente para determinar el valor de un atributo booleano, por ejemplo,
si/no, verdader/falso, 1/0, etc., sobre el cual no sabemos nada. En general, si los
posibles valores del atributo vi , ocurren con probabilidades P(vi ), entonces en con-
tenido de informacion, o entropia, E de la respuesta actuale esta dado por:
n
E(P(vi ), . . . , P(vn )) = P(vi ) log2 P(vi )
i=1
Consideren nuevamente el caso booleano, aplicando esta ecuacion a un volado

con una moneda confiable, tenemos que la probabilidad de obtener aguila o sol es
de 1/2 para cada una:
1 1 1 1 1 1
E( , ) = log2 log2 = 1
2 2 2 2 2 2
Ejecutar el volado nos provee 1 bit de informacion, de hecho, nos provee la clasi-
ficacion del experimento: si fue aguila o sol. Si los volados los ejecutamos con una
moneda cargada que da 99 % de las veces sol, entonces E(1/100, 99/100) = 0,08
bits de informacion, menos que en el caso de la moneda justa, porque ahora tene-
mos mas evidencia sobre el posible resultado del experimento. Si la probabilidad de
que el volado de sol es del 100 %, entonces E(0, 1) = 0 bits de informacion, ejecu-
tar el volado no provee informacion alguna. La grafica de la funcion de entropa se
muestra en la figura 10.2.
Figura 10.2 Grafica de la funcion entropia para clasificaciones booleanas.
Consideren nuevamente los ejemplos de entrenamiento del cuadro 10.1. De 14

ejemplos, 9 son positivos (si es un buen da para jugar tenis) y 5 son negativos. La
entropia de este conjunto de entrenamiento es:
9 5
E( , ) = 0,940
14 14
10.4 Espacio de hipotesis en el aprendizaje inductivo de arboles de decision 127
Si todos los ejemplos son positivos o negativos, por ejemplo, pertencen todos a
la misma clase, la entropia sera 0. Una posible interpretacion de esto, es considerar
la entropia como una medida de ruido o desorden en los ejemplos. Definimos la ga-
nancia de informacion (GI) como la reduccion de la entropa causada por particionar
un conjunto de entrenamiento S, con respecto a un atributo A:
|Sv |
Ganancia(S, A) = E(S) E(Sv )
vA |S|
Observen que el segundo termino de Ganancia, es la entropa con respecto al

atributo A. Al utilizar esta medida en ID3, sobre los ejemplos del cuadro 10.1, obte-
nemos:
Ganancia de informacion del atributo CIELO : 0.24674976

Ganancia de informacion del atributo TEMPERATURA : 0.029222548
Ganancia de informacion del atributo HUMEDAD : 0.15183544
Ganancia de informacion del atributo VIENTO : 0.048126936
Maxima ganancia de informacion: 0.24674976
Particion:
[cielo [soleado 1 2 8 9 11] [nublado 3 7 12 13]
[lluvia 4 5 6 10 14]]
Esto indica que el atributo con mayor ganancia de informacion fue cielo, de
ah que esta parte del algoritmo genera la particion de los ejemplos de entrena-
miento con respecto a este atributo. Si particionamos recursivamente los ejemplos
que tienen el atributo cielo = soleado, obtendramos:
Ganancia de informacion del atributo TEMPERATURA : 0.5709506

Ganancia de informacion del atributo HUMEDAD : 0.9709506
Ganancia de informacion del atributo VIENTO : 0.01997304
Maxima ganancia de informacion: 0.9709506
Particion:
[humedad [normal 11 9] [alta 8 2 1]]
Lo cual indica que en el nodo debajo de soleado deberamos incluir el atributo

humedad. Todos los ejemplos con humedad = normal, tienen valor si para el con-
cepto objetivo. De la misma forma, todos los ejemplos con valor humedad = alta,
tiene valor no para el concepto objetivo. As que ambas ramas descendiendo de no-
do humedad, llevaran a clases terminales de nuestro problema de aprendizaje. El
algoritmo terminara por construir el arbol de la figura 10.1.
10.4. Espacio de hipotesis en el aprendizaje inductivo de

arboles de decision
Como los otros metodos de aprendizaje, ID3 puede concebirse como un proceso
de busqueda en un espacio de hipotesis, para encontrar aquella hipotesis que se
ajusta mejor a los datos de entrenamiento. El espacio de hipotesis explorado por
ID3 es el espacio de todos los arboles de decision posibles. El algoritmo lleva a
cabo una busqueda de lo simple a lo complejo, comenzando por el arbol vaco, para
considerar cada vez hipotesis mas complejas. La medida ganancia de informacion
gua esta busqueda de ascenso de colina (hill-climbing), como ejemplificamos en la
seccion anterior.
Considerando ID3 en terminos de su espacio y estrategias de busqueda, es posible
analizar sus capacidades y limitaciones:
El espacio de hipotesis de ID3 es completo con respecto a las funciones de valores
discretos que pueden definirse a partir de los atributos considerados. De manera
que no existe el riesgo que la funcion objetivo no se encuentre en el espacio de
hipotesis.
ID3 mantiene solo una hipotesis mientras explora el espacio de hipotesis posi-
bles. Esto contrasta, por ejemplo, con el algoritmo eliminacion de candidatos,
que mantiene el conjunto de todas las hipotesis consistentes con el conjunto de
entrenamiento. Es por ello que ID3 es incapaz de determinar cuantos arboles de
decision diferentes son consistentes con los datos.
El algoritmo basico ID3 no ejecuta vuelta atras (backtracking) en su busqueda.
Una vez que el algoritmo selecciona un atributo, nunca reconsiderara esta elec-
cion. Por lo tanto, es suceptible a los mismos riesgos que los algoritmos estilo
ascenso de colina, por ejemplo, caer maximos o mnimos locales. Como vere-
mos, la vuelta atras puede implementarse con alguna tecnica de poda.
ID3 utiliza todos los ejemplos de entrenamiento en cada paso de su busqueda
guiada por el estadstico ganancia de informacion. Esto contrasta con los meto-
dos que usan los ejemplos incrementalmente, por ejemplo encuentra-S o elimi-
nacion de candidatos. Una ventaja de usar propiedades estadsticas de todos los
ejemplos es que la busqueda es menos sensible al ruido en los datos.
10.5. Sesgo inductivo en el aprendizaje de arboles de decision
Recuerden que el sesgo inductivo es el conjunto de afirmaciones que, junto con

los datos de entrenamiento, justifican deductivamente la clasificacion realizada por
un sistema de aprendizaje inductivo sobre casos futuros. Dado un conjunto de en-
trenamiento, por lo general hay muchos arboles de decision consistentes con este.
Describir el sesgo inductivo de ID3 equivale a explicar porque este algoritmo pre-
fiere ciertos arboles a otros, que arbol eligira.
Puesto que ID3 encontrara el primer arbol consistente con el conjunto de entrena-
miento, producto de una busqueda de ascenso de colina, de lo simple a lo complejo,
el algoritmo tiene preferencia por: i) arboles pequenos sobre arboles grandes, que
indican que la busqueda termino en proximidad a la raz del arbol; y ii) debido a
su caracter egoista, arboles que colocan atributos mas informativos cerca de la raz
del arbol. Sin embargo, observen que este sesgo es aproximado. Un algoritmo que
tuviera un sesgo identico al descrito aqu, tendra que realizar una busqueda prime-
ro en amplitud y preferir los arboles de menor profundidad. ID3 busca primero en
profundidad.
10.6 Consideraciones sobre el aprendizaje inductivo de arboles de decision 129
10.5.1. Sesgo por restriccion y sesgo por preferencia
Existe una diferencia interesante entre los sesgos que exhiben ID3 y el algo-
ritmo eliminacion de candidatos, discutido en la sesion anterior. El sesgo de ID3
es producto de su estrategia de busqueda, mientras que el sesgo de eliminacion de
candidatos es resultado de la definicion del espacio de busqueda. Por lo tanto, el
sesgo de ID3 es exhibe una preferencia por ciertas hipotesis, sobre otras, por ejem-
plo, hipotesis compactas. Este tipo de sesgo, que no impone restricciones sobre
las hipotesis que seran eventualmente consideradas, recibe el nombre de sesgo por
preferencia. Por otra parte, el sesgo de eliminacion de candidatos que restringe el
conjunto de hipotesis a considerar, recibe el nombre de sesgo por restriccion o sesgo
del lenguaje.
En general, es preferible trabajar con un sesgo por preferencia, puesto que este
permite al sistema de aprendizaje explorar un espacio de hipotesis completo, ase-
gurando que la representacion del concepto objetivo se encuentra ah. Consideren
que es posible trabajar con ambos sesgos a la ves, por ejemplo, el sistema aprendiz
de damas chinas de la sesion de introduccion, introduce un sesgo por restricciones
cuando se decide que la hipotesis tiene la forma de una combinacion lineal de los
atributos del tablero, y un sesgo por preferencia cuando se introduce la busqueda
ordenada por mnimos cuadrados (LMS) en el espacio de posibles parametros wi .
10.5.2. Porque preferir hipotesis mas compactas?
Es el sesgo inductivo de ID3, preferir las hipotesis mas compactas, lo suficiente-

mente robusto para generalizar mas alla de los datos observados? Este es un debate
no resuelto iniciado por William de Occam1 circa 1320. Un argumento intuitivo
es que existen mucho menos hipotesis compactas que extensas, por lo que es mas
difcil que una hipotesis compacta coincida accidentalmente con los datos obser-
vados. En cambio, hay muchas hipotesis extensas que se puede, ajustar a los datos
de entrenamiento, pero fallaran al generalizar. Aunque este argumento no es del
todo convincente, dejaremos la discusion sobre la navaja de Occam para la sesion
destinada a aprendizaje Bayesiano.
10.6. Consideraciones sobre el aprendizaje inductivo de arboles

de decision
Algunas consideraciones sobre la aplicacion practica del algoritmo basico de ID3

presentado aqu, incluyen: mecanismos para determinar que tanto debe crecer el
1 El enunciado exacto de la navaja de Occam es: Non sunt multiplicanda entia prater necessitatem
(las entidades no deben multiplicarse mas alla de lo necesario).
arbol en profundidad; para procesar atributos con valores contnuos; para procesar
ejemplos de entrenamiento con valores faltantes; para introducir costos diferentes
asociados a los atributos; as como para determinar una buena metrica de seleccion
de los atributos y mejorar la eficiencia computacional del algoritmo. Cabe mencio-
nar que, muchos de estos aspectos han sido incorporados en el sistema C4.5 [14].
10.6.1. Evitando un sobreajuste con los datos de entrenamiento
El algoritmo basico de ID3 crece cada rama del arbol en profundidad hasta que
logra clasificar perfectamente los ejemplos de entrenamiento. Esta estrategia es ra-
zonable, pero puede introducir dificultades si los datos de entrenamiento presentan
ruido, o cuando el conjunto de entrenamiento es demasiado pequeno, como para
ofrecer un muestreo significativo del concepto objetivo. En estos casos, ID3 pue-
de producir arboles que se sobreajustan a los datos de entrenamiento. Formalmente
definimos el sobreajuste como:
Definition 10.1. Dado un espacio de hipotesis H, se dice que una hipotsis h H
esta sobreajustada a los ejemplos de entrenamiento, si existe una hipotesis alterna-
tiva h0 H, tal que h0 tiene un error de clasificacion mas pequeno que h sobre la
distribucion completa de los casos del problema.
Es comun observar que a medida que el tamano del arbol crece, en termino del
numero de nodos usado2 , su precision sobre el conjunto de entrenamiento mejora
monotonicamente, pero, sobre el conjunto de prueba primero crece y luego decae.
Como es esto posible que un arbol h que tiene mayor precision que h0 sobre el
conjunto de entrenamiento, luego tenga un desempeno menor sobre el conjunto de
prueba? Una situacion en la que esto ocurre es cuando el conjunto de entremien-
to contiene ruido, por ejemplo, elementos mal clasificados. Consideren agregar el
siguiente caso mal clasificado (clasificado como jugar-tenis? = no) al conjunto de
entrenamiento del cuadro 10.1:
h cielo = soleado,temperatura = caliente, humedad = normal, viento = f uerte i
Al ejecutar ID3 sobre el nuevo conjunto de entrenamiento, este construira un

arbol mas complejo. En partcular, el ejemplo con ruido sera filtrado junto con los
ejemplos d9 y d11 (cielo = soleado y humedad = normal), que son ejemplos positi-
vos. Dado que el nuevo ejemplo es negativo, ID3 buscara refinar el arbol a partir del
nodo humedad, agregando un atributo mas al arbol. Este nuevo arbol h0 tiene ma-
yor precision sobre los ejemplos de entrenamiento que h, puesto que se ha ajustado
al ejemplo con ruido. Pero h tendra mejor desempeno al clasificar nuevos casos,
tomados de una misma distribucion que los ejemplos de entrenamiento.
2Obseven que esto refleja el numero de atributos usado en la hipotesis, esto es, arboles mas grandes
imponen mas restricciones.
Existe la posibilidad de sobreajuste, aun cuando el conjunto de entrenamiento

este libre de ruido, por ejemplo, si el conjunto de entrenamiento tiene pocos ele-
mentos. En conjuntos de entrenamiento pequenos es facil encontrar regularidades
accidentales en donde un atributo puede particionar muy bien los ejemplos dados,
aunque no este relacionado con el concepto objetivo.
Puesto que el sobreajuste puede reducir la precision de un arbol inducido por
ID3 entre un 10 a 25 %, diferentes enfoques han sido propuestos para evitar este
fenomeno. Los enfoques pueden agruparse en dos clases:
Enfoques que detienen el crecimiento del arbol anticipadamente, antes de que
alcance un punto donde clasifique perfectamente los ejemplos de entrenamiento.
Enfoques en donde se deja crecer el arbol para despues podarlo.
Aunque el primer enfoque parezca mas directo, la poda posterior del arbol ha
demostrado tener mas exito en la practica. Esto se debe a la dificultad de estimar
en que momento debe detenerse el crecimiento del arbol. Independientemente del
enfoque usado, una pregunta interesante es: Cual es el tamano correcto de un arbol?
Algunos enfoques para responder a esta pregunta incluyen:
Usar un conjunto de ejemplos, diferentes de los usados en el entrenamiento, para
evaluar la utilidad de eliminar nodos del arbol.
Usar los ejemplos disponibles para el entrenamiento, pero aplicando una prueba
para estimar cuando agregar o eliminar un nodo, podra producir una mejora al
clasificar nuevos casos, por ejemplo, usar el test 2 para evaluar si al expandir un
nodo, el cambio mejorara la clasificacion sobre los ejemplos de entrenamiento, o
sobre toda la distribucion.
Usar explcitamente una medida de complejidad para codificar los ejemplos de
entrenamiento y el arbol de decision, deteniendo el crecimiento cuando el ta-
mano codificado sea minimizado. Por ejemplo, el principio de descripcion mni-
ma (MDL).
10.6.1.1. Reduciendo el error por poda
Como podemos usar un conjunto de ejemplos de validacion para prevenir el

sobre ajuste? Un enfoque llamado reduced-error pruning [?], consiste en considerar
cada nodo del arbol como candidato a ser podado. La poda consiste en eliminar todo
el subarbol que tiene como raz el nodo en cuestion, convirtiendolo as en una hoja,
cuya clase corresponde a valor mas comun de los casos asociados a ese nodo.
Un nodo solo es eliminado si el arbol podado que resulta de ello, no presenta
un desempeno peor que el arbol original sobre el conjunto de validacion. El efecto
de esto, es que los nodos que se han colocado en el arbol por coincidencias fortui-
tas en los datos del entrenamiento, generalmente son eliminados debido a que las
coincidencias suelen no estar presentes en el conjunto de validacion.
Este metodo es unicamente efectivo si contamos con suficientes ejemplos, de tal
forma que el conjunto de entrenamiento y el conjunto de validacion sean significati-
vos estadsticamente. De otra forma, tomar ejemplos para el conjunto de validacion
reduce aun mas el tamano del conjunto de entrenamiento, aumentando as la posibi-

lidad de sobre ajuste.
10.6.1.2. Poda de reglas
En la practica, un metodo exitoso para encontrar el arbol de mayor precision se

conoce como rule post-prunning [14] y esta incorporado en el sistema C4.5 de Ross
Quinlan. El procedimiento es el siguiente:
1. Inducir el arbol de decision permitiendo sobre ajuste, por ejemplo, con nuestro
algoritmo basico ID3.
2. Convertir el arbol aprendido en un conjunto de reglas equivalente, esto es, una
conjuncion por cada rama del arbol que va de la raz a una hoja.
3. Podar (generalizar) cada regla, eliminando las precondiciones que resulten en
una mejora de la precision estimada.
4. Ordenar las reglas por su precision estimada, y aplicarlas en ese orden al clasificar
nuevos casos.
Cabe mencionar que el metodo aplicado por C4.5 no es estadsticamente valido,
aunque ha demostrado ser una heurstica util. En la sesion de evaluacion de hipote-
sis, estudiamos tecnicas estadsticamente robustas para estimar medias e intervalos
de confianza. Lo relevante aqu es que la conversion del arbol en reglas ayuda a dis-
tinguir los diferentes contextos en los que un atributo participa en la clasificacion, es
decir, reglas diferentes; elimina la diferencia entre nodos ubicados cerca de la raz y
aquellos ubicados cerca de las hojas; y aumenta la facilidad de comprehension por
parte del usuario.
10.6.2. Incorporando valores contnuos
En el algoritmo basico de ID3 tanto el concepto objetivo, como los atributos

usados para describir los casos, deben tener valores discretos. La segunda restric-
cion puede ser eliminada facilmente, permitiendo el uso de atributos con valores
contnuos. Esto se logra definiendo dinamicamente nuevos atributos discretos que
particionan los atributos de valores contnuos, en intervalos discretos. Para un atri-
buto contnuo A, el algoritmo puede crear dinamicamente un atributo discreto Ac que
es verdadero si A > c y falso en cualquier otro caso. La unica consideracion es como
seleccionar el mejor valor para el umbral c. Supongan que el atributo temperatura
toma valores discretos y que su relacion con el concepto objetivo es la siguiente:
temperatura 40 48 60 72 80 90
jugar-tenis? No No Si Si Si No
Que valor booleano basado en un umbral debemos definir para el atributo tem-
peratura? Obviamente, necesitamos un umbral c, tal que este produzca la mayor
ganancia de informacion posible. Es posible generar candidatos a umbral, ordenan-

do los ejemplos de acuerdo a su valor en el atributo temperatura e identificando
ejemplos adyacentes que difieren en el valor de su atributo objetivo. Se puede de-
mostrar que los umbrales c que maximiza la ganancia de informacion, se encuentran
en estos sitios. Para el ejemplo presentado, dos umbrales pueden localizarse en los
puntos (48 + 60)/2 y (80 + 90/2). La ganancia de informacion puede entonces cal-
cularse para los atributos temperatura>54 y temperatura>85 . El atributo con mayor
ganancia de informacion, en este caso el primero, puede ser usado entonces para
competir con otros atributos en la construccion del arbol de decision. Por supues-
to, es posible tambien mantener ambos atributos dinamicamente creados, usando
multiples intervalos [?].
10.6.3. Medidas alternativas para la seleccion de atributos
Existe un sesgo natural en la medida de ganancia de informacion, el cual favorece

atributos con muchos valores, sobre aquellos que tienen poco valores. Por ejemplo,
un atributo fecha, tendra mayor ganancia de informacion que cualquiera de los atri-
butos en nuestro ejemplo. Esto se debe a que este atributo predice perfectamente
el valor del atributo objetivo. El problema es que este atributo tiene tantos valores
distintos que tiende a separar perfectamente los ejemplos de entrenamiento en pe-
quenos subconjuntos, que se ajustan al concepto buscado. Por esto, el atributo fecha
tiene una ganancia de informacion elevada, a pesar de ser un predictor pobre.
Una solucion a este problema es usar una metrica alternativa a la ganancia de in-
formacion. Quinlan [?], propone una medida alternativa que ha sido usada con exito,
gain ratio. Esta metrica penaliza atributos como fecha incorporando un termino co-
nocido como split information, que es sensible a que tan amplia y uniforme es la
particion que un atributo induce en los datos:
c
|Si| |Si|
splitIn f ormation(S, A) = log2
i=1 |S| |S|
Observen que este termino es la entropia de S con respecto al atributo A. La
medida gain radio esta definida como:
gain(S, A)
gainRatio(S, A) =
splitIn f ormatio(S, A)
Un problema practico con este enfoque es que el denominador de esta medida
puede ser 0 o muy pequeno, si |Si| |S|, lo cual hace que la medida sea indefinida
para atributos que tienen casi el mismo valor para todos los ejemplos.
10.7. Implementacion el Prolog
Los ejemplos de entrenamiento se definiran mediante el predicado example/3

cuyos argumentos son el numero de ejemplo, el valor para la clase, y los pares atri-
buto valor. Para el ejemplo de jugar tenis, el conjunto de entrenamiento incluira las
siguientes lneas:
1 ejemplo(1,no,[dia=soleado,temperatura=calor,humedad=alta,viento=debil]).
2 ejemplo(2,no,[dia=soleado,temperatura=calor,humedad=alta,viento=fuerte]).
3 ejemplo(3,si,[dia=nublado,temperatura=calor,humedad=alta,viento=debil]).
4 ejemplo(4,si,[dia=lluvia,temperatura=templado,humedad=alta,viento=debil]).
5 ejemplo(5,si,[dia=lluvia,temperatura=frio,humedad=normal,viento=debil]).
6 ejemplo(6,no,[dia=lluvia,temperatura=frio,humedad=normal,viento=fuerte]).
7 ejemplo(7,si,[dia=nublado,temperatura=frio,humedad=normal,viento=fuerte]).
8 ejemplo(8,no,[dia=soleado,temperatura=templado,humedad=alta,viento=fuerte]).
9 ejemplo(9,si,[dia=soleado,temperatura=frio,humedad=normal,viento=debil]).
10 ejemplo(10,si,[dia=lluvia,temperatura=templado,humedad=normal,viento=debil]).
11 ejemplo(11,si,[dia=soleado,temperatura=nublado,humedad=normal,viento=fuerte]).
12 ejemplo(12,si,[dia=nublado,temperatura=templado,humedad=alta,viento=fuerte]).
13 ejemplo(13,si,[dia=nublado,temperatura=calor,humeda=normal,viento=debil]).
14 ejemplo(14,no,[dia=lluvia,temperatura=templado,humedad=alta,viento=fuerte]).
El arbol se representara mediante el predicado nodo/3 cuyo primer elemento

puede ser el identificador de un ejemplo, o la constante ho ja para indicar que hemos
encontrado el valor de la clase. El segundo argumento de nodo es el test que se aplica
para llegar a el. El tercer argumento es el padre del nodo en cuestion. Por ejemplo:
1 nodo(13,(dia=lluvia),raiz).
indica que al ejemplo 13 se llega desde el nodo raiz si el atributo dia tiene como
valor lluvia.
La llamada principal al algoritmo es id3/1 cuyo argumento es el mnimo numero
de casos que debe cubrir una hoja del arbol:
1 id3 :- id3(1). % Umbral = 1, por default.

2
3 id3(Umbral) :-
4 retractall(nodo(_,_,_)),
5 findall(N,ejemplo(N,_,_),E),
6 ejemplo(_,_,L), !,
7 atributos(L,A),
8 idt(E,raiz,A,Umbral), !.
Con la llamada a id3 se borran los nodos construidos anteriormente y se cons-

truye una nueva lista de ejemplos E. Posteriormente se obtiene la lista de atributos
usados en los ejemplos A. El corte es para construir la lista de atributos solo con un
ejemplo (evita el reconsiderar con los demas ejemplos). Y se llama a idt/4 cuyos
argumentos son la lista de ejemplos E, el identificador raiz para el nodo raz del
arbol, la lista de atributos A y el Umbral que por defecto es igual a 1.
10.7 Implementacion el Prolog 135
En la construccion del arbol hay varios casos que cubrir. Comencemos por los
casos terminales. Hay dos casos terminales a considerar, el primero es cuando el
numero de ejemplos disponibles es menor que el Umbral en ese caso se guarda
un nodo ho ja con la distribucion de la clase para los ejemplos como contenido. El
otro caso terminal es cuando todos los ejemplos pertenecen a la misma clase. En
ese caso la distribucion de la clase para los ejemplos tomara la forma [C] donde
C = Clase/NumE js. Estos dos casos corresponde a:
1 idt(E,Padre,_,Umbral) :-
2 length(E,Lon),
3 Lon=<Umbral,
4 distr(E, Distr),
5 assertz(nodo(hoja,Distr,Padre)), !.
6
7 idt(E,Padre,_,_) :-
8 distr(E, [C]),
9 assertz(nodo(hoja,[C],Padre)).
Si no estamos en el caso terminal, es necesario elegir el mejor atributo y parti-

cionar los ejemplos de acuerdo a los valores para el atributo seleccionado:
1 idt(Es,Padre,As,Umbral) :-
2 elige_atributo(Es,As,A,Valores,Resto), !,
3 particion(Valores,A,Es,Padre,Resto,Umbral).
Si esto no es posible, es que los datos son inconsistentes:
1 idt(E,Padre,_,_) :- !,
2 nodo(Padre,Test,_),
3 write(Datos inconsistentes: no es posible construir
4 particion de ),
5 write(E), write( en el nodo ), writeln(Test).
10.7.1. Atributos
Veamos ahora en detalle estos procedimientos. El siguiente procedimiento extrae

los atributos de un ejemplo:
1 atributos([],[]) :- !.
2 atributos([A=_|T],[A|W]) :-
3 atributos(T,W).
De forma que, para el caso de jugar tenis, los atributos se pueden obtener con la
siguiente llamada:
1 ?- ejemplo(_,_,L), !, atributos(L,A).
2 L = [dia=soleado, temperatura=calor, humedad=alta, viento=debil],
3 A = [dia, temperatura, humedad, viento].
10.7.2. Distribucion de clases
Cual es la distribucion inicial de la clase para los ejemplos de jugar tenis? Esto
lo podemos consultar con:
1 ?- findall(E,ejemplo(E,_,_),Ejs), distr(Ejs,Dist).
2 Ejs = [1, 2, 3, 4, 5, 6, 7, 8, 9|...],
3 Dist = [no/5, si/9].
lo que indica que tenemos 5 ejemplos de la clase no y 9 de la clase si. Los ejemplos
1,2,6 y 8 son todos miembros de la clase no, por lo que:
1 ?- distr([1,2,6,8],Dist).
2 Dist = [no/4].
La implementacion de distr/2 es la siguiente:
1 distr(S,Dist) :-
2 setof(C,XL(member(X,S),ejemplo(X,C,L)),Cs),
3 cuentac(Cs,S,Dist).
4
5 cuentac([],_,[]) :- !.
6
7 cuentac([C|L],E,[C/N|T]) :-
8 findall(X,(member(X,E),ejemplo(X,C,_)),W),
9 length(W,N), !,
10 cuentac(L,E,T).
10.7.3. El mejor atributo
El mejor atributo es el que maximiza la ganancia de informacion Gain con res-

pecto a los ejemplos Es y atributos As disponibles. El predicado elige atributo/4
computa los valores posibles para el atributo seleccionado y lo elimina de la lista de
atributos disponibles para construir el arbol:
1 elige_atributo(Es,As,A,Valores,Resto) :-
2 length(Es,LonEs),
3 contenido_informacion(Es,LonEs,I), !,
4 findall((A-Valores)/Gain,
5 (member(A,As),
6 valores(Es,A,[],Valores),
7 separa_en_subconjs(Valores,Es,A,Ess),
8 informacion_residual(Ess,LonEs,R),
9 Gain is I - R),
10 All),
11 maximo(All,(A-Valores)/_),
12 eliminar(A,As,Resto), !.
13
14 separa_en_subconjs([],_,_,[]) :- !.
15 separa_en_subconjs([V|Vs],Es,A,[Ei|Resto]) :-
16 subconj(Es,A=V,Ei), !,
17 separa_en_subconjs(Vs,Es,A,Resto).
18
19 informacion_residual([],_,0) :- !.
20 informacion_residual([Ei|Es],Lon,Res) :-
21 length(Ei,LonEi),
22 contenido_informacion(Ei,LonEi,I), !,
23 informacion_residual(Es,Lon,R),
24 Res is R + I*LonEi/Lon.
25
26 contenido_informacion(Es,Lon,I) :-
27 setof(C,EL(member(E,Es),ejemplo(E,C,L)),Classes), !,
28 suma_terms(Classes,Es,Lon,I).
29
30 suma_terms([],_,_,0) :- !.
31 suma_terms([C|Cs],Es,Lon,Info) :-
32 findall(E,(member(E,Es),ejemplo(E,C,_)),InC),
33 length(InC,N),
34 suma_terms(Cs,Es,Lon,I),
35 Info is I - (N/Lon)*(log(N/Lon)/log(2)).
36
37 valores([],_,Valores,Valores) :- !.
38 valores([E|Es],A,Vs,Valores) :-
39 ejemplo(E,_,L),
40 member(A=V,L), !,
41 (member(V,Vs), !, valores(Es,A,Vs,Valores);
42 valores(Es,A,[V|Vs],Valores)
43 ).
44
45 subconj([],_,[]) :- !.
46 subconj([E|Es],A,[E|W]) :-
47 ejemplo(E,_,L),
48 member(A,L), !,
49 subconj(Es,A,W).
50 subconj([_|Es],A,W) :- subconj(Es,A,W).
Por ejemplo, la siguiente meta computa el mejor atributo (dia), dados los ejem-
plos E y atributos conocidos:
?- findall(N,ejemplo(N,_,_),E), elige_atributo(E,[dia,temperatura,humedad,
viento],A,V,R).
E = [1, 2, 3, 4, 5, 6, 7, 8, 9|...],
A = dia,
V = [lluvia, nublado, soleado],
R = [temperatura, humedad, viento].
Como vimos en la primera parte de este captulo, para computar la ganancia de

informacion necesitamos computar el contenido informacional de todos los ejem-
plos:
?- findall(N,ejemplo(N,_,_),E), length(E,L), contenido_informacion(E,L,I).

E = [1, 2, 3, 4, 5, 6, 7, 8, 9|...],
L = 14,
I = 0.940286.
Y por cada atributo, computar la informacion residual para restarsela al contenido

informacional, y as obtener las ganancias de informacion:
?- findall(N,ejemplo(N,_,_),E),
findall((A-Valores)/Gain,
(member(A,[dia,temperatura,humedad,viento]),
valores(E,A,[],Valores),
separa_en_subconjs(Valores,E,A,Ess),
informacion_residual(Ess,14,R),
Gain is 0.940286 - R),
All).
E = [1, 2, 3, 4, 5, 6, 7, 8, 9|...],
All = [ (dia-[lluvia, nublado, soleado])/0.24675,
(temperatura-[nublado, frio, templado, calor])/0.0760099,
(viento-[fuerte, debil])/0.151836 ].
Solo resta obtener el atributo de All con la maxima ganancia de informacion y

eliminarlo de la lista de atributos disponibles regresada en Resto. La induccion del
arbol de decision es un proceso recursivo. Los valores del atributo elegido inducen
una particion sobre los ejemplos. Esto se logra con el predicado particion/6.
1 particion([],_,_,_,_,_) :- !.
2 particion([V|Vs],A,Es,Padre,Resto,Umbral) :-
3 subconj(Es,A=V,Ei), !,
4 genera_nodo_id(Nodo),
5 assertz(nodo(Nodo,A=V,Padre)),
6 idt(Ei,Nodo,Resto,Umbral), !,
7 particion(Vs,A,Es,Padre,Resto,Umbral).
10.7.4. El arbol
El arbol se guarda en la memoria de trabajo como un conjunto de nodos con la

forma nodo(Identi f icador, Atributo Valor, NodoPadre). Se pueden recuperar con
la siguiente meta:
?- nodo(I,AV,P).
I = 1,
AV = (dia=lluvia),
P = raiz ;
I = 2,
AV = (viento=fuerte),
P = 1 ;
I = hoja,
AV = [no/2],
P = 2 ;
I = 3,
AV = (viento=debil),
P = 1 ;
I = hoja,
AV = [si/3],
P = 3 ;
I = 4,
AV = (dia=nublado),
P = raiz ;
I = hoja,
AV = [si/4],
P = 4 ;
I = 5,
AV = (dia=soleado),
P = raiz ;
I = 6,
AV = (humedad=normal),
P = 5 ;
I = hoja,
AV = [si/2],
P = 6 ;
I = 7,
AV = (humedad=alta),
P = 5 ;
I = hoja,
AV = [no/3],
P = 7.
10.7.5. Imprimiendo el arbol construido.
Para imprimir el arbol construido de una manera legible definimos:
1 imprime_arbol :-
2 imprime_arbol(raiz,0).
3
4 imprime_arbol(Padre,_) :-
5 nodo(hoja,Class,Padre), !,
6 write( => ),write(Class).
7 imprime_arbol(Padre,Pos) :-
8 findall(Son,nodo(Son,_,Padre),L),
9 Pos1 is Pos+2,
10 imprime_lista(L,Pos1).
11
12 imprime_lista([],_) :- !.
13
14 imprime_lista([N|T],Pos) :-
15 node(N,Test,_),
16 nl, tab(Pos), write(Test),
17 imprime_arbol(N,Pos),
18 imprime_lista(T,Pos).
10.7.6. Ejecutando todo el experimento
As la sesion para construir el arbol de decision para jugar tenis es (con id3.pl
ya cargado en Prolog):
?- [test3].
% test3 compiled 0.00 sec, 3,896 bytes
true.
?- id3.
true.
?- imprime_arbol.
dia=lluvia
viento=fuerte => [no/2]
viento=debil => [si/3]
dia=nublado => [si/4]
dia=soleado
humedad=normal => [si/2]
humedad=alta => [no/3]
true.
10.7.7. Predicados auxiliares
Algunos predicados auxiliares incluyen:
1 genera_nodo_id(M) :-
2 retract(id(N)),
3 M is N+1,
4 assert(id(M)), !.
5
6 genera_nodo_id(1) :-
7 assert(id(1)).
8
9 eliminar(X,[X|T],T) :- !.
10
11 eliminar(X,[Y|T],[Y|Z]) :-
12 eliminar(X,T,Z).
13
14 subconjunto([],_) :- !.
15
16 subconjunto([X|T],L) :-
17 member(X,L), !,
18 subconjunto(T,L).
19
20 maximo([X],X) :- !.
21 maximo([X/M|T],Y/N) :-
22 maximo(T,Z/K),
23 (M>K,Y/N=X/M ; Y/N=Z/K), !.
Captulo 11
Planeacion
Resumen La planeacion es un tema de interes tradicional en Inteligencia Artificial,

que involucra razonar acerca de los efectos de las acciones y la secuencia en que
estas se aplican para lograr un efecto acumulativo dado. En esta sesion desarrolla-
remos planificadores simples para ilustrar los principios de la planeacion.
11.1. Acciones
Cada accion posible es definida en terminos de su condicion y sus efectos, es-

pecficamente:
Condicion. La condicion que debe satisfacerse para la accion pueda ejecutarse.

Agregar. Es una lista de cambios que se espera ocurran despues de ejecutarse la
accion.
Quitar. Es una lista de observaciones que se espera dejen de ser verdaderas des-
pues de ejecutarse la accion.
Las condiciones, pueden definirse por un procedimiento
1 cond(Acc,Cond).
Los efectos de una accion pueden definirse de manera similar, por dos procedi-
mientos:
1 add(Acc,ListaAdd).
2 del(Acc,ListaDel).
donde ListaAdd y ListaDel corresponden a las listas definidas para agregar y borrar.
Asumamos que vamos a realizar la planeacion en el dominio del mundo de los
bloques. As que la unica accion posible sera:
143
144 11 Planeacion
1 mover(Bloque,De,A).
La definicion completa de esta accion es como sigue:
1 precond( mover( Bloque, De, A),

2 [ despejado( Bloque), despejado( A),
3 en( Bloque, De)] ) :-
4 bloque( Bloque),
5 objeto( A),
6 A \== Bloque,
7 objeto( De),
8 De \== A,
9 Bloque \== De.
10
11 agregar( mover(X,De,A), [ en(X,A), despejado(De)]).
12
13 borrar( mover(X,De,A), [ en(X,De), despejado(A)]).
De manera que para poder mover un bloque Bloque de la posicion De a la posi-

cion A, es necesario que el bloque Bloque y la posicion A esten despejados, lo mismo
que el bloque Bloque este en la posicion De. El resto del procedimiento cond/2 es-
tablece restricciones extras: que Bloque sea un bloque, y A y De sean objetos en el
universo de discurso; que A sea diferente de Bloque (no mover el bloque sobre si
mismo); que se debe mover el bloque a una nueva posicion (A es diferente de De);
y no mover el bloque de s mismo (Bloque es diferente de De). Las definiciones de
add/2 y del/2 completan la especificacion de mover/3.
Las siguientes definiciones especifican un escenario en el mundo de los bloques:
1 objeto( X) :-
2 lugar( X)
3 ;
4 bloque( X).
5
6 bloque( a).
7 bloque( b).
8 bloque( c).
9
10 lugar( 1).
11 lugar( 2).
12 lugar( 3).
13 lugar( 4).
14
15 estado1( [ despejado(2), despejado(4), despejado(b),
16 despejado(c), en(a,1), en(b,3), en(c,a) ] ).
17
18 metas1([en(a, b)]).
11.2 Analisis medios-fines 145
Tal definicion de las acciones, establece tambien el espacio de planes posibles,

por lo que se le conoce como espacio de planeacion. Las metas del planeador se
definen en terminos de una lista de observaciones que se deben cumplir.
Ahora veremos como a partir de esta representacion, es posible derivar los planes
mediante un procedimiento conocido como analisis medios-fines.
11.2. Analisis medios-fines
Consideremos que el mundo de los bloques se encuentra en el estado inicial

especificado anteriormente (estado1). Sea la meta del planeador en(a, b). El trabajo
del planeador consiste en encontrar una secuencia de acciones que satisfagan esta
meta. Un planeador tpico razonara de la siguiente forma:
1. Encontrar una accion que satisfaga en(a, b). Al buscar en la relacion add, en-
contramos que tal accion es de la forma mover(a, De, b) a partir de cualquier
De. Tal accion debera formar parte de nuestro plan, pero no podemos ejecutarla
inmediatamente dado nuestro estado inicial.
2. Hacer posible la accion mover(a, De, b). Al buscar en la relacion cond encontra-
mos que la condicion para ejecutar esta accion es:
1 [ despejado(a), despejado(b), en(a,De) ]
en el estado inicial tenemos que despe jado(b) y que en(a, De) para De/1; pero
no que despe jado(a), as que el planeador se concentra en esta formula como su
nueva meta.
3. Volvemos a buscar en la relacion add para encontrar una accion que satisfaga
despe jado(a). Tal accion tiene la forma mover(Bloque, a, A). La condicion para
ejecutar esta accion es:
1 [despejado(Bloque), despeado(A), en(Bloque,a) ]
la cual se satisface en nuestro estado inicial para Boque/c y A/2. De forma que
mover(c, a, 2) puede ejecutarse en el estado inicial, modificando el estado del
problema de la siguiente manera:
Eliminar del estado inicial las relaciones que la accion borra.
Incluir las relaciones que la accion agrega al estado inicial del problema.
esto produce la lista:
1 [ despejado(a), despejado(b), despejado(c), despejado(4),

2 en(a,1), en(b,3), en(c,2) ]
4. Ahora podemos ejecutar la accion mover(a, 1, b), con lo que la meta plantada se
satisface. El plan encontrado es:
146 11 Planeacion
1 [ mover(c,a,2), mover(a,1,b) ]
Este estilo de razonamiento se conoce como analisis medios-fines. Observen que

el ejemplo planteado el plan se encontro directamente, sin necesidad de reconside-
rar. Esto ilustra como el proceso de razonar sobre el efecto de las acciones y las me-
tas guan la planeacion en una direccion adecuada. Desafortunadamente, no siempre
se puede evitar reconsiderar. De hecho, la explosion combinatoria y la busqueda son
tpicas en la planeacion.
El principio de planeacion por analisis medios-fines se ilustra en la figura 11.1.
Puede plantearse como sigue: Para resolver una lista de metas Metas en un estado
Estado, que lleven a un estado Estado final, hacer:
Si todas las Metas son verdaderas en Estado, entonces Estado final = Estado. En
cualquier otro caso:
1. Seleccionar una Meta no solucionada en Metas.
2. Encontrar una Accion que agregue Meta al estado actual.
3. Hacer posible Accion resolviendo Condicion para obtener el estado inter 1.
4. Aplicar la Accion en el estado inter 1 para obtener el estado inter 2 donde Meta
se cumple.
5. Resolver Metas en el estado inter 2 para llegar a Estado final.
Condicin Meta Metas
prePlan Accin postPlan
Estado Estado Estado Estado

inter 1 inter 2 final
Figura 11.1 Analisis medios-fines
El codigo del planeador medios fines es como sigue:
1 plan( Estado, Metas, [], Estado) :-

2 satisfecho( Estado, Metas).
3
4 plan( Estado, Metas, Plan, EstadoFinal) :-
5 append( PrePlan, [Accion | PostPlan], Plan),
6 seleccionar( Estado, Metas, Meta),
7 lograr( Accion, Meta),
8 precond( Accion, Condicion),
9 plan( Estado, Condicion, PrePlan, EstadoInter1),
10 aplicar( EstadoInter1, Accion, EstadoInter2),
11 plan( EstadoInter2, Metas, PostPlan, EstadoFinal).
12
11.3 Metas protegidas 147
13 satisfecho( _, []).
14
15 satisfecho( Estado, [Meta | Metas]) :-
16 member( Meta, Estado),
17 satisfecho( Estado, Metas).
18
19 seleccionar( Estado, Metas, Meta) :-

20 member( Meta, Metas),
21 not(member( Meta, Estado)).
22
23 lograr( Accion, Meta) :-
24 agregar( Accion, Metas),
25 member( Meta, Metas).
26
27 aplicar( Estado, Accion, NewEstado) :-

28 borrar( Accion, ListaBorrar),
29 borrar_todos( Estado, ListaBorrar, Estado1), !,
30 agregar( Accion, ListaAgregar),
31 append( ListaAgregar, Estado1, NewEstado).
32
33 borrar_todos( [], _, []).

34
35 borrar_todos( [X | L1], L2, Diff) :-

36 member( X, L2), !,
37 borrar_todos( L1, L2, Diff).
38
39 borrar_todos( [X | L1], L2, [X | Diff]) :-

Para invocar al planeador, ejecutamos en Prolog la siguiente meta:
1 ?- estado1(E), metas1(M), plan(E,M,P,Efinal).

2 E = [despejado(2), despejado(4), despejado(b),
3 despejado(c), en(a, 1), en(b, 3), en(c, a)],
4 M = [en(a, b)],
5 P = [mover(c, a, 2), mover(a, 1, b)],
6 Efinal = [en(a, b), despejado(1), en(c, 2), despejado(a),
7 despejado(4), despejado(c), en(b, 3)]
11.3. Metas protegidas
Consideren ahora la siguiente llamada a plan/4:
1 ?- estado1(E), plan(E,[en(a,b),en(b,c)],Plan,_).
4 Plan = [mover(b, 3, c),
5 mover(b, c, 3),
148 11 Planeacion
6 mover(c, a, 2),
7 mover(a, 1, b),
8 mover(a, b, 1),
9 mover(b, 3, c),
10 mover(a, 1, b)]
Aunque el plan resultante cumple con su cometido, no es precisamente elegante.

De hecho, existe un plan de tres movimientos para lograr las metas de este caso! Esto
se debe a que el mundo de los bloques es mas complejo de lo que parece, debido a
la combinatoria. En este problema, el planeador tiene acceso a mas opciones entre
diferentes acciones que tienen sentido bajo el analisis medios-fines. Mas opciones,
significa mayor complejidad combinatoria.
Regresemos al ejemplo, lo que sucede es que el planeador persigue diferentes
metas en diferentes etapas de la construccion del plan. Por ejemplo:
mover(b, 3, c) satisfacer en(b, c)

mover(b, c, 3) satisfacer clear(c) y ejecutar siguiente accion
mover(c, a, 2) satisfacer clear(a) y mover(a, 1, b)
mover(a, 1, b) satisfacer on(a, b)
mover(a, b, 1) satisfacer clear(b) y mover(b, 3, c)
mover(b, 3, c) satisfacer en(b, c) otra vez
mover(a, 1, b) satisfacer en(a, b) otra vez
Lo que esta tabla muestra es que a veces el planeador destruye metas que ya haba
satisfecho. El planeador logra facilmente satisfacer una de las dos metas planteadas,
en(b, c) pero la destruye al buscar como satisfacer la otra meta en(a, b). Lo peor
es que esta forma desorganizada de seleccionar las metas, puede incluso llevar al
fracaso en la busqueda del plan, como en el siguiente ejemplo:
1 ?- estado1(E), plan(E,[despejado(2), despejado(3)], Plan, _).

2 ERROR: Out of local stack
Hagan un trace de esta corrida, para saber porque la meta falla.

Una idea evidente para evitar este comportamiento en nuestro planeador, es man-
tener una lista de metas protegidas, de forma que las acciones que destruyen estas
metas no puedan ser seleccionadas. De forma que el planeador medios-fines con
metas protegidas se define como:
1 plan_metas_protegidas(EstadoInicial,Metas,Plan,EstadoFinal):-
2 plan_mp(EstadoInicial,Metas,[],Plan,EstadoFinal).
3
4 plan_mp(Estado,Metas,_,[],Estado) :-
5 satisfecho(Estado,Metas).
6
7 plan_mp(Estado,Metas,Protegido,Plan,EstadoFinal) :-
11.4 Aspectos procedimentales de la busqueda en amplitud 149

12 preservar(Accion,Protegido),
13 plan_mp( Estado, Condicion, Protegido, PrePlan,
14 EstadoInter1),
16 plan_mp( EstadoInter2, Metas, [Meta|Protegido],
17 PostPlan, EstadoFinal).
18
19 preservar(Accion,Metas) :-
20 borrar(Accion,ListaBorrar),
21 not( (member(Meta,ListaBorrar),
22 member(Meta,Metas))).
De forma que si ejecutamos la consulta:
1 ?- estado1(E), plan_metas_protegidas(E,[despejado(2),
2 despejado(3)], P, _).
5 P = [mover(b, 3, 2), mover(b, 2, 4)]
obtenemos una solucion, aunque sigue sin ser la mejor. Un solo movimiento mover(b, 2, 4)
era necesario para cumplir con las metas planeadas.
Los planes innecesariamente largos son resultado de la estrategia de busqueda
usada por nuestro planeador.
11.4. Aspectos procedimentales de la busqueda en amplitud
Los planeadores implementados usan esencialmente una estrategia de busqueda

primero en profundidad, pero no por completo. Para poder estudiar lo que esta pa-
sando, debemos poner atencion al orden en que se generan los planes candidatos.
La meta
1 append(PrePlan, [Accion|PostPlan], Plan)
es central en este aspecto. La variable Plan no esta instanciada cuando esta meta es
alcanzada. El predicado append/3 genera al reconsiderar, candidatos alternativos
para PrePlan en el siguiente orden:
1 PrePlan = [];
2 PrePlan = [_];
3 PrePlan = [_,_];
4 PrePlan = [_,_,_];
5 ...
150 11 Planeacion
Candidatos cortos para PrePlan son los primeros. PrePlan establece una con-
dicion para Accion. Esto permite encontrar una accion cuya condicion puede sa-
tisfacerse por un plan tan corto como sea posible (simulando busqueda primero en
amplitud). Por otra parte, la lista candidato para PostPlan esta totalmente no ins-
tanciada, y por tanto su longitud es ilimitada. Por tanto, la estrategia de busqueda
resultante es globalmente primero en profundidad, y localmente primero en ampli-
tud. Con respecto al encadenamiento haca adelante de las acciones que se agregan
al plan emergente, se trata de una busqueda primero en profundidad. Cada accion es
validada por un PrePlan, este plan es por otra parte, buscado primero en amplitud.
Una forma de minimizar la longitud de los planes es forzar al planeador, en su
parte de busqueda en amplitud, de forma que los planes cortos sean considerados
antes que los largos. Podemos imponer esta estrategia embebiendo nuestro plani-
ficador en un procedimiento que genere planes candidatos ordenados por tamano
creciente. Por ejemplo:
1 plan_primero_amplitud(Estado, Metas, Plan, EstadoFinal) :-

2 candidato(Plan),
3 plan(Estado,Metas,Plan,EstadoFinal).
4
5
6 candidato([]).
7
8 candidato([Primero|Resto]) :-
9 candidato(Resto).
El mismo efecto puede lograrse de manera mas elegante, insertando el generador

de planes directamente en el procedimiento plan/4 de forma que:
1 plan_metas_protegidas_amplitud(EstadoInicial,Metas,Plan,
2 EstadoFinal):-
3 plan_mp_amplitud(EstadoInicial,Metas,[],Plan,
4 EstadoFinal).
5
6 plan_mp_amplitud(Estado,Metas,_,[],Estado) :-
8
9 plan_mp_amplitud(Estado,Metas,Protegido,Plan,EstadoFinal) :-
10 append(Plan,_,_),
15 preservar(Accion,Protegido),
16 plan_mp_amplitud( Estado, Condicion, Protegido, PrePlan,
17 EstadoInter1),
19 plan_mp_amplitud( EstadoInter2, Metas, [Meta|Protegido],
20 PostPlan, EstadoFinal).
11.4 Aspectos procedimentales de la busqueda en amplitud 151
Y por tanto podemos volver a computar la meta original, encontrando esta vez el
plan mas corto:
1 ?- estado1(E),
2 plan_metas_protegidas_amplitud(E,[despejado(2),
3 despejado(3)], Plan,_).
6 Plan = [mover(b, 3, 4)]
Este resultado es optimo, sin embargo la meta:
1 ?- estado1(E),
2 plan_metas_protegidas_amplitud(E,[en(a,b), en(b,c)], Plan, _).
5 Plan = [mover(c, a, 2),
6 mover(b, 3, a),
7 mover(b, a, c),
8 mover(a, 1, b)]
sigue siendo problematica. Este resultado se obtiene con y sin proteccion de me-
tas siguiendo la estrategia primero en amplitud. El segundo movimiento del plan
parece superfluo y aparentemente no tiene sentido. Investiguemos porque se le in-
cluye en el plan y porque aun en el caso de la busqueda primero en amplitud, el plan
resultante esta lejos del optimo.
Dos preguntas son interesantes en este problema: Que razones encuentra el pla-
neador para construir este curioso plan? y Por que el planeador no encuentra el plan
optimo e incluye la accion mover(b, 3, a)? Atendamos la primer pregunta. La ultima
accion mover(a, 1, b) atiende la meta en(a, b). Los tres primeros movimientos estan
al servicio de cumplir las condiciones de esta accion, en particular la condicion
despe jado(a). El tercer movimiento despeja a y una condicion de este movimiento
es en(b, a). Esto se cumple gracias al curioso segundo movimiento mover(b, 3, a).
Esto ilustra la clase de exoticos planes que pueden emerger durante un razonamiento
medios-fines.
Con respecto a la segunda pregunta, Por que despues de mover(c, a, 2), el pla-
neador no considera inmediatamente mover(b, 3, c), lo que conduce a un plan opti-
mo? La razon es que el planeador estaba trabajando en la meta en(a, b) todo el
tiempo. La accion que nos interesa es totalmente superflua para esta meta, y por lo
tanto no es considerada. La cuarta accion logra en(a, b) y por pura suerte en(b, c)!
Este ultimo resultado no es una decision planeada de nuestro sistema.
De lo anterior se sigue, que el procedimiento medios-fines, tal y como lo he-
mos implementado es incompleto, no sugiere todas las acciones relevantes para el
proceso de planificacion. Esto se debe a la localidad con que se computan las so-
luciones. Solo se sugeriran acciones relevantes para la meta actual del sistema. La
solucion al problema esta en este enunciado: se debe permitir la interaccion entre
metas en el proceso de planificacion. Antes de pasar al siguiente tema, consideren
152 11 Planeacion
que al introducir la estrategia primero en amplitud para buscar planes mas cortos,
hemos elevando considerablemente el tiempo de computacion necesario para hallar
una solucion.
11.5. Regresion de metas
Supongan que estamos interesados en una lista de metas Metas que se cumplen
en cierto estado E. Sea el estado anterior a E, E0 y la accion ejecutada en E0 , A.
Que metas Metas0 tienen que cumplirse en E0 para que Metas se cumpla en E?
Metas0 debe tener las siguientes propiedades:
1. La accion A debe ser posible en E0 , por lo que Metas0 debe implicar la condicion
para A.
2. Para cada meta M en Metas, se cumple que:
la accion A agrega M; o
M Metas0 y A no borra M.
El computo para determinar Metas0 a partir de Metas y la accion A se conoce

como regresion de metas. Por supuesto, solo estamos interesados en aquellas accio-
nes que agregan alguna meta M a Metas. Las relaciones entre varios conjuntos de
metas y condiciones se ilustra en la figura 11.2
Figura 11.2 Relaciones entre conjuntos de condiciones en la regresion de metas va la accion A. El

area sombreada representa las metas Metas0 resultado de la regresion. Observen que la interseccion
entre Metas y la lista borrar de A debe ser vaca.
El mecanismo de regresion de metas puede usarse como planeador de la siguiente

manera. Para satisfacer una lista de metas Metas a partir de un estado EstadoInicial,
hacer: Si Metas se cumple en EstadoInicial, entonces el plan vaco es suficiente; en
cualquier otro caso, seleccionar una meta M Metas y una accion A que agregue
11.5 Regresion de metas 153
M; entonces computar la regresion de Metas va A obteniendo as NuevasMetas y

buscar un plan para satisfacer NuevasMetas desde EstadoInicial.
El procedimiento puede mejorarse si observamos que algunas combinaciones de
metas son imposibles. Por ejemplo en(a, b) y despe jado(b) no pueden satisfacerse
al mismo tiempo. Esto se puede formular va la relacion:
1 imposible(Meta,Metas).
que indica que la Meta es imposible en combinacion con las Metas. Para el caso del
mundo de los bloques la incompatibilidad entre las metas se define como:
1 imposible(en(X,X),_).
2
3 imposible(en(X,Y), Metas) :-
4 member(despejado(Y),Metas)
5 ;
6 member(en(X,Y1),Metas), Y1 \== Y
7 ;
8 member(en(X1,Y),Metas) X1 \== X.
9
10 imposible(despejado(X),Metas) :-
11 member(en(_,X),Metas).
El resto del planeador es como sigue:
1 plan(Estado, Metas, []) :-

2 satisfecho(Estado, Metas).
3
4 plan(Estado, Metas, Plan) :-

5 append( PrePlan, [Accion], Plan),
7 lograr(Accion, Meta),
8 precond(Accion, Condicion),
9 preservar(Accion, Metas),
10 regresion(Metas, Accion, MetasReg),
11 plan(Estado, MetasReg, PrePlan).
12
13 satisfecho(Estado, Metas) :-
14 borrar_todos(Metas,Estado,[]).
15
16 seleccionar(_, Metas, Meta) :-
18
19 lograr( Accion, Meta) :-
20 agregar( Accion, Metas),
22
23 borrar_todos( [], _, []).

24
25 borrar_todos( [X | L1], L2, Diff) :-

26 member( X, L2), !,
154 11 Planeacion

28
29 borrar_todos( [X | L1], L2, [X | Diff]) :-
31
32 preservar(Accion,Metas) :-
33 borrar(Accion,ListaBorrar),
34 not( (member(Meta,ListaBorrar),
35 member(Meta,Metas))).
36
37 regresion(Metas, Accion, MetasReg) :-
38 agregar(Accion, NuevasRels),
39 borrar_todos(Metas, NuevasRels, RestoMetas),
40 precond(Accion, Condicion),
41 agregarNuevo(Condicion,RestoMetas,MetasReg).
42
43 agregarNuevo([],L,L).
44
45 agregarNuevo([Meta|_],Metas,_) :-
46 imposible(Meta,Metas),
47 !,
48 fail.
49
50 agregarNuevo([X|L1],L2,L3) :-
51 member(X,L2), !,
52 agregarNuevo(L1,L2,L3).
53
54 agregarNuevo([X|L1],L2,[X|L3]) :-
55 agregarNuevo(L1,L2,L3).
Ahora es posible encontrar el plan optimo de tres movimientos para el problema

del mundo de los bloques:
1 ?- estado1(E), plan(E,[en(a,b),en(b,c)],P).
4 P = [mover(c, a, 2), mover(b, 3, c), mover(a, 1, b)]
11.6. Combinando planeacion medios fines con primero el

mejor
Los planeadores construidos hasta ahora hacen uso de estrategias de busqueda

basicas: primero en profundidad, o primero en amplitud, o una combinacion de am-
bas. Estas estrategias son totalmente desinformadas, en el sentido que no pueden
usar informacion del dominio del problema para guiar su seleccion entre alternati-
vas posibles. En consecuencia, estos planeadores son sumamente ineficientes, salvo
en casos muy especiales. Existen diversas maneras de introducir una gua heurstica,
11.6 Combinando planeacion medios fines con primero el mejor 155
basada en el dominio del problema, en nuestros planeadores. Algunos lugares donde

esto puede hacerse son:
En la relacion seleccionar(Estado, Metas, Meta) que decide el orden en que las
metas seran procesadas. Por ejemplo, una gua en el mundo de los bloques es que
las torres deben estar bien cimentadas, de forma que la relacion en/2 mas arriba
de la torre, debera resolverse al ultimo (o primero en el planeador por regresion,
que soluciona el plan en orden inverso). Otra gua es que las metas que ya se
cumplen en el medio ambiente, deberan postergarse.
En la relacion lograr(Accion, Meta) que decide que accion alternativa sera inten-
tada para lograr una meta dada. Observen que nuestro planeador tambien genera
alternativas al procesar precond/2. Por ejemplo, algunas acciones son mejo-
res porque satisfacen mas de una meta simultaneamente. Tambien, con base en
la experiencia, podemos saber que cierta condicion es mas facil de satisfacer que
otras.
Decisiones acerca de que conjunto de regresion de metas debe considerarse a
continuacion. Por ejemplo, seguir trabajando en el que parezca mas facil de re-
solver, buscando as el plan mas corto.
Esta ultima idea muestra como podemos imponer una estrategia primero el mejor
en nuestro planeador. Esto implica computar un estimado heurstico de la dificultad
de conjuntos de regresion de metas alternativos, para expandir el mas promisorio.
Recuerden que para usar este tipo de estrategia es necesario especificar:
1. Una relacion s/3 entre nodos del espacio de busqueda: s(Nodo1 , Nodo2 ,Costo).
2. Los nodos meta en el espacio: meta(Nodo).
3. Una funcion heurstica de la forma h(Nodo, Hestimado).
4. El nodo inicial de la busqueda.
Una forma de definir estos requisitos es asumir que los conjuntos de regresion
de metas son nodos en el espacio de busqueda. Esto es, en el espacio de busqueda
hara una liga entre Metas1 y Metas2 si existe una accion A tal que:
1. A agrega alguna meta Metas1 .
2. A no destruye ninguna meta Metas1
3. Metas2 es el resultado de la regresion de Metas1 a traves de A, tal y como defi-
nimos en nuestro planeador anterior: regresion(Metas1 , A, Metas2 ).
Por simplicidad, asumiremos que todas las acciones tienen el mismo costo, y en
consecuencia asignaremos Costo = 1 en todas las ligas del espacio de busqueda. Por
lo que la relacion s/3 se define como:
1 s(Metas1,Metas2) :-
2 member(Meta,Metas1),
3 lograr(Accion,Meta),
4 precond(Accion,Cond),
5 preservar(Accion,Metas1),
6 regresion(Metas1,Accion,Metas2).
156 11 Planeacion
Cualquier conjunto de metas que sea verdadero en la situacion inicial de un plan,

es un nodo meta en el espacio de busqueda. El nodo inicial de la busqueda es la lista
de metas que el plan debe lograr.
Aunque la representacion anterior tiene todos los elementos requeridos, tiene un
pequeno defecto. Esto se debe a que nuestra busqueda primero el mejor encuentra
un camino solucion como una secuencia de estados y no incluye acciones entre los
estados. Por ejemplo, la secuencia de estados (listas de metas) para logra en(a, b) en
el estado inicial que hemos estado usando es:
1 [ [despejado(c), despejado(2), en(c,a), despejado(b), en(a,1)]

2 [despejado(a), despejado(b), en(a,1)]
3 [en(a,b)] ]
El primer estado es verdadero por la situacion inicial, el segundo es resultado de

la accion mover(c, a, 2) y el tercero es resultado de la accion mover(a, 1, b).
Observen que la busqueda primero el mejor regresa el camino solucion en el
orden inverso. En nuestro caso es una ventaja, porque los planes son construidos en
la regresion haca atras, as que al final obtendremos la secuencia de acciones en
el orden correcto. Sin embargo, es raro no tener mencion explcita a las acciones
en el plan, aunque puedan reconstruirse de las diferencias entre listas de metas.
Podemos incluir las acciones en el camino solucion facilmente, basta con agregar
a cada estado la accion que se sigue de el. De forma que los nodos del espacio de
busqueda tendran la forma:
1 Metas -> Accion
Su implementacion detallada es la siguiente:
1 :- op(300,xfy, ->).
2
3 s(Metas -> AccSiguiente,MetasNuevas -> Accion, 1) :-
4 member(Meta,Metas),
5 lograr(Accion,Meta),
6 precond(Accion,Cond),
7 preservar(Accion,Metas),
8 regresion(Metas,Accion,MetasNuevas).
9
10 meta(Metas -> Accion) :-

11 inicio(Estado),
13
14 h(Metas -> Accion,H) :-
15 inicio(Estado),
16 borrar_todos(Metas,Estado,Insatisfecho),
17 length(Instatisfecho,H).
18
19 inicio([en(a,1),en(b,3),en(c,a),despejado(b),despejado(c),
20 despejado(2),despejado(4)]).
11.6 Combinando planeacion medios fines con primero el mejor 157
Ahora podemos usar nuestro viejo buscador primero el mejor:
1 primeroMejor(Inicio,Solucion) :-
2 expandir([],hoja(Inicio,0/0),9999,_,si,Solucion).
3
5 %% % expandir(Camino,Arbol,Umbral,Arbol1,Solucionado,Solucion)
6 %% % Camino es el recorrido entre Inicio y el nodo en Arbol
7 %% % Arbol1 es Arbol expandido bajo el Umbral
8 %% % Si la meta se encuentra, Solucion guarda el camino
solucion
9 %% % y Solucionado = si
10
11 % Caso 1: la hoja con Nodo es una meta, construye una solucion

12
13 expandir(Camino,hoja(Nodo,_),_,_,si,[Nodo|Camino]) :-
14 meta(Nodo).
15
16 % Caso 2: una hoja con f-valor menor o igual al Umbral
17 % Generar succesores de Nodo y expandirlos bajo el Umbral
18
19 expandir(Camino,hoja(Nodo,F/G),Umbral,Arbol1,Solucionado,Sol) :-
20 F =< Umbral,
21 (bagof( M/C,(s(Nodo,M,C),not(member(M,Camino))),Succ),
22 !, % Nodo tiene sucesores
23 listaSuccs(G,Succ,As), % Encontras subarboles As
24 mejorF(As,F1), % f-value of best successor
25 expandir(Camino,arbol(Nodo,F1/G,As),Umbral,Arbol1,
26 Solucionado,Sol)
27 ;
28 Solucionado = nunca % Nodo no tiene sucesores
29 ).
30
31 % Caso 3: Nodo interno con f-valor menor al Umbral

32 % Expandir el subarbol mas promisorio con cuyo
33 % resultado, continuar/7 decidira como proceder
34
35 expandir(Camino,arbol(Nodo,F/G,[A|As]),Umbral,Arbol1,
36 Solucionado,Sol) :-
37 F =< Umbral,
38 mejorF(As,MejorF), min(Umbral,MejorF,Umbral1),
39 expandir([Nodo|Camino],A,Umbral1,A1,Solucionado1,Sol),
40 continuar(Camino,arbol(Nodo,F/G,[A1|As]),Umbral,Arbol1,
41 Solucionado1,Solucionado,Sol).
42
43 % Caso 4: Nodo interno con subarboles vaco

44 % Punto muerto, el problema nunca sera resuelto
45
46 expandir(_,arbol(_,_,[]),_,_,nunca,_) :- !.
47
48 % Caso 5: f-valor mayor que el Umbral

49 % Arbol no debe crecer
50
158 11 Planeacion
51 expandir(_,Arbol,Umbral,Arbol,no,_) :-
52 f(Arbol,F), F > Umbral.
53
54 %% % continuar(Camino,Arbol,Umbral,NuevoArbol,SubarbolSolucionado,
55 %% % ArbolSolucionado,Solucion)
56
57 % Caso 1: el subartol y el arbol estan solucionados

58 % la solucion esta en Sol
59
60 continuar(_,_,_,_,si,si,Sol).
61
62 continuar(Camino,arbol(Nodo,F/G,[A1|As]),Umbral,Arbol1,no,
64 insertarArbol(A1,As,NAs),
65 mejorF(NAs,F1),
66 expandir(Camino,arbol(Nodo,F1/G,NAs),Umbral,Arbol1,
67 Solucionado,Sol).
68
69 continuar(Camino,arbol(Nodo,F/G,[_|As]),Umbral,Arbol1,nunca,
71 mejorF(As,F1),
72 expandir(Camino,arbol(Nodo,F1/G,As),Umbral,Arbol1,
73 Solucionado,Sol).
74
75 %% % listaSuccs(G0,[Nodo1/Costo1, ...], [hoja(MejorNodo,MejorF/G),
...])
76 %% % hace una lista de arboles sucesores ordendados por F-valor
77
78 listaSuccs(_,[],[]).
79
80 listaSuccs(G0,[Nodo/C|NCs],As) :-
81 G is G0 + C,
82 h(Nodo,H), % Heuristic term h(N)
83 F is G + H,
84 listaSuccs(G0,NCs,As1),
85 insertarArbol(hoja(Nodo,F/G),As1,As).
86
87 %% % Inserta A en una lista de arboles As preservando el orden por

f-valor
88
89 insertarArbol(A,As,[A|As]) :-
90 f(A,F), mejorF(As,F1),
91 F =< F1, !.
92
93 insertarArbol(A,[A1|As], [A1|As1]) :-
94 insertarArbol(A,As,As1).
95
96
97 %% % Extraer f-valores
98
99 f(hoja(_,F/_),F). % f-valor de una hoja

100 f(arbol(_,F/_,_),F). % f-valor de un arbol
101
102 mejorF([A|_],F) :- f( A, F).

11.7 Variables y planes no lineales 159
103 mejorF([], 9999).

104
105 min(X,Y,X) :- X =< Y, !.
106 min(_,Y,Y).
De forma que podemos procesar el plan con la siguiente llamada:
1 ?- primeroMejor([en(a,b), en(b,c)] -> stop, Plan).

2 Plan = [[despejado(2), en(c, a), despejado(c), en(b, 3),
3 despejado(b), en(a, 1)]->mover(c, a, 2),
4 [despejado(c), en(b, 3), despejado(a), despejado(b),
5 en(a, 1)]->mover(b, 3, c),
6 [despejado(a), despejado(b), en(a, 1), en(b, c)]
7 ->mover(a, 1, b),
8 [en(a, b), en(b, c)]->stop]
La accion nula stop es necesaria pues todos los nodos deben incluir una accion.
Aunque la heurstica usada es simple, el programa debe ser mas rapido que las ver-
siones anteriores. Eso si, el precio a pagar es una mayor utilizacion de la memoria,
debido a que debemos mantener el conjunto de alternativas competitivas.
11.7. Variables y planes no lineales
A manera de comentario final, consideraremos dos casos que pueden mejorar la

eficiencia de los planificadores construidos en esta sesion. El primer caso consiste
en permitir que las acciones y las metas contengan variables no instanciadas; el
segundo caso es considerar que los planes no son lineales.
11.7.1. Acciones y metas no instanciadas
Las variables que ocurren en nuestros planeadores estan siempre instanciadas.

Esto se logra, por ejemplo en la relacion precond/2 cuyo cuerpo incluye la meta
block(Block) entre otras. Este tipo de meta hace que Block siempre este instanciada.
Esto puede llevar a la generacion de numerosos movimientos alternativos irrelevan-
tes. Por ejemplo, cuando al planeador se le plantea como meta despe jar(a), este
utiliza lograr/2 para generar movimientos que satisfagan despe jado(a):
1 mover(De,a,A)
Entonces se computan las condiciones necesarias para ejecutar esta accion:
1 precond(mover(De,a,A)),Cond)
160 11 Planeacion
Lo cual fuerza, al reconsiderar, varias instanciaciones alternativas para De y A:
1 mover(b,a,1)
2 mover(b,a,2)
3 mover(b,a,3)
4 mover(b,a,4)
5 mover(b,a,c)
6 mover(b,a,1)
7 mover(b,a,2)
Para hacer mas eficiente este paso del planeador, es posible permitir variables no
instanciadas en las metas. Para el ejemplo del mundo de los bloques, las condiciones
de mover seran definidas como:
1 precond(mover(Bloque,De,A),
2 [despejado(Bloque),despejado(A),en(Bloque,De)]).
Si reconsideramos con esta nueva definicion la situacion inicial, la lista de con-

diciones computadas sera:
1 [despejado(Bloque),despejado(A),en(Bloque,a)]
Observen que esta lista de metas puede ser satisfecha inmediatamente en la si-
tuacion inicial de nuestro ejemplo si Bloque/c y A/2. Esta mejora en eficiencia se
logra postergando la decision de como instanciar las variables, al momento en que
ya se cuenta con mas informacion para ello.
Este ejemplo ilustra el poder de la representacion con variables, pero el precio a
pagar es una mayor complejidad. Para empezar, nuestro intento por definir precond
para mover/3 es erroneo, pues permite movimientos como mover(c, a, c), que da
como resultado que !el bloque c este en el bloque c! Esto podra arreglarse si espe-
cificaramos que De y A deben ser diferentes:
1 precond(mover(Bloque,De,A),
2 [despejado(Bloque),despejado(A),en(Bloque,De),
3 diferente(Bloque,A), diferente(De,A),
4 diferente(Bloque,De)]).
donde di f erente/2 significa que los dos argumentos no denotan al mismo objeto
Prolog. Una condicion como estas, no depende del estado del problema, de forma
que no puede volverse verdadero mediante accion alguna, pero debe verificarse eva-
luando el predicado correspondiente. Una manera de manejar estas cuasi-metas es
agregar al predicado satis f echo/2 la siguiente clausula:
1 satisfecho(Estado,[Meta|Metas]) :-
2 satisface(Meta),
11.7 Variables y planes no lineales 161
De forma que debemos definir tambien:
1 satisface(diferente(X,Y))
Tal relacion tiene exito si X y Y no se corresponden. Si X y Y son lo mismo,

la condicion es falsa. Este caso debera tratarse con imposible, pues la condicion
debera seguir siendo falsa, sin importar las acciones que seran adoptadas en el plan.
En otro caso, estamos ante falta de informacion y satis f ace se debera postergar.
11.7.2. Planes no lineales
Un problema con nuestro planeador es que considera todos los posibles ordenes
de las acciones, aun cuando las acciones son completamente independientes. Con-
sideren el problema ilustrado en la figura 11.3, donde la meta es construir dos pilas
de bloques que estan de antemano bien separados. Las dos pilas puede construirse
independientemente con los siguientes planes:
1 Plan1 = [mover(b,a,c), mover(a,1,b)]

2 Plan2 = [mover(e,d,f), mover(d,8,e)]
El punto importante aqu es que estos planes no interaccionan entre ellos, de

forma que el orden de las acciones solo es relevante dentro de cada plan. Tampoco
importa si se ejecuta primero Plan1 o Plan2 y es incluso posible ejecutarlos de
manera alternada, por ejemplo:
1 [mover(b,a,c), mover(e,d,f), mover(d,8,e), mover(a,1,b)]
Sin embargo, nuestro planeador considerara las 24 permutaciones posibles de

las cuatro acciones, aunque existan solo 4 alternativas: 2 permutaciones para ca-
da uno de los planes. El problema se debe a que el planeador insiste en el orden
total de las acciones en el plan. Una mejora se lograra si, en los casos donde el
orden no es importante, la precedencia entre las acciones se mantiene indefinida.
Entonces nuestros planes seran conjuntos de acciones parcialmente ordenadas. Los
planeadores que aceptan este tipo de representacion se conocen como planeadores
no lineales.
Consideremos nuevamente el ejemplo de la figura 11.3. Analizando las metas
en(a, b) y en(b, c) el planeador no lineal concluye que las siguientes dos acciones
son necesarias en el plan:
1 M1 = mover(a,X,b)
2 M2 = mover(b,Y,c)
162 11 Planeacion
b e
a c f d
1 2 3 4 5 6 7 8
a d
b e
c f
1 2 3 4 5 6 7 8
Figura 11.3 Una tarea de planeacion con dos planes independientes
No hay otra forma de resolver ambas metas, pero el orden de estas acciones es
aun indeterminado. Ahora consideren las condiciones de ambas acciones. La condi-
cion de mover(a, X, b) incluye depe jado(a), la cual no se satisface en la situacion
inicial, por lo que necesitamos una accion de la forma:
1 M3 = mover(Bloque,a,A).
que precede a M1. Ahora tenemos una restriccion en el orden de las acciones:
1 antes(M3,M1)
Ahora revisamos si M3 y M1 pueden ser el mismo movimiento. Como este no

es el caso, el plan tendra que incluir tres movimientos. Ahora el planeador debe
preguntarse si hay una permutacion de [M1, M2, M3] tal que M3 preceda a M1, tal
que la permutacion es ejecutable en el estado inicial del problema y las metas se
cumplen en el estado resultante. Dadas las restricciones de orden anteriores tres
permutaciones de seis, cumplen con los requisitos:
1 [M3,M1,M2]
2 [M3,M2,M1]
3 [M2,M3,M1]
Y de estas permutaciones, solo la del medio cumple con el requisito de ser ejecu-
table bajo la sustitucion Bloque/c, A/2, X/1,Y /3. Como se puede intuir, la comple-
jidad computacional no puede ser evitada del todo por un planeador no lineal, pero
puede ser aliviada considerablemente.
Referencias 163
Referencias
1. I. Bratko. Prolog programming for Artificial Intelligence. Addison-Wesley, 3rd edition, 2001.
2. Alonzo Church. A note on the entscheidungsproblem. Journal of Symbolic Logic, 1:4041,
1936.
3. K. Clark. Negations as failure. In H. Gallaire and J. Minker, editors, Logic and Databases,
pages 293322. Plenum Press, New York, USA, 1978.
4. A. Colmerauer and P. Roussel. The birth of Prolog. In T. H. Bergin and R. G. Gibson, editors,
History of Programming Languages, chapter The birth of Prolog, pages 331367. ACM Press
/ Addison-Wesley, 1996.
5. M.R. Genesereth and N.J. Nilsson. Logical Foundations for Artificial Intelligence. Morgan
Kauffman Publishers, Inc., Palo Alto, CA., USA, 1987.
6. R. A. Kowalski. Predicate logic as a programming language. In J. L. Rosenfeld, editor,
Information Processing, pages 569574. North-Holland, 1974.
7. Robert A. Kowalski and Donald Kuehner. Linear resolution with selection function. Artificial
Intelligence, 2(3/4):227260, 1971.
8. J. McCarthy. Programs with common sense. In Proceedings of the Symposium on the Mecha-
nization of Thought Processes, Teddington, England, 1958.
9. M. Minsky. The Society of Mind. Simon and Schuster, New York, NJ., USA, 1986.
10. T.M. Mitchell. Machine Learning. Computer Science Series. McGraw-Hill International
Editions, Singapore, 1997.
11. Shan-Hwei Nenhuys-Chen and Ronald de Wolf. Foundations of Inductive Logic Program-
ming, volume 1228 of Lecture Notes in Artificial Intelligence. Springer-Verlag, Berlin Heidel-
berg, 1997.
12. Ulf Nilsson and Jan Maluszynski. Logic, Programming and Prolog. John Wiley & Sons Ltd,
2nd edition, 2000.
13. J. R. Quinlan. Induction of decision trees. Machine Learning, 1:81106, 1986.
14. J.R. Quinlan. C4.5: Programs for Machine Learning. Morgan Kaufmann, San Mateo, CA.,
USA, 1993.
15. J. A. Robinson. A machine-oriented logic based on the resolution principle. Journal of the
ACM, 12(1):2341, 1965.
16. J. A. Robinson. Logic and logic programming. Communications of the ACM, 35(3):4065,
1992.
17. Stuart J. Russell and Peter Norvig. Artificial Intelligence, a modern approach. Prentice Hall,
New Jersey, USA, 2nd edition, 2003.
18. C. Shannon and W. Weaver. The mathematical theory of communication. The Bell System
Technical Journal, 27:623656, July, October 1948.
19. Alan M. Turing. On the computable numbers, with applications to the entscheidungsproblem.
In Proceedints of the London Mathematical Society, volume 42 of series 2, pages 230265,
1936.
20. D. H. D. Warren. An abstract Prolog instruction set. Technical Report 309, SRI, 1983.

Prolo PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Prolo PDF

Transféré par

Droits d'auteur :

Formats disponibles

Alejandro Guerra-Hernandez

Departamento de Inteligencia Artificial

2. Logica de Primer Orden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3. Clausulas y Programas Definitivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

4.3. Pruebas y programas logicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

8. Estrategias basicas de resolucion de problemas . . . . . . . . . . . . . . . . . . . . 85

10. Arboles de Decision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

11. Planeacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

Resumen El tema de este curso de metodologas de programacion es la programa-

1.1. Breve historia de la programacion logica.

La historia reciente, y a la francaise, de la programacion logica comienza en

Usuario > Los gatos matan ratones.

Cuadro 1.1 Sistema de lenguaje natural de Alain Colmerauer et al. [4].

En realidad, la creacion de este paradigma de programacion tiene una larga his-

Si la forma procedimental era la adecuada, entonces tal realizacion pasaba por la

1.2. Una breve introduccion a Prolog

Prolog es la realizacion mas utilizada del paradigma de programacion logica.

1.2.1. Hechos y relaciones

Figura 1.1 Una relacion familiar.

SWI Prolog, en una terminal invocaramos swipl (o pl en algunos sistemas ope-

For help, use ?- help(Topic). or ?- apropos(Word).

El smbolo ?- es el indicador de que Prolog espera una instruccion. Si tenemos

Prolog responde que el programa clase01 ha sido compilado (Saban ustedes

Lo mismo sucede con la siguiente consulta, pues Ben no es siquiera un objeto

Una pregunta mas interesante sobre la relacion progenitor es Quien es el proge-

Prolog computa un valor para X tal que la relacion progenitor se cumple. Si

La secuencia de preguntas en Prolog es como sigue:

Si invertimos el orden de las dos preguntas, el resultado sigue siendo el mismo:

Podemos preguntar tambien Quien es nieto de Tom?:

Es sencillo definir en Prolog una relacion, como progenitor/2, especificando las

Nuestro ejemplo puede extenderse en muchas formas interesantes. Definamos

Las relaciones unarias (n = 1) se usan normalmente para expresar propiedades de

La clausula puede leerse tambien como: Si X es un progenitor de Y enton-

No existe ningun hecho sobre vastagos en nuestro programa, por lo tanto, la

La parte condicional de la regla es ahora:

Ahora Prolog tratara de encontrar si esta condicion es verdadera, de forma que la

ha sido substituida por una sub-meta progenitor(tom,liz). Esta nueva

Especifiquemos ahora la relacion madre/2 a partir del siguiente enunciado logi-

1 madre(X,Y) :- progenitor(X,Y), mujer(X).

La coma en el cuerpo de la regla, indica una conjuncion: ambas condiciones

1 abuela(X,Y) :- progenitor(X,Z), progenitor(Z,Y), mujer(X).

Observen, en el caso de hermana/2, la manera de especificar que X e Y tienen un

Figura 1.3 La relacion hermana.

Los programas Prolog pueden extenderse facilmente agregando nuevas clausulas.

ejemplo la clausula tiene hijo(X) :- progenitor(X,Y) puede leerse

1.2.3. Definicion de reglas recursivas

Agreguemos una relacion nueva a nuestro programa: la relacion ancestro/2. Esta

Figura 1.4 La relacion ancestro en terminos de progenitor directo e indirecto.

La primera regla es muy sencilla y se expresa en Prolog como:

La segunda regla es mas complicada porque las cadenas de progenitores presen-

Ahora podemos preguntar De quien es ancestro Pam?

O Quienes son los ancestros de Jim?

1.3. Como computa Prolog una solucion?

Un ejemplo mas complicado, tomado de la familia de la figura 1.1, es la meta: ?-

progenitor(bob, pat) ancestro(bob, pat)

Decimos que la cabeza de estas reglas coincide o corresponde (match) con la

Figura 1.6 El segundo paso de la ejecucion. Dos sub-metas son generadas.

Enfrentado ahora el problema de resolver dos sub-metas, Prolog intentara satis-

Lo cual conduce a la substitucion de variables: X/bob y Z/pat. La meta es

Figura 1.7 El segundo paso de la ejecucion. Dos sub-metas son generadas.

Call: (9) progenitor(bob, pat) ? creep

1.4. Organizacion del curso

Durante el curso revisaremos tanto el fundamento teorico de la programacion