Prolog LanguagePremiers pas avec le langage Prolog


Remarques

Les implémentations

  1. SWI-Prolog (gratuit)
    • Implémenté dans
  2. SICStus (commercial)
  3. YAP (gratuit)
  4. GNU Prolog (gratuit)
  5. XSB (gratuit)
  6. B (commercial)
  7. SI (commercial)
  8. Ciao (libre)
  9. Minerva (commercial)
  10. ECLiPSe-CLP (gratuit)
  11. Jekejeke Prolog (commercial)
  12. Prolog IV
  13. Rendement Prolog (gratuit)
  14. Visual Prolog (commerciale)

annexe / 3

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

append/3 est l'une des relations Prolog les plus connues. Elle définit une relation entre trois arguments et est vraie si le troisième argument est une liste indiquant la concaténation des listes spécifiées dans les premier et deuxième arguments.

Notamment, et comme c'est généralement le cas pour un bon code Prolog, append/3 peut être utilisé dans plusieurs directions : Il peut être utilisé pour:

  • ajouter deux listes totalement ou partiellement instanciées:

      ?- 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].
     
  • vérifier si la relation est vraie pour trois listes complètement instanciées:

      ?- A = [1, 2, 3], B = [4, 5], C = [1, 2, 3, 4, 5, 6], append(A, B, C)
      Output:
      false
     
  • générer tous les moyens possibles pour ajouter deux listes à une liste donnée:

      ?- 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.
     

Contraintes CLP (FD)

Les contraintes CLP (FD) sont fournies par toutes les implémentations sérieuses de Prolog. Ils nous permettent de raisonner sur des entiers de manière pure.

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

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

Programmation de base de données

Prolog classe tout en:

  • Atomes - Toute séquence de caractères qui ne commence pas par un alphabet majuscule. Par exemple - a , b , d' okay
  • Nombres - Il n'y a pas de syntaxe spéciale pour les nombres, aucune déclaration n'est requise. Par exemple 1 , 22 , 35.8
  • Variables - Chaîne commençant par un caractère majuscule ou un trait de soulignement ( _ ). Par exemple X , Y , Abc , AA
  • Termes complexes - Ils sont fabriqués à partir d'un foncteur et d'une séquence d' arguments . Le nom d'un terme complexe est toujours un atome, alors que les arguments peuvent être des atomes ou des variables. Par exemple, father(john,doe) , relative(a) , mother(X,Y) .

Une base de données logique contient un ensemble de faits et de règles .

Un terme complexe avec uniquement des atomes comme arguments est appelé un fait, tandis qu'un terme complexe avec des variables comme arguments est appelé une règle.

Exemple de faits dans Prolog:

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

Exemple de règle dans Prolog:

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

Notez que le ; ici est comme l'opérateur or dans d'autres langues.

Prolog est un langage déclaratif et vous pouvez lire cette base de données comme suit:

fred est le père de susan

Hillary est la mère de Joe.

Pour tout X et Y , X est un enfant de Y si Y est un père de X ou Y est une mère de X

En fait, un ensemble fini de faits et / ou de règles constitue un programme logique.

L'utilisation d'un tel programme est démontrée par des requêtes . Les requêtes vous permettent de récupérer des informations à partir d'un programme logique.

Pour charger la base de données dans l'interpréteur (en supposant que vous avez enregistré la base de données dans le répertoire dans lequel vous exécutez l'interpréteur), il vous suffit d'entrer:

?- [nameofdatabase].
 

remplacer le nameofdatabase la nameofdatabase de nameofdatabase par le nom de fichier réel (notez que nous excluons ici l'extension .pl du nom de fichier).

Exemple de requêtes dans l'interpréteur pour le programme ci-dessus et les résultats:

?- 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.
 

Les questions ci-dessus et leurs réponses peuvent être lues comme suit:

est susan un enfant de fred? - vrai

Joe est-il un enfant de Hillary? - vrai

fred est un enfant de susan? - faux

est susan un enfant de hillary? - faux

qui est un enfant de Susan? - fred

Voici comment nous programmons la logique dans Prolog. Un programme logique est plus formel: un ensemble d'axiomes ou de règles définissant des relations (aka prédicats) entre objets. Une autre manière d’interpréter la base de données ci-dessus de manière plus formelle est la suivante:

La relation father_child tient entre fred et susan

La relation mother_child tient entre hillary et joe

Pour tout X et Y la relation child_of est child_of entre X et Y si la relation father_child entre Y et X , ou la relation mother_child entre Y et X

Bonjour le monde

Bonjour, World dans l'interpréteur interactif

Pour imprimer "Bonjour, Monde!" dans l'interpréteur Prolog (nous utilisons ici swipl , le shell pour SWI Prolog):

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

?- est l'invite du système: cela indique que le système est prêt pour que l'utilisateur entre une séquence d' objectifs (c.-à-d. une requête ) devant être terminée par un . (arrêt complet).

Ici, la requête write('Hello World!'), nl a deux objectifs:

  • write('Hello World!') : 'Hello World!' doit être affiché et ( , )
  • une nouvelle ligne ( nl ) doit suivre.

write/1 (le /1 indique que le prédicat prend un argument) et nl/0 sont des prédicats intégrés (la définition est fournie au préalable par le système Prolog). Les prédicats intégrés fournissent des fonctionnalités qui ne peuvent pas être obtenues par une définition de Prolog pure ou pour empêcher le programmeur de les définir.

Le résultat:

Bonjour le monde!

Oui

se termine par yes ce qui signifie que la requête a réussi. Dans certains systèmes, true est imprimé au lieu de yes .

Bonjour, Monde d'un fichier

Ouvrez un nouveau fichier appelé hello_world.pl et insérez le texte suivant:

:- initialization hello_world, halt.

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

La directive d' initialization spécifie que l'objectif hello_world, halt doit être appelé lorsque le fichier est chargé. halt quitte le programme.

Ce fichier peut alors être exécuté par votre exécutable Prolog. Les drapeaux exacts dépendent du système Prolog. Si vous utilisez SWI Prolog:

$ swipl -q -l hello_world.pl 
 

Cela produira une sortie Hello, World! . L' -q supprime la bannière qui s'affiche généralement lorsque vous appelez run swipl . Le -l spécifie un fichier à charger.

Installation ou configuration

SWI-Prolog

Windows et Mac:

  • Téléchargez SWI-Prolog sur le site officiel
  • Installez simplement en suivant les instructions du programme d'installation.

Linux (PPA):

  • Ajoutez le PPA ppa:swi-prolog/stable aux sources logicielles de votre système (les développeurs peuvent choisir ppa:swi-prolog/devel ):

    • Ouvrez un terminal (Ctrl + Alt + T) et tapez: sudo add-apt-repository ppa:swi-prolog/stable

    • Ensuite, mettez à jour les informations sur le paquet: sudo apt-get update

  • Maintenant, installez SWI-Prolog via le gestionnaire de paquets: sudo apt-get install swi-prolog

  • Vous pouvez maintenant démarrer SWI-Prolog via la ligne de commande avec la commande swipl