Tutorial ..

Editado y corregido por Elicer Pineda Ballesteros Pgina 1
Programacin Lgica Lenguaje Prolog y Visual Prolog

INTRODUCCIN A LA
PROGRAMACIN LGICA
Y
VISUAL PROLOG V 5.2
1

Inteligencia Artificial y
Sistemas Expertos

1 Material recopilado de las pginas personales de la profesora Nieves Pavn de la Universidad
de Huelva y el profesor Omar Valdivia de la Universidad de Santiago de Chile. Texto editado por
Elicer Pineda Ballesteros. Webs: http://www.uhu.es/nieves.pavon/pprogramacion/practicas/ y
www.comenius.usach.cl/gvillarr/cursoia/Guias/Guia%201%20VPI.doc

NDICE
1 Lenguaje PROLOG: Conceptos ............................................................................................... 6
2 Bases del lenguaje PROLOG.................................................................................................... 6
2.1 Metodologa declarativa frente a metodologa imperativa. ......................................................................... 6
2.2 Ventajas e inconvenientes. ........................................................................................................................ 7
3 Definicin de Hechos, Metas y Predicados en PROLOG ...................................................... 7
3.1 Construccin de Bases de Conocimientos en PROLOG ......................................................................... 10
3.2 Consultas sobre la Base de Conocimientos ............................................................................................ 12
3.3 Ejemplos .................................................................................................................................................. 15
4 Definicin y funcionamiento de la Mquina PROLOG ......................................................... 20
4.1 Unificacin ............................................................................................................................................... 20
4.2 Backtracking ............................................................................................................................................ 21
5 Sintaxis Bsica de VISUAL PROLOG .................................................................................... 24
5.1 Aritmtica de VISUAL PROLOG .............................................................................................................. 24
6 Datos simples y Estructuras de Datos: DOMINIOS ............................................................. 27
6.1 OBJETOS COMPUESTOS ...................................................................................................................... 27
6.2 RBOLES ................................................................................................................................................ 28
6.3 LISTAS .................................................................................................................................................... 30
6.4 MATRICES .............................................................................................................................................. 34
7 Manipulacin del Control en Prolog ...................................................................................... 36
8 Corte (!) y fail............................................................................................................................ 36
8.1 El Corte "!" ............................................................................................................................................... 36
8.2 El predicado fail ....................................................................................................................................... 39
8.3 Implementacin de la negacin y predicado repeat ................................................................................. 40
9 Aplicaciones actuales del Lenguaje PROLOG ..................................................................... 43
9.1 Inteligencia Artificial ................................................................................................................................. 43
9.2 Sistemas Expertos ................................................................................................................................... 49

9.3 Compiladores ........................................................................................................................................... 50
9.4 Miscelnea ............................................................................................................................................... 52
10 Lneas Futuras ......................................................................................................................... 53
11 Introduccin. ............................................................................................................................ 56
11.1 Conceptos bsicos................................................................................................................................... 56
11.2 Resolucin y unificacin. Mtodos. .......................................................................................................... 59
12 Entorno De Desarrollo De Visual Prolog .................................... Error! Marcador no definido.
12.1 Secciones De Un Programa En Visual Prolog ............................................ Error! Marcador no definido.
12.2 Directivas de compilacin ........................................................................... Error! Marcador no definido.
12.3 Seccin de constantes ................................................................................ Error! Marcador no definido.
12.4 Seccin de dominios ................................................................................... Error! Marcador no definido.
12.5 Dominios de Objetos Compuestos ............................................................. Error! Marcador no definido.
12.6 Dominios de Objetos Compuestos Functorless .......................................... Error! Marcador no definido.
12.7 Sinnimos de Dominios Estndar ............................................................... Error! Marcador no definido.
12.8 Dominios tipo Lista...................................................................................... Error! Marcador no definido.
12.9 Dominios tipo Predicado ............................................................................. Error! Marcador no definido.
12.10 Seccin de la base de datos ......................................................... Error! Marcador no definido.
12.11 Seccin de definicin de predicados ............................................ Error! Marcador no definido.
12.12 Tipos de predicados ..................................................................... Error! Marcador no definido.
12.13 Cmo conseguir la coherencia entre reglas y predicados en el aspecto determinista ........ Error!
Marcador no definido.
12.14 Seccin de clusulas .................................................................... Error! Marcador no definido.
12.15 Seccin de meta u objetivo ........................................................... Error! Marcador no definido.
12.16 Ejemplo ......................................................................................... Error! Marcador no definido.
13 El Entorno De Desarrollo De Visual Prolog ............................... Error! Marcador no definido.
13.1 Aplicaciones orientadas a eventos ............................................................. Error! Marcador no definido.
13.2 Aplicaciones orientadas a eventos en Visual Prolog .................................. Error! Marcador no definido.
13.3 Tipos de ventanas en Visual Prolog............................................................ Error! Marcador no definido.
13.4 Programa Cero ........................................................................................... Error! Marcador no definido.
13.4.1 Pasos para realizar una Aplicacin Experta ................................. Error! Marcador no definido.

13.4.2 Realizar una aplicacin Hello World ........................................... Error! Marcador no definido.
13.4.3 Aadir un cuadro de mensaje en la aplicacin Experta. ............... Error! Marcador no definido.
13.4.4 Crear "Cross Window" ................................................................ Error! Marcador no definido.
13.4.5 Cmo crear una nueva ventana .................................................... Error! Marcador no definido.
13.4.6 Generando cdigo para la venta ................................................... Error! Marcador no definido.
13.4.7 Comprobando que eventos inician en la ventana ......................... Error! Marcador no definido.
13.4.8 Ms operaciones con dibujos ....................................................... Error! Marcador no definido.
13.4.9 Creando curvas en una ventana ................................................... Error! Marcador no definido.
13.4.10 Creando un Bitmap .................................................................. Error! Marcador no definido.
13.4.11 Creando una Toolbar ............................................................... Error! Marcador no definido.
13.4.12 Creando una ventana .............................................................. Error! Marcador no definido.
13.4.13 La Toolbar Expert ................................................................... Error! Marcador no definido.
13.4.14 Dibujando con un Mouse Sweep ............................................ Error! Marcador no definido.
13.4.15 El evento Mouse Down ............................................................ Error! Marcador no definido.
13.4.16 El evento e_MouseUp ............................................................. Error! Marcador no definido.
13.4.17 El evento e_Update ................................................................. Error! Marcador no definido.
13.4.18 Manejando la Toolbar ............................................................. Error! Marcador no definido.
13.4.19 Cleaning Up ............................................................................. Error! Marcador no definido.
13.4.20 Cambiando el cursor del Mouse .............................................. Error! Marcador no definido.
13.4.21 Ajustando el cursor .................................................................. Error! Marcador no definido.
13.4.22 Creando un menu Pop-Up ....................................................... Error! Marcador no definido.
13.4.23 Cambiando el color del dibujo.................................................. Error! Marcador no definido.
13.4.24 Usando un Timer - El reloj de Window ................................... Error! Marcador no definido.
13.4.25 Using Timers............................................................................ Error! Marcador no definido.
13.4.26 The e_Size Event for the Clock Window .................................. Error! Marcador no definido.
13.4.27 La ventana pintada ................................................................. Error! Marcador no definido.
13.4.28 Creando una ventana rbol ..................................................... Error! Marcador no definido.
13.5 Primer Programa en Prolog ........................................................................ Error! Marcador no definido.
13.6 El entorno VPI ............................................................................................. Error! Marcador no definido.
13.7 El segundo programa VPI ........................................................................... Error! Marcador no definido.
13.7.1 CREAR UNA APLICACIN DESDE CERO ................................. Error! Marcador no definido.
13.7.2 Pestaa General ........................................................................... Error! Marcador no definido.
13.7.3 Pestaa Target ............................................................................. Error! Marcador no definido.
13.7.4 Pestaa VPI Options .................................................................... Error! Marcador no definido.
13.7.5 Pestaa User Info ......................................................................... Error! Marcador no definido.
13.7.6 Disear La Ventana Principal ....................................................... Error! Marcador no definido.
13.7.7 Insertar Cdigo En El Programa ................................................... Error! Marcador no definido.

13.7.8 Ejecutar La Aplicacin Y Eliminar Componentes Adicionales....... Error! Marcador no definido.
13.7.9 Eliminacin de men emergente .................................................. Error! Marcador no definido.
El tercer programa VPI ........................................................................................ Error! Marcador no definido.
13.7.10 Crear Una Aplicacin Desde Cero ........................................... Error! Marcador no definido.
13.7.11 Disear La Ventana Principal .................................................. Error! Marcador no definido.
13.7.12 Disear Ventanas De Tipo Dialog ............................................ Error! Marcador no definido.
13.7.13 Insertar Cdigo De Los Dialog Al Programa Principal ........... Error! Marcador no definido.
13.7.14 Insertar Codigo En El Programa Principal ............................... Error! Marcador no definido.
13.7.15 Ejecutar La Aplicacin Y Eliminar Componentes Adicionales . Error! Marcador no definido.
13.7.16 Eliminacin de men emergente ............................................. Error! Marcador no definido.

CAPTULO 1
1 Lenguaje PROLOG: Conceptos
PROLOG constituye la primera realizacin prctica de un concepto de programacin orientado ms a
modelar la forma de entender un tipo de problemas que a la forma concreta de calcular las soluciones de
esos problemas. Esto quiere decir que se debe realizar un esfuerzo para modelar formalmente los
enunciados que definen los problemas en lugar de aportar los pasos concretos que resuelven dicho
problema. Por ejemplo, si se nos plantea el problema de resolver el factorial de un nmero, podemos
modelar el enunciado como: factorial(1)=1 y factorial(N)=N*factorial(N-1), en lugar de especificar de forma
imperativa los pasos individuales que resuelven el factorial a travs de asignaciones y operaciones.
Por tanto, para entender la programacin lgica, lo que necesitamos es adaptar nuestro lenguaje a un
lenguaje matemtico ms formal que nos permita expresar nuestros enunciados de manera que puedan ser
resueltos de modo general, automticamente.
La mquina PROLOG, como se ver ms adelante, no es ms que un demostrador automtico de
teoremas. Por tanto, nosotros debemos expresar nuestro problema en forma de premisas y teoremas para
que la mquina PROLOG pueda demostrarlos y, por tanto, aportarnos las soluciones que buscamos.
Evidentemente, para comprender las bases de la programacin lgica es necesario tener unos
conocimientos mnimos de la lgica matemtica que se aplica y se utiliza en estos casos. Por lo tanto, en el
anexo proporcionado al final de la documentacin se describe brevemente el significado de "Clculo
Proposicional", "Clculo de Predicados" y "Mtodo de Resolucin".
2 Bases del lenguaje PROLOG.
Centrmonos ahora en comentar las diferencias existentes entre metodologa declarativa e imperativa,
observando las ventajas e inconvenientes que supone usar este nuevo paradigma frente al mtodo
tradicional imperativo al que estamos acostumbrados.
2.1 Metodologa declarativa frente a metodologa imperativa.
Como se ha comentado, la programacin declarativa supone especificar formalmente los enunciados
utilizando la lgica de predicados de manera que la mquina PROLOG sea capaz de interpretar e inferir
soluciones a partir de esos enunciados. En un lenguaje imperativo, sin embargo, no slo hemos de
preocuparnos de entender el significado del enunciado del problema sino que debemos escribir nosotros

mismos cada uno de los pasos e instrucciones que la mquina debe ejecutar para resolverlo. Esta es la
diferencia ms notable entre ambas metodologas. Podemos especificar ms las diferencias, pero al final,
todas se resumen en la que acabamos de enunciar:
- Los lenguajes declarativos no se basan en la mquina Von Newman sino en modelos matemticos.
- Los lenguajes declarativos, en contra de lo que hacen los imperativos, intentan ser
referencialmente transparentes, es decir, la misma expresin siempre da los mismos resultados.
- En un lenguaje declarativo el control lo lleva la mquina, sin embargo en un lenguaje imperativo el
control depende exclusivamente del programador.
- Los lenguajes declarativos son independientes de la mquina, sin embargo los imperativos se basan
en el lenguaje mquina en el que se apoyan, teniendo como instruccin principal la asignacin.
- El concepto de variable en un lenguaje imperativo es un objeto cuyo valor puede cambiar en el
tiempo, en cambio, en los lenguajes declarativos las variables son objetos cuyo valor no se conoce,
y que, una vez que se le asocia un valor, conserva dicho valor hasta el final.
2.2 Ventajas e inconvenientes.
- La principal ventaja de los lenguajes declarativos es que son independientes de la mquina y, como
se ha comentado, referencialmente transparentes.
- Adems la cantidad de cdigo que debemos escribir es menor, aunque la representacin formal de
estos problemas puede resultar, en ocasiones, poco evidente.
- Podemos desentendernos del control. Aunque aqu existe una limitacin: no podemos hacerlo
totalmente. Por ello, PROLOG nos proporciona formas, un tanto artificiales, de manejo de este
control.
- Los datos pueden ser tanto de entrada como de salida y se pueden utilizar datos parcialmente
construidos, es decir, podemos empezar a ejecutar sin contar con todos los datos.
- Es difcil representar la negacin.
3 Definicin de Hechos, Metas y Predicados en PROLOG
Para construir programas en Prolog es necesario convertir los conceptos expresados en lenguaje
natural en un lenguaje basado en la lgica de primer orden, con el fin de obtener las clusulas de Horn tras
el proceso de conversin adecuado, ya que Prolog trabaja, precisamente, con este tipo de clusulas.
Bsicamente, nuestro trabajo va a consistir en especificar adecuadamente los enunciados y reglas bsicas

para resolver un determinado problema de forma general. Despus le plantearemos a Prolog el conjunto de
objetivos (problemas especficos para un problema general dado), que queremos que resuelva.
En definitiva, nuestros programas estarn formados por:
- La base de conocimientos: Hechos + Reglas de Inferencia.
- El conjunto de objetivos o metas.
Para comprender adecuadamente los conceptos expresados hasta ahora, veamos una serie de
definiciones bsicas: predicado, hecho, regla de inferencia y meta.
Un predicado especifica la relacin existente entre los argumentos del mismo. El nmero de
argumentos a los que se aplica dicho predicado se denomina aridad. Con un predicado podemos
representar algo que sucede en el mundo real (hecho), o una regla (regla de inferencia), que nos permite
deducir hechos que suceden en ese dominio mediante la aplicacin de la misma. La sintaxis de Prolog para
especificar un predicado es la siguiente:
nombre_predicado(arg1, arg2, ... , argN). (En el caso de que el predicado represente un hecho).
nombre_p1[([arg1], [arg2],..., [argN])]:-otro_p1[([arg1], [arg2],..., [argN])],...,
otro_pN[([arg1], [arg2], ... , [argN])].
(En el caso de que el predicado represente una regla de inferencia).
Las reglas de inferencia se pueden definir como la especificacin de una relacin entre predicados y
argumentos que permiten plasmar el hecho de que si la parte derecha del predicado se cumple, se cumple
la parte izquierda. El eje lo proporciona el smbolo ":-" que representa para nosotros la implicacin lgica
(en lgica ""). Las comas (","), representan el smbolo de conjuncin (en lgica "."), y el punto y coma
(";"), representa el smbolo de disyuncin (en lgica "v"). En la Tabla 1 se representan estas
correspondencias.
Lgica de Primer Orden Prolog
:-
. ,
v ;
Tabla 1

