Prolog para niños

Prolog es un lenguaje de programación especial que se basa en la lógica. Su nombre viene del francés "PROgrammation en LOGique", que significa "programación en lógica". Es muy usado en el campo de la Inteligencia artificial, que es cuando las computadoras pueden "pensar" o resolver problemas de forma inteligente.

¿Qué es Prolog y para qué sirve?

Prolog es un lenguaje de programación diferente a otros como Python o Java. En lugar de darle a la computadora una lista de pasos exactos para seguir, en Prolog le das hechos y reglas. Luego, le haces preguntas y la computadora usa esos hechos y reglas para encontrar las respuestas. Es como si le dieras un montón de información y luego le pidieras que deduzca algo.

¿Cómo funciona la lógica en Prolog?

Prolog se basa en la programación lógica. Esto significa que los programas se construyen a partir de:

• Hechos: Son cosas que sabemos que son verdad. Por ejemplo, "el cielo es azul".
• Reglas: Son condiciones que, si se cumplen, hacen que algo sea verdad. Por ejemplo, "si llueve, el suelo se moja".

Cuando le haces una pregunta a Prolog, él busca entre sus hechos y reglas para ver si puede demostrar que tu pregunta es verdadera.

Historia de Prolog: ¿Cuándo y dónde nació?

Prolog fue creado a principios de los años 70 en la Universidad de Aix-Marseille I en Marsella, Francia. Sus creadores principales fueron Alain Colmerauer y Philippe Roussel.

El origen de Prolog

Al principio, el objetivo no era crear un lenguaje de programación. Querían que las computadoras pudieran entender y procesar el lenguaje humano. Alain Colmerauer y Robert Kowalski trabajaron en cómo las computadoras podían "entender" lo que decimos. Philippe Roussel se encargó de la parte de "deducción", es decir, cómo la computadora podía sacar conclusiones.

Gracias a la colaboración con Robert Kowalski, la primera versión de Prolog apareció a finales de 1971, y la versión que conocemos hoy llegó en 1972.

Evolución y popularidad de Prolog

Al principio, Prolog era un lenguaje que se "interpretaba". Esto significa que el programa se ejecutaba línea por línea. Pero en 1983, David H.D. Warren creó un "compilador" para Prolog. Un compilador es como un traductor que convierte todo el programa a un lenguaje que la computadora entiende más rápido. Desde entonces, Prolog es un lenguaje "semi-interpretado".

En los años 80, Prolog se hizo más popular. Aparecieron versiones para computadoras personales, como Turbo Prolog. También fue elegido para un gran proyecto en Japón llamado la "quinta generación de computadoras", que buscaba crear computadoras muy avanzadas. Esto ayudó mucho a que Prolog se conociera más.

Con el tiempo, se creó un estándar internacional para Prolog en 1995 (llamado ISO-Prolog). Esto aseguró que los programas hechos en Prolog funcionaran igual en diferentes sistemas.

¿Cómo piensa Prolog? El "backtracking"

En la mayoría de los lenguajes de programación, las instrucciones se ejecutan una tras otra, en orden. Pero en Prolog, la forma de trabajar es diferente. Se basa en dos ideas clave: la unificación y el backtracking.

Unificación y puntos de elección

Cuando le haces una pregunta a Prolog, él busca las reglas y hechos que podrían ayudar a responderla. A esto se le llama "unificación". Cada posible camino o regla que puede usar se convierte en un "punto de elección". Prolog elige el primer camino y trata de resolver la pregunta.

El proceso de "vuelta atrás" (backtracking)

Si el camino que eligió Prolog no lleva a una respuesta verdadera (es decir, falla), entonces entra en acción el backtracking. Esto es como si Prolog dijera: "¡Ups, este camino no funcionó!". Entonces, retrocede, deshace lo que hizo y elige el siguiente "punto de elección" que tenía pendiente. Repite este proceso hasta que encuentra una respuesta verdadera o se da cuenta de que no hay ninguna respuesta posible.

Todos los intentos de Prolog terminan en "éxito" (si encuentra una respuesta verdadera) o en "fracaso" (si no puede encontrarla).

Programando en Prolog: Hechos y Reglas

En Prolog, los programas se construyen con dos tipos de "cláusulas":

• Hechos: Son afirmaciones simples que siempre son verdad.
• Reglas: Son afirmaciones que son verdad si se cumplen ciertas condiciones.

Una regla se escribe así:

Cabeza :- Cuerpo.

Esto se lee como: "La Cabeza es verdad SI el Cuerpo es verdad". El "Cuerpo" son las condiciones que deben cumplirse. Si hay varias condiciones, se separan con una coma (,), que significa "y".

Ejemplos de Hechos y Preguntas

Un hecho es una cláusula sin "Cuerpo". Por ejemplo:

gato(tom).

Esto significa: "Tom es un gato". Es una verdad simple.

Ahora, puedes hacerle preguntas a Prolog: ¿Es Tom un gato?

