Initiation à Prolog

Li en e Informatique  Année 20032004

Jean-Paul Comet

Université d'Évry LaMI Département d'informatique

Tour Evry 2, 523 Pla e des terrasses de l'agora 91000 Évry Cedex

e-mail : ometlami.univ-evry.fr

September 12, 2003

Contents
1 Introdu tion 3
1.1 La programmation logique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Les éléments fondamentaux de Prolog . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.1 Les faits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.2 Les questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.3 Les données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.4 Uni ation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.5 Les questions existentielles . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.6 Les faits universels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.7 Les questions onjon tives . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.8 Les règles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.9 Synthèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3 Comment Prolog répond aux questions ? . . . . . . . . . . . . . . . . . . . . . . . 7

2 Résolution en Prolog 8
2.1 Algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2 Ordre des lauses et des buts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3 Arithmitique 11
3.1 Les opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2 Arithmitique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2.1 Prédi at d'évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2.2 Opérateurs de omparaison . . . . . . . . . . . . . . . . . . . . . . . . . . 12

4 Les Listes 14
4.1 représentation des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.2 Quelques opérateurs sur les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

1
 4.3 Exer i es sur les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

5 Les Arbres 16
5.1 Arbres binaires de re her he . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

6 Les Coupures 18
6.1 Fon tionnement de la oupure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
6.2 Coupures vertes, oupures rouges . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
6.3 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
6.4 Negation par e he . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

7 Pour aller plus loin 22

7.1 Les entrées sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
7.2 Les prédi ats prédénis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
7.2.1 Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
7.2.2 Solutions multiples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
7.2.3 Dé omposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
7.2.4 Gestion des lauses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
7.3 Tri de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
7.3.1 Tri par séle tion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
7.3.2 Tri par insertion (ave oupure) . . . . . . . . . . . . . . . . . . . . . . . . 24
7.3.3 Tri à bulle (ave oupure) . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
7.4 Representation des ensembles par des arbres binaires . . . . . . . . . . . . . . . . 25
7.5 Ajout et suppression dans un arbre binaire . . . . . . . . . . . . . . . . . . . . . . 25
7.6 Les graphes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

8 Programmation de Jeux 26
8.1 Les jeux à 2 joueurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
8.2 Le prin ipe minimax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
8.3 L'algorithme alpha-béta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
8.4 Le morpion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.5 Le jeu de Nim . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

9 Utilisation de Prolog 34
10 Les TDs 35
11 Projets divers 48
11.1 Les arbres AVL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
11.2 Les di tionnaires 2-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
11.3 Dérivation symbolique de fon tions . . . . . . . . . . . . . . . . . . . . . . . . . . 48
11.4 Intégration symbolique de fon tions . . . . . . . . . . . . . . . . . . . . . . . . . . 48
11.5 Prin ipe Minimax et alpha-beta . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

2
1 Introdu tion
Cette partie passe en revue les mé anismes de bases de Prolog à travers plusieurs exemples.
Les on epts les plus importants sont introduits dans une forme qui pourra être informelle : les
lauses Prolog, les faits, les règles et les pro édures.

1.1 La programmation logique

Le langage Prolog à été inventé en 1972 par Alain Colmerauer au Groupe d'Intelligen e Arti ielle
de Luminy (Marseille). Les idées de bases remontent aux travaus de Ja ques Herbrand sur la
demonstration automatique età elles de J.A. Robinson sur la méthode de résolution, une règle
d'inféren e logique parti ulièrement bien adaptée au traitement informatique. C'est de là que
Prolog tire son nom : Programmer en logique. Il faut aussi iter Robert Kowalski qui a également
joué un rle important pour la génèse de e langage.
La logique parmet de déduire des onséquen es de ertaines hypothèses. Elle permet aussi de
vérier et d'établir la ohéren e des programmes. D'où l'idée d'utiliser la logique omme langage
de programmation logique, e qui a donné naissan e à la programmation logique.
Idée de la programmation logique:

 énon er des onnaissan es et hypothèses sur un problème donné en tant qu'axiomes est
susant pour trouver la solution au problème.

 résoudre le problème: faire une démonstration à partir de es axiomes.

Prolog :

 programmation dé larative

 programme Prolog : ensemble d'axiomes.

 al ul : d'émonstration d'un énon é à partir du programme. L'algorithme d'élaboration

des preuves étant ommun à tous les programmes.

Ce type de programmation est totalement diérent de la programmation impérative, où on

her he à établir la façon de résoudre un problème en terme de modi ations à apporter à des
données sous forme d'instru tion d'ordinateur.
C'est pour ela que Prolog est un langage adapté au al ul symbolique non-numérique. Il est
parfaitement adapté pour résoudre des problèmes qui font intérvenir des objets et des relations
entre es objets: relations génealogiques par exemple.

1.2 Les éléments fondamentaux de Prolog

1.2.1 Les faits
Dénition 1.1 Un fait est le moyen d'armer, de dé rire des propriétes, de mettre en relation
des objets.
Syntaxe : f(t1,t2,...,tn)
 f est un fon teur d'arité n
 les ti sont les termes

Exemples :

3
 hat(felix). prix(baguette,0.5).
hien(medor). utile( outeau).
plus(1,3,4). frere(thomas, helsea).
pere(bill, helsea). ...
Syntaxe : les identi ateurs de onstantes, relation ou opération sont en minus ule.

Exer i e 1.1 E rire les faits orrespondant à un arbre généalogique.

1.2.2 Les questions

Dénition 1.2 Les questions permettent de poser une question à prolog, pour savoir si un fait
est vérié.

Exemples :

hat(felix)?
yes
hat(mistigris)?
no
pere(bill, moni a)?
no

Exer i e 1.2 Le programme suivant dénit la relation plus d'arité 3 de façon à e que le 3ème
argument soit la somme des 2 premiers.

plus(0,2,2).
plus(0,3,3).
plus(0,4,4).
plus(1,1,2).
plus(1,2,3).
plus(1,3,4).
Que répond Prolog aux 2 questions suivantes: plus(0,1,1)? et plus(1,1,2)?

1.2.2.1 U n but sera noté P, un fait sera noté P. et une question P?.

1.2.3 Les données

Les données sont des termes qui peuvent être :

1. des onstantes

(a) des atomes : haines alphanumériques (+ ara tères spé iaux : +-*/<>=:. ...)
ommen ant par une minus ule, ou s'il y a onfusion ave un autre type, entourée de
'...'.
(b) nombres

2. des variables : haines alphanumériques ommen ant par une majus ule ou par _. La
haine _ est une variable anonyme.

Chaque fois que _ apparait, il s'agit d'une nouvelle vraiable. parent(_,_) est équivalent
à parent(X,Y).

4
 3. des stru tures ou termes omposés : fon teur prin ipal + arguments qui peuvent être
n'importe quelle type de données. p(t1,...tn) est un terme omposé dont p est le fon teur
prin ipal et n l'arité. t1, ... tn sont ses n sous termes.
Exemples :

a 1 onstantes
X Var1 variables
date(J,M,A) donnee stru turee
date(18, sept, 2003) donnee stru turee
numse u(felix,180129100114337) donnee stru turee
point(1,4)
*(+(2,3),-(5,2))

Dénition 1.3 les questions, faits et termes sans variables sont dit de base. Un terme sans
variable est los.

1.2.4 Uni ation

Etant donnés 2 termes, nous dirons qu'ils s'unient si :

1. ils sont identiques

2. les variables omprises dans les 2 termes peuvent être instan iées à des objets de telle
manière qu'après substitution des variables par es objets, les termes deviennent identiques.