Ejemplos:

Ejemplos de hechos:
madre(pepe, juan).
factorial(0,1).

Ejemplos de reglas de inferencia:
abuela(X,Y):-madre(X,Z), madre(Z,Y).
factorial(N, R):- N1 is N-1, factorial(N1, Y), R is N*Y.

Ejemplo de regla de inferencia utilizando la disyuncin:
mcd(A,B,R):-A==B, R is A; A>B, Aux is A-B, mcd(Aux,B,R); A<B, Aux is B-A, mcd(A,Aux,R);
mcd(B,A,R).

Como se observa, las reglas de inferencia permiten llevar a cabo la deduccin de metas. Para que las
reglas de inferencia sean aplicables, en general, deber existir un conjunto de hechos sobre los que
apoyarse para que las demostraciones se puedan realizar. Las metas representan los problemas especficos,
basados en los problemas generales expresados en la base de conocimientos que deseamos que el
demostrador automtico de teoremas resuelva. Si nos fijamos, para escribir programas en Prolog, siempre
debemos tener en cuenta que el demostrador resuelve las metas comenzando por los predicados situados
en la zona superior (de arriba a abajo), y para cada predicado el proceso de unificacin se lleva a cabo de
izquierda a derecha, ver Figura 1.

Figura 1, Esquema del flujo de ejecucin de un programa Prolog

Una vez que hemos comprobado el funcionamiento general del demostrador, pasemos a estudiar
como llevar a cabo la correcta especificacin de las bases de conocimientos.

3.1 Construccin de Bases de Conocimientos en PROLOG
En el campo de la Inteligencia Artificial es muy habitual implantar agentes que se pueden considerar
como entidades que poseen un conocimiento de su mundo capaces de razonar sobre las posibles acciones
que pueden emprender. Este tipo de agentes adoptan tareas nuevas en forma de metas perfectamente
definidas. Pueden inferir y razonar conocimientos en funcin de los hechos que conocen de su mundo y de
las reglas de inferencia que permiten deducir propiedades de ste que no resultan completamente
evidentes [Russel, 1996]. La construccin de agentes o programas que desempean labores de este tipo se
puede realizar mediante el uso de lenguajes lgicos adaptados a la resolucin de esta clase de cuestiones.
Como hemos visto, la forma de llevar a cabo la implantacin de un agente consiste en estudiar el mundo o
mbito donde va a tener que trabajar y definir ese dominio mediante una sintaxis adecuada al lenguaje
utilizado. El componente medular de un agente basado en el conocimiento es su base de conocimientos,
junto con el mecanismo de inferencia que se utilice para realizar las deducciones. Para nosotros, el
mecanismo o motor de inferencia que vamos a usar va a ser la mquina Prolog.
La construccin, por tanto, de la base de conocimientos es el punto crucial que nos debe ocupar en
este curso, por ello, en este punto y en los siguientes, comentaremos las reglas bsicas que se deben tener
en cuenta para implementar adecuadamente nuestro conocimiento acerca de los problemas que queremos
resolver y veremos cmo plantear las metas al demostrador de teoremas (motor de inferencia), de Prolog.
La mquina virtual Prolog toma como entrada nuestra base de conocimientos expresada en forma
clausal, nuestro objetivo, tambin expresado en forma clausal, y genera una respuesta afirmativa en caso de
que el objetivo se pueda demostrar aplicando el conocimiento almacenado en la base. La Figura 2 muestra
un esquema grfico de lo que acabamos de comentar.

Figura 2, Esquema del funcionamiento de la mquina Prolog.

Resolver un problema, por tanto, es construir adecuadamente la base de conocimientos, y esta base
expresada en lenguaje Prolog junto con el conjunto de metas especificadas constituirn nuestro programa.

Los programas que se pueden resolver utilizando esta metodologa son muchos y muy variados. Desde
la manipulacin de bases de datos hasta la construccin de sistemas expertos, sin olvidar la compresin del
lenguaje natural, resolucin de juegos, diseo de compiladores, etc.
Un programa Prolog probablemente utilizar predicados recursivos, es decir, nuestro problema se
expresa en trminos de s mismo aplicado sobre un conjunto de datos distintos que tiende a convertirse en
el conjunto de datos que satisface el caso o casos triviales del proceso de recursin. Por ejemplo, en el caso
del problema del factorial, vamos calculando sucesivamente el factorial de un nmero decrementado del
nivel anterior. Este nmero se aproxima cada vez ms a 0, que es justamente el caso trivial de este proceso
recursivo. Una vez que se alcanza este caso, las llamadas recursivas retornan los datos de salida y se
produce lo que todos conocemos como vuelta atrs.
Cuando sea necesario construir un programa usando tcnicas recursivas en Prolog, hemos de recordar
que los objetivos intentarn satisfacerse mediante una bsqueda que comienza por los predicados situados
en la zona superior, y para cada uno de ellos el proceso de unificacin se realizar de izquierda a derecha.
Evidentemente, para conseguir un funcionamiento adecuado en el procedimiento de resolucin hemos de
construir la base de conocimientos adecuadamente, situando primero los casos triviales o especficos y a
continuacin los casos ms generales.

Ejemplo:

factorial(0,1).

Igualmente, si ciertas realidades del mundo que se desea representar, se pueden expresar mediante
una regla de inferencia en lugar de hacerlo con un conjunto de hechos, elegiremos la primera opcin, de
modo que en nuestra base de conocimientos, tendremos solamente los hechos que son necesarios para
deducir otros que se pueden razonar a travs de reglas. Por ejemplo, si deseamos construir parte de
nuestro rbol genealgico y establecemos como dominio en el que vamos a trabajar el de las madres y
abuelas, solamente ser necesario definir el predicado madre para representar hechos del tipo "Ana es
madre de Pepa", "Pepa es madre de Luisa", etc. Sin embargo el predicado abuela no se implementar como
un hecho, aunque podra hacerse, sino como una regla de inferencia ya que ese suceso ocurrido en el
mundo que estamos representando se puede deducir en funcin del hecho "ser madre".


Ejemplo:
A continuacin proponemos un ejemplo de cmo debe modificarse una base de conocimientos
incorrectamente implementada.
madre(pepa, juana).
madre(juana, ana).
madre(ana, beatriz).
abuela(pepa, ana).
abuela(juana, beatriz).
La base de conocimientos est mal construida porque su actualizacin es ms complicada y, por tanto,
tambin su manejo.
La forma correcta de realizar ese programa sera del modo que se propone:
madre(pepa, juana).
madre(juana, ana).
Como se observa la cantidad de cdigo se reduce ya que para establecer nuevos hechos del mundo real:
"ser madre" o "ser abuela" basta con introducir nuevos predicados del tipo madre ya que el hecho de
"ser abuela" se deduce en funcin de la regla de inferencia especificada con el predicado abuela.

3.2 Consultas sobre la Base de Conocimientos
Evidentemente, las bases de conocimientos se construyen con el fin de que preguntemos al agente
sobre nuevos hechos del mundo deducidos de dicha base. El agente debe poseer un motor de inferencia
para llevar a cabo el proceso de deduccin de forma automtica. Para nosotros, Prolog va a constituir
nuestro "motor de inferencia". Por tanto, nos queda saber como hemos de plantear los objetivos y como
funciona la inferencia en Prolog (mquina virtual Prolog).
En este apartado vamos a centrarnos en estudiar las respuestas proporcionadas por Prolog a los
objetivos que le podemos plantear.
El objetivo se plantea como un predicado nuevo basado en el conocimiento que tenemos. La mquina
virtual o intrprete intentar unificar dicho predicado con los existentes en la base de conocimientos. Si
puede unificarlo con alguno, nos dar una respuesta afirmativa. En caso contrario, proporcionar una
respuesta negativa.
Prolog comienza a buscar de arriba a abajo en la secuencia de predicados y para cada predicado de
izquierda a derecha. Pues bien, vamos a examinar ahora el mtodo de ejecucin para cada caso, es decir, si

el predicado es un hecho, una regla de inferencia, etc. Adems, ser necesario concretar como se realiza el
proceso de recursin y backtracking a travs de algunos ejemplos sencillos.

Cuando en la base de conocimientos slo hay hechos
En este caso slo tenemos un conjunto de predicados que expresan los hechos o afirmaciones que se
producen en el mundo real.
La forma de proceder de la mquina Prolog, ser por tanto, el intento de unificacin con alguno de
ellos.
predicado1(arg1, ..., argN).
...
predicadoM(arg1, ..., argN).
Supongamos que nuestro objetivo es:
El rbol de bsqueda generado sera el que se muestra en la Figura 3.
Cuando en la base de conocimientos hay hechos y reglas de inferencia no recursivas
Las reglas de inferencia permiten relacionar hechos o situaciones del mundo real para deducir otros
hechos que, en principio, no son evidentes sin la utilizacin de dicha reglas.

predicado2(arg1, ... ,argN).
OBJETIVO
predicado1(arg1, ... ,argN). predicado2(arg1, ... ,argN). predicadoM(arg1, ... ,argN).
FAIL XITO EN LA
UNIFICACIN
SALIDA = YES

Figura 3, rbol de bsqueda para satisfacer un predicado en una base de hechos

Cuando en Prolog tenemos una sentencia de la forma predicado(argumentos):-
predicado2(argumentos)., la mquina intenta unificar la parte izquierda de la regla mediante la
demostracin de la parte derecha. Dicha parte derecha se convierte en un subobjetivo a resolver. Las
entradas y salidas se proporcionan a travs de los argumentos, y se pueden utilizar variables locales o
auxiliares para realizar clculos que slo afectan a esa parte derecha. De esta forma, en cada nivel de
llamadas dichas variables locales funcionan del mismo modo que en cualquier lenguaje imperativo, ya que
se consideran direcciones independientes unas de otras que slo sobreviven en su nivel de llamada.
Supongamos una base de conocimientos como la siguiente:
pred1(arg1).
pred2(arg2).
pred3(arg1, arg2, arg3):- pred1(arg1), aux is operacin sobre arg1, pred2(aux), arg3 is
operacin entre arg1 y aux.
Para satisfacer el objetivo pred3(arg1, arg2, arg3). se genera el rbol de bsqueda de la Figura 4.
pred3(arg1, arg2, arg3).
OBJETIVO
pred1(arg1). pred2(arg2). pred3 (arg1, arg2, arg3)
FAIL FAIL
SALIDA = YES
pred1(arg1). pred2(aux). Operacin
sobre aux
Operacin
sobre arg3
XITO XITO XITO XITO
AND

Figura 4, rbol de bsqueda para satisfacer un objetivo en funcin de una sencilla regla de inferencia

Cuando en la base de conocimientos hay hechos y reglas de inferencia recursivas
Para estudiar este caso, vamos a utilizar el ejemplo del clculo del mximo comn divisor. Hemos de
apuntar, que el proceso se realizar de la misma forma que en el caso anterior. Lo nico que hay que tener
en cuenta es que es necesario controlar el orden en que se colocan los predicados para evitar una ejecucin
no deseada, ya que toda solucin recursiva debe evolucionar hacia el caso trivial.

En cada nivel de recursin, las variables locales son independientes y se localizan en direcciones de
memoria distintas.
mcd(A,B,R):-A==B, R is A.
mcd(A,B,R):-A>B, Aux is A-B, mcd(Aux,B,R).
mcd(A,B,R):-A<B, Aux is B-A, mcd(A,Aux,R).
mcd(A,Aux,R):-mcd(B,A,R).
El rbol de bsqueda generado para encontrar la solucin mcd(7, 5, R). se muestra en la Figura 5.
mcd(7,5,R)
OBJETIVO
Predicado1 Predicado2
SALIDA = YES
R = 1
7=5
FAIL
7>5
XITO
Aux is 2
XITO
mcd(2, 5, R)
Predicado1 Predicado2
2=5
FAIL
2>5
FAIL
Predicado3
2<5
XITO
Aux is 3
XITO
mcd(2, 3, R)
2 Nivel de
Recursin

Figura 5, rbol parcial de bsqueda para resolver un caso del problema del mximo comn divisor de dos nmeros
3.3 Ejemplos
En el punto anterior, hemos observado como funciona la mquina Prolog a la hora de resolver
objetivos planteados sobre distintos tipos de bases de conocimientos. Es conveniente ilustrar todos los
conocimientos adquiridos hasta ahora observando como se resuelven distintos problemas mediante un
lenguaje lgico. Por ello, veamos un resumen de algunos ejemplos comentados hasta ahora.

Clculo del factorial.


factorial(0,1).

Clculo del mximo comn divisor.

mcd(A,B,R):-A==B, R is A.
mcd(A,B,R):-A>B, Aux is A-B, mcd(Aux,B,R).
mcd(A,B,R):-A<B, Aux is B-A, mcd(A,Aux,R).
mcd(A,Aux,R):-mcd(B,A,R).

Clculo del mximo comn divisor usando disyunciones.

mcd(A,B,R):-A==B, R is A; A>B, Aux is A-B, mcd(Aux,B,R); A<B, Aux is B-A, mcd(A,Aux,R);
mcd(B,A,R).

rbol genealgico.

madre(pepa, juana).
madre(juana, ana).

Tras la exposicin de estos pequeos ejemplos, pasemos a realizar un programa un poco ms grande.
Vamos a construir una base de conocimientos que nos permita resolver objetivos o preguntas relacionadas
con el cdigo de la circulacin de vehculos.
La aplicacin va a permitir especificar un tipo de vehculo y las caractersticas de la va por la que circula
y nos informar sobre la velocidad mxima genrica que dicho vehculo puede alcanzar. Hablaremos
exclusivamente de velocidad genrica de va y vehculos.
A continuacin, en la Tabla 2, se muestran los tipos de va que existen tanto fuera como dentro de
poblado.
Caractersticas de la va Nombre de la va
Va interurbana sealizada con la seal S-1 (Figura 6) Autopista
Va interurbana sealizada con la seal S-1a (Figura 7) Autova
Va interurbana sealizada con la seal S-1b (Figura 8) Va Rpida
Va interurbana con dos o ms carriles para cada sentido
carril para facilitar el adelantamiento arcn pavimentado de,
al menos, 1,5 metros de longitud
Carretera Convencional Buena
Va interurbana que no cumple los requisitos de una carretera
convencional buena.
Carretera Convencional Mala
Va urbana Va Urbana
Va interurbana que discurre por suelo urbano Travesa
Tabla 2

