PROLOG

Ing. Magno Edwin Calizaya Ajhuacho

Introducción
• Prolog es un lenguaje de programación hecho para representar y
utilizar el conocimiento que se tiene sobre un determinado dominio
de objetos y el conocimiento se representa por un conjunto de
relaciones que describen las propiedades de los objetos y sus
interrelaciones. Es un lenguaje de programación que es usado para
resolver problemas que envuelven objetos y las relaciones entre ellos
Hechos
• Es un mecanismo para representar Objetos, personas o conceptos,
como también sus propiedades y relaciones de dichos hechos.

• Ejemplo
• varon(mario).
• mujer(maria).
Relaciones
• Para escribir una relación primeramente se escribe la relación y luego los
objetos separados por comas y encerrados entre paréntesis, sirven para
expresan relaciones entre objetos. Supongamos que queremos expresar el
hecho de que "el auto tiene ruedas". Este hecho, consta de dos objetos,
"auto" y "ruedas", y de una relación llamada "tiene" y representado en
prolog seria:
• tiene(auto,ruedas).
• Estos objetos y relaciones deben comenzar con una letra minúscula.
• Primero se escribe la relación, y luego los objetos separados por comas y
encerrados entre paréntesis.
• Al final de un hecho debe ir un punto (el carácter ".").
Reglas
• En prolgo las reglas se utilizan para significar que un hecho depende de uno ó mas hechos. Son la
representación de las implicaciones lógicas del tipo p ---> q (p implica q).

 Una regla esta formado por una cabeza y un cuerpo, unidos por el signo ":-".
 La cabeza está formada por un único hecho.
 El cuerpo puede ser uno ó mas hechos (conjunción de hechos), separados por una coma (","), que actúa
como el "y" lógico.
 Las reglas finalizan con un punto (".").
• Supongamos que tenemos el siguientes hecho que dice que henry es padre de susan:
• es_padre_de(juan,mario).
• Ejemplo: aquí estaríamos formando una regla para verificar si una persona es padre.
• es_padre(X):- es_padre_de(X,Y).
Variables
• Son preguntas generales que se pueden hacer, los nombres de variables comienzan siempre por una letra
mayúscula.
• La variable anónima, se representa por el carácter subrayado ("_"). Es una especie de comodín que
utilizaremos en aquellos lugares que debería aparecer una variable, pero no nos interesa darle un nombre
concreto ya que no vamos a utilizarla posteriormente
Operadores
• Son predicados predefinidos en PROLOG para las operaciones matemáticas básicas. Su sintaxis depende de
la posición que ocupen, pudiendo ser infijos ó prefijos. Por ejemplo el operador suma ("+"), podemos
encontrarlo en forma prefija '+(2,5)' ó bien infija, '2 + 5'. También disponemos de predicados de igualdad y
desigualdad.
• X=Y igual
• X \= Y distinto
• X<Y menor
• X>Y mayor
• X =< Y menor ó igual
• X >= Y mayor ó igual
• Al igual que en otros lenguajes de programación es necesario tener en cuenta la precedencia y la
asociatividad de los operadores antes de trabajar con ellos.
• En cuanto a precedencia, es la típica. Por ejemplo, 3+2*6 se evalúa 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 término que se
interpreta como una expresión aritmética, contrastándose con el
término de su izquierda.
• Por ejemplo, la expresión '6 is 4+3.' es falsa. Por otra parte, si la
expresión es 'X is 4+3.', el resultado será la instanciación de X:
• X=7
• Una regla PROLOG puede ser esta:
• densidad(X,Y) :- poblacion(X,P), area(X,A), Y is P/A.
Conectivas Lógicas
Conector Nombre
, Conjunción
; Disyunción
Not(X) o también \+X Negación
Cabeza_de_la_regla: Cuerpo_de_la_reglla
Implicación o Condicional
 Comentarios
/* esto el comentario
de mas de una línea*/

•% comentario de una sola línea

Caracteres

• Los nombres de constantes y variables se construyen a partir de cadenas y caracteres.

• Letras mayúsculas A, B, C, ….. Z
• Letras minúsculas a,b,c, …….. z
• Números 1,2,3,….. 0
• Signos !"#$%&'()=-^|/\{}[]_@+*;:<>,.?
Operadores y su precedencia
habitual entre ellos son:
 Listas
• La lista es una estructura de datos muy común en la programación no numérica. 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 término e incluso otra lista. Se representa como una serie de elementos separados por comas y
encerrados entre corchetes. 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 vacía)
• [] 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 símbolo "|". Una expresión 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]
• More (Y/N):y
• X = el,
• Y = [gato,estaba,[en,la,alfombra]]
Recursividad
• Recursividad en el paradigma lógico no sólo puede ser aplicado a listas, como en
los paradigmas procedurales o funcionales. La relación recursiva entre elementos de un mismo
tipo no tiene por qué estar contenida en una lista.

