Or Term1 , Term2 (and): Es verdadero si Term1 es verdadero y

1. Construccion de Predicados o Consultas: And, Or, call

And - Or
Term1 , Term2 (and): Es verdadero si Term1 es verdadero y Term2 es verdadero
Term1 ; Term2 (or): Es verdadero si Term1 es verdadero o si Term2 es verdadero

call(+Term): es verdadero si y solo si Term representa un objetivo el cual es verdadero
Para call se asume que X se instanciará con un término que puede ser interpretado como
un objetivo a cumplir.
call(f(a,X)) = f(a,X)
2. Verificación de tipos de términos: atom, integer, atomic, var, nonvar, float, compound

atom(+Term)
Atomos: Son palabra que no requieren de una sintaxis especial. Sin embargo, los átomos
que contienen espacios o algunos otros caracteres especiales deben estar rodeados por
comillas simples (O los que empiezan con letra capital para distinguirlos de las variables).
La lista vacía también es un átomo. Ejemplos de átomos: x, blue, 'Taco', and 'some atom'.
Por lo tanto, un el predicado atom tendrá éxito si el argumento es un átomo o una variable
instanciada previamente con un átomo
Ejemplos:
?- atom(abc).
Yes
?- atom(‘Programación Exploratoria’).
Yes
?- Var=abc, atom(Var).
Var=abc
Yes
El predicado atom fallará si el argumento es una variabla sin instanciar, un número
o un objeto estructurado (incluyendo una lista)
Ejemplo:
?- atom(X).
No
?- atom(13).
No
?- atom([1,2,3|[X]]).
No
?- atom([]).
Yes

integer(+Term)
integer tendrá éxito si el argumento es un entero o una variable previamente instanciada
con un entero
Ejemplos:
?- integer(1).
Yes
?- Var=2, integer(Var).
Yes
Integer fallará si el argumento es una variable sin instanciar, un átomo, un número
flotante o un objeto estructurado
?- integer(Var).
No
?- integer(abc).
No
?- integer(1.3).
No
?- integer(a(x,y,z)).
No
?- integer([a,b,c]).
No
?- integer([]).
No

atomic(+Term)
atomic(X) :- integer(X).
atomic(X) :- atom(X).
atomic tendrá éxito si el argumento es un integer, un átomo o una variable previamente
instanciada con un átomo o un integer.
Ejemplos:
?- atomic(abc).
Yes
?- atomic(1).
Yes
?- Var=abc, atomic(Var).
Yes
?- Var=1, atomic(Var).
Yes
atomic fallará si el argumento es una variable sin instanciar o un objeto estructurado
(incluyendo la lista)
Ejemplos:
?- atomic(Var).
No
?- atomic(a(x,y,z)).
No
?- atomic([a,b,c]).
No
?- atomic([]).
Yes

var(+Term)
YES: Si X es actualmente una variable sin instanciar.
Una variable sin instanciar puede representar parte de una estructura que aún no ha sido
llenada. Cuando tales estructuras están siendo examinadas el predicado var puede ser
muy útil para determinar si alguna parte ya ha sido llenada.
Ejemplos:
?- var(X).
Yes
?-Var1=Var2, var(Var1).
Yes
Var fallará si el argumento es una variable instanciada, un átomo, un número o un objeto
estructurado (incluyendo la lista):
Ejemplos:
?- var(abc).
No
?- var(123).
No
?- var(a(X,Y,Z)).
No
?- var([X,Y,Z]).
No
?-X=Y, Y=23, var(X).
No

nonvar(+Term)
Tiene éxito si Term NO es una variable libre. Es el opuesto del predicado var(X).
Ejemplos:
?-nonvar(abc).
Yes
?-nonvar(1).
Yes
?-nonvar(a(x,y,z)).
Yes
?-nonvar([X,Y,Z]).
Yes
Si una variable es previamente instanciada también se tiene éxito:
?-Var=abc, nonvar(Var).
Yes
Nonvar fallará si el argumento es una variable sin instanciar
?-nonvar(Var).
No
Ejemplo de uso en suma:
plus(X,Y,Z) :- nonvar(X), nonvar(Y), Z is X+Y.
plus(X,Y,Z) :- nonvar(X), nonvar(Z), Y is Z-X.
plus(X,Y,Z) :- nonvar(Y), nonvar(Z), X is Z-Y.

float(+Term)
float tendrá éxito si el argumento es un flotante (con punto) o una variable previamente
instanciada con un flotante:
Ejemplos:
?-float(1.3).
Yes
Float fallará si el argumento es una variable sin instanciar, un átomo o un objeto
estructurado:
Ejemplos:
?-float(Var).
No
?-float(abc).
No
?-float(a(b,c)).
No
?-float([a,b,c]).
No

compound(+Term)
compound tendrá éxito si el argumento es una estructura o una lista
Ejemplos:
?- compound(a(X)).
Yes
?- compound([a, B]).
Yes
compound fallará si el argumento es una variable sin instanciar, un átomo o un número:
Ejemplos:
?- compound(Var).
no
?- compound(abc).
no
?- compound(1).
No
3. Análisis y Construcción de Términos: functor, arg, name