Figura 6
Seal S-1
AUTOVA

Figura 7
Seal S-1a
VA RPIDA

Figura 8
Seal S-1b

En la Tabla 3, se expresan las relaciones de velocidad segn la va y el vehculo que se conduce.

Va
Vehculo

Autopistas y Autovas Vas Rpidas y
Carreteras
Convencionales Buenas
Carreteras
Convencionales Malas
Vas Urbanas y Travesas
Turismos y
Motocicletas
120 100 90 50
Autobuses y
Vehculos Mixtos
100 90 80 50
Camiones y
Vehculos
Articulados
90 80 70 50
Automviles con
Remolque
80 80 70 50
Noveles 80 80 80 50
Tabla 3

Una vez que tenemos todos los datos, slo nos queda expresar los acontecimientos de la realidad de
forma sintcticamente correcta.
Los hechos y reglas de inferencia para resolver este problema se muestran a continuacin.

Experto de Autoescuela
predicates
maximo(string, string, integer)
via(integer, integer, string, string)
velocidad(string, integer, integer, string, integer)
nondeterm repeat
nondeterm pedirdatos

clauses
/* Definicin de las velocidades genricas de vehculos segn la va */
maximo("novel", "autopista", 80):-!.
maximo("novel", "autovia", 80):-!.
maximo("novel", "via_rapida", 80):-!.
maximo("novel", "ccb", 80):-!.
maximo("novel", "ccm", 80):-!.
maximo("turismo", "autopista", 120):-!.
maximo("motocicleta", "autopista", 120):-!.
maximo("vehiculomixto", "autopista", 100):-!.
maximo("autobus", "autopista", 100):-!.
maximo("camion", "autopista", 90):-!.
maximo("vehiculoarticulado", "autopista", 90):-!.
maximo("conjuntovehiculos", "autopista", 80):-!.
maximo(Veh, "autovia", R):-maximo(Veh, "autopista", R), !.
maximo("turismo", "ccb", 100):-!.
maximo("motocicleta", "ccb", 100):-!.

maximo("vehiculomixto", "ccb", 90):-!.
maximo("autobus", "ccb", 90):-!.
maximo("camion", "ccb", 80):-!.
maximo("vehiculoarticulado", "ccb", 80):-!.
maximo("conjuntovehiculos", "ccb", 80):-!.
maximo(Veh, "via_rapida", R):-maximo(Veh, "ccb", R),!.
maximo(Veh, "ccm", R):-maximo(Veh, "ccb", Auxi), R=Auxi-10, !.
maximo(Veh, "via_urbana", _):-
Veh<>"turismo",
Veh<>"motocicleta",
Veh<>"vehiculomixto",
Veh<>"autobus",
Veh<>"camion",
Veh<>"vehiculoarticulado",
Veh<>"conjuntovehiculos",
Veh<>"novel",
fail, !.
maximo(_, "via_urbana", 50):-!.
maximo(Veh, "travesia", R):-maximo(Veh, "via_urbana", R).

/* Definicin de va en funcin de sus caractersticas */
via(_, _, "autopista", "autopista"):-!.
via(_, _, Senal, Tipo):-Senal="autovia", Tipo="autovia", !.
via(_, _, Senal, Tipo):-Senal="viarapida", Tipo="via_rapida", !.
via(_, _, Senal, Tipo):-Senal="de_via_urbana", Tipo="via_urbana", !.
via(_, _, Senal, Tipo):-Senal="de_travesia", Tipo="travesia", !.
via(Arcen, _, "nohay", "ccb"):-Arcen >=150, !.
via(_, Carriles, "nohay", "ccb"):-Carriles>=2, !.
via(_, -1, "nohay", "ccb"):-!.
via(_, _, "nohay", "ccm").
/* Predicado de clculo de velocidad en funcin del vehculo y las caractersticas
de la va */

velocidad(Vehiculo, A, C, S , V):-via(A, C, S, Carretera),
maximo(Vehiculo, Carretera, V).

repeat.
repeat:-repeat.

pedirdatos:-repeat,
write("PETICIN DE DATOS (nohay=no hay dato concreto)"), nl, nl, nl,
write("Especifica el tipo de vehculo, (turismo, motocicleta,
vehiculomixto, autobus, camion)"), nl,
write("(vehiculoarticulado, conjuntovehiculos, novel): "),
readln(V),
nl,
write("Especifica el tamao del arcen: "), readint(A),
nl,
write("Especifica el nmero de carriles (-1 para adelantamiento): "), readint(C),
nl,
write("Especifica seal (autopista, autovia, via_rapida): "), readln(S),
velocidad(V, A, C, S , Velocidad), nl,
write("La velocidad mxima es: "), write(Velocidad), nl,
write("Continuar=Cualquier tecla, Salir=1"), nl,
readint(Tecla), nl, nl, nl,
Tecla=1.

goal
pedirdatos.


4 Definicin y funcionamiento de la Mquina PROLOG
Hasta ahora, conocemos como se pueden modelar problemas reales utilizando la metodologa
declarativa lgica. Pero adems, es necesario, definir formalmente qu es la mquina o intrprete Prolog.
En este apartado nos centraremos en la definicin y muestra del funcionamiento interno de este intrprete,
examinando como se realiza el proceso de resolucin, a travs del mtodo de unificacin, y como se llevan a
cabo las tareas de recursin y backtracking.
Un intrprete Prolog es un demostrador de teoremas sobre Clusulas de Horn que trabaja Top-Down, y
que emplea Resolucin Lineal con Funcin de Seleccin. La entrada al intrprete es un conjunto de clusulas
definidas C, junto con la especificacin de la meta G0, como ya se vio en apartados anteriores. El proceso
del intrprete consiste en una bsqueda incremental por backtracking en el espacio (organizacin en forma
de rbol), de refutaciones posibles a G0 [Adarraga, 1994].
4.1 Unificacin
La unificacin se realiza, para cada predicado, de izquierda a derecha, y para cada conjunto de
predicados, de arriba a abajo. Se pueden unificar variables con constantes, siempre que la variable no est
instanciada. Si la variable est instanciada, el hecho de hacer unificacin entre ambas se corresponde con la
situacin de unificacin de dos constantes. Para que dos constantes se puedan unificar ambas han de ser
iguales.
Veamos en la Tabla 4 algunos casos que muestran el funcionamiento de la unificacin.
Variable no instanciada se intenta unificar con cualquier tomo XITO

X=5
Variable instanciada se intenta unificar con cualquier tomo distinto al valor que
contiene
FAIL X que contiene 5, X=6
Constante se intenta unificar con otra constante distinta FAIL 5=6
Expresiones se intentan comparar mediante smbolos de comparacin que no "evalan"
y no coinciden totalmente, incluido el orden
FAIL 5+3=3+5
Variable se intenta instanciar dos veces en la misma ejecucin del programa. En el
segundo intento de instanciacin
FAIL X=6, X=7
Tabla 4

Vemos que las instanciacin es un caso de unificacin en la que a una variable no instanciada se le
asigna un valor.

Tambin podemos observar que no es necesario definir los tipos de las variables locales usadas dentro
de cada regla de inferencia. Cuando las variables se instancian a un valor, entonces todas las operaciones
que se realicen con dicho valor debern tener en cuenta el tipo especificado. Por ejemplo, si una variable se
instancia al valor 5, todas las comparaciones posteriores se harn con nmeros y no con tomos del tipo
pepe, blas similar.
El proceso de unificacin intenta casar un predicado con otro para comprobar si son absolutamente
iguales, cuando es posible hacer sustituciones, stas se realizan de manera que los predicados que se estn
unificando se tornen completamente iguales y proporcionen un resultado de XITO.
4.2 Backtracking
Ya se ha comentado en puntos anteriores: Prolog utiliza un sistema de backtracking para resolver una
meta propuesta. El procedimiento de backtracking consiste en generar un rbol de bsqueda de todas las
posibles resoluciones que puede tener la meta en funcin de la base de conocimientos. Esto significa, que el
algoritmo itera hasta que encuentra una solucin. Cada vez que los predicados fallan y no son unificables se
va generando una nueva rama hasta encontrar la solucin deseada, de esta forma se va construyendo el
rbol de bsqueda.
Puede ser que un problema se pueda resolver de varias formas. Es, por tanto, posible especificar que
deseamos una nueva solucin. El intrprete Prolog ignora la solucin encontrada hasta ahora y construye el
rbol de bsqueda hasta generar una nueva solucin o encontrar que sta no existe.
Cuando un predicado se demuestra en funcin de una llamada a s mismo, la llamada se convierte en
un subobjetivo casi idntico al objetivo a cumplir, salvo por el conjunto de datos sobre el que se aplica.
Cuando se consigue la demostracin de los subobjetivos generados en el proceso de recursin, se produce
lo que se denomina vuelta atrs de la recursin, que funciona igual que en cualquier lenguaje.
No hemos de confundir recursividad con backtracking. Los predicados recursivos los diseamos
nosotros mientras que el procedimiento de backtracking es intrnseco al mtodo de refutacin que se usa
para demostrar las metas.
Para comprender mejor lo expuesto hasta ahora, vamos a examinar un par de ejemplos de uso forzado
de backtracking para obtener nuevas soluciones y de uso de predicados recursivos.

Uso forzado de backtracking

La traza del programa siguiente se muestra en la Figura 9.
hermano(juan, beatriz).
hermano(pepe, beatriz).
Objetivos planteados
?.-hermano(X, beatriz).
X->juan;
X->pepe;
no.

hermano(X, beatriz).
hermano(pepe, beatriz)
XITO
X=pepe
hermano(juan, beatriz)
XITO
X=juan
1 SOLUCIN 2 SOLUCIN

Figura 9, rbol de bsqueda generado para la solucin del predicado "hermano(X, beatriz)"

Uso de predicados recursivos
La traza del programa siguiente se muestra en la Figura 10.
numero(0):-write(0).
numero(N):-N1 is N-1, numero(N1), write(N).
Objetivo planteado.
?.-numero(2).
210
yes.

numero(2).
FAIL
Predicado Siguiente
N1 is N-1
XITO
write(2)
XITO
numero(1)
Predicado Siguiente
N1 is N-1
XITO
write(1)
XITO
numero(0)
XITO
FAIL

Figura 10, rbol de bsqueda generado para la solucin del predicado "numero(2)"


CAPITULO 2
Aritmtica, datos y estructuras en Visual Prolog
5 Sintaxis Bsica de VISUAL PROLOG
Hemos visto ya un buen nmero de convenciones que debemos utilizar para escribir programas en
Prolog. La ltima parte de este tema la dedicaremos a conocer detalladamente las reglas sintcticas que
hemos de seguir para que nuestras bases de conocimientos sean reconocidas por Visual Prolog.
Como ya hemos estudiado, un programa Prolog no es ms que la especificacin de una base de
conocimientos lgica con las caractersticas siguientes:
- Consta de una secuencia de oraciones, todas ellas verdaderas, que expresan un conjunto de realidades
sobre los objetos del mundo representado, as como sobre sus relaciones. Todas las variables tienen
cuantificacin universal implcita y cuando las variables aparecen en oraciones distintas se consideran
tambin distintas.
- Se aceptan nicamente oraciones en forma de Clusula de Horn, es decir, las oraciones son atmicas, o
bien una implicacin con un antecedente no negado y un consecuente generalmente expresiones
separados por comas o por puntos y comas. Las comas significan conjuncin y los puntos y comas
significan disyuncin.
- En vez de utilizar antecedentes negados en sus implicaciones, en Prolog se emplea un operador de
negacin basado en el fallo: una meta no P se considera demostrada si el sistema no logra demostrar P.
5.1 Aritmtica de VISUAL PROLOG
Las expresiones aritmticas en Visual Prolog se componen de operandos (nmeros y variables),
operadores (+, -, *, /, div, y mod) y parntesis: A = 1 + 6 / (11 + 3) * Z. Ver Tabla 5.
Los nmeros "0x" o "0o" significan hexadecimal y octal respectivamente: 0xFFF = 4095; 86 = 0o112 +
12.

