Programacin Lgica

2. Fundamentos de la
Programacin Lgica
Jorge Cabrera Gmez
Departamento de Informtica y Sistemas
Universidad de Las Palmas de Gran Canaria
Todos los derechos reservados
Programacin Lgica
Contenidos

2. Fundamentos de la Programacin Lgica
2.1 Introduccin a la representacin en Lgica.
2.2 Representacin mediante Clusulas.
2.3 Unificacin y sustitucin.
2.4 Resolucin por Refutacin.
2.5 Sistemas de Deduccin o No-Resolucin.
2.6 Programacin Lgica y Prolog.
2.7 Bibliografa bsica:
Principles of Artificial Intelligence, N.J. Nilsson, Springer-Verlag,
1982.
From Logic Programming to Prolog, K.R. Apt, Prentice-Hall,
1997.

Programacin Lgica
Objetivos:

Presentar la lgica de predicados de primer
orden como formalismo de representacin del
conocimiento e inferencia.

Estudiar los mtodos de inferencia
automticos aplicables a la lgica de predicados,
esencialmente el mtodo de resolucin por
refutacin.
Programacin Lgica
Representacin e inferencia en la lgica de predicados
Idea:
La lgica como sistema de representacin del
conocimiento y de obtencin de
consecuencias (control)
Clculo de predicados de primer orden
Frmulas
Frmulas atmicas
Conectores
Programacin Lgica
autor(quijote, cervantes)

escritor(cervantes)
Predicado: Un predicado es un smbolo cuyo valor
se encuentra en el dominio lgico (verdadero o
falso) y representa alguna cualidad semntica, en
un cierto contexto, acerca de las relaciones entre
objetos o entidades
Frmulas atmicas
Trminos
autor(quijote, Quin)
autor(quijote, mejor(novelista, espaa))
Programacin Lgica
Constante:

Representa un trmino con un valor semntico
determinado




Frmulas atmica :: Predicado | Predicado(Trminos)

Trminos :: Trmino | Trmino, Trminos

Trmino :: Variable | Constante | Functor

Functor :: NombreFunctor(Trminos)

Variable:

Representa un trmino cuyo valor no est determinado
inicialmente y su dominio de definicin debe coincidir con
el de los trminos constantes

Functor:

Es un smbolo que posee valor en el dominio de las
variables y constantes, pero que no es ni una variable ni
una constante.

Normas lxicas:

Las variables siempre empiezan por mayscula

las constantes por minscula

Programacin Lgica
Conectores

Permiten construir frmulas complejas a partir de
frmulas o expresiones atmicas

Negacin : (~)
Disyuncin : v (OR)
Conjuncin : . (AND)
Implicacin : ()
Equivalencia :
Programacin Lgica
Negacin: Genera una frmula que posee valores lgicos
complementarios a los de la frmula sobre la que se
aplica. Estrictamente no es un conector, pues no conecta
dos frmulas sino que transforma una.

autor(hamlet, cervantes)

Disyuncin: Genera una frmula cuyo valor lgico es el
OR de los valores de las dos frmulas que conecta.

estado(bombilla, encendida) v estado(bombilla, apagada)

Conjuncin: Genera una frmula cuyo valor lgico es el
AND de los valores de las dos frmulas que conecta.

color(coche, rojo) . color(camisa, azul)
Programacin Lgica
Implicacin: Genera una frmula compuesta no-simtrica
que es cierta siempre, salvo cuando el antecedente es
cierto y el consecuente falso.

p q es equivalente a p v q

p q p q p p v q

0 0 1 1 1
0 1 1 1 1
1 0 0 0 0
1 1 1 0 1

est(cielo, azul) llover(hoy)

est(cielo, azul) v llover(hoy)

Programacin Lgica
Equivalencia o doble implicacin: Genera una frmula que
es cierta slo si las dos componentes poseen idntico
valor.

p q es equivalente a (p q) . (q p)

p q p q q p (p q) . (q p)

0 0 1 1 1
0 1 1 0 0
1 0 0 1 0
1 1 1 1 1


llueve(hoy) est(cielo, nublado)
Programacin Lgica
Equivalencias

Complemento: p v p 1
Doble negacin: ( p ) p
Conmutativa: p v q q v p
p . q q . p

Distributiva: p v (q . r) (p v q) . (p v r)
p . (q v r) (p . q) v (p . r)

Asociativa: p v (q v r) (p v q) v r
p . (q . r) (p . q) . r

Leyes de De Morgan: (p v q) p . q
(p . q) p v q

Ley del contrapositivo: p q q p
Programacin Lgica
Cuantificadores
Establecen el mbito de
existencia de las variables
Cuantificador Universal ():

Cuando acompaa a una variable X establece que la
frmula es siempre vlida para cada valor posible
de la variable X. La variable X se dice entonces
cuantificada universalmente.

Todo cuerpo con masa cae

(X) ( [cuerpo(X) . posee(masa, X)] cae(X) )
Programacin Lgica
Cuantificadores
Establecen el mbito de
existencia de las variables
Cuantificador Existencial (-):

Establece que como mnimo existe un valor de la
variable cuantificada que hace cierta la frmula. La
variable se dice cuantificada existencialmente.

Alguin descubri la penicilina

