A.2.6.

Operaciones aritmticas
La programacin lgica no tiene como objeto abordar problemas de
clculo numrico, pero a veces son necesarias ciertas operaciones
elementales, como contar el nmero de elementos de una lista,
multiplicar por una constante, etc.
En principio, las operaciones aritmticas pueden expresarse mediante
relaciones. As, se puede definir la relacin suma , que tiene tres
argumentos numricos, y que ser verdadera si el tercero es la suma de
los dos primeros, de manera que suma(2,3,5) es verdadero y
suma(2,3,4) es falso. Su definicin extensional sera:
suma(0,0,0).
suma(0,1,1).
suma(0,2,2).
...

Es fcil comprender que esta manera de proceder carece de utilidad

prctica, como en el caso de las relaciones de orden entre nmeros.
Operadores

Para hacer viables las operaciones aritmticas, Prolog incorpora (o sea,

el procesador reconoce) operadores aritmticos que, para mejor
legibilidad, se escriben con notacin infija: + , - , * y / .
Un trmino en Prolog es, por ejemplo, 6+7 (equivalente a +(6,7)).
Pero, como decamos al hablar de las funciones, Prolog interpreta 6+7
simplemente como una estructura, diferente de 13 . Por tanto la
consulta ?- 13=6+7. obtiene como resultado NO , y ?- X=6+7.
da X=6+7 .
Para desencadenar la evaluacin aritmtica el lenguaje incorpora un
predicado especial infijo: is .
Evaluacin de expresiones aritmticas

El predicado is , escrito con una variable o una constante a su

izquierda y una expresin aritmtica a su derecha, es verdadero si el

resultado de evaluar la expresin es igual a la constante, o es verdadero

para el valor de la variable igual a ese resultado. Por ejemplo:
?- 13 is 6+7.
YES
?- 13 is 6*7.
NO
?- X is 6*7.
X=42

En la expresin aritmtica pueden figurar variables siempre que estas

variables tengan un valor determinado al evaluar la expresin. Por
ejemplo, con la regla:
media(X,Y,M) :- M is (X+Y)/2.

podemos hacer consultas como:

?- media(10,16,X).
X=13

pero la mquina Prolog (el procesador ejecutndose en un ordenador)

dar un error si preguntamos:
?- media(X,16,13).

Un ejemplo tpico del uso de is es la definicin recursiva del

factorial de un nmero natural:
fact(0,1).
fact(N,F) :- N>0,
Nmenos1 is N-1,
fact(Nmenos1,F1),
F is N*F1.

?- fact(5,X).
X=120
?- fact(-1,X).
NO
?- fact(X,120).
(mensaje de error)
Un par de clusulas muy tiles son las que permiten obtener la
longitud (nmero de elementos) de una lista:
longitud([],0).
longitud([C|L],Long):-longitud(L,L1),Long is L1+1.
?- longitud([a,b,c,d],X).
X=4
Aadiendo esta definicin de longitud, por ejemplo, a las escritas ms
arriba para la generacin de listas que representan algunas frases en
espaol, podemos preguntar por frases con un determinado nmero de
palabras:
?- sentencia(X),longitud(X,4).
X=[Espana,es,un,estado]
X=[un,estado,es,Espana]
?- sentencia(X),longitud(X,L),L<3
NO

APLICACIONES

FAMILIA ADAMS
ARACNIDO
CALCULADORA
ARBOL GENEALOGICO
PRENDAS
MEDICO
VENTANAS

FAMILIA ADAMS
domains
persona= symbol
predicates
repeat
action(integer,string)
test(string)
menu
/*papa
abuel
tios
son*/
padres
padre(persona,persona)
madre(persona,persona)
hombre(persona)
mujer(persona)
casados(persona,persona)
hermano(persona,persona)
/*hermana(persona,persona)*/
hijo(persona,persona)

hija(persona,persona)
tio(persona,persona)
abuela(persona,persona)
hijos(persona,persona)
clauses
menu:makewindow(1,7,7,"BIENVENIDO A LA FAMILIA ADAMS\n",0,2,11,43),
repeat,
shiftwindow(1),clearwindow,
write("\t1. Padres Adams\n"),
write("\t2. Hijos Adams\n"),
write("\t3. Abuela Adams\n"),
write("\t4. Tios Adams\n"),
write("\t0. Salir \n"),
write(" seleccione una opcion\n"),readint(Int),nl,
action(Int,Text),Int = 0,!, test(Text).

action(0,"Exit"):-!,/* previene de un loop*/

exit.

action(1,"papas"):-!,nl,
makewindow(2,7,7,"PADRES ADAMS",12,3,12,40),
clearwindow,
padres,
readchar(_).
action(2,"hijo"):-!,nl,
makewindow(3,7,7,"HIJOS ADAMS ",12,3,12,40),
clearwindow,
hijos(pericles,homero).
action(3,"abuelas"):-!,nl,
makewindow(4,7,7,"ABUELAS ADAMS ",12,3,12,40),
clearwindow,
abuela(" ",la_abuela).
action(4,"tios"):-!,nl,
makewindow(5,7,7,"TIOS ADAMS ",12,3,12,40),
clearwindow,
tio(merlina,tio_cosa).
action(_,"Error"):- write("Opcion no valida\n"),
write("precione una tecla para continuar\n").

test(Text):-write(Text).
repeat.
repeat:-repeat.

/* padre(P,H) <- P tiene como hijo a H */

padre(homero,pericles).
padre(homero,merlina).
padre("_",homero).
padre("_",tio_cosa).
padre("_",tio_lucas).
padre("",morticia).
/* madre(M,H) <- M tiene como hijo a H */
madre(morticia,merlina).
madre(morticia,pericles).
madre(la_abuela,tio_lucas).
madre(la_abuela,tio_cosa).
madre(la_abuela,homero).
madre("",morticia).
/*hijo(H,P) <- H es el hijo del padre/madre */
hijo(pericles,homero).
hijo(pericles,morticia).
hijo(homero,la_abuela).
hijo(tio_cosa,la_abuela).
hijo(tio_lucas,la_abuela).
/*hija(H,P) <- H es la hija del padre/madre */
hija(merlina,homero).
hija(merlina,morticia).
/* hombre(P) <- la persona P es del gnero masculino*/
hombre(homero).
hombre(pericles).
hombre(tio_lucas).
hombre(tio_cosa).