El valor de una expresin se puede calcular si todas las variables estn unificadas en el momento de la
evaluacin. El clculo ocurre entonces en un orden determinado por la prioridad de los operadores
aritmticos. Los operadores de mayor prioridad son evaluados primero. Ver Tabla 6.
Operaciones
Operando 1 Operador Operando 2 Resultado
entero +, -, * Entero entero
real +, -, * Entero real
entero +, -, * Real real
real +, -, * Real real
entero real / entero real real
entero div Entero entero
entero mod Entero entero
Tabla 5
Orden de evaluacin
Si la expresin contiene subexpresiones entre parntesis, las subexpresiones se evalan primero.
Si la expresin contiene multiplicacin o divisin, estas operaciones son realizadas trabajando de
izquierda a derecha a travs de la expresin.
Las operaciones de suma y resta son llevadas a cabo de izquierda a derecha tambin.
En el orden de evaluacin se tiene en cuenta, lgicamente, la precedencia de los operadores.
Operador Prioridad
+ - 1
* / mod div 2
- + (unario 3
Tabla 6
Funciones y predicados
Visual Prolog posee una gran cantidad de funciones y predicados matemticos para realizar las ms
variadas operaciones. La lista completa se ofrece en la Tabla 7.
Nombre Descripcin
X mod Y Resto de X dividido entre Y.
X div Y Cociente de X dividido entre Y.
abs(X) Valor absoluto de X.
cos(X) Coseno de X.
sin(X) Seno de X.

tan(X) Tangente de X.
arctan(X) Arcotangente de X.
exp(X) e elevado al valor almacenado en X. (Exponencial).
ln(X) Logaritmo neperiano de X.
log(X) Logaritmo en base 10 de X.
sqrt(X) Raz cuadrada de X.
random(X) Almacena en X un nmero aleatorio real entre 0 y 1.
random(X, Y)
Almacena en Y un nmero aleatorio en el intervalo 0 <= Y
< X.
round(X) Valor redondeado de X. El resultado es un nmero real.
trunc(X) Valor truncado de X. El resultado es un nmero real.
val(domain,X) Conversin explcita entre dominios numricos.
Tabla 7
Comparaciones
En Visual Prolog podemos comparar expresiones aritmticas, caracteres, cadenas de caracteres y
smbolos.
Las comparaciones de este tipo se realizan a travs de operadores relacionales. Ver Tabla 8.
Smbolo Relacin
< menor que
<=
menor o igual
que
= igual que
> mayor que
>=
mayor o igual
que
<> o >< Distinto
Tabla 8, Comparacin de caracteres, cadenas de caracteres y smbolos

Adems de las expresiones numricas, podemos comparar caracteres, cadenas y smbolos: 'a' < 'b';
"antony" > "antonia" y P1 = peter, P2 = sally, P1 > P2.
- Caracteres: Visual Prolog convierta la comparacin 'a' < 'b' a su expresin aritmtica
correspondiente 97 < 98, usando el cdigo ASCII correspondiente a cada carcter.
- Cadenas de caracteres: Cuando se comparan dos cadenas o smbolos, la comparacin se realiza
carcter a carcter en sus correspondientes posiciones. El resultado es el mismo que se consigue

comparando el carcter inicial a menos que los dos sean iguales en cuyo caso se pasa al siguiente.
Cuando se encuentran dos caracteres iguales, el proceso de comparacin termina y se produce el
resultado.
- Smbolos: No pueden ser comparados directamente debido a la sintaxis. Primero deben ser
unificados a variables o escritos como cadenas de caracteres.

6 Datos simples y Estructuras de Datos: DOMINIOS
En cualquier lenguaje de programacin necesitamos representar datos complejos. Podemos definir
dato complejo como la agrupacin homognea o heterognea de otros datos que a su vez pueden ser
tambin complejos o simples. As pues, a partir de esta definicin, los datos se pueden organizar de
mltiples formas que ya conocemos: vectores, registros, listas, rboles, grafos, etc.
Un programa en Visual Prolog utiliza distintas secciones para las declaraciones de tipos o dominios con
el fin de crear estructuras complejas de datos (DOMAINS), predicados (PREDICATES), reglas y hechos que
forman los predicados (CLAUSES) y metas (GOAL).
En la seccin de predicados se definen las cabeceras de los predicados que vamos a utilizar en nuestros
programas, es decir el nombre del predicado y el dominio o tipo de los argumentos del mismo.
En la seccin de clusulas se define la implementacin de cada predicado declarado en PREDICATES.
En la seccin GOAL se establece la meta principal del programa.
Centrmonos ahora en la seccin DOMAINS y en cmo crear estructuras complejas: objetos
compuestos, rboles, listas y matrices.

6.1 OBJETOS COMPUESTOS
Los objetos compuestos estn formados por un functor y un conjunto de argumentos. Por ejemplo,
cuadro(NS, Autor, Estilo, Dimensiones) representa una estructura que almacena los datos ms relevantes
para describir este tipo de obra de arte. El nombre cuadro es el functor y los elementos entre parntesis son
los argumentos del objeto compuesto. Los argumentos (campos), de un objeto compuesto pueden ser datos
simples o datos complejos.

Para definir objetos compuestos es necesario introducirnos en el concepto de DOMINIO o DOMAINS.
Como veremos en la seccin de prcticas, la seccin DOMAINS de un programa en Visual Prolog agrupa los
dominios (tipos), no estndares en el sistema.
Definir un dominio no es ms que establecer qu forma tendrn los objetos que pertenecen a dicho
dominio o tipo, por ejemplo, para el caso del cuadro, el dominio sera as:
un_cuadro= cuadro(INTEGER, STRING, STRING, STRING)
Como hemos dicho, los argumentos de un objeto compuesto pueden ser complejos:
un_comprador= comprador(STRING, un_cuadro)
El dominio o tipo del ejemplo define a un comprador de un cuadro. Los objetos compuestos de este
tipo almacenan una cadena que puede representar el DNI y el cuadro que posee.
Veamos varios objetos de tipo un_comprador:
comprador("111111111", cuadro(1239, "Martn Jimnez", "leo", "39x23")).
comprador("122111111", cuadro(1449, "Surez Jimnez", "acuarela", "130x50")).
comprador("111133331", cuadro(2232, "Martn Prez", "carboncillo", "100x100")).
6.2 RBOLES
Un rbol es una estructura con una definicin puramente recursiva, ya que se puede considerar como
el elemento raz cuyos hijos son, a su vez, rboles. Si el rbol tiene nicamente dos hijos se denomina rbol
binario. Este modelo especfico de rbol se utiliza mucho para resolver gran cantidad de problemas en
aspectos de programacin.
Un rbol se puede considerar, a su vez, un caso particular de grafo, donde todos los caminos son
acclicos.
La Figura 11 muestra un ejemplo de rbol.
Nivel 0
Nivel 2
Nivel 1
Hoja
Raz

Figura 11, Ejemplo de rbol

Muchos problemas de Inteligencia Artificial donde interviene el concepto de bsqueda se resuelven
mediante la implementacin de rboles. Los rboles de juego o los utilizados en la resolucin de problemas
relacionados con el procesamiento de lenguaje natural son casos muy concretos y descriptivos. Por lo tanto,
podemos notar que el manejo eficiente de estas estructuras es sumamente importante para conseguir
programas de calidad en este mbito de la Ciencia.
Ya vimos que Prolog es un lenguaje que se adapta adecuadamente a este tipo de problemas. De hecho
la tcnica de resolucin que utiliza Prolog se basa en la construccin de un rbol de bsqueda de soluciones,
luego podemos concluir que el conocimiento de esta estructura es clave para este tipo de metodologa
declarativa.
Como en cualquier lenguaje, lo que necesitamos saber es la forma de declarar el rbol, ya que su
implementacin se puede realizar de muchas formas, por ejemplo, aunque una lista es un caso particular de
rbol, un rbol se puede representar a travs de listas, aunque en el caso de Visual Prolog, estudiaremos la
construccin de rboles utilizando objetos compuestos recursivos.
Dado que un rbol est formado por la raz y un conjunto de hijos, podemos representarlo utilizando la
siguiente notacin:
oracin (sujeto (artculo (el), sustantivo (hombre)), predicado (verbo (come), CD (pan)))
El rbol generado se muestra en la Figura 12.
Nivel 0
Nivel 2
Nivel 1
El
ORACIN
SUJETO PREDICADO
hombre come pan
ARTCULO SUSTANTIVO VERBO CD

Figura 12, rbol de anlisis de una frase en espaol

Como se observa, el uso de un predicado con dos argumentos en el caso de rbol binario o N
argumentos en el caso de rbol N-ario es una forma sencilla de representar un rbol.
Mediante objetos compuestos recursivos del tipo arbol(nodo, hijoizq, hijoder), donde hijoizq e hijoder
son tambin rboles, podemos representar un rbol binario. El rbol vaco se representa a travs del hecho
vacio:
arbol(1,arbol(2,arbol(4,vacio,vacio),arbol(5,vacio,vacio)),arbol(3,vacio,vacio))
En la seccin DOMAINS podemos crear un tipo rbol de enteros del modo siguiente:

mi_arbol= arbol(INTEGER, mi_arbol, mi_arbol); vacio

Operaciones con rboles representados mediante objetos compuestos recursivos
Domains
arbol= nodo(integer, arbol, arbol); vacio
lista= integer*

predicates
concatenar(lista, lista, lista)
preorden(arbol, lista)
inorden(arbol, lista)
postorden(arbol, lista)

clauses
concatenar([],[],[]):-!.
concatenar([],L2,L2):-!.
concatenar(L1,[],L1):-!.
concatenar([X|Y],L2,[X|Aux]):-concatenar(Y,L2,Aux).

preorden(vacio,[]):-!.
preorden(nodo(X,Izq,Der),[X|L]):-preorden(Izq,L1),
preorden(Der,L2),
concatenar(L1,L2,L).

inorden(vacio,[]):-!.
inorden(nodo(X,Izq,Der),L):-inorden(Izq,L1),
inorden(Der,L2),
concatenar(L1,[X|L2],L).

postorden(vacio,[]):-!.
postorden(nodo(X,Izq,Der),L):-postorden(Izq,L1),
postorden(Der,L2),
concatenar(L1,L2,L3),
concatenar(L3,[X],L).

Goal
inorden(nodo(1,nodo(2,nodo(4,vacio,vacio),nodo(5,vacio,vacio)),nodo(3,vacio,vacio)),
L1),
preorden(nodo(1,nodo(2,nodo(4,vacio,vacio),nodo(5,vacio,vacio)),nodo(3,vacio,vacio)),
L2),
postorden(nodo(1,nodo(2,nodo(4,vacio,vacio),nodo(5,vacio,vacio)),nodo(3,vacio,vacio)),
L3).

6.3 LISTAS
Una lista se puede considerar como un caso particular de rbol del modo que se muestra en la Figura
13.

Nivel 0
Nivel 2
Nivel 1
1
2 3

Figura 13, Lista implementada en forma de rbol

A su vez, una lista se puede considerar de forma recursiva. Es decir, siempre est formada por un
elemento seguido de otra lista (ver Figura 14). Cuando la lista tienen un slo elemento podemos considerar
que est formada por dicho elemento y la lista vaca. Esta definicin es muy interesante, ya que su
conocimiento nos permitir llevar a cabo todos las operaciones que se pueden realizar sobre las listas con
poco esfuerzo.

Figura 14, Definicin recursiva de una lista

Hemos de recordar que en Prolog no existen estructuras para realizar bucles luego todo los algoritmos
que representemos se definirn de forma recursiva. El hecho de que la implementacin de la lista sea
tambin recursiva facilita la construccin de operaciones sobre la misma.
Es necesario comprender este tipo de estructura para construir algoritmos eficientes. La mayor parte
de las operaciones que se realizan sobre una lista implica un recorrido de la misma, luego hemos de
centrarnos en conocer cmo se lleva a cabo este algoritmo utilizando tcnicas de recursividad.
Una lista se puede especificar en un predicado o en un objetivo a travs de:
- una constante: [a, b, c, 1, pepe]
- una variable: L

- la estructura [Cabeza|Cola] que almacenar el primer elemento en la variable Cabeza y el resto
en la variable Cola.
Las listas pueden ser homogneas o heterogneas, es decir, almacenar elementos del mismo tipo, o
elementos de distinto tipo.
Para definir un tipo de lista en particular es necesario declararla en la seccin DOMAINS.
lista= elementos* (lista de una dimensin)
lista2= elementos** (lista de dos dimensiones)
lista3= elementos*** (lista de tres dimensiones)...
Es interesante observar la sintaxis de definicin de una lista: elementos representa el dominio o tipo de
los elementos que componen la lista.
El tipo elementos puede representar un dominio simple, es decir, slo un tipo de elementos se
corresponde con dicho dominio o un dominio complejo, donde varios tipos de elementos se corresponden
con dicho dominio.
Por ejemplo, una lista homognea de elementos simples estara definida como:
lista= integer*
Una lista heterognea de elementos estara definida como:
listaenteros=integer*
elementos= i(integer); s(symbol); c(char); le(listaenteros)
lista= elementos*

Ejemplo:

Domains
listaenteros= integer*
elementos= i(integer); c(char); s(symbol); le(listaenteros)
lista= elementos*

predicates
recorrer(lista)

clauses
recorrer([]):-!.
recorrer([X|Y]):-write(X), nl, recorrer(Y).

Goal
recorrer([i(1),c('a'),s(pepe),i(5),c('b'),le([1,2,3])]).

Se observa que la lista puede contener cuatro tipo de elementos distintos: enteros, caracteres,
smbolos y listas de enteros. En la seccin de declaracin del dominio o tipo elementos no podemos escribir:
elementos= integer; char; symbol; listaenteros
para expresar que dicho dominio agrupa a cuatro tipos de elementos distintos sino que la sintaxis a
utilizar es aquella que representa que elementos agrupa a cuatro tipos de objetos compuestos distintos.
El resultado de la ejecucin de la meta es el siguiente:
i(1)
c('a')
s("pepe")
i(5)
c('b')
le([1,2,3])
yes
Las operaciones tpicas que se pueden realizar sobre listas son: la insercin de elementos al principio, al
final, en orden; borrado, bsqueda de elementos, recorrido, eliminacin de duplicados y, en general, todas
las de las que se pueden realizar sobre conjuntos de elementos tales como: interseccin, unin, diferencia,
pertenencia, comprobacin de lista vaca, concatenacin, etc.
Las listas se pueden utilizar para implementar otras estructuras tales como listas circulares, vectores,
pilas, colas, rboles, grafos y matrices.
De cada estructura nos interesa saber cules son los algoritmos para acceder a ellas. Una vez que
conocemos, perfectamente, el tipo de operaciones que las definen, cualquier tipo de implementacin es
vlida. Por ejemplo, es frecuente usar una implementacin mediante listas para plasmar matrices.

Por otro lado, es fundamental aplicar tcnicas de diseo descendente para resolver todos nuestros
problemas e implementar las estructuras necesarias en nuestras aplicaciones.
6.4 MATRICES
Podemos definir matrices a partir de listas, primero de 2 dimensiones y, ms tarde, generalizar
matrices de dimensin N.
En un lenguaje imperativo, recorrer una matriz de dos dimensiones implica el uso de un par de bucles
anidados, que proporcionan una complejidad computacional O(n2). Sin embargo, en Prolog, no disponemos
de este tipo de estructuras de control, por tanto, cualquier operacin debe ser resuelta de forma recursiva
mediante la declaracin formal de su enunciado.
Un tratamiento elemento a elemento de las matrices tal y como se realiza en un lenguaje imperativo
no es adecuado en Prolog, por tanto, conviene entender la estructura matriz como una lista de listas, y
aplicar los algoritmos diseados sobre listas para resolver problemas matriciales.
Una matriz de cuatro dimensiones se puede ver como la secuencia de un conjunto de matrices de tres
dimensiones, una matriz de tres dimensiones como un conjunto de matrices de dos dimensiones, una
matriz de dos dimensiones como un conjunto o lista de matrices de una dimensin (vector o lista), por
ltimo, un vector o lista no es ms que una secuencia de elementos simples.
Las definiciones dadas son recursivas, luego los algoritmos que debemos construir para realizar
operaciones sobre este tipo de estructuras, as definidas, tambin sern recursivos.

Operaciones con matrices bidimensionales
Domains
fila=integer*
matriz= fila*

predicates
sumafila(fila, fila, fila)
sumar(matriz, matriz, matriz)

clauses
/*Predicado para calcular la suma de los elementos de una fila */
sumafila([],[],[]):-!.
sumafila([], L2, L2):-!.
sumafila(L1, [], L1):-!.
sumafila([C1|Cola1], [C2|Cola2], Res):- S=C1+C2,
sumafila(Cola1, Cola2, ColaRes),
Res=[S|ColaRes].
/*Predicado de recorrido de las filas para sumar los elementos mediante el uso del
predicado anterior */

sumar([],[],[]):-!.
sumar([], L2, L2):-!.
sumar(L1,[], L1):-!.
sumar([C1|Cola1], [C2|Cola2], LR):-sumafila(C1, C2, Res),
sumar(Cola1, Cola2, ColaRes),
LR=[Res|ColaRes].

Goal
sumar([[1,2,3],[2,2,2],[4,4,4]],[[1,1,1],[2,1,2],[1,2,3]],R).

CAPITULO 3.
7 Manipulacin del Control en Prolog
En el captulo anterior, hemos aprendido cmo es el esquema bsico de trabajo en Prolog.
Sabemos que un programa lgico consta de una base de conocimientos donde expresamos los hechos
y reglas de deduccin que aportan la informacin completa acerca del mundo o dominio que deseamos
representar.
Por otro lado, disponemos de un motor de inferencia que aplica un algoritmo, concretamente el
algoritmo de resolucin, que permite inferir nuevos datos relativos al mundo que estamos representando.
Para ello, toma como entrada la base de conocimientos desarrollada y el objetivo planteado y ofrece como
salida un resultado de verdadero o falso en funcin de si ha podido o no demostrar el objetivo segn la base
de conocimientos. Adems proporciona tambin el conjunto de sustituciones o unificaciones para los
parmetros de salida especificados en el objetivo.
El algoritmo de demostracin del objetivo se basa en el uso de la tcnica de backtracking, de forma que
la inferencia de dicho objetivo se realiza a base de prueba y error. Debido a este tipo de funcionamiento,
podemos notar que el control de la ejecucin lo lleva la mquina Prolog y, aparentemente, nosotros no
podemos interferir en dicho control.
El hecho de que exista este tipo de control automtico supone una extraordinaria ventaja a la hora de
programar aunque, en ocasiones, tambin limita el funcionamiento o la eficiencia del programa diseado.
Para solventar esta limitacin, se introduce en Prolog la posibilidad de incluir en nuestras bases de
conocimientos unos predicados especiales que tienen como misin proporcionar una herramienta, un tanto
artificial, para "controlar el control".
8 Corte (!) y fail
En este apartado describiremos el significado de los predicados "!" (Corte), y fail. Veremos
grficamente como actan, y propondremos algunos ejemplos de cmo y cundo deben utilizarse.
8.1 El Corte "!"
Podemos definir el Corte como un predicado que siempre se cumple, es decir, que genera un resultado
verdadero en la primera ejecucin, y falla en el proceso de backtracking, impidiendo dicho retroceso. Su

aplicacin principal es generar cdigo ms eficiente por el efecto que causa en la reduccin o poda del rbol
de bsqueda generado durante el procedimiento de resolucin.
Para comprender el funcionamiento de este predicado nada mejor que considerar un par de ejemplos,
cuyos rboles de bsqueda se muestran en la Figura 15 y Figura 16.

Ejemplo:
Base de conocimientos sin utilizar el Corte.
padre(juan, pepe).
padre(juan, luis).
padre(juan, alberto).
hermanodepadre(X,Y):-padre(Z,X), padre(Z,Y).
Objetivo
?.- hermanodepadre(pepe, ana).
No
El proceso de ejecucin se observa en la Figura 15.

hermanodepadre(pepe, ana)
padre(Z, pepe) padre(juan, ana)
XITO
padre(juan, pepe)
Z
=
j
u
a
n
padre(juan, pepe)
FALLO
padre(juan, luis) padre(juan, alberto)
FALLO FALLO
padre(juan, luis)
FALLO
Z
=
j
u
a
n
Z
=
j
u
a
n
padre(juan, alberto)
FALLO
FALLO

Figura 15, rbol de ejecucin para la base de conocimientos y objetivo del ejemplo que no usa corte

Como se observa en el rbol de ejecucin, cuando falla el segundo predicado del consecuente, al hacer
backtracking, ignoramos la solucin obtenida para el primer predicado en la rama anterior, y buscamos una

nueva solucin, con la esperanza de hallar aquella que, posteriormente, satisfaga al segundo predicado. Sin
embargo, nosotros sabemos, a priori, que dicha solucin no va a ser posible, porque ya hemos demostrado
que juan es el padre de pepe y no lo es de ana, luego ambos no son hermanos de padre, luego, en este caso,
no interesa seguir buscando nuevos padres para pepe (esto sera absurdo e ineficiente). Por tanto, no es
necesario desarrollar la rama de retroceso representada por la lnea discontinua en la Figura 15.
En la Figura 16 se muestra como queda el rbol al introducir en el cdigo, el predicado corte. La rama
que no se procesa se representa en color gris, para que sea posible la comparacin con el ejemplo anterior.

Ejemplo:
Base de conocimientos utilizando el Corte.
padre(juan, pepe).
padre(juan, luis).
hermanodepadre(X,Y):-padre(Z,X), !, padre(Z,Y).
Objetivo
?.- hermanodepadre(pepe, ana).
no
El proceso de ejecucin se observa en la Figura 16.

hermanodepadre(pepe, ana)
padre(Z, pepe) padre(juan, ana)
XITO
padre(juan, pepe)
Z
=
j
u
a
n
padre(juan, pepe)
FALLO
padre(juan, luis) padre(juan, alberto)
FALLO FALLO
FALLO
Corte(!)

Figura 16, rbol de ejecucin utilizando el corte


Utilidad del predicado Corte
Las principales utilidades del Corte se exponen en los puntos siguientes:
- Confirmacin de la regla elegida. Por ejemplo, cuando calculamos el factorial, slo hay una posible
solucin para el mismo, sin embargo, desde el entorno de programacin, en la ventana de objetivos,
podemos pedir una nueva solucin. En lugar de buscarla, un programa correcto debe indicar que no
hay ms soluciones, aunque exista la posibilidad de realizar el procedimiento de retroceso. La forma
de construir dicho programa es mediante el uso del Corte, es decir manejando desde la base de
conocimientos el control de la mquina Prolog.
- Ahorrar comprobaciones innecesarias, como en el caso de los ejemplos vistos en el punto anterior.
- Parar al obtener una solucin y no permitir que se generen nuevas soluciones, aunque se lo
indiquemos de modo forzado.
- Para construir la negacin conjuntamente con el predicado fail, como se ver en la seccin
"Implementacin de la negacin y predicado repeat".
8.2 El predicado fail
Se trata de un predicado que siempre falla, por tanto, implica la realizacin del proceso de retroceso
para que se generen nuevas soluciones.
Una aplicacin de este predicado, entre otras que ya se han comentado en el punto anterior, es la
generacin de todas las posibles soluciones para un problema.
Recordemos que cuando la mquina Prolog encuentra una solucin para y devuelve el resultado de la
ejecucin. Con fail podemos forzar a que no pare y siga construyendo el rbol de bsqueda hasta que no
queden ms soluciones que mostrar. A continuacin se ilustra el funcionamiento de este predicado con un
ejemplo sencillo.


Ejemplo:
Base de conocimientos.
padre(juan, pepe).
padre(juan, luis).
listado:-padre(juan,X), write(X), nl, fail.
Objetivo
?.- listado.
pepe
luis
alberto

no.
El proceso de ejecucin se observa en la Figura 17 .

listado
padre(juan, X)
XITO
padre(juan, pepe)
X
=
p
e
p
e
FALLO
fail write(X) nl
XITO
padre(juan, luis)
XITO
padre(juan, alberto)
X
=
l
u
i
s
X
=
a
l
b
e
r
t
o

Figura 17, Ilustracin del funcionamiento del predicado fail

8.3 Implementacin de la negacin y predicado repeat
Veamos cmo se implementan dos predicados interesantes: not y repeat
Predicado not (negacin).
Como se coment en el punto anterior, la negacin se implementa como fallo, de modo que para negar
algo, debemos demostrar que el objeto de la negacin falla, es decir, para negar P, hemos de demostrar que
P es falso y por tanto, la negacin de P es verdadera.

El predicado not ya est implementado en Prolog pero conviene conocer dicha implementacin.
not(P):-call(P), !, fail.
not(P).
Para comprender la implementacin de la negacin nos vamos a fijar en la Figura 18, que muestra el
funcionamiento del predicado cuando P es cierto y en la Figura 19, que muestra el funcionamiento cuando P
es falso.
not(P)
call(P)
XITO
FALLO
! fail
FALLO

Figura 18, Funcionamiento de not cuando P es cierto

not(P)
call(P)
FALLO
XITO
not(P)
XITO

Figura 19, Funcionamiento de not cuando P es falso

Como ya se ha comentado la interpretacin dada de not se basa en una hiptesis de modelizacin que
habitualmente se conoce con el nombre de "supuesto de mundo cerrado", y que se puede formular como la
afirmacin de que si no podemos demostrar que una clusula es cierta, entonces podemos afirmar de
forma coherente que la negacin de la clusula es verdadera. Sin embargo, esta no es la negacin que se
utiliza en la lgica clsica y, por tanto, introduce problemas en la actividad de modelizacin lgica [Adarraga,
1994].
Consideremos por ejemplo, la asercin "soltero(X) si no casado(X)". Dicha asercin parece equivalente
a "casado(X) si no soltero(X)". Pero si utilizamos la primera asercin bajo el supuesto de mundo cerrado, con
un individuo X de cuyo estado nada sabemos, podemos concluir que es soltero, mientras que si utilizamos la
segunda asercin, podemos inferir que est casado.
casado(pepe).
soltero(X):-not(casado(X)).

Supongamos que no sabemos el estado de X=juan. Esto implica que casado(juan) falla y, por tanto,
not(casado(juan)) es cierto, luego soltero(juan) es cierto.
soltero(pepe).
casado(X):-not(soltero(X)).
Supongamos que no sabemos el estado de X=juan. Esto implica que soltero(juan) falla y, por tanto,
not(soltero(juan)) es cierto, luego casado(juan) es cierto.
Como vemos, el resultado del estado de un individuo del que no sabemos nada depende de cmo
implementemos la base de conocimientos. Una situacin, por tanto, ilgica y contradictoria.
Predicado repeat
Se implementa como:
repeat.
repeat:-repeat.
Esto implica que siempre que hacemos backtracking repeat es verdadero.

Ejemplo:
predicates
nondeterm repeat
opcion(integer)
nondeterm menu

clauses
repeat.
repeat:-repeat.

/* Cmo hacer un men de opciones */
opcion(X):-X=0, write("Has elegido salir"), nl, !.
opcion(X):-write("No has elegido salir"), nl.
menu:-repeat,
write("Elige opcin (0 para salir, Otro para continuar): "),
readint(X),
opcion(X),
X=0.
goal
menu.

La ejecucin de la meta proporciona el siguiente resultado:
Elige opcin (0 para salir, Otro para continuar): 1
No has elegido salir

Has elegido salir
yes
CAPITULO 4.
Aplicaciones del Lenguaje PROLOG
9 Aplicaciones actuales del Lenguaje PROLOG
Como hemos visto, programar en Prolog abre nuestras mentes a un nuevo modo de ver la
computacin. Puede que nos resulte difcil comprender esta tcnica, pero nos preocupa, finalmente, ms
que su dificultad, su utilidad, ya que muchas veces nos preguntamos para qu aprender conceptos que
puede que en el futuro no sirvan.
Este captulo trata de mostrar de forma general la importancia actual que este tipo de paradigmas
tiene. En concreto, el paradigma declarativo lgico y, por supuesto, el lenguaje Prolog.
Prolog se puede utilizar para resolver, bsicamente, cualquier tipo de problema. Principalmente es til
en la gestin de Juegos, en Inteligencia Artificial y Sistemas Expertos, como lenguaje especialmente pensado
para construir bases de conocimientos basados en la lgica que forman parte importante de cualquier
agente inteligente, en la construccin de Compiladores e Intrpretes, en el Reconocimiento del Lenguaje
Natural, etc.
9.1 Inteligencia Artificial
La resolucin de juegos y la planificacin as como la construccin de agentes inteligentes constituyen
amplios campos que abarca la rama de la Inteligencia Artificial. A continuacin, veremos algunos ejemplos
de resolucin de juegos y problemas tpicos de planificacin implementados en Prolog. Podremos observar
la facilidad con la que podemos plasmar las especificaciones de los problemas directamente, utilizando una
sintaxis que nos proporciona un alto grado de abstraccin. Esto nos aporta una gran ventaja a la hora de
realizar el desarrollo de la aplicacin una vez analizado el problema y diseada su solucin.


PROBLEMA DE LAS OCHO REINAS
El problema de las ocho reinas y en general de las N reinas, se basa en colocar 8 reinas en un tablero de
88 (o N en un tablero de NN, si el problema se generaliza), de forma que en no puede haber dos piezas
en la misma lnea horizontal, vertical o diagonal, ver Figura 20.

Figura 20, Posible solucin para el problema de las ocho reinas

Este programa ha sido muy estudiado por los matemticos. Se trata de un problema NP-Completo que
no tiene solucin para N=2 y N=3. Para N=4 tiene una nica solucin. Para N=8 hay ms de 80 soluciones
dependiendo de las restricciones que se impongan.
Una forma de abordar el problema se lleva a cabo mediante la construccin de un predicado en Prolog
del tipo siguiente: reinas(N, Solucion), donde N representa las dimensiones del tablero y el nmero de
reinas y Solucion es una lista que contiene la permutacin de la lista de nmeros que resuelven el problema.
Los ndices de dicha lista representan la columna en la que se encuentra una reina y el nmero que
almacena la posicin o ndice representa la fila donde la reina est colocada. As, para el ejemplo mostrado
en la Figura 20, tenemos que R=[2,4,1,3].
Este problema es resuelto, de modo clsico, por el mtodo de prueba y error, luego se adapta
perfectamente a un algoritmo de backtracking. Bsicamente, el problema se reduce a colocar una reina, e
intentar repetir el proceso teniendo en cuenta la reina colocada. Si logramos poner todas las reinas el
problema se ha resuelto, en caso contrario, deshacemos lo que llevamos hasta ahora y probamos con otra
combinacin. Por tanto, hemos de generar un conjunto de permutaciones y seleccionar aquella que cumpla
los requisitos impuestos por el juego.
Veamos el cdigo que resuelve el problema:
domains
lista=integer*

predicates
rango(integer, integer, lista)

nondeterm dame(integer, lista, lista)
nondeterm permuta(lista, lista)
atacada(integer, integer, lista)
correcta(lista)
nondeterm reina(integer, lista)

clauses
rango(N, N, [N]):-!.
rango(N, M, [N|Cola]):-N<M, Aux=N+1, rango(Aux, M, Cola).

dame(X,[X|Xs],Xs).
dame(X,[Y|Ys],[Y|Zs]):-dame(X,Ys,Zs).

permuta([],[]).
permuta(L,[Z|Zs]):-dame(Z,L,Ys), permuta(Ys,Zs).

atacada(X,N,[Y|Ys]):-X=Y+N, !; X=Y-N, !.
atacada(X,N,[_|Ys]):-N1=N+1, atacada(X,N1,Ys).

correcta([]):-!.
correcta([X|Y]):-correcta(Y), not (atacada(X, 1, Y)).

reina(N, Solucion):-rango(1,N,L1), permuta(L1,Solucion), correcta(Solucion).

goal
write("Tamao tablero = "), readint(N),
nl,
write("Soluciones: "), nl,
reina(N, Solucion),
write(Solucion),nl, fail.

Es muy importante comprender como funciona cada uno de los predicados para entender el
funcionamiento del algoritmo general.
Prolog permite implementar los programas casi directamente a partir de las especificaciones realizadas
a partir de un anlisis y diseo de la solucin desde un alto nivel de abstraccin. Adems el procedimiento
de backtracking est implcito en el propio motor de inferencia, luego este paradigma se adapta
perfectamente a nuestro problema.
Si analizamos y diseamos nuestro problema tenemos que la forma de resolverlo se resume en los
pasos siguientes:
1. Para N, obtenemos una lista de nmeros comprendidos entre 1 y N: [1,2,3,4,...,N].
2. Obtenemos una permutacin del conjunto de nmeros de la lista.
3. Comprobamos que la permutacin es correcta.
4. Si la permutacin no es correcta, lo que debemos hacer es volver al paso 2 para generar una
permutacin nueva.

Comencemos a analizar la solucin implementada. El problema se resuelve con el predicado reina(N,
Solucion):-rango(1,N,L1), permuta(L1,Solucion), correcta(Solucion). Como vemos es, sencillamente,
una copia de las especificaciones realizadas ms arriba. Se genera el rango entre 1 y N, se obtiene una
permutacin y se comprueba si la permutacin es, o no, correcta. En el caso de que cualquier predicado del
consecuente falle, la propia mquina Prolog se encarga de realizar el proceso de backtracking. Con lo cual ya
tenemos cubiertos los cuatro pasos fundamentales del algoritmo.
Para tener ms claras las ideas, observemos el rbol de ejecucin general del objetivo
reina(4,Solucion) en la Figura 21.
reina(4,Solucion)
rango(1,4,L1) permuta(L1,Solucion) corrrecta(Solucion)
L1=[1,2,3,4] Solucion=[1,2,3,4] Solucion=[1,2,3,4]
FAIL
Solucion=[1,2,4,3]
Solucion=[2,4,1,3]
Solucion=[1,2,4,3]
FAIL
Solucion=[2,4,1,3]
XITO
Solucion=[2,4,1,3]

Figura 21, rbol de ejecucin para el objetivo reina(4,Solucion)

Para N=4, existe una nica solucin, aunque si ejecutamos el programa, veremos que se obtienen dos
soluciones. La segunda solucin es la primera girada, ver Figura 22.

Figura 22, Soluciones al problema de las 4 reinas

ANALOGA
Analoga es un problema clsico de Inteligencia Artificial diseado por Evans para resolver cuestiones
de analoga geomtrica en tests de Inteligencia.

En este tipo de tests de Inteligencia se presentan varias figuras geomtricas complejas. Cada figura
compleja est formada por figuras ms pequeas unas dentro de otras, a este conjunto lo denominamos
Origen. Por otro lado, tenemos otro conjunto de figuras complejas que forman parte del conjunto
Respuesta. Se trata, pues, de encontrar una similitud entre las figuras de Origen y las figuras del conjunto
Respuesta. La relacin entre las figuras de Origen es del tipo A es a B como C es a X, siendo X la solucin que
puede encontrarse, o no, en el conjunto Respuesta. Si existe en dicho conjunto una figura que satisfaga la
anterior afirmacin, X se empareja con dicha figura, en caso contrario, hemos de responder que no existe
analoga entre el conjunto Origen y el conjunto Respuesta.
Veamos un ejemplo que ilustre todos estos conceptos. Dada la situacin de la Figura 23, la respuesta
correcta sera 2.

Figura 23, Problema de Analoga

La solucin como vemos consiste en aplicar la operacin invertir a la figura C. Teniendo en cuenta esto,
podemos escribir un programa que resuelva, de forma general, este tipo de analogas. Los pasos
fundamentales se exponen a continuacin.
1. A debe ser el inverso de B.
2. Eso implica que debemos calcular el inverso de C.
3. Si el inverso de C est en la lista de respuestas, hemos encontrado la respuesta.
4. En caso contrario, volvemos al paso 2 para encontrar otra solucin.

La implementacin de las figuras complejas es sumamente importante. Por tanto, vamos a definirlas.
Las figuras complejas estn formadas por dos figuras ms simples una dentro de otra. As la figura A se
puede representar mediante el predicado: dentro(cuadro,triangulo).
Una vez que sabemos plasmar dichas figuras, veamos el cdigo fuente del programa Prolog que
resuelve este tipo de analogas.
domains
disposicion= dentro(symbol, symbol);
fuera(symbol, symbol)
lista=disposicion*
test=determ (integer, disposicion) - (i, o)

predicates
figuras(integer, disposicion, disposicion, disposicion)
respuestas(integer, lista)
esta(disposicion, lista)
casar(disposicion, disposicion)
analogia(disposicion, disposicion, disposicion, disposicion, lista)
test_analogia: test

clauses
figuras(1, dentro(cuadro, triangulo), dentro(triangulo, cuadro), dentro(circulo, cuadro)):-
!.
figuras(2, dentro(cuadro, triangulo), dentro(triangulo, cuadro), dentro(circulo, cuadro)).
respuestas(1, [dentro(circulo, triangulo), dentro(cuadro, circulo), dentro(triangulo,
cuadro)]):-!.
respuestas(2, [dentro(circulo, triangulo), dentro(circulo, cuadro), dentro(triangulo,
cuadro)]).

esta(X, [X|_]):-!.
esta(X, [_|Y]):-esta(X,Y).

casar(dentro(F1, F2), dentro(F2, F1)):-!.
casar(fuera(F1, F2), fuera(F2, F1)).

analogia(A, B, C, X, Respuestas):-casar(A, B),
casar(C, X),
esta(X, Respuestas).

test_analogia(Numero, X):-figuras(Numero, A, B, C),
respuestas(Numero, Respuestas),
analogia(A, B, C, X, Respuestas).

goal
write("Dame nmero de test: [1,2]: "),
readint(N),
test_analogia(N, X),
write(X).

Si nos centramos en el predicado analogia vemos que se ajusta, perfectamente, a los pasos generales
de resolucin del problema expuestos en la fase de anlisis-diseo:
analogia(es_a(A, B), como_es_a(C, X), Respuestas):-casar(A, B),

casar(C, X),
esta(X, Respuestas).
Por un lado intentamos casar A y B, esto implica que A debe ser el inverso de B. Si este predicado se
cumple, continuamos con la siguiente clusula del consecuente. Como X no est an instanciada, X se
instancia al valor inverso de C. A continuacin, se comprueba si X est en la lista de respuestas. En caso de
que est, analogia termina, si no, analogia mediante backtracking busca una nueva solucin, hasta que la
encuentre o demuestre que no existe.
test_analogia(Numero, X) es un predicado que permite probar el funcionamiento de analogia para un
conjunto de figuras dado. Para testear el predicado diseado se han seleccionado los tests de la Figura 24.

(a)

(b)
Figura 24, Tests del ejemplo codificado en Prolog

9.2 Sistemas Expertos
Los agentes y sistemas expertos se pueden considerar entes capaces de actuar como lo hara un
experto humano en la resolucin de un determinado problema. Pueden percibir el ambiente mediante
sensores y actan sobre ese ambiente por medio de efectores. En los agentes hardware, los sensores son
sustituidos por cmaras y telmetros y los efectores son reemplazados mediante motores. En los agentes
software, las percepciones y acciones vienen a ser las cadenas de bits codificados. La Figura 25 muestra un
agente genrico.

AMBIENTE
percepciones
acciones
sensores
efectores
AGENTE

Figura 25, Estructura general de un agente inteligente

Pero, tanto si un agente es hardware o software, necesita un programa que permita transformar los
datos provenientes del entorno de usuario en acciones adecuadas para la resolucin del problema para el
que han sido diseados.
Estos programas se pueden construir siguiendo multitud de paradigmas, y uno de ellos es la
programacin lgica, que, como hemos visto, se adapta perfectamente a la representacin del
conocimiento.
Existen muchos tipos de sistemas expertos: de diagnstico mdico, para el anlisis de imgenes de
satlite, clasificadores, controladores, asesores, agentes econmicos, etc.
Como ejemplo de sistema experto tenemos el programa Prolog que permite conocer la velocidad de un
vehculo dadas sus caractersticas y las de la va por la que circula.
Dado que hemos hablado repetidas veces de estos sistemas a lo largo del curso, no vamos a
profundizar ms en esta cuestin.
9.3 Compiladores
La comprensin del lenguaje natural y la construccin de compiladores e intrpretes son campos de
desarrollo muy adecuados para Prolog.
En esta seccin vamos a ver una aplicacin de la programacin lgica a la teora de autmatas y
lenguajes formales.
En Prolog se puede especificar un autmata finito mediante tres hechos, simplemente. El predicado
inicial, inicial(Q), es true si Q es el estado inicial. El predicado final(Q) es true si Q es el estado final. Y el
predicado delta(Q, X, Q1) que funciona del siguiente modo: es true si el autmata cambia del estado Q al
estado Q1 al recibir el smbolo X. El autmata recibe una cadena de smbolos del alfabeto E*. El autmata

reconoce el lenguaje si comenz en el estado inicial y acab en el estado final tras seguir las transiciones
especificadas por o.
Veamos un ejemplo concreto utilizando el lenguaje (ab)*. La Figura 26 representa el autmata que
reconoce el lenguaje.
q0 q1
a
b

Figura 26, Reconocedor del lenguaje (ab)*

El cdigo del programa Prolog para implementar el reconocedor se expone a continuacin.
domains
lista=char*

predicates
inicial(symbol)
final(symbol)
delta(symbol, char, symbol)
aceptar(lista, symbol)
acepto(lista)

clauses
inicial(q0).
final(q0).
delta(q0, 'a', q1).
delta(q1, 'b', q0).

acepto(L):-inicial(Q), aceptar(L,Q).
aceptar([X|Y], Q):-delta(Q, X, Q1), aceptar(Y, Q1).
aceptar([],Q):-final(Q).

goal
write("Dame lista de smbolos: "), readterm(lista, L),
acepto(L),
nl,
write("Pertenece al lenguaje").
Las trazas de los programas para los casos ab y aa se muestran en la Figura 27.

aceptar([a,b])
inicial(Q)
inicial(q0)
aceptar([a,b], q0)
aceptar([a|[b]], q0)
delta(q0, a, q1) aceptar([b], q1)
aceptar([], q1)
final(q0)
delta(q1, b, q0)
XITO
XITO
XITO
XITO

(a)
aceptar([a,a])
inicial(Q)
inicial(q0)
aceptar([a,a], q0)
aceptar([a|[a]], q0)
delta(q0, a, q1) aceptar([a], q1)
delta(q1, a, q0)
XITO
FAIL
FAIL

(b)
Figura 27, rboles de ejecucin del predicado reconocedor del lenguaje (ab)*

9.4 Miscelnea
Como ya hemos comentado, Prolog se puede adaptar a la resolucin de casi cualquier tipo de
problema con gran facilidad. Aunque, en mi opinin, es ideal como lenguaje de implementacin de
aplicaciones provenientes del campo de la Inteligencia Artificial.
En este punto, vamos a proponer y resolver algunos problemas tpicos que se pueden resolver en
Prolog de un modo sumamente sencillo.
TORRES DE HANOI
El problema de las torres de Hanoi consiste en mover un conjunto de discos de un palo a otro palo
utilizando un palo auxiliar situado en medio. Las reglas para mover los discos son las siguientes:
- No se puede mover ms de un disco en cada ocasin.
- No puede quedar un disco de menor radio debajo de un disco de mayor radio.
- Mover el conjunto de discos se puede ver como: mover N-1 discos del palo izquierdo al palo del
medio, mover el disco sobrante del palo izquierdo al palo derecho y mover N-1 discos del palo del
medio al palo derecho.
El pseudocdigo del algoritmo queda como sigue:
hanoi(N)mover(N,izquierda,medio,derecha).
mover(1,A,_,C)Pasar disco de A a C.
mover(N,A,B,C)mover(N-1,A,C,B), mover(1,A,C), mover(N-1,B,A,C).

La solucin del problema de las torres de Hanoi para tres discos y tres palos se muestra en la Figura 28.
A B C

A B C

A B C

A B C

A B C

A B C

C B A

C A B

Figura 28, Solucin al problema de las Torres de Hanoi, con tres palos y tres discos

10 Lneas Futuras
Los agentes inteligentes, quienes funcionan como sistemas de razonamiento, son necesarios para
obtener resultados eficaces. La principal ventaja que ofrecen es su alto grado de modularidad. Adems, es
posible independizar la estructura de control del conocimiento, con lo que cada porcin del mismo
mantiene total independencia entre s. Actualmente se trabaja en la construccin de agentes inteligentes
verdaderamente eficientes tanto hardware como software. Para comprender cuales son las lneas futuras
que se pretenden trazar, conviene saber qu se est haciendo en la actualidad, por tanto, vamos a describir
brevemente los cuatro grupos principales que componen la clasificicacin de los sistemas de razonamiento
automtico, cada uno diseado especficamente para resolver distintos tipos de problemas:
- Demostradores de teoremas y lenguajes de programacin lgicos. En los demostradoress de
teoremas se utiliza la resolucin o algn otro procedimiento de inferencia completa para
demostrar oraciones expresadas en lgica de primer orden total, frecuentemente en trabajos de
razonamiento matemtico y de tipo cientfico. Tambin son empleados para responder preguntas:
la demostracin de una oracin que contiene variables sirve como respuesta a una pregunta
debido a que concretiza las variables. Los lenguajes de programacin lgicos se caracterizan por
restringir la lgica, lo que impide el manejo completo de la negacin, la disyuncin y/o la igualdad.
Por lo general utilizan el encadenamiento hacia atrs, y a veces pueden incluir caractersticas no
lgicas de los lenguajes de programacin (por ejemplo, entrada y salida). Tenemos como ejemplos
de demostradores de teoremas a SAM, AURA, OTTER, y como ejemplo de lenguajes lgicos,
tenemos PROLOG, MRS, LIFE.

- Sistemas de produccin. Estos sistemas, al igual que los lenguajes de programacin, utilizan la
implicacin como elemento primario de representacin. El consecuente de cada implicacin se
interpreta como recomendacin de la accin, y no como mera conclusin lgica. Funcionan con
una estructura de control de encadenamiento hacia delante. Algunos de ellos cuentan con un
mecanismo de resolucin de conflictos para decidir qu accin emprender cuando son varias las
que se recomienda realizar. Citemos algunos ejemplos: OPS-5, CLIPS, SOAR.
- Sistemas de cuadro y redes semnticas. En estos sistemas se aplica la metfora de que los objetos
son nodos de una grfica, de que estos nodos se organizan de acuerdo a una estructura
taxonmica y de que los vnculos que existen entre los nodos representan relaciones binarias. En
los sistemas de cuadro estas relaciones se consideran como ranuras de un cuadro que se llenan
mediante otra. En las redes semnticas, en cambio, se consideran como flechas entre un nodo y
otro. Tenemos ejemplos de sistemas de cuadro como OWL, FRAIL, KODIAK, y ejemplos de redes
semnticas: SNEPS, NETL, Grficas Conceptuales.
- Sistemas lgicos por descripcin: Son la consecuencia de la evolucin de las redes semnticas, al ser
presionadas para formalizar el significado de las redes, sin dejar de poner nfasis en la estructura
taxonmica como principio rector. La idea consiste en emplear como medio de expresin y de
razonamiento las definiciones complejas de objetos y clases, as como sus relaciones entre ellos.
Los trabajos ms recientes se han enfocado al compromiso entra expresividad del lenguaje y
complejidad para el cmputo de ciertas operaciones. Tenemos como ejemplos KL-ONE, CLASSIC,
LOOM.
Durante el curso, nos hemos centrado en el estudio del primer grupo de la clasificacin citada. Los
lenguajes lgicos, como ya se ha comentado, ofrecen muchas ventajas y, evidentemente, plantean
inconvenientes que deben ser subsanados.
En concreto, si utilizamos un entorno de programacin interpretado de Prolog notaremos que la
eficiencia, en cuanto a velocidad de ejecucin se refiere, disminuye, al igual que en cualquier lenguaje
interpretado, frente a un lenguaje compilado.
El conjunto de instrucciones de las computadoras actuales resulta muy pobre en relacin con la
semntica de Prolog, por lo que la mayora de los compiladores de Prolog, que tambin existen, realizan una
compilacin a un lenguaje intermedio en vez de hacerlo directamente a lenguaje mquina. El lenguaje ms
popular es el Warren Abstract Machine (WAM), que es un conjunto de instrucciones abstractas utilizable en
Prolog y que se puede interpretar o traducir a lenguaje mquina. Existen otros compiladores que traducen
Prolog a un lenguaje de alto nivel como Lisp o C, y utilizan dicho compilador para traducir a lenguaje
mquina.

Antes del trabajo de Warren sobre la compilacin de la inferencia en Prolog, la programacin lgica
resultaba excesivamente lenta para su uso generalizado. Los compiladores diseados por Warren y otros
permitieron a Prolog alcanzar velocidades adecuadas en estaciones de trabajo promedio modelo 1990. En
fechas ms recientes, la aplicacin de la moderna tecnologa de compilacin, incluidos inferencia de tipo,
codificacin abierta y anlisis de flujo de datos entre procedimientos ha permitido a Prolog alcanzar
velocidades tan ptimas que lo hace competir con C en cuanto a diversos aspectos estndar (Van Roy,
1990). Por supuesto, el hecho de poder escribir un planificador o un analizador de lenguaje natural en unas
cuantas decenas de lneas de Prolog, hacen que ste sea ms preferible que C en la realizacin de los
prototipos de gran parte de los proyectos de investigacin de Inteligencia Artificial a escala reducida.
Aparte de las mejoras que se estn realizando en cuanto a velocidad de ejecucin tambin se han
desarrollado y se estn desarrollando ampliaciones de Prolog que permiten su adaptacin a muchos
problemas que han surgido recientemente: programacin lgica y orientacin a objetos, programacin
concurrente, programacin visual y construccin de razonadores completos de lgica de primer orden.

CAPITULO 5.
LGICA MATEMTICA
11 Introduccin.
Dado que el Lenguaje Natural, aunque es potente, resulta muy ambiguo, nos interesa encontrar un
lenguaje ms sencillo, sin ambigedades que nos permita realizar razonamientos y generalizaciones. Por
ello, es necesario introducirnos en la formalizacin del Clculo Proposicional, que, aunque no cuenta con
toda la potencia necesaria para describir el mundo, es vlido como primera aproximacin. Tambin
veremos algunos conceptos del Clculo de Predicados y, por supuesto, nos centraremos en definir y ver
cmo funciona el Mtodo de Resolucin.
11.1 Conceptos bsicos.
Para comprender los principios de la lgica matemtica en el campo del Clculo Proposicional,
necesitamos conocer una serie de conceptos bsicos que se describen a continuacin:
tomo: Tambin llamado Frmula Atmica o Enunciado Simple. Permite la formalizacin de una
frase declarativa que no se puede descomponer en frases ms simples. Para denotar tomos se
utilizan las letras p, q, r, etc.
Conectiva: Operador que permite construir sentencias compuestas a partir de tomos. Las
principales conectivas lgicas son: , ., v, .
Enunciado: Tambin llamado Frmula. Es una expresin realizada con tomos y conectivas lgicas,
siguiendo unas determinadas normas. Para denotar enunciados se utilizan las letras A, B, C, etc.
Deduccin: Consiste en una lista de enunciados que, o bien son dados previamente, en este caso se
llaman Premisas, o bien se han obtenido de enunciados anteriores mediante la utilizacin de un
conjunto finito de reglas denominadas Reglas de Inferencia.
Dada una serie de premisas, a travs de las reglas de inferencia, podemos llegar a un enunciado que
podemos denominar enunciado Conclusin. El conjunto de pasos para llegar a este enunciado a partir de las
premisas usando dichas reglas de inferencia, compone un algoritmo general que permite automatizar el

proceso de demostracin. De esta forma, obtenemos un demostrador automtico de teoremas que es,
justamente, en lo que consiste la mquina PROLOG.
Aunque mediante la Lgica Proposicional podemos describir muchas situaciones, existen otras
imposibles de representar. Necesitamos introducirnos, adems, en la Lgica de Predicados. Podemos
considerar la Lgica Proposicional como un subconjunto de la Lgica de Predicados o de Primer Orden. Por
tanto, a las definiciones anteriores, hemos de aadir otras nuevas que nos permitan comprender los
mtodos que se explicarn en apartados posteriores.
Smbolos: Existen varios tipos:
- Individuales o Constantes: Representan valores concretos. C={a, b, c, d, e}.
- Variables: Se pueden sustituir por constantes. V={x, y, z, v, w}.
- Funciones: Aplicacin que asocia una serie de constantes con otra constante. F={f, g, h}.
- Predicados: Funcin de resultado Verdadero o Falso. Pred={P, Q, R}.
- Relaciones: Representan relaciones o cuantificaciones. Rel={., v, , , , , -}
- Signos de puntuacin: Permiten agrupar o separar otros smbolos. Pun={(, ), ,, [, ]}
Trminos: Se pueden definir de varias maneras. A continuacin se exponen las distintas formas de
definicin de trminos:
- Una constante: a, c.
- Una variable: x, z.
- Si f es un smbolo de funcin y t
1
, t
2
,..., t
n
son trminos, entonces f (t
1
, t
2
,,..., t
n
) es un trmino, por
ejemplo g(a, f(x)).
Frmulas: Se definen como:
- Si R es un smbolo de relacin y t
1
, t
2
,..., t
n
son trminos, entonces R (t
1
, t
2
,,..., t
n
) es una frmula.

Ejemplo:
f(a, x) . g(x), x (g(x) v a) [f(a, v) . P(b v c)]

- Si A y B son dos frmulas y R es un smbolo de relacin, entonces R(A, B) tambin es una frmula.


Ejemplo:
[x (g(x) v a) (f(a, v) . P(b v c))] v (f(a, x) . g(z))

Sentencias: Se definen como frmulas en las que ninguna de las variables que la componen tiene
una o ms ocurrencias libres, o sea, todas las variables de la frmula son ligadas. Es necesario que
definamos, por tanto, lo que son variables libres y ligadas.
- Una ocurrencia de una variable x es ligada en una frmula si y slo si se da una de las siguientes
condiciones:
1) La variable x est inmediatamente despus de un smbolo -.
2) La variable x est en el radio de accin de un cuantificador x -x.
- El radio de accin de un cuantificador en una frmula abarca al trmino inmediatamente
siguiente, hacindose imprescindible el uso de parntesis para aumentar su radio de accin.