Par exemple, date(D,M,2001) et date(D1,may,Y1) s'unient. Une instantiation qui rend les
termes identiques :

 D est instantiée à D1

 M à may

 Y1 à 2001

Prolog é rit :

D = D1
M = may
Y1 = 2001

Dénition 1.4 Xi = ti ℄ où les Xi sont les variables

Une substitution est une liste d'instantiation [
des termes onsidérés, et les ti sont des termes ave les ontraintes : Xi 6= Xj ; 8i; j tels que i 6= j .

Exemple: pour f(X) et f(g(Z)) il existe plusieurs substitutions possibles qui rendent les
termes identiques : [X=g(a),Z=a℄ et [X=g(Z)℄

Dénition 1.5 t1 est une instan e de t2 s'il existe une substitution  telle que (t2) = t1.
Dans e as on dit que t2 est plus général que t1.

Exemple: le terme etudiant(toto,info,adresse(3,bld des oquibus,Evry)) est une in-

stan e de etudiant(X,info,Y).

5
Dénition 1.6 L'uni ation de 2 termes est l'instan e ommune la plus générale des deux ter-
mes. L'opérateur = est l'opérateur d'uni ation.

Exer i e 1.3 Dans ha un des as suivants, dites si les deux termes sont uniables. Si tel est
le as, donner l'uni ateur (rapeller les onventions variables-atomes (majus ule-minus ule)).

1. f(X,g(a,Y),Z et f(h(U, ),g(U,W),k(X))

2. f(X,h(Z),h(X) et f(g(a,Y),h(b)h(Y))
3. f(h(Z),X,h(X)) et f(g(a,Y),h(b),h(Y))
Indi ation: représenter les deux termes sous forme d'arbres et essayer de les superposer.

Exer i e 1.4 Donner un algorithme pour trouver l'uni ateur de 2 termes.

1. Si S et T sont des onstantes, S et T s'unient ssi ils sont le même objet.

2. Si S est une variable, alors les 2 termes s'unient et S est instantié en T. Et ré iproquement.

3. Si S et T sont des stru tures alors S et T s'unient ssi:

 S et T ont le même fon teur prin ipal

 ha une de leurs omposantes s'unient.

L'uni ation est déterminée par l'uni ation de leurs omposantes.

On pourra en n de ours, programmer l'algorithme de l'uni ation en prolog.

1.2.5 Les questions existentielles

Dénition 1.7 Une question existentielle est une question qui omporte une ou plusieurs vari-
ables (elle n'est don pas de base). Les variables sont quantiées existentiellement.

Cher her à savoir s'il existe existe une valeur pour ette variable, 'est her her un fait qui est
une instan e de la question. On représente les solution par la ou les substitutions orrespondant
à ha une des solutions.
Exemple : soit le programme suivant

pere(bill, helsea).
pere(roger,georges).
On peut alors poser des questions existentielles:

pere(bill,X).
X = helsea
pere(X, helsea).
X = bill
pere(X,Y).
X = bill
Y = helsea ;

X = roger
Y = georges ;

6
1.2.6 Les faits universels
Dénition 1.8 Un fait universel est un fait qui ontient une ou plusieurs variables quantiées
universellement.

Exemple : inferieur(0,X). ou alors ouleur hat(nuit,Chat,gris).

1.2.7 Les questions onjon tives

Dénition 1.9 Une question onjon tive est une onjon tion de buts. La onjon tion est notée :
T1 , T2.

Une question simple est une question onjon tive à un seul but.

Dénition 1.10 Une variable partagée est une variable apparaissant dans au moins 2 bits dif-
férents de la question.
La portée d'une variable partagée est toute la onjon tion.

Exer i e 1.5 Faire les questions 1 et 2 du TDs sur l'arbre généaligique.

1.2.8 Les règles

Dénition 1.11 Une règle ou lause est de la forme A B1,B2,...,Bn où

 A, B1, ... Bn sont des buts,

 A est la tête de la règle,

 les B1, ... Bn onstituent le orps de la règle.

Les règles permettent de dénir de nouvelle relations à l'aide des relations déjà existantes.

Exemple-Exer i e : Si les relations homme(), femme() et parent(,) sont déjà dénies, on

dénit les relations pere, mere, grandparent, grandmere, et aieul. Attention à la relation
aieul qui est dénie ré ursivement.

1.2.9 Synthèse
 programme logique = ensemble ni de lauses/règles

 un prédi at p d'arité n est déni par un ensemble de lauses dont la tête est de la forme :
p(t1,t2,...,tn)
 les buts : atomes ou terme omposés.

1.3 Comment Prolog répond aux questions ?

7
2 Résolution en Prolog
2.1 Algorithme
Soit un but G1,...,Gm à résoudre et un programme P.
Algorithme de résolution :

1. hoix d'un sous-but Gi.

Dans la stratégie standard, on hoisit le premier (ie. le plus à gau he).

2. Choix d'une lause H B1,...,Bn du programme P dont la tête s'unie ave Gi.
Dans la stratégie standart, le hoix de la lause H B1,...,Bn se fait suivant l'ordre des
lauses dans le programme.
Soit  l'uni ateur le plus général (mgu : most general unier) de H et Gi.
3. réé riture de G1,...,Gm en leur appliquant 
et en remplaçant Gi par B1,...,Bn :
(G1),...,(Gi-1), (B1),...,(Bn), (Gi+1),...,(Gm).
Le but Gi a été rempla é, éliminé, ea é.

4. Re ommen er les étapes 1,2 et 3 de manière ré ursive ave la nouvelle liste de buts.

5. Si l'exe ution de ette nouvelle liste de buts termine ave su ès, alors terminer l'exe ution
de la liste originale ave su ès.
Sinon, abandonner la nouvelle liste de buts et revenir au dernier point de hoix (Ba ktra k-
ing) et essayer l'uni ation ave une autre lause.

Au départ, il n'y a qu'un seul but : la question qui est posée. On arrive à un su ès si la
liste des buts devient vide. La réponse donnée par Prolog est la om:position des uni ateurs
su essifs.
Exemple : Soit le programme suivant

C1 p(X) :- q(X), r(X).

C2 q(f(X)).
C3 q(b).
C4 r(b).
Faire l'arbre de résolution pour la question p(X).

2.2 Ordre des lauses et des buts

Pour la signi ation dé larative, l'ordre des lauses ou l'ordre des buts n'a pas d'importan e.
En eet, pour l'ordre des buts, la onjon tion est ommutative. Par ontre pour la signi ation
pro édurale, l'ordre est important, ar la re her he des solutions se fait suivant l'ordre des lauses
du programme et suivant l'ordre des buts dans le orps des lauses.
On va don mettre en pla e une stragégie simple pour éviter de tomber rapidement dans une
bran he innie lors de la résolution d'un but. Il s'agit de la règle du plus simple en premier.
Soit le programme suivant :

P1 C1 an etre(X,Y) :- parent(X,Y).
C2 an etre(X,Y) :- parent(X,Z),an etre(Z,Y).

8
 ancetre(michel,nicolas)

C1 C2

parent(michel,nicolas) parent(michel,Z),ancetre(Z,nicolas)

Z=stephane

no ancetre(stephane,nicolas)

parent(stephane,nicolas) parent(stephane,Z),ancetre(z,nicolas)

no no

On hange l'ordre des buts pour obtenir le programme P2.

P2 C1 an etre(X,Y) :- parent(X,Y).
C2 an etre(X,Y) :- an etre(Z,Y),parent(X,Z).
Lors de la résolution du but an etre(mi hel,ni olas), on tombe dans une bran he innie.
ancetre(michel,nicolas)

C1 C2

parent(michel,nicolas) ancetre(Z,nicolas),parent(michel,Z)

C1 C2

no no ancetre(Z1,nicolas),parent(Z,Z1),parent(michel,Z)
C1 C2

Boucle infinie d’Appels récursifs

On inverse maintenant les lauses pour obtenir le programme P3.

P3 C1 an etre(X,Y) :- an etre(Z,Y),parent(X,Z).
C2 an etre(X,Y) :- parent(X,Y).
Ce programme donne la même solution que le programme 1 mais est moins e a e par rapport
à P1, ar il y a plus re re her he et de retour dans l'arbre de résolution.
ancetre(michel,nicolas)

C1 C2

parent(michel,Z),ancetre(Z,nicolas) parent(michel,nicolas)

Z=stephane

ancetre(stephane,nicolas) no

parent(stephane,Z),ancetre(z,nicolas) parent(stephane,nicolas)

no no
Autre exemple sur les listes (à pla er plus tard, ar les listes n'ont pas en ore été vues):

P1 C1 min([X℄,X).
C2 min([E|L℄,E) :- E<X , min(L,X).
C3 min([E|L℄,X) :- X<E , min(L,X).

9
 min([2,1,3],X)

inverser les 2 buts

dans les 2 clauses
2<X,min([1,3],X)

X insuffisamment instancié

Exer i e 2.1 Cet exer i e a pour but de montrer l'importan e de l'ordre des lauses. On on-
sidère le programme suivant dans lequel les prédi ats t1 et t2 sont logiquement équivalents :

C1 p(a,b).
C2 t1(a).
C3 t1(X) :- t1(X), p(X,Y)
C4 t2(X) :- t2(X), p(X,Y)
C5 t2(a).
Montrer que t1(Z) réussit et que t2(Z) é houe.

Exer i e 2.2 E rire an etre de plusieurs façon diérentes (ordre des lauses).

10
3 Arithmitique
3.1 Les opérateurs
Prolog dispose des opérateurs +,-,* et / inxé, préxé et postxé. ils sont onsidérés omme
fon teurs ainsi l'expression 2*3+4*2 est un terme identique à +(*(2,3),*(4,2)).
La notation inxe est simplement la représentation externe du terme, la représentation interne
est la notation préxe, plus pré isement, l'arbre représentatnt le terme.
Pour passer de la représentation interne à la représentation extrene, prolog doit onnaitre
les priorités entre opérateurs : la multipli ation est prioritaire sur l'addition, autrement dit
l'addition a une plus grande pré éden e que la multipli ation. Les onventions de pré éden e
de Prolog sont en a ord ave les les onventions habituelles. Ainsi a+b* est interprété omme
+(a,*(b, )) et non omme *(+(a,b), ).
Le programmeur peut dénir ses propres opérateurs. Le terme opérateur est pas for ement
bien adapté, ar en général, on n'asso ie pas d'a tion à leurs fon teurs asso iés. la dire tive pour
dénir un opérateur est de la forme : :- op(600,xfx,nomOperateur) où

 le niveau de pré eden e est 600 (sur une é helle de 1200 pour la plupart des Prologs)

 xfx est le type de l'opérateur,

 nomOperateur est le nom de l'opérateur.

Le type xfx suggère que l'opérateur, noté par f, est un opérateur inxe pla é entre 2 arguments
notés ha un x. Il y a 3 groupes de types :

 les opérateurs inxes : xfx, xfy et yfx

 les opérateurs préxes : fx et fy

 les opérateurs postxes : xf et yf.

Il y a une diéren e entre x et y. Introduisons d'abord la notion de pré eden e des arguments.
Si un argument est parenthésé, ou s'il s'agit d'un objet non stru turé, sa pré eden e est 0. S'il
s'agit d'un objet stru turé, sa pré éden e est égale à la pré éden e de son fon teur prin ipal. x
représente un argument dont la pré éden e doit être stri tement plus petite de elle de l'opérateur
lui même. y représente un argument dont la pré éden e doit être plus petite ou égale à elle de
l'opérateur.
Exemple. l'expression a - b - est interprétée normalement omme (a - b) - . Pour
arriver à ette interprétation, l'opérateur - doit être déni par yfx

Exer i e 3.1 Redénir les opérateurs suivants: -(unaire),  , **, *,/,+,-.

Exer i e 3.2 Supposons que l'on e rive un programme de manipulation d'expressions booléennes.
On voudrait pouvoir e rire une des loi de Morgan :

:(A ^ B ) () :A _ :B

Une façon d'exprimer ette loi en prolog est la lause equiv(not(and(A,B)),or(not(A),not(B))).

Dénir les opérateurs <==>, v, & et , (A&B)
de telle manière que la loi de morgan s'e rive:
<==>  A v  B .

11
3.2 Arithmitique
3.2.1 Prédi at d'évaluation
Les opérateurs sont : +,-,*,/, **, // (division entière), mod. Prenons un exemple :

?- X = +(1,+(1,1)).
X = 1+ (1+1)
X n'est pas évalué. Pour évaluer il faut utiliser le prédi at d'évaluation is.
?- X is +(1,+(1,1)).
X = 3
?- Z=2, X is 1+1+Z.
Z = 2
X = 4

3.2.2 Opérateurs de omparaison

les opérateurs de omparaisons entre des nombres sont : >, <, >=, =<, =:=, =n= . Les deux
derniers opérateurs sont l'égalité entre 2 valeurs et l'inégalité entre 2 valeurs.
Les opérateurs de omparaisons de termes ( omparaison littérale) sont : ==, n==, <, =<,
.... Ils ne sont pas utilisables sur des entiers. L'ordre de pré éden e est déterminé par l'ordre
alphabétique des fon teurs prin ipaux, et en as d'égalité, des fon teurs les plus à gau he des
sous-termes dans X et Y.

?- 1+a==1+a.
Yes
?- 1+a == a+1.
No
?- A==A.
Yes
?- f(A)==f(A).
Yes
?- f(A)==f(B).
No
?- 1+a =:= 1+a.
ERROR
Exer i e 3.3 Quel est le résultat des requètes suivants :

1. ?- X=2, Y=5, Z=9, T is X*X, Z=T+Y.

2. ?- X=2, Y=5, Z=9, T is X*X, Z is T+Y.
X = 2
Y = 5
Z = 9
T = 4
3. ?- X=2, Y=5, Z=9, T = X*X, Z is T+Y.
X = 2
Y = 5
Z = 9
T = 2*2
Yes

12
Exer i e 3.4 E rire la fon tion fa torielle.

fa t(0,1).
fa t(X,Y) :- 0<X, X1 is X-1, fa t(X1,Y1), Y is X*Y1.

13
4 Les Listes
4.1 représentation des listes
La liste est une stru ture largement utilisée dans la programmation non numérique. Une liste est
une suite d'un nombre ni d'objets, omme par exemple ann,tennis, tom, skiing. En plolog,
une telle liste est réprésentée par
[ann,tennis, tom, skiing℄

Dénition 4.1 Une liste est une suite nie d'objets.

 [℄ est la liste vide.

 le onstru teur est . d'arité 2 : .(X,L) où L est une liste.

 On utilise une autre notation : [X|L℄.

 X est appelé la tête de la liste, L la queue de la liste.

Exemples :

 pour la liste .(ann, .(tennis, .(tom, .(skiing,[℄)))), la stru ture en arbre est la
suivante :
[]

ann tennis tom skiing

 .(1, .(2, .(3,[℄))) est la liste [1,2,3℄ et la liste [1|[2|[3|[℄℄℄℄

 [1,[a,2℄,[1,[1℄℄, [℄℄ est une liste. il n'y a pas detypage omme en Caml.

 [1|2℄ n'est pas une liste. il faut é rire [1,2℄.

Exer i e 4.1 Les listes suivantes sont elles uniables ?

l1=[X | [Y,Z | [a℄℄℄ et l2=[b,X|[Y,W℄℄

l1=[X , Y | [Z℄℄ et l2=[[a,b, ℄℄
l1=[1,2 | [3|[4℄℄℄ et l2=[X | [Y, Z | [W℄℄℄

Exer i e 4.2 Dénir un prédi at qui vérie si une liste est une vraie liste.

vraieliste([℄).
vraieliste([X|L℄) :- vraieliste(L).

Exer i e 4.3 Dénir un prédi at qui vérie si une liste est une vraie liste d'entiers (qui ne
ontient que des entiers).

4.2 Quelques opérateurs sur les listes

Exer i e 4.4 Dénir les prédi ats append, member, prefix, suffix, et reverse.

14
append([℄,Ys,Ys).
append([X,Xs℄, Ys, [X|Zs℄) :- append(Xs,Ys,Zs).

member(X,[X,L℄).
member(X,[Y,L℄) :- member(X,L).

prefix([℄,Ys).
prefix([X,Xs℄,[X,Ys℄) :- prefix(X,L).

suffix(Xs,Xs).
suffix(Xs,[Y,Ys℄) :- suffix(Xs,Ys).

reverse([℄,[℄).
reverse([X,Xs℄,Zs) :- reverse(Xs,Ss),append(Ss,[X℄,Zs).

reverse2(List, Tsil) :- reverse(List,[℄,Tsil).

reverse2([℄,Tsil, Tsil).
reverse2([X|Rest℄,PartReverse,TotalReverse) :-
reverse(rest,[X|PartReverse℄,TotalReverse).

Comparer les omplexités des deux solutions pour reverse.

4.3 Exer i es sur les listes

Exer i e 4.5 Dénir les prédi ats length et somme qui al ulent la longueur d'une liste et la
somme des entiers d'une liste d'entiers. Essayer-les sur [1,2,3,4,5℄ et sur [1,2,[3,4℄,5℄.
length([℄,0).
length([X|L℄,N) :- length(L,M), N is M+1.

somme([℄,0).
somme([X|L℄,N) :- somme(L,M), N is M+X.

Exer i e 4.6 Dénir le prédi at ordered sur une liste de termes d'entiers, sur une liste d'entiers.
ordered([℄).
ordered([Y|[℄℄).
ordered([X,Y|L℄ :- X=< Y, ordered ([Y|L℄).

Exer i e 4.7 Dénir le prédi at sansdoublon qui supprime les doublons dans une liste.

15
5 Les Arbres
Dénition 5.1  Un arbre est une stru ture omposée d'un noeud ra ine et de sous arbres.
Un arbre peut être vide.

 Un arbre binaire est un arbre dont haque noeud a au plus 2 ls : un sous-arbre gau he,
un sous arbre droit.

Exemple :
Dénition de la stru ture :

 arbre(R,G,D)

 vide : arbre vide

Exer i e 5.1 Vérier qu'une stru ture est un arbre.

estarbre(vide).
estartbre(arbre(R,G,D)) :- estarbre(G), estarbre(D).
a a

b vide b 2

vide vide vide vide 3 vide

est un arbre n’est pas un arbre

3 est un entier.

Exer i e 5.2 Appartenan e d'un élément à un arbre.

appartenan e(X,arbre(X,G,D)).
appartenan e(X,arbre(Y,G,D)) :- appartenan e(X,G).
appartenan e(X,arbre(Y,G,D)) :- appartenan e(X,D).

Exer i e 5.3 Par ours d'un arbre, ordre préxe, inxe et postxe.

preordre(vide,[℄).
preordre(arbre(X,G,D),L) :-
preordre(G,LG), preordre(D,LD),append([X|LG℄,LR,L).

postordre(vide,[℄).
postordre(arbre(X,G,D),L) :-
postordre(G,LG), postordre(D,LD),
append([LD℄,[X℄,L1),
append(LG,L1,L).

Exer i e 5.4 Somme des entiers d'un arbre binaire.

16
Exer i e 5.5 Profondeur d'un arbre.

prof(vide,0).
prof(arbre(X,vide,vide),1).
prof(arbre(R,G,D),P) :- prof(G,PG), prof(D,PD),
PG1 is PG+1,
PD1 is PD+1,
max(PD1,PG1,P).

5.1 Arbres binaires de re her he

Un arbre binaire est un arbre binaire de re her he si

 8n, noeud de l'ardre, les éléments du sous arbre G sont inférieurs au noeud père,

 8n, noeud de l'ardre, les éléments du sous arbre D sont supérieurs au noeud père,

 les deux sous-arbres sont eux-mêmes ordonés.

Exemple.

Exer i e 5.6 Dire si un arbre est un arbre binaire de re her he.

Exer i e 5.7 Re her he d'un élément dans un arbre binaire de re her he.

 X = la ra ine, ok

 X<ra ine de l'arbre, re her her dans G

 sinon, re her her dans D

Exer i e 5.8 Insertion dans un arbre binaire de re her he (aux feuilles).

 insertion dans vide donne arbre(X,vide,vide)

 sinon on insere dans le sous arbre en fon tion de l'ordre.

Exer i e 5.9 sous-arbre d'un arbre

Exer i e 5.10 Substituer X par Y dans TX pour obtenir TY

subst(X,Y,vide,vide).
subst(X,Y,arbre(X,L,R),arbre(Y,L1,R1) :-
subst(X,Y,L,L1),
subst(X,Y,R,R1).
subst(X,Y,arbre(Z,L,R),arbre(Z,L1,R1) :-
Z \== X.
subst(X,Y,L,L1),
subst(X,Y,R,R1).

17
6 Les Coupures
Prolog, quand il ne trouve pas de solution, il ee tue automatiquement le b htra king, retour
en arrière jusqu'au dernier hoix ee tuer an d'en faire un autre. Parfois, le ba ktra king est
inutile, ar on sait par avan e que les autres hoix possibles ne pourront pas mener à une solution.
C'est le as lorsqu'on doit exprimer un hoix ex lusif, un
if ondition then ... else ....
e mé anisme peut entrainer une ine a ité du programme.
La oupure est un but parti ulier qui empè he le ba ktra king, et gèle ainsi ertaines alter-
natives dans l'arbre d'ea ement des buts.
Exemple jouet : imprime_pair
C1 imprime_pair(X,Y) :- X<Y, pair(X), print('premier ok').
C2 imprime_pair(X,Y) :- X=Y, pair(X), print('premier ok').
C3 imprime_pair(X,Y) :- X>Y, pair(X), print('premier ok').

pair(0).
pair(X) :- X<0, fail.
pair(X) :- X>0, X2 is X-2, pair(X2).
imprime_impair(1,3)

C1 C3
C2

1<3,pair(1),print() 1=:=3,pair(1),print() 1>3,pair(1),print()

pair(1) echec echec

echec
On aurait pu s'en rendre ompte plus tt puisque les 3 onditions sont ex lusives.

6.1 Fon tionnement de la oupure

La oupure, ou ut, notée !, est un prédi at toujours évalué à vrai. Il sert à empe her le retour
en arrière (ba ktra king), autrement dit, il limite les points de hoix en empe hant ertaines
alternatives de l'arbre de résolution, alternatives dont on siat qu'elle ne menerait à rien. La
oupure élague des bran hes inutiles.
Supposons que le prédi at P soit déni par les lauses :

1- B :- ...
2- B :- B1,...,Bn, !, Bn+1,...,Bp
3- B :- ...
Si on her he à ea er Bn+1, ongèle les alternatives non en ore explorées pour l'évaluation de
B,B1,...,Bn.

18
 (I) (II)

X : marque signalant le noeud père

B,...
du noeud liste des sous buts contenant le cut
C1 C2 C3 (1)

B1,B2,...Bn, ! , Bn+1,...,B’p,...

(2)
Effacement de B1,B2,...,Bn (retours arrièrepossibles)

Unification de B par 1− ! , Bn+1,...,Bp

Evaluation du cut à vrai (marquage de l’arbre)

− gel des alternatives pour eliminer les B1,B2,...,Bk (2)
Bn+1,...,Bp − gel des alternatives pour éliminer G (1)

Si echec pour effacer

les buts Bn+1,...Bp

Retour à XX et
passer à (II) pas d’évaluation de 3

C : A :- B1,...,Bk,!,Bk+1,... Bn
Le but ourant G s'unie ave la tête de C.
Si les B1,...,Bk réussissent, la oupure est exé utée et

 toute autre lause qui s'unie ave G sera ignorée ((1) dans le s héma) : oupure des autres
hoix au niveau de elui qui a introduit la oupure.

 Si Bi, pour i>k e houent, la remontée ne se fait que jusqu'à la oupure. Les autres hoix
restant pour l'élimination de B1,..,Bk sont élagués ((2) dans le s héma).

 si la remontée arrive à la oupure ( .a.d. e he dans l'ea ement de Bk+1,...,bn), alors

ette dernière é houe et la re her he se poursuit ave le dernier hoix fait avant d'unier
G ave la tête de C (II).

Exer i e 6.1 tra er l'arbre de résolution pour la question ?-(a(a). ave le programme

d(X) :- w(X). (b).

d(X) :- p(X),!,s(X). e(a).
d(X) :- v(X). f(b).
a(X) :- b(X),d(X). g(a).
p(X) :- (X). w(b).
p(X) :- e(X). k(b).
p(X) :- g(X). l(b).
s(X) :- k(X). v(a).
s(X) :- l(X).
b(X) :- f(X).
b(X) :- g(X).

6.2 Coupures vertes, oupures rouges

 oupure verte : ne modie pas le sens du programme, 'est à dire l'ensemble
des buts qu'ils permet de démontrer.
 oupure rouge : modie le sens du programme.

19
Exemple :

C1 fusion([℄,L,L).
C2 fusion(L,[℄,L).
C3 fusion([X|Xs℄,[Y|Ys℄,[X|Zs℄) :- X<Y,!,fusion(Xs,[Y|Ys℄,Zs).
C4 fusion([X|Xs℄,[X|Ys℄,[X,X|Zs℄) :- !, fusion(Xs,Ys,Zs).
C5 fusion([X|Xs℄,[Y|Ys℄,[Y|Zs℄) :- X>Y,!,fusion([X|Xs℄,Ys,Zs).

Les 3 lauses sont ex lisives, on ne peut pas avoir simultanément X<Y, X=Y, X>Y. Si un test est
évalué à vrai, la oupure immédiatement après sera évaluée à vrai. Les autres lauses dénissant
fusion ne seront pas utilisées.
Faire le graphe de résolution ave fusion([1,...℄,[2,...℄,L.
Exemple de oupure verte :

minimum(X,Y,X) :- Y >= Y, !.
minimum(X,Y,X) :- Y < Y, !.
min(2,3,Z) min(2,3,3) min(3,2,Z)
X=3
C1 C2 C2 X=2 C1 C2 Y=2
X=2 Y=3 Z=Y
Y=3 X=2
2<=3,! 3<2, ! 3=<2 2<3,!
Z=X Y=3
Z=X
! 2>3,! echec echec yes

Z=X=2 echec
Exemple de oupure rouge :

minimum(X,Y,X) :- Y =< Y, !.
minimum(X,Y,Y).

min(2,3,3) min(3,2,Z)
X=3
C2 X=2 C1 C2 Y=2
Y=3 Z=2
yes 3=<2,! yes

or ce n’est pas le cas...

L’autre version était bonne echec

Exer i e 6.2 E rire un prédi at member qui re her he que la première solution.

member(X,[X|L℄).
member(X,[Y|L℄) :- member(X,L).

member1(X,[X|L℄) :- !.
member1(X,[Y|L℄) :- member1(X,L).

member(X,[a,b, ℄) sans le ut :

20
X=a ;
X=b ;
X= ;
no
ave la oupure :

X=a ;
no

6.3 Exemples
6.4 Negation par e he
Comment exprimer en prolog :  Marie aime tous les animaux sauf les serpents . S'il n'y avait
pas le  sauf les serpents , on é rirait :

likes(marie,X) :- animals(X).
On utilise alors une autre formulation : Si X est un serpent, alors  Marie aime X  n'est pas
vrai, sinon, si X est un animal, alors Marie aime X. Il faut don pouvoir exprimer qu'un but est
faux. Ce i se fait grà e au prédi at fail qui est toujours faux, for ant le but appelant de l'être
aussi. On peut alors trans rire en Prolog :

likes(marie,X) :- snake(X),!,fail.
likes(marie,X) :- animals(X).
ou
likes(marie,X) :- snake(X),!,fail
;
animals(X).
Prolog dénit un prédi at not ou n+ qui a le omportement suivant : si But est vrai alors
not(But) est faux, sinon not(But) réussit. Un but not(But) réussit si Prolog n'arrive pas à
prouver But. On parle de négation par e he .
La dénition de not en Prolog est la suivante :

not(P) :- P,!,fail.
not(P).
Supposons que P est vrai Supposons de P est faux

not(P) not(P)
C1 C2 C1 C2

P,!,fail P,!,fail yes

!,fail echec car P est faux

exécution coupure

fail
echec

21
7 Pour aller plus loin
7.1 Les entrées sorties
 read(X) : lit un terme à partir du ot d'entrée ourant.

 write(X) : E rit sur le ot de sortie ourant le terme X.

 tab(N) : insère N espa e sur le ot de sortie.

 nl : insère un saut de ligne sur le ot de sortie.

 see(file1) :

 seen : ferme le ot d'entrée ourant.

 tell(file2) :

 told : ferme le ot de sortie ourant.

 les ots par défaut sont user pour les ots d'entrée et de sortie.

 l'atom end_of_file est renvoyé si on essaye de lire à la n d'un  hier.

write('fi hier_d_entree_:'),
read(File1),
write(File1),nl,
write('fi hier_de_sortie_:'),
read(File2),
write(File2),nl,
see(File1),read(X),seen,
tell(user),
write(X),nl,
tell(File2),write(X),told,
see(user),
tell(user).

7.2 Les prédi ats prédénis

7.2.1 Type
 integer(X) : réussit si X est instan ié à un entier.

 float(X) : réussit si X est instan ié à un oatant

 number(X) : oat ou integer.

 atom(X) : réussit si X est instan ié à un atome.

 atomi (X) : atom ou number

 var(X) : réussit si X est une variable.

 nonvar(X) : X non variable ou variable instan iée

22
  ompound(X) : réussit si X est un terme omposé.

Exer i e : E rire un prédi at qui ompte le nombre de fois qu'un atome apparait dans une liste
donnée d'objets.

7.2.2 Solutions multiples

 bagof(X,P,L) : produit la liste L de tous les objets X tels que le but P est satisfait. fail si
pas de solutions pour P(...X...)

age(peter,7).
age(ann,5).
age(pat,8).
age(tom,5).
bagof(Child,age(Child,5),List). % List = [ann,tom℄
bagof(Child,age(Child,X),List). %
% X=7 List=[peter℄
% X=5 List = [ann,tom℄
% X=8 List = [pat℄
bagof(Child,X^age(Child,X),List).
% génère une seule liste indépendemment de l'age
% List=[peter,ann,tom,pat℄

 setof : produit une liste triée sans doublon, ordre du tri : <.
 findall(X,P(...X...),List) : liste de tous les objets X, independemment des dierentes
solutions pour les autres variables de P.

7.2.3 Dé omposition
 Term =.. [Fon teur|ArgList℄ : Term =.. L est vrai si L est une liste dont le premier
élément est le fon teur de Term suivi de ses arguments.

 fun tor(Term,Fun tor,Arity) : vrai si Fun tor est le fon teur de Term et si Arity est
l'arité de Term.

 arg(N,Term, A) : A = n-ième argument de Term

 name(Atom,ListeDesCodesAs ii) : liste des odes as ii des lettres qui ompose l'atome.

 all(Goal) : lan er l'évaluation d'un but.

Exer i e : E rire un prédi at qui demande le fon teur puis les arguments de e fon teur et qui
le teste.

7.2.4 Gestion des lauses

 assert(T) : ajoute T à la base de données (après tous prédi at de même dénomination et
ne même arité).

 asserta(T) : idem mais avant tout autre prédi at de même nom.

23
  assertz(T) : idem mais après tout autre prédi at de même nom.

 retra t(F) : ea e le fait F de la base de données. E houe s'il n'y a pas e but. Si on
utilise des variable, prolog ea e le premier but qui s'unie ave F.

7.3 Tri de listes

7.3.1 Tri par séle tion
Cher her le maximum de la liste, trier le reste et mettre le maximum en tête de la liste. Cet
algorithme donne une liste triée par ordre dé roissant.

% renvoie le maximum entre 2 nombres

max(X,Y,X) :- X >= Y.
max(X,Y,Y) :- X < Y.

% renvoie le maximum d'une liste

maxliste([X℄,X).
maxliste([X,Y|Rest℄,Max) :- maxliste([Y|Rest℄,M1), max(X,M1,Max).

% supprime un element d'une liste

supprime(X,[X|L℄,L).
supprime(X,[℄,[℄).
supprime(X,[Y|L℄,[Y|L2℄) :-
X\==Y, supprime(X,L,L2).

% tri par sele tion

trimax([℄,[℄).
trimax(L,[X|L2℄) :-
maxliste(L,X),
supprime(X,L,L1),
trimax(L1,L2).

7.3.2 Tri par insertion (ave oupure)

L'idée est de trier d'abord la queue de la liste puis d'inserer à la bonne pla e la tête de la liste
dans la liste triée.

% tri par insertion

triinsertion([℄,[℄).
triinsertion([X|Q℄,T) :- triinsertion(Q,QT),inserer(X,QT,T).

inserer(X,[Y|L1℄,[Y|L2℄) :-
X > Y, ! , inserer(X,L1,L2).
inserer(X,T,[X|T℄).

7.3.3 Tri à bulle (ave oupure)

Trouver 2 éléments adja ents X et Y tels que X>Y. E hanger X et Y pour obtenir L1. Trier L1.
Si au un X>Y adja ents trouvé, alors L est triée.

24
% tri a bulle
tribulle(L,T) :-
e hange(L,L1), ! , tribulle(L1,T).
tribulle(T,T).

e hange([X,Y|R℄,[Y,X|R℄) :- Y<X.
e hange([Z|R℄,[Z|R1℄) :- e hange(R,R1).

7.4 Representation des ensembles par des arbres binaires

7.5 Ajout et suppression dans un arbre binaire
7.6 Les graphes

25
8 Programmation de Jeux
Nous allons onsidéré des te hniques pour jouer à des jeux tels que les e he s : 2 joueurs
s'arontent et haque situation peut être dé rite parfaitement (pas d'aléatoire).
Cependant, pour les jeux intéressants les arbres omplets des futurs possibles sont trop om-
plexes pour permettre une re her he exhaustive. On peut alors développer une appro he heuris-
tique basée sur le prin ipe minimax, et qui peut être impléméntée de manière e a e dans
l'algorithme dit alpha béta.

8.1 Les jeux à 2 joueurs

Les jeux onsidérés sont les jeux dans lesquels 2 joueurs sarontent, haque joueur modiant
la situation du jeu ha un son tour de manière alternative. De plus ha un des joueurs onnaît
la totalité de l'information de la situation ourrante du jeu (pas d'information a hée). Cette
dernière remarque ex lue don la majorité des jeux de artes.
Le jeu se termine lorsque une ertaine situation est atteinte, situation que l'on qualie de
terminale. Les règles du jeux donnent les diérents transitions entre les situations possibles
(graphe d'états).
Ces jeux peuvent être représentés par des arbres de jeu. Les n÷uds orrespondent aux
situations et les ar s aux dépla ements possibles. La situation est la ra ine de l'arbre, les feuilles
aux états terminaux.
Dans la majorité des jeux les situations terminales sont du type : gagné, perdu, ou aléatoire.
Nous ne onsidèrerons que les 2 premières possibilités. On appellera les 2 joueurs nous et eux.
L'un des joueurs peut gagner dans une position non terminale s'il existe un dépla ement qui le
mène à une position treminale gagnante. De manière presque similaire, une jour peut perdre à
une position non terminale, si tous les dépla ements possibles le mènent à des positions perdantes.
Prin ipe :

won(Pos) :- terminalwon(Pos).
won(Pos) :- not terminallost(Pos),
move(Pos,Pos1),
not( move(Pos1,Pos2), not won(Pos2)).
Ce prin ipe repose sur une re her he en profondeur d'abord, et n'empè he pas les y les.
Mais omme il s'agit d'une re her he en profondeur, elle ne donne pas de bons résultats pour
les jeux un peu ompliqués où l'arbre est grand (e he s). Si on onsidère qu'à une position du
jeu donnée, il y a 30 su esseurs possibles, et que le jeu se joue en 80 dépla ements, on arrive à
un arbre ave environ 10
120 (impossible).

Jeu de nim : Cependant pour des jeux omme le nim, ette appro he est possible.
Des ription du jeu :
Sur un plateau de jeu sont disposées des rangées d'allumettes. Si nous numérotons les rangées de
0 à N, haque rangée ontient 2*k+1 allumettes où k va de 0 à N. A tour de rle, ha un des 2
joueurs hoisit une rangée dans laquelle il prélève le nombre d'allumettes de son hoix (maximum
3). Le gagnant est elui qui retire la dernière allumette.
Position de départ :
Au départ, le programme vous demandera de hoisir le nombre initial d'allumettes, les allumettes
seront rangées dans une pyramide omme l'illustre la gure 1.
Déroulement du jeu :

26
A tour de rle, le joueur Humain (vous) et le joueur Ordinateur (votre ordinateur) vont prendre
un ertain nombre d'allumettes dans un même tas. Fin de la partie :
La partie s'a hève lorsqu'un joueur prend la dernière allumette, il a alors gagné et son adversaire
a perdu.

Cadre General pour jouer a un jeu :

play(Game) :-
initialise(Game,Position,Player),
affi her(Position,Player),
play(Position,Player,Result).

play(Position,Player,Result) :-
game_over(Position,Player,Result),!,announ e(Result).

play(Position,Player,Result) :-
hoose_move(Position,Player,Move),
move(Move,Position,Position1),
affi her(Position1,Player),
next_player(Player,Player1),!,
play(Position1,Player1,Result).

Choisir le meilleur mouvement:

evaluate_and_ hoose([Move|Moves℄,Position,Re ord,BestMove) :-

move(Move,Position, Position1),
value(Position1,Value),
update(Move,value,re ord,Re ord1),
evaluate_and_ hoose(Moves,Position,Re ord1,BestMove)
evaluate_and_ hoose([℄,Position,(Move,Value),Move).

update(Move,Value,(Move1,Value1),(Move1,Value1)) :-
Value <= Value1.
update(Move,Value,(Move1,Value1),(Move,Value)) :-
Value > Value1.

Il faut en fait anti iper sur plusieurs mouvements, et les arbres de re her he sont parfois trop
omplexes pour pouvoir etre par ouru exhaustivement.

8.2 Le prin ipe minimax

la solution hoisie est une exploration partielle de l'espa e  représenté sous forme d'arbre ou
plutt de graphe orienté sans y le (DAG)  et pour une profondeur déterminée. De e fait on
est amené à introduire une fon tion d'évaluation qui, pour les é he s, dépend des piè es et de la
mobilité du jeu omme par exemple :

S ore = Matériel + (Coe ient * Mobilité)

D'autre part, il est évident que plus la fon tion d'évaluation sera omplexe, plus le temps de
al ul sera important, et moins il sera possible d'étudier de oups en un laps de temps donné.

27
Les programmes lassiques re her hent dans l'arbre le meilleur oup possible en fon tion de la
réplique de l'adversaire et e jusqu'à une ertaine profondeur de l'arbre.
Cette pro édure est onnue sous le nom de MINIMAX. À haque niveau de l'arbre orrespond le
joueur qui doit jouer. À une situation donnée orrespond un ensemble de oups possible, souvent
appelés légaux, à haque oup est asso ié un noeud ave sa valuation (dépendant de la fon tion
hoisie). La pro édure her he dans l'arbre la bran he la plus valuée asso iant à l'adversaire une
valuation négative.

4 MAX
a

4 MIN 1 MIN
b c

4 MAX 6 MAX 2 MAX 1 MAX

d e f g

1 4 5 6 2 1 1 1 MIN

Les valeurs de la fon tion d'évaluation sont al ulées à partir de l'état du jeu al ulé pour
ha un des hemins possibles. Les valeurs pour les n÷uds internes sont propagées du bas vers le
haut : une fois en prenant le maximum de tous les ls, une autre fois en prenant le max.

% D : profondeur
% MaxMin : Flag pour prendre le min ou le max

evaluate_and_ hoose([Move|Moves℄,Position,D,MaxMin,Re ord,BestMove) :-

move(Move,Position, Position1),
minimax(D,Position1,MaxMin,MoveX,Value),
update(Move,Value,Re ord,Re ord1),
evaluate_and_ hoose(Moves,Position,D,MaxMin,Re ord1,BestMove)
evaluate_and_ hoose([℄,Position,D,MaxMin,Re ord,Re ord).

minimax(0,Position,MaxMin,Move,Value) :-
value(Position, V),
Value is V*MaxMin. % si fon tion symetrique
minimax(D,Position,MaxMin,Move,Value) :-
D>0,
setof(M,move(Position,M), Moves),
D1 is D -1,
MinMax is 0-MinMax,
evaluate_and_ hoose(Moves,Position,D1,MinMax,(nil,-1000),(Move,Value)).

update(Move,Value,(Move1,Value1),(Move1,Value1)) :-
Value <= Value1.
update(Move,Value,(Move1,Value1),(Move,Value)) :-
Value > Value1.
En pratique et algorithme est outeux en temps, le nombre de solutions augmentant expo-
nentiellement ave la profondeur de l'arbre. C'est pourquoi, on utilise la te hnique de AlphaBéta
fondée sur le fait que ertaines bran hes onduisent à des situations pires ou identiques à elles
déjà étudiées.

28
8.3 L'algorithme alpha-béta
Il n'est pas ne essaire de onnaître exa tement de ombien la meilleure bran he l'est. Il sut de
savoir que 'est la meilleur. Pour reprendre le pré édent exemple, on par ourt l'arbre : a,b,d, les
su esseurs de d. La valeur de d est don 4. On redes end en e. Pour le premier su esseur de e,
on trouve une valeur de 5. On en déduit don que quelque soit la valeur des autres su esseurs
de e, la valeur de e sera au moins égal à 5, don sera supérieure à 4. Don pour prendre le
minimum des su esseurs de b, on peut s'arreter au premier su esseur de e. La valeur de e est
approximée, elle est même fausse, mais ela n'aura pas d'inuen e au niveau supérieur.
De la même manière, seul le premier su esseur de est évalué.
Cette idée est formalisée en introduisant 2 bornes : alpha et beta aux valeurs de remontée
dans l'arbre. alpha est la valeur minimale que MAX est sûr d'atteindre (en fon tion des sous-
arbres déjà par ourus). beta est la valeur maximale que MAX peut espérer atteindre. Du point
de vue de MIN, beta est la plus mauvaise valeur pour MIN que MIN est sûr d'atteindre.
La valeur à trouver est omprise entre alpha et beta. Si une position a une valeur qui est
en dehors de l'intervalle, il n'est pas ne essaire de la al uler exa tement. Si la valeur est dans
l'intervalle, il faut la al uler exa tement.

% D : profondeur
% MaxMin : Flag pour prendre le min ou le max

evaluate_and_ hoose([Move|Moves℄,Position,D,Alpha,Beta,Move1,BestMove) :-
move(Move,Position, Position1),
alphabeta(D,Position1,Alpha,Beta,MoveX,Value),
Value1 is 0 - Value,
utoff(Move,Value1,D,Alpha,Beta,Moves,Position,Move1,BestMove).
evaluate_and_ hoose([℄,Position,D,Alpha,Beta,Move,(Move,Alpha)).

alphabeta(0,Position,Alpha,Beta,Move,Value) :-
value(Position, Value).
alphabeta(D,Position,Alpha,Beta,Move,Value) :-
setof(M,move(Position,M), Moves),
Alpha1 is 0 -Beta,
Beta1 is 0 -Alpha,
D1 is D -1,
evaluate_and_ hoose(Moves,Position,D1,Alpha1,Beta1,nil,(Move,Value)).

utoff(Move,Value,D,Alpha,Beta,Moves,Position,Move1,(Move,Value)) :-
Value >= Beta.
utoff(Move,Value,D,Alpha,Beta,Moves,Position,Move1,BestMove) :-
Alpha < Value, Value < Beta,
evaluate_and_ hoose(Moves,Position,D,Value,Beta,Move,BestMove).
utoff(Move,Value,D,Alpha,Beta,Moves,Position,Move1,BestMove) :-
Value <= Alpha,
evaluate_and_ hoose(Moves,Position,D,Alpha,Beta,Move1,BestMove).

Le prédi at uto soit arrete l'exploration de la bran he ourante, soit ontinue l'exploration
mettant à jour la valeur d'alpha et du meilleur mouvement ourant, selon e qui est approprié.

29
8.4 Le morpion
À titre d'exemple nous proposons l'étude du ti -ta -toe version simpliée du morpion jeu bien
onnu des ly éens. Le ti -ta -toe se joue à deux joueurs sur un damier 3x3. Le but étant d'aligner
3 pions de sa ouleur symbolisée par X et O. Au départ le trait est à X. La partie se termine soit
lorsque les 9 oups ont été joués, soit s'il y a un gagnant.

Grâ e à la pro édure d'alpha-béta on onstate qu'au niveau 1 de la gure ??, seuls les as A,
B et C sont distin ts, les six autres as peuvent être obtenus par rotation de B ou C. De A on
aboutit à trois as distin ts, de B ou C inq oups diérents peuvent être joués par O. Ce qui
réduit l'arbre de 9! (soit 362880) noeuds en théorie à (2+5+5)*7! (soit 60480). Imaginons une
autre situation où l'espa e de re her he est valué par une ertaine fon tion de oût, omme dans
la gure ??.

On suppose, dans et exemple, que la profondeur d'exploration maximale est xée à trois.
On évalue les situations aux feuilles, et on suppose que l'adversaire utilise la même fon tion de
oût et que, e faisant, il her he lui aussi à maximiser son gain, don à minimiser le vtre. Cette
idée est dûe à Os ar Morgenstern et John Von Neumann (1945).
Si on évalue les gains possibles à partir des quatre oups jouables A, B, C et D en ae tant
un oe ient négatif pour le joueur Lui, on trouve:

 A 3, 5, 7

 B 3, 6

 C 3

 D 9, 9, -1

Il faut alors hoisir la solution qui onduit au gain maximum tout en évitant une perte trop
importante. De façon évidente on voit que le hoix C est moins bon que les hoix A et B  le
plus mauvais s ore est le même dans les trois as, mais pas l'espéran e de gain. La situation D

30
est la plus juteuse, mais aussi la plus risquée. Le programme se doit don de onnaître la for e
de son adversaire, et utiliser des méthodes de la théorie des jeux (se rapporter aux ours sur les
probas et autres...).
Du fait d'une profondeur d'exploration limitée, l'ordinateur est sujet à l'eet d'horizon, que
l'on peut traduire approximativement par : un oup peut être optimal à la profondeur n, mais
pas à la profondeur n+k, k>0. De plus es programmes jouent au  oup par oup, 'est-à-dire
qu'il re al ule des solutions, non seulement entre deux parties, mais aussi entre deux traits. En
fait ils utilisent e que l'on appelle la for e brute, 'est-à-dire leur puissan e de al ul, plutt
qu'une quel onque aptitude à raisonner. Ce type de programmes arrive à battre entre 80% et
90% des joueurs.
Sur des ma hines plus puissantes, outre les fon tionnalités pré édentes, les programmes peu-
vent élaguer l'arbre d'évaluation en élaborant des plans, omme dans le as des é he s essayer
d'attaquer une piè e non défendue ou en ore réaliser une four hette. Dans e as, seules
les bran hes pertinentes pour l'aboutissement du plan sont évaluées. Ce type de programme
s'apparente alors aux Systèmes Experts.

8.5 Le jeu de Nim

1. Représentation du jeu : liste d'entier où les éléments de la liste orrespondent à des tas
d'allumettes. Un mouvement est un ouple (N,M) pour prélever M allumettes du tas N.

move((K,M),[N|Ns℄,[N|Ns1℄) :-
K>1, K1 is K-1, move((K1,M), Ns,Ns1).
move((1,N),[N|Ns℄,Ns).
move((1,M),[N|Ns℄,[N1|Ns℄) :- N>M, N1 is N - M.

2. initialisation :

initialize(nim,[1,3,5,7℄,humain).
game_over([℄,Player,Player).
next_player(humain,ordinateur).
next_player(ordinateur,humain).
affi hage(Position,X) :- write(Position),nl.
announ e( omputer) :- write('vous avez gagne...'),nl.
announ e(humain) :- write('j ai gagne...'),nl.

3. Mouvement du joueur :

hoose_move(Position,humain,Move) :-
writeln(['Please make move'℄,
read(Move).

4. Stratégie pour l'ordinateur : Elle onsiste à partager les états du jeu en 2 lasses : la lasse
des états sûrs et elle des états pas sûrs. Pour al uler la lasse d'un état, on al ule la

31
 représentation binaire du nombre d'allumettes de haque tas. La somme de nim est al uler
omme suit: on fait la somme modulo 2 de haque olonne indépendemment. Si le total
de haque olonne est 0, alors la position est sûre. sinon elle n'est pas sûre.

Exemple pour l'initialisation. Les représentations binaires de 1,3,5,7 sont 1, 11, 101, 111.
Il y a 4 1 dans la olonne de droite, don la somme vaut 0 mod 2. Pour la olonne des
2, il y en a 2, don en ore 0, pour la olonne des 4, il y en a aussi 2, don 0 mod 2. La
situation [1,3,5,7℄ est don sûre.

La stratégie gagnante est de laisser toujours la position sûre. Toute position pas sûre
peut être onvertie en une position sûre, alors que tout mouvement à partir d'une position
sûre en rée une pas sûre. La meilleure stratégie est de faire un mouvement arbitraire
lorsque l'on est onfrontée à une situation sûre en espérant un faux pas de l'adversaire et
de onvertir des positions pas sûres en position sûres.

Pour mettre en oeuvre ette stratégie, il faut un algorithme pour al uler la somme de nim,
et un autre pour déterminer un mouvement d'une position pas sûre en une position sûre.
Si la position est sûre, alors prendre une allumette du 1er tas et espérer, sinon, onvertir
la position pas sûre en position sûre.

hoose_move(Ns,ordinateur,Move) :-
unsafe(Ns,Sum),safe_move(Ns,Sum,Move).
hoose_move(Ns,ordinateur,(1,1)) :-
safe(Ns).

5. le prédi at unsafe:

unsafe(Ns,Sum) :- nim_sum(Ns,[℄,Sum),not zero(Sum).

safe(Ns) :- not unsafe(Ns,Sum).

nim_sum([N|Ns℄,Ns,Sum) :-
binary(N,Ds),nim_add(Ds,Bs,Bs1),nim_sum(Ns,Bs1,Sum).
nim_sum([℄,Sum,Sum).

nim_add(Bs,[℄,Bs).
nim_add([℄,Bs,Bs).
nim_add([B|Bs℄,[C|Cs℄,[D,Ds℄) :-
D is (B+C) mod 2,
nim_add(Bs,Cs,Ds).

binary(1,[1℄).
binary(N,[D|Ds℄) :-
N>1, D is N mod 2,
N1 is N / 2,
binary(N1,Ds).

de imal(Ds,N) :- de imal(Ds,0,1,N).
de imal([℄,N,T,N).
de imal([D|Ds℄,A,T,N) :-

32
 A1 is A+D*T,
T1 is T*2,
de imal(Ds,A1,T1,N).

zero([℄).
zero([0|Zs℄) :- zero(Zs).

safe_move(Piles,NimSum,Move) :-
safe_move(Piles,NimSum,1,Move).
safe_move([Pile|Piles℄,NimSum,K,(K,M)) :-
binary(Pile,Bs), an_zero(Bs,NimSum,Ds,0), de imal(Ds,M).
safe_move([Pile|Piles℄,NimSum,K,Move) :-
K1 is K+1,
safe_move(Piles,NimSum,K1,Move).

an_zero([℄,NimSum,[℄,0) :- zero(NimSum).
an_zero([B|Bs℄, [0|NimSum℄,[C|Ds℄,C) :-
an_zero(Bs,NimSum,Ds,C1).
an_zero([B|Bs℄, [1|NimSum℄,[D|Ds℄,C) :-
D is 1 - B*C,
C1 is 1 - B,
an_zero(Bs,NimSum,Ds,C1).

33
9 Utilisation de Prolog
1. lire un programme :
?- onsult(fi hier). ave ou sans extension, dépend des versions
?- [fi hier℄.
?- onsult(ListeDeFi hiers).
?- [fi hier1,fi hier2,...℄.

2. ?- ompile(f). plus rapide

3. ?- help(predi at).
4. ?- read(Term).

5. ?- write(Term).
6. ?- nl.
7. Debugger :

 tra e : tra e exhaustive des buts qui suivent.

 notra e :

 spy(P) : tra e seulement le prédi at P, pas de tra e des prédi ats appelés en dessous
ou au dessus de P.

 nospy(P) :

34