(- X) ( descubri( X, penicilina )
Programacin Lgica
Reglas de precedencia entre operadores

, -
v , .
,
menor precedencia
Forma Normal de una frmula
Una frmula se dice que est en forma normal
si todos los cuantificadores han sido
desplazados al principio de la frmula.
Programacin Lgica
Forma normal de una frmula
Una frmula se dice que est en forma normal si todos los
cuantificadores han sido desplazados al principio de la
frmula.

Algunas equivalencias tiles para alcanzar una forma
normal
[ (- X) p(X) ] (X) [ p(X) ]
[ (X) p(X) ] (- X) [ p(X) ]
( X) [ p(X) . q(X) ] [ (X) p(X) ] . [ (X) q(X) ]
(- X) [ p(X) v q(X) ] [ (- X) p(X) ] v [ (- X) q(X) ]
Programacin Lgica
Reglas de Inferencia
Especializacin Universal: siempre es posible deducir la
verificacin de un caso concreto a partir de un cuantificador
universal.
(X) p(X) p(a)

Sustitucin: permite la sustitucin de cualquier proposicin
en una frmula por otra biequivalente.

Modus ponens: de una implicacin de la verificacin de la
premisa se verifica la conclusin.
Axioma: p q
Axioma: p
Teorema: q
Programacin Lgica
Modus tollens: de una implicacin y de la no verificacin del
consecuente, se concluye la no verificacin de la premisa.
Axioma: p q
Axioma: q
Teorema: p


. Introduccin: la fbf p.q puede ser inferida de las fbf p y q.
. Eliminacin: la fbf p puede ser inferida de la fbf p.q.
v Introduccin: la fbf p v q puede ser inferida de la fbf p o
de la fbf q.

Programacin Lgica
Lgica de orden cero:

Los predicados carecen de trminos y el clculo de
predicados se reduce al clculo de proposiciones o
proposicional.

Lgica de orden uno:

Los predicados poseen trminos que pueden ser
constantes, variables o functores.

Lgica de orden superior:

Los predicados lgicos pueden ser en s mismos
variables.
Programacin Lgica
Ejercicios. Expresar como fbf en lgica de predicados los
siguientes hechos

A. Marco era un hombre.
B. Marco era pompeyano (de Pompeya).
C. Todos los pompeyanos eran romanos.
D. Csar era un dirigente.
E. Todos los romanos o bien eran leales a Csar o bien le
odiaban.
F. Todo el mundo es fiel a alguien.
G. La gente slo trata de asesinar a aquellos dirigentes a
los que no son leales.
H. Marco intent asesinar a Csar.
I. Algn romano odia a Csar.
Programacin Lgica
A. hombre(marco)
B. pompeyano(marco)
C. (X)(pompeyano(X) romano(X))
D. dirigente(csar)
E. (X)(romano(X) leal(X,csar) v odia(X,csar))
F. (X)(hombre(X) |(-Y) leal(X,Y)|
G. (X)|(Y) (hombre(X) . dirigente(Y)
. intenta_asesinar(X,Y) leal(X,Y))|
H. intenta_asesinar(marco, csar)
I. (-X) (romano(X) . odia(X, csar))
Programacin Lgica
Teorema + Axiomas (como frmulas bien formadas, fbf)
Teorema + Axiomas (como clusulas)
Mtodo de resolucin por refutacin


Unificacin
Demostracin automtica de teoremas
+
+
Lo que queremos hacer ...
Programacin Lgica
IMPORTANTE:

La demostracin automtica de teoremas lgicos es un
procedimiento que involucra una mera actividad
sintctica, o de relacin entre smbolos, ignorndose
completamente el contenido semntico que resulta de
la interpretacin de las frmulas.
Programacin Lgica
Frmulas bien formadas (fbf)
Son aquellas que cumplen ciertos requisitos en su estructura y
definen la sintaxis del clculo de predicados

Una frmula se dice bien formada si puede derivarse de
alguna de las siguientes reglas de formacin:

1. Cualquier frmula atmica es una fbf.
2. Si p y q son fbf, entonces tambin sern fbf las siguientes:
p, p v q, p . q, p q

3. Si X es una variable libre en la fbf p, entonces son fbf :
(X) p(X), (-X) p(X)

4. Cualquier frmula que no pueda formarse a partir de estas
reglas no es una fbf.

Programacin Lgica
Clusula
Es una frmula que slo contiene operadores disyuntivos
y posiblemente negaciones sobre los tomos.

Este tipo de frmulas pueden ser expresadas por una
nica implicacin. As la frmula:

a
1
v a
2
v ... v a
n
v b
1
v b
2
v ... v b
m

se puede transformar en :

( a
1
. a
2
. ... . a
n
) v b
1
v b
2
v ... v b
m


a
1
. a
2
. ... . a
n
b
1
v b
2
v ... v b
m


Programacin Lgica
Clusulas de Horn.

Aquellas cuyo consecuente tiene un nico predicado.

a
1
. a
2
. ... . a
n
b

Ventajas de una representacin basada en clusulas de Horn

La demostracin de teoremas o resolucin de un conjunto
de clusulas de Horn es ms sencilla en general.

Las clusulas de Horn admiten una interpretacin directa
en trminos de un lenguaje de programacin, lo que no es
posible con clusulas generales.
Programacin Lgica
Transformacin a clusulas
Para ilustrar el proceso paso a paso emplearemos la siguiente
fmula compleja como ejemplo:

(X){p(X) {(Y)[p(Y) p(f(X,Y))]. (Y)[q(X,Y) p(Y)]}}

1. Eliminar los smbolos de implicacin, sustituyendo p q
por p v q.

Tras este primer paso, nuestra fmula se transforma en:

(X){p(X) v {(Y)[ p(Y) v p(f(X,Y))] . (Y)[ q(X,Y) v p(Y)]}}


Programacin Lgica
2. Mover las negaciones hasta las frmulas atmicas, para
ello se emplean las leyes de Morgan y las transformaciones
de cuantificadores existenciales y universales.

(p v q) p . q
(p . q) p v q

[ (- X) p(X) ] (X) [ p(X) ]
[ (X) p(X) ] (- X) [ p(X) ]

Aplicndolo sobre el ejemplo:
(X){p(X) v {(Y)[ p(Y) v p(f(X,Y))] . (Y)[ q(X,Y) v p(Y)]}}

(X){ p(X) v {(Y)[ p(Y) v p(f(X,Y))] . (-Y)[q(X,Y) . p(Y)]}}

Programacin Lgica
3. Renombrar variables, en aquellos casos en los que varias
variables se hayan nombrado de igual forma. En nuestro caso
esto ocurre con la variable Y que renombramos como Z en su
segunda ocurrencia.

As nuestro ejemplo se transforma en:
(X){ p(X) v {(Y)[ p(Y) v p(f(X,Y))] . (-Y)[q(X,Y) . p(Y)]}}

(X){ p(X) v {(Y)[ p(Y) v p(f(X,Y))] . (-Z)[q(X,Z) . p(Z)]}}

Programacin Lgica
4. Eliminar los cuantificadores existenciales. Las variables
cuantificadas por este tipo de cuantificadores sern
sustituidas por un tipo de funcin comodn denominada
funcin de Skolem (proceso de skolemizacin).

P.e. (-Z) q(X,Z) se transforma en q(X, g(X))

en donde g(X) es la funcin de Skolem para este caso.
Ntese que no slo se eliminan los cuantificadores
existenciales sino tambin las variables ligadas a los mismos.

La funcin de Skolem introducida debe ser nueva en el
universo de discurso, y adems deber ser funcin de todas
las variables cuantificadas universalmente cuyos mbitos
incluyan el mbito del cuantificador existencial que se
pretende eliminar.
Programacin Lgica
As nuestro ejemplo se transforma en:
(X){ p(X) v {(Y)[ p(Y) v p(f(X,Y))] . (-Z)[q(X,Z) . p(Z)]}}

(X){ p(X) v {(Y)[ p(Y) v p(f(X,Y))] . [q(X, g(X)) . p(g(X))]}}

Si el cuantificador existencial no se encuentra en el mbito de
ningn cuantificador universal, se usar una funcin de
Skolem sin argumentos. Como en el siguiente ejemplo:

(-Z) q(Z) se transforma en q(a)

Donde el smbolo constante a referencia a la entidad que
sabemos existe. Evidentemente a debe ser un smbolo que no
haya sido empeado con anterioridad.
Programacin Lgica
5. Desplazar los cuantificadores universales, de manera que
queden al comienzo de la frmula (prenex form). Estre
proceso puede ser realizado por cuanto no existen ya
variables distintas con el mismo nombre.
(X){ p(X) v {(Y)[ p(Y) v p(f(X,Y))] . [q(X, g(X)) . p(g(X))]}}

(X) (Y){ p(X) v { [ p(Y) v p(f(X,Y))] . [q(X, g(X)) . p(g(X))]}}

6. Convertir los operadores conjuntivos (AND) en los ms
externos, para lo que se emplean las leyes distributivas. A la
forma resultante se le denomina forma normal conjuntiva.

Este paso se ejecuta sobre el ejemplo en dos pasos:

Programacin Lgica
Partiendo de la ltima expresin,

(X)(Y){ p(X) v { [ p(Y) v p(f(X,Y))] . [q(X, g(X)) . p(g(X))]}}

se aplica primero la ley distributiva:

(X)(Y){ { p(X) v [ p(Y) v p(f(X,Y))]} .
{ p(X) v [q(X, g(X)) . p(g(X))]}}

Aplicando de nuevo la ley distributiva y la asociativa:

(X)(Y){ [ p(X) v p(Y) v p(f(X,Y))] .
[ p(X) v q(X, g(X)) ] .
[ p(X) v p(g(X))]}


Programacin Lgica
7. Eliminar los cuantificadores universales. Se trata de
una eliminacin convencional, no terica, pues se asume
que toda variable que aparezca est cuantificada
universalmente. La funcin de Skolem adquiere sentido,
dado que al no aparecer otras variables que las
universales, pueden eliminarse sus cuantificadores por
convenio. En nuestro ejemplo:

(X)(Y){ [ p(X) v p(Y) v p(f(X,Y))] .
[ p(X) v q(X, g(X)) ] .
[ p(X) v p(g(X))]}

[ p(X) v p(Y) v p(f(X,Y))] .
[ p(X) v q(X, g(X)) ] .
[ p(X) v p(g(X))]
Programacin Lgica
8. Eliminar los conectores conjuntivos (AND).
Dado que la fmula se corresponde con una conjuncin
de subfmulas, stas debern verificarse por separado
para que se verifique la frmula principal.

Esto produce, en nuestro caso, el siguiente conjunto de
frmulas:

[ p(X) v p(Y) v p(f(X,Y))] .
[ p(X) v q(X, g(X)) ] .
[ p(X) v p(g(X))]

p(X) v p(Y) v p(f(X,Y))
p(X) v q(X, g(X))
p(X) v p(g(X))
Programacin Lgica
9. Renombrar las variables. para que no aparezca la
misma variable en dos clusulas.

p(X) v p(Y) v p(f(X,Y))
p(X) v q(X, g(X))
p(X) v p(g(X))

p(X) v p(Y) v p(f(X,Y))
p(U) v q(U, g(U))
p(W) v p(g(W))

------ * * * ------

Mediante este proceso se termina en una representacin
en forma de clusulas. As de una una nica frmula
pueden resultar varias clusulas que son ms modulares
y de estructura ms simple.
Programacin Lgica
Proceso de paso a clusulas

1. Eliminar los smbolos de implicacin
2. Mover las negaciones hasta las frmulas atmicas
3. Renombrar variables
4. Eliminar los cuantificadores existenciales.
5. Desplazar los cuantificadores universales
6. Convertir los operadores AND en los ms externos
7. Eliminar los cuantificadores universales.
8. Eliminar los conectores conjuntivos (AND).
9. Renombrar las variables.
Programacin Lgica
Un ejemplo del mundo de los bloques
Acerca de los bloques conocemos tres cosas:

A. Que un bloque est encima de algo que no es una
pirmide.
B. Que no existe ningn objeto que est debajo de un
bloque y, a la vez, encima del mismo.
C. Que no hay nada que no sea un bloque y que
tambin sea lo mismo que el bloque.

(X) { bloque(X) [(-Y) (encima(X,Y) . piramide(Y))
. (-Y) (encima(X,Y) . encima(Y,X))
. (Y) ( bloque(Y) igual(X,Y))]}


Programacin Lgica
0. La frmula inicial

(X) { bloque(X) [ (-Y) (encima(X,Y) . piramide(Y))
. (-Y) (encima(X,Y) . encima(Y,X))
. (Y) ( bloque(Y) igual(X,Y))]}

1. Eliminar las implicaciones

(X) { bloque(X) v [ (-Y) (encima(X,Y) . piramide(Y))
. (-Y) (encima(X,Y) . encima(Y,X))
. (Y) (bloque(Y) v igual(X,Y))]}

2. Mover las negaciones hasta las frmulas atmicas

(X) { bloque(X) v [ (-Y) (encima(X,Y) . piramide(Y))
. (Y) ( encima(X,Y) v encima(Y,X))
. (Y) (bloque(Y) v igual(X,Y))]}

Programacin Lgica
3. Renombrar las variables

(X) { bloque(X) v [ (-Y) (encima(X,Y) . piramide(Y))
. (Z) ( encima(X,Z) v encima(Z,X))
. (W) (bloque(W) v igual(X,W))]}

4. Eliminar los cuantificadores existenciales

(X) { bloque(X) v [ (encima(X,g(X)) . piramide(g(X)))
. (Z) ( encima(X,Z) v encima(Z,X))
. (W) (bloque(W) v igual(X,W))]}

5. Desplazar los cuantificadores universales

(X)(Z)(W){ bloque(X) v [ (encima(X,g(X)) . piramide(g(X)))
. ( encima(X,Z) v encima(Z,X))
. (bloque(W) v igual(X,W))]}

Programacin Lgica
6. Convertir los operadores AND en los ms externos

(X)(Z)(W){ bloque(X) v [ (encima(X,g(X)) . piramide(g(X)))
. ( encima(X,Z) v encima(Z,X))
. (bloque(W) v igual(X,W))]}
paso 1.

(X)(Z)(W){( bloque(X) v (encima(X,g(X)) . piramide(g(X))))
. ( bloque(X) v encima(X,Z) v encima(Z,X))
. ( bloque(X) v bloque(W) v igual(X,W))]}

paso 2.

(X)(Z)(W){( bloque(X) v encima(X,g(X)))
. ( bloque(X) v piramide(g(X)))
. ( bloque(X) v encima(X,Z) v encima(Z,X))
. ( bloque(X) v bloque(W) v igual(X,W))]}