Ejemplos:
x (f(x) v g(z)). El cuantificador abarca a f(x) y g(z).
x h(x) v f(a, v, x). El cuantificador abarca slo a h(x).

- Una variable es libre en una frmula si no tiene ninguna ocurrencia ligada en la misma. En el
siguiente ejemplo, la variables v es libre, puesto que no tiene ninguna ocurrencia ligada. Sin
embargo, la x presenta una ocurrencia ligada, ya que g(x) cae dentro del radio de accin del
cuantificador x.

Ejemplo:
x [P(g(x)) v R(a)] [f(a, v) . Q(b v c)]

Sustituciones: Dado el conjunto de variables V y el conjunto de trminos Term, una sustitucin se
define como la aplicacin que se muestra en la Ec 1 y se suele denotar como s={x
1
/t
1
,...,x
n
/t
n
}. De
dicha definicin podemos concluir dos cosas:
- Slo son vlidas aquellas sustituciones que transforman una variable en una constante, en otra
variable o en una funcin, es decir, en trminos.
- La sustitucin de una variable afecta a todas las ocurrencias de la misma.
n n
t x
t x
Term V
... ...
1 1

Ec 1
11.2 Resolucin y unificacin. Mtodos.
La Deduccin Natural consiste en un sistema de reglas de inferencia que permite construir
deducciones, es decir, a partir de "algo" podemos deducir o "llegar a" "otra cosa", hasta que encontramos
una conclusin. Se trata de un mtodo puramente sintctico donde slo nos ocupamos de la manipulacin
de smbolos. Es un mtodo interesante para construir demostraciones, sin embargo es difcilmente
mecanizable.
Por otro lado, como hemos visto, es fcil representar hechos del mundo real mediante la lgica
proposicional y mediante la lgica de predicados. Adems mediante la lgica de predicados podemos
representar el conocimiento que tenemos sobre un cierto mundo finito ponindolo en forma de sentencias
y disponemos de un mecanismo para razonar con ese conocimiento. Sin embargo, lo que para el ser
humano resulta trivial, deducir una sentencia a partir de otra, para la mquina puede llegar a ser
computacionalmente muy costoso e, incluso, inviable. Los estudios, por tanto, se han centrado en conseguir
un mtodo de demostracin que se puede ejecutar en un tiempo finito, y que en dicho tiempo, de forma
eficiente, nos proporcione una solucin acertada.
El Mtodo de Resolucin [Robinson, 1965], es un intento de mecanizar el proceso de deduccin natural
de esa forma eficiente. Las demostraciones se consiguen utilizando el mtodo refutativo (reduccin al
absurdo), es decir lo que intentamos es encontrar contradicciones. Para probar una sentencia nos basta con
demostrar que su negacin nos lleva a una contradiccin con las sentencias conocidas (es insatisfactible). Si
la negacin de una sentencia entra en contradiccin con los hechos de nuestra base de conocimiento es
porque lo contrario, es decir, la sentencia original era verdadera y se puede deducir lgicamente de las
sentencias que componen dicha base de conocimientos.