hombre("_").
/* mujer(M) <- la persona M es del gnero femenino*/
mujer(morticia).
mujer(la_abuela).
mujer(merlina).

/* casados(H,M) <- el hombre H esta casado con la mujer M */

casados(homero,morticia).
casados("_",la_abuela).
/* hermano(H1,H2) <- H1 es hermano de H2*/
hermano(H1,H2) :- hombre(H1),padre(P,H1),padre(P,H2),
madre(M,H1),madre(M,H2),
H1<>H2.

/* hermana(H2,H1) <- H2 es la hermana de H1 */

/*hermana(H1,H2) :- mujer(H1),padre(P,H1),padre(P,H2),
madre(M,H1),madre(M,H2),
H1<>H2,
!.*/
/* tio(T,S) <- T es el tio de S */
tio(T,S) :- hombre(T),
padre(P,S),
hermano(T,P),
T<>S.
/* abuela(A,N) <- A es la abuela de N */
abuela(A,N) :- padre(P,N),madre(M,N),
padre(_,P),madre(A,P),
padre(_,M),madre(_,M).
padres:-padre(P,Y),madre(M,Y),
write(P, " es el papa y la mama", M," de ",Y).
hijos(H,P):-hijo(H,P),hija(H,M),
write(H, " es el hijo(a) de ",M).
goal

menu.
/*papa.
abuel,
tios,
son.*/

ARACNIDO
domains
predicates
clase(string,string).
ser(string,string).
cuantas_patas_tiene(string).
clauses
clase(insecto,siete_patas).
clase(aracnido,ocho_patas).
ser(insecto,hormiga).
ser(insecto,mosca).
ser(insecto,alacran).
ser(insecto,avispa).
ser(aracnido,tarantula).
ser(aracnido,viuda_negra).

/* reglas */

cuantas_patas_tiene(X):-

clase(C,D),
ser(A,B),
X=B,
A=C,
write(X ," Tiene ", D),nl.

CALCULADORA
domains
i = integer
predicates
opc( integer, integer )
suma( i, i, char, i )
valida( i, char )
clauses
opc( _, 0 ):- clearwindow,
write("Numero:"),
readint(A),
opc( A, 1 ).
opc( N, 1 ):- nl,
write("Operacion + - * / (S): "),
readchar(Y),
valida( N, Y),
nl,
write("Numero:"),
readint(A),
suma( N, A, Y, Z ),
nl,
write("Resultado=", Z),
opc( Z, 1 ).
suma( A, B, '+', R ):suma( A, B, '-', R ):suma( A, B, '*', R ):suma( A, B, '/', R ):-

R = A + B.
R = A - B.
R = A * B.
R = A / B.

valida( _, '+' ).
valida( _, '-' ).
valida( _, '*' ).
valida( _, '/' ).
valida( N, X ) :- X <> 'S' ,
nl, write("Error"),
opc( N, 1 ).

goal
opc( 0, 0 ).

ARBOL GENEALOGICO
predicates
hombres(string).
mujeres(string).
papa(string,string).
mama(string,string).
tias(string,string).
tios(string,string).
abuelas(string,string).
abuelos(string,string).
hermanas(string,string).
hermanos(string,string).
sobrino(string,string).
sobrina(string,string).
hija(string,string).
clauses
hombres(alberto).
hombres(ignacio).
hombres(john).
hombres(humberto).
hombres(nilson).
hombres(jose).
hombres(fernando).
hombres(jaime).
hombres(heli).
hombres(emiliano).
hombres(pablo).
mujeres(ruth).
mujeres(teresa).
mujeres(martha).
mujeres(elena).
mujeres(bertha).
mujeres(mery).
mujeres(luisa).
mujeres(laura).
mujeres(leonor).
mujeres(edilma).
mujeres(iveth).
abuelas(leonor,edilma).
abuelas(teresa,edilma).

abuelos(emiliano,edilma).
abuelos(ignacio,edilma).
papa(pablo,edilma).
mama(elena,edilma).
tias(bertha,edilma).
tias(luisa,edilma).
tios(jaime,edilma).
tios(heli,edilma).
hermanos(nilson,edilma).
hermanos(alberto,edilma).
hermanos(fernando,edilma).
hermanos(jose,edilma).
hermanas(ruth,edilma).
hermanas(mery,edilma).
hermanas(martha,edilma).
sobrino(john,edilma).
sobrina(iveth,edilma).
hija(laura,edilma).

PRENDAS
predicates
nombres(string).
colores(string).
prendas(string,string).
gusto(string,string).
traje(string,string).
clauses
nombres(martin).
nombres(diana).
nombres(soledad).
nombres(lucas).
nombres(cecilia).
colores(negro).
colores(azul).
colores(verde).
colores(violeta).
colores(blanco).
prendas(pantalon,azul).
prendas(camisa,verde).
prendas(pantalon,negro).
prendas(bufanda,violeta).
prendas(saco,azul).
gusto(martin,negro).
gusto(diana,verde).

gusto(lucas,azul).
gusto(cecilia,blanco).
gusto(soledad,violeta).
traje(martin,pantalon).
traje(diana,pantalon).
traje(lucas,camisa).
traje(cecilia,bufanda).
traje(soledad,saco).

MEDICO
domains
texto=string*
predicates
cambiar(string,texto)
hablar(texto,texto)
clauses
cambiar(cabeza,[aspirina]).
cambiar(fiebre,[acetaminofen]).
cambiar(me,[tome]).
cambiar(duele,[apliquese]).
cambiar(pies,[quiteselos]).
cambiar(no,[si]).
cambiar(X,[X]).
hablar([],[]).
hablar([H|T],[X|Y]):-cambiar(H,[X|_]),
hablar(T,Y),!.