Programacin Lgica
7. Eliminar los cuantificadores universales

( bloque(X) v encima(X,g(X)))
. ( bloque(X) v piramide(g(X)))
. ( bloque(X) v encima(X,Z) v encima(Z,X))
. ( bloque(X) v bloque(W) v igual(X,W))

8. Eliminar los conectores AND

bloque(X) v encima(X,g(X))
bloque(X) v piramide(g(X))
bloque(X) v encima(X,Z) v encima(Z,X)
bloque(X) v bloque(W) v igual(X,W)



Programacin Lgica
9. Renombrar las variables

bloque(X) v encima(X,g(X))
bloque(Y) v piramide(g(Y))
bloque(U) v encima(U,Z) v encima(Z,U)
bloque(V) v bloque(W) v igual(V,W)

Ntese que la funcin de Skolem tiene la semntica de identificar el
apoyo de X. Si la renombramos a soporte(X) y representamos las
clusulas como implicaciones obtenemos:

bloque(X) encima(X, soporte(X))
bloque(Y) piramide(soporte(Y))
bloque(U) . encima(U,Z) encima(Z,U)
bloque(V) . bloque(W) igual(V,W)
Programacin Lgica
A. hombre(marco)
B. pompeyano(marco)
C. (X)(pompeyano(X) romano(X))
D. dirigente(csar)
E. (X)(romano(X) leal(X,csar) v odia(X,csar))
F. (X)(hombre(X) |(-Y) leal(X,Y)|
G. (X)|(Y) (hombre(X) . dirigente(Y)
. intenta_asesinar(X,Y) leal(X,Y))|
H. intenta_asesinar(marco, csar)
I. (-X) (romano(X) . odia(X, csar))
Programacin Lgica
Proceso de paso a clusulas

1. Eliminar los smbolos de implicacin
A. hombre(marco)
B. pompeyano(marco)
C. (X)( pompeyano(X) v romano(X))
D. dirigente(csar)
E. (X)( romano(X) v leal(X,csar) v odia(X,csar))
F. (X)( hombre(X) v |(-Y) leal(X,Y)|
G. (X){ (Y) | (hombre(X) . dirigente(Y) . intenta_asesinar(X,Y) |
v leal(X,Y)) }
H. intenta_asesinar(marco, csar)
I. (-X) (romano(X) . odia(X, csar))

Programacin Lgica
Proceso de paso a clusulas

2. Mover las negaciones hasta las frmulas atmicas
A. hombre(marco)
B. pompeyano(marco)
C. (X)( pompeyano(X) v romano(X))
D. dirigente(csar)
E. (X)( romano(X) v leal(X,csar) v odia(X,csar))
F. (X)( hombre(X) v |(-Y) leal(X,Y)|
G. (X)(Y)
( hombre(X)v dirigente(Y) v intenta_asesinar(X,Y) v leal(X,Y))
H. intenta_asesinar(marco, csar)
I. (-X) (romano(X) . odia(X, csar))

3. Renombrar las variables
Programacin Lgica
Proceso de paso a clusulas

4. Eliminar los cuantificadores existenciales
A. hombre(marco)
B. pompeyano(marco)
C. (X)( pompeyano(X) v romano(X))
D. dirigente(csar)
E. (X)( romano(X) v leal(X,csar) v odia(X,csar))
F. (X)( hombre(X) v leal(X, g(X))
G. (X)(Y)
( hombre(X)v dirigente(Y)v intenta_asesinar(X,Y)v leal(X,Y))
H. intenta_asesinar(marco, csar)
I. romano(f) . odia(f, csar))

Programacin Lgica
Proceso de paso a clusulas

5. Desplazar los cuantificadores universales
6. Convertir los operadores AND en los ms externos
A. hombre(marco)
B. pompeyano(marco)
C. (X)( pompeyano(X) v romano(X))
D. dirigente(csar)
E. (X)( romano(X) v leal(X,csar) v odia(X,csar))
F. (X)( hombre(X) v leal(X, g(X))
G. (X)(Y)
( hombre(X)v dirigente(Y)v intenta_asesinar(X,Y)v leal(X,Y))
H. intenta_asesinar(marco, csar)
I. romano(f) . odia(f, csar))

Programacin Lgica
Proceso de paso a clusulas

7. Eliminar los cuantificadores universales

A. hombre(marco)
B. pompeyano(marco)
C. pompeyano(X) v romano(X)
D. dirigente(csar)
E. romano(X) v leal(X,csar) v odia(X,csar)
F. hombre(X) v leal(X, g(X))
G. hombre(X) v dirigente(Y) v intenta_asesinar(X,Y) v leal(X,Y)
H. intenta_asesinar(marco, csar)
I. romano(f) . odia(f, csar))

Programacin Lgica
Proceso de paso a clusulas

8. Eliminar los conectores AND

A. hombre(marco)
B. pompeyano(marco)
C. pompeyano(X) v romano(X)
D. dirigente(csar)
E. romano(X) v leal(X,csar) v odia(X,csar)
F. hombre(X) v leal(X, g(X))
G. hombre(X) v dirigente(Y) v intenta_asesinar(X,Y) v leal(X,Y)
H. intenta_asesinar(marco, csar)
I1. romano(f)
I2. odia(f, csar))

Programacin Lgica
Proceso de paso a clusulas

8. Renombrar las variables

A. hombre(marco)
B. pompeyano(marco)
C. pompeyano(X) v romano(X)
D. dirigente(csar)
E. romano(Y) v leal(Y,csar) v odia(Y,csar)
F. hombre(Z) v leal(Z, g(Z)
G. hombre(W) v dirigente(K) v intenta_asesinar(W,K) v leal(W,K)
H. intenta_asesinar(marco, csar)
I1. romano(f)
I2. odia(f, csar))

Programacin Lgica
Teorema + Axiomas (como frmulas bien formadas, fbf)
Teorema + Axiomas (como clusulas)
Mtodo de resolucin por refutacin


Unificacin
Demostracin automtica de teoremas
+
+
Lo que queremos hacer ...
Unificacin
Programacin Lgica
Unificacin y sustitucin
Ejemplos:

Definir las sustituciones necesarias para unificar el predicado

p(X, f(Y), b)

con cada uno de los siguientes predicados:

P1: p(g(Z), f(a), b)

P2: p(X, f(a), b)

P3: p(Z, f(U), b)

P4: p(c, f(a), b)


Programacin Lgica
Unificacin y sustitucin
El proceso de unificacin determina las condiciones y posibilidades de
sustitucin de un predicado por otro. Por ejemplo, en el caso de los
siguientes axiomas:
p(X) q(X)
p(a)
la demostracin de q(a) es consecuencia de la regla de
especializacin Universal aplicada a:
p(X) q(X)
para producir
p(a) q(a)

Tambin puede interpretarse como que se ha procedido a realizar la
sustitucin de p(X) por p(a), previa unificacin de X con a.

El proceso de sustitucin de trminos, denominado Unificacin, para
lograr que dos expresiones sean idnticas es fundamental en el
proceso de demostracin de teoremas en la lgica de predicados de
primer orden.

Programacin Lgica
Unificacin y sustitucin
Un proceso de unificacin puede ser representado mediante un
operador u constituido por un conjunto de de pares de trminos
ordenados por:

u = { v
1
t
1
, v
2
t
2
, ..., v
n
t
n
}

donde el par v
i
t
i
, indica que la variable v
i
es sustituida por el
trmino t
i
.

As el predicado p se transforma mediante la sustitucin indicada por
u en p(... , v
k
, ...) u = p(... , t
k
, ...).


NOTA: Tambin es muy habitual la notacin equivalente
u = { v
1
/ t
1
, v
2
/ t
2
, ..., v
n
/ t
n
}
Programacin Lgica
Unificacin y sustitucin
Ejemplos:

Definir las sustituciones necesarias para unificar el predicado

p(X, f(Y), b)

con cada uno de los siguientes predicados:

P1: p(g(Z), f(a), b)

P2: p(X, f(a), b)

P3: p(Z, f(U), b)

P4: p(c, f(a), b)


u
1
= { X g(Z), Y a }
u
2
= { Y a }
u
3
= { X Z, Y U }
u
4
= { X c, Y a }
Programacin Lgica
Unificacin y sustitucin
El proceso de unificacin implica la sustitucin de una variable por
otro trmino que puede ser variable, constante o functor. En este
ltimo caso, el functor no puede contener la variable sustituida.

Es evidente que no siempre es posible unificar dos realizaciones de
un mismo predicado. Por ejemplo q(a, f(X), X) y q(c, f(d), b)
no son unificables.

La composicin de dos sustituciones u
1
y u
2
, se denota por u
1
u
2
y es
la sustitucin que resulta de aplicar la sustitucin u
2
a los trminos de
u
1
y de aadir a continuacin los pares de sustituciones de u
2
sobre
las variables no contenidas entre las variables de u
1
.

{ Z f(X,Y), U X } { X a, Y b, W c, Z d }
{ Z f(a,b), U a, X a, Y b, W c }
Programacin Lgica
Unificacin y sustitucin
Se puede demostrar que :

A. [Lu
1
]u
2
= L [u
1
u
2
]
B. (u
1
u
2
) u
3
= u
1
(u
2
u
3
), Asociatividad
C. u
1
u
2
= u
2
u
1
no es conmutativa

Diremos que dos predicados, E
1
y E
2
, son unificables, y lo
representaremos por {E
1
, E
2
}, si existe una sustitucin u tal que se
verifica:
E
1
u = E
2
u

A la sustitucin u la denominaremos Unificador de E
1
y E
2
.

Ejemplo: Dados p(X, f(Y), b) y p(X, f(b), b) y la sustitucin
u = { X a, Y b }, decimos que u es un unificador de estos dos
predicados porque los convierte en p(a, f(b), b).
Programacin Lgica
Unificacin y sustitucin

Aunque u = { X a, Y b } es un unificador de estos dos
predicados no es el ms simple de los unificadores posibles (se le
podra denominar alternativamente ms general) para este
conjunto, que este caso sera O = { Y b }.

As si O es el unificador ms simple de { E
i
} se verifica que si u es
un unificador de { E
i
} entonces existe una sustitucin s tal que:

{ E
i
} O s = { E
i
} u


Un algoritmo recursivo nos permite descubrir si dos predicados son
unificables o no, y, en su caso, hallar el unificador ms simple.
Programacin Lgica
Algoritmo de Unificacin
Etapas del algoritmo.

1. Comprobaremos si los smbolos de los predicados son los
mismos. En caso negativo los predicados no son unificables.

2. Si los predicados son iguales, han de tener la misma aridad (n
de argumentos). En caso negativo los predicados no son
unificables.

3. Comprobaremos los argumentos por pares correspondientes,
aplicando el algoritmo recursivamente (es necesario si los
argumentos contienen functores), abortando el proceso desde el
momento en que un par de argumentos no sea unificable.
Programacin Lgica
Algoritmo de Unificacin
Unifica(e1, e2) {

1. Si e1 o e2 son ambos variables o constantes, entonces
1.a Si e1 y e2 son idnticos, entonces devolver { }.
1.b Si e1 es una variable, entonces
1.b.1 Si e1 aparece dentro de e2 entonces devolver {FALLO}
en otro caso, devolver { e1 e2 }.
1.c Si e2 es una variable, entonces
1.c.1 Si e2 aparece dentro de e1 entonces devolver {FALLO}
en otro caso, devolver { e2 e1 }.
1.d Devolver {FALLO}

2. Si los smbolos de los predicados e1 y e2 son diferentes o tienen
diferente aridad entonces devolver {FALLO}.

3. Hacer SUBS = NIL (al final del proceso SUBS contendr las
sustituciones necesarias para unificar e1 y e2).
(contina ...)

Programacin Lgica
Algoritmo de Unificacin
Unifica(e1, e2) {
...
4. Para cada uno de los argumentos de e1 (indexados por i)
4.a Invocar Unifica con los i-simos argumentos de e1 y e2, poniendo el
resultado en s.
4.b Si s es igual a FALLO, entonces devolver {FALLO}.
4.c Si s es diferente de { }, entonces
4.c.1 Aplicar la sustitucin s sobre el resto de argumentos de e1 y
e2
4.c.2 Aadir s a las sustituciones ya contenidas en SUBS.

5. Devolver SUBS.

}
Programacin Lgica
Algoritmo de Unificacin
Ejercicios: Tracear la operacin del algoritmo de unificacin
para cada uno de los siguientes pares de predicados.

A. f(marcos), f(csar)
B. f(X), f(g(Y))
C. f(marcos, g(X,Y)), f(X, g(csar, marcos))
D. p(X, X), p( g(X), g(X))
E. p(X, X), p( Y, g(X))
F. p(X, f(x)), p(Y, Y)
G. p(Y, Y, b), p(Z, X, Z)
H. p(f(X,X), a), p(f(Y, f(Y,a)), a)



Programacin Lgica
Resolucin por refutacin
Mtodo de demostracin de teoremas
Robinson, 1965
Basado en el principio de refutacin
Relativamente sencillo de automatizar
IDEA.

Si queremos demostrar un teorema dado en base a un
conjunto de axiomas que suponemos consistente, podemos
hacerlo mostrando que el conjunto formado por la negacin
del teorema y el conjunto de axiomas es inconsistente.

Si tal inconsistencia se demuestra ser porque el teorema era
cierto.

Programacin Lgica
Decidibilidad y Consistencia
Sistema formal:



Validez de
una expresin:



Decidibilidad:



Un conjunto de expresiones bsicas y un
conjunto de reglas de generacin de
nuevas expresiones
Se dice que una expresin es vlida en
un sistema formal si es posible derivar la
misma a partir de las expresiones
bsicas
Un sistema formal U se dice decible si
existen procedimientos efectivos para
determinar la validez dentro de U de las
expresiones V y V
procedimientos efectivos : desarrollos que involucran un
nmero finito de operaciones elementales y de posiciones
de memoria
Programacin Lgica
Decidibilidad y Consistencia
Indecidibilidad:



Semi-decibilidad:



Consistencia:



Un sistema formal U se dice indecible si
no es posible determinar la validez V y
V de forma efectiva

Cuando slo es posible determinar de
forma efectiva la validez de una de las
expresiones V o V
Un sistema formal U se dice consistente
en sentido fuerte, si slo una de las
expresiones V o V es vlida en U. Es
evidente que un sistema consistente
debe ser Decible.
Programacin Lgica
Decidibilidad y Consistencia
Inconsistencia:

Un sistema formal U se dice
inconsistente si ambas expresiones V y
V son vlidas en U.
Un sistema lgico L compuesto de frmulas bsicas o
axiomas y reglas de inferencia constituye un sistema
formal.
Un sistema lgico L que contiene las expresiones F y F
constituye un sistema inconsistente por cuanto F y F
son vlidas en L.
Programacin Lgica
Decidibilidad y Consistencia
Se han desarrollado procedimientos efectivos capaces de
demostrar la inconsistencia de un sistema lgico. Sin
embargo, no existen tales procedimientos para demostrar
su consistencia.

Por ello un sistema lgico es un sistema Semi-decible y no
pueden definirse criterios de consistencia fuerte, usndose
en su defecto otro criterio de consistencia dbil.
Definicin: un sistema lgico que no es Inconsistente se
dice que es consistente en sentido dbil
Programacin Lgica
Decidibilidad y Consistencia
Si A es un conjunto de clusulas lgicas consistentes,
denominadas Axiomas, y T es otra clusula, denominada
Teorema, entonces si T es una consecuencia lgica de A
se debe verificar:

1. El conjunto A T es consistente

2. El conjunto A T es inconsistente
Slo la segunda propiedad es verificable de forma efectiva,
de donde se deduce intuitivamente un procedimiento de
demostracin de teoremas que consiste en demostrar la
inconsistencia de A T . A este procedimiento se le
denomina de Resolucin por Refutacin del Teorema.
Programacin Lgica
Clusula resolvente
Sean dos clusulas, que denominaremos clusulas padres, que
contengan respectivamente, una misma proposicin, negada y sin
negar, cada una de ellas. Como es el caso de la proposicin p
1
en el
siguiente ejemplo:

p
1
v p
2
v ... v p
n

p
1
v q
2
v ... v q
m


Ambas clusulas forman parte de un sistema que se asume consistente
y, por tanto, son ciertas. Puede construirse entonces una nueva
clusula, denominada clusula resolvente a partir de la disyuncin de
ambas eliminando la proposicin que aparece doblemente. Esto es:

(p
1
v p
2
v ... v p
n
) v ( p
1
v q
2
v ... v q
m
)
(p
1
v p1) v (p2

v ... v p
n
v q
2
v ... v q
m
)
p
2
v ... v p
n
v q
2
v ... v q
m



Programacin Lgica
Clusula resolvente
La nueva clusula (clusula resolvente) debe ser cierta por cuanto las
clusulas padre forman un conjunto de clusulas consistente con lo que
el conjunto que resulta de aadir la clusula resolvente al conjunto de
clusulas anterior sigue siendo consistente.

Los siguientes son algunos ejemplos de la aplicacin del mtodo de la
clusula resolvente:

( p v q) v p q (modus ponens)
(p v q) v ( p v q) q
( p v p) nil (inconsistencia)
( p v q) v ( q v r) p v r (encadenamiento de reglas)
(p v q) v ( p v q) q v q (tautologa)

Ntese que en el ltimo caso, tambin podra resolverse sobre q y
obtendramos como clusula resolvente p v p. Lo que no es correcto
es resolver doblemente sobre p y q y obtener un resolvente nulo.


Programacin Lgica
Clusula resolvente
(p v q) v ( p v q) q v q (tautologa)

Una forma de ver que la doble resolucin es un error es considerar el
caso sencillo anterior cuando se resuelve doblemente. En ese caso
obtendramos la clusula nula, indicando una inconsistencia. Sin
embargo, podemos comprobar que ambas clusulas son consistentes
cuando ambos predicados son verdaderos, lo que indica que la
conclusin de inconsistencia que se deriva de la doble resolucin es
incorrecta.

La idea que subyace en el mtodo de resolucin se basa en que la
frmula ((p v o) . ( p v |)) (o v |) es una tautologa (demostrarlo
empleando una tabla de verdad).

Por el contrario, puede comprobarse que la frmula similar que debera
sustentar la doble resolucin, ((p v r v o) . ( p v r v |)) (o v |) ,
donde r es q o q, no es vlida.
Programacin Lgica
Resolucin por Refutacin
La resolucin por refutacin consiste esencialmente en aplicar el mtodo
de la clusula resolvente para eventualmente alcanzar el resolvente
nulo. Si esto es posible se habr demostrado la inconsistencia del
conjunto formado por los axiomas (cuya validez est garantizada) y el
teorema negado, en cuyo caso el teorema se considera demostrado.

a v b b v c a c
a v c
c
nil
Programacin Lgica
Resolucin por Refutacin
Para poder aplicar el mtodo de la clusula resolvente a predicados y no
slo a proposiciones es preciso primeramente unificar las clusulas para
conseguir que los trminos de los predicados complementarios sean
idnticos.

Ejemplo: Sean las siguientes clusulas padre.

p(X, f(a)) v p(X, f(Y)) v q(Y)
p(Z, f(a)) v q(Z)

Se puede encontrar un resolvente empleando bien p o bien q como
predicados complementarios. Si elegimos p, el unificador ser:

{ p(X, f(a)), p(Z, f(a)) } con la sustitucin u = { X Z }

que produce la clusula resolvente:

p(Z, f(Y)) v q(Y) v q(Z)
Programacin Lgica
Resolucin por Refutacin
Otra forma de generar una clusula resolvente ms sencilla consiste en
eliminar alguna de las realizaciones del mismo predicado p en alguna de
las clusulas padre. Por ejemplo, encontrando un unificador y
absorbiendo una de las realizaciones.

p(X, f(a)) v p(X, f(Y)) v q(Y)
p(Z, f(a)) v q(Z)

As : { p(X, f(a)), p(X, f(Y)) } con la sustitucin u = { Y a }

convierte las clusulas padre en:

p(X, f(a)) v q(a)
p(Z, f(a)) v q(Z)

Aplicando el unificador u = { Z X } resolviendo, obtenemos como
resolvente:

q(a) v q(X)
Programacin Lgica
Resolucin por Refutacin

Una idea clave:

Si el par de clusulas padre se toma de un
conjunto de clusulas consistentes, entonces,
dado que la clusula resolvente es una
consecuencia lgica de las anteriores, tambin es
consistente el conjunto resultante de aadir el
resolvente al conjunto original.
Programacin Lgica
Resolucin por Refutacin
Idea sobre la que se desarrolla el algoritmo:

Hasta que se encuentre la clusula nula se exploran pares de
clusulas padre, incluyendo - en caso de fracaso - el resolvente en el
conjunto de clusulas.

El proceso para si:

1. El resolvente generado es nulo: se ha demostrado el teorema.

2. Si no existe ningn par de clusulas que puedan producir un
resolvente, entonces no se puede demostrar la inconsistencia del
conjunto y se dice que el conjunto no es completo. Esto significa que
el teorema no es una consecuencia lgica de los axiomas y, por
tanto, se puede suponer falso.
Programacin Lgica
Algoritmo: Resolucin por Refutacin
0. Se supone que tanto los axiomas como la negacin del teorema han
sido transformados en clusulas.

1. Incluir en el conjunto de clusulas TRABAJO el conjunto de axiomas
y el teorema negado.

2. Repetir hasta que se produzca la clusula nula, o no se encuentre
ningn resolvente:

2.a Encontrar en TRABAJO un par de clusulas que puedan
resolverse y obtener el resolvente. Eliminar los elementos
duplicados.
2.b Descartar la clusula si contiene un predicado y su negacin.
2.c Si el resolvente no est en TRABAJO, aadirlo.

3. Si se ha encontrado la clusula nula, el teorema es cierto. En caso
contrario, el teorema se supone falso.
Programacin Lgica
Ejemplo:
Axiomas.
A.1 Cualquiera que puede leer es un ilustrado


A.2 Los delfines no son ilustrados


A.3 Algunos delfines son inteligentes


Teorema.
T. Algunos que son inteligentes, no pueden leer
Axiomas
A.1 Cualquiera que puede leer es un ilustrado
(X)(r(X) l(X))

A.2 Los delfines no son ilustrados
(X)(d(X) l(X))

A.3 Algunos delfines son inteligentes
(-X)(d(X) . i(X))

Teorema.
T. Algunos que son inteligentes, no pueden leer
(-X)(i(X) . r(X))
Programacin Lgica
Ejemplo: Paso a clusulas
Axiomas
A.1 (X)(r(X) l(X))

A.2 (X)(d(X) l(X))

A.3 (-X)(d(X) . i(X))

Teorema.
T. (-X)(i(X) . r(X))

r(X) v l(X)
d(Y) v l(Y)
d(a)
i(a)
donde a es una funcin de Skolem constante
i(Z) v r(Z)
Programacin Lgica
Ejemplo: Grafo de resolucin
r(X) v l(X)
d(Y) v l(Y)
d(a)
i(Z) v r(Z) i(a)
r(a)
l(a)
d(a)
{ }
{Z a}
{X a}
{Y a}
Programacin Lgica
El proceso de resolucin puede simplificarse si ,
previamente o durante el proceso se realizan determinadas
eliminaciones de clusulas, lo que equivale a una poda del
rbol de exploracin.
1. Eliminacin de tautologas. Eliminacin de clusulas tales
que puedan ser reducidad a una tautologa.

p(A) v q(B) v q(B)
2. Eliminacin por absorcin. Por definicin, una clusula
{Li} absorbe a otra {Mi} si existe una sustitucin s tal que
{Li}s es un subconjunto de {Mi}.

p(X) elimina a p(Y) v q(U)
p(X) elimina a p(a)
p(X) elimina a p(b) v q(Z)
p(X) v q(W) elimina a p(f(a,b)) v q(g(T)) v r(V)
3. Eliminacin procedimental. Cuando un predicado puede
ser evaluado (debido a mecanismos extralgicos o de tipo
procedimental) y se evala a cierto entonces es posible
eliminar la clusula que lo contiene. Si se evala a falso,
entonces simplemente se puede eliminar ese predicado de
la clusula.



Programacin Lgica
El proceso de resolucin descrito previamente es claramente
un sistema de exploracin de alternativas.

ESTADOS: Cada estado est constituido por la situacin del
conjunto de clusulas.
estado inicial: conjunto de axiomas+teorema negado
...
estado final: clusula nula.

OPERADORES: Generan nuevas clusulas.
* Considerando diferentes pares de clusulas padres
* Considerando un mismo para de clusulas padres,
pero unificndolas de diferentes maneras.
Programacin Lgica
Para realizar todo el proceso de exploracin es necesario
disponer de una estrategia que indique en cada situacin
qu accin realizar, bsicamente, como seleccionar los pares
de clusulas padres.

Veremos las siguientes estrategias de control:

Estrategia por niveles
Estrategia del conjunto soporte
Estrategia de la Unidad Preferente
Estrategia de Entrada Lineal
Programacin Lgica
Estrategia por Niveles
A partir del conjunto de clusulas
1. Se calculan todos los posibles resolventes
2. Se aaden stos a la base de datos
3. Algn resolvente es la clusula nula?. En caso afirmativo
terminar. En otro caso volver a 1.
r(X) v l(X) d(Y) v l(Y) d(a) i(Z) v r(Z) i(a)
r(a) i(Z) v l(Z) r(Y) v d(Y) l(a)
l(a) d(a) l(a) i(Z) v d(Z) r(a) i(a) i(Z) v d(Z)
{}
X X
Programacin Lgica
Estrategia del Conjunto Soporte
El primer nivel de resolventes se genera teniendo como clusula padre
a la clusula que resulta de negar el teorema.
Posteriormente, para el resto de resolventes siempre se toma como
mnimo un padre del conjunto de resolventes ya generado, al que se
denomina conjunto soporte. De esta manera todos los resolventes son
descendientes de la clusula del teorema.

El fundamento de esta estrategia radica en que si se alcanza la clusula
nula se deber a la clusula del teorema, ya que es sta la que podr
generar la inconsistencia del conjunto.
Programacin Lgica
r(X) v l(X) d(Y) v l(Y) d(a) i(Z) v r(Z) i(a)
r(a)
i(Z) v l(Z)
l(a)
i(Z) v d(Z)
l(a)
d(a) i(a)
d(a)
d(a)
{}
X
X
X
Programacin Lgica
Estrategia de la Unidad Preferente
Modificacin de la estrategia del Conjunto Soporte en la que slo se
genera un resolvente por nivel. Para formarlo se toma una clusula
padre del conjunto de resolventes y otra que se pueda resolver con l.
Evidentemente en el primer nivel se tomar la clusula del teorema
como una de las clusulas padre.
r(X) v l(X)
d(Y) v l(Y)
d(a)
i(Z) v r(Z) i(a)
r(a)
l(a)
d(a)
{}
Programacin Lgica
Estrategia de Entrada Lineal
En esta estrategia se toma como mnimo una clusula del conjunto de
clusulas iniciales. Esta estrategia no es completa, y puede no ser
adecuada en todos los problemas por cuanto puede conducir a una
situacin en la que no se pueda continuar con la refutacin, aunque el
teorema sea cierto.
r(X) v l(X) d(Y) v l(Y) d(a) i(Z) v r(Z) i(a)
r(a) i(Z) v l(Z) r(Y) v d(Y) l(a)
l(a) l(a) i(Z) v d(Z) r(a) i(Z) v d(Z)
X X
i(a)
{}
Programacin Lgica
Obtencin de respuestas
El procedimiento de Resolucin por Refutacin demuestra
teoremas del tipo (-X) p(X) para los que, adems de
concluir si el teorema es verdadero o falso, interesa
conocer el valor de X que satisface el teorema.

A este proceso se le denomina obtencin de repuestas

Se pueden emplear dos procedimientos
Programacin Lgica
Obtencin de respuestas
Procedimiento A:

1. Demostrar el teorema por el procedimiento ya explicado.

2. Aadir al conjunto de clusulas inicial, no el teorema
negado (p(X)), sino la disyuncin de ste con su negado,
es decir, (p(X) v p(X)) (una tautologa).

3. Seguir los mismos pasos que condujeron a la
demostracin del teorema. Dado que la clusula del teorema
contiene una tautologa no se concluir en el resolvente nulo,
sino que se concluir en la clusula del teorema.

4. La respuesta es el resolvente final.
Programacin Lgica
Ejemplo:

Axiomas: A1. (X)( juega(pedro, X) juega(luis, X))
A2. juega(pedro, ftbol).

Teorema: T. (-X) juega(luis, X)

El problema consiste en demostrar el teorema y, adems,
en saber a qu juega luis.
Programacin Lgica
Expresados en forma clausular y negando el teorema:

A1. juega(pedro, X) v juega(luis, X))
A2. juega(pedro, ftbol).
T. juega(luis, Y)

El rbol de refutacin sera:
juega(luis, Y) juega(pedro, X) v juega(luis, X)
juega(pedro, ftbol).
juega(pedro, X)
{}
{YX}
{Xftbol}
Programacin Lgica
Y la obtencin de la respuesta sera:
juega(luis, Y) v juega(luis, Y) juega(pedro, X) v juega(luis, X)
juega(pedro, ftbol). juega(pedro, X) v juega(luis, X)
juega(luis, ftbol)
{YX}
{Xftbol}
Programacin Lgica
Puede generalizarse el procedimiento anterior de manera
que en lugar de incluir la tautologa (p(X) v p(X)), se
incluya la clusula:

(p(X) v respuesta(X))

donde respuesta es un predicado comodn, que no puede
aparecer en el conjunto de axiomas.

Dado que este predicado no aparece en el resto del conjunto
es imposible que pueda desaparecer del rbol modificado de
refutacin y, por tanto, no se concluir en la clusula nula.
Programacin Lgica
Obtencin de respuestas
Procedimiento B:

1. Aadir al conjunto de clusulas de los axiomas la clusula
(p(X) v respuesta(X)). El predicado comodn debe contener
tantos trminos como respuestas se deseen, p.e.
(p(X,Y) v respuesta(X,Y))

2. Realizar la demostracin del teorema, utilizando como
objetivo no la clusula nula, sino una clusula que contiene
solamente el predicado comodn respuesta.

3. Las respuestas son los trminos del predicado comodn en
el estado final.
Programacin Lgica
Con este procedimiento, la obtencin de la respuesta sera:
juega(luis, Y) v respuesta(Y)
juega(pedro, X) v juega(luis, X)
juega(pedro, ftbol). juega(pedro, X) v respuesta(X)
respuesta(ftbol)
{YX}
{Xftbol}
Programacin Lgica
Problema:

A partir del siguiente conjunto de axiomas,
A1. X (c(X) s(X))
A2. X ( g(X) d(X))
A3. (-X (g(X) . c(X)))

Aplicar el mtodo de resolucin por refutacin para
demostrar los siguientes teoremas:

TEOREMA 1. X (s(X) . d(X))
TEOREMA 2. X ( s(X) d(X))

NOTA: Es importante detallar bien cada paso del proceso
de demostracin

Programacin Lgica
Problema:

Convirtiendo en clusulas:
A1. c(X) v s(X)
A2. g(Y) v d(Y)
A3. g(Z) v c(Z)

Negando los teoremas:
T1. (X (s(X) . d(X)))
T2. (X ( s(X) d(X)))

Conviertiendo los teoremas negados en clusulas:
T1. s(f) v d(f)
T2. s(f)
d(f)


Programacin Lgica
Resolvamos primero para el T2
c(X) v s(X)
g(Y) v d(Y)
g(Z) v c(Z)
d(f)
g(f)
c(f)
s(f) s(f)
{}
{Y f}
{Z f}
{X f}
Programacin Lgica
Resolvamos para el T1
c(X) v s(X)
g(Y) v d(Y)
g(Z) v c(Z)
s(f) v d(f)
s(f) v g(f)
s(f) v c(f)
c(f) v c(f)
OJO: No se puede resolver doblemente
{Y f}
{Z f}
{X f}
Programacin Lgica
Sistemas de Deduccin
Un conjunto de procedimientos de demostracin de
teoremas que utilizan esquemas diferentes al de
refutacin.

Procedimientos directos: porque emplean el conjunto
de axiomas y el teorema sin negar

Como estrategia de control: exploracin de
alternativas.

Sistemas de deduccin Hacia-Delante
Sistemas de deduccin Hacia-Atrs
Programacin Lgica
Sistemas de Deduccin
S.D. Hacia-Delante:

Se parte de los axiomas y se trata de llegar al
teorema por aplicacin de reglas de inferencia.
Evidentemente, sto slo ser posible si el teorema
es una consecuencia lgica de los axiomas.
S.D. Hacia-Atrs:

Se parte del teorema y, por aplicacin de reglas de
inferencia, se intenta llegar a unos hechos
completamente ciertos.
Programacin Lgica
Hechos, Reglas y Objetivos
Los elementos que intervienen en la deduccin son:
Reglas: Son aquellos axiomas que contienen una
implicacin, con antecedentes y consecuentes
Hechos: Se denominan as a los axiomas que no
contienen una implicacin. Son elementos sin
condiciones.
Meta u Objetivo: Designa al teorema a demostrar.
Programacin Lgica
Hechos, Reglas y Objetivos
Nomenclatura de Kowalsky:
Reglas: b
1
v b
2
v b
3
v ... v b
m
a
1
. a
2
. ... . a
n

Hechos: b
1
v b
2
v b
3
v ... v b
m

Meta u Objetivo: a
1
. a
2
. ... . a
n

donde a
i
y . b
j
representan predicados lgicos
Programacin Lgica
Hechos, Reglas y Objetivos
Se puede simplificar esta nomenclatura si se admite la
sustitucin de operadores por comas que el antecedente
representarn conjunciones y el consecuente
disyunciones. Si nos restrigimos, adems, a considerar
slo clusulas de Horn:
Reglas: b a
1
, a
2
, ... , a
n

Hechos: b
Meta u Objetivo: a
1
, a
2
, ... , a
n

Programacin Lgica
Deduccin progresiva o Hacia-Delante
Se parte de los hechos como elementos bsicos de
transformacin. Intuitivamente, el procedimiento puede
resumirse de la siguiente forma, suponiendo que a
1
es un
predicado unificable con algn antecedente o subobjetivo:
a
1

c a
1
, a
2
, ... , a
n

a
1
, o
2
, ... , o
m

a
1

c a
2
, ... , a
n

o
2
, ... , o
m

A partir de:
Se deduce:
Programacin Lgica
Deduccin progresiva o Hacia-Delante
Cuando se trata de una regla con un nico antecedente,
el resultado es la generacin de un nuevo hecho
a
1

c a
1

a
1
, o
2
, ... , o
m

a
1

c
o
2
, ... , o
m

A partir de:
Se deduce:
Programacin Lgica
Deduccin progresiva o Hacia-Delante
El objetivo es llegar al objetivo vaco, es decir:
a
1

c a
2
, ... , a
n

A partir de:
Se deduce:
a
1

c a
1
, a
2
, ... , a
n

a
1

Programacin Lgica
Deduccin progresiva o Hacia-Delante
El procedimiento consiste, en esencia, en generar
nuevos hechos por reduccin de los antecedentes de
las reglas, y en reducir el objetivo, por aplicacin de los
hechos originales o los generados, hasta alcanzar el
objetivo vaco, lo que equivale a haber satisfecho todos
los subojetivos.
Programacin Lgica
Deduccin progresiva o Hacia-Delante
1. Formular el problema en trminos de hechos, reglas y objetivos como
clusulas de Horn, y aadirlos a una base de datos inicialmente vaca.
2. Hasta que el objetivo est vaco o no existan sustituciones aplicables.
2.1 Partiendo de algn hecho disponible, encontrar una regla con un
antecedente, o un subobjetivo, que pueda ser sustituido, previa
unificacin, con el hecho en cuestin




2.2 Aadir a la base de datos, la siguiente regla o subobjetivo, donde
u es la unificacin ms general de la sustitucin:



3. Si el objetivo est vaco, entonces el objetivo es cierto y las posibles
respuestas vienen dadas por la secuencia de unificaciones. En otro caso,
el objetivo no se puede verificar.
a
1

c a
1
, a
2
, ... , a
n

a
1
, o
2
, ... , o
m

(c a
2
, ... , a
n
) u
( o
2
, ... , o
m
) u
Programacin Lgica
Ejemplo:
Antonio y Miguel son dos amigos miembros de un club
alpino. Cada miembro de este club que no es esquiador
es escalador.

A los escaladores les disgusta la lluvia y, por otra parte, a
los que les disgusta la nieve no son esquiadores.

Ambos amigos tienen gustos diferentes, de tal forma que
a Miguel le disgusta los que a Antonio le gusta, y le
gusta lo que a Antonio le disgusta.

A Antonio le gustan la nieve y la lluvia.

Existe algn miembro del club que sea escalador?.
Quin?.

Programacin Lgica
Antonio y Miguel son dos amigos
miembros de un club alpino.
Cada miembro de este club que
no es esquiador es escalador.

A los escaladores les disgusta la
lluvia y,por otra parte,
a los que les disgusta la nieve no
son esquiadores.

Ambos amigos tienen gustos
diferentes, de tal forma que a
Miguel le disgusta los que a
Antonio le gusta,
y le gusta lo que a Antonio le
disgusta.

A Antonio le gustan la nieve y la
lluvia.

Existe algn miembro del club
que sea escalador?. Quin?.
escalador(X) no_esquiador(X)
disgusta(Y, lluvia) escalador(Y)
no_esquiador(Z) disgusta(Z, nieve)
disgusta(miguel, C) gusta(antonio, C)
gusta(miguel, A) disgusta(antonio, A)
gusta(antonio, lluvia)
gusta(antonio, nieve)
escalador(Quien)
Programacin Lgica
Partiendo de los dos nicos hechos iniciales, el proceso de
deduccin podra ser el siguiente:
gusta(antonio, lluvia)
{ C lluvia }
disgusta(miguel, lluvia)
escalador(X) no_esquiador(X)
disgusta(Y, lluvia) escalador(Y)
no_esquiador(Z) disgusta(Z, nieve)
disgusta(miguel, C) gusta(antonio, C)
gusta(miguel, A) disgusta(antonio, A)
gusta(antonio, lluvia)
gusta(antonio, nieve)
escalador(Quien)
disgusta(miguel, C) gusta(antonio, C)
Programacin Lgica
Partiendo de los dos nicos hechos iniciales, el proceso de
deduccin podra ser el siguiente:
gusta(antonio, nieve)
{ C nieve}
disgusta(miguel, nieve)
escalador(X) no_esquiador(X)
disgusta(Y, lluvia) escalador(Y)
no_esquiador(Z) disgusta(Z, nieve)
disgusta(miguel, C) gusta(antonio, C)
gusta(miguel, A) disgusta(antonio, A)
gusta(antonio, lluvia)
gusta(antonio, nieve)
escalador(Quien)
disgusta(miguel, C) gusta(antonio, C)
no_esquiador(Z) disgusta(Z, nieve)
{ Z miguel}
no_esquiador(miguel)
escalador(X) no_esquiador(X)
{ X miguel}
escalador(miguel)
escalador(Quien)
{ Quien miguel}

Conclusin: al menos
un escalador, miguel
Programacin Lgica
Deduccin regresiva o Hacia-Atrs
Intuitivamente el procedimiento consiste en deducir el
objetivo por aplicacin sobre el mismo de las reglas y
hechos.
Si existe algn subobjetivo a
1
que pueda ser sustituido por
un hecho, entonces el mismo est satisfecho:
a
1

a
1
, o
2
, ... , o
m

a
1

o
2
, ... , o
m

A partir de:
Se deduce:
Programacin Lgica
En caso contrario, y cuando el subobjetivo b puede ser
sustituido por el consecuente de una regla, entonces el
objetivo se modifica sustituyendo el subobjetivo por los
antecedentes de la regla:
b a
1
, a
2
, ..., a
n

b , o
2
, ... , o
m
b a
1
, a
2
, ..., a
n

a
1
, a
2
, ..., a
n
, o
2
, ... , o
m
A partir de:
Se deduce:
Deduccin regresiva o Hacia-Atrs
Programacin Lgica
Deduccin regresiva o Hacia-Atrs
En este ltimo caso, el nuevo objetivo es ms complejo
al poseer ms subobjetivos, pero se supone que cada
uno de ellos es de menor complejidad, esto es, ms
cercanos a un hecho.
El resultado final se alcanza cuando se reduce al vaco el
objetivo, lo que indicar que se han satisfecho todos los
subobjetivos.
Programacin Lgica
1. Formular el problema en trminos de hechos, reglas y objetivos como
clusulas de Horn, y aadirlos a una base de datos inicialmente vaca.
2. Hasta que el objetivo est vaco o no existan sustituciones aplicables.
2.1 Partiendo del objetivo, encontrar algn hecho o consecuente de
regla que pueda que pueda ser sustituido, previa unificacin, con
algn subobjetivo




2.2 Aadir a la base de datos, el siguiente objetivo, donde u es la
unificacin ms general de la sustitucin:



3. Si el objetivo est vaco, entonces el objetivo es cierto y las posibles
respuestas vienen dadas por la secuencia de unificaciones. En otro caso,
el objetivo no se puede verificar.
p


p a
1
, a
2
, ... , a
n

p , o
2
, ... , o
m

( o
2
, ... , o
m
) u
( a
1
, a
2
, ... , a
n
, o
2
, ... , o
m
) u
Deduccin regresiva o Hacia-Atrs
Programacin Lgica
Antonio y Miguel son dos amigos
miembros de un club alpino.
Cada miembro de este club que
no es esquiador es escalador.

A los escaladores les disgusta la
lluvia y,por otra parte,
a los que les disgusta la nieve no
son esquiadores.

Ambos amigos tienen gustos
diferentes, de tal forma que a
Miguel le disgusta los que a
Antonio le gusta,
y le gusta lo que a Antonio le
disgusta.

A Antonio le gustan la nieve y la
lluvia.

Existe algn miembro del club
que sea escalador?. Quin?.
escalador(X) no_esquiador(X)
disgusta(Y, lluvia) escalador(Y)
no_esquiador(Z) disgusta(Z, nieve)
disgusta(miguel, C) gusta(antonio, C)
gusta(miguel, A) disgusta(antonio, A)
gusta(antonio, lluvia)
gusta(antonio, nieve)
escalador(Quien)
Programacin Lgica
Partiendo del teorema:
escalador(Quien)
{ X Quien}
no_esquiador(Quien)
escalador(X) no_esquiador(X)
disgusta(Y, lluvia) escalador(Y)
no_esquiador(Z) disgusta(Z, nieve)
disgusta(miguel, C) gusta(antonio, C)
gusta(miguel, A) disgusta(antonio, A)
gusta(antonio, lluvia)
gusta(antonio, nieve)
escalador(Quien)
disgusta(miguel, C) gusta(antonio, C)
no_esquiador(Z) disgusta(Z, nieve)
{ Z Quien}
disgusta(Quien, nieve)
escalador(X) no_esquiador(X)
{ Quien miguel,
C nieve }
gusta(antonio, nieve)
{ }

Conclusin: al menos
un escalador, miguel
gusta(antonio, nieve)
Programacin Lgica
En el proceso de exploracin pueden producirse diversas
situaciones anmalas como las siguientes
Bucles: Cuando la resolucin de un objetivo conduce a que
el mismo objetivo o alguno de sus sucesores se vuelva a
plantear de nuevo como objetivo.

Desbordamientos: Cuando la resolucin de un objetivo
conduzca a un objetivo, que ni pueda ser reducido, ni
presente condicin de parada, es decir, que siempre
existen reglas aplicables.

Duplicacin de objetivos: Cuando se suscita la resolucin
de un objetivo ya resuelto con anterioridad.
Programacin Lgica
Ejemplo de bucle debido a un problema mal definido.
rel(a, b)
rel(a, c)
alt(a, d)
rel(A, B) alt(A, B)
alt(X, Y) rel (a, Y)
rel(a, D)
rel(a, D)
rel(a, b)
rel(a, c)
alt(a, D)
alt(a, d) rel(a, D)
{D b} {D c}
{A a
B D}
{D b} {X a, Y D}
Programacin Lgica
1
rel(a, b)
2
rel(a, c)
1
alt(a, d)
3
rel(A, B) alt(A, B)
2
alt(X, Y) rel (a, Y)
rel(a, D)
[rel(a, D)]
[
1
rel(a, D)] [
2
rel(a, D)] [
3
rel(a, D)]
{D b}
[
1
rel(a, b)] [
2
rel(a, D)] [
3
rel(a, D)]
[ ] [
2
rel(a, D)] [
3
rel(a, D)]
[
2
rel(a, D)] [
3
rel(a, D)]
{D c}
[
2
rel(a, c)] [
3
rel(a, D)]
[ ] [
3
rel(a, D)]
[
3
rel(a, D)]
{A a, B D}
[alt(a, D)]
[
1
alt(a, D)] [
2
alt(a, D)]
[
1
alt(a, D)] [
2
alt(a, D)]
{D d}
[
1
alt(a, d)] [
2
alt(a, D)]
[ ] [
2
alt(a, D)]
{X a, Y D }
[rel(a, D)]
Programacin Lgica
Jack es dueo de un perro
Quien es dueo de un perro es un amante de los animales
Ningn amante de los animales mata a un animal
O Jack o Curiosidad mat al gato, cuyo nombre era Tuna
Mat Curiosidad al gato?
Programacin Lgica
A. Jack es dueo de un perro
B. Quien es dueo de un perro es un amante de los animales
C. Ningn amante de los animales mata a un animal
D. O Jack o Curiosidad mat al gato, cuyo nombre era Tuna
E. Mat Curiosidad al gato?
1. Expresin como predicados de primer orden
A. (-X) perro(X) . dueo(jack, X)
B. (X) {(-Y) perro(Y) . dueo(X, Y)} naturalista(X)
C. (X) (Y) naturalista(X) . animal(Y) mata(X,Y)
D1. mata(jack, tuna) v mata(curiosidad, tuna)
D2. gato(tuna)
E. mata(curiosidad, tuna)
Es necesario aadir que los gatos son animales
F. (X) gato(X) animal(X)
Programacin Lgica
2. Transformacin a clusulas
Negacin del teorema:
E. mata(curiosidad, tuna)

2.1 Eliminacin de la implicaciones

B. (X) {(-Y) perro(Y) . dueo(X, Y)} naturalista(X)
C. (X) (Y) naturalista(X) . animal(Y) mata(X,Y)
F. (X) gato(X) animal(X)

B. (X) {(-Y) perro(Y) . dueo(X, Y)} v naturalista(X)
C. (X) (Y) { naturalista(X) . animal(Y)} v mata(X,Y)
F. (X) gato(X) v animal(X)

Programacin Lgica
2. Transformacin a clusulas
2.2 Mover las negaciones hasta las frmulas atmicas

B. (X) {(-Y) perro(Y) . dueo(X, Y)} v naturalista(X)
C. (X) (Y) { naturalista(X) . animal(Y)} v mata(X,Y)


B. (X) {(Y) perro(Y) v dueo(X, Y)} v naturalista(X)
C. (X) (Y) naturalista(X) v animal(Y) v mata(X,Y)

Programacin Lgica
2. Transformacin a clusulas
2.3 Renombrar variables

A. (-X) perro(X) . dueo(jack, X)
B. (Y) {(Z) perro(Z) v dueo(Y, Z)} v naturalista(Y)
C. (U) (W) naturalista(U) v animal(W) v mata(U,W)
F. (C) gato(C) v animal(C)
2.4 Eliminar los cuantificadores existenciales

A. (-X) perro(X) . dueo(jack, X)

A. perro(a) . dueo(jack, a)
donde a es una funcin de Skolem constante
Programacin Lgica
2. Transformacin a clusulas
2.5 Desplazar los cuantificadores universales hasta el
comienzo de las frmulas

B. (Y) {(Z) perro(Z) v dueo(Y, Z)} v naturalista(Y)

B. (Y) (Z) perro(Z) v dueo(Y, Z) v naturalista(Y)

2.6 Convertir los operadores AND en los ms externos
2.7 Eliminar los cuantificadores universales
2.8 Eliminar los conectores AND
Programacin Lgica
2. Transformacin a clusulas
Conjunto de clusulas resultante

A.1 perro(a)
A.2 dueo(jack,a)
B. perro(Z) v dueo(Y, Z) v naturalista(Y)
C. naturalista(U) v animal(W) v mata(U,W)
D1. mata(jack, tuna) v mata(curiosidad, tuna)
D2. gato(tuna)
E. mata(curiosidad, tuna)
F. gato(C) v animal(C)
Programacin Lgica
3. Resolucin por refutacin
mata(curiosidad, tuna) mata(jack, tuna) v mata(curiosidad, tuna)
mata(jack, tuna)
naturalista(U) v animal(W) v mata(U,W)
naturalista(jack) v animal(tuna)
perro(Z) v dueo(Y, Z) v naturalista(Y)
perro(Z) v dueo(jack, Z) v animal(tuna)
dueo(jack, a)
perro(a) v animal(tuna)
gato(C) v animal(C)
gato(tuna) v perro(a)
gato(tuna)
perro(a)
perro(a)
[ ]
{U jack, W tuna}
{Y jack}
{Z a}
{C a}
Programacin Lgica
Expresar como clusulas de Horn:
A) caballos, vacas y cerdos son mamferos
B) el hijo de un caballo es un caballo
C) centella es un caballo
D) centella es el padre de chispas
E) hijo y padre son relaciones inversas
F) todo mamfero tiene un padre
y, mediante deduccin hacia atrs, contestar a la pregunta:
Cuntos caballos conocemos?
Programacin Lgica
A) mamfero(X) vaca(X)
mamfero(Y) cerdo(Y)
mamfero(Z) caballo(Z)
B) caballo(centella)
C) caballo(W) caballo(U), hijo(W, U)
D) padre(centella, chispas)
E) padre(S, R) hijo(R, S)
hijo(P, Q) padre(Q, P)
F) padre(L, M) mamfero(M)

