1).- HECHOS (Sentencias):
Son relaciones entre los objetos del sistema. Su formato es:
- - nombre-de-predicado(constante...)
- Ejemplo: La relación o el hecho que Cayo y Pity son hermanos se expresa: Hermano (Cayo, Pity).

2).- REGLAS:
Sentencias de relación entre hechos, del tipo p®q, con el formato:
nombre-de-predicado(constante o variable...) :- nombre-de-predicado(constante o variable...)...

Ejemplo: Hermano_de(X,Y):-hombre(X), padres(X,M,P), padres (Y,M,P).

Que se lee:
Si X es hombre y los padres de X (MP) son los mismos que los de Y (MP), entonces establece el hecho de que X es hermano de Y.

B.- PROLOG: OPERADORES:
Son reglas de operadores relacionales y aritméticos básicos, donde:

"is", es operador de asignación o relacional igual. Ejemplo:

Velocidad (X,V): distancia_recorrida(X.D), tiempo_utilizado(X,T), V is DT.

Leído como:
- Si la distancia recorrida por X es D, y
- el tiempo utilizado por X es T,
- se calcula y almacena en V, la velocidad, por medio de la división de la distancia entre el tiempo, y
- se concluye que X tiene una velocidad V.

"read" y "write" son operadores para lectura y escritura de información.
"½" es un operador para manejar listas.

C.- PROLOG: VARIABLES:
Define reglas validas dentro de regla donde aparecen.
- No existen variables globales.
- Comienzan con una letra mayúscula. Ejemplo: Pity
- La variable anónima, identificada con guión bajo ("_"), almacena valores temporales.

EJEMPLO 1 PROLOG:
Que destaca la estructura del programa utilizando el Paradigma Lógico: Predicados, Cláusulas, y Resultados (goal).

     database - tmp
                hijo(STRING, STRING)
                hermana(STRING, STRING)
                hermano(STRING, STRING)
                casado(STRING, STRING)

     clauses
                hijo("Paco","Cacho").
                hermana("Mary","Carola").
                hermano("Tomas","Lucas").
                casado("Paco","Mary").
                casado("Lucas","Graciela").

     predicates
                padre(STRING padre, STRING chico)
                abuelo(STRING abuelo, STRING nieto)
                cuñada(STRING, STRING)

     clauses
                padre(A,B):-
                       hijo(B,A).
                abuelo(A,B):-
                       padre(A,C),
                       padre(C,B).
                cuñada(A,B):-
                       casado(A,C),
                       hermano(C,B).

     goal
                cuñada("Paco",Z),
                format(Msg,"cuñada(/"Paco/",%)",Z),
                write(Msg).

EJEMPLO 2 EN PROLOG:

   Domains
     Wilo = symbol
   
   Predicates
     Wilo(symbol)
     juegan(Wilo,Wilo)

   Clauses
     Wilo(a).
     Wilo(b).
     Wilo(c).

    juegan(X,Y):-   Wilo(X),Wilo(Y),

    X<>Y,write(X," juega vs. ",Y),
                            nl, fail.

  Goal
    juegan(S,T).

D.- PROLOG: RECURSIVIDAD:
Itera sobre las cláusulas y está basado en el concepto matemático de inducción planteado como Forma:

Procedural:
Parte de un caso genérico hasta la cláusula de corte de recursividad (prueba que un hecho o regla se cumple n veces).

Declarativa:
Desde el caso inicial (P0), inferimos el caso general (Pn) y vemos que cumple para n+1.

Ejemplo de recursividad: Factorial en pseudocódigo esta función:
Factorial (N)
- Si N = 0 entonces Factorial = 1
- Si N > 0 entonces Factorial = N * Factorial (N-1)

