L'utilisation des prédicats intégrés, la séquence d'objectifs ou la spécification d'un objectif à l'invite du système n'auraient que peu de valeur en soi. Pour écrire un programme Prolog, l'utilisateur doit d'abord écrire un programme écrit en langage Prolog, charger ce programme, puis spécifier une séquence d'un ou plusieurs objectifs à l'invite.

Pour créer un programme dans Prolog, le plus simple est de le saisir dans l'éditeur de texte puis de l'enregistrer sous forme de fichier texte comme prolog1.pl .

L'exemple suivant montre un programme simple de Prolog. Le programme contient trois composants, appelés clauses. Chaque clause se termine par un point.

 dog(rottweiler). cat(munchkin). animal(A) :- cat(A). 

Utilisation du prédicat intégré ' consulter' , le programme ci-dessus peut être chargé dans le système Prolog.

?-consulter('prolog1.pl').

Cela montre que le fichier prolog1.pl existe et que le programme prolog est systématiquement correct, ce qui signifie qu'il a des clauses valides, que l'objectif réussira et que pour confirmer que le programme a été correctement lu, il produit une ou plusieurs lignes de sortie. par exemple.,

?-
# 0,00 seconde pour consulter prolog1.pl
?-

comment trouver des applications cachées sur Android

L'alternative à « consulter » est « Charger », qui existera dans l'option de menu si le système Prolog dispose d'une interface utilisateur graphique.

Lorsque le programme est chargé, la clause sera placée dans une zone de stockage, et cette zone de stockage est connue sous le nom de base de données Prolog. En réponse à l'invite du système, spécifiez une séquence d'objectifs, et Prolog recherchera et utilisera les clauses nécessaires pour évaluer les objectifs.

Terminologie

Dans le programme suivant, trois lignes montrent les clauses.

 dog(rottweiler). cat(munchkin). animal(A) :- cat(A). 

En utilisant le point, chaque clause sera terminée. Les programmes Prolog ont une séquence de clauses. Des faits ou des règles sont décrits par ces clauses.

Exemple de faits est chien (rottweiler) et chat (munchkin) . Ils veulent dire que ' rottweiler est un chien' et ' munchkin est un chat'.

Le chien est appelé un prédicat. Dog contient un argument. Mot ' rottweiler entre parenthèses ( ). Le Rottweiler s'appelle un atome.

L'exemple de règle est la dernière ligne du programme.

 animal(A) :- dog(A). 

Le caractère deux-points (:-) sera lu comme « si ». Ici, A est une variable et représente n’importe quelle valeur. De manière naturelle, la règle peut être lue comme suit : « Si A est un animal, alors A est un chien ».

La clause ci-dessus montre que le rottweiler est un animal. Une telle déduction peut également être effectuée par Prolog :

?- animal(rottweiler).
Oui

Pour laisser entendre que munchkin est un animal, il n'y a aucune preuve de cela.

?- animal(munchkin).
Non

Plus de terminologie

L'évaluation d'un terme d'objectif détermine s'il est satisfait ou non. Cela signifie également que l'objectif est évalué comme vrai ou faux.

Notez que lorsqu'un utilisateur saisit un objectif, celui-ci peut parfois être interprété comme une commande. Par exemple,

?- s'arrêter. 'Il sert à sortir du système Prolog.'

Parfois, cela peut être considéré comme une question du type :

?- animal(rottweiler). & 'Le rottweiler est-il un animal ?'

Le programme suivant montre un autre exemple sur les animaux. Il comprend huit articles. Le commentaire est affiché par tout le texte entre /* et */.

 /* Another Program of Animal */ Dog(rottweiler). cat(sphynx). dog(poodle). dog(bulldog). cat(bengal). dog(dobermann). cat(himalayan). cat(singapura). /* This Prolog program consists of various clauses. It is always terminated using the full stop.*/ 