Programacin Lgica
A)
1
mamfero(X) vaca(X)

2
mamfero(Y) cerdo(Y)

3
mamfero(Z) caballo(Z)
B)
1
caballo(centella)
C)
2
caballo(W) caballo(U), hijo(W, U)
D)
1
padre(centella, chispas)
E)
2
padre(S, R) hijo(R, S)
hijo(P, Q) padre(Q, P)
F)
3
padre(L, M) mamfero(M)
El objetivo: caballo(M)

Programacin Lgica
[caballo(H)]
[
1
caballo(H)] [
2
caballo(H)] {H centella}
[caballo(centella)] [
2
caballo(H)]
[ ] [
2
caballo(H)] {W H}
[caballo(U), hijo(H,U)]
[
1
caballo(U), hijo(H,U)] [
2
caballo(U), hijo(H,U)] {U centella}
[caballo(centella), hijo(H, centella)] [
2
caballo(U), hijo(H,U)]
[hijo(H, centella)] [
2
caballo(U), hijo(H,U)] {P H, Q centella}
[padre(centella, H)] [
2
caballo(U), hijo(H,U)]
[
1
padre(centella, H)] [
2
padre(centella, H)]
[
3
padre(centella, H)] [
2
caballo(U), hijo(H,U)]
{H chispas}
[padre(centella, chispas)] [
2
padre(centella, H)]
[
3
padre(centella, H)] [
2
caballo(U), hijo(H,U)]
Programacin Lgica
[ ] [
2
padre(centella, H)] [
3
padre(centella, H)] [
2
caballo(U), hijo(H,U)]
{S centella, R H}
[hijo(H, centella)] [
3
padre(centella, H)] [
2
caballo(U), hijo(H,U)]
{P H, Q centella}
[padre(centella, H)] [
3
padre(centella, H)] [
2
caballo(U), hijo(H,U)]
[
1
padre(centella, H)] [
2
padre(centella, H)]
[
3
padre(centella, H)]
[
3
padre(centella, H)] [
2
caballo(U), hijo(H,U)]
...
A partir de aqu slo obtendremos una nica respuesta H= chispas
Programacin Lgica
Cul sera ahora el resultado si cambisemos el orden de las
definiciones del predicado caballo?
A)
1
mamfero(X) vaca(X)

