Instituto:
Instituto Tecnológico Superior de Misantla
Alumno:
Alejandro Limón Téllez
CARRERA:
Ingeniería en Sistemas Computacionales.
GRUPO:
603.
Tema:
Investigación de PROLOG
MATERIA:
Programación Lógica y Funcional
Fecha:
04 de Mayo del 2020
INDICE
Operadores aritméticos y relacionales. ................................................................... 1
Predicados y funciones predefinidas. ...................................................................... 2
Adición de Bases de Conocimiento externas:...................................................... 2
Construcción de objetivos compuestos (conectivas lógicas): .............................. 2
Clasificación de términos: .................................................................................... 2
Control del programa: .......................................................................................... 3
Funciones aritméticas: ......................................................................................... 3
Manejo de listas: .................................................................................................. 4
Predicados de Entrada y Salida: .......................................................................... 4
Manejo de ficheros: ............................................................................................. 5
Manipulación de la Base de Conocimiento: ......................................................... 5
Construcción y acceso a componentes de estructuras: ....................................... 6
Depuración de programas Prolog: ....................................................................... 6
Reglas recursivas .................................................................................................... 7
Referencias ............................................................................................................. 8
i
Operadores aritméticos y relacionales.
Todas las versiones de Prolog soportan los siguientes operadores aritméticos,
listados en el orden de prioridad de ejecución.
1. X=Y Se cumple si puede hacer X e Y iguales (unificarlos)
2. X\=Y Se cumple si X=Y fracasa
3. X==Y Igualdad más estricta
4. X\==Y Se cumple si fracasa ==
5. X < Y Predicado menor que
6. X > Y Predicado mayor que
7. X >= Y Predicado mayor o igual que
8. X =< Y Predicado menor o igual que
9. X @< Y Ordenación de términos. Predicado menor que
10. X @> Y Ordenación de términos. Predicado mayor que
11. X @>= Y Ordenación de términos. Predicado mayor o igual que
12. X @=< Y Ordenación de términos. Predicado menor o igual que
13. 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
14. 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
15. X & Y Operador concatenación de cadenas de caracteres
16. X + Y Operador suma
17. X - Y Operador resta
18. X * Y Operador de multiplicación
19. X / Y Operador de división
20. X // Y Operador de división entera
21. X mod Y Operador de resto de la división entera
22. X ** Y Operador de exponenciación
23. X ^ Y Operador de exponenciación
24. op(X,Y,Z) Declara el operador de nombre Z con clase de precedencia X y
1
posición-asociatividad Y
25. current_op(X,Y,Z) Busca el operador ya declarado de nombre Z con clase
de precedencia X y posición-asociatividad Y
Los paréntesis se pueden utilizar para dar preferencia de ejecución en una
expresión compuesta. Prolog utiliza la precedencia de operadores con la regla de la
mano izquierda.
Predicados y funciones predefinidas.
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
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
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
2
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
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 mecanismode
reevaluación
X -> Y Si X entonces Y. En combinación con ; actúa como Si-
EntoncesSino.
call(X) Se cumple si tiene éxito el intento de satisfacer X (instanciada aun
término)
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
sqrt(X) Raíz cuadrada de la expresión X
3
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)
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 de Entrada y Salida:
4
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
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
Manipulación de la Base de Conocimiento:
listing Se escriben en el fichero de salida activo todas las cláusulas
5
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
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
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
6
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
Reglas recursivas
En general, en una definición recursiva, es necesario considerar 2 casos:
Caso básico: Define cuándo se detiene el cálculo.
Caso recursivo: Suponiendo que ya se ha solucionado un caso más simple, define
cómo descomponer el caso actual hasta llegar al caso básico.
Por ejemplo:
predecesor(X,Y):-progenitor(X,Y). %caso base
predecesor(X,Y):-progenitor(X,Z), predecesor(Z,Y). %caso recursivo
Las definiciones recursivas se resuelven de la misma forma que las reglas
comunes. En la traza de este tipo de definiciones tiene especial importancia el
renombramiento de variables.
7
Referencias
Prolog. (2016, mayo 3). Recuperado 4 de 2020, de
[Link]
M6mjaHftsWtI8CoYA7z9UvbfhLj4aIvCvqDEewGO414lncJE
Zavaleta, J. M. (2015, marzo 26). Predicados y funciones en prolog.
Recuperado 5 de julio de 2016, de
[Link]
Martinez, J. P. (2010, mayo 23). Introduccion a Prolog. Recuperado 13 de
junio de 2018, de [Link]