?- gato(tom).  
Yes

Prolog responde "Yes" (Sí) porque encuentra el hecho `gato(tom)`.

¿Qué cosas son gatos?

?- gato(X).  
X = Tom

Aquí, `X` es una variable. Prolog busca todo lo que sea un gato y te dice que `X` puede ser "Tom".

Reversibilidad: Una característica especial

Una cosa genial de Prolog es que muchos de sus comandos son "reversibles". Esto significa que puedes usarlos de diferentes maneras. Por ejemplo, el comando `length/2` (que calcula la longitud de una lista) puede:

• Decirte cuántos elementos tiene una lista: `length([a,b,c], L)` (L sería 3).
• O, si le das una longitud, puede crear una lista con esa cantidad de espacios: `length(X, 5)` (X sería una lista de 5 elementos vacíos).

Esto hace que Prolog sea muy flexible, porque un solo comando puede servir para varias cosas.

Expresiones y comparaciones en Prolog

Prolog tiene operadores para comparar cosas o para hacer cálculos. Aquí te mostramos algunos:

• X is Y: Calcula el valor de Y y lo asigna a X.
• X = Y: Compara si X e Y son exactamente iguales (sin calcular).
• X=:=Y: Compara si los valores de X e Y son iguales después de calcularlos.
• X == Y: Compara si X e Y son idénticos (iguales en forma y valor).

Veamos ejemplos:

?- X is 3+5.
   X = 8  % Calcula 3+5 y X es 8

?- X = 3+5.
   X = 3+5 % X es la expresión "3+5", no el resultado

?- 3+5 =:= 2+6.
   yes   % (3+5) es 8, (2+6) es 8. Los valores son iguales.

?- 3+5 == 2+6.
   no    % "3+5" no es idéntico a "2+6" como expresiones.

?- 3+5 == 3+5.
   yes   % "3+5" es idéntico a "3+5".

Listas en Prolog

Las listas son una forma de agrupar elementos en Prolog. Son como una secuencia de cosas. Una lista se divide en dos partes:

• Cabeza: Es el primer elemento de la lista.
• Cola: Es una lista con todos los demás elementos, excepto el primero.

La cabeza y la cola de una lista se separan con el símbolo "|". Por ejemplo, en la lista `[1,2,3]`, la cabeza es `1` y la cola es `[2,3]`.

Ejemplos de código en Prolog

Ejemplo simple: Árbol familiar

Este ejemplo muestra cómo definir relaciones familiares usando hechos y reglas.

%%
%% declaraciones (hechos y reglas)
%%
padrede('Juan', 'María'). % Juan es padre de María
padrede('Pablo', 'Juan'). % Pablo es padre de Juan
padrede('Pablo', 'Marcela'). % Pablo es padre de Marcela
padrede('Carlos', 'Débora'). % Carlos es padre de Débora

% Regla: A es hijo de B si B es padre de A
hijode(A,B) :- padrede(B,A).

% Regla: A es abuelo de B si A es padre de C Y C es padre de B
abuelode(A,B) :- 
   padrede(A,C), 
   padrede(C,B).

% Regla: A y B son hermanos si el padre de A es también el padre de B Y A y B no son la misma persona
hermanode(A,B) :- 
   padrede(C,A) , 
   padrede(C,B), 
   A \== B.        

% Reglas: A y B son familiares si A es padre de B O A es hijo de B O A es hermano de B
familiarde(A,B) :- 
   padrede(A,B).
familiarde(A,B) :-
   hijode(A,B). 
familiarde(A,B) :- 
   hermanode(A,B).

%%
%% consultas (preguntas a Prolog)
%%
% ¿Juan es hermano de Marcela?
?- hermanode('Juan', 'Marcela').
yes

% ¿Carlos es hermano de Juan?
?- hermanode('Carlos', 'Juan').
no

% ¿Pablo es abuelo de María?
?- abuelode('Pablo', 'María').
yes

% ¿María es abuela de Pablo?
?- abuelode('María', 'Pablo').
no

Calcular el factorial de un número

El factorial de un número (N!) es el producto de todos los números enteros positivos desde 1 hasta N. Por ejemplo, 5! = 5 * 4 * 3 * 2 * 1 = 120.

% Regla: El factorial de 0 es 1.
factorial(0, 1).
% Regla: El factorial de 1 es 1.
factorial(1, 1).
% Regla: El factorial de N (F) es N multiplicado por el factorial de (N-1).
% Esto se llama recursividad: la función se llama a sí misma.
factorial(N, F) :- N>0, N1 is N - 1, factorial(N1, F1), F is N * F1.

Calcular el término de Fibonacci de un número

La secuencia de Fibonacci es una serie de números donde cada número es la suma de los dos anteriores (0, 1, 1, 2, 3, 5, 8...).