2
mamfero(Y) cerdo(Y)

3
mamfero(Z) caballo(Z)
C)
2
caballo(W) caballo(U), hijo(W, U)
B)
1
caballo(centella)
D)
1
padre(centella, chispas)
E)
2
padre(S, R) hijo(R, S)
hijo(P, Q) padre(Q, P)
F)
3
padre(L, M) mamfero(M)
El objetivo: caballo(M)

Programacin Lgica
[caballo(H)]
[
2
caballo(H)] [
1
caballo(H)] {W H}
[caballo(U), hijo(H, U)][
1
caballo(centella)]
[
2
caballo(U), hijo(H, U)] [
1
caballo(U), hijo(H, U)][
1
caballo(H)]
{W U}
[caballo(F), hijo(U, F), hijo(H, U)] [
1
caballo(U), hijo(H, U)][
1
caballo(H)]
[
2
caballo(F), hijo(U, F), hijo(H, U)]
[
1
caballo(F), hijo(U, F), hijo(H, U)]
[
1
caballo(U), hijo(H, U)][
1
caballo(H)]
...
Y finalmente la pila se desbordara
Programacin Lgica
Supongamos ahora que intercambiamos el orden de las premisas de
la regla C. Qu pasara?
A)
1
mamfero(X) vaca(X)