VENTANAS
predicates
repeat
action(integer,string)
test(string)
goal
clearwindow,
makewindow(1,7,7,"interactuando window", 0,2,11,43),
repeat,shiftwindow(1),clearwindow,
write("0. entre 0 para salir\n"),
write("1. para crear una nueva ventana\n"),
write("2. para remover ventana\n"),

write("3. para escribir en una ventana existente\n"),

write("seleccione una opcion"),readint(Int),nl,
action(Int,text),Int=0,!,test(text).
clauses
action(0,"exit"):-!, exit,
action(1,str):-existwindow(2),
write("la ventana ya existe\n",
write("desea limpiarla?\n"),
readchar(ans),!,
ans=`Y`, n\,
shifwindow(2), crearwindow,
write("entre su texto\n"),
readln(str).
action(1,str):-!,nl,
makewindow(2,7,7,"ventana de control(",12,13,12,40),
write("entre su texto\n")readln(str).
action(2,"borra ventana"):-existwindow(2),
shiftwiondow(2),removewindow,
clearwindow.
action(2,"error"):-clearwindow,
write("primero debe crear la ventana\n",),
write("presiona una tecla para salir\n"),
readchar(_).
action(3,str):-existwiondow(2),!,
shiftwiondow(2),clearwndow,
write("entre su texto\n"),
readln(str).
action(3,str):-write("la ventana no existe\n"),
write("desea crearla(S/N)\n"),
readchar(ans), ans=`S`
makewindow(2,7,7")
ventana de control("12,3,12,40),
write("entre su texto\n"),
readln(str).
action(-,"error"):
write("caracter no valido\n"),
write("presiona una tecla para continuar\n"),
readchar(.).
test(text):-write(text).
repeat.
repeat:-repeat.

utorial bsico de programacin en Prolog

o
o
o
o
o

Mi primer programa en Prolog

Cargando el cdigo
Predicados reversibles
Predicados no reversibles
Modos de uso
Culturilla

Mi primer programa en Prolog

Los programas se escriben en ficheros de texto, generalmente con extension .pl y pueden contener
comentarios y cdigo. Para ello puede utilizar cualquier editor de texto. Le recomendamos que intente escribir
el siguiente programa desde el principio para familiarizarse con la sintxis.

%
%
%
%
%
%
%
%

Este es mi primer programa en Prolog

Se trata de un arbol genealogico muy simple
Primero defino los parentescos basicos
de la familia.
padre(A,B) significa que B es el padre de A...

padre(juan,alberto).
padre(luis,alberto).
padre(alberto,leoncio).
padre(geronimo,leoncio).
padre(luisa,geronimo).
% Ahora defino las condiciones para que
% dos individuos sean hermanos
% hermano(A,B) significa que A es hermano de B...
hermano(A,B) :padre(A,P),
padre(B,P),
A \== B.
% Ahora defino el parentesco abuelo-nieto.
% nieto(A,B) significa que A es nieto de B...
nieto(A,B) :padre(A,P),
padre(P,B).

Cargando el cdigo
Para compilar y cargar el cdigo existe el predicado consult/1. Recuerde que puede ser necesario indicar la
ruta completa del fichero fuente. En este ejemplo hemos usado el top-level shell de SWI-Prolog:

Welcome to SWI-Prolog (Version 2.7.14)

Copyright (c) 1993-1996 University of Amsterdam.
reserved.
For help, use ?- help(Topic). or ?- apropos(Word).

All rights

1 ?- consult('arbolgenealogico.pl').
arbolgenealogico.pl compiled, 0.00 sec, 1,108 bytes.
Yes
2 ?-

Predicados reversibles
Una vez que hemos compilado y cargado nuestro programa vamos a estudiar sus caractersticas. Una de ellas
es el backtracking, o la posibilidad de obtener varias soluciones, como ya hemos visto.

2 ?- hermano(A,B).
A = juan
B = luis ;
A = luis
B = juan ;
A = alberto
B = geronimo ;
A = geronimo
B = alberto ;
No
3 ?-

Ahora vamos a reparar en otra curiosa propiedad que no existe en otros lenguajes: lareversibilidad. Esto es
la habilidad de los argumentos de los predicados para actuar indistintamente como argumentos de entrada y/o
salida.Por ejemplo:

3 ?- nieto(luis,X).
X = leoncio
No
4 ?-

Aqu, el primer argumento es de entrada mientras que el segundo es de salida. El predicado nos dice de quin
es nieto Luis. Pero ahora vamos a intercambiar los papeles:

4 ?- nieto(X,leoncio).
X = juan ;
X = luis ;
X = luisa ;
No
5 ?-

Obsrve cmo el mismo predicado que nos dice el abuelo de un nieto sirve para conocer los nietos de un
abuelo. Estos predicados se dicen reversibles, o que sus argumentos son reversibles.

Predicados no reversibles
No todos los predicados son reversibles. Por ejemplo, los de comparacin aritmtica. El predicado >/2 sirve
para saber si un nmero es mayor que otro, pero no sirve para saber todos los nmeros mayores que uno
dado (puesto que son infinitos).

Otros predicados pueden perder la reversibilidad por deseo expreso de su programador, o solamente ser
reversibles para ciertos argumentos pero no otros. As podemos hablar de las posibles formas de invocar un
predicado. Esto es lo que se denomina modos de uso.

Modos de uso
Los modos de uso indican que combinacion de argumentos deben o no estar instanciados para que un
objetivo tenga sentido. Se dice que un argumento est instanciado cuando no es una variable libre.
A efectos de documentacin, los modos de uso se describen con un trmino anotado en sus argumentos con
un smbolo. Los argumentos pueden ser:
De entrada y/o salida indistintamente. Estos argumentos se denotan con un smbolo de interrogacin (?).
De solamente entrada. Estos se denotan con un smbolo de suma (+).
De solamente salida. Estos se denotan con un smbolo de resta (-).
El modo de uso que instancia todos los argumentos siempre es vlido.
Por ejemplo, para el predicado hermano/2 su nico modo de uso es hermano(?A,?B). Supongamos un
predicado cuyos modos de uso son:
p(+A,+B,-C).
p(+A,-B,+C).
Entonces son objetivos vlidos:
p(1,2,X).
p(1,X,3).
p(1,2,3).
Pero no son vlidos:
p(X,Y,3).
p(X,2,3).
p(X,Y,Z).
Los modos de uso se suelen indicar a modo documentativo, pero actualmente los entornos de desarrollo ms
avanzados los pueden utilizar para detectar errores en tiempo de compilacin.

Culturilla

Un compilador que no utiliza los modos de uso no detecta objetivos invlidos. En ese caso, el programa
se ejecuta sin ms. Cuando le llega el turno al objetivo mal formado pueden ocurrir dos cosas: que el
objetivo falle sin ms, o que se lance una excepcin. Cualquiera de ellas suele ir acompaada de un
horrendo mensaje por pantalla.
La forma de describir los modos de uso "formalmente" varia de un entorno de desarrollo a otro. Si no es
posible especificarlos "formalmente", entonces conviene escribir un comentario explicativo.
Si el compilador no detecta modos de uso, es responsabilidad del programador no invocar objetivos mal
formados, tarea que no resulta nada trivial puesto que hay que saber que variables van a estar ligadas
cuando el programa se ejecute.
Otra buena prctica es escribir predicados que siempre sean reversibles.

Temas generales de prolog

Enviado por etuckler

1. Introduccin

3. Variables
4. Reglas
5. El mbito de las variables
6. Operadores
7. La resolucin de objetivos
8. El mecanismo de control de PROLOG
9. Entrada / Salida
10. Historia y desarrollo de Prolog
11. Tipos de datos en Prolog
12. Estructura de un programa PROLOG
13. Funciones y Pasos de Parmetros.
14. Estructuras de Datos en Prolog
15. Desarrollo de Versiones Actuales
1. Introduccin
Prolog es un lenguaje de programacin hecho para representar y utilizar el conocimiento que se tiene sobre
un determinado dominio. Ms exactamente, el dominio es un conjunto de objetos y el conocimiento se
representa por un conjunto de relaciones que describen las propiedades de los objetos y sus interrelaciones.
Un conjunto de reglas que describa estas propiedades y estas relaciones es un programa Prolog.
Prolog es un lenguaje de programacin que es usado para resolver problemas que envuelven objetos y las
relaciones entre ellos.
2. Hechos
Expresan relaciones entre objetos. Supongamos que queremos expresar el hecho de que "un coche tiene
ruedas". Este hecho, consta de dos objetos, "coche" y "ruedas", y de una relacin llamada "tiene". La forma de
representarlo en PROLOG es:
tiene(coche,ruedas).
* Los nombres de objetos y relaciones deben comenzar con una letra
minscula.
* Primero se escribe la relacin, y luego los objetos separados por
comas y encerrados entre parntesis.
Al final de un hecho debe ir un punto (el carcter ".").
El orden de los objetos dentro de la relacin es arbitrario, pero debemos
ser coherentes a lo largo de la base de hechos.
3. Variables
Representan objetos que el mismo PROLOG determina. Una variable puede estar instanciada o no
instanciada. Esta instanciada cuando existe un objeto determinado representado por la variable. De este
modo, cuando preguntamos "Un coche tiene X ?",
PROLOG busca en los hechos cosas que tiene un coche y respondera:
X = ruedas.
instanciando la variable X con el objeto ruedas.
* Los nombres de variables comienzan siempre por una letra mayscula.
Un caso particular es la variable annima, representada por el carcter subrayado ("_"). Es una especie de
comodn que utilizaremos en aquellos lugares que debera aparecer una variable, pero no nos interesa darle
un nombre concreto ya que no vamos a utilizarla posteriormente.
4. Reglas
Las reglas se utilizan en PROLOG para significar que un hecho depende de uno o ms hechos. Son la
representacin de las implicaciones lgicas del tipo p ---> q (p implica q).

* Una regla consiste en una cabeza y un cuerpo, unidos por el signo ":-".
* La cabeza esta formada por un nico hecho.
* El cuerpo puede ser uno o ms hechos (conjuncin de hechos), separados
por una coma (","), que acta como el "y" lgico.
* Las reglas finalizan con un punto (".").
La cabeza en una regla PROLOG corresponde al consecuente de una implicacin lgica, y el cuerpo al
antecedente. Este hecho puede conducir a errores de representacin. Supongamos el siguiente razonamiento
lgico:
tiempo(lluvioso) ----> suelo(mojado)
suelo(mojado)
Que el suelo esta mojado, es una condicin suficiente de que el tiempo
sea lluvioso, pero no necesaria. Por lo tanto, a partir de ese hecho, no
podemos deducir mediante la implicacin, que esta lloviendo (pueden haber
regado las calles). La representacin *correcta* en PROLOG, sera:
suelo(mojado) :- tiempo(lluvioso).
suelo(mojado).
Cabe sealar que la regla esta "al revs". Esto es as por el mecanismo
de deduccin hacia atrs que emplea PROLOG. Si cometiramos el *error* de
representarla como:
tiempo(lluvioso) :- suelo(mojado).
suelo(mojado).
PROLOG, partiendo del hecho de que el suelo esta mojado, deducira
incorrectamente que el tiempo es lluvioso.
Para generalizar una relacin entre objetos mediante una regla,
utilizaremos variables. Por ejemplo:
Representacin lgica | Representacin PROLOG
Es un coche(X) ----> | tiene(X,ruedas) :
tiene(X,ruedas) | es un coche(X).
Con esta regla generalizamos el hecho de que cualquier objeto que sea un coche, tendr ruedas. Al igual que
antes, el hecho de que un objeto tenga ruedas, no es una condicin suficiente de que sea un coche. Por lo
tanto la representacin inversa sera incorrecta.
5. El mbito de las variables.
Cuando en una regla aparece una variable, el mbito de esa variable es
nicamente esa regla. Supongamos las siguientes reglas:
(1) hermana_de(X,Y) :- hembra(X), padres(X,M,P), padres(Y,M,P).
(2) puede_robar(X,P) :- ladron(X), le_gusta_a(X,P), valioso(P).
Aunque en ambas aparece la variable X (y la variable P), no tiene nada que ver la X de la regla (1) con la de la
regla (2), y por lo tanto, la instanciacin de la X en (1) no implica la instanciacin en (2). Sin embargo todas las
X de *una misma regla* si que se instanciaran con el mismo valor.
6. Operadores
Son predicados predefinidos en PROLOG para las operaciones matemticas bsicas. Su sintaxis depende de
la posicin que ocupen, pudiendo ser infijos o prefijos. Por ejemplo el operador suma ("+"), podemos
encontrarlo en forma prefija '+(2,5)' o bien infija, '2 + 5'.
Tambin dispone de predicados de igualdad y desigualdad.
X = Y igual
X \= Y distinto
X < Y menor
X > Y mayor
X =< Y menor o igual
X >= Y mayor o igual
Al igual que en otros lenguajes de programacin es necesario tener en cuenta la precedencia y la
asociatividad de los operadores antes de trabajar con ellos.

En cuanto a precedencia, es la tpica. Por ejemplo, 3+2*6 se evala como 3+(2*6). En lo referente a la
asociatividad, PROLOG es asociativo por la izquierda. As, 8/4/4 se interpreta como (8/4)/4. De igual forma,
5+8/2/2 significa 5+((8/2)/2).
El operador 'is'.
Es un operador infijo, que en su parte derecha lleva un termino que se interpreta como una expresin
aritmtica, contrastndose con el termino de su izquierda.
Por ejemplo, la expresin '6 is 4+3.' es falsa. Por otra parte, si la expresin es 'X is 4+3.', el resultado ser la
instanciacin de X:
X=7
Una regla PROLOG puede ser esta:
densidad(X,Y) :- poblacin(X,P), rea(X,A), Y is P/A.
Algunos comandos bsicos
* consult.
El predicado _consult_ esta pensado para leer y compilar un programa PROLOG o bien para las situaciones
en las que se precise aadir las clusulas existentes en un determinado fichero a las que ya estn
almacenadas y compiladas en la base de datos. Su sintaxis puede ser una de las siguientes:
consult(fichero).
consult('fichero.ext').
consult('c:\ia\prolog\fichero').
* recon.
El predicado recon es muy parecido a consult, con la salvedad de que las clusulas existentes en el fichero
consultado, reemplazan a las existentes en la base de hechos. Puede ser til para sustituir una nica clusula
sin consultar todas las dems, situando esa clusula en un fichero. Su sintaxis es la misma que la de consult.
*forget.
Tiene como fin eliminar de la base de datos actual aquellos
hechos consultados de un fichero determinado. Su sintaxis es:
forget(fichero).
* exitsys.
Este predicado nos devuelve al sistema operativo.
7. La resolucin de objetivos
Ya hemos creado un programa PROLOG [relacion.pro] y lo hemos compilado
en nuestro interprete PROLOG [consult(relacion)]. A partir de este
momento podemos interrogar la base de datos, mediante consultas.
Una consulta tiene la misma forma que un hecho.
Consideremos la pregunta:
?-quiere_a(susana,pablo).
PROLOG buscara por toda la base de datos hechos que coincidan con el anterior. Dos hechos coinciden si
sus predicados son iguales, y cada uno de sus correspondientes argumentos lo son entre si. Si PROLOG
encuentra un hecho que coincida con la pregunta, responder yes. En caso contrario responder no.
Adems, una pregunta puede contener variables. En este caso PROLOG buscara por toda la base de hechos
aquellos objetos que pueden ser representado por la variable. Por ejemplo:
?-quiere_a(maria, Alguien).
El resultado de la consulta es:
Alguien = enrique
More (Y/N):
El hecho 'quiere_a(maria,enrique).' coincide con la pregunta al instanciar la variable Alguien con el objeto
'enrique'. Por lo tanto es una respuesta valida, pero no la nica. Por eso se nos pregunta si queremos obtener
m s respuestas. En caso afirmativo, obtendramos:
Alguien = susana
More (Y/N):y
Alguien = ana
More (Y/N):y
No.
?-

Las consultas a una base de datos se complican cuando estas estn compuestas por conjunciones o bien
intervienen reglas en su resolucin. Conviene, por lo tanto, conocer cual es el mecanismo de control del
PROLOG, con el fin de comprender el porque de sus respuestas.
8. El mecanismo de control de PROLOG
El mecanismo empleado por PROLOG para satisfacer las cuestiones que se le plantean, es el de
_razonamiento hacia atrs (backward) complementado con la bsqueda en profundidad (depth first) y la vuelta
atrs o reevaluacin (backtracking).
Razonamiento hacia atrs: Partiendo de un objetivo a probar, busca las aserciones que pueden probar el
objetivo. Si en un punto caben varios caminos, se recorren en el orden que aparecen en el programa, esto es,
de arriba a abajo y de izquierda a derecha.
Reevaluacin: Si en un momento dado una variable se instancia con determinado valor con el fin de alcanzar
una solucin, y se llega a un camino no satisfactorio, el mecanismo de control retrocede al punto en el cual se
instanci la variable, la des-instancia y si es posible,
busca otra instanciacin que supondr un nuevo camino de bsqueda.
Se puede ilustrar esta estrategia sobre el ejemplo anterior:
Supongamos la pregunta:
?-puede_casarse_con(maria,X).
PROLOG recorre la base de datos en busca de un hecho que coincida con la cuestin planteada. Lo que halla
es la regla:
puede_casarse_con(X,Y) :- quiere_a(X,Y), varon(X), hembra(Y).
Producindose una coincidencia con la cabeza de la misma, y una instanciacion de la variable X de la regla
con el objeto 'maria'.
Tendremos por lo tanto:
(1) puede_casarse_con(maria,Y) :- quiere_a(maria,Y), varon(maria), hembra(Y).
A continuacin, se busca una instanciacin de la variable Y que haga cierta la regla, es decir, que verifique los
hechos del cuerpo de la misma. La nueva meta ser :
(2) quiere_a(maria,Y).
De nuevo PROLOG recorre la base de datos. En este caso encuentra un hecho que coincide con el objetivo:
quiere_a(maria,enrique).
instanciando la variable Y con el objeto 'enrique'. Siguiendo el orden dado por la regla (1), quedan por probar
dos hechos una vez instanciada la variable Y:
varon(maria), hembra(enrique).
Se recorre de nuevo la base de datos, no hallando en este caso ninguna coincidencia con el hecho
varn(maria)'. Por lo tanto, PROLOG recurre a la vuelta atrs, desistanciando valor de la variable Y, y
retrocediendo con el fin de encontrar una nueva instanciacin de la misma que verifique el hecho (2). Un
nuevo recorrido de la base de hechos da como resultado la coincidencia con:
quiere_a(maria,susana).
Se repite el proceso anterior. La variable Y se instancia con el objeto 'susana' y se intentan probar los hechos
restantes:
varn(maria), hembra(susana).
De nuevo se produce un fallo que provoca la desinstanciacin de la variable Y, as como una vuelta atrs en
busca de nuevos hechos que coincidan con (2).
Una nueva reevaluacin da como resultado la instanciacin de Y con
el objeto 'ana' (la ultima posible), y un nuevo fallo en el hecho
varn(maria)'.
Una vez comprobadas sin xito todas las posibles instanciaciones del hecho (2), PROLOG da por imposible la
regla (1), se produce de nuevo la vuelta atrs y una nueva bsqueda en la base de datos que tiene como
resultado la coincidencia con la regla:
(3) puede_casarse_con(maria,Y) :- quiere_a(maria,Y), hembra(maria), varon(Y).
Se repite todo el proceso anterior, buscando nuevas instanciaciones de la variable Y que verifiquen el cuerpo
de la regla. La primera coincidencia corresponde al hecho
quiere_a(maria,enrique).
que provoca la instanciacin de la variable Y con el objeto 'enrique'. PROLOG tratar de probar ahora el resto
del cuerpo de la regla con las instanciaciones actuales:

hembra(maria), varon(enrique).
Un recorrido de la base de datos, da un resultado positivo en ambos hechos, quedando probado en su
totalidad el cuerpo de la regla (3) y por lo tanto su cabeza, que no es mas que una de las soluciones al
objetivo inicial.
X = enrique
PROLOG utiliza un mecanismo de bsqueda independiente de la base de datos. Aunque pueda parecer algo
ilgico, es una buena estrategia puesto que garantiza el proceso de todas las posibilidades. Es til para el
programador conocer dicho mecanismo a la hora de depurar y optimizar los programas.
9. Entrada/Salida
PROLOG, al igual que la mayora de lenguajes de programacin modernos incorpora predicados predefinidos
para la entrada y salida de datos. Estos son tratados como reglas que siempre se satisfacen.
* write.
Su sintaxis es:
write('Hello world').
Las comillas simples encierran constantes, mientras que todo lo que se encuentra entre comillas dobles es
tratado como una lista. Tambin podemos mostrar el valor de una variable, siempre que este instanciada:
write(X).
* nl.
El predicado nl fuerza un retorno de carro en la salida. Por ejemplo:
write('linea 1'), nl, write('linea 2').
tiene como resultado:
linea 1
linea 2
* read.
Lee un valor del teclado. La lectura del comando read no finaliza hasta que se introduce un punto ".". Su
sintaxis es:
read(X).
Instancia la variable X con el valor leido del teclado.
read(ejemplo).
Se evala como cierta siempre que lo tecleado coincida con la constante entre parntesis (en este caso
'ejemplo').
10. Historia y desarrollo de Prolog
Una de las preocupaciones ms tempranas de la computacin de los aos cincuenta fue la posibilidad de
hacer programas que llevaran a cabo demostraciones automticas de teoremas. As empezaron los primeros
trabajos de inteligencia artificial que ms de veinte aos despus dieron lugar al primer lenguaje de
programacin que contempla, como parte del intrprete, los mecanismos de inferencia necesarios para la
demostracin automtica. Este primer lenguaje est basado en el formalismo matemtico de la Lgica de
Primer Orden y ha dado inicio a un nuevo y activo campo de investigacin entre las matemticas y la
computacin que se ha denominado la Programacin Lgica.
Estos mecanismos de prueba fueron trabajados con mucho entusiasmo durante una poca, pero, por su
ineficiencia, fueron relegados hasta el nacimiento de PROLOG, ocurrido en 1970 en la Universidad de
Marsella, Francia, en el seno de un grupo de investigacin en el campo de la Inteligencia Artificial.
La Programacin Lgica tiene sus orgenes ms cercanos en los trabajos de prueba automtica de teoremas
de los aos sesenta. J. A. Robinson propone en 1965 una regla de inferencia a la que llama resolucin,
mediante la cual la demostracin de un teorema puede ser llevada a cabo de manera automtica.
La resolucin es una regla que se aplica sobre cierto tipo de frmulas del Clculo de Predicados de Primer
Orden, llamadas clusulas y la demostracin de teoremas bajo esta regla de inferencia se lleva a cabo por
reduccin al absurdo.
Actualmente, la programacin lgica ha despertado un creciente inters que va mucho ms all del campo de
la Inteligencia Artificial(IA) y sus aplicaciones. Los japoneses, con su proyecto de mquinas de la quinta
generacin, dieron un gran impulso a este paradigma de programacin. Sin embargo, antes que ellos existan
ya en Estados Unidos y en Europa grupos de investigacin en este campo, en pases como Inglaterra,
Holanda, Suecia y, desde luego, Francia.

A principios de los aos ochentas los japoneses comienzan a invertir recursos en un proyecto que denominan
la Quinta Generacin, para lucrar con la buena fama de los 4GL. Con este ambicioso proyecto Japn busca
obtener el liderazgo en computacin, usando como base la Programacin Lgica y la Inteligencia Artificial.
La programacin lgica tiene sus races en el clculo de predicados, que es una teora matemtica que
permite, entre otras cosas, lograr que un computador pueda realizar inferencias, capacidad que es requisito
para que un computador sea una "mquina inteligente". La realizacin del paradigma de la programacin
lgica es el lenguaje Prolog.
El Prolog estuvo un tiempo diseado para ejecutarse en minicomputadoras o estaciones de trabajo,
actualmente hay versiones en Prolog que pueden instalarse en computadores personales como IBM-PC y PCCompatibles.
Un programa escrito en PROLOG puro, es un conjunto de clausulas.
Sin embargo, PROLOG, como lenguaje de programacin moderno, incorpora
mas cosas, como instrucciones de Entrada/Salida, etc.
Una clausula puede ser una conjuncin de hechos positivos o una implicacin con un nico consecuente (un
nico termino a la derecha). La negacin no tiene representacin en PROLOG, y se asocia con la falta de una
afirmacin (negacin por fallo), segn el modelo de suposicin de un mundo cerrado solo es cierto lo que
aparece en la base de conocimiento o bien se deriva de esta.
Las diferencias sintcticas entre las representaciones lgicas y las representaciones PROLOG son las
siguientes:
1. En PROLOG todas las variables estn implcitamente cuantificadas
universalmente.
2. En PROLOG existe un smbolo explicito para la conjuncin "y" (,), pero no existe uno para la disyuncin "o",
que se expresa como una lista de sentencias alternativas.
3. En PROLOG, las implicaciones p --> q se escriben al reves q :- p, ya que el interprete siempre trabaja hacia
atrs sobre un objetivo.
11. Tipos de datos en Prolog
Symbol
Hay dos tipos de smbolos:
1. Un grupo de caracteres consecutivos (letras, nmeros y signos de subrayado) que comienzan con un
carcter en minscula
2. Ejemplo: Alto,Alto_edificio,El_alto_edificio_en_la_ciudad
3. Un grupo de caracteres consecutivos(letras y nmeros) que comienzan y terminan con dobles comillas(").
Este tipo es til cuando se quiere comenzar el smbolo con un carcter en mayscula o si se quieres
agregar espacios entre los caracteres del smbolo.
Ejemplo:"alto","alto edificio"
String
Cualquier grupo de caracteres consecutivos (letras y nmeros) que comience y termine con dobles comillas(").
Es igual a smbolo pero Prolog los trata de forma distinta.
Ejemplo:"alto","alto edificio"
Integer
Cualquier numero comprendido entre (-32.768 y 32.768). El limite esta determinado porque los enteros se
almacenan como valores de 16 bits, este limite puede variar segn la versin de Prolog.
Ejemplo:4,-300,3004
Real
Cualquier numero real en el rango +/- 1E-307 a +/-1E+308. El formato incluye estas opciones: signo, numero,
punto decimal, fraccin, E(exponente), signo para el exponente, exponente.
Ejemplo:3,3.1415
Char
Cualquier carcter de la lista ASCII estndar, posicionado entre dos comillas sencillas().
Ejemplos:t,X,f
12. Estructura de un programa PROLOG
Un programa Prolog est formado por una secuencia de enunciados: hechos, reglas y comentarios.

Una relacin puede estar especificada por hechos, simplemente estableciendo objetos que satisfacen la
relacin o por reglas establecidas acerca de la relacin.
Cada regla est formada por un primer miembro (o la cabeza de la regla), un segundo miembro (o cola de la
regla) ligados por " :- " y termina con el carcter " . ".
cdigo del programa
** Hechos **
mujer(maria).
hombre(pedro).
hombre(manuel).
hombre(arturo).
** Relaciones **
padre(pedro,manuel).
padre(pedro,arturo).
padre(pedro,maria).
** Reglas **
nino(X,Y):- padre(Y,X)
hijo(X,Y):-nino(X,Y),hombre(X).
hija(X,Y):-nino(X,Y),mujer(X).
hermano_o_hermana(X,Y):-padre(Z,X),padre(Z,Y).
hermano(X,Y):-hermano_o_hermana(X,Y),hombre(X).
hermana(X,Y):-hermano_o_hermana(X,Y),mujer(X).
13. Funciones y Pasos de Parmetros.
La recursividad es un mecanismo que da bastante potencia a cualquier lenguaje de programacin. A
continuacin un ejemplo de programacin recursiva que nos permitir determinar si un tomo es miembro de
una lista dada:
(1) miembro(X,[X|_]).
(2) miembro(X,[_|Y]) :- miembro(X,Y).
La regla (1) es el caso base de la recursion. Se evaluar como cierta
siempre que coincida la variable X con la cabeza de la lista que se pasa
como argumento. En la regla (2) est la definicin recursiva. X es miembro de una lista si lo es de la cola de
esa lista (la cabeza se comprueba en la regla (1)).
La regla (1) es una simplificacin de la regla:
miembro(X,[Y|_]) :- X = Y.
La traza para el caso de 'miembro(b,[a,b,c]).' es la siguiente:
(1) miembro(b,[a,b,c]) :- b = a. ---> no.
(2) miembro(b,[a,b,c]) :- miembro(b,[b,c]).
(1) miembro(b,[b,c]) :- b = b. ---> yes.
Si necesitamos conocer la longitud de una lista, emplearemos una funcin
recursiva como la siguiente:
longitud([],0).
longitud([_|Y],L1) :- longitud(Y,L2), L1 is L2 + 1.
Otro ejemplo muy tpico de funcin recursiva es el del factorial de un
numero:
factorial(0,1) :- !.
factorial(X,Y) :- X1 is X-1, factorial(X1,Y1), Y is X*Y1.
La definicin de una funcin esta en los hechos que adoptemos para inferir sobre la base de conocimiento de
Prolog, el paso de parmetros debe definirse en las reglas a travs de los predicados que los invoquen, ya
sea por el mismo o por otro predicado.
Para que los predicados definidos como funcin, no retornen un valor errado, el tipo de dato de la variable del
predicado llamador debe ser igual al del predicado llamado. Esto es debido a que los predicados aritmticos
propios de Prolog no identifican entre un numero real o entero.
14. Estructuras de Datos en Prolog
La lista es una estructura de datos muy comn en la programacin no numrica. Es una secuencia ordenada
de elementos que puede tener cualquier longitud. Ordenada significa que el orden de cada elemento es

significativo. Un elemento puede ser cualquier termino e incluso otra lista. Se representa como una serie de
elementos separados por comas y encerrados entre corchetes.
El valor de las listas en un programa Prolog disminuye si no es posible identificar los elementos individuales
que habrn de integrarlas. Debido a ello, es necesario tener en cuenta el concepto de su divisin en dos
partes: cabeza y cola. La cabeza de la lista es el primer elemento de la misma. La cola es el resto de la lista,
sin importar lo que pueda contener.
Para hacer uso practico de la capacidad de dividir listas en cabeza y cola, el Prolog proporciona una notacin
especial con la que se definen las listas en los programas. Existen dos smbolos especiales que se utilizan:
1. El corchete abierto/cerrado. Se usa para denotar el inicio y el final de una lista
2. El separador. Su smbolo es | y se usa para permitir que una lista se represente como una cabeza y una
cola.
Para procesar una lista, la dividimos en dos partes: la cabeza y
la cola. Por ejemplo:
Lista Cabeza Cola
----- ------ ---[a,b,c,d] a [b,c,d]
[a] a [] (lista vacia)
[] no tiene no tiene
[[a,b],c] [a,b] [c]
[a,[b,c]] a [[b,c]]
[a,b,[c,d]] a [b,[c,d]]
Para dividir una lista, utilizamos el smbolo "|". Una expresin con la forma [X | Y] instanciar X a la cabeza de
una lista e Y a la cola. Por ejemplo:
p([1,2,3]).
p([el,gato,estaba,[en,la,alfombra]]).
?-p([X|Y]).
X = 1,
Y = [2,3]
X = el,
Y = [gato,estaba,[en,la,alfombra]]
Lista de listas, se pueden hacer estructuras tan complejas como se quiera en Prolog. Se pueden poner listas
dentro de listas.
Ejemplo:
animales([[mono,bufalo,rata], [serpiente,iguana,cocodrilo], [paloma,pingino]])
15. Desarrollo de Versiones Actuales
Antes de que existieran sistemas expertos, sistemas inteligentes adaptables o cualquier otro tipo de programa
capaz de funcionar con inteligencia artificial, se necesito crear los lenguajes para desarrollarlo. Para ello, se
consideraron algunos requerimientos bsicos como la posibilidad de procesar smbolos de todo tipo y la
capacidad de hacer inferencias asociadas con el lenguaje, todo dentro de un ambiente flexible que permitiera
escribir el programa de forma interactiva.
Uno de los lenguajes que ms xito ha tenido es Prolog. Por tal razn son muchas las compaas
de software que han creado sus propias versiones del mismo.
La diferencia es mnima entre versiones ya que su sintaxis y semntica es la misma, la variacin que ms
resalta son el cambio de plataforma para el cual fueron desarrollados.
Nuestro trabajo de investigacin no pretende abarcarlos todos, pero si hablar de los mas usados y conocidos
por el mbito informtico.
PROLOG1- Esta versin la ofrece Expert Systems International, se utiliza en maquinas que trabajan con los
sistemas operativos MS-DOS, CP/M-86, RSX-11M y RT-11.
Su mayor fortaleza radica en su interprete PROLOG86, este interprete contiene un editor de clusulas del
sistema. Tiene un mejor manejo de los tipos de datos entero y real, y adems posee mas predicados
integrados por lo cual el programador ya no requiere de definirlos.
PROLOG QUINTUS- Es una versin avanzada del lenguaje. El objetivo de sus diseadores era producir una
versin que pudiera ofrecer velocidades rpidas de ejecucin, as como la capacidad de comunicacin con

otros programas. Esta versin funciona en los sistemas operativo UNIX y VMS. Una de las caractersticas
interesantes es la interface al editor EMACS, esto provocara que la pantalla se parta en dos ventanas, en una
estar el cdigo del archivo fuente en la parte superior, mientras prolog correr en la parte inferior, esto brinda
una ayuda ya que cualquier cambio en las clusulas del archivo, podra ser probada inmediatamente,
solamente interactuando entre ventanas.
MACPROLOG- Esta versin esta diseada totalmente para correr en maquinas MAC. Esta versin combina
sofisticadas tcnicas de programacin de inteligencia artificial en ambientes Macintosh. Al integrar el
compilador Prolog con las herramientas de MAC (ratn, men, ventanas y grficos), Prolog ofrece un entorno
de programacin sofisticado que antes solo se poda obtener con hardware costoso y muy especializado.
SWI-PROLOG- Es una implementacin de Prolog basada en un subconjunto del WAM(Warren Abstract
Machine). SWI-Prolog ha sido diseado e implementado de tal modo que puede ser empleado fcilmente para
experimentar con la lgica de la programacin y con las relaciones que esta mantiene con
otros paradigmas de la programacin, tales como el entorno PCE orientado al objeto. Posee un rico conjunto
de predicados incorporados que hacen posible el desarrollo de aplicaciones robustas. Adems ofrece una
interfaz para el lenguaje C.

Leer ms: http://www.monografias.com/trabajos5/prolog/prolog.shtml#ixzz3JlxMuzqw