% Regla: El término 0 de Fibonacci es 0.
fibonacci(0, 0) :-!.
% Regla: El término 1 de Fibonacci es 1.
fibonacci(1, 1) :-!.
% Regla: El término N de Fibonacci (F) es la suma de los términos (N-1) y (N-2).
fibonacci(N ,F) :-N1 is N - 1, fibonacci(N1, F1),N2 is N - 2, fibonacci(N2, F2), F is F1 + F2.

Usos de Listas en Prolog

Crear y consultar listas

plantas([manzana, naranja, limón, espinaca, gardenia, alfalfa, pino]). 

lista([1,2,3]).

% Pregunta: ¿Cuál es la cabeza (H) y la cola (T) de la lista?
?-lista([H|T]).
   H=1 
   T=[2,3]

% Pregunta: ¿Cuáles son los dos primeros elementos (H, J) y el resto (T)?
?-lista([H,J|T]).
   H=1
   J=2
   T=[3]

Longitud de una lista

% Regla: La longitud de una lista vacía es 0.
longitud([],0).
% Regla: La longitud de una lista (cuya cabeza no nos importa, _ ) es la longitud de su cola (T) más 1.
longitud([_|T],N):-longitud(T,N0), N is N0 + 1.

?- longitud([a,b,c],L).
   L = 3
?- longitud([a,b,c],4).
   No % Porque la longitud de [a,b,c] es 3, no 4.

Buscar un elemento en una lista

% Regla: Un elemento (X) pertenece a una lista si es la cabeza de la lista.
pertenece(X,[X|_]) .
% Regla: Un elemento (X) pertenece a una lista si no es la cabeza, pero sí está en la cola (R).
pertenece(X,[_|R]):- pertenece(X,R). 

?- pertenece(b,[a,b,c]).
   Yes
?- pertenece(b,[a,[b,c]]).
   No % 'b' no es un elemento directo, está dentro de otra lista.
?- pertenece([b,c],[a,[b,c]]).
   Yes % '[b,c]' sí es un elemento directo de la lista.
?- pertenece(X,[a,b]).
   X = a ; % Prolog encuentra que 'a' pertenece
   X = b   % Y también que 'b' pertenece

Eliminar un elemento de una lista

% Regla: Si X es la cabeza de la lista, la lista sin X es la cola (T).
elimina(X,[X|T],T).
% Regla: Si X no es la cabeza (H), mantenemos H y eliminamos X de la cola (T), resultando en T1.
elimina(X,[H|T],[H|T1]):- elimina(X,T,T1).

?- elimina(1,[1,2,3,4],R).
   R = [2,3,4]
?- elimina(1,R,[2,3]).
   R = [1, 2, 3] ; % Prolog encuentra todas las listas R de las que al quitar 1, queda [2,3]
   R = [2, 1, 3] ;
   R = [2, 3, 1]  
?- elimina(X,[1,2,3],Y).
   X = 1, Y = [2,3] ; % Si quitamos 1, queda [2,3]
   X = 2, Y = [1,3] ; % Si quitamos 2, queda [1,3]
   X = 3, Y = [1,2]   % Si quitamos 3, queda [1,2]

Unir (concatenar) listas

% Regla: Unir una lista vacía con L da como resultado L.
concatenar([],L,L).
% Regla: Para unir [X|L1] con L2, el resultado es X seguido de la unión de L1 con L2.
concatenar([X|L1],L2,[X|L3]):-concatenar(L1,L2,L3).

?- concatenar([1,2],[3,4],R).
  R = [1, 2, 3, 4].
?- concatenar(X,Y,[1,2]).
  X = [], Y = [1,2] ; % Una forma de obtener [1,2] es unir una lista vacía con [1,2]
  X = [1], Y = [2] ; % Otra es unir [1] con [2]
  X = [1,2], Y = []  % Y otra es unir [1,2] con una lista vacía

Comprobar si una lista es la inversa de otra

% Regla: La inversa de una lista vacía es una lista vacía.
inversa([],[]).
% Regla: Para invertir [H|T], primero invertimos la cola (T) para obtener R,
% y luego unimos R con la cabeza (H) para obtener la lista final L.
inversa([H|T],L):-  inversa(T,R),  concatenar(R,[H],L).

?- inversa([a,b,c,d],[d,c,b,a]).
   Yes/Si

% Otra forma de invertir una lista usando un "parámetro acumulador" para mayor eficiencia.
inver(L1,L2):-inver(L1,L2,[]).

inver([],L,L).
inver([H|T],L,S):-inver(T,L,[H|S]).

?- inver([a,b,c,d],[d,c,b,a]).
   Yes

Más sobre Prolog

• SWI-Prolog: Una versión popular de Prolog.
• GNU Prolog: Otra versión de Prolog de código abierto.
• Programación lógica: El tipo de programación en el que se basa Prolog.
• Probador de teoremas lógicos: Programas que usan la lógica para demostrar verdades.

Véase también

En inglés: Prolog Facts for Kids