2
mamfero(Y) cerdo(Y)

3
mamfero(Z) caballo(Z)
B)
1
caballo(centella)
C)
2
caballo(W) hijo(W, U), caballo(U).
D)
1
padre(centella, chispas)
E)
2
padre(S, R) hijo(R, S)
hijo(P, Q) padre(Q, P)
F)
3
padre(L, M) mamfero(M)
El objetivo: caballo(M)

Programacin Lgica
[caballo(H)]
[
1
caballo(H)] [
2
caballo(H)] {H centella}
[caballo(centella)] [
2
caballo(H)]
[ ] [
2
caballo(H)] {W H}
[hijo(H,U), caballo(U)] {P U, Q H}
[padre(U, H), caballo(U)]
[
1
padre(U, H), caballo(U)] [
2
padre(U, H), caballo(U)]
[
3
padre(U, H), caballo(U)]
{U centella, H chipas}
[
1
padre(centella, chispas), caballo(centella)] [
2
padre(U, H), caballo(U)]
[
3
padre(U, H), caballo(U)]
[caballo(centella)] [
2
padre(U, H), caballo(U)] [
3
padre(U, H), caballo(U)]
[
1
caballo(centella)] [
2
caballo(centella)]
[
2
padre(U, H), caballo(U)] [
3
padre(U, H), caballo(U)]
Programacin Lgica
[
1
caballo(centella)] [
2
caballo(centella)]
[
2
padre(U, H), caballo(U)] [
3
padre(U, H), caballo(U)]
[ ] [
2
caballo(centella)]
[
2
padre(U, H), caballo(U)] [
3
padre(U, H), caballo(U)]
{W centella}
[hijo(centella, F), caballo(F)]
[
2
padre(U, H), caballo(U)] [
3
padre(U, H), caballo(U)]
...
Repetiramos la misma demostracin anterior, con otros
argumentos, y finalmente la pila se desbordara
Programacin Lgica
p(a, b)
p(a, X) r(X)
r(c)
r(d)
p(Y, Z) q(Y, Z)
q(a, e)
q(U, V) s(W), p(W, V)
s(a)
s(f)
p(a, R)