Existen distintas Estrategias de Resolucin: sistemtica, con conjunto soporte, unitaria, primaria y
lineal.
En este apartado formularemos detalladamente el mtodo de Resolucin por Refutacin Lineal. Para
ello, es necesario conocer el proceso de conversin a forma clausal, ya que las clusulas con las que se
trabaja en esta tcnica deben tener una forma especfica. Por otro lado, hemos de definir tambin el
proceso o algoritmo de Unificacin, paso imprescindible en este mtodo de Resolucin.
Conversin a forma clausal.
El proceso de conversin a forma clausal consiste en transformar las sentencias y frmulas en
clusulas, cuya principal caracterstica, al nivel de representacin, es la ausencia casi total de smbolos de
relacin. En una clusula slo aparecern disyunciones "v".
De esta manera, el primer paso ser transformar todas las sentencias a una forma cannica llamada
forma normal conjuntiva [Davis y Putnam, 1960], a partir de la cual obtendremos el conjunto de clusulas.
As, podemos definir una clusula, ms formalmente, como una frmula en forma normalizada conjuntiva
que no tiene ninguna conectiva. Esta transformacin la vamos a realizar en varios pasos:
1) Primero pasaremos las sentencias a Forma Normal Prenexa.
2) En el siguiente paso las transformaremos a Funciones de Skolem.
3) Finalmente llegaremos a una representacin en Forma de Clusulas.
Forma Prenexa
Una frmula est en Forma Normal Prenexa si es de la forma: Q
1
x
1
...Q
n
x
n
Y donde Y es una frmula
desprovista de cuantificadores y escrita como conjuncin de disyunciones, Q
1,
...,Q
n
e {, -} y x
1
,..., x
n
son
variables.

