EPITA

Introdution à Prolog, cours n° 1

Jean-François Perrot

Histoire de Prolog
1. Implémentations disponibles aujourd'hui (2009)
2. La programmation logique comme style de programmation
Première approche : interroger une base de données.
Seconde approche : avec des fonctions (plus exactement, avec des symboles de fonctions)
Fonctionnement de base
Programmes récursifs sur les listes, plus ou moins réversibles

Histoire de Prolog

Prolog : Wikipédia-fr, Wikipedia-en

Début des années '70, travaux de R. Kowalski à Édimbourg sur l'idée de la programmation logique :
Principe : Programs = Logic + Control
1972 : Naissance de Prolog à Marseille (Alain Colmerauer, Philippe Roussel)
Récit, écrit par les auteurs 20 ans apès.
1977 : Prolog sur PDP-10 à Édimbourg (nouvelle syntaxe)
1982 : PrologII à Marseille (extensions substantielles)
1983 : La machine abstraite de D.H. Warren (la WAM)
La WAM est à la base de la plupart des Prolog actuels, notamment SWI Prolog (Univ. d'Amsterdam)
Dans les années '80, le projet japonais de "5ème génération"
Développements actuels : langages de programmation par contraintes issus de Prolog,
p. ex. Chip de Cosytec, IlogSolver d'Ilog et PrologIV de PrologIA

Implémentations disponibles aujourd'hui (2009)

SWI-Prolog (Sociaal-Wetenschappelijke Informatica ("Social Science Informatics"), Univ. Amsterdam),
gratuit, l'implémentation la plus utilisée dans l'enseignement.
SICStus Prolog (SICS = Swedish Institute of Computer Science)
l'implémentation de référence des utilisateurs industriels.
Voir une liste plus longue dans Wikipédia

La programmation logique comme style de programmation

Le programme entre l'homme et la machine :
métaphores pour défnir des séquences de calcul
La programmation impérative :
la séquence de calcul pensée comme une séquence d'actions
- structurée : goto considered harmful
- à objets : mieux adaptée à la modélisation
La programmation fonctionnelle :
la séquence de calcul est obtenue de manière indirecte, par le calcul d'une fonction
La programmation logique :
la séquence de calcul est obtenue de manière indirecte, par la démonstration d'un résultat

Première approche : interroger une base de données.

Les données

pere(cesar, adrienne). pere(marc, enza). pere(cesar, marc). pere(marc, mara). mere(silvia, cesar). mere(julie, lea). mere(lea, adrienne). mere(adrienne, enza).
Les questions directes
(posées de manière interactive, une fois lu le fichier contenant les données)
1. ?- pere(cesar, mara).
  false.
2. ?- mere(silvia, cesar).
  true.
3. ?- pere(cesar, X).
  X = adrienne ;
  X = marc.
4. ?- pere(cesar, X), mere(Y,X).
  X = adrienne
  Y = lea ;
  false
Les déductions
(après lecture du fichier contenant les définitions suivantes :

masc(X) :- pere(X, Y). fem(X) :- mere(X, Y). ancetre(X, X). ancetre(A, D) :- pere(A, G), ancetre(G, D). ancetre(A, D) :- mere(A, G), ancetre(G, D).
)
1. ?- fem(adrienne). true.
2. ?- fem(enza). false.
3. ?- fem(mara). false.
4. ?- masc(cesar). true ;
  true.
5. ?- ancetre(silvia, adrienne). true ;
  false.
6. ?- ancetre(X, adrienne). X = adrienne ;
  X = cesar ;
  X = silvia ;
  X = julie ;
  X = lea ;
  false.
7. ?- ancetre(X, enza), ancetre(julie, X). X = enza ;
  X = julie ;
  X = lea ;
  X = adrienne ;
  false.
Commentaire
Dans son ensemble, l'interprétation de ces échanges est sans mystère,
- la virgule dans les requêtes (question 4) et (déduction 7) signifiant la conjonction des demandes.
- le symbole ":-" dans les définitions s'interprète comme une implication de droite à gauche :
  si le membre droit est vérifié, alors le membre gauche l'est aussi.
  On reviendra longuement sur cette interprétation.
Quelques points méritent d'être soulignés.
1. Constantes et variables
  - Les variables sont en majuscules (X, Y) - plus généralement leur initiale est une majuscule.
    Sur leur nature exacte nous reviendrons longuement dans la suite.
  - Les constantes apparaissent comme des noms écrits en minuscules.
    Elles ne désignent pas des valeurs, mais des adresses fixes en mémoire (dans le tas).
    Ces adresses sont attribuées par le lecteur.
    Il n'y a pas de différence de nature entre celles qui apparaissent en position de prédicat (pere, mere, masc,...)
    et celles qui jouent le rôle d'argument (enza, julie, marc,...).
    On peut demander, par exemple :
    ?- fem(masc).
    et recevoir la réponse légitime
    false.
    sans causer une quelconque erreur de type ou de syntaxe.
2. Réponses multiples
  Les questions 3 et 4, et les déductions 6 et 7, ont plusieurs réponses : elles sont énumérées automatiquement
  sur demande de l'utilisateur qui tape un point-virgule sans retour-chariot (marqué en rouge).
  À la fin de l'énumération, le système signale qu'il ne trouve plus de solution en déclarant false.
3. La trace
  La séquence d'exécution de Prolog se manifeste clairement dans le dispositif de traçage.
  Ce dispositif prend en Prolog une forme plus élaborée qu'en Lisp.
  Il est utile de prendre l'outil en main...

Seconde approche : avec des fonctions (plus exactement, avec des symboles de fonctions)

Exemple
Définition
id(le_pere(X), P) :- pere(P, X). id(la_fille(X, Y), F) :- pere(X, F), mere(Y, F), fem(F).

Exécution
?- id(X,Y). X = le_pere(adrienne), Y = cesar ; X = le_pere(enza), Y = marc ; X = le_pere(marc), Y = cesar ; X = le_pere(mara), Y = marc ; X = la_fille(cesar, lea), Y = adrienne ; false.

Prolog manipule exclusivement des arbres,
représentés par des termes du 1er ordre en notation traditionnelle fonction(arg1, arg2, ..., argk).
Comme on est au premier ordre, seules des constantes apparaissent en position de fonction.
Prolog ne fait pas de différence entre une constante désignant un objet (ici, lea, adrienne, marc,...)
et une constante nommant une fonction sans argument (fonction zéro-aire, ou d'arité zéro).

En syntaxe écossaise, les constantes sont des symboles dont le nom a un initiale minuscule
et où les variables sont des symboles dont le nom a un initiale majuscule.
Exemple : append(X, iReverse(Y, nil))
Attention à une particularité irritante de la syntaxe écossaise (a bug that became a feature):
ne pas laisser de blanc entre le nom de fonction et la première parenthèse : ne pas taper "pere (cesar...".

Ces arbres sont l'unique structure de données que Prolog connaisse.
Comme on le verra, le lecteur de Prolog peut accepter diverses conventions qui facilitent la commuication avec l'utilisateur humain,
(par exemple, les expressionss arithmétiques, les listes, les clauses elles-mêmes)
mais la représentation interne est uniformément celle des arbres.

Listes

Les listes sont une famille particulièrement importance de termes Prolog,
dotés d'une syntaxe particulière.

Une liste en Prolog, comme en Lisp, n'est pas autre chose
qu'une notation commode pour un arbre binaire.

Syntaxe : écriture entre crochets et avec virgules.
La liste vide "[]"
Le constructeur binaire "|" (= le cons de Lisp)
- à sa gauche le premier élément (car)
- à sa droite le reste de la liste (cdr)

Exemple typique : calcul récursif de la longueur d'une liste

 long([], 0).

long([A | S], N) :- long(S, P), N is P+1.

Intermède illustrant la manipulation des arbres en Prolog :
import/export d'arbres donnés sous la forme de documents XML.

Symboles arithmétiques
les opérateurs arithmétiques usuels en programmation ('+', '-', '*', '/') sont des symboles fonctionnels prédéfinis,
auquels sont associés les règles de la syntaxe infixée à précédences :
on peut les écrire aussi bien en notation fonctionnelle : '+(3, /(5,2))' qu'en notation traditionnelle '3+5/2'.
De cette manière, Prolog connaît des expressions arithmétiques d'allure traditionnelle.
Introduction d'opérateurs supplémentaires
Elle permet d'écrire des termes dans une syntaxe infixée à précédences, à la manière des expressions arithmétiques.
La directive :- op(préc, assoc, [nom])
introduit dansle système (à l'usage du lecteur et de l'imprimeur)
- le nom comme opérateur binaire ou unaire infixé,
- avec préc comme précédence (plus préc est petit, plus elle est forte : celle de '+' est 500, celle de '*' est 400)
- le symbole assoc régissant l'arité et l'association à gauche ou à droite
  - yfx binaire associe à gauche
  - xfy binaire associe à droite
  - fx unaire préfixé
  - xf unaire postfixé
Exemple : introduction de connecteurs booléens pour écrire des termes sous la forme :
non a ou (b imp c) imp a et non b ou (a imp c)

:- op(900, yfx, [imp]) . :- op(800, yfx, [ou]) . :- op(700, yfx, [et]) . :- op(600, fx, [non]) .

Pour combiner harmonieusement ses propres opérateurs avec ceux du système,
il est utile de connaître la table des précédences standard ! Voyez la documentation relative aux opérateurs.
Il est également utile de lire attentivement les règles concernant la redéfinition de ces opérateurs.

Littéraux
Même si leur représentation en machine est la même, il faut bien distinguer les énoncés atomiques des arbres-objets.
- Les littéraux
  sont les énoncés atomiques (indécomposables).
  Ils sont vrais ou faux (part rapport à la base de connaissances du système)
  Ce sont eux-mêmes des termes (dont le symbole-fonction est appelé un prédicat).
  
  Exemple : nom(femme(X), marie) <==> X a une femme nommée Marie (c'est vrai ou faux, suivant la valeur de X)
  ici nom est un prédicat, mais pas femme qui est un symbole fonctionnel.
  Dans les exemples précédents pere, mere, ancetre et id sont des prédicats,
  mais le_pere et la_fille sont des symbole fonctionnels.
- Prédicats prédéfinis et prédicats évaluables
  Certains prédicats sont définis par le programme (p. ex. pere, mere, ancetre et id),
  d'autres sont prédéfinis (prédicats "primitifs"), et certains jouent un rôle particulier
  (on est bien obligé de tricher par rapport à la stricte logique) :
  leur démonstration réussit immédiatement et elle donne lieu à divers effets :
  - write(terme) a pour effet d'envoyer en sortie l'écriture canoniqe du terme-argument
  - nl (sans argument) provoque un saut de ligne
  - tab(terme à valeur numérique) provoque autant de tabulations
  - le prédicat très spécial is, prend deux arguments dont le premier doit être une variable et le second une expression arithmétique;
    il évalue l'expression et affecte sa valeur à la variable.
    Ainsi, en syntaxe normale :
    ?- X is 3+5/2, write(X). 5.5 X = 5.5.
    mais aussi bien en notation fonctionnelle
    ?- is(X, +(3, /(5,2))), write(X). 5.5 X = 5.5.
Clauses de Horn
Les définitions de prédicats prennent la forme d'implications où la conjonction des littéraux du membre droit
entraîne le littéral unique du membre gauche, appelé le littéral de tête.
c :- p₁, p₂, ... , p_k. <==> p₁ ⋀ p₂⋀... ⋀ p_k ⊃ c
On peut les voir comme autant de règles de déduction, dont les littéraux du membre droit sont les prémisses
et le littéral de tête est la conclusion :
[Une règle de déduction est formée d'un nombre fini de prémisses, et d'une seule conclusion (qui sont des formules quelconques).
On l'écrit traditionnellement ainsi

p₁, p₂, ... , p_k <--- les prémisses
----------------
c <--- la conclusion

]
Ce type de formule est appelée clause de Horn (par référence à la forme clausale en logique).
Nous verrons plus tard que ces clauses sont elles aussi représentées comme des termes dont ":-" est le symbole fonctionnel.
Exemple

/* Arbre généalogique, première manière */ ecrire(X, N) :- tab(N), write(X), nl. /* N doit etre entier */ arbgen1(X) :- ecrire(X, 0), genarb1(X, 10). genarb1(X, N) :- genp1(X, N). /* p comme pere */ genarb1(X, N) :- genm1(X, N). /* m comme mere */ genp1(X, N) :- pere(Y, X), ecrire(Y, N), sgenarb1(Y, N). genm1(X, N) :- mere(Y, X), ecrire(Y, N), sgenarb1(Y, N). sgenarb1(X, N) :- M is N + 10 , genarb1(X, M).

Exécution, avec une base de données familiale plus étendue :
pere(jules, cesar). pere(andre, lea). pere(cesar, adrienne). pere(otto, enza). pere(cesar, marc). pere(otto, mara). pere(marc, antoine). pere(marc, paul). mere(silvia, cesar). mere(julie, lea). mere(lea, adrienne). mere(pippa, enza). mere(lea, marc). mere(enza, antoine). mere(enza, paul).

?- arbgen1(paul). paul marc cesar jules silvia lea andre julie enza otto pippa false.

Fonctionnement de base

Paquets de clauses

L'opération élémentaire du calcul de Prolog est la démonstration d'un énoncé atomique, alias littéral.
Pour des raisons historiques on parle de résoudre un littéral.
Il nous faut donc comprendre comment se passe la résolution d'un littéral.

Cette résolution utilise les règles du système (les clauses) dont la conclusion est compatible (unifiable) avec le littéral-but (voir plus tard),
donc en particulier qui ont le même prédicat que le but.

Toutes les clauses relatives au même prédicat sont regroupées en un seul paquet,
où elles sont rangées dans l'ordre du texte-source.

L'ordre des paquets de clauses n'a pas d'importance,
en revanche l'ordre des clauses dans chaque paquet est significatif !

Le zig-zag

À chaque étape, Prolog doit démontrer une liste de buts : il procède de gauche à droite dans cette liste
Pour démontrer chacun de ces buts :

soit p le prédicat du but visé [c-à-d. but = p(....) ]
Prolog essaie les clauses du paquet p dans l'ordre (de haut en bas)
et naturellement, les différents sous-buts qui composent chaque clause sont traités de gauche à droite...

Exemple : résolution du littéral zig(X), avec :

zig(a) :- write('un '), write('deux '), write('trois'), nl. zig(b) :- write('quatre '), write('cinq '), write('six'), nl. zig(c) :- write('sept'), nl, write(fini_pour_zig), nl.

?- zig(X).

un deux trois

X = a

;

quatre cinq six

X = b

;

sept

fini_pour_zig

X = c.

Le séquencement standard avec retour-arrière

Le fonctionnement normal de Prolog lui fait chercher
toutes les démonstrations possibles du but visé.

Ceci le conduit à revenir en arrière après un échec,
pour essayer la clause suivante du paquet.

Ce mécanisme de retour-arrière (backtrack), superposé au "zig-zag"
induit un séquencement complexe :

Exemple : résolution du littéral zigzag(X, Y), avec
zigzag(X, Y) :- zig(X), write('X = '), write(X), nl, zig(Y), write('Y = '), write(Y), nl.

On observe que le littéral le plus à droite zig(Y) a été résolu 9 fois,
et zig(X) 3 fois seulement
[sorte de boucle intérieure sur zig(Y), extérieure sur zig(X) ]

Détail technique : le prédicat `fail`

Pour observer les phénomènes de séquencement, il est fastidieux de devoir taper un point-virgule ";" à chaque résultat.
En outre, l'impression automatique des valeurs des variables vient compliquer la lecture (cf. exemple précédent).
On peut demander à Prolog à épuiser toutes les possibilités en le contraignant à l'échec par le prédicat prédéfini fail
(sans argument), qui échoue toujours - comme son nom l'indique.
Exemple :

 ?- zigzag(X,Y), fail.

un deux trois

X = a

un deux trois

Y = a

quatre cinq six

Y = b

sept

fini_pour_zig

Y = c

quatre cinq six

X = b

un deux trois

Y = a

quatre cinq six

Y = b

sept

fini_pour_zig

Y = c

sept

fini_pour_zig

X = c

un deux trois

Y = a

quatre cinq six

Y = b

sept

fini_pour_zig

Y = c

false.

Interprétation logique du séquencement de base

Les deux dimensions horizontale et verticale d'un paquet de clauses ont deux interprétations bien différentes.

Les lignes horizontales, membres droits des clauses, s'interprètent comme des conjonctions de littéraux.
À la fin du parcours gauche-droite de chaque ligne, tous les littéraux qui la composent ont été démontrés.
- Mais attention ! la conjonction logique est commutative,
  pas le parcours gauche-droite de Prolog ...
La succession verticale des clauses dans le paquet correspond à une disjonction entre les clauses :
chacune d'entre elles indique une manière de démontrer son littéral de tête.
- Mais attention ! la disjonction logique est commutative,
  pas le parcours de haut en bas de Prolog ...

Le coupe-choix
- Idée
  Il arrive souvent quye l'exploration de toutes les possibilités conduise à des calculs inutiles
  voire à des calculs qui bouclent !
  L'idée est d'exprimer à un certain point du calcul que l'on renonce a explorer des possibilités non encore envisagées.
  - Par exemple, pour calculer une fonction, on dira que
    - lorsqu'on a trouvé un résultat, c'est le bon !
    - et qu'il est inutile (voire nuisible) de chercher plus loin.
  On introduit donc le prédicat sans argument "!"(point d'exclamation), dit en anglais "cut" et en français "coupe-choix",
  qui apparaît parmi d'autres littéraux dans les membres droits de clauses, avec l'interprétation suivante :
  
  Lors du parcours gauche-droite d'une liste de buts,
  - lorsqu'on rencontre le cut, il est aussitôt vérifié (comme un"write") et le calcul se poursuit normalement ;
  - mais lorsqu'un retour-arrière se produira, il ne pourra pas remonter pas plus haut que le "!".
    C'est-à-dire que la résolution des littéraux situés à gauche du coupe-choix dans la clause courante ne sera pas reprise,
    et que les clauses suivantes du paquet en cours ne seront pas essayées.
- Exemples de coupe-choix 1
  Nous pouvons ainsi exprimer que, dans la recherche des parents d'un enfant donné, le père est unique,
  de sorte que lorsqu'on l'a trouvé il est inutile de chercher plus loin :
  parentc(E, P, M) :- pere(P, E), !, mere(M, E).
  
  Lors de la résolution du littéral parentc (adrienne, P, M) avec la base de données ci-dessus,
  on obtiendra comme prévu
  P = cesar et M = lea,
  mais l'exploration du paquet de clauses "pere" s'arrêtera à la première,
  tandis que toutes les clauses du paquet "mere" seront successivement essayées.
  
  Si on place le coupe-choix à la fin du membre droit, on rétablit la symétrie entre le traitement du père et celui de la mère :
  parents(E, P, M) :- pere(P, E), mere(M, E) , !.
  
  Application à l'arbre généalogique :
  
  /* Arbre genealogique, deuxieme maniere */ arbgen2(X) :- ecrire(X, 0), genarb2(X, 10). genarb2(X, N) :- genp2(X, N), genm2(X, N). genp2(X, N) :- pere(Y, X), !, ecrire(Y, N), sgenarb2(Y, N). genp2(X, N) :- name(C, "Pere inconnu"), ecrire(C, N). genm2(X, N) :- mere(Y, X), !, ecrire(Y, N), sgenarb2(Y, N). genm2(X, N) :- name(C, "Mere inconnue"), ecrire(C, N). sgenarb2(X, N) :- M is N + 10 , genarb2(X, M).
  
  Exécution, avec la même famille que ci-dessus :
  
  ?- arbgen2(paul). paul marc cesar jules Pere inconnu Mere inconnue silvia Pere inconnu Mere inconnue lea andre Pere inconnu Mere inconnue julie Pere inconnu Mere inconnue enza otto Pere inconnu Mere inconnue pippa Pere inconnu Mere inconnue true.
- Programmation fonctionnelle récursive
  Pour traduire une définition de fonction récursive, lorsque le filtrage ne suffit pas à exprimer la conditionnelle,
  (ce qui est systématiquement le cas lorqu'on travaille sur des entiers)
  on place un coupe-choix à l'entrée de chaque membre droit (sauf pour le dernier, bien entendu !)
  - Cette chère factorielle :
    fac(0, 1) :- !. fac(N, F) :- P is N-1, fac(P, G), F is N*G.
    
    On notera au passage que la définition sans coupe-choix boucle !
  - L'inusable triangle de Pascal :
    bin(P, 0, 1):- !. bin(Q, Q, 1):- !. bin(P, Q, R) :- P1 is P-1, Q1 is Q-1, bin(P1, Q1, R1), bin(P1, Q, R2), R is R1+R2.
  - etc...
- Réalisation de boucles (itératives)
  Il n'y a en Prolog aucune primitive spécialisée pour écrire des boucles.
  Les calculs itératifs sont toujours effectués au moyen de prédicats dont la définition est récursive terminale.
  Il est essentiel que ces prédicats n'empilent pas de points de choix !
  On évitera cet empilement par un coupe-choix bien placé.
  
  Exemple : Lire une liste d'objets terminée par 'F' (exclus)
  liliste([X|S]):- read(X), not X='F', !, liliste(S). liliste([]).
  N.B. "=" en Prolog signifie "unifiable" dans le cas présent cette notion se réduit à l'égalité.
  Sur la négation "not", voir le prochain cours.
  Exécution :
  ?-liliste(X). |: a. |: b. |: c. |: $. X = [a,b,c]

Programmes récursifs sur les listes, plus ou moins réversibles

Exemples de définitions récursives sans coupe-choix
Le filtrage suffit à réaliser le test d'arrêt.
1. element1(E, [E|S]) . element1(E, [X|S]) :- element1(E, S).
  deux utilisations possibles :
  1. element1(a, [b,a,d,a,c]) ---> true (2 fois)
  2. element1(X, [b,a,d]) ---> X=b, X=a, X=d
2. enlever1(E, [E|S], S). enlever1(E, [X|S], [X|T]) :- enlever1(E, S, T).
  quatre utilisations possibles :
  1. enlever1(a, [b,a,c], [b,c]) ---> true
  2. enlever1(a, [b,a,c,a], X)--> X=[b,c,a], X=[b,a,c]
  3. enlever1(a, X, [b,c])--> X=[a,b,c], X=[b,a,c],X=[b,c,a]
  4. enlever1(X, [b,a,d,a,c], [b,d,a,c]) ---> X=a
3. Un générateur de permutations
  permut([], []). permut([A|S], P) :- permut(S, R), enlever1(A, P, R).
  à n'employer que dans un sens :
  ?- permut1([a, b, c], X). X = [a,b,c] ;
  X = [b,a,c] ;
  X = [b,c,a] ;
  X = [a,c,b] ;
  X = [c,a,b] ;
  X = [c,b,a] ;
  false.
  
  N.B. Ce prédicat fait partie de la bibliothèque standard sous le nom de permutation.
4. La concaténation des listes
  concat([], L, L). concat([A|S], L, [A|R]) :- concat(S, L, R).
  Cinq utilisations possibles :
  1. concat([a,b,c], [d,e], [a,b,c,d,e]) ---> true
  2. concat([a,b,c], [d,e], X) ---> X = [a,b,c,d,e]
  3. concat(X, [d,e], [a,b,c,d,e] ---> X = [a,b,c]
  4. concat(([a,b], X, [a,b,c,d]) ---> X = [c, d]
  5. concat(X, Y, [a, b, c]) ---> X=[] Y= [a,b,c], X=[a] Y=[b,c], X=[a,b] Y=[c], X=[a,b,c] Y=[]
  Mais attention ! concat boucle si son premier et son troisième paramètres sont des variables libres !
  Ne demandez donc jamais concat(X, [a, b, c], Y) !
  
  N.B. Ce prédicat fait partie de la bibliothèque standard sous le nom de append.
  Et cette version-là ne boucle jamais !
5. renverser([], []). renverser([A|S], R) :- renverser(S,T), concat(T, [A], R).
  Emploi : renverser([a,b,c], X) ---> X=[c,b,a]
  mais renverser(X, [a,b,c]) boucle ! par rappel à renverser(S,T)
  pour cet emploi il faudrait écrire comme seconde clause
  renverser([A|S], R) :- concat(T, [A], R), renverser(S,T).
  
  N.B. Ce prédicat fait partie de la bibliothèque standard sous le nom de reverse.
6. element2(E, L) :- concat(_, [E|_], L). enlever2(E, L, R) :- concat(D, [E|F], L), concat(D, F, R).
  Attention ! enlever2(a, X, [b,d,c]) boucle ! par appel à concat(D, [a|F], L)
Exemples avec coupe-choix
1. Une modification utile à enlever1 (cf. ci-dessus) :
  on souhaite ôter la première occurrence de l'élément dans la liste, sans aller chercher plus loin.
  On écrira donc :
  enleverp(E, [E|S], S) :- !. enleverp(E, [X|S], [X|T]) :- enleverp(E, S, T).
  signifiant ainsi que la seconde clause ne sera utilisée que si la première n'a pas été filtrée,
  ce qui est bien notre volonté.
  Ex. enleverp(a, [b,a,d,a,c], X). --> X = [b,d,a,c]
2. Autre variante utile de enlever1 : enlever toutes les occurrences "d'un seul coup"
  enlevertout(E, L, R) :- enlever1(E, L, T), !, enlevertout(E, T, R). enlevertout(E, L, L).
  Ex. enlevertout(a, [b,a,c,a,d], X). --> X = [b,c,d]
Les chaînes comme listes de codes ASCII
Une chaîne de caractères entre guillemets doubles est automatiquement convertie pa le lecteur Prolog
en la liste des codes ASCII de ses caractères.
Réciproquement, pour traduire une liste de codes ASCII en chaîne imprimable,
Prolog dispose du prédicat prédéfini name(chaine, liste).
- L'exemple historique des mutants
  Ce fut un programme de démonstration très populaire à Marseille.
  
  /* nonvide(L) vrai si la liste L contient au moins un élément */ nonvide([ _ | _ ]). /* pour mémoire : concat([], L, L). concat([A|S], L, [A|R]) :- concat(S, L, R). */ /* mutant(S) où S est le symbole obtenu par mutation, p.ex. chevalapin */ mutant(S) :- animal(D), animal(F), /* les deux noms qui vont se chevaucher*/ concat(Debut, Milieu, D), nonvide(Debut), nonvide(Milieu), /* décomposition non-triviale de D */ concat(Milieu, _, F), /* chevauchement avec F */ concat(Debut, F, M), /* composition du mutant */ name(S, M). /* pour visualiser */ /* la ménagerie */ animal("ALLIGATOR"). animal("TORTUE"). animal("LAPIN"). animal("CHEVAL"). animal("CARIBOU"). animal("OURS"). animal("PINTADE"). animal("VACHE"). animal("BOUC").
  
  Exécution
  
  ?- mutant(X), write(X),nl, fail. ALLIGATORTUE LAPINTADE CHEVALLIGATOR CHEVALAPIN CARIBOURS CARIBOUC VACHEVAL BOUCHEVAL BOUCARIBOU false.