functor(?Term,?Name,?Arity)
Functor(T,F,N): T es una estructura con nombre o functor F y aridad (cantidad de
argumentos) N.
Este predicado permite extraer el functor y la aridad de un término cualquiera. Pero, al ser
reversible, también permite construir nuevos términos a partir del functor y la aridad
deseada. Los modos de uso son:
functor(+Termino,-Functor,-Aridad).
functor(-Termino,+Functor,+Aridad).
Primero, si T esta instanciada. El propósito falla si T no es un átomo o una estructura. Si T
es un átomo o una estructura, F se machea con el functor y N se machea con el entero
dado por la aridad del functor (un átomo es considerado como una estructura con aridad
0).
En el caso de las listas el functor es representado por ‘.’ y la aridad es siempre 2 (cabeza y
cola).
?- functor(termino(arg(1),arg(2)),Functor,Aridad).
Aridad = 2, Functor = termino
yes
La otra forma de usarlo es si T no está instanciado, en este caso los otros dos deben estar
instanciados. T se instanciará con la estructura creada a partir del functor dado y la
cantidad de argumentos dada por la aridad.
Sus argumentos siempre serán nuevas variables libres:
Ejemplos:
?- functor(NuevoTermino,prueba,4).
NuevoTermino = prueba(_,_,_,_)
Yes
?- functor(f(a,b,g(Z)),F,N)
Yes
Z=_23, F=f, N=3
?- functor(a+b,F,N).
Yes
F=+, N=2
?- functor([a,b,c,d],F,N).
Yes
F=‘.’, N=2
?- functor(javaprolog,F,A).
Yes
F=javaprolog N=0.

arg(+Arg,+Term,?Value)
Ahora que podemos construir términos, sería deseable poder asignarles
argumentos. Uno de los predicados que permiten esto es arg. Para ello se indica el
número de índice del argumento deseado, empezando a numerar por el 1 de izquierda a
derecha. El modo de uso es:
arg(+Indice,+Termino,-Argumento).
El predicado arg debe ser utilizado con sus dos primeros argumentos instanciados. El
primero especifica el argumento (numero) requerido de la estructura. El segundo
especifica la estructura en la que se debe encontrar el argumento buscado.
El primer uso de este predicado es extraer un argumento concreto de un término:
Ejemplos:
?- arg(2,termino(a,b,c,d),ARG).
ARG = b
yes
Si el término tiene variables libres como argumento, se les puede asignar valor mediante
arg. Pero el resultado es el mismo que una simple unificación mediante =. Esto se
observa en el siguiente ejemplo:
?- Termino = p(X,b), arg(1,Termino,zzz).
Termino = p(zzz,b), X = zzz
yes
?- Termino = p(X,b), Termino = p(zzz,_).
Termino = p(zzz,b), X = zzz
yes
El predicado arg solamente es útil cuando se conoce a priori el número de argumentos
del término manipulado, pero en combinación con functor resulta muy eficaz.
?- arg(2,app(a,b,c),V).
Yes
V=b
?- arg(2,[a,b,c],V).
Yes
V=[b,c]
?- arg(2, a+(b+c), V).
Yes
V=‘+’(b,c)
?- functor (X, prueba, 1), arg(1, X, a).
Yes
X=prueba(a)

name(+Term,?List)
Relaciona un átomo con su lista de caracteres (código ACII).
?- name(apple, X).
Yes
X=[97,112,112,108,101]
?- name(apple, [97, 112, 112, 108, 101]).
Yes
4. Igualdad: =, ==, \=,\==
== es mucho más restrictivo que “=“. Si X==Y, entonces X=Y (No al revés). “=” considerará
una variable no instanciada como igual a cualquier cosa, porque puede ser matcheada con
cualquier cosa. Por otra parte “==” solo considera una variable no instanciada como igual a
otra no instanciada. “\==” es el opuesto de “==“
Ejemplos:
?- X == 2
No
?- X = 2
Yes
?- X == Y.
Yes
?- X == X.
X=_23, Yes.
?- X=Y , X==Y.
X=_23, Y=_23
Yes




?Term1 = ?Term2. COMPARA Y ASIGNA
?Term1 \= ?Term2. COMPARA Y ASIGNA
?Term1 == ?Term2 (más restrictivo que “=“) SOLO PARA COMPARAR
?Term1 \== ?Term2 (más restrictivo que “\=“) SOLO PARA COMPARAR
Ejemplos:
?- X==Y.
Yes
?- X==2.
No
?- X=Y.
Yes
?- X=2.
Yes
?- X\=Y.
No
?- X\=2.
No
?- X\==Y.
Yes
?- X\==2.
Yes
5. Comparación de números






+Integer1 = +Integer2
+Integer1 \= +Integer2
+Integer1 < +Integer2
+Integer1 =< +Integer2
+Integer1 > +Integer2
+Integer1 >= +Integer2
6. Aritmética Entera
En el IS, si o si lo de la derecha tiene que estar instanciado y es la UNICA forma de hacer
operaciones matemáticas. No sirve el igual.






+Integer1 + +Integer2
+Integer1 - +Integer2
+Integer1 * +Integer2
+Integer1 / +Integer2
+Integer1 mod +Integer2
?Integer is +Term -- Term debe ser aritméticamente evaluable
Ejemplo:
?- X is 7 mod 4.
X=3
Yes