Le chien prédicat et le chat prédicat ont tous deux quatre clauses. Supposons que dans un fichier texte « animal.pl », le programme a été enregistré et que la sortie est générée en chargeant le programme et à l'invite du système, nous entrons une séquence d'objectifs comme suit :

?- consulter('animaux1.pl'). Invite système
# 0,01 seconde pour consulter animaux.pl animaux.pl chargé en utilisant la consultation

?- chien(rottweiler).
Oui

?- chien(boxeur).
Non

?- chien(UNE).
A = le rottweiler fait une pause - la touche retour est enfoncée par l'utilisateur

?- chien(B).
B = rottweiler ; des pauses ? l'utilisateur appuie sur ;
B = caniche ; des pauses ? l'utilisateur appuie sur ;
B = bouledogue ; des pauses ? l'utilisateur appuie sur ;
B = dobermann Pas de pause ? Cela ira à la ligne suivante

?- chat(UNE). A = sphinx ; pause ? l'utilisateur appuie sur ;
A = Bengale fait une pause ? l'utilisateur appuie sur retour

?- écoute(chien). Il listera toutes les clauses qui définissent le chien prédicat

/* chien/1 */

chien (rottweiler).
chien (caniche).
chien (bouledogue).
chien (dobermann).
Oui
?-

Dans cet exemple, diverses nouvelles fonctionnalités de Prolog sont introduites. La requête est la suivante :

?- chien(UNE).

Cela signifie qu'il faut trouver la valeur du A, et ce sera le nom du chien. La réponse de Prolog est la suivante :

A = rottweiler

Les autres réponses possibles de A sont les suivantes : caniche, bouledogue, dobermann. Cela provoquera la pause du Prolog et, de ce fait, nous devrons attendre que l'utilisateur appuie sur la touche « retour » avant d'afficher l'invite système ?-.

Nous pouvons saisir la requête suivante comme suit :

?- chien(B).

Cette requête est la même que précédemment. La requête ci-dessus signifie « trouvez la valeur du B, et ce sera le nom d'un chien ». La réponse de Prolog est la suivante :

B = rottweiler

récursion java

Prolog fera à nouveau une pause. Cette fois, la touche point-virgule (;) est enfoncée par l'utilisateur. Maintenant, Prolog trouvera une valeur alternative de B qui satisfait le chien objectif (B). Il répondra comme suit :

B = caniche

Prolog fera à nouveau une pause. La touche point-virgule (;) est à nouveau enfoncée par l'utilisateur. Prolog produit une autre solution comme suit :

B = bouledogue

Prolog fera à nouveau une pause. La touche point-virgule (;) est à nouveau enfoncée par l'utilisateur. Prolog produit une autre solution comme suit :

B = dobermann

Prolog reconnaît qu'il n'y a plus de solution disponible en ne faisant pas de pause, mais l'invite système ?- en passant immédiatement à la sortie.

Un nouveau prédicat intégré est introduit dans cet exemple. Préciser l'objectif

?- annonce(chien)

Dans l'objectif ci-dessus, Prolog listera les quatre clauses qui définissent le chien prédicat. Ils définiront dans le même ordre que celui dans lequel ils ont été chargés dans la base de données.

L'utilisation de variables dans la requête est illustrée par l'exemple suivant. La séquence des objectifs est la suivante :

?-chat(A),chien(B).

Cela nous donnera toutes les combinaisons possibles d’un chat et d’un chien.

?-chat(A),chien(B).
A = sphinx,
B = rottweiler ;

Java 8

A = sphinx,
B = caniche ;

A = sphinx,
B = bouledogue ;

A = sphinx,
B = doberman ;

etc.

En revanche, la séquence d’objectifs est la suivante :

?-chat(A), chien(A).

Cela donnera tous les animaux qui sont à la fois un chat et un chien (dans la base de données, un tel animal n'existe pas). Ici, A est « n’importe quelle valeur » dans cat(A) et dog(A), mais les deux doivent avoir la même valeur.

?-chat(A),chien(A).
Non