Ejemplos:
x y -z v [(R(x) v T(y)) . Q(v, z)]
x -y (R(x, y) . Q(b, z))
x P(x, y)

Tenemos nuestro conocimiento en forma de sentencias, formadas por smbolos de relacin, variables,
constantes, cuantificadores, todos mezclados. Para transformar una frmula a Forma Normal Prenexa (o
inferencia por resolucin) seguiremos el siguiente algoritmo:
- Eliminar todos los smbolos de equivalencia (), sustituyndolos por una implicacin a la derecha y
una implicacin a la izquierda: P Q = (PQ) . (QP)
- Eliminar todas las implicaciones (), sabiendo que (a b) es equivalente a (a v b).
- Reducir el mbito de las negaciones (), a un nico trmino, usando las siguientes propiedades:
- (p)=p
- Leyes de Morgan: (a v b)= a . b y (a . b)= a v b
- x P(x) = -x P(x)
- -x P(x) = x P(x)
- Normalizar las variables de los cuantificadores, de forma que cada uno est ligado con una nica
variable. Para ello podemos, incluso, renombrar las variables.

Ejemplos:
x P(x) v x Q(x) y P(y) v x Q(x)
x [P(x) v Q(x)] . y R(y) v Q(x) z [P(z) v Q(z)] . y R(y) v Q(x)