Como PROLOG no tiene funciones:
Si factorial recibe un argumento y devuelve el factorial de ese número, necesita 2 argumentos:
- Uno de entrada y otro de salida. (Factorial será un hecho de la base de conocimientos como verdadera o falsa).
- Una función de Paradigma agrega un argumento más, que será el valor "devuelto" por el predicado.
- Como no se puede usar N = N -1, se:
- - Usan variables temporales (N1 = N - 1) y
- - Pasan como argumentos a sucesivas llamadas recursivas.
Ejemplo: El factorial en Prolog será:

  domains
  predicates
     factorial (int, int)
  clauses
     factorial (0, 1):-!.
     factorial (N, FN):- N1 = N - 1, 
                       factorial(N1, FN1),
                       FN = N * FN1.

En la segunda, utilizo dos argumentos: el primero es un contador, y el segundo un acumulador.
Pero como no puedo llamar a factorial (N-1), primero debo guardarlo en una variable auxiliar,
a la que unifico con N - 1 y la llamo N1.
N1 = N - 1

Para comprobar que la regla factorial se cumpla para N - 1
y recibiré además un valor para FN1, que está aún sin ligar, es una incógnita que debo resolver.
factorial(N1, FN1)

y finalmente, con el valor devuelto de FN1, aplico FN = N * FN1, y resuelvo la identidad para FN, que indicará el valor de esta "función".

E.- PROLOG: LISTAS:
El primer argumento de una lista es un elemento, el segundo argumento es recursivamente el resto de la lista.

Para las listas, igual que en los naturales, es necesario un símbolo constante para terminar la recursividad,
ésta es la lista vacía que se denomina "nil" y se denota [].

También se necesita un functor binario que en el caso de Prolog se escribe así:

[X|Y], donde:
- X es la cabeza de lista.
- Y es la cola.
- El símbolo "|" es el operador de concatenación.

Las listas son útiles para tratar con una cantidad de elementos desconocida a la hora de implementar una solución. La lista compuesta por los símbolos a, b y c se escribe: [a, b, c], y se representa

            lista
            /  \ 
          a     lista
                /  \
               b   lista
                   /  \
                  c    []

                  lista
                   /  \
                  1    []

  [a, b, c] equivale a [a|[b,c]],    y en consecuencia
  [a|[b,c]] equivale a [a|[b|[c]]]   que equivale a    
  [a|[b|[c|[]]]]

   lista([]).
   lista([Cabeza|Cola]):- lista(Cola).

  domains
	lista= elemento*
	elemento= integer
  predicates
	miembro(elemento,lista)
  clauses		
	miembro(X, [X|_]).
	miembro(X, [_|Z]):- miembro(X, Z).

Visión procedural: Si se le hiciera la consulta (goal): miembro(1 ,[2, 1, 8]).

Prolog:

• Primero aparea miembro(1, [2, 1, 8]) con miembro(X, [X|_]),
• Unifica X con 1 y realiza la comparación de X con el primer elemento de la lista, y como este es distinto de 1 la unificación falla.
• Luego Prolog aparea miembro(1, [2, 1, 8]) con miembro(X, [_|Z]), en este caso la unificación es exitosa, quedando X unificada con 1 y Z con la cola de la lista, o sea [1, 8].
• La cabeza de la lista no queda unificada a ninguna variable puesto que no es necesario conocer su valor. La manera de lograr esto es usr "_" en lugar de una variable, porque Prolog no permite utilizar variables que luego no van a ser usadas.
• Como miembro(X, [_|Z]) es la cabeza de una regla, Prolog procederá a verificar la subconsulta miembro(X, Z).
• Prolog iterará los pasos arriba mencionados, pero con un elemento menos en la lista, que es la cabeza que ha sido descartada, en este caso Prolog si logra la unificación porque X coincide con la cabeza de la lista, y entonces como miembro(X,[X|_]) es un hecho Prolog nos devuelve como respuesta True.

Este programa, además de verificar si un elemento está en una lista, permite hallar los elementos de una lista: miembro(X, [1, 3]), que devolverá X=1; X=3.

Visión declarativa:
Un elemento está en la lista si está en la cabeza o en la cola.

Observación: Si se define la cláusula miembro:
             miembro(X, [X|_]):-!.
             miembro(X, [_|Z]):- miembro(X, Z).
¿Cómo impacta el cut en las consultas miembro(X, [1, 2, 3])?