• Un ejemplo de relación recursiva es la relación antepasado.

• Defino antepasado de una persona X a:

 Y tal que Y es progenitor de X;

 Y tal que Z es progenitor de X e Y es antepasado de Z.

•
Es decir, un antepasado mío o es mi padre o bien es una persona que es antepasado de mi
padre (su padre, o el padre de su padre, etc...).
…Recursividad
• progenitor(daniel, papa).
• progenitor(papa, abuelo).
• progenitor(abuelo, bisa).

• antepasado(X,Y):- progenitor(X, Y).

• antepasado(X,Y):- progenitor(X,Z), antepasado(Z,Y).

• Entonces, para este caso, la relación progenitor es el CORTE DE LA RECURSIVIDAD.

• Otro ejemplo:
• Yo tengo un amigo que... si los amigos de mis amigos son mis amigos entonces...
• es_amigo(pamela,naomi).
• es_amigo(X,Y)es_amigo(Y,X).
• son_amigos(X,Y):-es_amigo(X,Y).
• son_amigos(X,Y):-es_amigo(X,Alguienmas),es_amigo(Alguienmas,Y).
…Recursividad
• es_amigo(naomi,pamela).
• es_amigo(pamela,susan).
• es_amigo(susan,yanine).
• son_amigos(X,Y):-es_amigo(X,Y).
• son_amigos(X,Y):-es_amigo(Y,X).
• son_amigos(X,Y):-
es_amigo(X,Alguienmas),son_amigos(Alguienmas,Y).
…Recursividad - Ejemplos
• padre(juan,delfin).
• padre(delfin,edwin).
• padre(edwin,cristian).
• antecesor(X,Y):-padre(X,Y).
• antecesor(X,Y):-padre(X,Z),antecesor(Z,Y).
…Recursividad - Ejemplos
• padre(juan,delfin).
• padre(delfin,edwin).
• padre(edwin,cristian).
• antecesor(X,Y):-padre(X,Y). %padre
• antecesor(X,Y):-padre(X,Z),padre(Z,Y). %abuelo
• antecesor(X,Y):-padre(X,Z1),padre(Z1,Z2),padre(Z2,Y).
Entrada Salida
• PROLOG, al igual que la mayoría de lenguajes de programación 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.
• También podemos mostrar el valor de una variable, siempre que esté
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 leído del teclado.
• read(ejemplo).
• Se evalúa como cierta siempre que lo tecleado coincida con la
constante entre paréntesis (en este caso 'ejemplo').
PREDICADOS PREDEFINIDOS
• Vamos a ver algunos predicados predefinidos que ofrecen la mayoría de los sistemas Prolog.
• 1.- Adición de Bases de Conocimiento externas:
• consult(X) Añadir las cláusulas del fichero X a la base de conocimiento
• reconsult(Y) Las cláusulas leídas de fichero Y sustituyen a las existentes para el
• mismo predicado
• [X,-Y,Z] Notación más cómoda para consult y reconsult
• halt Salir del sistema Prolog
• 2.- Construcción de objetivos compuestos (conectivas lógicas):
• X,Y Conjunción de objetivos
• X;Y Disyunción de objetivos
• \+ X Se cumple si fracasa el intento de satisfacer X
• not(X) Se cumple si fracasa el intento de satisfacer X
…PREDICADOS PREDEFINIDOS -
Clasificación de términos:
• var(X) Se cumple si X es en ese momento una variable no instanciada
• nonvar(X) Se cumple si X no es una variable sin instanciar en ese momento
• atomic(X) Se cumple si X representa en ese momento un número o un átomo
• atom(X) Se cumple si X representa en ese momento un átomo de Prolog
• numeric(X) Se cumple si X representa en ese momento un número
• integer(X) Se cumple si X representa en ese momento un número entero
• real(X) Se cumple si X representa en ese momento un número real
…PREDICADOS PREDEFINIDOS 4.-
Control del programa:
• true Objetivo que siempre se cumple
• fail Objetivo que siempre fracasa
• ! Corte. Fuerza al sistema Prolog a mantener ciertas elecciones
• repeat Sirve para generar soluciones múltiples mediante el mecanismo
• de reevaluación
• X -> Y Si X entonces Y. En combinación con ; actúa como Si-Entonces-
• Sino.
• call(X) Se cumple si tiene éxito el intento de satisfacer X (instanciada a
• un término)
…PREDICADOS PREDEFINIDOS 5.-
Operadores aritméticos y relacionales:
• X=Y Se cumple si puede hacer X e Y iguales (unificarlos)
• X\=Y Se cumple si X=Y fracasa
• X==Y Igualdad más estricta
• X\==Y Se cumple si fracasa ==
• X < Y Predicado menor que
• X > Y Predicado mayor que
• X >= Y Predicado mayor o igual que
• X =< Y Predicado menor o igual que
• X @< Y Ordenación de términos. Predicado menor que
• X @> Y Ordenación de términos. Predicado mayor que
• X @>= Y Ordenación de términos. Predicado mayor o igual que
• X @=< Y Ordenación de términos. Predicado menor o igual que
…PREDICADOS PREDEFINIDOS 5.-
Operadores aritméticos y relacionales:
• X is Y Se evalúa la expresión a la que esta instanciada Y para dar como
• resultado un número, que se intentará hacer coincidir con X
• X is_string Y Se evalúa la expresión a la que está instanciada Y para dar como
• resultado una cadena, que se intentará hacer coincidir con X
• X & Y Operador concatenación de cadenas de caracteres
• X + Y Operador suma
• X - Y Operador resta
• X * Y Operador de multiplicación
• X / Y Operador de división
• X // Y Operador de división entera
• X mod Y Operador de resto de la división entera
• X ** Y Operador de exponenciación
• X ^ Y Operador de exponenciación
• op(X,Y,Z) Declara el operador de nombre Z con clase de precedencia X y
• posición-asociatividad Y
• current_op(X,Y,Z) Busca el operador ya declarado de nombre Z con clase de
…PREDICADOS PREDEFINIDOS 6.-
Funciones aritméticas:
• abs(X) Devulve el valor absoluto de la expresión X
• sign(X) Devuelve -1 si X < 0, 1 si X > 0 y 0 si X = 0
• min(X,Y) Devuelve el menor de Xe Y
• max(X,Y) Devuelve el mayor de Xe Y
• random(X) Devuelve un entero aleatorio i ( 0 =< i < X ); la es determinada
• por el reloj del sistema cuando se arranca SWI-Prolog
• round(X) Evalua la expresión X y la redondea al entero más cercano
• integer(X) Evalua la expresión X y la redondea al entero más cercano
• float(X) Evalua la expresión X en un número en coma flotante
• truncate(X) Trunca la expresión X en un número entero
• floor(X) Devuleve el mayor número entero menor o igual que el resultado
• de la expresión X
• ceiling(X) Devuleve el menor número entero mayor o igual que el resultado
• de la expresión X
…PREDICADOS PREDEFINIDOS 6.-
Funciones aritméticas:
• sqrt(X) Raíz cuadrada de la expresión X
• sin(X) Seno de la expresión X (angulo en radianes)
• cos(X) Coseno de la expresión X (angulo en radianes)
• tan(X) Tangente de la expresión X (angulo en radianes)
• asin(X) Arcoseno (angulo en radianes) de la expresión X
• acos(X) Arcocoseno (angulo en radianes) de la expresión X
• atan(X) Arcotangente (angulo en radianes) de la expresión X
• log(X) Logaritmo neperiano de la expresión X
• log10(X) Logaritmo en base 10 de la expresión X
• exp(X) e elevado al resultado de la expresión X
• pi Constante matemática pi (3.141593)
• e Constante matemática e (2.718282)
…PREDICADOS PREDEFINIDOS 7.-
Manejo de listas:
• [X|Y] X es la cabeza de Y la cola de la lista
• is_list(X) Se cumple si X es una lista o la lista vacía []
• append(X,Y,Z) Z es la concatenación de las listas X e Y
• member(X,Y) X es uno de los elementos de la lista Y
• delete(X,Y,Z) Borra el elemento Y de la lista X y da como resultado la lista Z
• select(X,Y,Z) Selecciona el elemento X de la lista Y y da como resultado la lista Z
• nth0(X,Y,Z) El elemento X-ésimo de la lista Y es Z (empezando en 0)
• nth1(X,Y,Z) El elemento X-ésimo de la lista Y es Z (empezando en 1)
• last(X,Y) X es el último elemento de la lista Y
• reverse(X,Y) Y es la lista invertida de X
• length(X,Y) Y es la longitud de la lista X
• merge(X,Y,Z) Siendo X e Y listas ordenadas, Z es la lista ordenada con los
• elementos de ámbas
• sort(X,Y) Y es la lista ordenada de X (sin elementos duplicados)
• msort(X,Y) Y es la lista ordenada de X
…PREDICADOS PREDEFINIDOS 8.-
Predicados de Entrada y Salida
• get0(X) Se cumple si X puede hacerse corresponder con el siguiente
• carácter encontrado en el canal de entrada activo (en código ASCII)
• get(X) Se cumple si X puede hacerse corresponder con el siguiente
• carácter imprimible encontrado en el canal de entrada activo
• skip(X) Lee y pasa por alto todos los caracteres del canal de entrada activo hasta que encuentra un carácter que coincida
con X
• read(X) Lee el siguiente término del canal de entrada activo
• put(X) Escribe el entero X como un carácter en el canal de salida activo
• nl Genera una nueva línea en el canal de salida activo
• tab(X) Escribe X espacios en el canal de salida activo
• write(X) Escribe el término X en el canal de salida activo
• write_ln(X) Escribe el término X en el canal de salida activo y salta la línea
• writef(X,Y) Escribe en el canal de salida activo, siendo X el formato e Y la lista con los argumentos a escribir
• display(X) Escribe el término X en el canal de salida activo, pasando por alto las declaraciones de operadores
 …PREDICADOS PREDEFINIDOS 9.-