- Mover todos los cuantificadores a la izquierda de la frmula sin cambiar su orden relativo.

Ejemplos:
x P(x) v x Q(x)
y x [P(y) v Q(x)]
(x R(x) v y T(y)) . -z v Q(v v z)
x y -zv [(R(x) v T(y)) . Q(v v z)]

Funciones de Skolem
El siguiente paso es convertir las frmulas de Forma Normal Prenexa a Frmulas de Skolem, que se
caracterizan por no estar cuantificadas existencialmente. Por tanto, el algoritmo de transformacin a forma
de Skolem elimina los cuantificadores existenciales.
Partimos de una frmula: Q
1
x
1
...Q
n
x
n
Y. Se recorre la frmula en forma prenexa de izquierda a derecha y
se eliminan los cuantificadores existenciales segn los dos casos siguientes:
Sea Q
r
un cuantificador existencial:
- Si no hay ningn cuantificador universal antes de Q
r
x
r
, elegir una nueva constante c distinta de
todas las que aparecen en Y, y reemplazar cada ocurrencia de x
r
en Y por c. Borrar Q
r
x
r
del prefijo
de la frmula.
- Si Q
s1
, Q
s2
,, Q
sk
son los cuantificadores universales que aparecen antes de Q
r
x
r
, tomar un nuevo
smbolo de funcin f distinto a todos los que aparecen en Y y reemplazar cada ocurrencia de x
r

por f(x
s1
,x
s2
,...,x
sk
). Borrar Q
r
x
r
del prefijo de la frmula.

Ejemplos:
1. Supongamos que tenemos:
x y -z [(R(x) v P(y)) . Q(b, z)]
nos queda como
x y [(R(x) v P(y)) . Q(b, f(x, y))]

2. Supongamos la siguiente sentencia:
-x y -w [R(a, w) v P(y) v P(f(x))]
sustituimos x por c (caso 1): y -w [R(a, w) v P(y) v P(f(c))]
sustituimos w por g(y) (caso 2): y [R(a, g(y)) v P(y) v P(f(c))]

- Representacin en forma de clusulas: El ltimo paso ser convertir las funciones de Skolem a
clusulas. Tenemos las frmulas cuantificadas universalmente, entonces podemos eliminar todos
los prefijos, de tal manera que la frmula resultante est en forma de conjuncin de disyunciones
(forma normal conjuntiva): (a v b v c) . (d v e) . (j v l v m). Finalmente, por cada conjuncin
obtenemos una clusula: (a v b v c), (d v e) y (j v l v m).

Todos los pasos que hemos visto podemos resumirlos en el siguiente algoritmo, que es justamente el
algoritmo general de conversin a forma clausal:
1. Convertir la frmula a Forma Normal Prenexa.
2. Transformarla a Forma de Skolem.
3. Pasar a Forma Normal Conjuntiva.
4. Separar cada conjuncin en una clusula.

Ejemplo:
Vamos a partir de la sentencia:
x [(R(x) v C(x, a)) . [O(x, b) v (-y(-z O(y, z) L(x,y)))]]
Paso 1: Eliminamos los smbolos de implicacin:
x [(R(x) v C(x, a)) . [O(x, b) v (-y(-z O(y, z) v L(x,y)))]]
Paso 2: Reducimos el mbito de las negaciones:
x [(R(x) v C(x, a)) . [O(x, b) v (-y(z O(y, z) v L(x,y)))]]
Paso 3: En este caso no es necesario normalizar las variables de los cuantificadores por lo tanto pasamos
al paso siguiente
Paso 4: Movemos los cuantificadores a la izquierda:
x -y z [(R(x) v C(x, a)) . (O(x, b) v (O(y, z) v L(x,y)))]
Paso 5: Eliminamos los cuantificadores existenciales:
x z [(R(x) v C(x, a)) . (O(x, b) v (O(s(x), z) v L(x, s(x))))]
Paso 6: Eliminamos todos los cuantificadores: [(R(x) v C(x, a)) . (O(x, b) v (O(s(x), z) v L(x, s(x))))]
Paso 7: Separar una clusula por cada conjuncin:
(R(x) v C(x, a))
(O(x, b) v (O(s(x), z) v L(x, s(x))))

Algoritmo de Unificacin.
Podemos definir la Unificacin como un procedimiento de emparejamiento que compara dos literales y
descubre si existe un conjunto de sustituciones que los haga idnticos. La idea bsica de la unificacin es
muy sencilla. Para unificar dos literales vamos recorrindolos de izquierda a derecha. En primer lugar se
comprueba si los predicados coinciden. Si es as, seguimos adelante; si no es que no son unificables. Si el

predicado concuerda, comenzamos a comparar los argumentos. Si el primero de ellos coincide en ambos
literales, continuamos con el siguiente... y as hasta completar todos los argumentos. Como resulta obvio,
ambos literales deben tener el mismo nmero de argumentos.
Para conseguir que cada argumento de un literal sea coincidente con su homlogo en el otro literal,
debemos buscar una sustitucin que nos permita emparejarlos. La nica condicin que debe reunir esta
sustitucin es que ha de aplicarse a todo el literal, es decir, que la sustitucin afecta a todo el literal, y no
slo al argumento en cuestin. Por decirlo de una manera sencilla, las sustituciones se van arrastrando a lo
largo del proceso de unificacin.

Ejemplo:
Vamos a unificar P(x, x) con P(y, z):
- Primera sustitucin: (y/x)
Resultado: P(y, y) P(y, z)
- Segunda sustitucin: (z/y)
Resultado: P(z, z) P (z, z)
La sustitucin resultante es la composicin de las sustituciones: s = { z/y , y/x}

Describamos a continuacin los pasos bsicos del algoritmo de unificacin:
Tomamos como entrada dos clusulas, R y S.
1 Si R = S entonces R y S son unificables.
2 Si no, localizar el smbolo ms a la izquierda de R que se diferencia de su homlogo en S
2.1 Si es el primero (predicado), entonces R y S no son unificables.
2.2 Si es uno de los argumentos, entonces sean t
1
, t
2
los trminos en los que difieren.
2.2.1 Si ninguno de los dos (t
1
, t
2
) es una variable, entonces las clusulas no son unificables. Tampoco lo
sern si siendo uno de ellos una variable, est presente en las variables del otro.
2.2.2 Si t
1
es una variable x y no est entre las variables del otro t
2
, entonces haremos la sustitucin: s =
{x/t
2
}
3 Volver al paso 1.
A partir del algoritmo de unificacin podemos extraer las siguientes conclusiones:

a) Podemos sealar como unificables todas aquellas clusulas que no coincidan en su predicado y nmero
de argumentos.
b) Antes de intentar la unificacin debemos asegurarnos que no existen variables comunes en ambas
clusulas.
c) Debemos recordar siempre las condiciones que debe reunir una sustitucin y que sta debe ser nica.

Ejemplo:
Unificacin de las sentencias R (x, f(g(x)), a) y R (b, y, z)
Trminos desiguales Sustitucin Resultado

t1 = x t2 = b x/b - R(b, f(g(b)), a) , R(b, y, z)

t1 = f(g(b)) t2 = y y/f(g(b)) - R(b, f(g(b)), a), R(b, f(g(b)), z)

t1 = a t2 = z z/a - R(b, f(g(b)), a) , R(b, f(g(b)), a)
Las dos clusulas son unificables y la sustitucin resultante es: s = { z/a , y/f(g(b)) , x/b }

Una vez que hemos comprendido como funciona el algoritmo de unificacin y cmo debemos
especificar adecuadamente las sentencias para llevar a cabo el algoritmo de resolucin por refutacin,
vamos a describir los pasos del mismo detenidamente.
Algoritmo de Resolucin
El procedimiento de resolucin consiste en un proceso iterativo en el cual comparamos (resolvemos),
dos clusulas llamadas clusulas padres y producimos una nueva clusula que se ha inferido (deducido), de
ellas. Por tanto, lo que hacemos es combinar las clusulas padres para dar lugar a una nueva clusula, en la
que podemos simplificar alguno de sus trminos.
Por ejemplo, supongamos que tenemos las clusulas siguientes (ambas verdaderas):
- invierno v verano (es invierno o es verano).
- invierno v fro (hace fro o no es invierno).
Aplicando resolucin, podemos combinar ambas clusulas y obtener:

- invierno v verano v invierno v fro.
Ahora podemos hacer una simplificacin, ya que (invierno . invierno) es una tautologa, con lo que
nos queda:
- verano v fro (es verano o hace fro).
Que tambin deber ser verdadera, pues hemos seguido puntualmente todas las propiedades de la
lgica de primer orden.
La resolucin opera tomando dos clusulas tales que cada una contenga un mismo literal, en una
clusula en forma positiva y en la otra en forma negativa. El resolvente se obtiene combinando todos los
literales de las clusulas padres y eliminando aquellos que se cancelan.
Si la clusula resultante es la clusula vaca (), entonces es que hemos llegado a una contradiccin.
Como observamos el proceso de resolucin parece sencillo. Podemos resumirlo formalmente en los
pasos siguientes, basados en el algoritmo de resolucin lineal:
Vamos a partir de un conjunto de clusulas. Nuestro objetivo es probar una sentencia mediante la
demostracin de que su negacin nos lleva a una contradiccin con las sentencias conocidas (es
insatisfacible):
1 Convertimos todas las proposiciones a forma clausal.
2 Negamos la proposicin que queremos demostrar y convertimos el resultado a forma clausal aadiendo
la clusula resultante al conjunto obtenido en el paso anterior.
3 Hasta que se encuentre una contradiccin o no se pueda seguir avanzando, repetimos lo siguiente:
3.1 Seleccionamos dos clusulas (clusulas padres) que contengan un literal comn pero con signos
contrarios y unificamos esos dos literales.
3.2 Las resolvemos juntas. La clusula resultante llamada resolvente, ser la disyuncin de los literales de
las dos clusulas padres, una vez realizadas las sustituciones apropiadas. El par de literales L y L, que
provienen de cada una de las clusulas padres, se pueden eliminar de la resolvente.
3.3 Si la resolvente es la clusula vaca, es que se ha encontrado una contradiccin. Si no, aadimos la
resolvente al conjunto de clusulas disponibles.
El algoritmo que acabamos de ver est definido de una forma muy general. Sin embargo, para su uso
cotidiano se pueden hacer una serie de sugerencias que, si bien en la mayora de los casos no estn basadas
en aserciones infalibles, pueden facilitar el proceso general de resolucin:

- Aunque no sea un criterio estricto, suele dar buenos resultados comenzar a resolver por las clusulas de
mayor tamao, es decir, las que poseen mayor nmero de literales.
- La clusula resolvente se aade al conjunto de clusulas disponible y, en teora, se puede continuar el
proceso tomando dos clusulas padre cualesquiera. Sin embargo, al igual que en el caso anterior, suele
dar buen resultado continuar el proceso de resolucin a partir de la nueva clusula resultante.
- De igual forma, aunque no existe ninguna limitacin en cuanto al nmero de veces que se puede usar
una clusula para resolver, se recomienda probar primero a no usar dos veces la misma clusula antes
de usar todas las clusulas disponibles.
- Si es posible llegar a la clusula vaca resolviendo nicamente con las clusulas del conjunto inicial sin
usar en ningn momento la o las clusulas provenientes de la hiptesis, es porque existe una
inconsistencia dentro del conjunto inicial de clusulas. sta puede ser una forma de detectar errores en
el diseo de la base de conocimiento.

Ejemplo:

Partir de la base de conocimiento siguiente, compuesta por 5 clusulas, aplicar resolucin para demostrar
que la hiptesis V(z) es cierta:
P(x) v Q(c, x) v S(y, x) y P(a) v R(z) v S(b, a) y Q(z, a) v V(a) y R(x) v V(y) y
P(y) v Q(x, y)
Ya tenemos las proposiciones en forma de clusulas, luego slo nos falta agregar la hiptesis, transformarla
en clusula y aadirla al conjunto de sentencias anterior:
V(z) negada nos queda V(z). (Como vemos est en forma de clusula).
Dado que las sustituciones afectan a todas las ocurrencias de la variable que se pretende sustituir en toda la
base de conocimientos, si queremos que dicha sustitucin afecte a muchas ocurrencias de una variable
podemos intentar renombrarlas. Pero para evitar tener todas las variables renombradas y, por tanto, evitar
la complicacin del procedimiento, estableceremos un uso especial de las sustituciones. Slo afectarn a las
clusulas padres en el momento de la resolucin, y a la clusula resolvente, quedando el resto inalteradas.
Comenzamos el proceso por las clusulas de mayor tamao:
P(x) v Q(c, x) v S(y, x) y P(a) v R(z) v S(b, a) con la sustitucin o = {y/b, x/a} nos queda:
P(x) v Q(c, x) v S(y, x) v P(a) v R(z) v S(b, a) = P(a) v Q(c, a) v R(z).
Combinamos la resolvente con P(y) v Q(x, y) con la sustitucin o = {y/a} nos queda:
P(a) v Q(c, a) v R(z) v P(y) v Q(x, y) = Q(c, a) v R(z) v Q(x, a).
Aplicamos a la resolvente la sustitucin o = {x/c} y nos queda:

Q(c, a) v R(z).
Combinamos la resolvente con Q(z, a) v V(a) con la sustitucin o = {z/c} nos queda:
Q(c, a) v R(z) v Q(z, a) v V(a) = R(c) v V(a).
Combinamos la resolvente con R(x) v V(y) con la sustitucin o = {x/c} nos queda:
R(c) v V(a) v R(x) v V(y) = V(a) v V(y).
Aplicamos la sustitucin o = {y/a} y nos queda V(a) que podemos combinar con V(z) obteniendo la clusula
vaca {}.

- Si en la clusula resolvente existen dos literales iguales, sta se puede simplificar eliminando uno de los
dos literales. Puede ser necesaria una sustitucin previa a fin de que esos literales sean unificables y,
por tanto, completamente iguales.
- No es necesario usar todas las clusulas en el proceso de resolucin. En la mayora de los casos basta
con usar algunas de las clusulas de la base de conocimiento y alguna o algunas de las clusulas
provenientes de la hiptesis.

Tutorial ..

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Tutorial ..

Diunggah oleh

Hak Cipta:

Format Tersedia

Editado y corregido por Elicer Pineda Ballesteros Pgina 1

Programacin Lgica Lenguaje Prolog y Visual Prolog

Anda mungkin juga menyukai