Prolog Language Tutorial
Empezando con Prolog Language

Observaciones

Instalación o configuración

SWI-Prolog

Windows y Mac:

• Descarga SWI-Prolog en la web oficial
• Simplemente instale siguiendo las instrucciones del instalador.

Linux (PPA):

• Agregue el PPA ppa:swi-prolog/stable a las fuentes de software de su sistema (los desarrolladores pueden elegir para ppa:swi-prolog/devel ):

  • Abra una terminal (Ctrl + Alt + T) y escriba: sudo add-apt-repository ppa:swi-prolog/stable

  • Después, actualice la información del paquete: sudo apt-get update

• Ahora instale SWI-Prolog a través del administrador de paquetes: sudo apt-get install swi-prolog

• Ahora puede iniciar SWI-Prolog a través de la línea de comandos con el comando swipl

añadir / 3

append([], Bs, Bs).
append([A|As], Bs, [A|Cs]) :-
    append(As, Bs, Cs).

append/3 es una de las relaciones Prolog más conocidas. Define una relación entre tres argumentos y es verdadera si el tercer argumento es una lista que denota la concatenación de las listas que se especifican en el primer y segundo argumento.

Notablemente, y como es típico de un buen código de Prolog, el append/3 se puede usar en varias direcciones : Se puede usar para:

• Adjuntar dos listas total o parcialmente instanciadas:

    ?- A = [1, 2, 3], B=[4, 5, 6], append(A, B, Y)
    Output:
    A = [1, 2, 3],
    B = [4, 5, 6],
    Y = [1, 2, 3, 4, 5, 6].
  

• verifique si la relación es verdadera para tres listas totalmente instanciadas:

    ?- A = [1, 2, 3], B = [4, 5], C = [1, 2, 3, 4, 5, 6], append(A, B, C)
    Output:
    false
  

• generar todas las formas posibles de anexar dos listas a una lista dada:

    ?- append(A, B, [1, 2, 3, 4]).
    Output:
    A = [],
    B = [1, 2, 3, 4] ;
    A = [1],
    B = [2, 3, 4] ;
    A = [1, 2],
    B = [3, 4] ;
    A = [1, 2, 3],
    B = [4] ;
    A = [1, 2, 3, 4],
    B = [] ;
    false.
  

Restricciones de CLP (FD)

Todas las implementaciones serias de Prolog proporcionan restricciones CLP (FD) . Nos permiten razonar sobre los enteros de una manera pura.

?- X #= 1 + 2.
X = 3.

?- 5 #= Y + 2.
Y = 3.

Programación de base de datos

Prolog categoriza todo en:

• Átomos : cualquier secuencia de caracteres que no comienza con un alfabeto en mayúsculas. Por ejemplo, a , b , okay
• Números : no hay una sintaxis especial para los números, no se requiere declaración. Ej. 1 , 22 , 35.8
• Variables : una cadena que comienza con un carácter en mayúscula o un guión bajo ( _ ). Ej. X , Y , Abc , AA
• Términos complejos : están hechos de un funtor y una secuencia de argumentos . El nombre de un término complejo siempre es un átomo, mientras que los argumentos pueden ser átomos o variables. Ej. father(john,doe) , relative(a) , mother(X,Y) .

Una base de datos lógica contiene un conjunto de hechos y reglas .

Un término complejo con solo átomos como argumentos se llama un hecho, mientras que un término complejo con variables como argumentos se llama una regla.

Ejemplo de hechos en Prolog:

father_child(fred, susan).
mother_child(hillary, joe).

Ejemplo de una regla en Prolog:

child_of(X,Y):-
    father_child(Y,X)
    ;
    mother_child(Y,X).

Tenga en cuenta que el ; Aquí es como el operador or en otros idiomas.

Prolog es un lenguaje declarativo y puede leer esta base de datos de la siguiente manera:

fred es el padre de susan

hillary es la madre de joe.

Para todas las X e Y , X es un hijo de Y si Y es un padre de X o Y es una madre de X

De hecho, un conjunto finito de hechos y / o reglas constituye un programa lógico.

El uso de tal programa se demuestra haciendo consultas . Las consultas le permiten recuperar información de un programa lógico.

Para cargar la base de datos en el intérprete (asumiendo que ha guardado la base de datos en el directorio en el que está ejecutando el intérprete) simplemente ingrese:

?- [nameofdatabase].

reemplazando el nameofdatabase la base de nameofdatabase con el nombre del archivo real (tenga en cuenta que aquí excluimos la extensión .pl del nombre de archivo).

Ejemplo de consultas en el intérprete para el programa anterior y los resultados:

?- child_of(susan,fred).
true

?- child_of(joe,hillary).
true

?- child_of(fred,susan).
false

?- child_of(susan,hillary).
false

?- child_of(susan,X).
X = fred

?- child_of(X,Y).
X = susan,
Y = fred ;
X = joe,
Y = hillary.

Las consultas anteriores y sus respuestas se pueden leer de la siguiente manera:

¿Es Susan un hijo de Fred? - cierto

¿Es Joe un hijo de Hillary? - cierto

¿Es Fred un hijo de Susan? falso

¿Es Susan un hijo de Hillary? falso

quien es susan un hijo de fred

Así es como programamos la lógica en Prolog. Un programa lógico es más formal: un conjunto de axiomas, o reglas, que definen relaciones (también conocido como predicados) entre objetos. Una forma alternativa de interpretar la base de datos anterior de una manera lógica más formal es:

La relación father_child mantiene entre fred y susan.

La relación mother_child mantiene entre hillary y joe.

Para todas las X e Y la relación child_of mantiene entre X e Y si la relación father_child mantiene entre Y y X , o la relación mother_child mantiene entre Y y X

Hola Mundo

Hola, Mundo en el intérprete interactivo.

Para imprimir "¡Hola mundo!" en el intérprete de Prolog (aquí estamos usando swipl , el shell para SWI Prolog):

$ swipl
<...banner...>
?- write('Hello, World!'), nl.

?- es el indicador del sistema: indica que el sistema está listo para que el usuario ingrese una secuencia de objetivos (es decir, una consulta ) que debe terminarse con un . (parada completa).

Aquí la consulta de write('Hello World!'), nl tiene dos objetivos:

• write('Hello World!') : 'Hello World!' tiene que ser mostrado y ( , )
• una nueva línea ( nl ) debe seguir.

write/1 (el /1 se usa para indicar que el predicado toma un argumento) y nl/0 son predicados incorporados (la definición se proporciona de antemano en el sistema Prolog). Los predicados incorporados proporcionan recursos que no se pueden obtener mediante la definición pura de Prolog o para evitar que el programador tenga que definirlos.

La salida:

¡Hola Mundo!

sí

termina con yes lo que significa que la consulta ha tenido éxito. En algunos sistemas se imprime true lugar de yes .

Hola mundo de un archivo

Abra un nuevo archivo llamado hello_world.pl e inserte el siguiente texto:

:- initialization hello_world, halt.

hello_world :-
    write('Hello, World!'), nl.

La directiva de initialization especifica que el objetivo hello_world, halt debe llamarse cuando se carga el archivo. halt salidas del programa.

Este archivo puede ser ejecutado por su ejecutable Prolog. Las banderas exactas dependen del sistema Prolog. Si está utilizando SWI Prolog:

$ swipl -q -l hello_world.pl 

Esto producirá salida Hello, World! . El indicador -q suprime el banner que normalmente se muestra cuando se llama a ejecutar swipl . El -l especifica un archivo para cargar.