Manejo de ficheros:
• see(X) Abre el fichero X y lo define como canal de entrada activo
• seeing(X) Se cumple si el nombre del canal de entrada activo coincide con X
• seen Cierra el canal de entrada activo, y retorna al teclado
• tell(X) Abre el fichero X y lo define como canal de salida activo
• telling(X) Se cumple si X coincide con el nombre del canal de salida activo
• told Cierra con un fin de fichero el canal de salida activo, que pasa a ser la
pantalla
10.- Manipulación de la Base de
Conocimiento:
• listing Se escriben en el fichero de salida activo todas las cláusulas
• listing(X) Siendo X un átomo, se escriben en el fichero de salida activo todas las cláusulas que tienen
como predicado dicho átomo
• clause(X,Y) Se hace coincidir X con la cabeza e Y con el cuerpo de una cláusula existente en la base
de conocimiento
• assert(X) Permite añadir la nueva cláusula X a la base de conocimiento
• asserta(X) Permite añadir la nueva cláusula X al principio de la base de conocimiento
• assertz(X) Permite añadir la nueva cláusula X al final de la base de conocimiento
• retract(X) Permite eliminar la primera cláusula de la base de conocimiento que empareje con X
• retractall(X) Permite eliminar todas las cláusulas de la base de conocimiento que emparejen con X
• abolish(X) Retira de la Base de Conocimiento todas las cláusulas del predicado X
• abolish(X,Y) Retira de la Base de Conocimiento todas las cláusulas del predicado de nombre X y
número de argumentos Y
11.- Construcción y acceso a componentes de
estructuras:
• functor(E,F,N) E es una estructura con nombre F y número de argumentos N
• arg(N,E,A) El argumento número N de la estructura E es A
• E=..L Predicado univ. L es la lista cuya cabeza es el functor de la
• estructura E y la cola sus argumentos
• name(A,L) Los caracteres del átomo A tienen por ASCII los números de la
• lista L
12.- Depuración de programas Prolog:
• trace Activación de un seguimiento exhaustivo, generando la traza de la ejecución de las metas siguientes
• trace(X) Activación de un seguimiento del predicado X
• notrace Desactiva el seguimiento exhaustivo
• notrace(X) Desactiva el seguimiento mientras dure la llamada al objetivo X
• spy(X) Fijación de puntos espía en el predicado X
• nospy(X) Elimina los puntos espía especificados
• nospyall Elimina todos los puntos espía
• debugging Ver el estado del depurador y los puntos espía se han establecido hasta el momento
• debug Inicia el depurador
• nodebug Desactiva el depurador
Ejercicio 1
• Sacar el residuo de un número
• residuo:-write('digite un numero'),read(A), write('digite otro numero'), read(B), R is A mod B, writeln(['El
residuoes:', R]).
• residuo(A,B):-R is A mod B, write(R).
• residuo(A,B,R):-R is A mod B.
Ejercicio # 2
• Calcular el residuo sin ocupar el mod
• residuo:-write('digite un numero'),read(A), write('digite otro numero'), read(B), R is A-B*(A//B), write(R).
Ejercicio # 3
• padresDe(clara,felix,chelo).
• padresDe(borja,felix,chelo).
• hermanos(X,Y):-X\=Y,padresDe(X,P,M), padresDe(Y,P,M).
Ejercicio # 4
• /* animal(Anim) <- Anim es un animal */
• animal(mono).
• animal(gallina).
• animal(araña).
• animal(mosca).
• animal(cocodrilo).
• /* gusta(X,Y) <- a X le gusta Y */
• gusta(mono,banana).
• gusta(araña,mosca).
• gusta(alumno,logica).
• gusta(araña,hormiga).
• gusta(cocodrilo,X) :- animal(X).
• gusta(mosca,espejo).
• /* regalo(X,Y) <- Y es un buen regalo para X */
• regalo(X,Y) :- animal(X), gusta(X,Y).
 Ejercicio #5 /* es_padre_de(Padre,Hijo-a) <- Padre es el padre de
Hijo-a */
/*-- PROLOG Y EL LENGUAJE DE LA LàGICA DE PRIMER es_padre_de(felix,borja).
ORDEN --*/ es_padre_de(felix,clara).
/* Predicados mon dicos: PROPIEDADES */ /* es_madre_de(Madre,Hijo-a) <- Madre es la madre de
/* mujer(Per) <- Per es una mujer */ Hijo-a */
mujer(clara). es_madre_de(chelo,borja).
mujer(chelo).
/* hombre(Per) <- Per es un hombre */
es_madre_de(chelo,clara).
hombre(jorge). /* regala(Per1,Obj,per2) <- Per1 regala Obj a Per2
hombre(felix). */
hombre(borja). regala(jorge,flores,clara).
/* moreno(Per) <- Per tiene el pelo de color negro */ /* Condicional: REGLAS */
moreno(jorge). /* novios(Per1,Per2) <- Per1 y Per2 son novios
/* Predicados poli dicos: RELACIONES */ */
/* tiene(Per,Obj) <- Per posee el objeto Obj */
tiene(jorge,moto).
novios(X,Y) :- le_gusta_a(X,Y),
/* le_gusta(X,Y) <- a X le gusta Y */ le_gusta_a(Y,X).
le_gusta_a(clara,jorge).
le_gusta_a(jorge,clara). /* hermana_de(Per1,Per2) <- Per1 es la hermana de
le_gusta_a(jorge,informatica). Per2 */
le_gusta_a(clara,informatica). hermana_de(X,Y) :- mujer(X),
es_padre_de(P,X), es_madre_de(M,X),
es_padre_de(P,Y), es_madre_de(M,Y).
…Ejercicio #5
• /* PREGUNTAS:
• ?- le_gusta_a(clara,jorge).
• ?- le_gusta_a(jorge,cafe).
• ?- capital_de(madrid,espana).
• ?- le_gusta_a(jorge,X).
• ?- le_gusta_a(clara,jorge),le_gusta_a(jorge,cafe).
• ?- le_gusta_a(clara,X),le_gusta_a(jorge,X).
• ?- le_gusta_a(clara,informatica);le_gusta_a(jorge,cafe).
• ?- le_gusta_a(clara,cafe);le_gusta_a(jorge,cafe).
• ?- le_gusta_a(clara,X);le_gusta_a(jorge,X).
• ?- not(le_gusta_a(clara,jorge)).
• ?- not(le_gusta_a(jorge,cafe)).
• ?- hermana_de(clara,borja).
• ?- hermana_de(borja,X).
• ?- hermana_de(clara,X).
Ejercicio # 6
• /*-- SINTAXIS: Operadores --*/
• /* poblacion(Prov,Pob) <- la poblacion, en miles de habitantes, de la provincia Prov es Pob */
• poblacion(alicante,1149).
• poblacion(castellon,432).
• poblacion(valencia,2066).
• /* superficie(Prov,Sup) <- la superfie, en miles de km2, de la provincia Prov es Sup */
• superficie(alicante,6).
• superficie(castellon,7).
• superficie(valencia,11).
• /* densidad(Prov,Den) <- la densidad de poblacion, habitantes/km2, de la provincia Prov es Den */
• densidad(X,Y) :- poblacion(X,P), superficie(X,S), Y is P/S.
• /* PREGUNTAS : ?- densidad(alicante,X). */
 Ejercicio # 7 /* ÁRBOL GENEALÓGICO
• Tarea 3 parentescos familiares

• padre(abel,cesar).
• padre(abel,dario).
• madre(flavia,cesar).
• madre(flavia,dario).
• parejacasada(abel,flavia).
• hombre(abel).
• mujer(maria).
• -------------------------------------------------
• ?termano(abel,dario).
• ?tio(abel,juan).
• ?primo(abel,juan)
• ?abuelo(abel,juan)
• ?descendiente(bbel,juan)
• ….
Sumatoria de n primeros numeros
• sumar(1,1).
• sumar(N,R):- A is N-1, sumar(A,R2),R is N + R2.
GRACIAS (78115911)