Realizar la traza de la pila
de demostracin del
teorema indicado
Programacin Lgica
Problema. La funcin cons(X,Y) denota la lista formada insertando
X en la cabeza de la lista Y. As podemos representar la lista vaca
por nil; la lista (2) por cons(2, nil); la lista (1,2) por cons(1, cons(2,
nil)); y as sucesivamente. La formula last(lista, ultimo) devuelve
en ultimo el ltimo elemento de la lista lista. Supongamos los
siguientes axiomas:

( U) [last(cons(U, nil), U)]
( X, Y, Z) [last(Y, Z) last(cons(X, Y), Z)]

Probar por resolucin por refutacin el siguiente teorema:
(- V) [last(cons(2, cons(1, nil)), V)]

Emplear el mtodo de obtencin de respuestas para encontrar el
valor de V, el ltimo elemento de la lista (1,2).

Programacin Lgica
Bibliografa.

[Mend-92] J. Mndez
Apuntes del Curso de I.A.
U.L.P.G.C.

[Nils-82] N. J. Nilsson
Principles of Artificial Intelligence
Springer-Verlag, 1982.

[Apt-97] K.R. Apt,
From Logic Programming to Prolog
Prentice-Hall, 1997.

[Nils-98 ] N. J. Nilsson
Artificial Intelligence
Morgan Kaufmann, 1998.