Documentation PrologIII Manuel PdfA

$%"!$%&'$*)#$&$%$(%$"" $'% !&**%)-%%"&"!

!' %!"!%'&&"!$%'$!&$!&'#$!& #%
+
"!&&%%"&"!#$""$&"$
Aociation
Prolog
HERITAGE
Prolog III
Version 1.3
Dcembre 1991
PrologIA
Aociation
Prolog
HERITAGE
Garantie et responsabilits
PrologIA n'offre aucune garantie, expresse ou tacite, concernant ce manuel ou le
logiciel qui y est dcrit, ses qualits, ses performances ou sa capacit satisfaire
quelque application que ce soit.
PrologIA ne pourra tre tenue responsable des prjudices directs ou indirects, de
quelque nature que ce soit, rsultant d'une imperfection dans le programme ou le
manuel, mme si elle a t avise de la possibilit que de tels prjudices se
produisent. En particulier, elle ne pourra encourir aucune responsabilit du fait
des donnes mmorises ou exploites, y compris pour les cots de rcupration ou
de reproduction de ces donnes.
L'acheteur a toutefois droit la garantie lgale dans les cas et dans la mesure
seulement o la garantie lgale est applicable nonobstant toute exclusion ou
limitation.
Droits d'auteur
Ce manuel et le logiciel qu'il dcrit sont protgs par les droits d'auteur. Au
terme de la lgislation traitant de ces droits, ce manuel et ce logiciel ne peuvent
tre copis ou adapts, en tout ou en partie, sans le consentement crit de
PrologIA, sauf dans le cadre d'une utilisation normale ou pour faire une copie de
sauvegarde. Ces exceptions n'autorisent cependant pas la confection de copies
l'intention d'un tiers, que ce soit ou non pour les vendre.
Prolog III est une marque dpose de PrologIA.
Dcembre 1991
PrologIA
Aociation
Prolog
HERITAGE
Prambule
Flicitations ! Vous avez entre les mains le leader d'une nouvelle

gnration de langages de programmation en logique : Prolog III. Ce
langage s'appuie sur le concept nouveau de programmation logique par
contraintes. Si on y retrouve, bien sr, les principes gnraux qui ont fait de
Prolog le langage de programmation phare de l'Intelligence Artificielle,
Prolog III reprsente surtout une refonte totale du cur mme du langage,
l'unification. Ceci se traduit par une manipulation plus fine des arbres, finis et
infinis, qui demeurent les objets principaux utiliss par le langage, mais
galement par la gnralisation de la notion fondamentale, et seulement
bauche dans Prolog II, de rsolution de contraintes. C'est grce cette
notion que l'on peut, en Prolog III, dgager une approche du traitement
numrique et du traitement de l'algbre de Boole fondamentalement
diffrente des essais qui ont t tents dans ces domaines par l'adjonction de
prdicats valuables multiples et fort loigns de la philosophie de base.
Prolog III permet donc de poser des systmes d'quations et inquations
portant sur des nombres rels ou rationnels en prcision parfaite, de traiter
des formules en logique propositionnelle complte, et de rsoudre un certain
nombre de contraintes portant sur les arbres et les listes.
Ce remaniement profond, et la puissance qui en dcoule, ne sont cependant pas gratuits. Le cur de l'interprte est cinquante fois plus gros que
celui de Prolog II, et le pari de s'attaquer des problmes exponentiels,
comme le traitement de l'algbre de Boole ou la simplification de systmes
d'quations linaires, amne parfois des dconvenues du point de vue des
temps d'excutions. Il faut donc rester conscient du fait que la puissance
d'expression du langage voile parfois la complexit de la rsolution qui en
dcoule.
PrologIA
Aociation
Prolog
HERITAGE
Terminons ce premier contact en esprant que vous apprcierez la

programmation en Prolog III, et que vous serez aids en cela par ce manuel.
Nous avons tent d'y dcrire, mais surtout de commenter et d'expliquer les
nombreuses notions nouvelles qui font de Prolog III un langage qui se
dmarque fondamentalement des autres Prolog. Ce souci de produire un
discours la fois prcis dans les fonctionnalits et didactique dans les
concepts nous conduit, de fait, considrer ce manuel comme une premire
tape. Et il nous apparat vident que seuls votre aide, vos remarques et vos
critiques nous permettrons de rellement faire voluer cette documentation
vers un outil dont l'ambition est de vous amener pntrer jusque dans ses
moindres dtails un langage qui initialise une nouvelle tape de la
programmation logique.
En attendant vos critiques et remarques, nous vous souhaitons beaucoup
de satisfactions avec Prolog III.
Les auteurs
PrologIA
Aociation
Prolog
HERITAGE
Diffrences entre la version 1.2

et la version 1.3
Cette nouvelle version de Prolog III apporte un certain nombre de

modifications par rapport la version prcdente. Bien sr, les bogues
connus ont t corrigs, et certaines lacunes de la documentation combles.
Nous remercions ce propos tous ceux qui ont eu la gentillesse de nous
faire part de ces imperfections. Mais l'objectif essentiel de cette refacture est
l'implantation d'un dbogueur symbolique que nous n'hsiterons pas
appeler debugger dans tout le manuel !
Cette nouvelle version voit galement l'introduction de nouvelles
primitives numriques.
Il est maintenant possible de rcuprer et traiter les erreurs se produisant
en cours d'excution, par l'extension des primitives block et block_exit.
En ce qui concerne les rgles prdfinies et procdures externes, nous en
avons ajout de nouvelles, ou parfois mieux document d'anciennes. Voici la
liste de ces primitives, qui sont dcrites en dtail dans le chapitre rserv
cet effet.
Ont t ajoutes ou tendues :
'!'
minimize(R)
block(...)
minimum(R1,R2)
block_exit(...)
no_debug
break(S1)
no_spy(<I,A>)
break(S1,S2)
no_spy(S)
debug
set_config(S,N)
lower_bound(R1,R2)
spy(<I,A>)
maximize(R)
spy(S)
maximum(R1,R2)
upper_bound(R1,R2)
PrologIA
Aociation
Prolog
HERITAGE
Des primitives numriques plus performantes pour l'optimisation de

problmes linaires (minimize, maximize) sont introduites.
Les primitives min_value, max_value sont dsormais obsoltes1 et
remplaces par minimum, lower_bound, maximum, upper_bound .
Le prdicat cut a t retir de cette version : '!' doit tre utilis la place.
De nouveaux messages d'erreur ont t introduits, dont en particulier "Fin
de fichier", et "Fin de fichier inattendue". Ceci afin de permettre une
meilleure prise en compte des erreurs de lecture.
Signalons au programmeur que, par dfaut, la tentative d'effacement d'une
rgle non-dfinie ou d'un but non-excutable affiche un avertissement sur la
console. L'option "undefined_rule" du prdicat set_config est maintenant
positionne "warning" .
Le manuel de la version 1.3 se prsente sous la forme d'un classeur et deux
cahiers spars, un pour le manuel d'utilisation, un autre pour la mise au
point de programmes (debugger).
Pour conclure ce prambule, rappelons que nous restons toujours ouvert
toutes les remarques que vous pourrez faire au sujet du logiciel ou de cette
documentation, et que nous tenterons de rpondre le mieux possible vos
suggestions ou critiques ventuelles.
PrologIA
Parc Technologique de Luminy - Case 919
13288 Marseille Cedex 09 - FRANCE
Tl. : + (33) 91 26 86 36
Fax : + (33) 91 41 96 37
e-mail (net) : prolia@dcftlx.das.net
e-mail (net) : prolia@tlxf.geomail.org
Telex : Prolog 403 527 box : PrologIA
1 Et seront retires ds la version 1.4
PrologIA
Aociation
Prolog
HERITAGE
Table des matires
Manuel de rfrence
Prambule................................................................................................................i
Diffrences entre la versionn 1.2 et la version 1.3....................................... iii
Introduction........................................................................................................... 1
Dbuter avec Prolog III ...................................................................................... 5
1. Dmarrer une session Prolog III......................................................... 6
2. Utilisation dun programme dexemple.............................................8
Chargement du programme ................................................................... 8
Suppression, dition, sauvegarde .........................................................10
3.
Quelques petits exemples...................................................................12

Les tuples............................................................................................ 12
Larithmtique.................................................................................... 14
Les boolens.........................................................................................16
Concepts de base................................................................................................. 19
1. Arbres ................................................................................................... 20
2. Constantes............................................................................................ 23
Les identificateurs...............................................................................24
Les caractres......................................................................................25
Les valeurs boolennes .........................................................................25
Les nombres entiers non ngatifs............................................................26
Les nombres flottants non ngatifs.........................................................26
Le tuple vide.......................................................................................27
Les chanes de caractres .....................................................................27
3.
Oprations............................................................................................ 28
Oprations boolennes .........................................................................29
Oprations arithmtiques.................................................................... 30
Oprations de construction d'arbres ......................................................31
Les listes classiques .............................................................................33
4. Variables............................................................................................... 34
5. Termes .................................................................................................. 35
Syntaxe...............................................................................................35
Limitations.........................................................................................37
Dcembre 1990
PrologIA
Table des matires
Aociation
Exemples............................................................................................ 38
Identificateurs ............................................................................. 38
Identificateurs incorrects .............................................................. 39
Entiers ......................................................................................... 39
Entiers incorrects .......................................................................... 39
Flottants...................................................................................... 40
Flottants incorrects....................................................................... 40
Caractres.................................................................................... 40
Chanes de caractres................................................................... 41
Chanes de caractres incorrectes .................................................. 41
Expressions numriques ................................................................. 42
Expressions numriques incorrectes................................................. 43
Expressions boolennes.................................................................. 43
Expressions mixtes arithmtico-boolennes ................................ 44
Autres termes ............................................................................... 45
Termes incorrects .......................................................................... 45
Que reprsentent les termes ?............................................................... 46
Affectation .................................................................................. 47
Des termes particulirement subtils.................................................. 48
6.
Relations................................................................................................49
Egalit et ingalit............................................................................. 50
Implication ........................................................................................ 52
Comparaisons numriques.................................................................... 52
Relations unaires................................................................................ 53
7.
Contraintes...........................................................................................54
Syntaxe.............................................................................................. 54
Exemples............................................................................................ 56
8.
9.
Rsolution des systmes de contraintes ..........................................57

Rgles et requtes................................................................................60
Syntaxe.............................................................................................. 60
Signification d'un programme Prolog III .............................................. 62
L'ensemble des faits dfinis par un programme Prolog III ............... 62
Excution d'un programme ............................................................ 64
Arbres, tuples, chanes et listes ........................................................................69

1. Introduction..........................................................................................70
2. Les arbres..............................................................................................70
Oprations sur les arbres ..................................................................... 71
Contraintes sur les arbres..................................................................... 74
Exemples............................................................................................ 74
Restrictions sur la contrainte de taille ................................................. 76
3.
Les tuples ..............................................................................................76

Oprations ......................................................................................... 76
Relations............................................................................................ 77
Restrictions concernant les tuples......................................................... 77
Exemples de contraintes sur les tuples .................................................. 78
Rcapitulatif des oprations et relations............................................. 79
4.
Rgles prdfinies sur les tuples........................................................80

Tailles et concatnations..................................................................... 80
vi
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Table des matires
HERITAGE
Divers.................................................................................................81
Un exemple de programme sur les tuples ...............................................81
5.
Les listes................................................................................................ 83
6.
Les chanes........................................................................................... 85
7.
Exemples............................................................................................... 87
Primitives sur les listes........................................................................84

Primitives sur les chanes ....................................................................85
Calcul des feuilles dun arbre ...............................................................87
Quick sort............................................................................................87
Une suite priodique............................................................................89
Crible d'Eratosthne ...........................................................................90
Les contraintes numriques............................................................................... 93

1. Introduction ......................................................................................... 94
2. Gnralits............................................................................................ 94
Les nombres .........................................................................................94
Expressions numriques ........................................................................97
Les constantes numriques ..............................................................97
Les oprateurs numriques..............................................................98
Priorits des oprateurs numriques................................................98
Les relations...................................................................................... 100
Relations unaires. ....................................................................... 100
Relations binaires....................................................................... 101
Contraintes numriques...................................................................... 101
Exemples de contraintes numriques.................................................... 101
Restrictions....................................................................................... 102
Forme normale................................................................................... 102
Les quations............................................................................... 103
Les inquations............................................................................ 104
3.
Rgles prdfinies et procdures externes spcifiques................ 104

Vrifications de types ....................................................................... 106
Divers............................................................................................... 106
4. Retardement des contraintes non-linaires................................... 106

5. Formats d'entre-sortie.................................................................... 108
6. Exemples de programmes............................................................... 108
Calcul bancaire ................................................................................. 108
Crypto-arihmtique.......................................................................... 109
Remplissage dun rectangle par des carrs........................................... 110
Les contraintes boolennes............................................................................. 117

1. Introduction ....................................................................................... 118
2. Quelques dfinitions et remarques................................................. 118
Expressions boolennes....................................................................... 119
Priorits des oprateurs boolens........................................................ 119
Contraintes boolennes....................................................................... 120
Remarques importantes...................................................................... 121
Ensembles de contraintes boolennes ................................................... 122
Exemples de contraintes boolennes .................................................... 122
Forme normale conjonctive.................................................................. 123
Affectations boolennes ..................................................................... 125
PrologIA
vii
Table des matires
Aociation
Solution d'un ensemble de contraintes boolennes.................................126

Simplification de systmes de contraintes...........................................127
Rgles prdfinies spcifiques............................................................128
3. Premiers exemples de programmes...............................................129

Un ou sur deux variables.....................................................................129
Un ou sur une liste...............................................................................130
Au plus un de vrai ..............................................................................131
K lments vrais dans une liste de n boolens.......................................133
4.
D'autres exemples .............................................................................135

Pannes dans un additionneur binaire ...................................................135
Un puzzle logique...............................................................................143
Retardements......................................................................................................147
1. Introduction........................................................................................148
2. Termes connus...................................................................................148
Les prdicats valuables known, bound et free.....................................148
3. Retardement de l'excution d'un but .............................................149

4. Contraintes retardes .......................................................................151
Tailles retardes ...............................................................................151
Concatnation retarde......................................................................154
Contraintes numriques retardes .......................................................156
Le contrle et l'environnement des programmes ........................................161

1. Le contrle..........................................................................................162
2. Expressions, variables statiques, tableaux .....................................168
Expressions arithmtiques..................................................................168
Affectation. Tableaux. ......................................................................173
3.
Structuration, saisie et modification des rgles.............................176

Familles d'identificateurs .................................................................177
Partie ferme d'une famille................................................................178
Contexte de lecture et d'criture..........................................................179
Modules.............................................................................................184
Ajout, suppression et recherche de rgles.............................................186
Manipulation de modules objets..........................................................191
4.
Entres / sorties................................................................................. 192

Entres .............................................................................................. 193
Sorties...............................................................................................195
5.
Autres lments de l'environnement.............................................198

Sortir de Prolog III.............................................................................198
Temps, autres mesures ........................................................................198
Rgles prdfinies et procdures externes..................................................199

1. Introduction........................................................................................200
Index des rgles prdfinies, procdures externes et fonctions
valuables ..................................................................................................371
Rgles prdfinies et procdures externes (Edimbourg)...........................375
Identificateur - Arit.........................................................................376
Rgles sous forme de termes ................................................................376
Index des rgles prdfinies, procdures externes et fonctions

valuables pour la syntaxe Edimbourg.................................................421
viii
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Table des matires
HERITAGE
Les syntaxes de Prolog III............................................................................... 423

1. Introduction ....................................................................................... 424
Choix du mode syntaxique.................................................................. 424
Points communs, diffrences................................................................ 424
Conventions grammaticales ............................................................... 426
Jeu de caractres ................................................................................ 427
Constantes......................................................................................... 428
2.
Syntaxe de base ................................................................................. 432

Variables.......................................................................................... 432
Identificateurs .................................................................................. 433
Termes .............................................................................................. 435
Expressions numriques................................................................ 436
Expressions boolennes................................................................. 437
Arbres et Termes.......................................................................... 437
Contraintes ....................................................................................... 438
Rgles et requtes .............................................................................. 440
Quelques remarques ........................................................................... 441
Caractre espace......................................................................... 441
Continuation de ligne. ................................................................. 442
Les diffrents commentaires......................................................... 442
3.
Syntaxe d'Edimbourg....................................................................... 443

Variables.......................................................................................... 443
Identificateurs .................................................................................. 444
Termes .............................................................................................. 445
Oprateurs.................................................................................. 445
Les termes................................................................................... 447
Expressions numriques................................................................ 451
Expressions boolennes................................................................. 452
Arbres et Termes.......................................................................... 452
Contraintes ....................................................................................... 453
Rgles et requtes .............................................................................. 456
Quelques remarques ........................................................................... 458
Caractre espace......................................................................... 458
Continuation de ligne. ................................................................. 458
Les diffrents commentaires......................................................... 459
Oprateurs Edimbourg................................................................. 459
Etrangets................................................................................... 459
4.
Remarques gnrales ....................................................................... 460

Diffrences des modes.................................................................. 460
Cohabitation des deux syntaxes................................................... 461
Primitives Graphiques ..................................................................................... 463

1. Introduction et conventions ............................................................ 464
2. Primitives de gestion des fentres.................................................. 466
Rafrachissement de la fentre graphique.......................................... 473
3.
Dessin et positionnement................................................................. 473
PrologIA
ix
Table des matires

4.
Aociation
Usage de la souris..............................................................................478
Rgles pour manipuler les fentres l'aide du clavier et de la
souris.................................................................................................478
Reprage de la souris .........................................................................479
5. Modes de dessin et d'criture ..........................................................481

6. Primitives spciales de lecture et d'criture...................................485
Simulation de boutons ........................................................................485
Saisie de texte...................................................................................486
Botes de choix ..................................................................................489
Impression de fentres........................................................................492
7. Primitive de description de menus .................................................493

8. Gestion des botes de dialogue .......................................................498
Dfinition d'un dialogue standard......................................................498
Extensions utilisateur......................................................................... 510
9. Boutons actifs .....................................................................................515

10. Primitives de manipulation de fichiers...........................................516
Index des primitives graphiques............................................................519
Annexes...............................................................................................................523
A.
Liste des messages d'erreur de Prolog III ...........................................523
B.
Liste des rgles prdfinies par catgorie...........................................529

Rgles prdfinies Prolog III..............................................................529
Arbres, listes, chanes et tuples....................................................529
Contrle......................................................................................529
Contraintes numriques................................................................530
Conversion ..................................................................................530
Environnement.............................................................................530
Entres/Sorties............................................................................ 531
Gestion des rgles et des identificateurs........................................532
Vrification de types...................................................................532
Rgles prdfinies Edimbourg.............................................................533
Arbres, listes, chanes et tuples....................................................533
Contrle......................................................................................533
Evaluation de fonctions prdfinies..............................................533
Entres/Sorties............................................................................ 534
Gestion des rgles et des identificateurs........................................534
Vrification de types...................................................................534
C.
Quelques programmes Prolog III en syntaxe Edimbourg................535

1. Un petit exemple : menu.p3e...........................................................536
Le programme :............................................................................536
Une Question : .............................................................................536
2.
Calculs sur les grands nombres : fact.p3e......................................537

Le programme :............................................................................537
Questions :...................................................................................537
3. Calculs bancaires : bank.p3e ...............................................................538

Le programme :............................................................................538
Questions poses avec des nombres entiers ou flottants : .................538
4. Manipulation d'arbres : leaves.p3e ....................................................539

x
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Table des matires
HERITAGE
Le programme :............................................................................ 539

Questions : .................................................................................. 539
5. Un peu de logique : god.p3e............................................................... 540

Le programme :............................................................................ 540
LA question : ............................................................................... 540
6. Un problme de Lewis Caroll : lewis.p3e......................................... 541

Le programme :............................................................................ 541
Exemples de questions :................................................................ 542
7. Dtection de panne dans un additionneur : circuit.p3e .................. 543

Le programme :............................................................................ 543
Premier jeu de questions :.............................................................. 543
Second jeu de questions : ............................................................... 544
8. Un puzzle numrique : send.p3e ....................................................... 545

Le programme :............................................................................ 545
La question :................................................................................ 545
9. Un problme de remplissage : rectangle.p3e................................... 546

Le programme :............................................................................ 546
Une question :.............................................................................. 546
Index du manuel de rfrence ........................................................................ 547
Manuel d'utilisation
Utilisation de Prolog III ............................................................................... 1001
1. Installation de Prolog III................................................................. 1002
Matriel et logiciel requis................................................................ 1002
Contenu du kit d'installation ........................................................... 1002
Fichiers indispensables pour utiliser Prolog III .......................... 1003
Fichiers annexes........................................................................ 1004
Procdure d'installation .................................................................. 1005
Sur disque dur............................................................................ 1005
Sur Disquettes........................................................................... 1005
2.
Utilisation de Prolog III .................................................................. 1005

Activation de Prolog III................................................................... 1005
Paramtrisation de l'interprte Prolog III........................................ 1006
Interruption d'un programme............................................................ 1007
3.
Spcificits de Prolog III Macintosh.............................................. 1008

Valeurs extrmes des constantes arithmtiques................................. 1008
Espaces et tailles par dfaut............................................................ 1009
4.
A propos de l'environnement....................................................... 1009
5.
Ajout de rgles prdfinies............................................................ 1010
Utilisation d'un diteur hte ........................................................... 1009

Marche suivre............................................................................... 1011
Appel d'une rgle externe................................................................. 1012
Procdures de transfert de donnes.................................................... 1013
Premier protocole de transfert de donnes................................... 1014
Fonctions gnrales :..............................................................1014
PrologIA
xi
Table des matires
Aociation
Fonctions de conversion :........................................................ 1016

Second protocole de transfert de donnes..................................... 1018
Transfert de donnes simples de Prolog vers C. ....................... 1018
Transfert de donnes simples de C vers Prolog. ....................... 1020
Un exemple complet......................................................................... 1022
6. Appeler Prolog III depuis le langage C...........................................1025

Introduction..................................................................................... 1025
Description des fonctions.................................................................. 1025
Initialisation............................................................................ 1025
Appel ....................................................................................... 1026
Terminaison .............................................................................. 1027
Un petit exemple ............................................................................. 1028
Listings ........................................................................................... 1030
Index Gnral..................................................................................................1033
Manuel de mise au point

Dbuggeur et mise au point de programmes Prolog III ..........................2001
1. Introduction......................................................................................2002
2. Trace dexcution.............................................................................2003
3. Aperu du modle des boites ........................................................2004
Quelques dfinitions ........................................................................ 2006
4.
Les commandes du dbuggeur.....................................................2007

1.
2.
3.
4.
5.
6.
7.
8.
9.
Le langage de commande .............................................................. 2007

Points d'impression et points d'arrt............................................. 2008
Classifications des commandes..................................................... 2008
Progression .................................................................................. 2009
Informations................................................................................ 2011
Installer des points d'arrt........................................................... 2015
Modifier le droulement de l'excution ......................................... 2018
Gestion des options du dbuggeur................................................... 2022
Commandes annexes..................................................................... 2028
5. Rgles prdfinies de mise au point ............................................2031

6. Mise au point avance.....................................................................2031
1. Reprendre une dmonstration (retry)............................................. 2031
2. Rcuprer une erreur..................................................................... 2033
xii
Prolog
HERITAGE
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Prolog III
Version 1.3
Manuel de Rfrence
Dcembre 1991
PrologIA
Aociation
Prolog
HERITAGE
limitation.
Droits d'auteur
Dcembre 1991
PrologIA
Aociation
Prolog
HERITAGE
Introduction
Ce manuel entend rpondre un certain nombre des besoins lgitimes de

l'utilisateur d'un nouveau langage de programmation. Ces besoins sont
d'autant plus nombreux que certains des concepts utiliss couramment dans
les programmes Prolog III ne sont prsents dans aucun autre langage. Ainsi,
nous prsenterons ici, outre les caractristiques purement syntaxiques qui
dcrivent les programmes, un certain nombre de considrations, parfois
assez complexes, qui permettent, en cernant les mcanismes sous-jacents qui
rgissent l'unification, de programmer mieux, plus clairement, plus efficacement, et peut tre de programmer tout court. Dans cet ordre d'ides, de
nombreux exemples seront fournis et dvelopps, au fur et mesure des
besoins rencontrs.
Prolog III, tout comme son prdcesseur Prolog II, a ceci de remarquable
qu'il possde un modle thorique complet qui justifie, entre autres, que tout
programme respectant sa syntaxe est excut d'une manire unique et prvisible. Le lecteur intress par les aspects thoriques de la question pourra
se rfrer de nombreux articles et ouvrages publis sur le sujet. Toutefois,
pour des raisons de clart, nous avons prfr ici nous placer dans une
optique relativement informelle, qui devrait galement s'avrer plus
accessible. Nous esprons que les adeptes des prsentations thoriques ne
nous en tiendront pas rigueur.
Enfin, le lecteur peu habitu Prolog pourra se sentir quelque peu malmen par ce manuel, dont le but principal est de prsenter Prolog III et la
programmation logique par contraintes, au dtriment quelquefois d'une approche didactique et circonstancie des notions couramment utilises en Prolog. L encore, un certain nombre d'ouvrages, dont Prolog chez Inter
Editions, vous permettront de cerner les notions de base de la
programmation logique.
Dcembre 1991
PrologIA
Aociation
Prolog
HERITAGE
Quelques mots sur l'organisation de ce manuel. Il est divis en trois

parties : le manuel de rfrence, les manuels d'utilisation et de mise au point
de programmes, ces derniers sous forme de cahiers spars.
Le manuel de rfrence.
Notre intention, lors de la rdaction de ce manuel, a t de d'offrir au
lecteur une approche plusieurs niveaux; ces niveaux pouvant diffrer, selon
chaque lecteur, aussi bien par l'tat de ses connaissances sur Prolog III que
par le contexte d'utilisation un instant donn.
Une premire prise de contact pose les grands principes de Prolog III au
travers de l'utilisation de petits exemples. Cette prise de contact pourra
s'effectuer devant le clavier de votre machine favorite.
Un certain nombre de chapitres forment ensuite ce que l'on pourrait, avec
un soupon de prtention, appeler un "cours" sur Prolog III. On y dtaille les
concepts la base du langage, pour revenir dans le dtail sur les trois
principaux aspects : les tuples, le numrique et les boolens. Le dernier de ces
chapitres explicite la notion de retardement. Des exemples maillent cette
prsentation gnrale pour en faciliter la comprhension.
Le manuel se poursuit par une description de tout ce qui est utile pour le
programmeur, le contrle, l'environnement, les entres/sorties.
Ensuite on trouvera une liste, que nous esprons complte et que nous
avons voulu alphabtique, des primitives de Prolog III; tout d'abord la liste
des primitives communes aux deux syntaxes, puis celles propre la syntaxe
de type Edimbourg. Ces primitives sont prsentes raison d'une par page,
et nous avons tent de multiplier, partir de chaque entre, les accs
possibles d'autres primitives, ou mme d'autres parties du manuel.
Le chapitre "Syntaxes" prsente ensuite les syntaxes de Prolog III. Deux
syntaxes sont en effet admises, une syntaxe originale proche de Prolog II, et
une syntaxe anglaise de type Edimbourg.
Enfin le dernier chapitre, "Primitives graphiques", donne une description
dtaille des primitives d'environnement qui permettent de grer aussi bien
PrologIA
Aociation
Prolog
HERITAGE
du graphique, des fentres, ou des menus droulant, que des interruptions

souris, ou des objets structurs.
Avant de clore le manuel de rfrence par un certain nombre d'index,
gnraux ou spcifiques, on trouvera trois annexes, une premire
concernant la liste des messages d'erreur de Prolog III, une seconde
contenant la liste des rgles prdfinies et enfin une troisime reprenant les
exemples du manuel, cette fois ci en syntaxe Edimbourg.
Le manuel d'utilisation.
La partie "manuel d'utilisation" prsente les diffrentes spcificits de
Prolog III sur la machine que vous utilisez. On y trouvera galement les
informations relatives l'installation de Prolog III sur votre machine ainsi
qu' l'ajout de rgles prdfinies ou encore aux appels externes.
A la fin de ce cahier, on donne un rcapitulatif des index communs aux
manuels de rfrence et d'utilisation.
Le manuel de mise au point de programmes Prolog III.

Cette partie dcrit le debugger Prolog III travers son langage de
commande et ses primitives. Une prsentation de son modle est donne en
dbut de chapitre, et une approche progressive par des exemples
dmonstratifs amne naturellement une description plus dtaille de son
fonctionnement et de primitives plus complexes.
ststs
PrologIA
Aociation
Prolog
HERITAGE
PrologIA
Aociation
Prolog
HERITAGE
Dbuter avec Prolog III
1. Dmarrer une session Prolog III

2. Utilisation dun programme dexemple
- Chargement du programme
- Suppression, dition, sauvegarde
3. Quelques petits exemples
- Les tuples et les chanes de caractres
- Larithmtique et les contraintes numriques
- Les boolens et les formules
Que trouve-t-on dans ce chapitre ?
Ce chapitre vous propose un premier contact avec Prolog III, travers un petit
nombre d'exercices dont la principale caractristique est d'tre trs simples. Nous
ne cherchons pas introduire les concepts fondamentaux de Prolog III, ce sera
l'objet des chapitres suivants, mais uniquement la pratique simple du systme
Prolog III : l'activer, composer un programme, l'essayer, le modifier, etc
Dcembre 1990
PrologIA
1 . Dmarrer une session Prolog III

La manire d'entrer dans l'univers de Prolog III dpend du systme
d'exploitation de votre ordinateur. Sur UNIX, VMS, MS-DOS, etc il vous
suffit de composer la commande suivante (on suppose que $ est le
prompt de votre systme) :
$
prolog3
Prolog imprime :
PROLOG III, v1.2 Decembre (C) PrologIA 1989,90
>
Sur Macintosh, vous devez retrouver le fichier contenant le

logiciel Prolog III et l'ouvrir. Pour cela, cliquez deux fois
sur l'icne ci-contre. L'activation de Prolog III demande un
court instant. Une fentre nomme console s'ouvre, dans
laquelle est affich un texte de la forme :
PROLOG III, v1.2 Decembre (C) PrologIA 1989,90
>
A partir d'ici, le comportement de Prolog III est pratiquement le mme sur

toutes les machines, tout au moins pour ce qui concerne les exercices qui
vont nous intresser dans ce chapitre.
Le caractre > sert de prompt Prolog III et indique lutilisateur quil
est en attente dune commande. Une commande peut tre aussi bien une
rgle quune requte. Donnons une requte simple pour commencer :
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
> outml("Bonjour
Bonjour !
{}
>
!");
Prolog imprime des accolades pour exprimer que la requte sest excute
avec succs. Entrons maintenant un premier petit programme : les trois
rgles qui expriment que Jacques, Annie et Rmi habitent respectivement
Paris, Marseille et Paris :
> habite_a(Jacques,Paris) ->;
> habite_a(Annie,Marseille) ->;
> habite_a(Remi,Paris) ->;
>
Les rgles sont insres dans lordre o on les a tapes. Entrons la

commande list (qui affiche toutes les rgles donnes par lutilisateur).
> list;
habite_a(Jacques, Paris) ->;
habite_a(Annie, Marseille) ->;
habite_a(Remi, Paris) ->;
{}
>
Faisons quelques essais avec ce programme : o habite Jacques ?

> habite_a(Jacques,x);
{x=Paris}
>
Qui habite Paris ?

> habite_a(x,Paris);
{x=Jacques}
{x=Remi}
>
PrologIA
Aociation
Qui habite o ?
> habite_a(x,y);
{x=Jacques, y=Paris}
{x=Annie, y=Marseille}
{x=Remi, y=Paris}
>
A chaque fois, la rponse du systme est lensemble des valeurs donner

aux variables figurant dans la question pour que la relation correspondante
soit satisfaite. Pour terminer la session, on tape la commande :
> quit;
Prolog Quit ...
$
et on se retrouve sous linterprte de commandes du systme dexploitation.
2 . Utilisation dun programme dexemple

Chargement du programme
Dans ce qui suit, on utilisera le programme contenu dans le fichier menu.p3. Il

sagit du calcul des repas lgers, rcrit en Prolog III, trs connu mais trs
pdagogique. Ce programme est livr avec linterprte. Il suffit de lancer
Prolog III comme prcdemment, puis de charger le fichier menu.p3 en
tapant :
> input("menu.p3");
{}
>>>>>>>>>>>> Erreur 17: Fin de fichier inattendue
>
Prolog
HERITAGE
PrologIA
Aociation
Prolog
HERITAGE
Le but input("menu.p3") impose que lentre courante bascule sur le fichier

menu.p3. Les commandes y sont lues tour tour, excuts sil sagit de
requtes, codes en mmoire si ce sont des rgles. Lorsque le fichier dentre
est puis, le message : Erreur 17: Fin de fichier inattendue apparat et
lentre courante bascule sur lentre prcdente qui, en loccurrence, est le
clavier. Le message d'erreur n'aurait pas t affich si la fin du fichier en
question on avait trouv le but close_input. On peut visualiser les rgles
insres par :
> list;
RepasLeger(h,p,d) ->
HorsDoeuvre(h,i)
Plat(p,j)
Dessert(d,k),
{-k -i -i +10 >= 0 ,
i >= 0 ,
j >= 0 ,
k >= 0 };
HorsDoeuvre(radis,1) ->;
HorsDoeuvre(pate,6) ->;
Plat(p,i) ->
Viande(p,i);
Plat(p,i) ->
Poisson(p,i);
Dessert(fruit,2) -> ;
Dessert(glace,6) -> ;
Viande(boeuf,5) -> ;
Viande(porc,7) -> ;
Poisson(sole,2) -> ;
Poisson(thon,4) -> ;
{}
>
Remarquons tout dabord que ces rgles ne sont pas tout fait identiques
celles qui se trouvent dans le fichier menu.p3. Peu importe, elles leur sont
quivalentes. Prolog a cod les rgles prises dans le fichier menu.p3 sous une
forme canonique et ne peut plus les dcoder pour produire le texte initial car
PrologIA

il existe une infinit de textes initiaux possibles. Le fichier menu.p3 nest pas
modifi par Prolog.
Faisons un essai avec ce programme. Demandons de quoi est constitu un
repas lger; cela se traduit par :
>
{
{
{
{
{
{
>
RepasLeger(h,p,d);
h = radis, p = boeuf, d = fruit}
h = radis, p = porc, d = fruit}
h = radis, p = sole, d = fruit}
h = radis, p = sole, d = glace}
h = radis, p = thon, d = fruit}
h = pate, p = sole, d = fruit}
Suppression, dition, sauvegarde
Si nous voulons changer notre menu en remplaant les rgles :

Viande(porc,7) -> ;
par les rgles :

Viande(veau,4) -> ;
Viande(porc,7) -> ;
il nous suffit de supprimer le paquet de rgles ayant pour nom Viande, puis
dinsrer le nouveau paquet :
> suppress(Viande);
{}
> Viande(veau,4) -> ;
> Viande(boeuf,5) -> ;
> Viande(porc,7) -> ;
>
10
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
observons le paquet de nom Viande en utilisant la commande list:

> list(Viande);
Viande(veau,4)
Viande(boeuf,5)
Viande(porc,7)
{}
>
Excutons nouveau le programme :

>
{
{
{
{
{
{
{
>
RepasLeger(h,p,d);
d = radis, p = veau, h = fruit}
d = radis, p = boeuf, h = fruit}
d = radis, p = porc, h = fruit}
d = radis, p = sole, h = fruit}
d = radis, p = sole, h = glace}
d = radis, p = thon, h = fruit}
d = pate, p = sole, h = fruit}
Si nous voulons sauvegarder nos modifications dans un fichier, par exemple

menubis.p3, il nous faut taper les commandes suivantes :
> output("menubis.p3") list c l o s e _ o u t p u t ;
{}
>
La commande output fait basculer la sortie courante sur le fichier donn en

argument, list va nous lister notre programme sur cette sortie et close_output
ferme la sortie courante et bascule sur la sortie prcdente, dans notre cas,
lcran. Nous pouvons ensuite quitter la session, toujours par :
> quit;
$
Une fois revenu sous notre systme dexploitation, on peut vrifier que le
fichier menubis.p3 a bien t cr, comprenant les modifications que nous
avons faites plus haut.
PrologIA
11
3 . Quelques petits exemples

Prolog III est un langage qui manipule, outre les arbres que lon supposera
bien connus, les tuples, les expressions numriques linaires, les formules
boolennes. Tous ces objets peuvent tre solutions de systme de
contraintes.
Nous allons voir dans ce paragraphe, travers quelques petits exemples
comment manipuler ces diffrents objets.
ATTENTION. Quand on joue avec Prolog III, comme vous allez probablement le faire maintenant, on tape un petit programme, qu'on essaye, puis un
autre, et encore un autre, etc Or Prolog III conserve tous ces programmes
en mmoire, et on finit immanquablement par obtenir des erreurs qui
traduisent des conflits de noms comme Erreur 46: Regle deja definie .
Pour l'viter remettez zro l'espace des rgles, entre deux exemples, en
excutant la commande :
> kill_module("");
{}
>
Les tuples et les chanes de caractres
Un tuple est une suite dobjets Prolog. Le tuple not <a1,a2,a3> reprsente la
suite de longueur 3 forme des lments a1, a2, a3, quelle que soit la nature
de ces lments. Le tuple vide scrit naturellement <>. On peut indiquer
quune variable x est de type tuple en ajoutant la contrainte x !tuple. On peut
aussi imposer que x soit un tuple de longueur n donne par x :: n .
Lopration de base sur les tuples est la concatnation, note par . (point).
Observons les exemples suivants :
> {x = <1,2,3>.<4,5>};
{x=<1,2,3,4,5>}
> {x = y.z, y::2, y = <1,2>};
{x=<1,2>.z, y=<1,2>}
> {x = y.z, y::2};
12
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
{x=y.z, y::2}
>
N.B. Les exemples prcdents sont donns titre explicatif et la rponse fournie par
la machine peut avoir une forme diffrente, mais quivalente.
Si on souhaite obtenir le premier lment x dun tuple l, il suffit de lunifier
avec un terme de la forme <x>.r , qui dnote la concatnation d'un tuple <x>
un seul lment et d'un tuple r quelconque. Ceci nous permet dcrire les
deux rgles element_de en Prolog III :
> element_de(x,<x>.r) - > ;
> element_de(x,<y>.r) -> element_de(x,r) , { x # y } ;
>
puis on peut demander :

> element_de(1,
{}
> element_de(x,
{x=3}
{x=5}
{x=1}
> element_de(9,
>
<3,5,1>);
<3,5,1>);
<3,5,1>);
Les chanes de caractres sont des tuples dont les lments sont des
caractres. La chane note "abc" est le tuple de caractres <à`,`b`,`c`> .
On peut mlanger les chanes et les tuples, notamment l'aide de loprateur de concatnation. On peut imposer une variable de type chane une
longueur n connue (le nombre de caractres) en installant la contrainte x :: n .
> {x=y.<`-`>."au-".<`f`,è`,ù`>,
{x="pot-au-feu", y="pot"}
>
PrologIA
y="pot"};
13
Aociation
Larithmtique et les contraintes numriques
Voyons le problme suivant : on dispose dun certain nombre de chats,

d'oiseaux, les nombres de ttes et de pattes et on demande dexprimer les
relations liant ces nombres. Si on appelle c le nombre de chats, o le nombre
doiseaux, t le nombre de ttes, p le nombre de pattes, les relations sont les
suivantes :
t = c + o et p = 4c + 2o
et sexpriment naturellement en Prolog III :
> {t=c+o, p=4c+2o};
{t=o+c, p=2o+4c}
>
Prolog rpond par un systme dquations, ce qui signifie que le systme est
soluble. Allons un peu plus loin en donnant des valeurs certaines variables.
Comme il sagit dun systme de deux quations quatre inconnues, nous
allons fixer les valeurs de deux des variables pour obtenir les valeurs des
deux autres. Fixons le nombre de pattes 14 et le nombre de ttes 5 :
> {t=c+o, p=4c+2o,
{t=5,c=2,o=3,p=14}
>
p=14,
t=5};
Prolog nous dit cette fois-ci que la solution est unique en nous fournissant les
valeurs des variables pour lesquelles lensemble de contraintes est vrifi. On
aurait pu bien videmment fixer nimporte quel couple de variables pour
avoir une solution unique. Avant de continuer avec cet exemple nous allons,
afin de ne plus donner explicitement le systme dquations, dclarer dans
Prolog une rgle liant les quatre variables et les quations. Par la suite, nous
nutiliserons plus que cette relation. Entrons:
> ChatsOiseaux(c,o,p,t)
>
14
Prolog
HERITAGE
-> , {t=c+o, p = 4 c + 2 o } ;
PrologIA
Aociation
Prolog
HERITAGE
Nous venons dintroduire dans Prolog une rgle dont la smantique est :
sous rserve que le systme de contraintes soit vrifi, la relation ChatsOiseaux(c, o,
p, t) est vraie. On peut prsent donner les requtes suivantes :
> ChatsOiseaux(c,o,14,5);
{c=2, o=3}
> ChatsOiseaux(1,o,p,5);
{o=4, p=12}
> ChatsOiseaux(1,1,2,4);
{c=-1, o=5}
>
Prolog ne rpond rien la troisime requte car elle nest pas soluble. A la
quatrime, une des variables de la solution est ngative. En effet, lors de la
formalisation de notre problme, nous navons aucun moment prcis que
les solutions devaient tre positives ! Nous allons donc rcrire la relation
ChatsOiseaux en imposant aux variables figurant dans le systme
dquations de ne pas tre ngatives. Auparavant, nous enlevons la relation
ChatsOiseaux en donnant la requte :
> suppress(ChatsOiseaux);
{}
>
puis nous crivons la nouvelle relation :

> ChatsOiseaux(c,o,p,t) ->,
{t=c+o, p=4c+2o, c>=0, o>=0,
>
p>=0,
t>=0};
et nous demandons :
>
Prolog nous dit quil ny a pas de solution cette requte, ce que nous
voulions. Mais que se passe-t-il si nous fournissons un nombre de pattes et
de ttes tels quil nexiste pas de solution entire ?
PrologIA
15
Aociation
{c=1/2, o=5/2}
>
nous nous retrouvons avec 21 chat et 52 doiseaux.... Nous navions en effet

jamais prcis que nous voulions des solutions entires. Prolog rsout les
quations arithmtiques dans lensemble Q des nombres rationnels. Nous
arrterons l cet exemple car il nexiste pas de contraintes imposant une
variable dtre entire; il nous faudra utiliser un prdicat prdfini pour
raliser cette vrification.
Les boolens et les formules
Prolog manipule aussi les formules et les systmes de contraintes

boolennes. Il en vrifie tout instant la satisfaisabilit et donne un systme
simplifi comme solution. Nous ne nous tendrons pas ici sur la notion
de simplifi ; disons juste que le systme solution est quivalent celui fourni
en entre. Donnons par exemple ces trois relations sur les trois variables a, b,
c:
> {a=>b, b=>c, c=>a};
{b=>c, c=>a, a=>b}
>
Rappelons que ces trois relations implique indiquent que les trois variables a,
b, c sont quivalentes et ont donc mme valeur de vrit, sans pour autant
que celle-ci soit connue. Prolog rpond par un systme identique celui que
nous avons fourni au dpart, ce systme tant en fait dj "simplifi".
Imposons maintenant que lune des trois variables a ou b ou c soit vraie.
Pour cela on ajoute au systme prcdent lquation a|b|c = 1' qui dit que la
formule a ou b ou c est vraie ( 1' est la constante Prolog vrai, et 0' la
constante faux).
> {a=>b, b=>c, c=>a,
{a=1',b=1',c=1'}
>
16
a|b|c
Prolog
HERITAGE
PrologIA
1'};
Aociation
Prolog
HERITAGE
Cette fois-ci, la solution est unique et Prolog nous rpond que toutes les
variables prennent la valeur "vrai".
ststs
PrologIA
17
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Concepts de base
1.
2.
3.
4.
5.
6.
7.
8.
9.
Arbres
Constantes
Oprations
Variables
Termes
Relations
Contraintes
Rsolution des
Rgles et requtes

Quels sont les concepts fondamentaux de Prolog III ? Quels objets le langage
manipule-t-il ? Quelle est la nature des contraintes qui pseront sur ces objets ?
Qu'est-ce qu'un programme Prolog III signifie pour le programmeur ? Comment la
machine l'excute-t-elle ? Selon quelle syntaxe ces objets et contraintes doivent-ils
tre exprims ?
Il y a une diffrence de nature, et non de degr, entre la plupart des autres langages
de programmation et Prolog III. On ne peut aborder ce dernier sans examiner
auparavant un certain nombre de concepts originaux la base du langage, indispensables pour une utilisation optimale, parfois mme une utilisation tout-court, de
celui-ci.
Ce chapitre prsente l'ensemble des spcifications de Prolog III, d'une manire assez
informelle, accessible quel que soit le degr de familiarit que vous entretenez dj
avec la programmation logique.
Nous y dfinissons les objets manipuls par le langage, puis les oprations et les
relations qui permettent d'tablir des contraintes sur ces objets. Ensuite, nous
prsentons ce qu'est un programme Prolog III, ainsi que la manire dont il est
excut.
Dcembres 1990
PrologIA
Concepts de base
Aociation
1 . Arbres
Quelle est la nature des objets manipuls ? C'est une des premires
questions auxquelles il nous faut rpondre pour expliquer Prolog III. Le
langage est tout--fait cohrent et uniforme :
TOUS LES OBJETS MANIPULS PAR PROLOG III SONT DES ARBRES
Certains sont trs complexes, voire infinis, tandis que d'autres sont rduits
un unique nud. Certains ont une dnomination particulire, alors que
d'autres ne peuvent tre designs qu'au moyen d'une opration qui les
construit ou d'un systme de contraintes dont ils sont solution.
N'ayant pas reproduire les dmonstrations formelles qui justifient les
algorithmes du cur de Prolog III, nous ne donnerons pas ici de dfinition
rigoureuse des arbres. La notion intuitive habituelle, qui assimile le concept
d'arbre celui d'ensemble organis hirarchiquement nous suffira amplement.
Cette hirarchie est incarne dans un ensemble de positions, ou nuds, et un

ensemble de flches reliant ces positions. On dit que les nuds auxquels
aboutit une flche issue d'un nud n sont les fils de n. L'ensemble des fils
d'un nud donn est toujours ordonn, ne serait-ce que par l'ordre dans
lequel ces nuds sont pratiquement reprsents. Le nud qui est au
sommet de la hirarchie s'appelle la racine, ou nud initial de l'arbre.
20
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
Chaque nud d'un arbre est son tour racine d'un arbre, appel sous-arbre
de l'arbre initial, dfini par ce nud, ses fils, les fils de ses fils, etc ainsi que
les flches qui manent de tous ces nuds.
UN ARBRE COMPORTE UNE TIQUETTE ET UNE SUITE FINIE DE SOUS-ARBRES.
A chaque nud d'un arbre Prolog III est associe une tiquette.
tiquettes possibles sont :
Les
les identificateurs
les caractres
les valeurs boolennes 0' et 1'
les nombres
le double signe <>
Voici un arbre de Prolog III :
nom_marie_poids
<>
1'
755/10
`D` ù` `p` ò` `n` `t`
Le nombre des fils d'un nud est toujours fini et indpendant de la nature
de son tiquette. Bien entendu, la smantique de cette dernire, ce qu'elle
signifie pour le programmeur, peut faire qu'un nud n'ait de sens qu'assorti
d'un nombre dtermin de fils, mais cela n'est pas connu des mcanismes de
base de Prolog III.
Le nombre des fils d'un nud peut tre nul : un arbre rduit un seul nud
est appel une feuille. Prolog III ne fait pas de distinction entre une feuille et
l'tiquette qu'elle porte. Par consquent, les identificateurs, les caractres, les
valeurs boolennes et les nombres sont considrs comme des cas
particuliers d'arbres.
PrologIA
21
Concepts de base
Aociation
Tous ces lments peuvent servir tiqueter un nud, un cas particulirement frquent tant celui o l'tiquette est un identificateur, comme
dans l'exemple dessin ci-dessus. Fort souvent de tels arbres reprsentent
des relations. Pour l'arbre dont nous parlons, ce pourrait tre s'appelle
Dupont, est mari et pse 75,5 Kg .
Un autre cas frquent est celui o l'tiquette du nud initial de l'arbre n'a
aucune signification pour le programmeur, qui ne s'intresse donc qu' la
suite des fils. Prolog III permet d'utiliser alors pour tiquette le double signe
conventionnel <> . De tels arbres sont appels PIII-tuples ou, plus simplement, tuples, et ils implantent donc la notion de suite finie d'arbres. Dans cet
esprit, l'arbre rduit au symbole <> reprsente la suite vide. Les tuples sont
expliqus plus en dtail au chapitre Arbres, tuples, chanes et listes
Grce au puissant oprateur dont ils sont munis, qui traduit l'opration de
concatnation des suites finies, les tuples constituent un outil souple et
puissant pour la dfinition de nombreuses structures de donnes, alliant la
gnralit des listes et l'efficacit des vecteurs. Ils peuvent donc
avantageusement remplacer la notion habituelle de liste, comme elle existe
en Lisp ou dans d'autres Prolog.
Cependant ces listes classiques, dfinies partir de la notion de paire pointe,
peuvent tre aussi utilises en Prolog III, y compris travers leur syntaxe
habituelle, dite d'Edimbourg.
Dans les programmes Prolog III, les arbres sont reprsents par des
formules appeles termes. La syntaxe des termes apparatra progressivement tout au long des paragraphes suivants ; elle est rsume au
chapitre Les syntaxes de Prolog III .
22
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
Les arbres et les termes ne sont pas la mme chose : les lments du domaine de
Prolog III sont des arbres, les entits syntaxiques qui les reprsentent sont
des termes. Or, dans l'explication de Prolog III il ne sera gure question que
de ces derniers, car ils sont la seule expression crite des arbres en accord
avec la syntaxe du langage. Ceci semble encourager une certaine confusion
des deux notions. Nous ne saurions trop mettre en garde le lecteur contre
une telle confusion, car elle prsente de nombreux inconvnients et
notamment celui d'empcher la comprhension de notions parmi les plus
importantes.
Cela tant dit, il y a un cas dans lequel on confond un arbre et le terme qui le
reprsente : il s'agit des constantes, qui sont par dfinition les arbres
reprsents par des termes simples, dont l'expression ne fait pas intervenir
d'oprateur, ainsi que l'explique le paragraphe suivant.
2 . Constantes
Parmi les lments du domaine de Prolog III, c'est--dire les arbres, les
constantes dsignent ceux qui ont reu une dnomination particulire.
Comme nous l'avons dit, nous ne ferons pas de distinction entre une
constante et le terme qui la reprsente.
Il ne suffit pas d'tre une feuille pour tre une constante : un arbre rduit
un unique nombre fractionnaire, comme 755/10, est une feuille, mais il ne
possde pas de nom spcifique et il ne peut tre exprim qu' travers la
division dont il est le rsultat. Bien entendu, 151/2 est une autre manire
de spcifier le mme nombre rationnel.
Inversement, toutes les constantes ne reprsentent pas ncessairement des
feuilles. Ainsi une suite de caractres comme
<>
`D` ù` `p` ò` `n` `t`
PrologIA
23
Concepts de base
Aociation
n'est certainement pas atomique ; cependant, Prolog III la considrera comme une constante, ds lors que l'on utilisera la notation particulire des
chanes, "Dupont". Bien entendu, vous pouvez reprsenter le mme arbre
par le terme <`D`,ù`,`p`,ò`,`n`,`t`> .
Les constantes connues sont :
Les identificateurs
Les identificateurs sont les constantes symboliques, comme

pierre
repas_leger
calcul12
Un identificateur est une suite de lettres, de chiffres et des deux caractres

apostrophe ( ' ) et blanc soulign ( _ ) qui n'a pas la syntaxe d'un nom de
variable, c'est--dire qui commence par au moins deux lettres. Une
description plus prcise de la syntaxe des identificateurs est donne au
chapitre Les syntaxes de Prolog III .
En ralit la syntaxe des identificateurs est bien plus complexe que celle des
exemples montrs ici, puisque la notation complte d'un identificateur
comporte un qualifieur (ou prfixe) qui indique le module auquel
l'identificateur appartient. L'ensemble des modules intervenant dans un
programme Prolog III ralise une partition de l'espace des noms, lui
permettant d'tre gigantesque tout en restant facile apprhender par le
programmeur. Cependant, l'existence par ailleurs d'un contexte de lecturecriture permet le plus souvent de n'utiliser que des notations simplifies
pour les identificateurs.
Les notions de module, de qualifieur et de contexte de lecture-criture sont
expliques au chapitre Le contrle et l'environnement des programmes
24
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
Les caractres
Tous les caractres disponibles sur votre machine peuvent tre utiliss dans
un programme Prolog III. Les caractres imprimables peuvent tre
exprims en les encadrant par des anti-apostrophes :
À` ,
à` ,
`<`
Les caractres non imprimables et ceux ayant un rle spcial peuvent tre
indiqus au moyen du caractre d'chappement anti-slash ( \ ), selon une
convention proche de celle utilise dans la communaut UNIX. Par exemple
:
indique
`\n`
indique
` \ x 4 1 ` indique
hexadcimal)
` \ 1 0 1 ` indique
`\\`
indique
`\``
le caractre `
le caractre nouvelle ligne
le caractre A (de code ASCII 41 en
le caractre A (de code ASCII 101 en octal)
le caractre \ lui-mme
La syntaxe complte des caractres est donne au chapitre Les syntaxes de

Prolog III .
Les valeurs boolennes
Les valeurs boolennes sont les deux lments du domaine de l'algbre de

Boole classique :
0'
1'
Nous ne les interprterons pas en termes de vrai ou de faux, rservant ces

mots pour parler des contraintes (nous dirons qu'une contrainte est vraie ou
fausse, pour indiquer qu'elle est ou n'est pas satisfaite). Les contraintes sont
expliques ci-dessous, au 7.
PrologIA
25
Concepts de base
Aociation
Les nombres entiers non ngatifs
0
1
2
1991
815915283247897734345611269596115894272000000000
On notera que les entiers ngatifs ne sont pas considrs comme des
constantes, puisqu'on peut les exprimer comme rsultat d'une opration, le
changement de signe, applique un entier positif ou nul. De la mme
manire, les nombres fractionnaires ne sont pas des constantes non plus, ils
sont reprsents l'aide des oprations de division et de changement de
signe, appliques des entiers.
Les nombres rationnels sont reprsents dans la machine en prcision parfaite,
c'est--dire avec autant de chiffres que leur expression exacte le requiert. A
la condition, bien entendu, que cela ne dpasse pas la taille de la mmoire de
votre machine.
Les nombres flottants non ngatifs
Exemples :
12.345
0.5
314.15926535e-2
1.2E12
La reprsentation interne, et donc la prcision et l'tendue des nombres

flottants, sont dtermins par les particularits de votre machine. Leur
syntaxe concide avec celle utilise dans la plupart des langages qui connaissent ce type de donnes numriques. Elle est donne en dtail au chapitre
Les syntaxes de Prolog III .
26
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
Le tuple vide
<>
Le double signe <> est un symbole conventionnel destin servir

d'tiquette aux arbres qui, d'un point de vue smantique, n'en ont pas. Ces
arbres se rduisent donc la suite de leurs fils : ils implantent en Prolog III la
notion de suite finie d'arbres, qu'on appelle des tuples.
Comme nous le verrons, les tuples se notent <a1, an> ; le tuple vide se note
donc tout naturellement <>. Ceci justifie le nom donn ce signe.
Les chanes de caractres
La notation courante des chanes de caractres, l'aide de guillemets :

"Et
oui"
est en ralit une deuxime notation pour l'arbre

<>
È` `t` ` ` ò` ù` ì`
En Prolog III, une chane de caractres est toujours structure, puisque c'est
un tuple de caractres. Les chanes ne sont des entits atomiques qu'en tant
qu'objets syntaxiques, et encore la condition d'utiliser la notation des
constantes-chanes, "Et oui".
Cas particulier, le tuple vide et la chane vide sont la mme chose ; les deux
notations "" et <> sont donc quivalentes.
PrologIA
27
Concepts de base
Aociation
3 . Oprations
Pour dsigner des arbres qui ne sont pas des constantes vous devez crire
des formules qui combinent des constantes et des oprateurs, selon une
syntaxe que nous indiquerons progressivement. Une telle formule exprime
le rsultat d'une opration. Une opration est dfinie sur un ensemble de nuplets d'arbres ; chacun elle associe un arbre1 :
f : (a1, an) f (a1, an)
L'ensemble des n-uplets d'arbres pour lesquels une opration donne est
dfinie n'est pas obligatoirement gal l'ensemble de tous les n-uplets ; on
dit que l'opration est partielle. Spcifier le sous-ensemble des n-uplets sur
lesquels l'opration est dfinie fait partie de la dfinition de l'opration en
question.
On dispose de trois types d'oprations : les oprations boolennes, les
oprations arithmtiques et les oprations de construction d'arbres. Avec
une prcision importante: les oprations boolennes et arithmtiques ont leur
signification mathmatique habituelle.
Cette remarque peut surprendre mais elle mrite d'tre faite, notamment
l'intention des utilisateurs des Prolog prcdents. Dans ces langages, des
oprations notes +, *, &, etc sont dfinies ou pourraient l'tre ; cependant, elles n'y ont pas leur signification mathmatique courante, elles ne sont
que des oprations de construction d'arbres. Ainsi, en Prolog II, la formule
2 + 3 dsigne l'arbre dont l'tiquette est + et les fils 2 et 3. Un prdicat
prdfini peut ensuite interprter cet arbre et en extraire le nombre 5, mais

cela est tranger au cur de Prolog II, qui n'effectue aucun traitement
spcifique des boolens ou des nombres.
28
Prolog
HERITAGE
Dans le jargon mathmatique, une opration est donc une application

f : D' D , avec D' Dn
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
En Prolog III, au contraire, les oprations boolennes et arithmtiques sont

connues en tant que telles du cur du langage, qui leur donne leur
signification logique ou arithmtique habituelle. Il en dcoule que l'arbre
reprsent par la formule 2 + 3 n'est autre que la feuille rduite au
nombre 5, rsultat de l'opration indique.
Cette remarque aura encore plus d'intrt quand nous considrerons les
termes avec des variables. Comme pour l'addition prcdente, la formule 2
+ X ne dsignera pas un quelconque arbre non atomique mais bel et bien le
nombre (inconnu) rsultat de l'addition de 2 et du nombre inconnu X.
Oprations boolennes
Les oprations boolennes ne sont dfinies que si les oprandes sont des
valeurs boolennes, c'est--dire des feuilles tiquetes par des constantes
boolennes.
(1) L'opration unaire non
a1 ~ a1
(2) L'opration binaire et
(a1, a2) a1 & a2
(3) L'opration binaire ou (non exclusif)
(a1, a2) a1 | a2
(4) L'opration binaire implique
(a1, a2) a1 => a2
(5) L'opration binaire quivalent
(a1, a2) a1 <=> a2
Les rsultats rendus par ces diffrentes oprations sont dfinis par le tableau
suivant :
PrologIA
29
Concepts de base
a1
a2
~a2
0'
0'
1'
0'
1'
0'
1'
1'
Aociation
a1 & a2
a1 | a2
a1 => a2
a1 <=> a2
0'
0'
1'
1'
0'
1'
1'
0'
0'
0'
1'
0'
0'
1'
1'
1'
1'
1'
Des termes corrects exprimant des oprations boolennes, ainsi que

certaines fautes ne pas commettre, sont montrs au 5.
Oprations arithmtiques
Les oprations arithmtiques ne sont dfinies que si les oprandes sont des
valeurs numriques, c'est--dire des feuilles tiquetes par des nombres.
Si aucun de ces nombres n'est flottant, alors l'opration est considre
comme une opration exacte sur des nombres rationnels. Si l'un au moins
des oprandes est flottant, alors l'autre est transform en flottant, sauf s'il
l'tait dj, et l'opration est considre comme tant l'opration
correspondante sur les nombres flottants.
Les oprations arithmtiques sont :
(1) L'opration unaire neutre
a1 + a1
(2) L'opration unaire de changement de signe
a1 - a1
(3) L'opration binaire addition
(a1, a2) a1 + a2
(4) L'opration binaire soustraction
(a1, a2) a1 - a2
(5) L'opration binaire multiplication
30
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
(a1, a2) a1 * a2
Afin d'allger les critures, la syntaxe de Prolog III permet d'crire a1a2 la
place de a1*a2. A la condition, bien entendu, que cela ne change pas le sens
de ce qui est crit. Mais attention, il y a quelques piges passablement
vicieux : voyez le 5.
(6) L'opration binaire division
(a1, a2) a1 / a2
La division n'est dfinie que si a2 est diffrent de zro.
Des termes corrects exprimant des oprations arithmtiques, ainsi que des
fautes ne pas commettre, sont montrs au 5.
Oprations de construction d'arbres
Ces oprations permettent de construire des arbres non rduits des

feuilles. Nous avons :
(1)
L'opration de construction d'arbre
(a1, a2, an) a1(a2, an)

Pour que cette opration soit dfinie il faut que n 2 et que a 1 soit une
feuille. Elle a pour rsultat l'arbre dont l'tiquette est1 a1 et dont les fils sont
a2, an.
(2)
L'opration de construction de tuple

(a1, an) < a1, an >
En toute rigueur il faudrait dire l'arbre dont l'tiquette est l'tiquette de a1, mais
comme nous l'avons dit, Prolog III ne distingue pas une feuille de son tiquette.
PrologIA
31
Concepts de base
Aociation
Elle est dfinie quelque soit le n-uplet (a1, an), la condition que n 1 ; elle
a pour rsultat le PIII-tuple dont a1, an sont les lments. On dit que n est
la longueur du tuple construit. L'galit suivante dcoule de la dfinition
mme des tuples :
<a1, an> = <>(a1, an)
(3)
L'opration binaire de construction gnrale d'arbre
(a1, a2) a1[a2]

Cette opration n'est dfinie que si a1 est une feuille et a2 un tuple. Elle a
pour rsultat l'arbre qui a a 1 pour tiquette et a 2 pour suite de fils. Par
dfinition, on a donc l'galit :
a1[<b1, bm>] = a1(b1, bm)
(4) L'opration binaire de concatnation de tuples
(a1, a2) a1 . a2
Elle n'est dfinie que si a 1 et a 2 sont tous les deux des tuples. Elle a pour
rsultat le tuple dont les lments sont ceux de a1 suivis de ceux de a2. Par
dfinition, on a donc l'galit :
<b1, bm>.<c1, ck> = <b1, bm, c1, ck>
32
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
Les listes classiques
On peut aussi utiliser en Prolog III des listes classiques1, bases sur la notion
de paire pointe, comme elles existent en Lisp ou dans d'autres Prolog. Dans
la syntaxe d'Edimbourg2, ces listes s'crivent de la manire suivante :
liste vide :
[]
liste ayant les lments e1, e2, en et termine par [] :
[ e1, e2, en ]
liste ayant en tte les lments e1, e2, en et pour queue la liste q :
[ e1 , e2 , en | q ]
Il faut bien comprendre que ceci n'est pas une opration de construction
d'arbres spcifiquement prise en compte par Prolog III, mais uniquement un
autre moyen syntaxique d'exprimer certains arbres : la paire pointe et le
clbre nil. A cet effet, on donne un statut d'identificateur au double
signe [] et on code le doublet de base [ e 1 | e 2 ] par l'arbre []( e 1 , e 2 ) . Par
consquent, les expressions ci-dessus spcifient respectivement les arbres
[]
[]( e 1 ,[]( e 2 , []( e n ,[]) ) )
[]( e 1 ,[]( e 2 , []( e n , q ) ) )
Mme si les tuples de Prolog III sont une amlioration indiscutable des listes
classiques, toutes les rgles prdfinies de Prolog III qui sont hrites de
Prolog II n'utilisent que ces dernires, afin de ne pas changer de comportement.
Nous disons ici classiques par opposition aux nouvelles listes que sont les tuples,
mais dans la suite de cette documentation nous appellerons les listes classiques tout
simplement des listesou bien encore des "listes binaires".
2
Ces listes ne peuvent pas tre exprimes en Prolog III avec la syntaxe qu'elles ont en
Prolog II, c'est--dire a 1 .a 2 . . a n , le point ayant ici un tout autre rle syntaxique (il
exprime la concatnation)
PrologIA
33
Concepts de base
Aociation
4 . Variables
Les variables ne sont pas d'autres lments du domaine de Prolog III, dont
on n'aurait pas encore parl, et qui existeraient en plus des arbres.
Essentiellement, les variables sont une autre manire de reprsenter les
arbres, ainsi qu'il dcoulera des explications suivantes.
Du point de vue de la syntaxe, le principal signe de reconnaissance d'une
variable est d'avoir pour nom une suite de lettres, de chiffres et des deux
caractres apostrophe ( ' ) et blanc soulign ( _ ), commenant par une lettre
et dont le second caractre, s'il existe, n'est pas une lettre. Les formules
suivantes sont des noms de variables1
X
Y'
Z2
V_ariable
Il y a une profonde diffrence entre ce que signifient les variables dans la

plupart des langages classiques et ce qu'elles reprsentent en Prolog III.
Dans les langages classiques, une valeur est attache chaque variable.
L'excution d'un programme produit toutes sortes de modifications de ces
valeurs et obtient la solution du problme sous forme de valeurs finales des
variables. Dans ces langages, une variable dsigne constamment un objet
parfaitement connu, ou bien l'utilisation de la variable est illgale.
EN PROLOG III, LES VARIABLES REPRSENTENT DES ARBRES INCONNUS.
A l'oppos, une variable Prolog III dsigne un arbre inconnu, exactement
comme une inconnue dans une quation mathmatique dsigne un nombre
inconnu, par exemple X dans
Dans la syntaxe marseillaise de Prolog III, les variables n'ont pas commencer par
une lettre majuscule, ni les identificateurs par une lettre minuscule. Cependant, telle est la
rgle dans la syntaxe d'Edimbourg. Pour cette raison, bien qu'crits dans la syntaxe
originale, la plupart des expressions Prolog III donnes en exemple dans le texte seront,
autant que possible, compatibles avec les deux syntaxes.
34
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
X = (1/2)X + 1
Dans cet esprit, le droulement d'un programme Prolog III ne vise pas
modifier les valeurs des variables, mais les dterminer. Ds leur entre en
scne les variables pourront apparatre dans des termes et des contraintes,
comme X < 10 ; justement, programmer en Prolog III ne sera parfois rien
d'autre qu'crire les contraintes qui psent sur un arbre initialement inconnu,
reprsent par une variable. Le travail de Prolog III sera alors de rsoudre
ces contraintes et de dvoiler l'arbre en question.
5 . Termes
Ayant introduit les constantes, les oprations et les variables, nous disposons
de tout ce qu'il nous faut pour dfinir les termes dans toute leur gnralit.
Comme nous l'avons dit, les termes sont les formules qui reprsentent les arbres
dans les programmes.
Voici les plus significatives parmi les expressions BNF qui dfinissent la syntaxe des termes. La totalit de ces expressions est donne au chapitre Les
syntaxes de Prolog III .
Syntaxe
<terme>
::= <terme1>
::= <terme> => <terme1>
::= <terme> <=> <terme1>
<terme1>
::= <terme2>
::= + <terme2>
::= - <terme2>
::= <terme1> + <terme2>
::= <terme1> - <terme2>
::= <terme1> | <terme2>
PrologIA
35
Concepts de base
Aociation
<terme2>
::= <terme3>
::= <terme2> / <terme3>
::= <terme2> * <terme3>
::= <multiplicande> <variable>
::= <terme2> & <terme3>
<terme3>
::= <terme4>
::= ~ <terme3>
<terme4>
::= <terme5>
::= <terme5> ( <suite de termes> )
::= <terme5> [ <terme> ]
::= <terme4> . <terme5>
<terme5>
::=
::=
::=
::=
<variable>
<constante>
< <suite de termes> >
( <terme> )
<multiplicande>
::= <entier>
::= <rel>
::= ( <terme> )
<suite de termes>
::= <terme>
::= <terme> , <suite de termes>
36
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
Un point important apparat immdiatement : les expressions qui nous ont

servi dfinir les arbres et les oprations sur les arbres sont des termes. En
fait, pour expliquer les constantes et les oprations nous n'avons pas pu faire
autrement que de dfinir implicitement la syntaxe des termes sans variable.
Considrons ces formules comme tant acquises : ce que nous leur ajoutons
maintenant est la possibilit d'y mettre des variables. Plus prcisment, nous
permettons dsormais d'crire une variable tout endroit d'un terme-sansvariable o pouvait figurer l'expression d'un arbre.
Limitations
La syntaxe prcdente autorise donc l'criture de toute sorte de termes. En

particulier, elle n'tablit pas de dissymtrie entre les deux oprandes des
oprations arithmtiques, boolennes ou de construction d'arbre. Il faut
savoir qu'au niveau des mcanismes de base de Prolog III il existe deux
importantes restrictions.
La premire concerne les termes chapeauts par un oprateur arithmtique :
les expressions arithmtiques doivent tre linaires
Cela signifie que dans une multiplication a1 * a2 un des deux oprandes ne
doit pas contenir de variable, et que dans une division a1 / a2 le deuxime
oprande, a 2 , ne doit pas contenir de variable. Cela interdit des termes
comme (2x+3)*(4y+5) ou x/y.
La deuxime restriction concerne l'opration de concatnation : dans une
concatnation, la longueur de l'oprande gauche doit tre connue.
Cela interdit l'criture de termes comme x.y, sauf si une contrainte,
comme x = <z1,z2,z3> ou x::3 (les contraintes sont expliques au 7)
impose x de possder une longueur dtermine, ici 3.
PrologIA
37
Concepts de base
Aociation
Bien que ces limitations soient fondamentales au niveau des mcanismes de

base de Prolog III, dans la plupart des situations pratiques vous pourrez ne
pas en tenir compte, un dispositif de retardement automatique se chargeant
votre place de geler l'expression conflictuelle jusqu' ce qu'assez de
variables soient connues pour que l'expression puisse tre considre
comme lgitime. Ce mcanisme est dcrit au chapitre Retardements .
Exemples
Voici une collection de termes corrects et d'expressions errones, illustrant la

syntaxe des termes et justifiant un certain nombre de complments
d'information et de mises en garde leur sujet.
Identificateurs
pomme
(1)
pomme'
(2)
nb_fils
(3)
Paul_Hochon
(4)
zZ44a_45b_c46'
(5)
Il s'agit d'identificateurs corrects pour la syntaxe marseillaise. On notera que

pour la syntaxe d'Edimbourg (explique au chapitre Les syntaxes de
Prolog III ), notre exemple (4) n'est pas un identificateur mais une variable,
car il commence par une lettre majuscule.
38
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
Identificateurs
incorrects 1
t_iti
(1)
i'm_happy
(2)
nb-freres
(3)
1dou
(4)
Les exemples (1) et (2) ne sont pas des identificateurs, car leur deuxime
caractre n'est pas une lettre ; ce sont des noms de variables corrects. Les
deux exemples suivants (3) et (4) sont illgaux : le signe moins n'est pas
permis l'intrieur d'un mot, un identificateur ne peut pas commencer par
un chiffre.
Entiers
2500
(1)
815915283247897734345611269596115894272000000
(2)
012
(3)
00
(4)
Entiers
incorrects
2 500
(1)
8.0
(2)
0.
(3)
La premire expression ne dfinit pas un entier, mais deux entiers spars

par un blanc. Les deux expressions suivantes dfinissent des nombres
flottants lgitimes, mais non des entiers corrects.
Il faudrait dire des expressions qui ne sont pas des identificateurs corrects , bien
sur !
PrologIA
39
Concepts de base
Aociation
Flottants
1.e6
(1)
.5e6
(2)
31.4e-1
(3)
4.
(4)
.666
(5)
Ces expressions dfinissent respectivement les nombres 106 ; 0,5 10 6 ;

31,4 10-1 ; 4 ; 0,666
Flottants
incorrects
e10
(1)
.e10
(2)
1.2e
(3)
3e10
(4)
L'exemple (1) ne spcifie pas un nombre, mais une variable. Les autres
exemples nous rappellent que : la mantisse doit avoir au moins un chiffre (2),
l'exposant ne peut tre omis (3) pas plus que le point dcimal (4).
Caractres
À`
(1)
`\x41`
(2)
`\101`
(3)
`\41`
(4)
`\n`
(5)
Les trois premiers exemples spcifient le mme caractre : la lettre A, dont le

code ASCII est 41 en hexadcimal, ou 101 en octal. On notera que si le
zro a t omis dans le quatrime exemple, qui spcifie le caractre ! (041 en
octal), c'est parce qu'il n'y a aucune ambigut au sujet du caractre
immdiatement aprs l'expression \41. L'exemple (5) indique le caractre
de fin de ligne.
40
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
Chanes de caractres
"Pinocchio
va
"Pinocchio
va
(1)
l'ecole"
(2)
l'ecole"
"Cette
"Les
chaine
crochets
contient\nun
\"[\"
et
retour
\"]\"
chariot"
indiquent"
(3)
(4)
""
(5)
"A\tB"
(6)
"A\x09B"
(7)
"A\x7B"
(8)
Les chanes (1) et (2) sont identiques. La chane (4) a pour contenu :
Les
crochets
"["
et
"]"
indiquent
La chane (5) est la chane vide. Elle peut aussi s'crire

<>
Les chanes (6),et (7) sont identiques (A et B spars par une tabulation
horizontale).
L'exemple (8) reprsente la chaine
A{
Chanes de caractres incorrectes
(1)
"""
"Les
crochets
""[""
et"
(2)
(3)
"11\1112"
L'exemple (1) pose le problme bien connu de la prsence dans une chane
du dlimiteur des chanes lui-mme. L'exemple (2) montre une mauvaise
manire de rsoudre ce problme. L'exemple (3), comparer avec l'exemple
(8) des chanes correctes, montre un cas o l'on ne peut se dispenser d'crire
les trois chiffres du code ASCII en octal du caractre. L'criture correcte de
cette chane serait probablement
"11\01112
(ou
"11\t12 )
PrologIA
41
Concepts de base
Aociation
Expressions numriques
Appelons expression numrique un terme constitu par l'application d'un
oprateur arithmtique un ou plusieurs oprandes. En voici des exemples :
-X
(1)
+X
(2)
355/113
(3)
4 + 1/2 + 0.333
(4)
X + 3Y + 5Z/4 + (14+9/17)T
(5)
(1000
(6)
2*3*4*5)Y
(1/2 + 2/3 + 3/4 + 4/5)*(X + Y - 2T/5)
(7)
(X + Y)*(X - Y)
(8)
(2T/5 + X - Y)/(X + Y - 1/2)
(9)
L'expression (1) (resp. (2)) indique l'opration de changement de signe (resp.

l'opration neutre) applique au nombre inconnu X. L'une et l'autre n'ont
de sens que pour des nombres ; elles imposent donc X de reprsenter une
valeur numrique. En outre, leur rsultat est par dfinition un nombre.
Comme les autres oprations arithmtiques, elles ont donc bien plus de
consquences que la simple transformation de la valeur de leur oprande : ils
imposent des contraintes de type leurs oprandes et aux expressions dans
lesquelles ils apparaissent. La notion de contrainte est explique en dtail au
7.
L'exemple (4) montre divers cas o la syntaxe de Prolog III permet d'omettre l'oprateur *. Une criture quivalente de cette expression est
X + 3*Y + 5*Z/4 + (14+9/17)*T
Les exemples (8) et (9) sont des expressions non linaires, un dispositif de
retardement automatique est donc mis en place. On se rfrera pour plus de
dtails sur ce sujet au chapitre Retardements .
42
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
Expressions numriques incorrectes
5(X + Y)
(1)
4/5X
(2)
X5
(3)
XY
(4)
3*-X
(5)
En tant qu'expression arithmtique 5(X + Y) est incorrect. Cependant, ce

terme est l'criture correcte d'un arbre ayant 5 pour tiquette et le nombre
rsultat de l'addition X + Y pour unique fils.
L'exemple 4/5X est syntaxiquement incorrect. Pour indiquer les quatre
cinquimes de la valeur reprsente par X il faut crire (4/5)X.
L'expression X5 n'est pas incorrecte, mais elle ne reprsente pas une
expression arithmtique, uniquement une variable ayant ce nom. De la
mme manire, XY est un identificateur, non un produit.
Enfin, l'expression 3*-X doit tre rcrite 3*(-X)
Expressions boolennes
1'
(1)
X | 0'
(2)
X | ~Y
(3)
~~Y
(4)
X & X
(5)
X & 1'
(6)
(A & B) => (C & D)
(7)
(U3 & ( ~X1 <=> X3 )) | 0'
(8)
PrologIA
43
Concepts de base
Aociation
Expressions mixtes arithmtico-boolennes

La rgle est simple : elles sont toutes incorrectes. Autrement dit, il n'y a pas en
Prolog III d'expression arithmtique correcte comprenant des sousexpressions boolennes, pas plus qu'il n'y a d'expression boolenne correcte
comprenant des sous-expressions arithmtiques. Cela dcoule de la
dfinition des oprations arithmtiques et des oprations boolennes. Les
formules suivantes sont donc toutes incorrectes :
-1'
(1)
(X & Y) + Z
(2)
~0
(3)
X & (Y + Z)
(4)
On accepte sans grande difficult ces limitations qui, somme toute,

appartiennent tous les langages propres. On peut s'accommoder moins
facilement de la restriction suivante : en Prolog III il n'y a aucun oprateur
fournissant un rsultat boolen dcoulant de proprits des nombres. Les
oprateurs qui s'appliquent des nombres donnent tous des nombres pour
rsultat, tandis que ceux qui rendent des boolens n'ont de sens qu'appliqus
des boolens.
Des expressions comme la suivante sont donc fondamentalement incorrectes :
(0 < X) & (X < 9)
Mais alors, quel est le statut en Prolog III de l'galit, l'ingalit, les
comparaisons numriques, etc? Il ne faut pas oublier ceci : =, #, <, <=, >,
>= ne sont pas des oprateurs. Ces symboles servent exprimer des relations,
lesquelles servent crire des contraintes. Le propre d'une contrainte est

d'tre vrifie ou non, et en pratique il nous arrivera de dire qu'elle est vraie
ou fausse. Mais il ne s'agit pas l des valeurs boolennes du domaine de
Prolog III, 0' et 1'. Une contrainte n'est pas un terme, et ne peut pas tre
vue comme exprimant une opration.
44
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
Autres
termes
mesure(pierre,
<180/100,
mesure[<pierre,
<mesure,
<180/100,
pierre,
<>(mesure,
metres>,
metres>,
<180/100,
pierre,
metres>,
<180/100,
(1)
1')
1'>]
(2)
1'>
(3)
metres>,
1')
(4)
(5)
4(X + Y)
(4z+y)(caractere(`c`,
"caractere
`c`"))
(6)
On notera qu'en Prolog III les termes (1) et (3) ne sont pas quivalents1. En
revanche, (1) et (2) le sont, ainsi que (3) et (4). L'exemple (5) montre un
terme correct, qui n'est pas le nombre 4 (x y) mais l'arbre ayant 4 pour
tiquette et le nombre (x y) pour unique fils.
On notera aussi que l'tiquette du dernier exemple a d tre parenthse.
Termes
incorrects
triplette
(1)
(X,Y,Z)
ff(X,Y)(Z,T)
(2)
uneFeuille()
(3)
L'exemple (1) rappelle un des (rares) endroits o la syntaxe ne tolre pas

l'insertion d'un blanc : entre l'tiquette d'un arbre et la parenthses ouvrante
qui prcde les fils.
Du seul point de vue de la syntaxe, l'exemple (2) pourrait tre corrig en
l'crivant (ff(X,Y))(Z,T) . Mais ce terme serait alors smantiquement
incorrect, puisque l'tiquette d'un arbre doit tre une feuille.
Puisqu'il ne s'agit dans cet exemple que de termes sans variable, tre quivalent
signifie tout simplement reprsenter le mme arbre
PrologIA
45
Concepts de base
Aociation
L'exemple (3) montre que dans le cas d'une feuille, la syntaxe interdit
l'criture d'une paire de parenthses encadrant la suite (vide) des fils. Ceci
est tout--fait cohrent avec la proprit que Prolog III ne distingue pas une
feuille de son tiquette.
Que reprsentent les termes ?
Les termes reprsentent les arbres dans les programmes Prolog III. On peut
comprendre cela de deux manires :
Un terme dsigne un arbre partiellement inconnu. Nous avons dj expliqu
qu'une variable, terme particulier, reprsentait un arbre inconnu dont la
dtermination tait l'objet du programme Prolog III considr. De manire
analogue, un terme reprsente dans le cas gnral un arbre dont certains
constituants seulement sont connus, l'objet du programme tant de dvoiler
les autres constituants. Les parties inconnues sont ncessairement des sousarbres ; les parties connues peuvent tre des sous-arbres ou bien des
lments qui dfinissent le squelette de l'arbre. Par exemple, le terme

reprsente un tuple dont le squelette est connu (c'est un tuple de longueur

deux) alors que les sous-arbres qui le constituent sont les nombres inconnus
rsultats des oprations P + L et 2P + 4L.
Un terme reprsente un ensemble d'arbres, savoir l'ensemble obtenu en
donnant toutes les valeurs possibles aux variables qu'il contient. Ainsi, le
terme donn en exemple ci-dessus reprsente l'ensemble infini de tous les
tuples de deux nombres. Cet ensemble est identique celui dfini par le
terme < +X, +Y > et n'a aucun lment en commun avec les ensembles
dfinis par les tuples < X > ou < X, Y, Z >
Nous retrouvons bien entendu les deux cas extrmes des termes : un terme
rduit une variable reprsente l'ensemble de tous les arbres, tandis qu'un
terme sans variable reprsente l'ensemble rduit l'unique arbre dont le
terme en question est l'expression crite.
46
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
Affectation
Attardons-nous un instant sur le concept donner des valeurs aux variables
d'un terme pour un peu mieux le formaliser ; cela nous servira plus tard
comprendre ce qu'est la rsolution d'un systme de contraintes. Nous avons
dj dit qu'une variable pouvait reprsenter n'importe quel lment du
domaine de Prolog III ; dfinir une affectation d'un ensemble de variables
c'est tout simplement choisir une valeur pour chacune des variables en
question. Si l'ensemble est
V = { x1, x2, xn }
alors une affectation de cet ensemble sera un ensemble de couples (xi, ai),
nots plutt xi ai, comme
A = { x1 a1, x2 a2, xn an }
signifiant : l'arbre a 1 est donn pour valeur la variable x 1, l'arbre a 2 la
variable x2, etc Une affectation n'est donc rien d'autre qu'une application,
dfinie en extension (lment par lment), d'un ensemble de variables dans
le domaine de Prolog III.
Soit t un terme ; chaque affectation A de l'ensemble des variables figurant
dans t permet de transformer ce dernier en un arbre a = t/A. Grosso modo,
il suffit de remplacer chaque variable de t par sa valeur dans A . Si on voulait
tre plus rigoureux, il faudrait dfinir t/A pour chaque modle de terme t, de
la manire suivante :
- si t se rduit une constante k, alors a est l'arbre k
- si t se rduit une variable x, alors a est l'arbre donn pour valeur x
dans l'affectation A
- si t est de la forme < t1, t2, tn > et si a1, a2, an sont les arbres t1/A,
t2/A, tn/A alors a est l'arbre < a1, a2, an >
- si t est de la forme t1(t2, tn) et si a1, a2, an sont les arbres t1/A, t2/A,
tn/A alors
- si a1 est une feuille, alors a est l'arbre a1(a2, an)
- sinon, a est indfini
PrologIA
47
Concepts de base
Aociation
- si t est de la forme t1[t2] et si a1 et a2 sont les arbres t1/A et t2/A alors

- si a1 est une feuille et a2 un tuple, alors a est l'arbre a1[a2]
- sinon, a est indfini
etc
Par exemple, l'affectation { P 2, L 3 } permet de transformer le terme
 en l'arbre < 2 + 3, 2*2 + 4*3 > c'est--dire <
5,
16 > .
Des termes particulirement subtils
Pour en finir avec les termes, remarquons que la prise en considration

spcifique des oprations arithmtiques et boolennes par le cur de
Prolog III a des consquences dont la finesse mrite d'tre souligne.
Examinons par exemple les deux termes
X
X + 0
Le premier dsigne l'ensemble de tous les arbres : tout lment du domaine

de Prolog III peut tre reprsent dans un programme par la variable X. Le
second comporte des lments connus : l'opration d'addition + et la
constante 0 . Ce terme reprsente comme nous l'avons dit l'ensemble des
arbres qu'on peut obtenir en donnant des valeurs la variable X. Or
l'addition n'est dfinie que sur les valeurs numriques, c'est--dire des arbres
rduits une feuille tiquete par un nombre, et elle rend pour rsultat des
valeurs numriques ; d'autre part, tout nombre y peut s'crire sous la forme
y = x + 0. Par consquent, le terme X + 0 dfinit le sous-ensemble du
domaine de Prolog III constitu par tous les nombres.
On peut dsigner ce mme sous-ensemble par le terme
1*X
ou encore de manire plus conomique, par le terme
48
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
+X
en effet, l'opration arithmtique + unaire impose son oprande d'tre un

nombre, et rend ce nombre comme rsultat. Remarquons au passage que,
bien que qualifie d'opration neutre, il serait bien trompeur de prendre le +
unaire pour une opration sans effet.
Bien entendu, toutes ces considrations s'appliquent de manire analogue
aux expressions boolennes. Ainsi, les termes
X & 1'
X | 0'
~~X
sont trois manires de dsigner l'ensemble de tous les boolens. Si l'on

prfre, on peut considrer que ces trois expressions reprsentent un arbre
qui est rduit une feuille tiquete par un boolen et qui, pour le reste, est
inconnu.
6 . Relations
En Prolog III les relations unaires et binaires traduisent des conditions
portant sur des arbres, comme <aa,bb,cc> est diffrent de aa(bb,cc)
ou 1 est suprieur 0 . Nous disposons de relations tout--fait gnrales,
comme l'galit entre arbres, et de relations spcifiques qui n'ont de sens
que pour une catgorie bien particulire d'arbres, comme les relations
d'ordre sur les nombres ou l'implication entre boolens.
PrologIA
49
Concepts de base
Aociation
Les relations ne sont pas des oprations1. Le propre d'une opration, applique
un n-uplet d'arbres, est de rendre un arbre titre de rsultat ; le propre
d'une relation, applique un n-uplet d'arbres, est d'tre ou non vrifie.
Bien que dfinie sur des arbres ou des couples d'arbres, elle ne leur associe
pas des lments du domaine de Prolog III et, mme si dans le langage
courant un dit qu'une relation est vraie ou fausse , il ne faut pas voir
cela comme des occurrences des valeurs boolennes 1' et 0' du domaine de
Prolog III.
Comme les oprations, les relations sont partielles. L'ensemble des arbres ou
des couples d'arbres pour lesquels une relation est dfinie n'est pas
ncessairement gal l'ensemble de tous les arbres ou de tous les couples
d'arbres.
Les relations binaires sont au nombre de sept :
Egalit et ingalit
La condition
a1 = a2
se lit les arbres a1 et a2 sont gaux .
La condition
a1 # a2
se lit les arbres a1 et a2 ne sont pas gaux .
Rappelons que d'un point de vue mathmatique, dfinir une relation binaire sur un
ensemble D c'est choisir un sous-ensemble B de l'ensemble D D des couples d'lments de
D ; les couples appartenant B sont dits vrifier la relation. De la mme manire, dfinir
une relation unaire sur D c'est choisir le sous-ensemble U de D des lments pour lesquels la
relation est vrifie.
50
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
L'galit des arbres est une relation qui se dfinit rcursivement en affirmant
que deux arbres a1 et a2 sont gaux si
- les tiquettes de a1 et a2 sont gales-au-sens-des-tiquettes
- a1 et a2 ont le mme nombre n de fils
- (si n 0) le premier fils de a1 est gal au premier fils de a2, le deuxime
fils de a1 est gal au deuxime fils de a2, etc jusqu'au n-me fils de a1
qui est gal au n-me fils de a2.
Bien entendu, ceci suppose que l'on a pralablement dfini une galit-destiquettes. Pour que deux tiquettes soient gales, il faut
- qu'elles soient de mme type (deux identificateurs, deux nombres, deux
caractres etc)
- qu'elles soient gales pour les critres d'galit propres leur type.
Pour l'essentiel, ces critres sont les suivants :
- identificateurs : deux identificateurs sont gaux si leurs formes non
abrges s'pellent exactement de la mme manire. On notera bien
qu'il n'y a pas d'quivalence entre les lettres majuscules et les minuscules. La forme non abrge des identificateurs est explique au
chapitre Le contrle et l'environnement des programmes .
- caractres : deux caractres imprimables internationaux sont gaux si leur
forme crite est la mme, ce qui quivaut dire qu'ils ont la mme
reprsentation interne (code ASCII). Pour les caractres nationaux ou
les caractres non imprimables il y a lieu de se rfrer la
documentation particulire du systme Prolog III utilis.
- nombres rationnels. L'galit entre nombres entiers est une notion
primitive, hrite des mathmatiques, qui ne pose aucun problme. En
ce qui concerne les nombres fractionnaires, si l'on sait que Prolog III les
conserve en prcision infinie et sous leur forme irrductible, l encore
l'galit. ne pose aucun problme.
PrologIA
51
Concepts de base
Aociation
- nombres flottants. L'galit entre deux nombres flottants x et y, ou entre

deux nombres x et y dont l'un au moins est flottant, est dfinie par une
relation de la forme |x - y| , o est un seuil qui prend en
compte l'ordre de grandeur de x et y , les particularits de la
reprsentation des nombres flottants dans la machine utilise et
ventuellement une estimation de l'erreur commise dans l'expression
o x et y apparaissent.
- les cas restants, c'est dire les deux boolens 0' et 1', et le tuple vide
<> sont sans mystre : chacune de ces valeurs est diffrente des autres.
Implication
La condition
a 1 => a 2
s'nonce : les arbres a1 et a2 sont tous les deux des boolens et si a1 vaut 1'
alors a2 vaut 1' . Puisque a1 et a2 sont des boolens, il n'existe que quatre
cas possibles et nous pouvons dfinir cette contrainte par un tableau :
a1
a2
la contrainte a 1 => a 2 est-elle satisfaite ?
0'
0'
oui
0'
1'
1'
0'
oui
non
1'
1'
oui
Comparaisons numriques
Les conditions
a1
a1
a1
a1
52
Prolog
HERITAGE
a2
<= a 2
> a2
>= a 2
<
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
sont vrifies si les arbres a1 et a2 sont tous les deux des nombres et si a1 est
infrieur (resp. infrieur ou gal, suprieur, suprieur ou gal) a2
Relations unaires
Les relations unaires sont souvent appeles des relations de type, car elles
concernent principalement la nature de l'tiquette du nud initial de l'arbre
sur lequel elles portent. Dans certains cas, elles mettent aussi en jeu le
nombre de fils du nud initial.
a
a
a
a
!numt
!chart
!boolt
!idt
Ces conditions sont vrifies si le nud initial de l'arbre a est tiquet par,
respectivement, un nombre, un caractre, un boolen, un identificateur.
Aucune condition n'est impose pour les autres nuds.
a !tuple
Cette condition est vrifie si le nud initial de l'arbre a est <> , autrement
dit si a est un PIII-tuple. Aucune condition ne doit tre vrifie par les autres
nuds.
a :: n
Cette condition se lit n est un nombre entier non ngatif et du nud initial
de a partent n branches . Souvent mise en conjonction avec la prcdente,
elles quivalent alors, ensemble, a est un tuple de longueur n
a
a
a
a
!num
!char
!bool
!id
PrologIA
53
Concepts de base
Aociation
Ces conditions sont vrifies si a est une feuille, et si son unique nud est tiquet par un nombre (resp. un caractre, un boolen, un identificateur). Par
consquent :
a
a
a
a
!num
!char
!bool
!id
quivaut
quivaut
quivaut
quivaut
a
a
a
a
et
! c h a r t et
! b o o l t et
!idt
et
!numt
a
a
a
a
::0
::0
::0
::0
7 . Contraintes
De la mme manire que nous sommes passs des arbres aux termes, nous
allons passer des conditions aux contraintes. Une condition tait constitue
par l'application d'une relation, entit mathmatique, un arbre ou un
couple d'arbres, lments du domaine de Prolog III. Une contrainte sera un
objet syntaxique, form partir du symbole qui exprime une relation et un
terme ou un couple de termes, sur lesquels on dira encore que la relation
porte. Nous allons donc
- nous transporter sur un plan syntaxique1
- introduire les variables
Syntaxe
Dans les programmes Prolog III, les contraintes sont toujours exprimes au
sein de systmes de contraintes. Un systme de contraintes est une suite finie
de contraintes spares par des virgules, encadre par des accolades :
<systme de contraintes>
::= { }
::= { <contrainte> {, <contrainte> } }
En expliquant les conditions sur des arbres nous n'avons pas pu faire autrement que de
dfinir en mme temps les symboles qui expriment les relations ; nous avons donc dj donn
l'essentiel de la syntaxe des contraintes. Bien entendu, une contrainte sur des termes sans
variable n'est rien d'autre que l'expression crite d'une condition sur des arbres.
54
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
<contrainte>
::= <terme> = <terme>
::= <terme> # <terme>
::= <terme> => <terme>
::= <contrainte de typage>
::= <contrainte Sup>
::= <contrainte Inf>
<contrainte Sup>
::= <terme> <terme>
::= <contrainte Sup> <terme>
<contrainte Inf>
::= <terme> <inf> <terme>
::= <contrainte Inf> <inf> <terme>
<inf>
::= < | <=

::= > | >=
<type darbre>
::= !idt | !boolt | !numt | !chart | !tuple
::= !id | !bool | !num | !char
<contrainte de typage>
::= <terme> <type d'arbre>
::= <terme> :: <terme>
Relativement ce que nous savions dj, cette syntaxe ajoute surtout un
dtail : il est permis d'agglutiner plusieurs contraintes <, , > ou condition
qu'elles soient toutes de type <, ou toutes de type >, . On pourra donc
crire { 1 < x < y 3 } la place de { 1 < x, x < y, y 3 }
PrologIA
55
Concepts de base
Aociation
Exemples
Voici des contraintes syntaxiquement correctes :
X
!num
(1)
!id
(2)
(3)
A # B(I, J + 1)
<P,
"Durand">
<"Pierre",
N>
(4)
A => B & C
(5)
0 < T < 3X/4 + 5Y
(6)
et des formules qui ne sont pas des contraintes correctes :
4X + Z
(1)
TT(X)
(2)
A & B
(3)
(X = Y) & (Y = Z)
(4)
(1), (2) et (3) souffrent du mme mal : ce sont des termes corrects, non des
contraintes. Pour (4) c'est plus grave : une contrainte (ici X = Y) ne peut en
aucun cas figurer dans un terme, de plus (4) traduit une confusion entre les
boolens, lments du domaine de Prolog III, et la vrit ou la fausset des
contraintes.
8.
Rsolution des systmes de

contraintes
Une condition portant sur des arbres est gnralement la formalisation d'un
nonc dont implicitement on prtend qu'il est vrai, comme a est gal b .
On peut en dire autant au sujet d'une contrainte portant sur des termes sans
variable, puisque de tels termes reprsentent sans ambigut des arbres
uniques. Il nous reste dfinir ce que signifie tre vrifie pour une
contrainte portant sur des termes avec des variables.
56
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
Nous avons expliqu comment une affectation de l'ensemble des variables

permet de transformer un terme en un arbre ; appliqu chacun des termes
qui y figurent, le mme procd permet de transformer une contrainte sur
des termes en une condition sur des arbres. Un systme de contraintes sera
dit vrifiable, ou plutt soluble, s'il existe au moins une affectation des
variables apparaissant dans le systme par laquelle ce dernier se transforme
en un ensemble de conditions vraies sur des arbres. L'affectation en
question s'appelle une solution du systme de contraintes.
Par exemple, le systme de contraintes
{ P 0, L 0, P + L = 16 }
est soluble puisque, parmi d'autres, l'affectation
{ P 8, L 8 }
le transforme dans l'ensemble de conditions :
{ 8 0, 8 0, 8 + 8 = 16 }
Parlant familirement nous dirons que, o qu'elles apparaissent dans un
programme Prolog III, les contraintes demandent tre vrifies. Une
grande partie du travail de la machine Prolog III sera de veiller ce que le
systme de toutes les contraintes prises en considration soit constamment
soluble. Mais on ne se contentera pas de cela : la solubilit tant acquise, les
valeurs qu'on doit affecter aux variables du systme de contraintes, ou
certaines de ces variables, pour le transformer en un ensemble de conditions
vraies nous intressent beaucoup ; l'obtention de ces valeurs tait souvent le
but principal du programme en question.
Par exemple, le systme de contraintes
{ P 0, L 0, P + L = 16, 2P + 4L = 44 }
est soluble lui aussi, puisque l'affectation
{ P 10, L 6 }
PrologIA
57
Concepts de base
Aociation
le transforme en un ensemble de conditions vraies. Mais celle-ci est maintenant l'unique affectation ayant cette proprit ; les valeurs qui y figurent
constituent donc la solution unique du systme, ce qui sans doute intresse
beaucoup l'auteur de ce programme.
Les contraintes sont crites avec des relations partielles et des termes qui
eux-mmes sont construits l'aide d'oprations partielles. Lorsqu'on
considre une affectation qui transforme une contrainte en une condition sur
des arbres, avant de pouvoir se demander si la condition est satisfaite, il faut
dj que les arbres qui y figureront soient bien dfinis. Pour cette raison les
contraintes de Prolog III imposent gnralement aux variables qui y figurent
bien plus de limitations que celles qu'exprime au premier chef la relation qui
chapeaute la contrainte.
Par exemple, la contrainte
X = +Y
fait intervenir l'opration + unaire , qui n'est dfinie que sur les nombres.
Toute affectation de X et Y qui transformera cette contrainte en une
condition vraie devra affecter un nombre Y . Cette contrainte impose
d'abord la variable Y d'tre numrique, ensuite d'tre gale la variable X.
Autrement dit, les systmes { X = +Y } et { Y !num , X = Y } sont quivalents 1 . De manire analogue, les systmes { T = 1/X } et { X !num ,
X # 0 , T = 1/X } sont eux aussi quivalents.
Examinons d'autres exemples de systmes de contraintes du mme genre :
{
{
{
{
T = X[Y]
T = <>[y]
(1)
(2)
}
T = (+X)[Y] }
(3)
T = (~X)[Y]
(4)
Comme en mathmatiques, nous dirons que deux systmes sont quivalents lorsqu'ils
ont le mme ensemble de solutions.
58
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
Le terme X[Y] reprsente l'ensemble des arbres qui ont X pour tiquette et
Y pour suite de fils c'est--dire, puisqu'aucune autre contrainte ne pse sur X
ou sur Y, l'ensemble de tous les arbres : la contrainte (1) est satisfaite quelque
soit l'arbre donn pour valeur T.
Les contraintes (2), (3) et (4) n'ajoutent aucune autre limitation sur la suite
des fils de T ; en revanche, faisant intervenir des oprateurs arithmtiques
ou boolens, elles dterminent le type de l'tiquette de cet arbre. En
dfinitive, ces quatre systmes de contraintes sont respectivement quivalents
{
{
{
{
(1)
}
T !boolt }
T !numt }
T
(2)
!tuple
(3)
(4)
Restons dans les exemples un peu bizarres et examinons les deux

contraintes
{ +X # ~Y }
{ +X = ~Y }
(1)
(2)
Le systme (1) est quivalent { X !num, Y !bool }. En effet, les oprateurs

prsents imposent ces types aux variables X et Y et la relation # n'ajoute rien
puisque pour tout nombre n et tout boolen b on a n # b. Pour la mme
raison, le systme (2) est insoluble.
Signalons pour terminer que les expressions
{ +X = ~X }
{ +X # ~X }
(1)
(2)
seront rejetes par l'analyseur de Prolog III. Bien que d'un point de vue
strictement syntaxique elles soient correctes, comme il n'existe aucun arbre
qui soit simultanment numrique et boolen, il n'existe donc aucune
affectation qui transforme ces contraintes en des conditions vrifies sur des
arbres.
PrologIA
59
Concepts de base
Aociation
9 . Rgles et requtes
Syntaxe
Nous en arrivons enfin aux programmes Prolog III. Ceux-ci sont constitus
de rgles ; chacune comporte une tte, qui est un terme, et une queue forme
d'une suite de buts et d'un systme de contraintes. La suite de buts peut tre
vide, le systme de contraintes aussi. Quand le systme de contraintes est
vide, il peut tre omis.
<rgle>
::= <tte>
-> { <but> } [ , <systme de contraintes> ] ;
<requte>
::= { <but> } [ , <systme de contraintes> ] ;
<but>
::= /
::= <terme>
<tte>
::= <terme>
Voici des exemples de rgles correctes :
r e p a s(X,Y,Z) -> h ors_d _ o e u v r e ( X ) p l a t ( Y ) d e s s e r t ( Z ) ;
somme(<X>.L,S) -> somme(L,S0) , { S = S0 + X } ;
poules_lapins(P, L, P + L, 2P + 4L) -> ;
Pour activer un programme on doit composer une requte. Une requte est
la mme chose qu'une queue de rgle. Voici des exemples de requtes correctes :
60
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
hors_d_oeuvre(X ) p l a t ( Y ) d e s s e r t ( Z ) ;
repas(H, sole, D) , { H # salade } ;
poules_lapins(P , L , 1 6 , 4 4 ) ;
circuit(A,B,C) / , { C|A&~B = 0', D=>C, D#B } ;
Signification d'un programme Prolog III
Examinons maintenant la signification d'un programme Prolog III. Elle est

double : d'une part il constitue la dfinition rcursive d'un ensemble d'arbres
qui sont considrs comme des faits vrais par le programmeur ; c'est ce qu'on
appelle la smantique dclarative du langage. D'autre part, un programme se
traduit, pour l'interprte de Prolog III, en une suite d'actions excuter, de
deux sortes : des rsolutions de systmes de contraintes et des appels de
procdures. Nous appellerons cela la smantique oprationnelle de Prolog III.
L'ensemble des faits dfinis par un programme Prolog III

Un programme est fait de rgles de la forme :
t0 t1 t2 tn , S ;
(1)
o t 0 est un terme, t 1 t n sont des termes1 et S est un ensemble de

contraintes. Nous savons que chaque affectation A de l'ensemble des
variables de cette rgle transforme les termes ti en des arbres a i = t i/A et
l'ensemble S de contraintes en un ensemble C = S /A de conditions sur des
arbres. Par consquent, une rgle telle que (1) engendre tout un ensemble
de rgles portant sur des arbres, une pour chaque affectation A qui rend vraies
les conditions C = S/A, de la forme :
a0 a1 a2 an ;
(2)
Nous ignorerons pour le moment le cas de la coupure /, qui peut figurer dans une queue
de rgle la place d'un terme.
PrologIA
61
Concepts de base
Aociation
Une telle rgle sans variable exprime une proprit logique, qui s'nonce :
si a1, a2 an sont des faits, alors a0 est un fait .
Dans le cas n = 0 on a une rgle sans queue :
a0 ;
(3)
la proprit logique correspondante est tout simplement a0 est un fait .

Dans ces conditions, l'ensemble qu'un programme Prolog III dfinit est le
plus petit ensemble de faits satisfaisant toutes les proprits logiques
engendres par les rgles du programme. Ce dernier est donc compos de
rgles qui noncent des faits explicites (les rgles sans queue et sans variable,
du type (3)) et de toutes les autres rgles, qu'on peut voir comme des
procds de dduction pour produire les faits implicites.
Considrons par exemple le programme trs simple :
p r i x (fleurs,120) - > ;
p r i x (chocolats,90) - > ;
p r i x(vin,50) - > ;
p r i x (poisson_seche,40 ) - > ;
c a d eau(chocolats) - > ;
c a d eau(vin) - > ;
c a d e au(fleurs) - > ;
c a d e au_pas_cher(X) - >
cadeau(X)
prix(X,P) ,
{ P <= 100 } ;
Compte tenu des contraintes, la dernire rgle donne lieu aux rgles sur des
arbres :
c a d e au_pas_cher(poiss o n _ s e c h e ) - >
cadeau(poisson_seche)
prix(poisson_seche,40);
62
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
cadeau_pas_cher ( c h o c o l a t s ) - >
cadeau(chocolats)
prix(chocolats,90);
cadeau_pas_cher ( v i n ) - >
cadeau(vin)
prix(vin,50);
et puisque cadeau(chocolats) , prix(chocolats, 90) , cadeau(vin)

et p r i x ( v i n , 5 0 ) sont des faits, on en dduira que
c a d e a u _ p a s _ c h e r ( c h o c o l a t s ) et c a d e a u _ p a s _ c h e r ( v i n ) sont eux
aussi des faits. Ce programme dfinit donc l'ensemble de faits :

{ prix(fleurs, 120), prix(chocolats, 90), prix(vin, 50),
prix(poisson_seche, 40) , cadeau(chocolats) , cadeau(vin),
cadeau(fleurs) , cadeau_pas_cher(chocolats) ,
cadeau_pas_cher(vin) }.
Seuls les deux derniers de ces faits n'taient pas explicites.
Excution d'un programme

Nous venons de montrer quelle est l'information implicite contenue dans un
programme Prolog III. Examinons maintenant en quoi consiste son
excution par la machine. Cette excution vise rsoudre le problme
suivant : tant donns une suite t1 t2 tn de termes et un systme S de
contraintes, trouver les valeurs des variables qui transforment les termes ti
en des faits dfinis par le programme et les contraintes de S en des
conditions verifies
Ce problme sera soumis la machine sous la forme d'une requte
t1 t2 tn , S
Avec deux cas particuliers intressants :
PrologIA
63
Concepts de base
Aociation
- si la suite t 1 t 2 t n est vide, alors la requte se rsume demander la

rsolution du systme S
- si le systme S est vide et n = 1 alors la requte se rsume la question
pour quelles valeurs des variables le terme t1 se transforme en un fait
dfini par le programme ?
Pour expliquer comment Prolog III calcule la rponse ces questions nous
allons introduire une machine abstraite. Il s'agit d'une machine non
dterministe, dont l'unique instruction de base est dcrite par les trois
formules suivantes :
(1)
( W, t0 t1 tn , S )
(2)
s0 s1 s m , R
(3)
( W, s1 sm t1 tn , S R { s0 = t0 } )
La formule (1) reprsente l'tat de la machine un instant donn. La requte

courante est t0 t1 tn , S. W est l'ensemble des variables auxquelles on
s'intresse.
La formule (2) reprsente la rgle du programme utilise pour changer
d'tat. Au besoin, on a renomm certaines de ses variables, pour qu'elle
n'en ait aucune de commune avec (1). Les autres rgles du programme
auraient pu tre employes aussi bien ; utiliser celle-ci plutt qu'une autre
rsulte d'un choix.
La formule (3) reprsente le nouvel tat de la machine, aprs l'application de
la rgle (2). Le passage dans cet tat n'est possible que si le systme de
contraintes S R { s0 = t0 } possde une solution pour laquelle chacun des
termes de la suite s1 sm t1 tn reprsente un arbre bien dfini.
64
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Concepts de base
HERITAGE
Pour rpondre la requte t0 tn , S la machine partira de l'tat initial

( W, t 0 t n , S ), o W est l'ensemble des variables qui figurent dans la
requte, et passera dans tous les tats qu'elle peut atteindre en rptant
l'opration de base ci-dessus. Bien entendu, le choix exprim par la formule
(2) n'est pas laiss au hasard : Prolog III fait en sorte que toutes les rgles
soient successivement essayes1, dans l'ordre o elles ont t crites dans le
programme.
Ainsi, la machine Prolog III est en ralit la machine
(dterministe) qui produit toutes les excutions possibles de la machine non

dterministe dfinie par les expressions (1), (2), (3).
Chaque fois qu'il parviendra un tat de la forme
( W, , S )
c'est--dire dont la suite de buts est vide, Prolog III fournira comme rponse
la solution du systme S sur l'ensemble de variables W.
Par exemple, partir de la requte trs simple
cadeau_pas_cher(X);
des tats de la machine seront (on ne montre pas les tapes promises
chouer) :
{X}, cadeau_pas _ c h e r ( X ) , { } ;
utilisation de la rgle cadeau_pas_cher(X) -> etc :

{X}, cadeau(X')
prix(X',P') ,
{P100,cadeau_pas_cher(X)=cadeau_pas_cher(X')};
qui se simplifie en :
{ X } , cadeau(X')
prix(X',P') , { P 1 0 0 , X = X ' } ;
Ou tout au moins toutes les rgles raisonnables, c'est--dire toutes sauf celles qui de
manire vidente rendraient le systme S R { s0 = t0 } insoluble.
PrologIA
65
Concepts de base
Aociation
utilisation de la rgle cadeau(chocolats) ->; :

{ X } , prix(X',P')
{P'100,X=X',cadeau(X')=cadeau(chocolats)};
qui se simplifie son tour en :

{ X } , prix(X',P')
{P'100,X=X',X'=chocolats};
utilisation de la rgle prix(chocolats,90) ->; :

{X}, ,
{P'100,X=X',X'=chocolats,
prix(X',P')=prix(chocolats,90)};
lequel se simplifie en :
{X},
{P'100,X=X',X'=chocolats,P'=90)};
La suite de buts tant devenue vide, Prolog III affiche alors la solution du
systme courant S = {P' 100,X=X',X'=chocolats,P'=90)} , ou plutt la
partie intressante de cette solution, soit
{X = c h o c o l a t s }
ensuite Prolog III explore les autres excutions possibles de la machine non
dterministe (1), (2), (3) ; c'est ainsi que la solution
{X = v i n }
est affiche peu aprs.

ststs
66
Prolog
HERITAGE
PrologIA
Aociation
Prolog
HERITAGE
Arbres, tuples, chanes et listes
1.
2.
3.
4.
5.
6.
7.
Introduction
Les arbres
Les tuples
Rgles prdfinies sur les tuples
Les listes
Les chanes
Exemples
Le domaine de Prolog III est celui des arbres (finis et infinis). Un nouvel oprateur
universel a t ajout par rapport aux Prolog standard : le constructeur gnral
d'arbres. La notion de liste a galement t tendue celle de tuple, et ce domaine
muni d'une vritable opration de concatnation. Les chanes de caractres sont,
d'autre part, un sous-ensemble des tuples. Enfin, pour des raisons de compatibilit
et d'efficacit, les listes classiques de Prolog ont t conserves. Ce chapitre prsente
les oprations et les relations dfinies sur les arbres et les tuples, ainsi qu'un
certain nombre d'exemples utilisant des contraintes sur ces domaines.
Dcembre 1990
PrologIA
1 . Introduction
Prolog III amliore sensiblement le traitement des arbres, en introduisant un
oprateur qui autorise la reprsentation d'un arbre de manire totalement
gnrique, indpendamment de son arit. En ce qui concerne les listes,
structures de donnes de base des programmes Prolog, lamlioration
apporte par Prolog III est fondamentale et introduit un nouvel objet : le
tuple. Cette volution rpond un double constat. Tout dabord, la
structure mme de liste, un arbre construit partir dun symbole fonctionnel
binaire, rend l'opration de concatnation trs onreuse. Ensuite, tout accs
au n-ime lment dune liste (y compris lors d'une concatnation
programme en Prolog) ne peut tre effectu quau travers dun parcours
squentiel. Ces deux inconvnients sont supprims grce lintroduction de
contraintes sur les tuples, munis dune concatnation dont les proprits
rpondent ce que lon est en droit dattendre.
2 . Les arbres
Les arbres forment la classe la plus gnrale dobjets dfinis en Prolog III.
Tous les objets dfinis dans la suite de ce document (tuples, listes, chanes,
valeurs numriques ou boolennes, ) sont des lments de lensemble des
arbres et toute variable Prolog III reprsente une valeur prise dans cet ensemble.
Ces arbres sont composs de nuds tiquets par :
des identificateurs,
des caractres,
les valeurs boolennes 0' et 1',
des valeurs numriques ,
le signe spcial <>
70
On prendra bien garde ne pas confondre arbres et termes. Les

arbres sont des lments du domaine de Prolog III ; les termes
sont des constructions syntaxiques.
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Voici un exemple darbre :

rable
<>
feuilles
à` `c` è` `r` lobes
caduques
1'
Les arbres dont ltiquette initiale est un identificateur sont appels arbres
factuels, et ceux dont ltiquette initiale est le signe <> sont appels tuples. Les
tuples dont tous les lments sont des caractres sont appels chanes.
NOTATION : En Prolog III, les chanes sont plutt reprsentes

entre guillemets (par exemple : "Ralliez vous mon
panache
blanc" ) et les tuples entre chevrons (par exemple
<Marignan,
1515,
1'> ).
Oprations sur les arbres

Les oprations dfinies sur les arbres sont les oprations de construction. On
trouve ainsi, comme en Prolog II le constructeur darbres, mais galement
deux nouveaux oprateurs, le constructeur de tuple, et le constructeur gnral
darbres, qui permet de dsigner tout arbre de manire totalement
gnrique, indpendamment de son nombre de fils. Voici les schmas
illustrant ces oprations.
PrologIA
71

x (x x )
0 1
n
x1
Le constructeur darbres
<x0 xn >
<>
=
x0
xn
Le constructeur de tuples
[ <> ]
Le constructeur gnral darbres

Le constructeur gnral d'arbres permet de reprsenter tout arbre l'aide
seulement de son tiquette initiale et du tuple form de ses fils immdiats.
ATTENTION : on ne peut pas insrer d'espaces entre le terme qui
reprsente l'tiquette de l'arbre et la parenthse ouvrante du

constructeur. C'est l l'un des rares cas en Prolog III o l'criture
d'un blanc est interdite.
Voici quelques exemples de l'utilisation de ces divers constructeurs. On

donne ici plusieurs formes syntaxiques possibles qui utilisent les diffrents
constructeurs, et les arbres correspondants :
72
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
exemple
exemple(1,2,3)
exemple[<1,2,3>]
<>
<1,2,3>
<>(1,2,3)
<>[<1,2,3>]
1
exemple
exemple(<1,2,3>)
exemple[<<1,2,3>>]
<>
Voici enfin un exemple du mme type portant sur une chane de caractres :
<>
"123"
<>(`1`,`2`,`3`)
<>["123"]
<>[<`1`,`2`,`3`>]
`1`
PrologIA
`2`
`3`
73
Aociation
Contraintes sur les arbres

Les contraintes sont construites laide de relations. Les relations utilises
sur les arbres sont :
lgalit (=),
lingalit (#),
la relation unaire qui impose un arbre d'avoir un nombre dtermin
de fils immdiats. Dans le cas o cet arbre est reprsent par la
variable A et son nombre de fils par N, cette relation se note A::N.
Exemples
Voici quelques exemples de contraintes sur les arbres.
{X
Erable("acer",feuilles(lobes(7),caduques(1')))}
Cette contrainte impose la variable X de reprsenter l'arbre donn en

exemple prcdemment.
{X = E[U],Y = E[V]}
Cet ensemble de contraintes impose aux variables X et Y de reprsenter deux

arbres dont les tiquettes initiales sont gales
{X = E[U], E # <>}
Cette contrainte impose la variable X de reprsenter un arbre qui ne soit

pas un tuple.
Examinons enfin quelques excutions qui illustrent l'utilisation de ce type de
contraintes :
74
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
> {E[U] = exemple(1,2,3)};

{E = exemple, U = <1,2,3>}
> {E[U] = <1,2,3>};
{E = <>, U = <1,2,3>}
> {E[U] = exemple(<1,2,3>)};
{E = exemple, U = <<1,2,3>>}
> {E[U] = "123"};
{E = <>, U = "123"}
> {E[U] = 121/3};
{E = 121/3, U = <>}
Les exemples suivants montrent comment sont simplifies certaines

quations sur les arbres :
> {X(Y) = Y(X) };

{Y = X, X::0 }
> {<X> = X[Y]};
{X = <>, Y = <<>>}
> {Y[X] = X[Y] };
{Y = <>, X = <>}
Voici enfin des exemples qui montrent des contraintes pour lesquelles les
solutions sont des arbres infinis :
> {X(Y) = X[Y]};

{Y = <Y>, X::0 }
> {X(Y) = <<X,Y>>};
{X = <>, Y = <<>,Y>}
PrologIA
75
Aociation
Restrictions sur la contrainte de taille

En Prolog III on ne peut imposer un arbre d'avoir un nombre dtermin
de fils immdiats qu' la condition que ce nombre soit une constante, c'est-dire un entier positif. Toutefois, pour augmenter la facilit de
programmation, si ce nombre est reprsent par un terme contenant des
variables un mcanisme de retardement est mis en place par Prolog III.
Nous reviendrons sur ce mcanisme dans le chapitre spcialement consacr
aux retardements.
{E[<X, ff(Y)>. Z] :: 13};
Dans une contrainte de taille, le nombre de fils immdiats

doit tre explicitement connu
3 . Les tuples
On appelle tuple tout arbre dont ltiquette initiale est <>. Cette premire
dfinition permet de considrer les tuples comme des suites finies darbres.
On notera au passage que laspect fini se rapporte au nombre dlments (et
non pas la profondeur de ceux-ci), et que le caractre de suite induit un
ordre sur ces lments (les tuples ne sont pas des ensembles). On appellera
souvent taille le nombre de fils dun tuple.
Oprations
La seule opration dfinie sur les tuples est lopration de concatnation,
note par un point (.). Cette opration construit, partir de deux tuples
T1 et T2, respectivement de tailles n et m, le tuple T1.T2, de taille m+n,
dont les n premiers fils sont ceux de T1, et les m suivants ceux de T2.
76
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Ceci peut sillustrer par le schma suivant :
<>
x1
<>
xn
y1
<>
=
ym
x1 xn y1 ym
Concatnation de deux tuples
Relations
Les relations qui permettent de construire des contraintes sur les tuples sont
les mmes que celles utilises pour les arbres, savoir l'galit, l'ingalit, et
la relation unaire permettant d'associer un tuple le nombre de ses
lments. Dans ce dernier cas, on dispose de la relation de taille sur les
arbres, mais galement d'une relation unaire qui impose un terme T de
reprsenter un tuple (T !tuple).
Restrictions concernant les tuples

Pour raliser un bon compromis entre la complexit des contraintes traites
et les considrations d'efficacit lies la ralisation d'un langage de
programmation, Prolog III impose un certain nombre de restrictions sur ces
contraintes. En ce qui concerne les tuples, cette restriction porte
principalement sur le fait que tout tuple figurant en membre gauche d'une
opration de concatnation doit tre de taille explicitement connue. La seconde
restriction dcoule naturellement de celle impose aux arbres, savoir que
pour toute contrainte de taille portant sur un tuple, le nombre reprsentant
celle-ci doit tre explicitement connu. Dans le cas o ces restrictions ne sont
pas respectes, un mcanisme de retardement, que nous dtaillerons par la
suite, est mis en place (voir le chapitre entirement consacr aux
retardements)
PrologIA
77

{
U.V.W = <E>.Z,
U :: 4, V :: 2 }
Tout tuple figurant en membre gauche d'une opration de

concatnation doit tre de taille explicitement connue
Exemples de contraintes sur les tuples

Voici un certain nombre de systmes de contraintes corrects portant sur des
tuples :
{<1,2,3>.V
{<E>.U
Z}
V}
{U.V = W,U :: 100}
{U.<E,F>.V = W, U :: 4}
{(U.V).W = T,U :: 2,V :: 4}
On notera dans ces exemples que pour toute concatnation, la taille des
oprandes gauches est connue.
Voici, cette fois quelques excutions de ce types de contraintes, qui montrent
l'ensemble des solutions correspondantes :
> {<0>.U = U.<0>, U :: 10};

{U = <0,0,0,0,0,0,0,0,0,0>}
> {Z :: 10, <1,2,3>.Z = Z.<2,3,1>};
{Z = <1,2,3,1,2,3,1,2,3,1>}
78
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Rcapitulatif des oprations et relations

Pour rcapituler, voici toutes les oprations et relations utilisables sur les
arbres et les tuples :
Oprations et relations dfinies sur les arbres

oprations
constructeur d'arbre
x 0 (x 1 , ..., xn )
constructeur gnral d'arbre
x 0 [<x 1 , ..., xn > ]
relations
galit
x = y
ingalit
x # y
taille
x :: n
Oprations et relations dfinies sur les tuples

oprations
constructeur de tuple
<x 0 , x1 , ..., xn >
concatnation
u.v
relations
galit
u = v
ingalit
u # v
taille
u :: n
typage
!tuple
PrologIA
79
Aociation
4 . Rgles prdfinies sur les tuples

Les rgles prdfinies qui concernent la taille des tuples se divisent, on aura
l'occasion de le revoir souvent, en deux classes : les rgles occasionnant un
retardement et celles pour lesquelles ce n'est pas le cas. On retrouvera une
description dtaille et des exemples dans le chapitre "Rgles prdfinies et
procdures externes".
Tailles et concatnations
bound_size(T,N) : Pose la contrainte {T :: N} lorsque N est un entier
positif connu, ou {N = k} si k est la taille de T . Echoue si T n'est pas de
taille connue et si N est inconnu ou ne reprsente pas une valeur entire
positive.
size(U,N) : Pose la contrainte {U :: N}, avec les retardements ncessaires
si N et la taille de U ne sont pas connus. Echoue si N est connu mais ne
reprsente pas une valeur entire positive.
bound_conc(U1,U2,U3) : Pose la contrainte {U3 = U1.U2}. Echoue si la
taille du tuple U1 n'est pas connue.
c o n c 3 ( U 1 , U 2 , U 3 ) : Pose l'ensemble de contraintes suivant :
{ U3 = U1.U2,
N1 >= 0,
U1 :: N1,
U2 :: N2,
U3 :: N3,
N3 = N1+N2,
N2 >= 0} , avec les ventuels retardements lorsque N1, N2 ou
N3 ne sont pas connus.
arg3(N,T1,T2) : Cette primitive pose la contrainte {T2 = N'}, o N'

est le Nime argument du tuple T1. Si N est nul, T2 est gal l'tiquette
initiale de T1 c'est--dire <>. Echoue si N n'est pas un entier positif connu ou
si T1 n'est pas un tuple.
80
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Divers
arg(N,T1,T2) : Cette primitive pose la contrainte {T2 = N'}, o N' est
le Nime argument du terme T1. Si N est nul, T2 est gal l'tiquette initiale
de T1. En particulier, si T1 est un tuple T2 reprsente le Nime lment de ce
tuple. Echoue si N n'est pas un entier positif connu.
known_part(U1,U2,U3) : Pose la contrainte {U1 = U2.U3}, o U2 est un
tuple form de la plus grande suite de taille connue des premiers lments
de U1 .
split(U,L) : Pose la contrainte {L = L'}, o L' est la liste compose des
lments qui forment le tuple U (voir la suite de ce chapitre concernant les
listes). Echoue lorsque le tuple U n'est pas connu l'excution.
tuple(U) : S'excute avec succs si U reprsente un tuple entirement connu
(voir le prdicat bound). Echoue dans tous les autres cas.
is_tuple(U) : Vrifie que le terme U reprsente un tuple c'est--dire que la
contrainte {U !tuple} appartient au systme courant. Echoue dans le cas
contraire.
Un exemple de programme sur les tuples

Comme premier exemple de programme, nous nous proposons de
considrer le retournement (ou inversion) d'un tuple. Nous examinerons
successivement la manire habituellement utilise en Prolog, puis la
programmation en Prolog III, et nous terminerons par l'examen d'un
programme utilisant des contraintes retardes.
Voici tout d'abord le programme classique, ceci prs que l'on utilise des
tuples au lieu de listes. On pourra en profiter pour noter la manire
d'exprimer un tuple la mode Prolog standard (un couple tte-de-liste,
queue-de-liste) l'aide de la concatnation. Le rapport, dans ce cas, entre le
E.L de Prolog II et le <E>.L de Prolog III n'est, on l'aura compris que
purement fonctionnel, la smantique du . (point) demeurant fondamen-
PrologIA
81

talement diffrente. On retrouvera galement dans ce programme, peut tre
avec une certaine motion, le toujours fameux prdicat conc.
naive_reverse(<>,<>) -> ;
naive_reverse(<E>.X,X') ->
naive_reverse(X,X'')
conc(X'',<E>,X') ;
conc(<>,X,X) -> ;
conc(<E>.X,Y,<E>.Z) ->
conc(X,Y,Z) ;
Voici maintenant le mme programme, qui utilise cette fois-ci la

concatnation de Prolog III. Le prdicat bound_conc installe la contrainte
{X' = X''.<E>} aprs l'excution de naive_reverse . On est alors certain
de connatre la taille du tuple X''. Il n'y a donc aucun retard mis en place.
Cette manire de faire est bien plus efficace que la premire, dans la mesure
o la concatnation de Prolog III est bien suprieure au prdicat conc dcrit
dans le programme prcdent.
naive_reverse(<>, <>) -> ;

naive_reverse(<E>.X,X') ->
naive_reverse(X,X'')
bound_conc(X'',<E>,X') ;
Voici enfin un troisime programme, qui met en place les concatnations

avant l'excution de naive_reverse. Des contraintes retardes sont alors
mises en place (voir chapitre sur les retardements). Si le programme fournit
les rsultats attendus, les temps d'excutions sont moins bons que dans le cas
prcdent, en raison de la gestion des retards.
naive_reverse(<>,<>) -> ;
naive_reverse(<E>.X,X'.<E>) ->
naive_reverse(X,X') ;
82
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
5 . Les listes
Pour des raisons d'efficacit, et bien que l'oprateur binaire utilis pour les
listes en Prolog classique puisse tre aisment remplac par une concatnation, Prolog III permet l'utilisation de listes classiques construites sur la
notion de paire pointe, l'aide d'un symbole fonctionnel binaire reprsent
par [].
Syntaxiquement les formes suivantes sont permises :
[U|L]
qui reprsente une liste de tte U et de

queue L
[U1,U2,...,Un]
qui reprsente une liste forme des

lments U1,U2,...,Un
[U1,U2,...,Un|L]
qui reprsente une liste dont les premiers

lments sont U1,U2,...,Un et la queue
de liste L
Bien que la syntaxe ne soit pas ambigu, vous devez veiller ne pas
confondre l'oprateur binaire utilis pour les listes et reprsent par
des crochets (par exemple [U], pour une liste rduite un lment),
et l'oprateur n-aire de construction gnrale d'arbres, reprsent
par le mme symbole (par exemple E[U]).
A TTENTION : il y a une vritable ambigut dans le fait suivant :

comment distinguer une liste ayant A pour tte et B pour queue,
qu'on doit noter [A|B] , d'une liste rduite l'unique boolen,
rsultat de la disjonction des boolens A et B , qu'on devrait noter
encore [A|B] ? Cette ambigut est leve en imposant conventionnellement, dans le second cas, le parenthsage de l'expression
boolenne en question : [(A|B)]
Il n'y a aucune opration dfinie sur les listes en Prolog III autre que celles
concernant les arbres, et donc pas de contraintes particulires. On pourra
quelquefois privilgier ce type de structures dans des programmes sans
concatnations pour en amliorer les performances.
PrologIA
83
On peut se demander juste titre quel est le statut exact du double

symbole [] , qui dsigne la liste vide. La rponse est qu'il s'agit
d'un identificateur, qui devrait en toute rigueur tre reprsent
entre quotes, mais pour lequel il est tolr d'omettre ces quotes.
Les notations [] et ' [ ] ' (et mme s y s : [ ] ) sont donc
quivalentes.
Voici quelques excutions faisant intervenir des listes :
> {E[U] = [A,B,C|L]};

{E = '[]', U = <A,[B,C | L]>}
> {E(X,Y) = [A,B,C|L]};
{E = '[]', Y = [B,C | L], A = X}
> {[A,B,C|L] = [A'|L']};
{A' = A, L' = [B,C | L]}
> is_ident([]);
{}
Primitives sur les listes

arg2(N,L,T)
: Si N est nul, pose la contrainte {T = N'}, o N '
reprsente le nombre d'lment de la liste L . Si N n'est pas nul, pose la

contrainte {T = N'}, o N' est le Nime argument de la liste L. Echoue si N
n'est pas un entier positif connu ou si la liste L n'est pas suffisamment
connue.
list_tuple(L,U) : Pose la contrainte {U = U'}, o U' est le tuple
compos des lments qui forment la liste L (voir la suite de ce chapitre
concernant les listes). Echoue lorsque la liste L n'est pas entirement connue.
6 . Les chanes
Comme nous l'avons dj mentionn, les chanes en Prolog III sont des
tuples dont les lments sont des caractres. On peut donc utiliser sur les
84
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE

chanes l'opration de concatnation ainsi que les relations unaires et
binaires utilisables sur les tuples.
Voici quelques exemples de contraintes sur des chanes :
> {X."a" = "a".X, X :: 10};

{X = "aaaaaaaaaa"}
> {X = Y." une concatenation ".<`d`,è`,` `>.Z,
Y = <>(`V`,ò`,ì`,`c`,ì`), Z = U["chaine"]};
{X = "Voici une concatenation de chaine",
Y = "Voici",
Z = "chaine", U = <>}
Primitives sur les chanes

Il nous faut galement noter un certain nombre de rgles prdfinies et
prdicats valuables concernant les chanes de caractres. On se reportera
pour plus de dtails au chapitre Rgles prdfinies et procdures externes.
Manipulations de chanes
conc_string(S1,S2,S3) : Cette rgle prdfinie a le mme effet que son
homologue de Prolog II. Elle numre tous les triplets S1,S2,S3 de chanes
telles que S3 est la concatnation de S1 et S2. Ce prdicat ne russit que si
les chanes S1 et S2 ou bien la chane S3 sont entirement connues.
find_pattern(S1,S2,N) : Pose la contrainte {N = D} o D est la position
du dbut de la chane S2 dans la chane S1 . Si la chane S2 n'est pas
trouve, ou si S 1 et S 2 ne sont pas entirement connues, alors
find_pattern choue.
substring(S1,N1,N2,S2) : Pose la contrainte {S2 = S1'}, o S1' est
la sous-chane de S1 commenant la position N1, de longueur N2. Echoue
si une telle sous-chane n'existe pas ou si S1 n'est pas connue.
PrologIA
85

Conversions de chanes
list_string(L,S) : Pose la contrainte {S = L'}, o L' est une chane
compose des caractres qui forment la liste L. Echoue si la liste L n'est pas
entirement connue.
string_ident(P,S,I) :
Si I est connu : pose l'ensemble de contraintes {S = S',P = P'} o S'
est une chane compose des caractres de la reprsentation abrge de
l'identificateur I , et P' une chane compose des caractres formant le
prfixe de l'identificateur I.
Si S et P sont connus : pose l'ensemble de contraintes {I = I'}, o I' est
un identificateur compos des caractres de la chane reprsentant son
prfixe, P, et de celle reprsentant sa notation abrge, S.
string_integer(S,N) :
Si S est connu : pose l'ensemble de contraintes {N = S'} o S' est un
entier form partir des caractres de la chane S.
Si N est connu : pose l'ensemble de contraintes {S = N'}, o N' est une
chane forme des caractres qui composent l'entier N.
string_real(S,F) :
Si S est connu : pose l'ensemble de contraintes {F = S'} o S' est un
flottant form partir des caractres de la chane S.
Si F est connu : pose l'ensemble de contraintes {S = F'}, o F' est une
chane forme des caractres qui composent le flottant F.
string_bool(S,B) :
Si S est connu : pose l'ensemble de contraintes {B = S'} o S' est un
boolen form partir des caractres de la chane S.
Si B est connu : pose l'ensemble de contraintes {S = B'}, o B' est une
chane forme des caractres qui composent le boolen B.
Divers
string(S) : S'excute avec succs si S reprsente une chane entirement
connue. Echoue dans tous les autres cas.
86
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
7 . Exemples
Nous proposons ici un certain nombre de programmes, concernant plus
particulirement les tuples, qui montrent des possibilits d'utilisation.
Certains utilisant des contraintes retardes, il serait bon de se reporter au
chapitre correspondant si l'on dsire les examiner dans le dtail.
Calcul des feuilles dun arbre

Le programme suivant recherche les feuilles diffrentes de <> dans un arbre.
On notera la puissance de loprateur gnral de construction darbres, ainsi
que lutilisation des contraintes retardes.
feuilles(<>,<>) ->;
feuilles(A[<>], <A>) ->, {A#<>};
feuilles(A[.V], X.Y) ->
feuilles (U, X)
feuilles (V, Y);
Voici une excution de ce programme :
> feuilles(Erable("acer",feuilles(lobes(7),
caduques(1'))), L);
{L = "acer".<7,1'>}
Quick sort
Voici un programme de tri rcursif, le quick sort, qui utilise les contraintes
sur les tuples. Rappelons brivement lalgorithme utilis. Pour trier un tuple
compos de nombres, on choisit un lment, on partitionne le tuple en deux,
le premier tuple contenant les lments infrieurs ou gaux llment
considr, le second les lments strictement suprieurs. On applique alors
rcursivement lalgorithme sur les deux tuples ainsi forms jusqu arriver
au tuple vide.
PrologIA
87

Le choix de llment privilgi peut seffectuer de diverses manires. Nous
avons choisi ici, afin de mettre en vidence laccs direct, de choisir llment
situ au milieu du tuple.
trier(<>,<>) -> ;
trier(L,U.<X>.V) ->
partitionner(L,X,U',V')
trier(U',U)
trier(V',V);
partitionner(L,X,U',V') ->
trunc(N/2,N')
regrouper(X,L',U',V'),
{ L :: N,
U :: N',
L = U.<X>.V,
L' = U.V};
regrouper(X,<>,<>,<>) ->;
regrouper(X,<X'>.L,<X'>.U,V) ->
regrouper(X,L,U,V),
{ X' <= X};
regrouper(X,<X'>.L,U,<X'>.V) ->
regrouper(X,L,U,V),
{ X' > X};
On peut proposer un certain nombre d'excutions de ce programme. la

premire consiste effectuer un tri sur un tuple entirement connu :
> trier(<6,5,4,3,2,1>,L>);
{L = <1,2,3,4,5,6>}
On peut galement chercher les tuples qui, une fois tris, donnent un tuple
connu. Par exemple :
88
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
> trier(L,<1,2,3>)
{L = <1,2,3>}
{L = <1,3,2>}
{L = <2,1,3>}
{L = <2,3,1>}
{L = <3,2,1>}
{L = <3,1,2>}
>
::
};
Cette excution fournit, bien sr, toutes les permutations de n lments.

Enfin, on peut trier un tuple dont les lments sont inconnus, mais sur
lesquels on connait dj un ordre :
> trier(<X,Y,Z>,L),{Z>Y>=X};
{Y = X + X1, Z = X + X2 + X1,
L = <X,X + X1,X + X2 + X1>,
X1 >= 0 ,
X2 > 0 }
Les variables d'cart introduites ont t renommes X1 et X2.
Une suite priodique

Le but de ce programme est de montrer que la suite dfinie par :
Xi+2 = |Xi+1| - Xi
est priodique de priode 9
Voici le programme :
Suite(<Y,X>) ->;
Suite(<Y'-X,Y,X>.U) ->
Suite(<Y,X>.U)
Valeur_absolue(Y,Y');
PrologIA
89
Aociation
Valeur_absolue(Y,Y) -> , { Y >= 0 };

Valeur_absolue(Y,-Y) -> , { Y < 0 };
Ce programme se contente de dcrire la construction d'un tuple dont les

lments constituent une suite d'lments de la suite dfinie prcdemment.
Pour prouver que cette suite est priodique de priode 9, toute la subtilit
consiste poser une requte qui peut s'noncer de la manire suivante :
Quels sont les tuples de 11 lments dcrits par ce programme qui sont tels
que l'un ou l'autre des deux premiers lments soient diffrents de l'un ou
l'autre des deux derniers lments. Voici cette requte :
> Suite(U.V.W) ,
{ U :: 2, V :: 7, W :: 2, U # W };
>
La requte choue, ce qui signifie que l'ensemble des solutions est vide, et
prouve donc bien la proprit (!!). Elgant, non ?
Crible d'Eratosthne
Ce programme, qui calcule les nombres premiers infrieurs un entier N,
peut s'crire de manire plus efficace sans utiliser l'arithmtique sur la taille
des tuples. Il constitue cependant un excellent exemple de maniement des
tuples et de la concatnation. Voici le programme :
90
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
nombres_premiers(<1'>.Z) ->
cribles(2, X, Z),
{Z :: N, X :: N, X.<1'> = <1'>.X};
cribles(N, <>, <>) ->;
cribles(N, <0'>.X, <0'>.Z) ->
cribles(N+1, X, Z);
cribles(N, <1'>.X, <1'>.Z) ->
crible(N, X, Y)
cribles(N+1, Y, Z);
crible(N, X, X) -> {X :: M, N > M};
crible(N, X, Y) ->
Crible(N, X', Y')
{ X :: M, N <= M,
X = U.<E>.X',
Y = U.<0'>.Y',
U :: N-1 };
Pour construire le tuple form de valeurs boolennes o le rang de tout

lment gal 1' est un nombre premier, on procde de la manire
suivante (prdicat cribles) : pour un lment donn, et un nombre donn
(en commenant 2, et en initialisant le tuple de manire ce que tous les
lments soient gaux 1' ), si sa valeur est 0' , on la renvoie, sinon on
renvoie 1' , et on unifie 0' tous les lments multiples de N par simple
dcalage (i.e. l'aide de la concatnation). Cette dernire opration est
ralise par le prdicat crible.
N
Voici une excution :
>
nombres_premiers(Y), {Y :: 12};
{Y = <1',1',1',0',1',0',1',0',0',0',1',0'>}
ststs
PrologIA
91
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Les contraintes numriques
1. Introduction
2. Gnralits
- Les nombres
- Expressions numriques
- Les relations
- Contraintes numriques
- Exemples de contraintes numriques
- Restrictions
- Forme normale
3. Rgles prdfinies et procdures externes spcifiques
4. Retardement des contraintes non-linaires
5. Formats d'entre-sortie
6. Exemples de programmes
- Calcul bancaire
- Crypto-arihmtique
- Remplissage dun rectangle par des carrs

Parmi les diffrents domaines sur lesquels on peut faire porter des contraintes en
Prolog III, celui pour lequel on pressent d'ores et dj le plus d'applications est
certainement le domaine numrique. En effet, la possibilit, offerte en Prolog III, de
rsoudre des systmes d'quations et d'inquations sur les nombres rationnels et
rels ouvre la voie de la programmation logique tous les problmes de type
ordonnancement, planification, rseaux, analyse financire, etc. Nous aurons
l'occasion dans ce chapitre de dvelopper des exemples de ce type, non sans avoir au
pralable expos les diverses possibilits offertes par le langage et concernant ce type
de contraintes, de la description syntaxique des systmes numriques jusqu'
l'utilisation de certains prdicats valuables spcifiques.
Dcembre 1990
PrologIA
Aociation
1 . Introduction
Prolog a toujours t considr, juste titre, comme un puissant langage
symbolique, impropre tout traitement numrique. Ceci est li en grande
partie des considrations d'ordre historique, et bons nombres
d'interprteurs et de compilateurs du langage se sont jusqu' prsent borns
ajouter des couches coiffant l'unification, et permettant de manipuler
certaines expressions numriques. Ces traitements consistent en fait
valuer de telles expression en effectuant des calculs sur des variables dont
les valeurs sont connues au moment de l'unification. Prolog III propose une
approche qui va bien au-del de ce simple sucre syntaxique, puisque les
variables reprsentant des nombres sont traites comme toutes les variables
Prolog III, c'est dire que ce sont des objets dont la valeur peut parfaitement
tre inconnue. Ainsi, les expressions numriques ne sont gnralement pas
values (les valeurs de suffisamment de variables n'tant pas connues) mais
forment les principaux composants des contraintes numriques traites par
le langage au niveau de l'unification. Ce traitement consiste principalement
vrifier si l'ajout de ces contraintes ne rend pas le systme insoluble ainsi
qu' effectuer un certain nombre d'autres traitements sur lesquels nous
reviendrons par la suite.
2 . Gnralits
Les nombres
Les contraintes numriques de Prolog III portent sur deux types d'objets : les
nombres rationnels et les nombres flottants.
Les nombres rationnels sont reprsents dans la machine en prcision parfaite, c'est--dire avec autant de chiffres que leur expression exacte le
requiert. En fait, tout rationnel est cod sous la forme d'un nombre
fractionnaire irrductible, par un couple d'entiers en prcision parfaite qui
reprsentent son numrateur et son dnominateur. Ainsi Prolog III garantit
l'unicit de la reprsentation de tout nombre rationnel (les nombres 3/9,
2/6 et 1/3 reprsentent le mme nombre rationnel et sont cods sous la
94
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE

forme (1,3)). Pour conserver cette unicit de la reprsentation, un module
arithmtique en prcision parfaite a t intgr Prolog III.
En ce qui concerne les nombres flottants, leur reprsentation interne, et donc
leur prcision et leur tendue , sont dtermins par les particularits de votre
machine. Leur syntaxe concide avec celle utilise dans la plupart des
langages qui connaissent ce type de donnes numriques. Elle est donne en
dtail dans le chapitre consacr la syntaxe
Si les nombres flottants sont fort utiles, voire indispensables, dans la rsolution de nombreux problmes, on peut aussi considrer qu'ils ont des effets
nuisibles, notamment sur l'exactitude des calculs dans lesquels ils
interviennent. De plus, le statut des nombres flottants parmi les autres
objets qui constituent le domaine de Prolog III peut paratre au premier
abord assez confus. Il y a donc lieu de donner tout de suite quelques explications, et pour commencer sur ce que les flottants ne sont pas :
Les nombres flottants ne sont pas une notation alternative pour les
nombres rationnels. Il ne faut pas croire que 75.5 est une autre manire
d'crire 755/10. Mme si dans tel ou tel cas particulier l'opration est
exacte, la nature des calculs mis en uvre pour convertir un nombre flottant
en un rationnel ne permet pas d'assurer un rsultat gnralement
satisfaisant. Sans compter que pratiquer systmatiquement de telles
conversions serait trahir l'esprit mme des nombres flottants, en leur
accordant une exactitude qu'ils n'ont jamais possde, ni mme revendique.
Les nombres flottants ne constituent pas un autre domaine numrique,
disjoint de celui des nombres rationnels. Autrement dit, il n'est pas insens
de se demander si la contrainte 75.5 = 755/10 est satisfaite ou non. Plus
encore, non seulement une telle contrainte a un sens, mais il faut savoir que
Prolog III s'efforce de la traiter de la manire la plus prcise possible ; ainsi,
deux nombres dont l'un au moins est flottant sont trouvs gaux si leur cart
est infrieur un certain seuil qui prend en compte les nombres en question,
les caractristiques du codage des nombres flottants sur votre systme hte
ainsi qu'un savant calcul d'erreur ; en outre, la contrainte d'ingalit ( ) est
traite de manire tout--fait cohrente avec la prcdente.
PrologIA
95
Aociation
Voici en quelques points la bonne manire d'envisager les ensembles de

nombres que traite Prolog III :
1. Le domaine numrique est constitu par l'ensemble des nombres rels au
sens mathmatique du terme, comprenant en particulier les nombres rationnels, les nombres algbriques et les nombres transcendants, mme si
certaines de ces familles de nombres restent en pratique inaccessibles.
2. Les nombres qui ont t exprims sous la syntaxe des rationnels
reprsentent pour l'utilisateur des donnes exactes. Les quatre oprations
arithmtiques ( +, -, *, /) sont elles aussi qualifies d'exactes. Les
rsultats d'oprations exactes sur des nombres exacts sont exacts. Finalement, il
existe une syntaxe, celle des nombres rationnels, pour exprimer exactement
la valeur des nombres exacts.
3. Pour des raisons d'efficacit et d'ouverture vers d'autres domaines
d'application, on introduit une syntaxe permettant d'exprimer des nombres
inexacts : la syntaxe des nombres flottants. La porte l'inexactitude ayant
t ouverte, on ajoute alors un certain nombre d'oprations inexactes,
comme la racine carre ou les fonctions trigonomtriques et logarithmiques,
dont l'utilit n'est plus prouver.
4. L'inexactitude est contagieuse : le rsultat d'une opration inexacte, ou
d'une opration exacte sur des nombres inexacts est inexact.
5. Etre inexact n'est pas une infamie : Prolog III s'efforce de travailler avec
les nombres inexacts de la manire la plus prcise possible, comme nous
l'avons dj dit par exemple au sujet de x = y et x y lorsque x ou y
sont des nombres flottants.
Les expressions numriques sont des termes construits partir de variables
Prolog III, de constantes numriques et d'oprateurs numriques.
96
Prolog
HERITAGE
PrologIA
Aociation
Prolog
HERITAGE
Les constantes numriques

Il y a deux types de constantes numriques en Prolog III. Ce sont les
nombres entiers positifs ou nuls et les nombres flottants positifs ou nuls.
Les nombres entiers positifs ou nuls.
En voici quelques exemples :
0
1
2
1789
815915283247897734345611269596115894272000000000 1
On rappelle que ni les entiers ngatifs, ni les nombres fractionnaires ne sont considrs comme des constantes. On notera que
l'on peut les exprimer comme rsultats d'oprations sur des
entiers non ngatifs.
Les nombres flottants positifs ou nuls.

Exemples :
12.345
0.5
1.2E12
0.888e87
La syntaxe exacte pour les flottants est donne au chapitre rserv la

syntaxe
Les oprateurs numriques

il s'agit des oprateurs suivants :
+
plus unaire
:
:
moins unaire
addition
soustraction
Le lecteur attentif aura reconnu l le rsultat de 40!
PrologIA
97

:
:
/
*
division
multiplication
Syntaxiquement, Prolog III, conservant en cela une certaine
philosophie de la notation mathmatique, autorise
d'omettre le signe de la multiplication lorsque cela ne
gnre aucune ambigut. Par exemple, le systme de
contraintes {X+2Y = 1,3Z-2T < 5} est parfaitement

correct. Par contre la contrainte {(X+Y)(X-Y) # 0 } est
elle aussi correcte, mais signifie que l'arbre dont l'tiquette
est la valeur X + Y , et dont l'unique fils est la valeur
numrique X-Y est diffrent de l'arbre rduit la feuille 0,
ce qui, d'ailleurs, est toujours vrifi.
Priorits des oprateurs numriques

Afin de permettre la suppression d'un certain nombre de parenthses, on
introduit un ordre de priorit sur les oprateurs numriques :
Les oprateurs * et / sont prioritaires sur les oprateurs + et Tout d'abord on notera que les oprateurs plus et moins unaires ont le
mme ordre de priorit que les oprateurs plus et moins binaires. Ensuite,
en cas d'galit des ordres de priorits, l'oprateur de gauche est prioritaire
par rapport celui de droite.
Exemple :
((x*y)/z)+(x*(y/z))
s'crit plus simplement : x * y / z + x * ( y / z )
Voici prsent un certain nombre d'expressions numriques correctes (pour

la syntaxe exacte des expressions numriques on se reportera au chapitre
Syntaxes) :
(1)
1993/1989
(2)
+X
(3)
(3/2)X
(4)
2X+5Y
(5)
3/2-X+7.02
98
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
(6)
X+2Y/Z
et quelques unes incorrectes

(7)
2(X)
(8)
X2
(9)
3+-X
(10) 3 / 2 X
(11) X = 2Y+1
Voici quelques remarques concernant ces exemples :
(2) est une expression numrique qui impose simplement X de reprsenter
une valeur numrique. On remarquera en passant que le terme X n'est pas
une expression numrique, la variable X reprsentant un arbre quelconque.
(3) L'expression est parenthse, et n'admet pas l'omission des parenthses
(voir l'exemple (10) et le chapitre sur la syntaxe des expressions numriques,
particulirement en ce qui concerne l'omission possible de l'oprateur de
multiplication. On se rappelera ce sujet que cet oprateur peut tre omis
uniquement dans les expressions de type Constante*Variable et (Expression
Numrique)*Variable .
(6) est une expression numrique correcte, mais non-linaire. Le traitement
correspondant, et plus particulirement celui des contraintes faisant
intervenir de telles expressions est particulier et sera dtaill dans les
chapitres qui suivent.
(7) est un terme correct, qui reprsente un arbre tiquet par la valeur 2 et
dont le fils unique est reprsent par la variable X. Ce n'est donc en aucun
cas une expression numrique.
(8) est un terme form d'une unique variable d'identificateur X2, et pas un
produit de la variable X par la valeur 2.
(9) et (10) exigent un parenthsage (voir chapitre Syntaxes).
PrologIA
99
Aociation
(11) n'est pas une expression numrique, mme pas un terme Prolog III.
C'est tout de mme un objet syntaxique du langage, puisque c'est une
contrainte numrique. On veillera cependant ne pas confondre ces deux
types d'objets.
Les relations
On trouve, pour la partie numrique de Prolog III deux types de relations :
les relations unaires, qui serviront prciser le caractre numrique de
certains arbres, ce qui revient, dans les faits, formuler des contraintes de
type, et les relations binaires, utilises pour construire des contraintes
numriques proprement dites. Voici les diffrentes relations qui permettent
de construire des contraintes numriques :
Relations unaires.
X !numt qui impose la variable X de reprsenter un arbre tiquet par un
nombre rel ou rationnel. (Syntaxiquement, on remarquera qu'il n'est pas
autoris d'insrer, comme dans toutes les relations unaires de typage un
espace entre le ! et numt)
X !num qui est quivalent l'association des deux contraintes X !numt et X
::
0.
Relations binaires.
:
:
galit
ingalit
<
infrieur strict
>
<=
:
:
suprieur strict
infrieur ou gal
>=
suprieur ou gal
100
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Contraintes numriques
Les contraintes numriques sont des objets syntaxiques qui expriment, dans
le cas des relations binaires, la mise en relation de deux expressions
numriques. L'utilisation de contraintes unaires induit, elle, un typage des
variables considres.
A propos de types, on notera la proprit suivante :
la seule prsence d'une variable dans une expression numrique

contraint celle-ci reprsenter une valeur numrique.
Par exemple la contrainte {X = Y+2Z} est en fait code sous la forme

suivante : { Y !num, Z !num, X = Y+2Z}. le terme figurant gauche
de l'galit, X, n'tant pas une expression numrique, aucun typage
particulier n'est effectu et, du point de vue du typage, la variable X
reprsente un arbre quelconque, mme si pour vrifier cette galit, X est
contraint reprsenter un nombre.
Exemples de contraintes numriques

Voici quelques exemples de contraintes numriques correctes :
2X-3 = 0
X+5 = 3*(2X-1)+2
X # 1+Y
X > Y
1 <= 4X-1 <= 9
PrologIA
101
Aociation
Restrictions
La principale restriction portant sur les contraintes numriques rside dans le
fait que, pour des raisons d'efficacit videntes, seules les quations et
inquations linaires sont prises en compte par les algorithmes de rsolution
de Prolog III. De ce fait, le traitement de toute contrainte contenant une
multiplication de deux variables ou une division par une variable est retard,
jusqu' ce que le nombre de variables connues soit suffisant pour rendre la
contrainte linaire. Dans la majorit des cas cette linarit sera obtenue ds
l'unification. Nous examinerons en dtail le processus mis en place dans les
autres cas dans un chapitre spcialement consacr ce sujet.
Une autre restriction importante est que l'on ne peut, en Prolog III, imposer
un terme de reprsenter une valeur entire. Une faon de traiter les entiers
consiste dfinir des ensembles de contraintes portant sur des nombres
rationnels et, en fin de traitement, d'effectuer une numration entire des
valeurs possibles de ces variables grce la rgle prdfinie enum (voir le
chapitre "Rgles prdfinies et procdures externes")
Forme normale
Nous voquons ici la forme normale utilise pour le codage les contraintes
numriques afin d'apporter certains claircissements concernant les
expressions rencontres au cours des sorties (lors de l'utilisation du prdicat
valuable list par exemple).
Les quations
Tout d'abord examinons la forme normale utilise pour le codage des
quations. Dans une galit entre des expressions numriques, une variable
est privilgie (c'est une variable dont le domaine gnral des valeurs
possibles englobe le domaine gnral des valeurs possibles des autres
variables. On choisira, dans l'ordre, une variable de type arbre, numrique
non contrainte, numrique contrainte reprsenter une valeur positive ou
nulle). Cette variable (dans le cas ou plusieurs variables sont candidates, le
choix est arbitraire, ou plus prcisment non matrisable par l'utilisateur) est
alors exprime en fonction des autres variables.
102
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Pour visualiser cette mise sous forme normale, interrogeons l'interprteur :
> { 1X = (1/2)Y+2Z-4 };
{ Z = -(1/4)Y+(1/2)X+2 }
> { X = (1/2)Y+2Z-4 };
{ X = 2Z+(1/2)Y-4 }
> { 1X = (1/2)Y+2Z-4,Z >= 0 };

{ Y = 2X-4Z+8, Z >=0 }
Dans le premier exemple, les trois variables X, Y et Z sont des variables

numriques non-contraintes.
Dans le second exemple, X est une variable de type arbre quelconque, les
deux variables Y et Z sont des variables numriques non-contraintes.
Dans le troisime exemple, Z est une variable numrique contrainte
reprsenter une valeur positive ou nulle, les deux variables X et Y sont des
variables numriques non-contraintes.
Les inquations
Les inquations rencontres sont transformes de la manire suivante, en
introduisant une variable supplmentaire , appele variable d'cart :
X>Y est transforme en
X-Y = , > 0
XY "
X<Y
XY "
X-Y = , >= 0
Y-X= , > 0
Y-X = , >= 0
"
"
"
"
"
"
Cette transformation effectue, la contrainte de type quation est mise sous

forme normale, comme expos plus haut.
Voici deux exemples de contraintes linaires et la forme propose en sortie
par l'interprteur :
PrologIA
103

> { X+3Y >= Z+2T };
{ T = -(1/2)Z+(3/2)Y+(1/2)X-(1/2)X', X' >= 0 }
> {0
<=
(7/11)X+(4/6)Y};
{ Y = -(21/22)X+(3/2)X', X' >=0 }
Par souci de lisibilit, les variables d'cart cres par Prolog III ont t
renommes.
3 . Rgles prdfinies et procdures externes spcifiques

enum(N)
Cette rgle prdfinie permet d'numrer toutes les valeurs entires que
peut prendre le terme N dans le domaine de valeurs dfini par l'ensemble de
contraintes courant. Cette rgle prdfinie permet de raliser des
programmes dans lesquels interviennent des nombres entiers. Le principe
de base, bien sr, consiste contraindre le terme auquel on s'intresse de la
manire la plus complte possible, ceci afin de minimiser le nombre de
valeurs numrer.
Attention toutefois l'ordre d'numration des variables, des
carts de performances normes pouvant en dcouler. En rgle

gnrale, on choisira d'numrer d'abord les variables les plus
contraintes. Si les contraintes sont identiques, on choisira d'abord
celles dont les coefficients sont les plus levs ou encore celles qui
interviennent le plus souvent dans le systme de contraintes.
On examinera comme exemple le cryptarithme SEND+MORE = MONEY,

plus avant dans ce chapitre.
104
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
max_value(R1,R2)
min_value(R1,R2)
Cette procdure externe deux arguments calcule la valeur du maximum
(respectivement du minimum) d'une expression numrique R1. Si on veut
tre plus prcis, la valeur qui est calcule est, en fait, le plus petit des
majorants (respectivement le plus grand des minorant), dans le cas de
max_value (respectivement de min_value). Ceci implique que le maximum
(respectivement le minimum) calcul n'est pas forcment atteint, ce calcul ne
tenant pas compte des contraintes d'ingalits de type , et des contraintes
d'ingalits strictes (<, >).
particular_value(R1, R2) : Pose la contrainte {R2 = R1'}, o R1'
est une valeur quelconque du terme R 1 qui satisfait l'ensemble de
contraintes courant. Pour les remarques diverses concernant cette primitive,
se reporter au chapitre rgles prdfinies et procdures externes).
mult(R1,R2,R3) pose la contrainte {R3 = R1*R2} avec les retardements
ncessaires s'il y a lieu.
R3) pose la contrainte {R3 = R1*R2}, la
condition que la valeur de R1 ou celle de R2 soit connue, choue dans le cas
contraire.
bound_mult(R1,
R2,
Vrifications de types
integer(I) vrifie que le terme I reprsente une valeur entire connue.
num(R) vrifie que le terme R reprsente une valeur numrique connue.
rational(R) vrifie que le terme R reprsente une valeur numrique
rationnelle connue.
real(R) vrifie que le terme R reprsente une valeur numrique code en
flottant connue.
PrologIA
105
Aociation
is_num(T) vrifie que le terme T est astreint reprsenter une valeur

numrique, ou que la contrainte {T !num} appartient au systme courant
de contraintes.
Divers
trunc(R, N) pose la contrainte {N = R'}, o R' est la partie entire du
nombre R. Echoue si R n'est pas une valeur numrique connue.
div(N1,N2,N3) pose la contrainte {N3 = E} o E est le rsultat de la
division entire de N1 par N2 . Seules les valeurs absolues de N1 et N2 sont
prises en compte pour le calcul de E. Echoue si N1 et N2 ne sont pas tous les
deux des valeurs entires connues.
mod(N1,N2,N3)
pose la contrainte {N3 = R} o R est le reste de la
division entire de N1 par N2 . Seules les valeurs absolues de N1 et N2 sont

prises en compte pour le calcul de R. Echoue si N1 et N2 ne sont pas tous les
deux des valeurs entires connues.
4 . Retardement
linaires
des
contraintes
non-
Nous examinerons dans le dtail le processus de retardement des contraintes

numriques non-linaires dans un chapitre entirement consacr aux
retardements. Au niveau ou nous sommes, permettons nous tout de mme
une remarque. Prolog III autorise l'criture de contraintes non-linaires.
Retenons dans un premier temps que Prolog III ajoute au systme de
contraintes numriques toute contrainte qui est linaire au moment o on se
propose de raliser cet ajout. En d'autres termes, toute contrainte
syntaxiquement non-linaire est traite de manire tout fait naturelle si les
valeurs de suffisamment de variables sont connues au moment de
l'excution.
Voici un exemple :
106
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
> calculer(X,Y,Z)
{
->
Z = (3X-Y)/Z,
X+Y-2Z = 0
};
{}
> calculer(X,Y,2);
{ X = 2, Y = 2 }
> calculer(1,Y,Z);
{ Y = Y1, Z = (1/2)Y1+1/2,
((1/2)Y1+1/2)*((1/2)Y1+1/2) = -Y1+3,
(1/2)Y1+1/2 # 0 }
Dans le premier cas, au moment de traiter l'ensemble de contraintes li la

seule rgle qu'il est possible d'appliquer pour rpondre la requte, celui-ci
est linaire. En effet, le simple fait de connatre la valeur de Z suffit raliser
cette condition. On obtient donc une rponse qui fournit les uniques valeurs
de X et Y qui satisfont ce systme linaire de deux quations deux
inconnues.
Dans le second cas, par contre, le nombre de valeurs connues ne suffit pas
rendre le systme linaire, et la rponse fournie par Prolog III donne certains
renseignements sur les variables geles lors du retardement de cette
contrainte. Pour plus de prcisions sur ce type de retardement se reporter au
chapitre "Retardements"
5 . Formats d'entre-sortie
Les nombres utiliss en Prolog III se divisent, comme nous l''avons vu en
deux classes : les rationnels en prcision parfaite et les flottants. Pour
amliorer le confort d'utilisation, Prolog III autorise un certain nombre de
formats de sortie possibles. Ces formats sont positionns grce la
procdure externe set_config(S,T).
Le premier paramtre doit tre une chane. Pour ce qui concerne les formats
de sortie numrique S doit tre gal "format_out_num". Les valeurs
possibles pour le second paramtre T sont alors :
PrologIA
107
Aociation
" Fnormal " :
affiche les rationnels en prcision infinie, et les

flottants en notation scientifique
" Fexact " :
rationnels en prcision infinie, les flottants sont

convertis
" Fdecimal " :

" Ffloat " :
" Fint+fract ":
affichage sous forme dcimale

affichage en notation scientifique
affichage sous la forme partie entire + partie

fractionnaire
On trouvera des exemples d'utilisation la description de set_config au

chapitre "Rgles prdfinies et prdicats valuables"
6 . Exemples de programmes
Calcul bancaire
Il sagit de calculer la suite de versements successifs quil faut effectuer pour
rembourser un capital emprunt une banque. On suppose quentre deux
versements scoule toujours le mme temps et que pendant cette dure le
taux dintrt rclam par la banque est de 10%. Lensemble des faits dfinis
par le programme sera lensemble des arbres de la forme
versements_capital(X,C)
et o X reprsente la liste des versements ncessaires pour rembourser le
capital C avec un intrt de 10% entre deux versements. Le programme luimme se rsume deux rgles:
versements_capital(<>, 0) ->;
versements_capital(<V>.X, C) ->
versements_capital(X, C+(10/100)C-V);
La premire rgle exprime quil nest pas ncessaire de faire de versements

pour rembourser un capital nul. La deuxime rgle exprime que la suite des
n+1 versements pour rembourser un capital C consiste en un versement V
108
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
et dune suite X de N versements permettant de rembourser le capital C

augment de 10% dintrts mais diminu du versement V effectu.
Ce programme peut-tre utilis de diffrentes faons. Une des plus spectaculaires est de demander pour quelle valeur de V la suite de versements
<V,2V,3V> permet de rembourser 1000F. Il suffit de poser la requte
> versements_capital(<V,2V,3V>,1000);
{V = 207 + 413/641}
Crypto-arihmtique
Le problme consiste affecter aux 8 lettres s,e,n,d,m,o,r,y des chiffres tous
diffrents de faon ce que laddition send+more=money tombe juste. La
premire faon de procder consiste profiter du fait que laddition, la
soustraction, la multiplication par une constante et les relations =,,<,,,>
sont parfaitement connues au niveau des nombres rationnels.
On fait aussi intervenir le prdicat prdfini enum(X) qui numre tous les
entiers X satisfaisant aux contraintes accumules. Le programme est
dailleurs purement dterministe jusquau moment o lon appelle ce
prdicat.
solution(I,J,K) ->
chiffres_tous_differents(<S,E,N,D,M,O,R,Y>)
tous_entiers(<M,S,O,E,N,R,D,Y>),
{ S # 0,M # 0,
I =
1000 S + 100 E + 10 N + D,
J =
1000 M + 100 O + 10 R + E,
K = 10000 M + 1000 O + 100 N + 10 E + Y,
I + J = K };
PrologIA
109

tous_entiers(<>) ->;
tous_entiers(<X>.S) ->
enum(X)
tous_entiers(S);
chiffres_tous_differents(<>) -> ;
chiffres_tous_differents(<X>.S) -> ;
hors_de(X,S)
chiffres_tous_differents(S),
{0 <= X <= 9};
hors_de(X,<>) ->;
hors_de(X,<Y>.S) -> hors_de(X,S),{X # Y};
Si lon pose la requte
> solution(I,J,K);
{I=9567, J=1085, K=10652}
Remplissage dun rectangle par des carrs

Voici maintenant un problme, tir de l'article d'Alain Colmerauer, "une
introduction Prolog III" qui met bien en valeur la partie numrique de
Prolog III. Etant donn un entier N on s'intresse savoir s'il existe N carrs
de dimensions distinctes qui peuvent tre assembls pour former un
rectangle. Dans l'affirmative, on aimerait bien entendu connatre les
dimensions de ces carrs et du rectangle form. Voici par exemple deux
solutions ce problme pour N=9.
110
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
10
14
1
32
18
15
33
16
28
7
5
61
25
9
2
36
33
69
On dsignera par a le rapport de la longueur du plus grand ct avec celle
du plus petit ct du rectangle construit. On peut videmment supposer que
la longueur du plus petit ct est 1 et que la longueur du plus grand ct est
a. Il faut donc remplir un rectangle de dimensions 1 x a par N carrs tous
distincts. Ce remplissage se fera en plaant successivement chaque carr
dans la position la plus basse possible et, hauteur gale, dans la position la
plus gauche possible. En se rfrant au schma qui suit, la base de
l'algorithme de remplissage consistera alors
(1) placer un carr dans le coin infrieur gauche du rectangle,
(2) remplir de carrs la zone A, si elle n'est pas vide,
(3) remplir de carrs la zone B, si elle n'est pas vide.
PrologIA
111
Aociation
Le remplissage des zones A et B se fera rcursivement de la mme faon :

placer un carr dans le coin infrieur gauche et remplir deux sous-zones.
B
1
a
Les zones et les sous-zones sont spares par des lignes brises en forme
d'escalier allant du coin suprieur droit des carrs au coin suprieur droit du
rectangle. Ces lignes brises ne descendent jamais et s'il est possible d'en
tracer plusieurs pour aller d'un point un autre on considre toujours la plus
basse. Voici par exemple toutes les lignes de sparations correspondant la
premire solution du problme lorsque N = 9 :
112
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
D'une faon plus prcise une zone ou une sous-zone a la forme du schma
de gauche ci-dessous, la totalit du rectangle tant lui-mme assimil la
zone particulire dessine droite.
L'
P
L'
P
L
L
La zone est dlimite par une ligne brise infrieure L allant d'un point P
un point Q et par une ligne brise suprieur L' allant du mme point P au
mme point Q. Le point P est plac n'importe o dans le rectangle remplir
alors que le point Q dsigne le coin suprieur droit du rectangle. Ces lignes
brises sont reprsentes par des suite alternes de segments verticaux et
horizontaux
v 0 , h 1 , v 1 , ... , h n , v n ,
o vi dsigne la longueur d'un segments vertical et h i la longueur d'un
segment horizontal. Les h i sont toujours strictement positifs. Les v i sont
soit nuls, soit positifs pour dsigner des segments qui montent, soit ngatifs
pour dsigner des segments qui descendent. Les vi des lignes suprieures ne
sont jamais ngatifs et si une zone n'est pas vide seul le premier segment
vertical v0 de sa ligne infrieure est ngatif.
Si l'on applique ces conventions la totalit du rectangle, (figure droite

prcdente) la ligne infrieure L peut tre reprsente par la suite 1,a,1 et
la ligne suprieure L' par une suite de la forme 0, h 1,0,...,h n,0, avec
h1+...+hn = a, tous les hi tant positifs.
PrologIA
113
Aociation
Le cur du programme est la procdure

remplir_zone(L,L',C,C')
qui remplit de carrs une zone dlimite infrieurement par L et calcule sa

dlimitation suprieure L'. Les carrs sont puiss dans le dbut de la liste C
et C' est la liste de carrs qui restent. Cette procdure fait appel la
procdure
placer_carre(b,L,L')
qui place un carr de dimension bx b dans le coin infrieur gauche de la

zone remplir. Ici L dsigne la ligne infrieure de la zone, mais de laquelle
on a enlev le premier segment vertical, et L' dsigne la ligne descendant du
coin suprieur droit du carr pour rejoindre et se prolonger dans le reste de
la ligne L. La figure ci-dessous montre les trois cas qui se prsentent. Soit le
carr dborde sur la premire marche, qui en fait tait une fausse marche de
hauteur nulle, soit le carr est coll contre la premire marche, soit le carr
n'est pas assez grand pour toucher la premire marche.
L'
L'
L'
L
Le programme lui mme est constitu des dix rgles suivantes :
114
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
remplir_rectangle(A, C) ->
creer_carres(C)
remplir_zone(<-1, A, 1>, L, C, <>) ,
{ A >= 1 } ;
creer_carres(<>) -> ;
creer_carres(.C) ->
creer_carres(C)
rendre_distinct(B, C),
{B>0};
rendre_distinct(B, <>) -> ;
rendre_distinct(B, <B'>.C) ->
rendre_distinct(B, C) ,
{ B # B' } ;
remplir_zone(<V>.L, <V>.L, C, C) -> ,
{ V >= 0 } ;
remplir_zone(<V>.L, L''', .C, C'') ->
placer_carre(B, L, L')
remplir_zone(L', L'', C, C')
remplir_zone(<V+B, B>.L'', L''', C', C'') ,
{V<0};
placer_carre(B, <H, 0, H'>.L, L') ->
placer_carre(B, <H+H'>.L, L') ,
{B>H};
placer_carre(B, <H,V>.L, <-B+V>.L) -> ,
{B=H};
placer_carre(B, <H>.L, <-B, H-B>.L) -> ,
{B<H};
L'appel gnral se fait par la requte
> remplir_rectangle(a,
C),
{C::n};
o n est le nombre de carrs de tailles distinctes qui doivent remplir un

rectangle. Le programme calcule la dimension 1 x a du rectangle (a 1) et la
liste C des dimensions des n carrs. Ce calcul dbute par l'excution de la
premire rgle, qui la fois contraint a tre plus grand ou gal 1, cre n
carrs (de tailles inconnues) tous distincts et lance le remplissage de la zone
constitue par la totalit du rectangle. La ligne L constituant la dlimitation
PrologIA
115
Aociation
suprieure de cette zone est inconnue au dpart, mais, compte tenu que cette
ligne doit joindre deux points qui se trouvent la mme hauteur et qu'elle
ne peut descendre, ce sera forcment une ligne horizontale reprsente par
un escalier dont toutes les marches sont de hauteur nulles. Si on lance la
requte :
> remplir_rectangle(a,
C),
{C::9};
on obtient 8 rponses. Les deux premires que voici
{a = 33/32,
C = <15/32,9/16,1/4,7/32,1/8,7/16,1/32,5/16,9/32>}
{a = 69/61,
C =
<33/61,36/61,28/61,5/61,2/61,9/61,25/61,7/61,16/61>}
correspondent aux deux assemblages que nous avons dessins. Les 6 autres
rponses dcrivent des assemblages symtriques de ceux-ci.
ststs
116
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Les contraintes boolennes
1. Introduction
2. Quelques dfinitions et remarques
- Expressions boolennes
- Priorits des oprateurs boolens
- Contraintes boolennes
- Remarques importantes
- Ensembles de contraintes boolennes
- Exemples de contraintes boolennes
- Forme normale conjonctive
- Affectations boolennes
- Solution d'un ensemble de contraintes boolennes
- Simplification de systmes de contraintes
- Rgles prdfinies spcifiques
3. Premiers exemples de programmes
- Un ou sur deux variables
- Un ou sur une liste
- Au plus un de vrai
- K lments vrais dans une liste de n boolens
4. D'autres exemples
- Pannes dans un additionneur binaire
- Un puzzle logique

Ce chapitre est consacr aux contraintes boolennes et leur utilisation. Tout en
demeurant accessibles au lecteur peu familiaris avec l'algbre de Boole et le calcul
propositionnel, nous y prsentons les contraintes boolennes au travers de leur
reprsentation syntaxique, mais nous abordons galement des problmes comme la
reprsentation des sorties et la forme normale. Le chapitre se poursuit par l'examen
de divers exemples, en suivant une progression rgulire dans les niveaux de
difficult rencontrs, pour terminer par un exemple proche d'une petite application
de diagnostic de pannes sur un circuit logique.
Dcembre 1990
PrologIA
1 . Introduction
L'un des domaines sur lequel on peut faire porter des contraintes en
Prolog III est celui des boolens. Les constantes, les oprations et les relations qui y sont dfinies permettent d'exprimer toutes les formules du calcul
propositionnel, et autorisent par l mme une puissance d'expression bien
suprieure celle des clauses de Horn ou des rgles de production. On est
ainsi en mesure, pour ce domaine, de traiter de manire rigoureuse la
disjonction et la ngation.
Pourtant, cette puissance se paye. En effet, les algorithmes de rsolution
de contraintes boolennes sont exponentiels. On pourra donc rencontrer
certaines difficults (temps d'excutions trop longs, voire inacceptables)
lorsque l'ensemble d'quations boolennes traiter devient trop complexe.
Pour tenter de remdier cet tat de fait, en dehors des efforts accomplis
pour amliorer les algorithmes dans les versions futures, on pourra
souvent faire chuter par une programmation adapte, parfois de manire
spectaculaire, les temps d'excution. C'est pourquoi nous fournirons, dans ce
chapitre, des conseils de programmation destins minimiser les temps de
calcul.
On se propose ici, aprs quelques brefs rappels relatifs aux contraintes
boolennes, de dcrire les spcifications du langage pour ce qui concerne
cette partie, avant de prsenter un certain nombre d'exemples de programmes destins illustrer l'utilisation de ce type de contraintes.
2 . Quelques dfinitions et remarques

Nous allons tout d'abord rappeler ce que sont, en Prolog III, les expressions
boolennes, puis revenir sur les notions d'affectation, et de solution d'un
ensemble de contraintes boolennes. Nous terminerons par la prsentation
des simplifications, et plus prcisment de l'quivalence sur un sous-ensemble de variables, concept que nous rencontrerons frquemment par la
suite.
118
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Soit V le sous-ensemble des variables qui reprsentent des valeurs boolennes
Soit B = {0', 1'} l'ensemble des valeurs que peuvent prendre les lments
de V. Ce sont les reprsentations en Prolog III des constantes faux et vrai
Soient, enfin, les oprateurs suivants :
~
(non)
&
|
(et)
(ou)
=>
<=>
(implique)
(quivalent)
Les expressions boolennes sont dfinies comme suit :
0' et 1' sont des expressions boolennes,

les variables boolennes sont des expressions boolennes,
si f et g sont des expressions boolennes, alors :
~(f) ,
(f) |(g) ,
(f) (g),
(f) (g),
(f) <=> (g),
sont des expressions boolennes
Il est clair, d'aprs ce qui prcde, que toute expression boolenne est un
terme Prolog III.
Priorits des oprateurs boolens

Afin de permettre la suppression d'un certain nombre de parenthses, on
introduit un ordre de priorit sur les oprateurs boolens :
L'oprateur ~
est prioritaire sur
Les oprateurs | sont prioritaires sur
| => et <=>

=> et <=>
Exemples :
PrologIA
119
Aociation
(~(a)|b)<=>(c&~(d)) s'crit plus simplement : ~a|b <=> c&~d

(a|(b|c))|(~(d) s'crit plus simplement : a|b|c|~d
Voici d'autres exemples d'expressions boolennes correctes :
1'
b
si b est une variable type boolenne
~~a|1'
a&~b' <=> ~a'|b
(a|b)&(a'<=>(b&(a'|0')))
Contraintes boolennes
Pour reprsenter des contraintes boolennes, on se donne d'autre part les
symboles relationnels suivants :
Relations binaires :
=
#
=>
(gal)
(diffrent)
(implique)
On remarquera que implique est aussi en Prolog III une relation. En

tant qu'opration cela permet souvent de simplifier l'criture des
expressions mais on prendra garde de bien la discerner de la
relation implique.
On peut galement imposer un arbre b d'tre tiquet par une valeur

boolenne en utilisant la contrainte unaire suivante :
b
!boolt
On peut enfin imposer un arbre b d'tre rduit une feuille et tiquet par
une valeur boolenne en utilisant la contrainte unaire suivante :
b
120
Prolog
HERITAGE
!bool
PrologIA
Aociation
Prolog
HERITAGE
Une contrainte boolenne est, soit la relation unaire qui impose

une variable de reprsenter un arbre tiquet par un boolen, soit
une relation entre deux expressions boolennes.
Remarques importantes
Tout d'abord, il est noter que par sa dfinition mme, une contrainte est ou
n'est pas vrifie, et qu'en particulier celle-ci ne renvoie pas une valeur
boolenne. On prendra donc garde de ne pas utiliser des expressions pour
des contraintes, et inversement. Ainsi l'expression a b n'est pas une
contrainte, de mme qu'il n'est pas correct d'crire (a>0) (b>0)=1'. C'est l
une des restrictions de Prolog III que de ne pas permettre de mlanger les
diffrentes algbres. On se souviendra, de manire gnrale, qu'une
contrainte boolenne n'est valide que si elle contient exactement un symbole
relationnel.
Bien qu'il n'y ait pas, au sens strict, de notion de type dans Prolog III, on
remarquera galement que l'on peut contraindre une variable b tre
boolenne (c'est dire reprsenter un arbre tiquet par un boolen et
rduit une feuille), sans aucune autre restriction, de quatre faons :
en posant la contrainte b !bool
en posant les deux contraintes b !boolt, et b :: 0 (cette dernire
ajoute la contrainte que b est une feuille)
en faisant apparatre cette variable dans une expression boolenne. Celleci pourra figurer dans une contrainte, comme dans {b|~b=1'}1, ou dans
un terme, par exemple boolen (b|0')2.
en faisant figurer cette variable comme expression dans une contrainte de
type =>. Ceci impose en effet que les deux termes en relation soient des
expressions boolennes. Une criture possible est : 0'=>b 3, o la seule
contrainte impose la variable b est de reprsenter une valeur
boolenne.
On notera au passage que l'expression b|~b a toujours pour valeur 1'.
L'expression b|0', tout comme b1' a toujours la mme valeur que b.

La contrainte 0' => b est galement toujours vrifie, pour toute valeur de b.
PrologIA
121
Aociation
Dans cet ordre d'ides, on notera que si a est une variable boolenne, la
contrainte a#b (l'arbre reprsent par la variable a est diffrent de celui reprsent par la variable b ) n'impose en aucun cas b de reprsenter une
valeur boolenne. En particulier, sa simple non-appartenance au domaine
des boolens suffit vrifier la contrainte.
Ensembles de contraintes boolennes

Comme nous l'avons dj vu dans le cas gnral, les systmes de contraintes
boolennes sont des ensembles dont toutes les contraintes doivent tre vrifies simultanment. On remarquera, cependant, qu'il existe souvent
plusieurs critures possibles, le connecteur et implicite liant ces contraintes
pouvant apparatre comme oprateur explicite dans une contrainte
quivalente.
Par exemple, on pourra crire indiffremment :
{ a = 1 ' , b = 1 ' , c = 1 ' } ou
{a => c, c # a|b} ou
{a&b&c
1'}
{(~a|c)&~(c<=>a|b)
1'}
Toutefois, pour des raisons d'efficacit, afin d'viter un pr-traitement trop

coteux, on aura souvent intrt prfrer de grands ensembles de
contraintes simples des systmes constitus de peu de contraintes complexes.
Exemples de contraintes boolennes

Voici quelques exemples de contraintes boolennes correctes, ainsi que des
ensembles de contraintes qui leur sont quivalents :
a | ~a = 1'
Cette contrainte est toujours vrifie mais impose a de reprsenter

une valeur boolenne. Ensembles de contraintes quivalents :
{0' => a},{a = (~x)[<>]},{a # ~a},
122
Prolog
HERITAGE
PrologIA
Aociation
Prolog
HERITAGE
(a<=>b)&(b<=>c)
1'
Celle-ci pose une quivalence entre trois variables boolennes.

Ensembles de contraintes quivalents :
{a!boolt,a::0,a=b,a=c},
{a=>b,b=>c,c=>a},
a&b&c
=>a'|b'
Cette contrainte, que l'on pourra aisment rapprocher d'une clause

propositionnelle, voire d'une rgle de production de systme expert,
prsente la particularit de comporter un ou droite de l'implication,
ce qui est gnralement interdit dans les dmonstrateurs classiques.
Ensembles de contraintes quivalents :
{~a|~b|~c|a'|b'=1'},
{~a'&~b'
=>
~a|~b|~c},
Voici un tableau rcapitulatif des oprations et relations utilisables pour

l'algbre de Boole :
Oprations
Relations
Utilises pour construire des
Utilises pour construire
expressions boolennes
des contraintes boolennes
non
et
ou
=>
implique
~
&
=
#
=>
gal
diffrent
implique
< = > quivalent
Forme normale conjonctive

Au premier abord, la forme normale utilise pour le codage des contraintes
boolennes au sein de l'interprteur semble ne concerner en rien l'utilisateur
de Prolog III. Il nous parat toutefois important de la mentionner pour deux
raisons principales.
La premire est lie au fait que l'efficacit de la rsolution est d'autant plus
grande que les transformations effectuer pour le codage sont moins im-
PrologIA
123
Aociation
portantes, ces transformations s'avrant fort coteuses. La seconde concerne

les sorties qui, pour les contraintes boolennes, sont toutes imprimes sous
cette forme.
La forme normale conjonctive, ou forme clausale, d'une formule, est une formule
quivalente crite sous la forme de conjonctions de disjonctions de littraux,
c'est dire de la faon suivante :
(l1 ou l2 ou ln) et (l'1 ou l'2 ou l'p)
o les li et les l'j sont des littraux, c'est dire des formules du type v ou
non(v), avec v appartenant l'ensemble des variables, V.
On aura tout intrt crire, lorsque c'est possible, des contraintes
proches de ce formalisme, afin d'viter des transformations de cot exponentiel. L'exemple typique d'une contrainte dont la transformation est
pnalisante est une reprsentation d'une formule en forme normale disjonctive. Un exemple en est :
{(a&b&c)|(a'&b'&c')|(a''&b'')}
dont la forme normale conjonctive est :

{
a|a'|a''
1',
a|a'|b''
1',
a|b'|a''
1',
a|b'|b''
1',
a|c'|a''
1',
a|c'|b''
1',
b|a'|a''
1',
b|a'|b''
1',
b|b'|a''
1',
b|b'|b''
1',
b|c'|a''
1',
b|c'|b''
1',
c|a'|a''
1',
c|a'|b''
1',
c|b'|a''
1',
c|b'|b''
1',
c|c'|a''
1',
c|c'|b'' = 1'
Les sorties, y compris la visualisation des contraintes associes aux rgles

codes par l'interprteur, sont affiches sous forme de clauses, en respectant
les conventions suivantes :
124
Prolog
HERITAGE
PrologIA
Aociation
Prolog
HERITAGE
Si tous les littraux sont positifs (de la forme li), on crit :

l1 | l2 | | ln = 1'
Si tous les littraux sont ngatifs (de la forme ~li), on crit :
l1 l2 ln = 0'
Si certains littraux sont ngatifs (de la forme ~l i) et d'autres positifs
(forme l'j ), on crit :
l1 ln => l1 | | lp
Pour visualiser la mise sous forme clausale, on peut examiner la requte et la
rponse suivantes :
> {a<=>b
1'};
{a => b, b => a}
L'interprteur analyse l'ensemble de contraintes initial, le code sous forme

clausale, en vrifie la solubilit et l'imprime sous sa forme code, aprs
l'avoir simplifi. Nous tudierons dans les tout prochains sous-chapitres ces
notions de solubilit et de simplification.
Voici d'autres exemples de mise sous forme normale conjonctive
d'ensembles de contraintes, que vous pouvez galement tester sur votre interprteur :
{(a&~b)|(c&~d)=1'}
{a|b#c,c
!boolt,c::0}
devient
{a|c=1',d=>a,b=>c,b&d=0'}
"
{a&c=0',b&c=0',a|b|c=1'}
Affectations boolennes
Voici une dfinition de l'affectation boolenne, que l'on pourra rapprocher de la
notion d'interprtation en logique propositionnelle. De manire globale, on
pourra considrer qu'on affecte toutes les variables de V une valeur dans
{0', 1'}.
Une affectation boolenne est un ensemble X= {x1 := a1, x2 := a2,} o toute
variable boolenne xi est associe une valeur ai prise dans l'ensemble {0', 1'}
PrologIA
125

A partir de ces affectations on peut dfinir la valeur d'une expression
boolenne pour une affectation X de la manire suivante :
Soient v une variable de V, f et g deux expressions boolennes, alors :
0'/X = 0'
1'/X = 1'
v/X = 1' si v:=1' X, v/X = 0' si v:=0' X
~f/X = 0' si f/X = 1', ~f/X = 1' sinon
(f|g)/ X = 0' si f/X=0' et g/X = 0'(f|g)/ X = 1' sinon
(fg)/X = 1' si f/X=1' et g/X = 1'(fg)/ X = 0' sinon

(f=> g) /X = 0' si f/X = 1 et g/X, = 1', (f<=> g) /X = 0' sinon
(f<=> g) /X = 1' si f/X = g/X, (f<=> g) /X = 0' sinon
Ces valeurs correspondent, bien sr, celles donnes par les tables de vrit
habituelles pour les oprations concernes.
Solution d'un ensemble de contraintes

boolennes
Une affectation boolenne est solution d'un ensemble de contraintes si et
seulement si toutes les contraintes de cet ensemble sont vrifies lorsque l'on
a remplac les expressions qui y figurent par leurs valeurs pour cette
affectation.
Dans le mme esprit, un systme de contraintes boolennes est soluble s'il
admet au moins une affectation boolenne qui en soit solution, insoluble
sinon.
Exemples :
Le systme {a=>b,b=>c,c=>a} est soluble et admet les deux solutions
suivantes :
X={a:=1', b:=1', c:=1'}
et X'={a:=0', b:=0', c:=0'}
Le systme {~a|b=1',a|c=1',a#b,b#c} n'admet, lui, aucune solution
et est donc insoluble.
126
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Simplification de systmes de contraintes

Lorsque l'on parle de simplification de contraintes, cela recouvre gnralement deux aspects trs diffrents. Le premier aspect de la simplification est
de rendre le systme considr le plus lisible possible, grce une forme
normale agrable, mais surtout la suppression du plus grand nombre de
redondances, principalement pour en diminuer la taille. Le second aspect
concerne l'limination des variables inutiles.
Pour ce qui est du premier aspect, Prolog III ne supprime pas toutes les
redondances dans les contraintes boolennes, mais garantit cependant que
chaque fois que le domaine des valeurs possibles pour une variable est rduit un lment, l'quation correspondante figure dans le systme de
contraintes. Examinons, par exemple, la requte suivante et la rponse
fournie par l'interprteur :
> {a|b|c = 1',a => b,b => c};

{c = 1', a => b}
La variable c est contrainte de reprsenter la valeur 1' dans toutes les solutions du systme initial. L'quation est donc produite, et l'ensemble de
contraintes simplifi, en remplaant c par 1' dans chacune des contraintes
de la requte.
Examinons prsent le mcanisme de suppression des variables inutiles.
Voici, tout d'abord, la dfinition de l'quivalence sur un sous-ensemble de
variables.
Deux systmes de contraintes sont quivalents sur un sous-ensemble de
variables V si et seulement si pour toute solution X de l'un, il existe une
solution X' de l'autre qui concide avec X sur V et vice versa.
En particulier, pour les sorties, on cherchera exhiber un systme quivalent
sur un sous-ensemble V, gnralement l'ensemble des variables figurant
dans la requte, qui ne contienne que des variables de V. On parlera parfois
ce propos de projection sur un sous-vocabulaire. Les contraintes prsentes
PrologIA
127

dans ce systme fourniront les liens qui unissent les variables considres
dans le systme courant.
La ncessit d'une telle fonctionnalit est double. Tout d'abord, il arrive et
nous en verrons des exemples, que l'on ne s'intresse qu'aux liens qui
unissent certaines des variables sur lesquelles on a fait porter des contraintes
(par exemple, quels sont les liens entre les diffrentes pannes possibles, dans
une configuration donne, dans un systme expert). Ensuite, de manire
transparente pour l'utilisateur, l'interprteur cre constamment de nouvelles
variables, et il serait dommage que celles-ci, apparaissant dans des
contraintes, ne viennent perturber la clart (si l'on peut dire) des ensembles
de contraintes rsultats.
Voici, pour finir, quelques exemples de simplification de systmes :
La simplification du systme {a|x=1',a|~x=1'} sur le sous-ensemble
{a} donne le systme {a=1'}
Cet exemple est relativement trivial puisque le systme initial est dj
quivalent au systme {a=1'}
La simplification de {a|x=b|y,a&x#b&y} sur {a, b, c} fournit le systme
{a|b=1'}
On remarque sur cet exemple que l'une des deux variables a ou b doit
tre gale 1'. En fait, aucune solution du systme initial ne comporte
la fois les affectations a:=0' et b:=0'.
Enfin, le systme {a=>b|x,x=a&c,y|b#x&c} simplifi sur {a, b, c} est
gal {a=>c|b,a&b&c=0'}
Pas de commentaires particuliers, sinon qu'il est assez difficile de le vrifier la main. Essayez donc
Rgles prdfinies spcifiques

Les rgles prdfinies spcifiques aux boolens sont peu nombreuses. Les
voici succinctement nonces (On retrouvera ces rgles dans le chapitre
exclusivement consacr aux rgles prdfinies et prdicats valuables de
Prolog III)
128
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
bool(B) : Vrifie que le terme B reprsente une valeur boolenne connue.

is_bool(B) : Vrifie que le terme B reprsente une valeur boolenne ou
que la contrainte {B !bool} appartient au systme courant de contraintes.
3 . Premiers exemples de programmes

Nous allons prsent examiner quelques programmes Prolog III qui utilisent des contraintes boolennes.
Un ou sur deux variables

Un premier prdicat, tout fait lmentaire, calcule le ou de deux variables.
Le voici :
OuSimple(b1, b2, b1|b2) ->;
Quelques excutions nous donnent une ide plus prcise du traitement

effectu, lorsqu'on pose ce type de contraintes.
> OuSimple(1',0',b);
{ b = 1'}
Le rsultat de ou appliqu vrai et faux est vrai.
OuSimple(b1,0',b);
>
{
b => b1,
b1 => b }
Le rsultat de ou appliqu faux et une variable a la valeur de cette variable

(l'galit est reprsente ici par une double implication)
PrologIA
129
Aociation
OuSimple(b1,b2,0');
>
{
b1 = 0',
b2 = 0' }
Enfin, pour que le rsultat d'un ou appliqu deux variables soit faux, il faut
que les deux variables reprsentent la valeur faux.
Un ou sur une liste

Le calcul d'un ou sur une liste de boolens est un tout petit peu plus
compliqu. En fait, on veut exprimer les contraintes quivalentes l'expression "il y a au moins un lment vrai dans la liste", le second argument du
prdicat Ou ayant la valeur de cette expression.
Ou(<>, 0') ->;

Ou(<b1>.L, b1|b2) ->
Ou(L, b2);
La rgle d'arrt exprime qu'il n'y a pas au moins un lment vrai dans la liste
vide (il n'y en a bien sr aucun). L'autre procde rcursivement, en calculant
le ou sur la tte de liste et sur le ou de la queue de liste.
Quelques excutions pour y voir un peu plus clair :
> Ou(<1',b1,0'>,1');
{
b1 !bool }
La liste comportant d'ores et dj un lment dont la valeur est vrai, aucune

contrainte ne porte sur b1, si l'on excepte le fait que b1 doit reprsenter une
valeur boolenne.
130
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
> Ou(<b1,b1,b1>,1');
{
b1 = 1'}
Ici, pour qu'il y ait au moins un lment vrai dans une liste compose de trois
fois la mme variable, il faut bien sr que cette variable reprsente la valeur
vrai.
> Ou(<b1,b2,b3>,b);
{
b => b1|b2|b3,
b1 => b,
b2 => b,
b3 => b }
En laissant variables toutes les valeurs, le systme de contrainte quivalent

exprime l'galit entre la valeur de b et celle du ou des lments de la liste.
Au plus un de vrai
On complique quelque peu le problme. On veut imposer cette fois-ci qu'il y
ait au plus une variable de vraie dans une liste.
L'criture de ce prdicat n'est pas vraiment triviale, au sens ou il n'y a pas de
correspondance immdiate entre la valeur de au plus un de vrai sur une liste
de tte b1 et de queue L et sur celle de la liste L.
Si l'on observe le problme de manire un peu plus prcise, on se retrouve
devant l'alternative suivante :
Soit la tte de liste est vrai, et le ou de la queue de liste doit tre faux, soit la
valeur de la tte de liste est faux, et il faut qu'il y ait au plus un lment de vrai
dans la queue de liste. On peut alors proposer une premire solution de la
forme suivante :
PrologIA
131

AuPlusUnVrai(<>,1')->;
AuPlusUnVrai(<b1>.L, b)->
Ou(L,b2)
AuPlusUnVrai(L,b3)
{ b = (b1&~b2) | (~b1&b3) };
Voici quelques excutions :
> AuPlusUnVrai(<1',b2,b3>,1');
{ b2 = 0', b3 = 0'}
> AuPlusUnVrai(<b1,0',b2>,b);
{
b&b1&b2 = 0',
b|b1 = 1',
b|b2 = 1'}
Pas de commentaires particuliers pour le premier exemple. Dans le second,

le systme de contraintes quivalent exprime les affirmations suivantes :
b1, b2 et b ne peuvent pas tre vrais en mme temps. (dans le cas
contraire, AuPlusUnVrai renverrai la valeur 1' avec deux lments
vrais dans la liste)
b1 ou b est vrai (dans le cas contraire, AuPlusUnVrai renverrai la valeur
0', alors que deux des lments de la liste sur les trois sont faux)
b2 ou b est vrai (mme raison que prcdemment)

On peut galement crire ce programme sans renvoyer la valeur de
l'expression, cela permettant de l'optimiser. On peut en effet considrer le
problme de la manire suivante. Pour avoir au plus un lment vrai dans
une liste de tte b1 et de queue L, la premire contrainte vrifier est que le
et de la tte et du ou de la liste soit faux. Il faut cependant que cette
contrainte s'applique galement rcursivement sur chacune des sous listes
auxquelles on a enlev la tte de la prcdente.
Par exemple, si on considre une liste de cinq lments on aura :
{ b1
&
(b2|b3|b4|b5)
b2
&
(b3|b4|b5)
132
0'
0'
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
b3 & (b4|b5) = 0'

b4 & b5 = 0'
Voici donc une autre criture possible :
AuPlusUnVrai(L) -> OuSurAuPlusUnVrai(L, b);

OuSurAuPlusUnVrai(<>, 0') ->;
OuSurAuPlusUnVrai(<b1>.L, b1|b2) ->
OuSurAuPlusUnVrai(L, b2)
{b1 & b2 = 0');
Avec les mmes exemples d'excution que pour l'exemple prcdent :
> AuPlusUnVrai(<1',b2,b3>);
{ b2 = 0', b3 = 0'}
> AuPlusUnVrai(<b1,0',b2>);
{
b1&b2 = 0'}
K lments vrais dans une liste de n boolens

Voici, enfin, un dernier exemple de manipulation de contraintes sur des listes
de boolens. Dans le programme suivant, le prdicat Vrais(k,L,b) a t
construit de faon ce que la valeur boolenne de b soit celle de l'expression
:
"la liste de boolens L contient exactement k lments vrais"
PrologIA
133

Vrais(k, <>, 0') ->
{k 0};
Vrais(0, <>, 1') ->;
Vrais(0, <b1>.L, ~b1&b2) ->
Vrais(0, L, b2);
Vrais(k, <b1>.L, b) ->
Vrais(k-1, L, b2)
Vrais(k, L, b3),
{k 0, b = (b1 & b2) | (~b1& b3)};
L'ide gnrale de ce programme est de considrer le problme de la

manire suivante :
Il y a exactement k lments vrais dans une liste de boolens de tte b1 et
de queue L , si et seulement si l'une des deux propositions suivantes est
vraie :
(i)
b1 est vrai et il y a exactement k-1 lments vrais dans la liste L
(ii) b1 est faux et il y a exactement k lments vrais dans la liste L

L'utilisation du paramtre b permet, en outre, de rendre le programme
entirement dterministe si k et la taille de la liste L sont connus.
Voici un exemple d'excution de ce programme :
> vrais(2,<X,Y,Z,T>,1');
{
X & Y & Z = 0',

X & Y & T = 0',
X & Z & T = 0',
Y & Z & T = 0',
X | Y | Z = 1',
X | Y | T = 1',
X | Z | T = 1',
Y | Z | T = 1'
134
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
On notera que la rponse fournie, aprs simplification et limination des

variables inutiles du systme de contraintes final, induit une formalisation
diffrente du problme pos, que l'on peut exprimer de la manire
suivante :
k boolens sont vrais parmi n
si et seulement si
toute disjonction de (n-k+1) lments est vraie,
et toute conjonction de (k+1) lments est fausse.
On remarquera galement que l'excution d'une question dans laquelle k
n'est pas connu donne un ensemble de rponses correspondant aux valeurs
possibles de k.
Il existe galement une manire de programmer cet exemple en utilisant
un simple appel rcursif, ce qui le rend nettement plus efficace. Nous
laissons au lecteur le soin d'crire ce programme titre d'exercice.
4 . D'autres exemples
Nous allons ici prsenter quelques exemples, de tailles un peu plus volumineuses, qui permettent d'apprcier l'utilisation des contraintes boolennes
pour rsoudre un certain nombre de problmes.
Pannes dans un additionneur binaire

Il sagit de dtecter le ou les composants dfectueux dans un additionneur
qui calcule la somme binaire de trois bits x 1 ,x 2 ,x 3 , sous forme dun
nombre binaire de deux bits y1,y2. Comme on peut le voir dans la figure
suivante, ce circuit est form de 5 composants numrots de 1 5 : deux
portes et (marques Et), une porte ou (marque Ou) et deux portes ou exclusif (marques OuX). Trois variables u1,u2,u3 ont t introduites de faon
reprsenter les sorties des portes 1, 2 et 4.
PrologIA
135

x1
u1
1
Et
2
Et
x2
x3
Aociation
4
OuX
u2
u3
3
Ou
y1
5
OuX
y2
Fig. 4.1 Le circuit

On associe chaque porte i une panne p i et l'on se place dans une
hypothse de panne simple, c'est dire que l'on admet que deux portes ne
peuvent tre dfectueuses simultanment.
Voici les prdicats qui rendent compte de cette hypothse. On reconnatra
le prdicat au_plus_un_vrai, tel qu'il a t expos prcdemment.
au_plus_un_vrai(X) ->
ou_au_plus_un_vrai(X, A);
ou_au_plus_un_vrai(<>, 0') ->;
ou_au_plus_un_vrai(<A>.X, A | B) ->
ou_au_plus_un_vrai(X, B),
{ A & B = 0' };
Le prdicat suivant dcrit les liens qui unissent les pannes et les valeurs
d'entres-sorties du circuit.
circuit(<P1,P2,P3,P4,P5>,<X1,X2,X3>,<Y1,Y2>) ->
au_plus_un_vrai(<P1,P2,P3,P4,P5>)
{ ~P1 => (u1 <=> X1 & X3),
~P2 => (u2 <=> X2 & u3),
~P3 => (Y1 <=> (u1 | u2)),
~P4 => (u3 <=> ~(X1 <=> X3)),
~P5 => (Y2 <=> ~(X2 <=> u3)) };
136
Prolog
HERITAGE
PrologIA
Aociation
Prolog
HERITAGE
Les contraintes utilises dcrivent le fait que si une porte n'est pas en panne,
alors le rsultat fourni par celle-ci est conforme aux prdictions que l'on est
en droit de faire.
On peut se demander pourquoi on utilise ici une implication et pas une
galit (quivalence) entre les variables reprsentant les pannes pour une
porte donne et les expressions qui en expriment le bon fonctionnement. On
opre ainsi pour traduire le fait qu'une porte peut tre en panne et fournir,
pour un jeu de donnes prcis, une rponse correcte (l'exemple typique est
celui d'une porte qui renvoie toujours la mme valeur). Dans cette optique,
le lancement du programme pour un jeu de donnes correct ne fournit pas
comme rsultat la valeur 0' pour toutes les variables reprsentant les
pannes, ces variables restant libres.
On peut utiliser ce programme de deux manires : soit en imposant des
valeurs aux entres et aux sorties du circuit, de faon obtenir, le cas
chant, des informations sur les portes dficientes, soit en recherchant les
jeux de tests qui permettent de caractriser une panne.
Voici tout d'abord deux requtes qui recherchent une panne :
> circuit(<P1,P2,P3,P4,P5>,<1',1',0'>,<0',1'>);
{P5=0',P4=1',P3=0',P2=0',P1=0'}
La porte 4 (Oux) est en panne.
> circuit(<P1,P2,P3,P4,P5>,<1',0',1'>,<0',0'>);
{ P5=0',P4=0',P2=0',
P3&P1=0',
P3|P1=1' }
Une seule des deux portes parmi 1 ou 3 est dficiente.
PrologIA
137

Intressons nous prsent rechercher les jeux de tests ncessaires la caractrisation d'une panne donne. La premire ide est de lancer la requte
en laissant inconnues les entres et les sorties et en fixant une panne vrai.
Voici une telle requte, o l'on s'intresse la porte 1.
> circuit(<1',P2,P3,P4,P5>,<X1,X2,X3>,<Y1,Y2>);
{ P2 = 0', P3 = 0',
P4 = 0', P5 = 0',
X3&X2 => Y1|X1,
X2&X1 => Y1|X3,
Y2&X3&X2 => X1,
Y2 => X3|X2|X1,
Y2&X2&X1 => X3,
Y2&X3&X1 => X2,
X2 => Y2|Y1,
X2 => Y2|X3|X1,
X3 => Y2|X2|X1,
X3&X2&X1 => Y2,
X1 => Y2|X3|X2
}
Si l'on excepte le fait que les autres pannes sont fausses, ce qui provient
naturellement du prdicat AuPlusUnVrai, les renseignements fournis par le
systme simplifi sont plutt illisibles. Une solution consiste numrer les
solutions de ce systme pour visualiser les diffrents jeux de donnes qui
permettent de parvenir ce rsultat. Pour ce faire, on ajoute au programme
les prdicats suivant, qui instancient les variables boolennes, de manire
non dterministe.
booleans(<>)->;
booleans(.L)->
boolean(B)
booleans(L);
boolean(0')->;
boolean(1')->;
On lance alors la requte en numrant les solutions :
138
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE

> circuit(<1',P2,P3,P4,P5>,<X1,X2,X3>,<Y1,Y2>)
booleans(<X1,X2,X3,Y1,Y2>);
{ X1 = 0', X2 = 0', X3 = 0', Y1 = 0', Y2 = 0',
P2 = 0', P3 = 0', P4 = 0', P5 = 0'
}
{ X1 = 0', X2 = 0', X3 = 0', Y1 = 1', Y2 = 0',
P2 = 0', P3 = 0', P4 = 0', P5 = 0'
}
{ X1 = 0', X2 = 0', X3 = 1', Y1 = 0', Y2 = 1',
P2 = 0', P3 = 0', P4 = 0', P5 = 0'
}
{ X1 = 0', X2 = 0', X3 = 1', Y1 = 1', Y2 = 1',
P2 = 0', P3 = 0', P4 = 0', P5 = 0'
}
{ X1 = 0', X2 = 1', X3 = 0', Y1 = 0', Y2 = 1',
P2 = 0', P3 = 0', P4 = 0', P5 = 0'
}
{ X1 = 0', X2 = 1', X3 = 0', Y1 = 1', Y2 = 1',
P2 = 0', P3 = 0', P4 = 0', P5 = 0'
}
{ X1 = 0', X2 = 1', X3 = 1', Y1 = 1', Y2 = 0',
P2 = 0', P3 = 0', P4 = 0', P5 = 0'
}
{ X1 = 1', X2 = 0', X3 = 0', Y1 = 0', Y2 = 1',
P2 = 0', P3 = 0', P4 = 0', P5 = 0'
}
{ X1 = 1', X2 = 0', X3 = 0', Y1 = 1', Y2 = 1',
P2 = 0', P3 = 0', P4 = 0', P5 = 0'
}
{ X1 = 1', X2 = 0', X3 = 1', Y1 = 0', Y2 = 0',
P2 = 0', P3 = 0', P4 = 0', P5 = 0'
}
{ X1 = 1', X2 = 0', X3 = 1', Y1 = 1', Y2 = 0',
P2 = 0', P3 = 0', P4 = 0', P5 = 0'
}
{ X1 = 1', X2 = 1', X3 = 0', Y1 = 1', Y2 = 0',
P2 = 0', P3 = 0', P4 = 0', P5 = 0'
}
{ X1 = 1', X2 = 1', X3 = 1', Y1 = 0', Y2 = 1',
P2 = 0', P3 = 0', P4 = 0', P5 = 0'
}
{ X1 = 1', X2 = 1', X3 = 1', Y1 = 1', Y2 = 1',
P2 = 0', P3 = 0', P4 = 0', P5 = 0'
}
On obtient ainsi toutes les solutions pour lesquelles il est possible que la
porte 1 soit dfectueuse. On peut cependant remarquer des solutions o le
rsultat est correct, par exemple la premire, ainsi que d'autres pour
lesquelles la dfaillance de la porte 1 n'est pas la seule panne possible (on
retrouve notamment la dixime solution un des exemples prcdents pour
lequel l'une des portes 1 ou 3 tait en panne).
On va donc tenter de raffiner encore le traitement pour n'obtenir plus que
les jeux de tests ncessaires et suffisants pour isoler la panne. Il nous faut
exhiber pour cela les solutions qui sont telles que seule la porte 1 est en
panne.
Ce problme n'est pas spcialement trivial. Une ide pour le rsoudre
consiste exhiber, non pas les jeux de tests qui nous intressent, mais le
complmentaire de ceux-ci parmi les solutions prcdentes. Il suffit pour cela
de ne retenir, parmi les solutions qui vrifient le systme de contraintes pour
PrologIA
139

P1 = 1', celles qui vrifient galement le systme quand P1 = 0'. Voici
la requte correspondante :
circuit(<0',P2,P3,P4,P5>,<X1,X2,X3>,<Y1,Y2>)
Une autre solution envisageable consiste a se placer un mta-niveau et

utiliser une ngation par chec, puisque l'on veut connatre les donnes qui,
d'une part vrifient le systme de contraintes lorsque P1 est vrai, et d'autre
part qui ne vrifient pas celui-ci quand P1 est faux.
Voici, tout d'abord le prdicat non, tout fait classique en Prolog, qui
s'efface si le prdicat P ne peut pas tre effac. :
non(P) -> P / fail;

non(P)->;
On peut alors poser notre requte de la manire suivante :
>
circuit(<1',P2,P3,P4,P5>,<X1,X2,X3>,<Y1,Y2>)
booleans(<X1,X2,X3,Y1,Y2>)
non(circuit(<0',P2,P3,P4,P5>,<X1,X2,X3>,<Y1,Y2>));
Il faut noter ici que l'numration doit se faire avant la ngation, sous
peine de rencontrer des problmes, les variables n'tant pas encore
instancies (il est clair en effet dans ce cas que la ngation sera systmatiquement vrifie, le systme de contraintes avant instanciation des
variables boolennes d'entres-sorties tant soluble dans tous les cas). Or
cette instanciation systmatique au plus haut est fondamentalement en
opposition avec la philosophie de Prolog III qui consiste installer le plus de
contraintes possibles avant toute numration (voir le chapitre sur les
contraintes numriques et le prdicat valuable enum ). Cette solution ne
nous satisfait manifestement donc pas.
140
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
On peut galement, en restant un mta-niveau, mais sans utiliser de

ngation par chec, utiliser le prdicat valuable known. On rappelle ce
propos qu'une variable est connue si et seulement si elle reprsente un arbre
dont on connait l'tiquette initiale et dont on sait si le nombre de fils est nul ou non.
Dans ce cas on pourra vrifier, pour chacune des solutions au systme de
contraintes pour lequel P1 est vrai, que le systme contraint cette dernire
reprsenter la valeur 1' (c'est dire qu'elle est connue) aprs un nouvel
effacement du prdicat circuit o on reprend les entres-sorties mais o
la variable P1 est cette fois-ci inconnue.
Voici cette dernire requte et le rsultat fourni :
circuit(<P1,P2,P3,P4,P5>,<X1,X2,X3>,<Y1,Y2>)
booleans(<X1,X2,X3,Y1,Y2>)
known(P1);
{ X1 = 0',
P2 = 0',
X2 = 0',
P3 = 0',
X3 = 0',
P4 = 0',
Y1 = 1',
P5 = 0',
Y2 = 0',
P1 = 1'
{ X1 = 0',
P2 = 0',
X2 = 0',
P3 = 0',
X3 = 1',
P4 = 0',
Y1 = 1',
P5 = 0',
Y2 = 1',
P1 = 1'
{ X1 = 0',
P2 = 0',
X2 = 1',
P3 = 0',
X3 = 0',
P4 = 0',
Y1 = 1',
P5 = 0',
Y2 = 1',
P1 = 1'
{ X1 = 1',
P2 = 0',
X2 = 0',
P3 = 0',
X3 = 0',
P4 = 0',
Y1 = 1',
P5 = 0',
Y2 = 1',
P1 = 1'
{ X1 = 1',
P2 = 0',
X2 = 0',
P3 = 0',
X3 = 1',
P4 = 0',
Y1 = 0',
P5 = 0',
Y2 = 0',
P1 = 1'
{ X1 = 1',
P2 = 0',
X2 = 1',
P3 = 0',
X3 = 1',
P4 = 0',
Y1 = 0',
P5 = 0',
Y2 = 1',
P1 = 1'
Cette solution n'est pas encore parfaitement satisfaisante. En effet, dans la

mesure o les seules variables prsentes dans le prdicat Circuit sont des
variables boolennes, on peut imaginer de reporter directement la ngation
sur l'algbre des boolens, et traiter par l mme celle-ci de manire
parfaitement rigoureuse.
PrologIA
141

Pour ce faire, il suffit d'ajouter un paramtre au prdicat Circuit et
a u _ p l u s _ u n _ v r a i , paramtre qui renvoie la valeur boolenne de
l'expression qui reprsente le systme de contraintes initial (on a dj
remarqu que l'on peut toujours transformer un systme de contraintes
boolennes en expression dont la valeur est vrai).
Voici le nouveau programme. On utilise la version de au_plus_un_vrai
trois arguments qui renvoie la valeur b de l'expression Il existe au plus un
lment vrai dans la liste L. Le rsultat de Circuit est la conjonction de b
et de la valeur de la nouvelle expression construite. Notons galement au
passage que les implications originales ont t transformes en disjonctions :
ou(<>, 0') ->;

ou(<B1>.L, B1|B2) ->
ou(L, B2);
au_plus_un_vrai(<>,1')->;
au_plus_un_vrai(<B1>.L, B)->
ou(L,B2)
au_plus_un_vrai(L,B3)
{ B = (B1&~B2) | (~B1&B3) };
circuit(<P1,P2,P3,P4,P5>,<X1,X2,X3>,<Y1,Y2>,B1&B2) ->
au_plus_un_vrai(<P1,P2,P3,P4,P5>, B1)
{ B2 = (P1|(U1 <=> X1 & X3)) &
(P2|(U2 <=> X2 & U3)) &
(P3|(Y1 <=> (U1 | U2))) &
P4|(U3 <=> ~(X1 <=> X3))) &
(P5 |(Y2 <=> ~(X2 <=> U3)))
};
On peut prsent faire porter la ngation sur le dernier paramtre de

circuit et la requte s'crit de la manire suivante :
> circuit(<1',P2,P3,P4,P5>,<X1,X2,X3>,<Y1,Y2>, 1')
circuit(<0',P2,P3,P4,P5>,<X1,X2,X3>,<Y1,Y2>,
0')
Le rsultat est, bien sr, identique celui prsent prcdemment.
142
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Un puzzle logique
Ce casse-tte logique, propos par Lewis Caroll, a ceci d'intressant qu'il est
constitu d'une suite de phrases, que l'on peut aisment formaliser sous la
forme de formules de logique propositionnelle, et qu'il ne comporte pas de
questions. On peut donc s'amuser, partir de ces phrases, rechercher les
liens qui existent entre certaines des propositions qui y figurent. C'est donc
un exemple typique pour lequel la solution recherche ne peut se prsenter
que sous la forme de la simplification sur un sous-ensemble de variables du
systme de contraintes initial. Voici les phrases proposes.
1.
Tout individu apte tre dput et qui ne passe pas son temps faire des discours, est
un bienfaiteur du peuple.
2.
Les gens lesprit clair, et qui sexpriment bien, ont reu une ducation convenable.
3.
Une femme qui est digne dloges est une femme qui sait garder un secret.
4.
Les gens qui rendent des services au peuple, mais nemploient pas leur influence des
fins mritoires, ne sont pas aptes tre dputs.
5.
Les gens qui valent leur pesant dor et qui sont dignes dloges, sont toujours sans
prtention.
6.
Les bienfaiteurs du peuple qui emploient leur influence des fins mritoires sont dignes
dloges.
7.
Les gens qui sont impopulaires et qui ne valent pas leur pesant dor, ne savent pas garder un secret.
8.
Les gens qui savent parler pendant des heures et des heures et qui sont aptes tre dputs, sont dignes dloges.
9.
Tout individu qui sait garder un secret et qui est sans prtention, est un bienfaiteur du
peuple dont le souvenir restera imprissable.
10. Une femme qui rend des services au peuple est toujours populaire.
11. Les gens qui valent leur pesant dor, qui ne cessent de discourir, et dont le souvenir demeure imprissable, sont prcisment les gens dont on voit la photographie dans toutes
les vitrines.
12. Une femme qui na pas lesprit clair et na pas reu une bonne ducation, est inapte
devenir dput.
13. Tout individu qui sait garder un secret et qui sait ne pas discourir sans cesse, peut tre
certain dtre impopulaire.
14. Un individu lesprit clair, qui a de linfluence et lemploie des fins mritoires, est
un bienfaiteur du peuple.
15. Un bienfaiteur du peuple sans prtention nest pas le genre de personnes dont la photographie est affiche dans toutes les vitrines.
16. Les gens qui savent garder un secret et qui emploient leur influence des fins mritoires, valent leur pesant dor.
17. Une personne qui ne sait pas sexprimer, et qui est incapable den influencer dautres,
nest srement pas une femme.
PrologIA
143

18. Les gens populaires et dignes dloges sont, soit des bienfaiteurs du peuple, soit des
gens sans prtention.
Voici le programme. Un premier prdicat, Possibilit , lie les variables

boolennes utilises et les propositions prsentes dans les phrases
prcdentes, et pose les contraintes portant sur ces variables.
Possibilite(<<a,"avoir l'esprit clair">,

<b,"avoir reu une bonne ducation">,
<c,"discourir sans cesse">,
<d,"employer son influence des fins mritoires">,
<e,"tre affich dans les vitrines">,
<f,"tre apte tre dput">,
<g,"tre un bienfaiteur du peuple">,
<h,"tre digne d'loges">,
<i,"tre populaire">,
<j,"tre sans prtention">,
<k,"tre une femme">,
<l,"laisser un souvenir imprissable">,
<m,"possder une influence">,
<n,"savoir garder un secret">,
<o,"s'exprimer bien">,
<p,"valoir son pesant d'or">>) ->
{ (f & ~c) => g,
(a & o) => b,
(k & h) => n,
(g & ~d) => ~f,
(p & h) => j,
(g & d) => h,
(~i & ~p) => ~n,
(c & f) => h,
(n & j) => (g & l), (k & g) => i,
(p & c & l) => e,
(k & ~a & ~ b) => ~f,
(n & ~c) => ~i,
(a & m & d) => g,
(g & j) => ~e,
(n & d) => p,
(~o & ~m) => ~k,
(i & h) => (g | j) };
Le reste du programme vrifie que la liste fournie en entre est un sousensemble de la liste donne dans Possibilite . Les contraintes sont alors
mises en place, et l'algorithme de simplification sur un sous-ensemble de
variables (voir les remarques concernant cette fonctionnalit) nous permet
de visualiser les liens entre les variables du sous-ensemble considr dans la
question.
144
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
SousPossibilite(x) ->
Possibilite(y)
SousEnsemble(x,y);
SousEnsemble(<>,y) ->;
SousEnsemble(<e>.x, y) ->
ElementDe(e,y)
SousEnsemble(x,y);
ElementDe(e, <e>.y) ->;
ElementDe(e, <e'>.y) ->
ElementDe(e,y), {e#e'};
Intressons nous dans un premier temps tablir les rapports ventuels qui
existent entre "avoir l'esprit clair", "tre populaire"et "savoir garder un
secret". Il suffit pour cela de poser la requte suivante :
> SousPossibilite(<<p,"avoir
<q,"tre
l'esprit
clair">,
populaire">,
<r,"savoir
garder
un
secret">>);
{}
La rponse est l'ensemble vide de contraintes et nous signifie que suivant

Lewis Caroll il n'y a aucun rapport entre "avoir l'esprit clair", "tre
populaire"et "savoir garder un secret".
Voyons prsent quels sont les liens qui unissent les propositions "savoir
garder un secret","tre apte tre dput" et "valoir son pesant d'or". On
pose la requte ci-dessous :
> SousPossibilite(<
<p,"savoir
<q,"tre
apte
<r,"valoir
{
garder
p & q => r
son
un
secret">,
tre
dput">,
pesant
d'or">>);
PrologIA
145
Cette fois ci, la contrainte fournie en rponse exprime le fait que si l'on
sait garder un secret et que l'on est apte tre dput alors on vaut son
pesant d'or.
ststs
146
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Retardements
1. Introduction
2. Termes connus
- Les prdicats valuables known, bound et free
3. Retardement de l'excution d'un but
4. Contraintes retardes
- Tailles retardes
- Concatnation retarde
- Contraintes numriques retardes
On retrouve en Prolog III le concept de retardement de l'excution d'un but. La

comprhension de ce processus demande que l'on s'attarde un peu sur la
signification prcise de ce qu'est une variable connue. De plus, un processus
complexe de retardement de contraintes s'applique lorsque les restrictions de base
sur la taille des arbres, la concatnation des tuples ou la linarit des expressions
numriques ne sont pas explicitement respectes. L'utilisation de ce processus de
retardement de contraintes est un exercice qui peut s'avrer tout fait prilleux, et
nous essayerons dans ce chapitre d'en donner une explication dtaille.
1 . Introduction
Comme Prolog II et Prolog II+, Prolog III permet de retarder l'excution
d'un but en attendant qu'un terme soit connu. La comprhension de ce
Dcembre 1990
PrologIA
Retardements
Aociation
concept demande que l'on s'attarde sur la signification du terme connu. De

plus, certaines contraintes qui ne vrifient pas les restrictions imposes par
Prolog III sont automatiquement retardes. Ce chapitre propose un tour
d'horizon de ces diffrents retardements, ainsi qu'un certain nombre
d'exemples. On conservera l'esprit que la notion de contrainte retarde
sort du cadre formel de Prolog III en fournissant un outil qui, s'il s'avre
agrable l'utilisation ouvre la voie une programmation seme
d'embches.
2 . Termes connus
La dfinition d'un terme connu est trs prcise en Prolog III :
Un terme est connu lorsque l'on connait l'tiquette de l'arbre qu'il

reprsente et que l'on sait si son nombre de fils est nul ou non.
Souvent ces termes sont rduits une variable et on parle alors de variable
connue.
Les prdicats valuables known, bound et free

Les trois prdicats valuables suivants ont un rapport direct avec ce que l'on
sait, au cours de l'excution d'un programme, propos d'un terme donn :
known(T) s'excute avec succs si T est un terme connu au sens de la
dfinition prcdente
148
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Retardements
HERITAGE
bound(T) s'excute avec succs si T est un terme reprsentant un arbre

dont :
L'tiquette initiale est connue
Le nombre des fils est connu
free(T) s'excute avec succs si l'on ne connait pas l'tiquette de l'arbre
reprsent par le terme T, et que l'on ne sait pas si le nombre de ses fils est
nul ou non.
On remarquera au passage que f r e e ( T ) n'est pas la ngation de
known(T) . Par exemple, known(+x) choue car +x n'est pas assez connu
(on sait que l'tiquette est un nombre, mais on ne connat pas sa valeur), et
free(+x) choue aussi, car +x est trop connu (on sait que c'est une
feuille).
3 . Retardement de l'excution d'un but

Prolog III permet de retarder l'excution d'un but tant qu'un terme n'est pas
connu (toujours au sens de la dfinition prcdente). Aussitt que celui-ci est
connu, on tente d'excuter le but retard. Cette opration de retardement se
ralise grce au prdicat valuable freeze(X, P).
Nous pouvons examiner ce traitement sur un exemple. Admettons que l'on
dsire construire le prdicat creer(T1, T2, U) qui retarde la cration du tuple U
form des deux lments T1 et T2 tant que l'on ne connait pas le premier de
ces deux lments. Voici les rgles correspondantes :
creer(T1, T2, U) ->

freeze(T1, creer'(T1,T2,U));
creer'(T1, T2, <T1, T2>)->;
On peut examiner une excution de crer, qui mettra en vidence les sorties
concernant les variables geles.
PrologIA
149
Retardements
Aociation
> creer(illusion(A),T,U);
{ U = <illusion(A),T> }
Le premier paramtre tant connu (l'tiquette est connue et on sait si le

nombre de fils, gal un, est nul ou non), le prdicat creer' e s t
immdiatement excut l'appel.
> creer(T1,T2,U);
{ T1 = E[X],
E[X] !freeze(creer'(E[X],T2,U)) }
Les variables intermdiaires cres par Prolog III ont t renommes par
souci de lisibilit. Ici, le premier paramtre n'est pas connu l'appel, et ne
sera jamais connu jusqu' la fin de l'excution de la requte. En sortie,
Prolog III rappelle que la variable T1, mise sous forme normale l'aide du
constructeur gnral d'arbres sous la forme E[X] demeure dans un tat gel,
et rappelle quel est le prdicat retard sur cette variable.
On peut compliquer un peu cet exemple et s'intresser aux deux prdicats
suivants :
creer_et(T1, T2, U) qui retarde la cration du tuple <T1, T2> jusqu' ce
que les deux termes T1 et T2 soient connus.
creer_ou(T1, T2, U) qui retarde la cration du tuple <T1, T2> jusqu' ce
que l'un des deux termes T1 et T2 soit connu.
Voici ces deux prdicats :
creer_et(T1, T2, U) ->

freeze(T1, freeze(T2, creer'(T1,T2,U)));
creer_ou(T1, T2, U) ->
freeze(T1, creer'(T1, T2, U))
freeze(T2, creer'(T1, T2, U));
creer'(T1, T2, <T1, T2>)->;
150
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Retardements
HERITAGE
On remarquera que le prdicat creer_ou peut s'crire d'une manire plus

subtile afin d'viter que creer' ne soit effac deux fois. Une faon de
rsoudre ce problme est donne dans le paragraphe consacr aux
contraintes numriques retardes.
4 . Contraintes retardes
Maintenant que le principe du retardement de l'excution d'un but est dfini,
examinons comment Prolog III retarde certaines contraintes qui ne
rpondent pas aux restrictions imposes par le langage. C'est le cas :
des contraintes de taille pour lesquelles cette taille n'est pas
explicitement connue
des contraintes faisant intervenir une concatnation pour laquelle la
taille de l'oprande de gauche n'est pas connue
des contraintes numriques non linaires, c'est dire faisant intervenir
des produits de variables ou des divisions par une variable.
On essayera de ne pas perdre de vue que les contraintes qui ne

respectent pas les restrictions de base de Prolog III sortent du
cadre formel et ne devraient, en toute rigueur, figurer dans un
programme. Le souci de faciliter la tche du programmeur a
conduit admettre l'criture de telles contraintes et en dfinir un
traitement appropri.
Dans ces trois cas, Prolog III automatise un certain type de retardement que
nous allons exposer maintenant.
Tailles retardes
On sait (voir chapitre "Arbres, tuples, listes et chanes") que dans une
contrainte de taille, celle-ci doit tre explicitement connue, c'est dire figurer
sous la forme d'une constante entire positive. On sait galement que la
rgle prdfinie bound_size(U, N) permet de poser une telle contrainte au
cours de l'excution d'un programme si la valeur de N est connue au
moment o l'on tente d'excuter le prdicat bound_size. Enfin la syntaxe de
Prolog III permet d'crire directement des contraintes du type {U :: N} ce qui
peut sembler en totale contradiction avec les affirmations prcdentes.
PrologIA
151
Retardements
Aociation
En fait, ce dernier type de contraintes est une facilit de syntaxe. Lorsque

Prolog III doit traiter une contrainte de ce type, il tente d'excuter, avant les
autres buts de la rgle o apparait cette contrainte, le prdicat size(U, N) qui
est un prdicat prdfini et qui utilise notamment freeze, bound_size et
known_part (voir ces prdicats dans le chapitre rgles prdfinies et
procdures externes).
Voici un premier prdicat, trs proche du prdicat size :
delayed_size(T, N) ->
freeze(T, delayed_size'(T, N))
freeze(N, bound_size(T, N))
delayed_size'(E[<>], 0) ->;
delayed_size'(E[U], N) ->
known_part(U, U', U'')
bound_size(U', N')
delayed_size(U'', N-N'),
{ U # <>, N # 0 };
On fera deux remarques propos de ce prdicat :

On profite du fait que la taille d'un terme est gale celle du tuple
form de ses fils.
On profite de tout renseignement sur le dbut de ce tuple pour ne
retarder que les contraintes portant sur la partie de taille inconnue.
Examinons quelques exemples triviaux (on a remplac les variables
intermdiaires de Prolog III par des noms plus lisibles) :
> delayed_size(T,N);
{ T = E1[U1], N = E2[U2],
E1[U1] !freeze(delayed_size'(E1[U1],E2[U2])),
E2[U2] !freeze(bound_size(E1[U1],E2[U2])) }
> delayed_size(Arbre[<1,2>.U],N);
{ U !freeze(delayed_size'(U,N-2)),
N !freeze(bound_size(Arbre[<1,2>.U],N)),
N !freeze(bound_size(U,N-2)) }
>
152
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Retardements
HERITAGE
Nous pouvons ds prsent entrer un peu plus dans le dtail. En fait

Prolog III effectue un traitement plus labor que ce simple retardement.
Voyons sur un exemple :
> {U :: N, U :: M, N # M};
>
Si tout se passait rellement comme nous l'avons dcrit prcdemment, les

deux contraintes de taille se contenteraient de rester geles, et l'incohrence
ne pourrait en aucun cas tre dtecte (rappelons encore une fois qu'il ne
s'agit pas l de rsolution, mais de retardements). Prolog III permet toutefois
de communiquer un certain nombre d'informations des arbres vers les
variables numriques qui reprsentent leurs tailles. Dans le sens inverse (des
tailles vers les arbres), ceci est gnralement beaucoup plus difficile et n'est
pas effectu dans la majorit des cas.
Examinons pour finir un exemple ou l'incohrence n'est pas dtecte :
> { U :: N, 0 < N < 1 };

{ U = E[X],
X :: N,
-N+1 > 0,
N > 0 }
>
De manire triviale, le systme de contraintes donn en entre n'admet

aucune solution, puisque aucune valeur de N dans l'intervalle ]0,1[ n'est
entire. Le processus de retardement ne permet pourtant pas de raliser
l'chec auquel on aurait pu s'attendre.
Concatnation retarde
La seconde restriction concerne les concatnations de tuples. Le retardement
de ces contraintes intervient lorsque l'on a crit une concatnation dont
l'oprande de gauche est de taille inconnue
PrologIA
153
Retardements
Aociation
De la mme manire que pour les contraintes de taille retardes, on peut

donner une premire explication satisfaisante du mcanisme mis en place
dans ce cas en crivant les rgles Prolog III correspondantes. On rappelle que
la rgle prdfinie qui met ce retardement en place est conc3(U,V,W). Voici
un prdicat qui constituera une premire approche de la concatnation
retarde :
delayed_conc(U, V, W) ->
freeze(U, delayed_conc'(U,V,W));
delayed_conc'(<>, V, V) ->;
delayed_conc'(U, V, W) ->
known_part(U, U', U'')
bound_conc(U', W', W)
delayed_conc(U'', V, W'),
{ U # <> };
On profite, comme pour les contraintes de taille, de toute information

partielle sur le dbut du tuple U pour dgeler ce qui peut l'tre.
De la mme manire que prcdemment, on peut aller un peu plus loin, en
tenant compte du fait que la taille du tuple rsultat est gale la somme des
tailles des tuples concatns. Voici un second prdicat, crit dans cette ide,
qui reproduit exactement le prdicat conc3 :
delayed_conc2(U, V, W) ->
freeze(U, delayed_conc'(U,V,W))
size(U, N)
size(V, M)
size(W, N+M);
Le prdicat delayed_conc' est le mme que celui prsent plus haut.

Ainsi toute contrainte du type W = U.V, o la taille de U n'est pas connue, est
remplace, avant le traitement du premier littral de la rgle contenant cette
contrainte, par l'appel d'un prdicat quivalent delayed_conc2(U, V, W).
154
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Retardements
HERITAGE
On peut, bien sr, s'apercevoir que cette manire de faire ne garantit

nullement la compltude du traitement dans le cas o les restrictions ne sont
pas respectes mais constitue bien un palliatif propre viter au
programmeur la gestion de ce type de retardement.
Voici, prsent un certain nombre d'exemples de contraintes de
concatnation retarde. Examinons, dans un premier temps, des contraintes
trs simples, et les rponses fournies par l'interprteur :
> { U.V = W };
{ W = X,
U :: N1,
U.V = X,
V :: N2,
X :: N2 +N1,
N1 >= 0 ,
N2 >= 0 }
Nous avons ici le cas le plus gnral de contrainte retarde faisant intervenir
des concatnations. La concatnation est retarde, et un certain nombre de
contraintes de taille, ainsi que des contraintes numriques liant ces tailles
sont ajoutes au systme courant. Il est bon de se souvenir que ces
contraintes de taille sont galement retardes.
> { U
V
W
W
P
>
:: N,
:: M,
:: P
= U.V,
# M+N };
PrologIA
155
Retardements
Aociation
> {U.X = V.X, U#V};

{ U :: N1,
U.X = X4,
U # V,
X :: N2,
V :: N1,
V.X = X4,
X4 :: N2+N1,
N1 >= 0,
N2 >= 0}
>
Cet exemple montre les limites des contraintes retardes faisant intervenir
des oprations de concatnation. Dans ce cas de figure, les valeurs
reprsentes par U et V ne sont pas suffisamment connues pour permettre
de dtecter l'incohrence de cet ensemble de contraintes.
Contraintes numriques retardes

Bien que seules les contraintes linaires soient prises en compte au niveau
des algorithmes fondamentaux de Prolog III, le langage autorise le
programmeur exprimer des contraintes non linaires. Dans la plupart des
cas il s'agira d'une facilit d'criture pour viter l'emploi du prdicat
valuable bound_mult, les expressions tant linaires, de fait, au moment de
l'unification, un nombre suffisant de variables prsentes dans ces expressions
tant alors connu. Dans le cas contraire, l'ajout de la contrainte est retard,
jusqu' ce que celle-ci devienne linaire.
Le processus, automatique, de retardement peut se programmer grce
l'utilisation de freeze, et nous en expliquerons comme prcdemment le
fonctionnement en dcrivant les rgles Prolog III qui effectuent ce retardement des contraintes.
Voici ces rgles, qui reproduisent le traitement effectu par la rgle
prdfinie mult. La rgle pour la division retarde est donne pour mmoire
:
delayed_mult(X, Y, Z)->
freeze(X, delayed_mult'(X, Y, Z, A))
156
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Retardements
HERITAGE
freeze(Y, delayed_mult'(Y, X, Z, A));

delayed_mult'(X, Y, Z, A)-> known(A) /;
delayed_mult'(X, Y, Z, 1')->
bound_mult(X, Y, Z);
delayed_divide(X, Y, Z)->
delayed_mult(Z, Y, X)
{ Y#0 };
Dans le cas de la multiplication, il faut retarder le traitement de la contrainte

jusqu' ce que l'une ou l'autre des variables X et Y soit connue. On installe
donc un double freeze sur les deux variables X et Y.
Le prdicat delayed_mult' permet, grce l'utilisation d'une variable de
communication A, de ne pas excuter delayed_mult' deux fois dans le cas o
il existe une tape o les deux variables sont connues. En effet, la premire
excution de delayed_mult' chouera sur la premire rgle, A n'tant pas
connu, et aprs mise en place de la contrainte, affectera A 1', forant par l
mme les appels suivants excuter la premire rgle, qui n'installe pour sa
part aucune contrainte.
La division est construite naturellement en utilisant le prdicat
delayed_mult.
Concernant le traitement retard des contraintes numriques non linaires,
on retiendra, pour finir, la dfinition informelle suivante :
Dans le traitement des expressions numriques non-linaires, tout se passe
comme si toute contrainte de la forme Z = E*E', o E et E' sont des
expressions contenant des variables, tait transforme en un appel du
prdicat delayed_mult(E, E', Z). De manire similaire, toute contrainte de la
forme Z = E/E', o E' est une expression contenant des variables, est
remplace par un appel de delayed_divide(E, E', Z).
PrologIA
157
Retardements
Aociation
Cette faon de faire garantit notamment le respect d'un

parenthsage ventuel. Par exemple les systmes de contraintes
{X=A*(B+C)} et {X=A*B+A*C} ne sont pas traits exactement de la
mme faon. Dans le second cas, si la valeur de A est inconnue, le
fait de connatre B ou C dgle une partie de la contrainte, alors
que dans le premier cas on ne fait rien tant que leur somme n'est
pas connue.
Examinons ce processus de retardement sur un exemple :
non_lineaire(X,Y,Z,T,V) ->
{Z = X*Y+2T/(X+(3/2)V)};
Cette rgle est considre par le systme de la manire suivante :
non_lineaire(X,Y,Z,T,V) ->
delayed_mult(X,Y,X')
delayed_divide(2T,X+(3/2)V,Y')
{Z = X'+Y'};
En fait, la rgle prdfinie est mult que l'on a renomm pour que vous
puissiez tester ces exemples sur votre interprte.
Voici un exemple d'excution o l'on connait un nombre suffisant de valeurs
pour rendre le systme linaire :
> non_lineaire(2,Y,Z,T,3);
{ Y = Y1, T = T1, Z = (4/13)T1+2Y1 }
>
Et un autre o des contraintes restent geles :
158
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Retardements
HERITAGE
> non_lineaire(X,3,Z,T,2);
{ X = X', Z = U'+3X', T = T',
X'+3 # 0,
U'*(X'+3) = 2T' }
>
Comme on pouvait s'y attendre, il demeure un freeze en place sur la division,

celle ci comportant des variables inconnues dans l'expression qui en
constitue le diviseur. La multiplication, linaire l'appel, a pu tre ajoute au
systme de contraintes.
On pourra galement noter ici les limitations de ce processus de retardement
qui ne garantit en rien la dtection systmatique des ensembles de
contraintes non-linaires incohrents.
En voici deux exemples :
> {
{
> {
{
X*X = -2 };
X*X = -2 }
X*Y > 0, X > 0 > Y };
Y = -Y',
(-Y')*X = U',
X > 0,
Y' > 0,
U' > 0 }
>
ststs
PrologIA
159
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Le contrle et l'environnement des

programmes
1.
2.
3.
4.
5.
Le contrle
Expressions, variables statiques, tableaux
Structuration, saisie
Entres / sorties
Autres lments de l'environnement
De tout! Ce chapitre prsente en effet un ensemble fort disparate de notions,

qu'on pourrait regrouper sous l'appellation les moyens de programmer effectivement en Prolog III . Il y sera question des outils pour contrler l'excution des
programmes afin de les rendre plus rapides, comme le clbre /, ainsi que de la
manire de structurer les gros programmes en modules et les directives pour
interfacer harmonieusement ces derniers. On parlera aussi de l'ensemble des
moyens ralisant pratiquement l'insertion, la suppression et la modification des
rgles, ainsi que leur sauvegarde et restauration l'aide de fichiers magntiques.
Du coup, on en profitera pour traiter des entres/sorties et, finalement de tous les
autres points ayant trait au monde environnant le systme Prolog III.
Dcembre 1990
PrologIA
L'environnement
Aociation
1 . Le contrle
A chaque tape de l'excution d'un programme l'interprte Prolog III doit
faire deux choix : l'un pour choisir un but dans une suite de buts excuter,
l'autre pour choisir la rgle qui servira l'excuter. Au chapitre Concepts
de base nous avons donn un modle de l'excution d'un programme
Prolog III (voir le chapitre Concepts de base ) :
(1)
(2)
(3)
( W, t0 t1 tn , S )
s0 s1 s m , R
( W, s1 sm t1 tn , S R { s0 = t0 } )
et nous avons expliqu comment se font les deux choix mentionns : le but
choisi est toujours le premier lment de la suite des buts excuter (ici t0) ;
les rgles choisies pour l'excuter sont toutes les rgles dont la tte s'unifie
avec le but en question, c'est--dire les rgles s 0 s 1 s m , R p o u r
lesquelles le systme S R { s0 = t0 } est soluble ; toutes ces rgles sont
examines, dans l'ordre o elles ont t crites.
Prolog III tant un langage foncirement dclaratif, la notion de contrle est
ncessairement rduite sa plus simple expression : cela consiste modifier
ou restreindre les deux choix prcdents. La manire dont Prolog fait ces
choix peut amener certains programmes boucler et par consquent ne
pas se comporter comme on pouvait l'esprer. Les deux exemples suivants
illustrent ce phnomne.
Exemple 1 : Un cas typique est celui de la transitivit. Quand on cherche
effacer plus_grand(Jo,x) en utilisant le programme suivant, on retrouve une
instance de ce mme but effacer. Le programme se met alors boucler et
se termine par un dbordement de pile (ou par une interruption utilisateur).
> insert;
plus_grand(Jo,Max) -> ;
plus_grand(Max,Fred) -> ;
plus_grand(x,y) -> plus_grand(x,z) p l u s _ g r a n d ( z , y ) ; ;
{}
> plus_grand(Jo,x);
{x = Max}
{x = Fred}
162
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
DEBORDEMENT
>
La manire correcte d'crire ce programme consiste enlever la rcursivit

gauche :
> insert;
plus_grand'(Jo,Max) ->;
plus_grand'(Max,Fred) ->;
plus_grand(x,z) ->
plus_grand'(x,y)
plus_grand_ou_egal(x,x)
plus_grand_ou_egal(x,y)
{}
> plus_grand(Jo,x);
{x = Max}
{x = Fred}
>
plus_grand_ou_egal(y,z);
->;
-> plus_grand(x,y);;
Exemple 2 : Cet exemple numre toutes les listes construites avec 1. Avec le
(mauvais) programme ci-dessous, c'est d'abord la liste infinie qui devrait tre
produite :
> insert;
liste_de_un(<1>.x) ->
liste_de_un(<>) - > ; ;
{}
> liste_de_un(x);
liste_de_un(x);
DEBORDEMENT
>
Bien entendu, la bonne solution s'obtient en permutant l'ordre des deux

rgles :
> insert;
liste_de_un(<>) ->;
liste_de_un(<1>.x) ->
{}
> liste_de_un(x);
{x = <>}
liste_de_un(x);;
PrologIA
163
L'environnement
Aociation
{x = <1>}
{x = <1,1>}
{x = <1,1,1>}
INTERRUPTION UTILISATEUR
La coupure / ( cut )
Normalement, Prolog III essaye d'excuter une suite de buts de toutes les
manires possibles. Mais si on utilise une rgle contenant un / (ou coupure1)
pour excuter un but q, l'excution de ce / supprimera tous les choix de
rgles restant faire pour l'excution de q. Cela restreint la taille de l'espace
de recherche : on peut dire que / fait oublier les autres manires possibles
d'excuter q.
Le / est un parasite qui ne peut apparatre que parmi les termes qui
constituent le membre droit d'une rgle. Les choix qui restent examiner et
que l'effacement du / supprime sont :
les autres rgles ayant la mme tte que celle o le / figure
les autres rgles qui auraient pu tre utilises pour effacer les termes
compris entre le dbut de la queue et le /
Cette question est illustre par les exemples suivants :
> list;
couleur(rouge) ->;
couleur(bleu) ->;
taille(grand) ->;
taille(petit) ->;
164
Prolog
HERITAGE
En accord avec la syntaxe d'Edimbourg, la coupure peut se noter aussi !
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
choix1([x,y]) -> couleur(x) taille(y);

choix1("c'est tout") ->;
choix2([x,y]) -> / couleur(x) taille(y);
choix3([x,y]) -> couleur(x) / taille(y);
choix4([x,y]) -> couleur(x) taille(y) /;
{}
> choix1(u);
{u=[rouge,grand]}
{u=[rouge,petit]}
{u=[bleu,grand]}
{u=[bleu,petit]}
{u="c'est tout"}
> choix2(u);
{u=[rouge,grand]}
{u=[rouge,petit]}
{u=[bleu,grand]}
{u=[bleu,petit]}
> choix3(u);
{u=[rouge,grand]}
{u=[rouge,petit]}
> choix4(u);
{u=[rouge,grand]}
> choix1(u) / ;
{u=[rouge,grand]}
>
On peut considrer la coupure comme une annotation que l'on fait un programme juste pour le rendre plus efficace ; bien entendu, cela ne se justifie
que si on ne s'intresse qu' la premire solution fournie par ce programme.
Voici quelques utilisations classiques du / :
" Premire solution uniquement "
premiere_solution_uniquement(b) -> b /;
" Si alors sinon "
si_alors_sinon(p,a,b) -> p / a;
si_alors_sinon(p,a,b) -> b;
PrologIA
165
L'environnement
Aociation
" non "

non(p) -> p / fail;
non(p) ->;
Dans le cas de non, montr ci-dessus, il faut remarquer que l'on peut avoir
des rsultats inattendus si p contient des variables libres. C'est ce que
montre le petit exemple suivant :
> list;
homme(Abelard) -> ;
femme(x) -> non(homme(x));
> femme(Abelard);
> femme(Eloise);
{}
> femme(x) eq(x,Eloise);
>
block(e, b), block_exit(e)

block est une rgle prdfinie qui permet de terminer brutalement l'excution
d'un but b. On peut considrer que :
- pour excuter block(e, b) on excute b en ayant auparavant cr une
paire de parenthses fictives, tiquetes par e, autour du but b.
- block_exit(e) provoque l'abandon immdiat de l'excution de tous les
buts inclus entre les parenthses tiquetes par e. L'excution continue
ensuite normalement, aprs avoir restaur l'environnement comme il
l'tait avant l'excution de b.
De plus :
- l'tiquette dont il est question ci-dessus est un terme Prolog III
quelconque, et on considre que pour que deux termes reprsentent la
mme tiquette au regard du mcanisme block_exit, il faut et il suffit
qu'ils soient unifiables.
- s'il y a plusieurs parenthses tiquetes par e, block_exit(e) s'arrte au
couple de parenthses la plus interne.
- si block_exit(e) ne rencontre pas de parenthses tiquetes par e, alors
une erreur est signale.
166
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
Interruption
A tout instant un programme Prolog peut tre interrompu au moyen d'une
touche dtermine, dpendant du systme utilis (par exemple : <Ctrl-C>).
Un petit dialogue est alors propos l'utilisateur :
User Interrupt by (^C). C(ontinue, K(ill, T(race, Q(uit ?
lui permettant selon la rponse fournie, de continuer l'excution (C), de
l'interrompre (K), de continuer l'excution en mode trace (T) ou encore de
quitter la session (Q).
Les primitives suivantes sont considres aussi comme des moyens de
contrler l'excution d'un programme :
bound(x)
bound(x) s'efface si x est li. Une variable est considre comme lie si elle est
astreinte reprsenter un arbre dont
l'tiquette initiale est connue
le nombre de fils est connu
default(t1, t2)
La rgle prdfinie default permet de raliser le contrle suivant : si on peut
effacer t1, alors on l'efface de toutes les manires possibles, sinon on efface t2,
galement de toutes les manires possibles. Il faut remarquer que cette
primitive ne peut pas tre ralise avec / . Voyons un exemple
d'utilisation de cette rgle :
> list;
repondre(p) -> default(p,outml("personne"));
homme(jean) ->;
homme(pierre) ->;
{}
> repondre(homme(x));
{x=jean}
{x=pierre}
> repondre(femme(x));
personne
{}
>
PrologIA
167
L'environnement
Aociation
free(x)
S'efface uniquement si x n'est pas, li c'est--dire si l'on ne connait pas
l'tiquette de l'arbre reprsent par x et si l'on ne sait pas si le nombre de fils
de x est nul ou pas.
2 . Expressions, variables statiques,

tableaux
Expressions arithmtiques
En Prolog III les oprations arithmtiques sont intgres dans le cur mme
du langage. Cependant, nous avons conserv le mcanisme val de Prolog II,
par souci de compatibilit, parce que ce mcanisme reste dans certaines
circonstances un procd fort efficace pour valuer des expressions
arithmtiques, et surtout parce qu'il demeure le moyen d'utiliser les
variables statiques et les tableaux.
Le rsultat d'une valuation faite au moyen de la rgle prdfinie val est soit
un entier, soit un rel, soit un identificateur, soit une chane. Les valeurs
boolens, dans ce cas seront reprsentes par les entiers 0 et 1. Sur la plupart
des machines, les valeurs des entiers sont comprises entre -2 147 483 648 et
2 147 483 647 (231-1) ; celles des flottants entre -1.7e38 et +1.7e38 et la plus
grande valeur ngative et la plus petite valeur positive sont respectivement
-0.29e-38 et +0.29e-38. Les valeurs situes strictement entre ces deux valeurs
sont mises 0.
val(t1, t2)
Evalue l'expression t1 et produit le rsultat t2. L'expression valuer est
construite rcursivement partir de constantes, de variables statiques
(identificateurs assigns), d'identificateurs, de composantes de tableaux et de
fonctions valuables. Des variables Prolog III ordinaires peuvent apparatre
dans une expression valuable, la condition qu'elles soient contraintes
reprsenter une valeur connue.
168
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
Exemples:
> val(add(mul(2,add(3,4)),1000),x);
{x = 1014}
> val(2*(3+4)+1000,x);
{x = 1014}
>
L'intgration de l'arithmtique au cur de Prolog III fait que les expressions

valuables n'ont souvent pas la mme signification qu'en Prolog II, du moins
lorsqu'elles sont crites dans la bonne syntaxe. Ecrivons les deux termes qui
ont t valus dans l'exemple prcdent :
> {t=add(mul(2,add(3,4)),1000)};
{t = add(mul(2,add(3,4)),1000)}
> {t=2*(3+4)+1000};
{t = 1014}
>
Lorsqu'une fonction valuer a un nombre incorrect d'arguments ou

lorsque certains de ses arguments sont du mauvais type, il se produit une
erreur. Chaque fonction valuable doit avoir des arguments d'un type
prcis : aucune conversion automatique de type n'est effectue lors de
l'valuation.
La valeur d'un nombre ou d'une chane est gale ce nombre ou
cette chane.
La valeur d'un tableau indic est gale la valeur de l'lment
correspondant de ce tableau. Exemple:
> def_array(tab,100) assign(tab(50),3);
{}
> val(tab(50),x);
{x = 3}
>
La valeur d'un identificateur i est dfinie comme suit :

- si une constante k a t affecte i (au moyen de la rgle assign,
voir le paragraphe suivant) alors la valeur de i est k.
- si i n'a pas fait l'objet d'une affectation pralable, alors la valeur de
i est i lui-mme.
PrologIA
169
L'environnement
Aociation
Exemple :
> assign(un,1);
{}
> val(un,x) val(deux,y);
{x = 1, y = deux}
>
Les fonctions valuables sont :

add(t1, t2)
valeur(add(t1, t2)) = valeur(t1) + valeur(t2).
Les valeurs de t1 et t2 doivent tre numriques et connues.
sub(t1, t2)
valeur(sub(t1, t2)) = valeur(t1) - valeur(t2).
mul(t1, t2)
valeur(mul(t1, t2)) = valeur(t1) valeur(t2).
div(t1, t2)
valeur(div(t1, t2)) =
|valeur(t1)|
|valeur(t2)|
Il s'agit du quotient entier par dfaut de la valeur absolue de t1 par la valeur

absolue de t2. Les valeurs de t1 et t2 doivent tre des nombres entiers.
mod(t1, t2)
valeur(mod(t1, t2)) = |valeur(t1)| modulo |valeur(t2)|.
Il s'agit du reste de la division entire de la valeur absolue de t1 par la valeur
absolue de t2. Les valeurs de t1 et t2 doivent tre des nombres entiers.
170
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
eql(t1, t2)
valeur(eql(t1, t2)) = 1 si valeur(t1) = valeur(t2) , 0 sinon.
Les valeurs de t1 et t2 doivent tre des constantes de mme type.
inf(t1, t2)
valeur(inf(t1, t2)) = 1 si valeur(t1) < valeur (t2) , 0 sinon.
Les valeurs de t1 et t2 doivent tre des constantes de mme type. Pour les
entiers et les rels, on prend la relation "<" entre les nombres. Pour les
chanes, on prend l'ordre lexicographique et pour les identificateurs on
prend l'ordre lexicographique sur les chanes associes.
infe(t1, t2)
valeur(infe(t1, t2)) = 1 si valeur(t1) valeur (t2) , 0 sinon.
Les valeurs de t1 et t2 doivent tre des constantes de mme type. Voir inf.
sup(t1, t2)
valeur(sup(t1, t2)) = 1 si valeur(t1) > valeur (t2) , 0 sinon.
supe(t1, t2)
valeur(supe(t1, t2)) = 1 si valeur(t1) valeur (t2) , 0 sinon.
if(t, t1, t2)
valeur(if(t, t1, t2)) = valeur(t1) si (valeur(t)0) , valeur(t2) sinon.
trunc(t)
valeur(trunc(t)) = conversion en entier de la valeur de t.
abs(t)
valeur(abs(t)) = valeur absolue de valeur(t).
La valeur de t doit tre de type entier ou flottant.
PrologIA
171
L'environnement
Aociation
Les fonctions suivantes donnent un rsultat de type rel. Les fonctions

trigonomtriques travaillent avec des angles exprims en radians.
atan(t)
valeur (atan(t)) = arc tangente de valeur(t).
cos(t)
valeur (cos(t)) = cosinus(valeur(t)).
exp(t)
valeur (exp(t)) = exponentielle(valeur(t)).
ln(t)
valeur(ln(t)) = logarithme nprien(valeur(t)).
rad(t)
valeur (rad(t)) = conversion en radian(valeur(t)).
sin(t)
valeur(sin(t)) = sinus(valeur(t)).
sqrt(t)
valeur(sqrt(t)) = racine carre(valeur(t)).
tan(t)
valeur(tan(t)) = tangente(valeur(t)).
Affectation.
Tableaux.
assign(i, t)
Affecte le terme t, qui doit reprsenter une constante, l'identificateur i.
Tout se passe comme si i devenait le nom d'une variable globale
(ultrieurement accessible pendant l'excution de n'importe quel but) et
statique (rsistante au backtracking) possdant t pour valeur. Il s'agit
donc bien de l'affectation classique, comme elle se pratique en FORTRAN ,
Pascal, etc.
172
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
Exemple :
> assign(nom_fichier,"monfichier.txt");
{}
> val(nom_fichier,x);
{x="monfichier.txt"}
>
En Prolog, ces variables statiques peuvent tre vues comme une manire
particulirement efficace d'crire des assertions (ou rgles sans queue). Du
point de vue de l'utilisateur, on peut considrer que l'emploi de assign et val
tel qu'il est fait ci-dessus est quivalent :
> retract(nom_fichier(x),[]);
> assert(nom_fichier("monfichier.txt"),[]);
{}
> nom_fichier(x);
{x="monfichier.txt"}
>
assign(tab(i), t)
Affecte la valeur de t l'lment de rang i du tableau tab. Ce tableau doit
avoir t dfini au pralable avec def_array (voir ci-dessous). Les mmes
restrictions que prcdemment s'appliquent t : ce doit tre une constante.
Lorsqu'on veut obtenir la valeur d'un lment de rang i du tableau, si cet
lment n'a pas t affect (assign) ou encore si la valeur du rang i est
l'extrieur des bornes du tableau val produit une erreur.
Exemple :
> def_array(tableau,10);
{}
> assign(tableau(5), cinq);
{}
> val(tableau(5), x);
{x = cinq}
Erreur 246: Erreur dans val
>
PrologIA
173
L'environnement
Aociation
def_array(i, n)
Dfinit dynamiquement un tableau de constantes Prolog de nom i et de taille
n. Ce tableau se comportera comme une variable globale et statique. Les
valeurs lgales de l'indice sont les lments 1, 2, n.
Si un tableau de mme nom existe dj :
- s'il s'agit d'un tableau de mme taille, il ne se passe rien
- si les tailles diffrent, il se produit une erreur
L'accs et l'affectation aux composantes des tableaux sont analogues ceux
des tableaux des autres langages de programmation. Le tableau est
dsallou lorsqu'on supprime (par exemple par kill_module) le module auquel
il appartient.
Exemple : la gestion d'une pile.
> insert;
inc(i) -> val(i,x) assign(i,x+1);
dec(i) -> val(i,x) assign(i,x-1);
initialise -> assign(pointeur,1) def_array(pile,100);
empile(v) ->
val(pointeur,p) !
assign(pile(p), v)
inc(pointeur),
{ p <= 100 };
empile(v) -> outml("dbordement de la pile") fail;
depile(v) ->
dec(pointeur)
val(pointeur,p) !
val(pile(p),v)
dec(pointeur),
{ p >= 1 };
depile(v) -> outml("pile vide") assign(pointeur,1) fail;;
{}
> initialise;
{}
> empile(111);
{}
> empile(222);
{}
> depile(x) depile(y);
174
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
{x=222, y=111}
> depile(x);
pile vide
>
3 . Structuration, saisie
et modification des rgles
Tous les exemples que nous avons examin jusqu' prsent taient de petits
programmes Prolog III dans lesquels le nombre des identificateurs restait
trs limit et facile apprhender par le programmeur. Dans de telles
circonstances, on peut supposer que les identificateurs en prsence
appartiennent un unique univers qui les contient tous ; c'est ce que nous
avons fait, faute d'indication contraire. Tant que les programmes restent de
taille raisonnable, la ncessit de regrouper les identificateurs et les rgles
dans des ensembles fonctionnels ne se manifeste pas.
La situation n'est plus la mme ds qu'on considre de gros programmes
suffisamment complexes pour ncessiter une dcomposition en modules de
fonctionnalits diffrentes ou encore des programmes, mme relativement
simples, qui comportent un nombre important d'identificateurs, qu'ils soient
ou non des noms de rgles. Apparat alors trs vite l'utilit de disposer d'un
moyen pour regrouper les identificateurs selon des critres logiques, ces
regroupements tant un moyen pour manipuler aisment des familles
entires d'identificateurs l'aide de noms uniques, et en mme temps un
moyen pour rglementer leur visibilit, c'est--dire pour indiquer quels
noms dfinis dans une partie d'un programme (nous dirons module)
peuvent tre rfrencs dans les autres parties.
Il s'agit donc de partitionner l'ensemble des identificateurs connus par un
programme Prolog III. En peu de mots, les outils pour effectuer ce
partitionnement peuvent se rsumer de la manire suivante :
la syntaxe complte des identificateurs prescrit la prsence d'un prfixe
au dbut de tout identificateur
PrologIA
175
L'environnement
Aociation
l'ensemble des identificateurs ayant mme prfixe est une famille. Les
familles peuvent tre manipules globalement : de nombreuses
primitives agissent sur des familles entires, reprsentes par le prfixe
commun de leurs membres.
certaines conventions, dfinissant des contextes d'criture/lecture, permettent d'crire les identificateurs en omettant leur prfixe et
inversement de complter des identificateurs lus sans prfixe.
Voyons tout cela un peu plus en dtail.
Familles d'identificateurs
Voici la syntaxe complte des identificateurs :

<prfixe>
::= [ <nom> { : <nom> } ]
orbis:lex
<nom>
::= <lettre> { <alphanumrique tendu> }
<identificateur>
::= <prfixe> : <identificateur abrg>
::= <identificateur abrg>
sys:outm
outm
<identificateur abrg>
::= <lettre> <lettre> { <alphanumrique tendu> }
Un identificateur complet se compose donc d'un nom prcd d'un prfixe,
dont il est spar par le caractre deux-points. Un identificateur abrg est
ce qui reste d'un identificateur complet lorsqu'on omet le prfixe et le
sparateur. Le prfixe peut tre vide, ou bien tre un mot, ou encore tre
compos de plusieurs mots spars par des deux-points.
176
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
Un identificateur complet comporte toujours au moins une occurrence du

caractre : tandis qu'un identificateur abrg n'en comporte aucune. Par
exemple, les trois premiers identificateurs ci-dessous sont complets, le
dernier est abrg :
grammaire:pluriel
sys:env:screen:clear_screen
:paul
paul
Les prfixes respectifs de ces trois premiers exemples sont "grammaire" ,

"sys:env:screen" et "" (le prfixe vide).
Les identificateurs abrgs
associs sont respectivement pluriel , clear_screen et paul .

On appelle famille correspondant un prfixe donn l'ensemble des identificateurs ayant ce prfixe. Il n'y a pas de hirarchie dans les familles :
lorsqu'un identificateur complet comporte plusieurs occurrences du
caractre : seule la dernire est prise en considration par Prolog III,
comme sparateur du prfixe et de l'identificateur abrg. Le prfixe est
alors compos de plusieurs mots spars par des : . Si cela correspond
une organisation hirarchique dans l'esprit du programmeur, ce fait reste
tranger Prolog III, pour qui les familles associes des prfixes comme
par exemple "aa" et "aa:bb" n'ont pas de lien particulier.
On appelle module l'ensemble des lments de code nomms par les
identificateurs d'une famille donne. Par lments de code nous
entendons bien sr les faits et les rgles Prolog III qui constituent les
programmes, mais aussi les fonctions valuables, les variables statiques1 et
les tableaux.
C'est--dire les identificateurs auxquels on associe une valeur par la primitive

assign.
PrologIA
177
L'environnement
Aociation
Partie ferme d'une famille
Les notions de famille et de module sont tout--fait dynamiques : chaque

nouvel identificateur lu et ventuellement complt par Prolog III est
incorpor automatiquement la famille correspondant son prfixe. Une
famille n'est jamais fige, elle peut tout moment tre augmente par l'ajout
de nouveaux identificateurs. Ce dynamisme est en gnral fort apprciable,
mais nous allons voir que lors de la dfinition des contextes de lecture et
criture (voir ci-dessous) une certaine stabilit est aussi souhaitable, afin que
les conventions dfinies par un contexte soient autant que possible hors du
temps et qu'un identificateur abrg reprsente le mme identificateur
complet tout moment d'une session Prolog III, ainsi que d'une session
une autre.
Ceci justifie l'introduction de la notion de famille ferme, ou plutt de partie
ferme d'une famille : des primitives sont fournies (close_context_dictionary)
pour figer un noyau dur de la famille, gal l'tat de cette dernire au
moment ou la fermeture est effectue. Par la suite, d'autres identificateurs
pourront encore tre ajouts la famille, mais ils ne seront pas incorpors
la partie ferme de cette dernire. Ce concept sera exploit dans
l'interprtation de la liste implicite qui figure dans les primitives de dfinition
des contextes de lecture et criture : cet endroit, une rfrence une famille
ne dsigne que sa partie ferme. Une telle rfrence est donc stable.
Contexte de lecture et d'criture
Un contexte de lecture et criture est un ensemble de rgles de transformation

d'identificateurs abrgs en identificateurs complets et vice-versa. Elles
associent tout identificateur abrg un unique identificateur complet ;
inversement, elles dfinissent l'ensemble des identificateurs qui peuvent
s'crire sous forme abrge. Le codage interne des identificateurs met
toujours en uvre la forme complte de ceux-ci ; les transformations dont
nous parlons sont donc faites uniquement au moment de leur lecture ou de
leur criture.
178
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
Un contexte de lecture et criture par dfaut est dfini au dmarrage de

Prolog III et des primitives sont fournies qui vous permettent de dfinir vos
propres contextes, de les nommer, de les ranger pour les rappeler ultrieurement, etc Un (et un seul) contexte de lecture et criture est constamment
dfini tout au long d'une session Prolog III ; nous l'appellerons le contexte
courant.
Formellement, un contexte de lecture et criture est dfini par la donne
d'un triplet
( liste explicite , liste implicite , prfixe par dfaut )
O liste explicite et liste implicite dsignent, par un mcanisme expliqu plus
loin, une grande liste L d'identificateurs complets. Les conventions dfinies
par un tel contexte sont les suivantes : lors d'une lecture
un identificateur complet n'est nullement transform
un identificateur abrg coincidant avec la forme abrge d'un lment
i de L est considr comme reprsentant cet identificateur, et est donc
complt avec le prfixe de i
les autres identificateurs abrgs sont complts avec le prfixe par
dfaut indiqu.
Par exemple, si la liste L est [ aa:bb, aa:cc, aa:dd ] et le prfixe par dfaut "zz",
alors
- pp:xx est compris comme pp:xx, car lu sous sa forme complte
- cc est compris comme aa:cc, puisque ce dernier figure dans L
- xx est compris comme zz:xx, puisqu'aucun identificateur complet de L
n'a xx pour forme abrge.
Venons-en aux dtails pratiques de la dfinition des contextes de lecture et

criture dans les programmes Prolog III.
PrologIA
179
L'environnement
Aociation
set_context(nom, suite_explicite, suite_implicite, prfixe_par_dfaut)

Cette commande permet la fois de dfinir un contexte, en lui associant un
nom, et de l'installer comme contexte courant de lecture et criture.
nom est un identificateur ou une chane : il sert de nom au contexte
nouvellement dfini.
suite_explicite est une liste de la forme
[ prefixe1, liste1, prefixe2, liste2,, prefixen, listen ]
qui reprsente une suite d'identificateurs complets, factoriss par

familles. Par exemple, la liste :
["m1",["aa","bb"],"m2",["cc"],"m3",["dd","ee","ff"]]
reprsente en fait la liste d'identificateurs complets m1:aa, m1:bb, m2:cc,
m3:dd, m3:ee, m3:ff
liste_implicite est une liste de prfixes donns sous forme de chanes de
caractres. Chacun de ces prfixes reprsente la partie ferme de la
famille correspondante ou, si la fermeture n'a pas t ralise, la totalit
de cette famille.
Dans ces conditions, la liste L d'identificateurs dfinie par tous ces
lments est la concatnation, dans l'ordre o elles apparaissent, de la
suite_explicite et des listes d'identificateurs dfinies par la suite_implicite.
L'exploitation ultrieure de toute cette information respecte l'ordre
d'entre en scne de ces lments : les recherches se font d'abord dans
la liste dduite de suite_explicite, cette liste tant parcourue du dbut
vers la fin, puis dans la liste dduite du premier lment de
suite_implicite, puis dans celle dduite de son second lment, et ainsi de
suite.
prfixe_par_dfaut est le prfixe qui sera attribu chaque identificateur
abrg condition que ce dernier ne soit pas la forme abrge de l'un
des identificateurs apparaissant dans la liste L.
Note 1. L'excution de la commande set_context(nom, suite_explicite,
suite_implicite, prfixe_par_dfaut) produit la mmorisation du contexte dcrit
par cette commande, sous la forme d'un fait ajout au module d'environnement :
sys:env:context(nom, suite_explicite, suite_implicite,
180
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
prfixe_par_dfaut) -> ;
Note 2. Si vous dfinissez des contextes ne contenant pas la famille "sys"
dans suite_implicite, vous devrez faire attention au fait qu'un grand nombre
d'identificateurs abrgs perdent leur signification habituelle : des rgles
prdfinies deviennent inconnues sous leur nom abrg et, pige bien plus
redoutable, des identificateurs abrgs trs communs, comme [ ]
(l'quivalent du nil de Prolog II) n'ont plus la forme complte qui est utilise
dans les rgles prdfinies qui constituent la bibliothque-systme de
Prolog III.
Note 3. Lorsqu'une rgle contient une dclaration de contexte, celle-ci ne
devient effective que lorsque la rgle est excute (et non au moment de sa
lecture). Dans l'exemple suivant, l'identificateur abrg peche est complt
en def:peche et non en fruits:peche, puisque la dfinition du contexte "new" ne
sera effective que lors de l'excution du programme pomme :
> pomme ->
set_context("new",["fruits",["peche"]],["sys"],
"def")
peche;
set_context(nom)
Permet de rinstaller comme contexte courant un contexte prcdemment
dfini. L'argument nom doit tre l'identificateur ou la chane associe au
contexte en question lors de sa dfinition.
current_context(t0, t1, t2, t3)
current_context(t0)
Obtention du nom et de la dfinition du contexte courant :
t0 = nom du contexte courant (identificateur ou chane) ;
t1 = suite_explicite,
t2 = suite_implicite,
t3 = prfixe_par_dfaut.
PrologIA
181
L'environnement
Aociation
close_context_dictionary(s)
Dfinit l'ensemble actuel d'identificateurs de la famille de prfixe s comme
tant la partie ferme de cette famille. Les identificateurs ajouts la famille
aprs l'excution de cette commande ne seront pas automatiquement
incorpors cette partie ferme.
add_implicit(s1, s2)
remove_implicit(s1, s2)
Ajoute (resp. enlve de) la partie ferme de la famille correspondant au
prfixe s 1 l'identificateur dont le nom abrg est donn par la chane s 2 .
Examinons l'effet de ces commandes sur un exemple :
> current_context(t0,t1,t2,t3);
{ t0 = 1, t1 = '[]', t2 = ["sys"], t3 = <> }
> string_ident(p,a,dictionary)
outl(sys:dictionary);
dictionary
{p = "sys", a = "dictionary"}
>
en lecture, l'identificateur abrg dictionary est devenu sys:dictionary (comme

le montre le rsultat du prdicat prdfini string_ident) tandis qu'en criture,
l'identificateur sys:dictionary est abrg en dictionary. Vue la dfinition du
contexte, tout ceci montre que sys:dictionnary appartient la partie ferme de
la famille "sys". Continuons notre exemple :
> remove_implicit("sys","dictionary");
{}
> string_ident(p,a,dictionary)
outl(sys:dictionary);
sys:dictionary
{p = <>, a = "dictionary"}
>
notre identificateur dictionary n'appartient plus la partie ferme de la

famille "sys". Le comportement du contexte de lecture et criture son sujet
a chang : en lecture, dictionary est complt en :dictionary, puisque d'aprs le
contexte le prfixe par dfaut est la chane vide (que l'on peut noter "" ou
<>) tandis que en criture, sys:dictionary n'est pas transform en sa forme
abrge.
dictionary
182
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
Ecrit sur la sortie courante la forme abrge des accs qui ont le mme
prfixe que le prfixe par dfaut du contexte de lecture et criture. Par accs
on entend un identificateur qui nomme un objet dans le code : rgle, fait,
variable statique ou tableau.
dictionary(L)
Unifie L avec la liste des prfixes des modules utilisateurs prsents en
mmoire.
dictionary(s0, t0)
s0 tant une chane de caractres, cette primitive unifie t0 avec la liste des
rgles de la famille correspondant au prfixe s0 . Chaque rgle est reprsente par un couple < accs , arit >
Modules
Dans un programme donn, et un moment donn, on appelle module p le

regroupement de tous les faits et rgles, les fonctions valuables, les
variables statiques (ou identificateurs affects par assign) et les tableaux dont
le nom appartient la mme famille p, c'est--dire possde le mme prfixe
p, que nous appellerons le prfixe du module. Les identificateurs de la famille p
peuvent apparatre dans d'autres modules, mais pas en position
d'identificateur d'accs (c'est--dire comme nom de prdicat de tte d'une
rgle). La notion de module est dynamique : lorsqu'une nouvelle rgle est
cre ou supprime, le module correspondant son identificateur d'accs est
modifi en consquence.
Un module peut exister sous forme de texte (avant lecture) ou sous forme
interne (aprs lecture), on parlera de module source et de module objet pour
dsigner l'un et l'autre cas.
Module source. Un module source est dfini comme la suite des rgles
comprises entre les deux directives:
module (prfixe-du-module,
suite-explicite, suite-implicite, prfixe-par-dfaut);

....
PrologIA
183
L'environnement
Aociation
end_module( prfixe-du-module ) ;
La directive module fait basculer Prolog III dans le mode insertion et la

directive end_module le fait sortir de cet tat. Par consquent, les lments
compris entre ces deux directives doivent tre des rgles (ou des
commentaires, qui sont ignors).
L'argument dsignant le prfixe-du-module dans la directive module doit tre le
mme que celui figurant dans la directive end_module, et toutes les rgles
comprises entre ces deux directives doivent avoir un identificateur d'accs
avec ce prfixe ; ceci permet de dtecter la lecture les ventuelles erreurs de
nommage. Navement, on peut dire que la directive module signifie insrez
les rgles qui suivent, avec le contexte de lecture dfini ici, et en vrifiant que les
rgles lues possdent (ou acquirent) bien le prfixe voulu
Lorsque tous les arguments ne sont pas donns, on a les valeurs par dfaut
suivantes (en supposant que le contexte lors de la lecture de la directive
module dispense de l'crire sys:module):
module(p)
module(p,
[],
["sys"],
p)
module(p,s)

module(p,
s,
["sys"],
p)
module(p,s,i)
module(p,
s,
i,
p)
Le contexte de lecture dfini par l'en-tte du module est utilis pour la lecture
de tout le reste du module, y compris la directive end_module. Le contexte
qui existait avant la lecture du module est ensuite rtabli.
Si un module m contient une rgle avec le prfixe m et le nom abrg
ini_module alors celle-ci est automatiquement excute aprs la lecture (ou le
chargement ultrieur) du module.
Le contexte de lecture du module permet de redfinir de manire claire
certaines des primitives utilises l'intrieur d'un module.
Exemple :
184
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
module("exemple", ["exemple", ["out"]] ) ;

...
out(x) -> enjoliver(x,y) s y s : o u t ( y ) ;
...
end_module("exemple");
Module objet. Une fois lus par Prolog III, les lments de code qui forment
un module sont dits constituer un module objet. La manipulation de modules
objets ne concerne que les reprsentations internes des identificateurs, la
notion de contexte n'intervient donc pas dans ces oprations.
Un module objet peut tre sauvegard dans un fichier magntique en vue de
son rechargement ultrieur. Cela se fait par les primitives load et save.
Lorsqu'un module objet est crit dans un fichier, il est rang de telle manire
qu'il est possible, lors de la restauration du module, de renommer ses
identificateurs. Il est ainsi possible de rsoudre les conflits de noms quels
qu'ils soient, et de construire des programmes qui n'interfrent pas avec les
donnes qu'ils manipulent.
Ajout, suppression et recherche de rgles
assert(t, q)
asserta(t,q)
Ajout d'une rgle, au dbut de son paquet.
t doit tre un terme pouvant tre une tte de rgle, c'est--dire un terme qui
reprsente un arbre dont le nud initial comporte une tiquette connue, qui
est un identificateur. q doit tre une liste de termes. La rgle effectivement
ajoute par ces primitives comporte un systme vide de contraintes.
L'excution de assert(t, [ q1, qn ]) ajoute la rgle t -> q1 qn , { } au-dessus
du groupe de rgles ayant le mme nom que t, c'est--dire au dbut du
paquet correspondant t, et si aucun groupe de rgles n'a le mme nom
que t, un nouveau paquet est cr. Par exemple, les deux commandes
suivantes
PrologIA
185
L'environnement
Aociation
assert(conc([e|x],y,[e|z]),[conc(x,y,z)]);
assert(conc([],y,y),[]);
tapes dans cet ordre, ont pour effet l'ajout du programme

conc([],y,y)
->;
conc([e|x],y,[e|z])
->
conc(x,y,z);
assert''(t, q)
assertz(t, q)
Ajout d'une rgle, la fin de son paquet.
Mme fonctionnement que assert, mais l'ajout se fait au-dessous, et non audessus, du paquet correspondant t. Exemple : les deux commandes
suivantes, dans l'ordre indiqu, produisent l'insertion du mme programme
conc que ci-dessus :
assert''(conc([],y,y),[]);
assert''(conc([e|x],y,[e|z]),[conc(x,y,z)]);
current_predicate(<i,a>)
Permet de tester la prsence d'une rgle.
L'excution de cette primitive russit s'il existe une rgle de nom i et d'arit a.
Si a est une variable, et i est connu, elle numre successivement toutes les
arits de rgles de nom i. Si i est une variable, et a est connu, elle numre
successivement tous les noms de rgles d'arit a. Enfin si a et i sont des
variables, cette primitive numre successivement tous les couples <i,a>
correspondant aux rgles du module associ au prfixe par dfaut du
contexte courant.
insert
reinsert
Insertion de rgles.
Cette rgle prdfinie fait basculer le systme dans un mode dans lequel les
noncs (rgles, commentaires et directives) lus sur l'unit d'entre courante
sont ajouts, dans l'ordre dans lequel ils sont lus, au programme courant.
186
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
Les directives (set_context, module, etc) sont excutes immdiatement

lorsqu'elles sont rencontres. Le mode insert se termine soit quand un
nonc vide est trouv, soit si l'on rencontre la fin du fichier d'entre.
Exemple:
> insert;
conc([],y,y) ->;
conc([e|x],y,[e|z])
>
->
conc(x,y,z);;
Si une erreur de syntaxe est rencontre, un avertissement est affich, et un

certain nombre de caractres (en principe tous les caractres jusqu' un ; ,
ou jusqu' la fin de la ligne sur l'unit console) sont ignors.
insert provoque une erreur lorsque un paquet lu existe dj, alors que
reinsert remplace l'ancien paquet par la nouvelle dfinition. Attention ceci
peut tre dangereux : par exemple une erreur sur une rgle l'intrieur d'un
paquet peut provoquer, avec reinsert, l'crasement des rgles prcdentes
quand on continuera lire le paquet.
insert(f)
reinsert(f)
Insertion de rgles partir d'un fichier.
Mme fonctionnement que insert, mais les noncs sont lus sur le fichier
indiqu. Selon que l'on a par ailleurs activ ou non le mode cho (cf. rgle
echo) les rgles sont affiches sur la console au fur et mesure de leur lecture.
list
Liste sur la sortie courante toutes les rgles dtermines par le prfixe par
dfaut du contexte courant.
list(t)
Liste sur la sortie courante le ou les paquet de rgles indiqus par t, qui doit
tre soit un terme de la forme indique ci-dessous, soit une liste de tels
termes (c dsigne une chane de caractres, i un identificateur, a un entier, et
v une variable) :
c
Toutes les rgles du module de nom c
PrologIA
187
L'environnement
Aociation
<i, a>
<i, v>
Toutes les rgles composant le paquet de nom i et d'arit a.

Toutes les rgles dont l'accs est i, quelque soit leur arit.
<v, a>
Toutes les rgles d'arit a appartenant au module ayant le prfixe

par dfaut du contexte de lecture et criture courant dont l'arit
est a.
quivalent de <i, v>
Exemple :
>
list([<aaa,2>,<aaa,3>,<bbb,X>]);
list(<i,a>, n)
Lister une rgle.
i doit tre un identificateur et a un entier; la rgle numro n du paquet
correspondant au nom i et l'arit (nombre d'arguments) a est liste sur la
sortie courante.
predefined(t)
Cette primitive russit si t est un terme correspondant l'appel d'une rgle
prdfinie.
rule(n, a, t, q)
rule(n, t, q)
Recherche des rgles correspondant un modle donn.
Ces primitives numrent les rgles qui satisfont aux contraintes suivantes :
n = rang de la rgle dans son paquet, a = identificateur d'accs (nom) de la
rgle, t = tte de la rgle, q = queue de la rgle. Dans la premire forme, a
doit tre un identificateur connu ; dans la deuxime forme, t doit tre
suffisamment connu pour pouvoir en dduire l'identificateur d'accs des
rgles vises.
Exemple d'utilisation se rapportant toujours au programme conc donn plus
haut en exemple :
>
188
Prolog
HERITAGE
rule(n,conc,t,q);
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
{ n = 1, t = conc([],x_8,x_8), q = [] }
{ n = 2, t = conc([e_11 | x_11],y_11,[e_11 | z_11]),
q = [conc(x_11,y_11,z_11)] }
> rule(n,conc[v],q);
{ n = 1, v = <[],x_12,x_12>, q = [] }
{ n = 2, v = <[e_15 | x_15],y_15,[e_15 | z_15]>,
q = [conc(x_15,y_15,z_15)] }
>
retract(t, q)
Recherche et suppression des rgles correspondant un modle donn.
Cette primitive recherche toutes les rgles qui satisfont aux contraintes
t = tte de la rgle, q = queue de la rgle, et les supprime. t doit tre assez
connu pour qu'il n'existe aucune ambigut quant au nom des rgles vises.
suppress(i)
suppress(i, a)
suppress(i, a, n)
Suppression de rgles.
i doit tre un identificateur, a et n des entiers; ces primitives produisent la
suppression de :
- premire forme : toutes les rgles ayant l'identificateur d'accs (nom) i
- deuxime forme : toutes les rgles de nom i et d'arit a
- troisime forme : la n-me rgle parmi celles qui ont le nom i et l'arit a
PrologIA
189
L'environnement
Aociation
Exemple :
> insert;
data(1) ->;
data(2) ->;
data(3) ->;
> data(x);
{x = 1}
{x = 2}
{x = 3}
> suppress(data,1,2);
{}
> data(x);
{x = 1}
{x = 3}
>
Manipulation de modules objets
kill_module(s)
Supprime toutes les rgles du module dsign par la chane de caractres s.
Les tableaux du module sont dsallous, et les assignations des
identificateurs du module sont dfaites.
reload(f, l)
Chargement de modules sauvs.
f est un nom de fichier (chane de caractres) et l est une liste de substitution
de prfixes. Cette commande produit le chargement des modules
sauvegards dans le fichier indiqu; celui-ci doit avoir t produit par la
commande save. En cas de redfinition d'un lment, la version rencontre
dans le fichier remplace celle qui se trouve en mmoire, sans produire
d'erreur.
l est une liste de la forme [ <pref1 , subs1> , <prefk , subsk> ] qui spcifie le
renommage des modules chargs : pref1 sera substitu par subs1, pref2 par
subs2, etc Cette liste peut tre vide.
190
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
save(l, f)
Sauvegarde de modules.
f est un nom de fichier (chane de caractres) et l une liste de prfixes
(chanes de caractres). Cette commande produit la sauvegarde dans le
fichier indiqu de tous les lments (rgles, variables statiques et tableaux)
des modules correspondant aux prfixes donns.
Exemple:
> save(["","data","dict"],
{}
"myfile.mo");
Le fichier produit est un fichier de code objet, destin tre ultrieurement

charg dans un autre environnement Prolog au moyen de la commande
reload (voir ci-dessus).
4 . Entres / sorties
Tous les organes d'entre / sortie (clavier, cran, fichiers, etc) utiliss par
un programme Prolog III y sont reprsents par des entits appeles units
d'entre/sortie. La reprsentation crite d'une telle unit est une chane de
caractres ; le cas chant, cette chane reprsente aussi une information
identifiant l'unit vis--vis du systme d'exploitation : nom de fichier, etc
A tout moment, le systme Prolog III connat un certain nombre d'units
d'entre/sortie : ce sont les units qui ont t prcdemment ouvertes et qui
n'ont pas encore t fermes. Les descripteurs de ces units sont rangs
dans une pile : l'unit qui est au sommet s'appelle l'unit courante. Toutes
les oprations d'entre / sortie s'effectuent sur l'unit courante. Au
lancement, une unit d'entre (appele console) et une unit de sortie
(appele galement console) sont ouvertes automatiquement par le systme
et sont les units courantes ; habituellement, ces units sont associes au
clavier et l'cran de l'ordinateur ou du terminal depuis lequel Prolog a t
lanc.
PrologIA
191
L'environnement
Aociation
Changer d'unit (c'est--dire excuter les primitives input(f) ou output(f)) ne

ferme pas l'unit courante ni ne change son tat, mais ouvre -si ncessaireune nouvelle unit et la met au sommet de la pile, au-dessus de la prcdente
unit courante, de faon pouvoir restaurer cette dernire lors de la
fermeture de la nouvelle unit courante.
Entres
in_char(t)
Lecture d'un caractre.
Lit le prochain caractre, le transforme en une chane de longueur 1 et essaie
de l'unifier avec t.
Exemple :
> in_char(c1) in_char(c2) in_char(c3);
ABC
{c1 = `\12`, c2 = À`, c3 = `B` }
>
Dans cet exemple, le caractre obtenu lors de la premire lecture est en

ralit le caractre fin-de-ligne qui terminait la ligne de commande.
in_term(t)
Lecture d'une suite de termes Prolog III.
Lit la plus grande suite de caractres qui constituent l'expression crite
(syntaxiquement correcte) d'une suite de termes Prolog III ; ensuite, tente
l'unification de t avec le premier des termes lus. Les caractres blancs qui
suivent le dernier terme lu sont lus eux aussi.
Exemple:
> in_term(t) in_char(c);
nom_marie_poids("Dupont",1',755/10) est un t e r m e ;
{ t = nom_marie_poids("Dupont",1',151/2) c = `\12` }
>
192
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
in_sentence(t1, t2, t3)

Lit une phrase qui se termine par ".", "?" ou "!" et la met sous la forme de trois
listes, respectivement unifies avec t 1 , t 2 et t 3 . t 1 est la liste des units
lexicales (mots, nombres, caractres spciaux, etc) constituant la phrase ; t3
est la liste obtenue en remplaant chaque lettre majuscule apparaissant dans
un lment de t1 par la lettre minuscule correspondante. t2 est la mme
chose que t3, mais chaque lment de t3 qui correspond un identificateur
connu dans la famille du prfixe par dfaut du contexte courant a t
remplac par le symbole conventionnel <> pour indiquer ce fait.
Exemple :
> truc;
> in_sentence(t1,t2,t3);
truc, Truc et line sont c o n n u s .
{t1 = <"truc",",","Truc","et","line","sont","connus",".">,
t2 = <<>,",",<>,"et","line","sont","connus",".">,
t3 = <"truc",",","truc","et","line","sont","connus",".">}
>
input(u)
L'unit dont le nom est u devient l'unit d'entre courante ; elle ne doit pas
tre une des units prcdemment ouvertes et non encore fermes. Le
fichier correspondant est recherch et ouvert.
Aucune autre action, en plus du changement de l'entre courante, n'est
excute pour le moment ; en particulier, Prolog III ne bascule pas dans un
quelconque mode lecture , mais continue l'excution du programme en
cours. Ce n'est que lorsque ce programme effectuera des lectures sur l'unit
courante, ou bien lorsqu'il sera termin et que Prolog III retournera dans
l'tat lecture d'une commande , que l'effet de input(u) se manifestera,
puisque les lectures seront faites partir de l'unit indique et non sur l'unit
courante.
Bien entendu, un fichier ouvert par input peut contenir aussi bien des rgles
que des requtes. De plus, il peut lui-mme contenir une commande input,
la nouvelle unit courante est empile au-dessus de la prcdente.
close_input
PrologIA
193
L'environnement
Aociation
L'unit courante est ferme et son descripteur est enlev du sommet de la

pile des units : l'unit prcdente redevient unit courante.
Sorties
out(t)
outl(t)
Ecrit le terme t sur l'unit courante. La lecture par in_term de la forme crite
d'un terme t produite par out reconstruit le terme t original.
Quelque soit le type du terme crire, si son expression est plus longue que
la place restant sur la ligne courante, alors elle est coupe l'endroit requis
par insertion d'un retour-chariot masqu (par un caractre \). L'criture
du terme obit en outre aux conventions suivantes:
Les listes sont imprimes dans la syntaxe d'Edimbourg (crochets [ ] ).
Tout identificateur ne rpondant pas la syntaxe d'un identificateur est
quot.
Le contexte courant dtermine les abrviations possibles pour les
identificateurs.
outl(t) quivaut la suite de buts out(t) line : lorsque le terme t a t crit on
produit le passage la ligne suivante.
Exemple :
> out([1, Pierre, "Salut!"]);
[1, Pierre, "Salut!"]{}
>
N.B. : Les accolades imprimes la suite du terme indiquent la russite de

l'effacement du but out([1, Pierre, "Salut!"]) . Une manire d'en
empcher l'impression consiste faire chouer artificiellement cet
effacement :
194
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
> out([1, Pierre, "Salut!"])

[1, Pierre, "Salut!"]
>
line
fail;
outm(s)
outml(s)
Ecrit la chane s sur l'unit de sortie courante, sans crire les quotes et en
interprtant correctement les caractres de formatage que s peut contenir
(comme \n , etc). Si la chane est plus longue que la place restante sur
la ligne en cours, alors elle est coupe par un retour chariot masqu.
outml(s) quivaut outm(s) line.
Exemple:
> out("\tBonjour!") line fail;
"\tBonjour!"
> outm("\tBonjour!") line fail;
Bonjour!
>
outc(t)
Ecrit le terme t et les contraintes qu'il supporte.
Exemples :
> outc(t) fail , { t ::num } ;
t,
{t::num }
> outc(t) fail , { t ::numt } ;
X3[X2],
{X3::num }
>
line
Ecrit une marque de fin-de-ligne sur l'unit de sortie courante.
output(u)
L'unit de nom u devient l'unit courante de sortie. Le cas chant, un
fichier de texte est cr, ayant le nom indiqu par la chane u.
PrologIA
195
L'environnement
Aociation
close_output
L'unit courante est enleve du sommet de la pile des units de sortie
ouvertes. Si elle correspond un fichier, alors celui-ci est ferm.
echo
no_echo
Active (resp. annule) l'option qui provoque l'affichage sur l'unit console des
termes lus ou crits sur une autre unit.
A TTENTION : les termes sont d'abord lus et cods, puis dcods et affichs.
Ce que vous voyez est donc quivalent ce qui a t lu, mais peut en
diffrer de manire plus ou moins importante. L'intrt de cette faon de
procder rside dans le fait que vous voyez les termes non pas comme vous
les avez taps, mais comme Prolog III les a compris ce qui, dans une
situation de recherche d'erreur, est prfrable.
196
Prolog
HERITAGE
PrologIA
Aociation
Prolog
L'environnement
HERITAGE
5 . Autres lments de l'environnement

Sortir de Prolog III
exit
exit(s)
Fait sortir de Prolog en sauvant la totalit des programmes couramment
connus, y compris ceux qui constituent le superviseur de Prolog III. Le
fichier produit a pour nom prolog3.psv (premire forme) ou la valeur de s,
qui doit tre une chane de caractres (deuxime forme).
quit(n)
quit
Fait quitter Prolog III sans rien sauver. Si n a pour valeur 0, cette valeur est
convertie dans le code correspondant pas d'erreur pour le systme
d'exploitation; les autres valeurs de n ne sont pas converties. Ce code est
ensuite envoy au systme d'exploitation titre de statut de terminaison.
La deuxime forme, quit, quivaut quit(0).
Temps et autres mesures
reset_cpu_time
rinitialise le chronomtre.
cpu_time(x)
cpu_time unifie x avec le temps cpu en millisecondes coul depuis le dernier
reset_cpu_time.
ststs
PrologIA
197
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Rgles prdfinies et procdures

externes

Ce chapitre regroupe par ordre alphabtique toutes les rgles prdfinies et
procdures externes disponibles en Prolog III.
On retrouvera la plupart des primitives de Prolog II et Prolog II+, ainsi qu'un
grand nombre de nouvelles rgles prdfinies adaptes aux fonctionnalits spcifiques de Prolog III. La plupart de ces prdicats ont dj t abords dans les
chapitres prcdents. Un accs thmatique ce dictionnaire des primitives Prolog
III est galement fourni la fin du manuel.
Dcembre 1990
PrologIA
Rgles prdfinies et procdures externes
1. Introduction
Ce chapitre prsente les rgles prdfinies et procdures externes de Prolog
III. Cette partie du manuel est certainement celle qui demeurera, au fur et
mesure de vos dveloppements, la plus utile. C'est pourquoi nous avons
essay de vous faciliter la tche en donnant, pour chacune de ces primitives
un mini mode d'emploi, et en multipliant les accs pertinents au reste du
manuel.
Ainsi, pour chacun de ces prdicats, on trouvera les rfrences suivantes :
Fonction :
dcrit en quelques mots les fonctionnalits du

prdicat
Classe :
dtermine s'il s'agit d'une procdure externe, d'une

rgle prdfinie ou d'une fonction valuable, et
donne les compatibilits Prolog II et Edimbourg.
Catgorie :
renvoie gnralement au chapitre concernant ce

type de prdicat, et donne souvent une souscatgorisation.
Paramtres connus :
informe sur la ncessit que certains des arguments

soient connus l'appel de la primitive concerne.
Message d'erreur :
renseigne sur la prsence ventuelle d'un ou

plusieurs messages d'erreurs attachs une
mauvaise utilisation de la primitive. A noter que
dans certains cas, on prfre chouer sans imprimer
de message d'erreur.
De plus, les arguments pour chacune de ces primitives correspondent, dans

la plupart des cas, au type requis (N pour entier, S pour string, T pour
terme, R pour rationnel, V pour variable, P pour prdicat, etc ... ).
200
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE

On donne ensuite une description plus dtaille de la primitive, suivie
d'exemples de sessions qui la font directement intervenir, ventuellement un
certain nombre de remarques, et pour finir une liste de primitives
consulter dont les fonctions se rapprochent de celle considre.
Ce chapitre est spar en deux parties distinctes. Une partie dcrivant les
primitives utilisables en syntaxe standard, et une partie dcrivant les
primitives Edimbourg.
On trouvera galement la fin de chacune de ces sous-parties un index
spcifique concernant les rgles prdfinies, les procdures externes, les
fonctions valuables, ainsi que certains identificateurs importants rencontrs
tout au long de ce chapitre.
PrologIA
201
add_implicit(S1,S2)
Fonction
: Ajout d'un identificateur
Classe
: Procdure externe Prolog III (II+)
Catgorie
: Gestion des rgles et des identificateurs
Paramtres connus
: S1 et S2
Message d'erreur
: Si S1 n'est pas le prfixe d'une famille ayant une

partie ferme
Description :
Rajoute l'identificateur de nom abrg S2 la partie ferme du contexte S1.
Si S1 n'est pas le prfixe d'une famille ayant une partie ferme, on obtient
une erreur.
Voir la section Structuration, saisie et modification des rgles du chapitre Le
contrle et l'environnement des programmes pour plus de dtails.
Voir galement :
remove_implicit, dictionary
set_context, current_context, close_context_dictionary
module, end_module
202
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
arg(N, T1, T2)

Fonction
: Calcul du N-ime argument d'un terme
Classe
: Rgle prdfinie Prolog III
Catgorie
: Arbres, listes, chanes et tuples
Paramtres connus
: N, qui doit tre un entier positif ou nul
Messages d'erreur
: N est inconnu, ngatif ou plus grand que le

nombre d'arguments de T1
Description :
Cette primitive pose la contrainte {T2 = N'}, o N' est le N-ime argument du
terme T1. Si N est nul, T2 est gal l'tiquette initiale de T1.
Exemples :
> arg(2,exemple(X,Y,5),T);
{ T = Y }
> arg(3,exemple[L],T);
{ L = V.<T>.V',
V :: 2 }
> arg(0,exemple[L],T);
{ T = exemple, L !tuple }
> arg(5,exemple(X,Y,5),T);
ERREUR 228: Argument de mauvais type
>
> arg(3,U,T),
{U
::
tuple};
{ U = V.<T>.V',
V :: 2 }
> arg(2,[A,B,C],T);
{ T = [B,C] }
>
Voir galement :
arg2, arg3
PrologIA
203
arg2(N, L, T)
Fonction
: Calcul du N-ime lment d'une liste
Classe
: Compatibilit partielle Prolog II+
Catgorie
Paramtres connus

L qui doit tre une liste suffisamment connue
Messages d'erreur

nombre d'lments de T.
La liste L n'est pas suffisamment connue
Description :
Si N est nul, arg2 pose la contrainte {T = S}, o S reprsente le nombre
d'lments de la liste L
Si N n'est pas nul, arg2 pose la contrainte {T = X}, o X est le N-ime lment
de la liste L.
Exemples :
> arg2(4,[1,2,3,4,5],T);
{ T = 4 }
> arg2(2,[A,B,C|L],T);
{ B = T }
> arg2(3,[A|L],T);
>
Voir galement :
arg, arg3
204
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
arg3(N, T1, T2)

Fonction
: Calcul du N-ime argument d'un tuple
Classe
Catgorie
Paramtres connus
Messages d'erreur

nombre d'arguments de T1
Description :
Cette primitive pose la contrainte {T2 = N'}, o N' est le N-ime argument du
tuple T1. Si N est nul, T2 est gal l'tiquette initiale de T1 c'est--dire <>.
Echoue si N n'est pas un entier positif connu ou si T1 n'est pas un tuple.
Exemples :
> arg3(2,<X,Y,5>,T);
{ T = Y }
> arg3(3,L,T);
{ L = <T>.V }
> arg3(0,E[L],T);
{ E = <>, T = <>, L !tuple }
> arg3(5,<X,Y,5>,T);
> arg3(5,exemple(1,2,3),T);
>
Voir galement :
arg, arg2
PrologIA
205
assert(T, Q)
Fonction
: Ajout d'une rgle au dbut de son paquet
Classe
: Rgle prdfinie Prolog III (II+)
Catgorie
Paramtres connus
: T et Q
Messages d'erreur
: - si Q n'est pas une liste classique

- si T est une tte de rgle incorrecte
Description :
Ajout d'une rgle, au dbut de son paquet. T doit tre un terme pouvant
tre une tte de rgle, c'est--dire reprsentant un arbre tiquet par un
identificateur et Q doit tre une liste de termes.
L'effacement de assert(T, Q) ajoute la rgle T -> Q au-dessus du groupe de
rgles ayant le mme nom que T, c'est--dire au dbut du paquet
correspondant T. Par exemple, les deux commandes suivantes
Exemples :
> assert(conc([e|x],y,[e|z]),[conc(x,y,z)]);
{}
> assert(conc([],y,y),[]);
{}
>

conc([],y,y) ->;
conc(conc([e|x],y,[e|z]) -> conc(x,y,z);
Il semble premire vue que assert ne permet pas d'ajouter des rgles
comportant un systme de contraintes. Il n'en est rien, comme le montre
l'exemple suivant :
206
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Exemples :
> assert(hors_de(x,[y|q]),[hors_de(x,q)]),
{x # y } ;
{ x # y }
> assert(hors_de(x,[]),[]);
{}
> list;
hors_de(x,[]) -> ;
hors_de(x,[y | q]) ->
hors_de(x,q),
{ x # y } ;
{}
>
asserta(T,Q)
Fonction
: identique assert (compatibilit Edinburgh)
Classe
: Rgle prdfinie Prolog III (Edinburgh)
Catgorie
Paramtres connus
: T et Q
Messages d'erreur

Identique assert(T, Q)
PrologIA
207
assert''(T, Q)
Fonction
: Ajout d'une rgle la fin de son paquet
Classe
Catgorie
Paramtres connus
: T et Q
Messages d'erreur

Description :
Ajout d'une rgle, la fin de son paquet. Mme fonctionnement que assert,
mais l'ajout se fait au-dessous, et non au-dessus, du paquet correspondant
T. Exemple: les deux commandes suivantes, dans l'ordre indiqu, produisent
l'insertion du mme programme conc que ci-dessus :
Exemples :
> assert''(conc([],Y,Y),[]);
{}
> assert''(conc([E|X],Y,[E|Z],[conc(X,Y,Z)]);
{}
>
assertz(T, Q)
Fonction
: identique assert'' (compatibilit Edinburgh)
Classe
Catgorie
Paramtres connus
: T et Q
Messages d'erreur

Identique assert''(T, Q)
208
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
assign(I, T)
Fonction
: Affectation
Classe
Catgorie
: Contrle
Paramtres connus
: T et I
Messages d'erreur
: Si T ne reprsente pas un identificateur, un

nombre, un caractre ou une chane de caractres.
Description :
Affecte le terme T, qui doit reprsenter un identificateur, un nombre, un
caractre ou une chane de caractres, l'identificateur I. Tout se passe
comme si I devenait le nom d'une variable globale (ultrieurement
accessible pendant l'effacement de n'importe quel but) et statique
(rsistante au backtracking) possdant T pour valeur. Il s'agit donc bien de
l'affectation classique, comme elle se pratique en FORTRAN, Pascal, etc.
Exemple :
> assign(nom_fichier,
"monfichier.txt");
{}
> val(nom_fichier,x);
{ x="monfichier.txt" }
>
En Prolog, ces variables statiques peuvent tre vues comme une manire
particulirement efficace d'crire des assertions (ou rgles sans queue). Du
point de vue de l'utilisateur, on peut considrer que l'emploi de assign et val
fait ci-dessus est quivalent :
PrologIA
209

> retract(nom_fichier(x),
[] );
{}
> assert(nom_fichier("monfichier.txt"),
[] );
{}
> nom_fichier(x);
{ x="monfichier.txt" }
>
assign(tab(N), T)
Fonction
: affectation d'un lment d'un tableau
Classe
Catgorie
: Contrle
Paramtres connus
: tab(N) et T
Messages d'erreur
: Entier attendu, Tableau dj dfini, Tableau non

dfini, Dbordement de tableau.
Description :
Affecte la valeur de T l'lment de rang N du tableau tab. Ce tableau doit
avoir t dfini au pralable avec def_array. Les mmes restrictions que
prcdemment s'appliquent T : ce doit tre une constante.
Voir galement :
val
def_array, undef_array, redef_array
210
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
block(E, C, B), block_exit(E, C)

Fonction
: Abandon d'effacement, Rcupration d'erreurs
Classe
Catgorie
: Contrle
Paramtres connus
: B
Messages d'erreur
: Block indfini
Description :
La rgle prdfinie block permet de terminer brutalement l'effacement d'un
but, ou d'une liste de buts, B. Cette primitive est essentiellement utilise
pour la rcupration des erreurs ou le contrle de programme.
On peut considrer que :
Pour effacer block(E, C, B) on efface B en ayant auparavant cr une
paire de parenthses fictives, tiquetes par E et ventuellement par
C , autour du but B.
Le deuxime paramtre C, de block(E C, B) , peut tre considr soit
comme une seconde tiquette, soit comme un complment
d'information qui sera retourn par block_exit(E, C). Certaines rgles
prdfinies, utilisent ce deuxime paramtre comme complment
d'information, en transmettant l'argument cause de l'erreur.
block_exit(E, C) provoque l'abandon immdiat de l'effacement de tous
les buts inclus entre les parenthses tiquetes par E et C .
L'effacement continue ensuite, comme si block(E, C, B) s'tait effac,
mais sans laisser aucun choix pour le ou les buts B en attente.
De plus :
Les tiquettes dont il est question ci-dessus sont des termes Prolog III
quelconques, et on considre que pour que deux termes reprsentent
la mme tiquette au regard du mcanisme block_exit, il faut et il suffit
qu'ils soient unifiables.
PrologIA
211

S'il y a plusieurs parenthses tiquetes par E et C, block_exit(E, C)
s'arrte au couple de parenthses le plus interne.
Si block_exit(E, C) ne rencontre pas de parenthses E et C on revient
au niveau de commande avec, si E n'est pas un entier, le message
d'erreur Erreur 50 : Block indfini, ou le message correspondant
l'erreur E si E est un entier.
C'est ce mme mcanisme qui est utilis pour la gestion interne des erreurs
en Prolog III. Une erreur rencontre dans l'excution d'un programme
provoque l'effacement du but block_exit(I, C) o I est un entier correspondant au numro de l'erreur et C un complment d'information ou le
tuple vide. De cette manire, l'utilisateur a la possibilit de rcuprer toutes
les erreurs de Prolog III pour les traiter dans son application.
Exemples :
executer_commande ->
block(fin_commande, C, lire_et_executer);
lire_et_executer ->
repeat
outm("? ")
in_char'(X)
executer(X);
executer(`t`) ->
% terminaison de programme
block_exit(fin_commande, <>);
executer(`c`) ->
outml("continuer");
executer(X) ->
block_exit(fin_commande, X),
{ X # `c` };
Dans cet exemple, la commande `t` utilise block_exit pour revenir au niveau
suprieur de executer_commande en interrompant l'effacement de
lire_et_executer et en supprimant tous les points de choix (repeat) en attente.
La commande `c` termine normalement l'effacement de lire_et_executer et
conserve les points de choix (repeat). Toute autre commande utilise aussi
block_exit et permet de remonter le caractre tap comme complment
d'information pour C.
212
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE

lecture_dans_un_fichier(L) ->
input("fichier_a_lire")
boucle_de_lecture(L);
boucle_de_lecture(L) ->
block(X, _, inl(D_onnee))
suite_boucle_de_lecture(X, D_onnee, L);
suite_boucle_de_lecture(X, D_onnee, <D_onnee>.L) ->
free(X) !
boucle_de_lecture(L);
suite_boucle_de_lecture(17, _, <>) -> % fin de fichier
close_input("fichier_a_lire");
Ce deuxime exemple permet de lire des donnes (chanes de caractres)

dans un fichier et de construire la liste (tuple) de ces donnes. Lorsque
l'interprteur Prolog dtecte la fin du fichier, il gnre un block_exit, avec
l'entier 17 comme valeur de l'tiquette principale, correspondant l'erreur
de fin de fichier. Cette erreur peut tre rcupre par le block englobant
puisque son tiquette principale tait une variable.
lecture_dans_un_fichier_et_traitement ->
input("fichier_a_lire")
block(E, C, lire_et_traiter(I_nfo))
suite_lire_et_traiter(E, C, I_nfo);
lire_et_traiter(I_nfo) ->
repeat
inl(I_nfo)
traiter(I_nfo);
suite_lire_et_traiter(X, _, _) ->
free(X) !
fail;
suite_lire_et_traiter(17, _, _) -> ! % fin de fichier
close_input("fichier_a_lire");
suite_lire_et_traiter(X, Y, _) -> !
% erreurs non rcupres
close_input("fichier_a_lire")
block_exit(X, Y),
{ X <= 9 };
suite_lire_et_traiter(X, Y, I) ->
% erreurs traites
traiter_erreur(I, X, Y)
block(E, C, lire_et_traiter(I_nfo))
suite_lire_et_traiter(E, C, I_nfo);
traiter_erreur(I, X, Y) ->
... ;
traiter(I) ->
... ;
PrologIA
212 i

Le dernier exemple permet de lire des donnes (chanes de caractres) dans
un fichier et de les traiter sans construire la liste (tuple) de ces donnes. Le
mme mcanisme que prcdemment est utilis lorsque Prolog dtecte la fin
de fichier, et un mcanisme analogue permet de grer les autres erreurs
pouvant intervenir au cours du traitement. Une partie de ces erreurs ne sont
pas rcuprables, telles que les erreurs de dbordement de piles, et dans ce
cas on utilise block_exit pour retourner au niveau suprieur de Prolog. Par
contre, certaines autres erreurs peuvent tre prises en compte dans le
traitement afin de poursuivre l'excution du programme, il faut dans ce cas
relancer l'effacement d'un nouveau block puisqu'il n'y a plus aucun moyen
de revenir dans le block prcdant.
Remarque :
A tout instant un programme peut tre interrompu au moyen d'une touche
dtermine, dpendant du systme utilis, par exemple : <Ctrl-C>. Cette
interruption est gre soit comme une erreur, il est alors possible de
l'intercepter par le mcanisme de block, soit comme un dialogue, et dans ce
cas block ne peut l'intercepter. L'utilisateur peut configurer la gestion de
l'interruption l'aide de la procdure externe set_config.
Voir galement :
set_config
212 ii
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
block(E, B), block_exit(E)

Fonction
: Abandon d'effacement, Rcupration d'erreurs
Classe
Catgorie
: Contrle
Paramtres connus
: B
Messages d'erreur
: Block indfini
Description :
Fonctionnement analogue aux formes prcdentes, avec une tiquette E
la place de deux. B est le but ou la suite de buts effacer. block(E, B) lance
l'effacement de B ; l'effacement ultrieur de block_exit un argument
produira la recherche d'un block dont le premier argument s'unifie avec
l'argument de block_exit.
La forme block(E, B) est quivalente block(E, _, B).
La forme block_exit(E) est quivalente block_exit(E, <>).
Lorsque block_exit(E, C) est effac dans un environnement parenths par
block(E, B), alors block_exit(E, C) se comporte comme block_exit(E).
Inversement, lorsque block_exit(E) est effac dans un environnement
parenths par block(E, C, B), alors block_exit(E) se comporte comme
block_exit(E, <>).
Remarque :
A tout instant un programme peut tre interrompu au moyen d'une touche
dtermine, dpendant du systme utilis, par exemple : <Ctrl-C>. Cette
interruption est gre soit comme une erreur, il est alors possible de
l'intercepter par le mcanisme de block, soit comme un dialogue, et dans ce
cas block ne peut l'intercepter. L'utilisateur peut configurer la gestion de
l'interruption l'aide de la procdure externe set_config.
Voir galement :
set_config
PrologIA
213
bool(B)
Fonction
: Vrification boolenne
Classe
Catgorie
: Vrification de types
Paramtres connus
: B
Messages d'erreur
: Aucun
Description :
Cette rgle prdfinie vrifie que B est un terme reprsentant une valeur
boolenne connue. Si ce n'est pas le cas bool(B) choue.
Exemples :
> bool(1');
{}
> bool(A&B);
>
> bool(A|1');
{ A !bool }
> bool(A),{A|B
1',
A|~B
1'};
{ A = 1',
B !bool }
> bool(2);
>
Remarques :
Cette rgle prdfinie ne teste pas seulement que B reprsente une valeur
boolenne (la rgle prdfinie is_bool(B) effectue cette vrification).
Le terme B peut tre contraint reprsenter une valeur boolenne connue
dans le cas o, pour toutes les solutions du systme de contraintes courant, B
reprsente la mme valeur (voir le troisime exemple ci-dessus)
214
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
bound(T)
Fonction
: Vrifie que T reprsente un terme suffisamment

connu
Classe
Catgorie
: Contrle
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Ce prdicat s'efface si T est un terme reprsentant un arbre dont :
L'tiquette initiale est connue
Le nombre des fils est connu
Voir la section Termes connus du chapitre Retardements pour plus de
dtails.
Exemples :
> bound(1');
{}
> bound(123/456);
{}
> bound(aurore(A,B,C,D));
{}
> bound(boreale[L]),{L
::
12};
{ L :: 12, L !tuple }
> bound(E[L]),{L
::
12};
>
Voir galement :
known, bound_tree, bound_tree'
free, free_label'
PrologIA
215
bound_conc(U1, U2, U3)

Fonction
: concatnation
Classe
Catgorie
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
Pose la contrainte {U3 = U1.U2}. Echoue si la taille du tuple U1 n'est pas
connue.
Exemples :
> bound_conc(<1,2>.X,Y,Z),
{ Z = <1,2>.X.Y, X::3 }
> bound_conc(X,Y,Z);
>
Voir galement :
conc3
216
PrologIA
X::3
};
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
bound_mult(N1, N2, N3)

Fonction
: Multiplication linaire
Classe
Catgorie
: Contraintes numriques
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
Pose la contrainte {N3 = N1*N2}. Echoue si N1 et N2 ne sont pas des valeurs
numriques connues (en d'autres termes russit si l'une des deux est connue,
ce qui rend la contrainte linaire).
Exemples :
> bound_mult(2,Y,Z);
{ Z = 2Y }
> bound_mult(X,X,4);
>
Voir galement :
mult
PrologIA
217
bound_size(T, N)
Fonction
: Taille d'un terme
Classe
Catgorie
Paramtres connus
: N ou la taille de T (voir ci-dessous)
Messages d'erreur
: Non
Description :
Pose la contrainte { T :: N }, si N est un entier positif, ou bien la contrainte
{ N = k } si T est un terme ayant un nombre connu, k, de fils. Echoue dans les
autres cas.
Exemples :
> bound_size(<1,2,3,4>,N);
{ N = 4 }
> bound_size("c'est
tout!",N);
{ N = 11 }
> bound_size(U,2);
{ U = X1[X2],
X2 :: 2 }
> bound_size(U,N);
>
Dans cet exemple nous avons renomm les variables intermdiaires cres
par Prolog III.
218
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
bound_tree(T)
Fonction
: Vrifie que T reprsente un arbre unique
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Vrifie que T reprsente un arbre unique, c'est dire que le terme T ne
comporte aucune variable.
Remarque :
T ne doit pas reprsenter un arbre infini. Si c'est le cas, utiliser la primitive
bound_tree'.
Exemples :
> bound_tree(<1,2,3,4>);
{}
> bound_tree("c'est
tout!");
{}
> bound_tree(E[U])
U::4
};
>
Voir galement :
free, free_label, known, bound, bound_tree'
PrologIA
219
bound_tree'(T)
Fonction
: Vrifie que T reprsente un arbre unique,

ventuellement infini
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Vrifie que T reprsente un arbre unique, c'est dire que le terme T ne
comporte aucune variable. T peut reprsenter un arbre infini. Si on est sr
d'tre dans le cas contraire, utiliser la primitive bound_tree, plus efficace.
Exemples :
> bound_tree'(<1,2,3,4>);
{}
> bound_tree'(X),{X
1(X)};
{ X = 1(X) }
>
Voir galement :
free, free_label, known, bound, bound_tree
220
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
break
break(S1)
break(S1, S2)
Fonction
: Appel au debugger Prolog III
Classe
: Procdure externe Prolog III
Catgorie
: Environnement
Paramtres connus
: S1 et S2
Messages d'erreur
: non
Description :
Cette primitive a pour effet de passer en mode debug et, selon la prsence
d'arguments, d'imprimer la chane S1 sur la sortie de trace, puis d'excuter
sous le debugger Prolog III les commandes contenues dans chane S2.
Placer des appels break dans un programme revient installer manuellement des points-espions des endroits beaucoup plus prcis que ceux
placs au moyen de la primitive Prolog spy sur tout un paquet de rgles. De
plus, la possibilit de passer des commandes au debugger par l'argument S2
permet une certaine automatisation (batch).
Si on n'est pas en mode debug au moment de l'appel break, la ou les
commandes S2 ne seront prises en compte et excutes qu' partir d'un
prochain port (ventuellement pendant un backtracking). Sinon le port EXIT
de break est montr et les ventuelles commandes S2 sont excutes.
Voici un exemple tir de menu.p3 , dans lequel on a remplac le paquet de
nom Poisson par ce qui suit :
Poisson(sole, 2) -> break("dans Poisson", "sol;p;C");
Poisson(thon,4) ->;
PrologIA
220 i

On souhaite donc espionner la premire rgle du paquet Poisson, et chaque
invocation de cette rgle, imprimer un message ("dans Poisson"), afficher le
systme de contraintes portant sur les variables de la question (sol),
imprimer le status du port courant (p) et enfin poursuivre l'excution
jusqu'au prochain point d'arrt (C).
Voici un exemple d'excution dans lequel ce qui est en gras est tap par
l'utilisateur. Les impressions provoques par l'appel break sont en italique.
On suppose que l'on n'est pas en mode debug au moment de lancer la
requte :
> RepasLeger(h,p,d);
{h = radis, p = boeuf, d = fruit}
{h = radis, p = porc, d = fruit}
dans Poisson
6[0]CALL
: Dessert(d,k_1)
{h = radis, p = sole}
6[0]CALL
: Dessert(d,k_1)
{h = radis, p = sole, d = fruit}

{h = radis, p = sole, d = glace}
{h = radis, p = thon, d = fruit}
dans Poisson
5[2]EXIT(rC): break("dans Poisson","sol;p;C")
{h = pate, p = sole}
5[2]EXIT(rC): break("dans Poisson","sol;p;C")
{h = pate, p = sole, d = fruit}
>
L'utilisateur se rfrera au manuel Mise au point de programmes

Prolog III pour la dfinition des points-espion.
Voir galement :
spy
debug, no_debug
220 ii
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
char(C)
Fonction
: Vrifie que C reprsente un caractre connu
Classe
Catgorie
Paramtres connus
: C
Messages d'erreur
: Non
Dfinition :
Le but char(C) s'efface si C est un terme reprsentant un caractre connu.
Exemples :
> char(à`);
{}
> char(A),
{A
!char};
>
char("A");
>
PrologIA
221
char_code(C, N)
Fonction
: Liaison d'un caractre et de son code ASCII
Classe
Catgorie
: Conversion
Paramtres connus
: C ou N
Messages d'erreur
: Non
Dfinition :
Fait correspondre au caractre C son code ASCII N et vice-versa.
Exemple :
> char_code(À`,N);
{N=65}
> char_code(C,65);
{C=À`}
>
Remarque :
Les caractres dont le code ASCII est compris entre 0 et 31 sont imprims
sous la forme `\uu` o uu reprsente l'criture octale du code en question.
222
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
close_context_dictionary(S)
Fonction
: Fermeture d'une famille d'identificateurs
Classe
Catgorie
Paramtres connus
: S
Messages d'erreur
: Non
Description :
Dfinit la partie ferme de la famille S, comme tant gale l'tat courant de
cette famille au moment o cette rgle est excute. Tout autre identificateur
venant s'ajouter cette famille par la suite ne sera pas dans sa partie ferme
et donc ne sera pas pris en compte dans les oprations utilisant la liste
implicite de la commande set_context (voir cette primitive), sauf s'il fait
l'objet d'un appel de la rgle add_implicit..
Voir galement :
add_implicit, remove_implicit, dictionary
set_context, current_context
PrologIA
223
close_input
Fonction
: Fermeture de l'unit d'entre courante
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: Aucun
Messages d'erreur
: Impossible de fermer le fichier
Description :
L'unit courante est ferme (sauf s'il s'agit de la console) et son descripteur
est enlev du sommet de la pile des units : l'unit prcdente redevient
unit courante.
close_input(F)
Fonction
: Fermeture de l'unit d'entre de nom F
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: F, qui doit tre une chane de caractres
Messages d'erreur
Description :
L'unit de nom F, qui doit figurer dans la liste des units ouvertes, est
ferme et son descripteur est enlev de cette liste.
Voir galement :
input
224
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
close_output
Fonction
: Fermeture de l'unit de sortie courante
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: Aucun
Messages d'erreur
Dfinition
L'unit courante est enleve du sommet de la pile des units de sortie
ouvertes, sauf s'il s'agit de la console. Si elle correspond un fichier, alors
celui-ci est ferm.
close_output(F)
Fonction
: Fermeture de l'unit de sortie de nom F
Classe
Catgorie
: Entres/Sorties
Paramtres connus
Messages d'erreur
Description :
L'unit de nom F, qui doit figurer dans la liste des units de sortie ouvertes,
est ferme et son descripteur est enlev de cette liste.
Voir galement :
output
PrologIA
225
conc3(U1, U2, U3)

Fonction
: Concatnation retarde de tuples avec contraintes

arithmtiques sur les tailles.
Classe
Catgorie
: Arbres, listes chanes et tuples
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
Pose le systme de contraintes {U3 = U1.U2, U1 :: N1, U2 :: N2, U3 :: N3,
N3 = N1+N2, N1 >= 0, N2 >= 0, N3 >= 0 }, avec les retardements ncessaires si
N1, N2 ou N3 ne sont pas connus.
Exemples :
> conc3(U,V,U);
{ V = <>,
U :: N,
U.<> = U,
N >= 0 }
>
Voir galement :
size, bound_size, bound_conc
226
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
conc_string(S1, S2, S3)

Fonction
: Concatnation de chanes
Classe
Catgorie
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
Enumre tous les triplets S 1 , S 2 , S 3 de chanes telles que S 3 est la
concatnation de S1 et S2. Les chanes S1, S2, S3 doivent tre suffisamment
connues pour produire des ensembles finis de triplets.
Exemples :
> conc_string("ab","cd",s);
{ s="abcd" }
> conc_string(s1,s2,"abcd");
{ s1=<>,s2="abcd" }
{ s1="a",s2="bcd" }
{ s1="ab",s2="cd" }
{ s1="abc",s2="d" }
{ s1="abcd",s2=<> }
>
PrologIA
227
cpu_time(N)
Fonction
: Obtention d'un temps cpu
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
cpu_time unifie N avec le temps cpu en millisecondes.
Voir galement :
reset_cpu_time
228
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
current_context(T0),
current_context(T0, T1, T2, T3)
Fonction
: Identification de contexte
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Unifie T0 avec le terme identifiant le contexte courant de lecture criture, et
T1, T2, T3 avec, respectivement, le terme dfinissant la suite explicite, le
terme dfinissant la suite implicite, et le prfixe par dfaut de ce contexte.
Voir galement :
set_context
PrologIA
229
current_predicate(<I, A>)
Fonction
: Test de prsence d'une rgle
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Permet de tester la prsence d'une rgle. S'efface s'il existe une rgle
d'identificateur d'accs I et d'arit A. Si A est une variable, et I est connu,
numre successivement toutes les valeurs de A correspondant une rgle
d'accs I. Si I n'est pas connu (i.e. est une variable), unifie l'argument
successivement avec toutes les formes I, A des rgles du module dtermin
par le prfixe par dfaut du contexte courant.
Voir galement :
rule
230
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
/
Fonction
: Coupure
Classe
Catgorie
: Contrle
Paramtres connus
: Aucun
Messages d'erreur
: Non
'!'
Description :
Le prdicat '!' s'excute de la mme manire que / (slash) en syntaxe
marseillaise ou ! (cut) en syntaxe Edinburgh, savoir qu'il coupe tous les
choix possibles le prcdant dans la rgle o il est prsent. Ces choix sont :
les autres manires d'excuter la tte de cette rgle, et les autres manires
d'excuter les buts de cette rgle prcdant le '!'.
La diffrence entre ces trois notations est que la forme 'identificateur quot'
(qui est donc un terme) est la seule utilisable l'intrieur d'un terme (comme
argument par exemple) alors que les formes / et ! ne sont que des parasites
employs uniquement dans une suite de buts (queue de rgle ou requte).
> couleur(rouge)
->;
> couleur(bleu)
->;
> taille(grand)
->;
> taille(petit)
->;
> choix1(<X,Y>)
->
> choix1("c'est
tout")
> choix2(<X,Y>)
->
> choix2("c'est
tout")
> choix3(<X,Y>)
->
> choix3("c'est
tout")
> choix4(<X,Y>)
->
> choix4("c'est
tout")
couleur(X)
taille(Y);
->;
couleur(X)
taille(Y);
->;
couleur(X)
taille(Y);
->;
couleur(X)
taille(Y)
'!';
->;
PrologIA
230 i

> choix1(U);
{ U = <rouge,grand> }
{ U = <rouge,petit> }
{ U = <bleu,grand> }
{ U = <bleu,petit> }
{ U = "c'est tout" }
> choix2(U);
{ U = <bleu,grand> }
{ U = <bleu,petit> }
> choix3(U);
> choix4(U);
> choix1(U)
cut;
>
230 ii
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
debug
Fonction
: Mode debug pour l'excution d'un programme
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Passage en mode debug pour le suivi de l'excution d'un programme.
Prolog III pour de plus amples informations.
Voir galement :
no_debug, trace, no_trace
set_config, set_configuration, get_config, get_configuration,
PrologIA
231
def_array(I, N)
Fonction
: Dclaration de tableau statique
Classe
Catgorie
Paramtres connus
: I et N
Messages d'erreur
: Identificateur attendu, Entier attendu, Tableau

dj dfini
Description :
Dfinit dynamiquement un tableau de constantes Prolog de nom I et de taille
N. Ce tableau se comportera comme une variable globale (ultrieurement
accessible pendant l'effacement de n'importe quel but) et statique
(rsistante au backtracking). Les valeurs lgales de l'indice sont incluses dans
1..N.
Si un tableau de mme nom existe dj :
s'il s'agit d'un tableau de mme taille, il ne se passe rien
si les tailles diffrent, il se produit une erreur
L'accs et l'affectation sont analogues ceux des tableaux des autres
langages de programmation. Le tableau est dsallou lorsqu'on tue le
module auquel il appartient (c..d. les rgles ayant le mme prfixe).
232
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Exemples
> list;
inc(i) -> val(i,x) assign(i,x+1);
dec(i) -> val(i,x) assign(i,x-1);
initialise -> assign(pointeur,1) def_array(pile,100);
empile(v) ->
val(pointeur,p)
!
assign(pile(p), v)
inc(pointeur)
,{ p <= 100 };
empile(v) -> outml("dbordement de la pile") fail;
depile(v) ->
dec(pointeur)
val(pointeur,p)
!
val(pile(p),v)
dec(pointeur)
, { p >= 1 };
depile(v) -> outml("pile vide") assign(pointeur,1) fail;
{}
> initialise;
{}
> empile(111);
{}
> empile(222);
{}
> depile(x) depile(y);
{ x=222, y=111 }
> depile(x);
pile vide
>
Voir galement :
assign, val
undef_array, redef_array
PrologIA
233
default(T1, T2)
Fonction
: Contrle de l'effacement
Classe
Catgorie
: Contrle
Paramtres connus
: Aucun
Causes d'chec
: T1 ou T2 ne reprsentent pas des arbres tiquets

par un identificateur.
Description :
La rgle prdfinie default permet de raliser le contrle suivant : si on peut
effacer T1, alors on l'efface de toutes les manires possibles, sinon on efface
T2. Il faut remarquer que contrairement ce que l'on pourrait penser
premire vue, cette primitive ne peut pas tre ralise avec '!'.
Exemple :
repondre(p) -> default(p,outml("personne"));
homme(jean) ->;
homme(pierre) ->;
> repondre(homme(x));
{ x=jean }
{ x=pierre }
> repondre(femme(x));
personne
{}
>
234
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
dictionary
Fonction
: Recherche des modules utilisateurs
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Ecrit sur la sortie courante la forme abrge des accs de la famille ayant le
mme prfixe que le prfixe par dfaut du contexte de lecture/criture.
Chaque accs est crit sous la forme identificateur/arit
dictionary(L)
Fonction
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Unifie L avec la liste des prfixes des modules utilisateur prsents en
mmoire.
PrologIA
235
dictionary(M, L)
Fonction
Classe
Catgorie
Paramtres connus
: M, qui doit tre une chane
Messages d'erreur
: Si M n'est pas une chane de caractres
Description :
Unifie L avec la liste des accs du module M. Chaque accs est reprsent
sous la forme d'un tuple : < identificateur , arit >.
Exemple :
> aa:bb(1)
->;
aa:cc(1,2)
->;;
> dictionary("aa",L);
{ L = [aa:<bb,1>,aa:<cc,2>] }
>
236
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
dif(T1, T2)
Fonction
: Ingalit
Classe
Catgorie
: Contrle
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Pose la contrainte {T1 #T2].
PrologIA
237
div(N1, N2, N3)

Fonction
: Division entire
Classe
Catgorie
Paramtres connus
: N1 et N2, entiers. N2 ne doit pas tre nul.
Messages d'erreur
: Division par zro
Description :
Pose la contrainte {N3 = D}, o D est le rsultat de la division entire de la
valeur absolue de N1 par la valeur de N2. On prendra garde ne pas
confondre le prdicat avec la fonction valuable du mme nom (voir la rgle
prdfinie val).
Exemples :
>
div(9,2,N);
{ N = 4 }
>
div(7,N1,N2):
>
Voir galement :
mod
trunc
238
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
dot(T)
Fonction
: Vrifie que T reprsente une liste binaire non vide
Classe
Catgorie
Paramtres connus
: T, qui doit reprsenter une liste binaire
Messages d'erreur
: Non
Description :
Vrifie que le terme T reprsente une paire pointe. Echoue si
T est libre,
ou
T ne reprsente pas une liste,
ou
T = [].
PrologIA
239
echo
Fonction
: Echo sur la console
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Provoque l'affichage sur l'unit courante de sortie de toutes les rgles ou
requtes lues sur l'unit courante d'entre. Ces rgles lorsqu'elles sont
valides sont d'abord codes, puis ensuite listes, donc dcodes, sur la sortie
courante.
Voir galement :
no_echo
set_config, set_configuration, get_config, get_configuration
240
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
edinburgh
Fonction
: Bascule en syntaxe Edimbourg
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Bascule en syntaxe Edimbourg si l'on se trouve en syntaxe Prolog III. Se
comporte en fait exactement de la mme manire que l'appel :
set_config("syntax","Edinburgh")
Remarques :
Il est possible de se retrouver directement sous le mode syntaxique
Edimbourg, pour chaque session Prolog III. Pour cela, il suffit une premire
fois d'excuter la primitive Edinburgh (mode syntaxique par dfaut :
Prolog III), puis de sauver l'tat courant l'aide de la commande exit. On
invitera chaque utilisateur renommer auparavant le fichier initial3.psv afin
d'en conserver une version l'tat d'origine.
Voir galement :
prologIII
exit, set_config
PrologIA
241
edit(I)
Fonction
: Edition de rgles
Classe
Catgorie
: Environnement
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
La primitive edit permet d'diter un ou plusieurs paquets de rgles et
rinsre les rgles modifies dans Prolog III, aprs avoir dtruit les rgles
devenues obsoltes.
L'argument I peut avoir toutes les formes dcrites pour la primitive list c'est-dire (s dsigne une chane de caractres, i un identificateur, a un entier et v
une variable) :
s
Tous les paquets de rgles du module correspondant au prfixe s
i
Le(s) paquet(s) de rgles ayant i pour accs.
[i1, i2, in]
Tous le(s) paquet(s) de rgles ayant i 1 pour accs puis le(s)

paquet(s) ayant i2 pour accs, etc
Tous les paquets de rgles du module correspondant au prfixe
par dfaut. v est unifi avec une liste de doublets de la forme
<ident, arit>.
<i, a>
Toutes les rgles composant le paquet de nom i et d'arit a.
<i, v>
<v, a>
Toutes les rgles dont l'accs est i, quelque soit leur arit.
Toutes les rgles d'arit a appartenant au module ayant le prfixe
par dfaut du contexte de lecture et criture courant.
Liste de doublets de l'une des trois dernires formes.

Pour les systmes disposant d'un ou plusieurs diteurs htes, on se rfrera
la section "Manuel d'utilisation" pour positionner la variable
d'environnement (PrologEdit) permettant de choisir son diteur prfr.
242
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
end_module(P)
Fonction
: Dclaration de fin de module
Classe
Catgorie
Paramtres connus
: P
Messages d'erreur
: Non
Description :
Dfinit toutes les rgles comprises entre les appels aux primitives module et
end_module comme dcrivant le mme module. On se reportera, pour ces
notions assez complexes au chapitre Environnement. On rappelle
cependant pour mmoire que P est le prfixe du module, et que ce prfixe
doit tre le mme que celui dfini dans la primitive module correspondante .
Voir galement :
module
PrologIA
243
enum(R)
Fonction
: Enumration entire
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Enumre toutes les constantes entires n telles que la contrainte { R = n } soit
satisfaisable. L'ordre d'numration est indfini. L'intrt de cette rgle
prdfinie rside dans la possibilit d'numrer des variables entires dans
un domaine de valeurs limit l'aide de contraintes numriques portant sur
des rationnels ou des rels.
Exemple :
> enum(R),{-1.5
<
<
4};
{ R = 3 }
{ R = 2 }
{ R = 1 }
{ R = 0 }
{ R = -1 }
>
244
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
enum(R, R1)
Fonction
: Enumration entire borne suprieurement
Classe
Catgorie
Paramtres connus
: R1
Messages d'erreur
: Non
Description :
Enumre toutes les constantes entires n positives telles que l'ensemble de
contraintes {R = n, 1<=R<=R1 } soit satisfaisable. L'ordre d'numration est
indfini.
enum(R, R1, R2)

Fonction
: Enumration entire entre deux bornes
Classe
Catgorie
Paramtres connus
: R1 et R2
Messages d'erreur
: Non
Description :
Enumre toutes les constantes entires n positives telles que l'ensemble de
contraintes {R = n, 1<=R1<=R<=R2 } soit satisfaisable. L'ordre d'numration
est indfini.
PrologIA
245
eq(T1, T2)
Fonction
: Egalit
Classe
Catgorie
: Contrle
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Pose tout simplement la contrainte {T1 = T2}
Voir galement :
dif
246
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
exit
Fonction
: Terminaison de Prolog III
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Permet de sortir de Prolog III en sauvant la totalit des modules, y compris
ceux qui constituent le superviseur Prolog III (tat initial) sous forme code.
Le fichier produit a pour nom prolog3.psv.
Voir galement :
exit(S), quit, quit(N)
reload
PrologIA
247
exit(S)
Fonction
: Sortie de Prolog III
Classe
Catgorie
: Environnement
Paramtres connus
: S, qui doit tre une chane de caractres
Messages d'erreur
: Chane attendue
Description :
Permet de sortir de Prolog III en sauvant la totalit des modules, y compris
ceux qui constituent le superviseur Prolog III (tat initial) sous forme code,
dans le fichier de nom S.
Voir galement :
exit, quit, quit(N)
reload
248
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
fail
Fonction
: Echec Prolog
Classe
Catgorie
: Contrle
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
fail provoque toujours un chec Prolog et donc l'exploration des autres choix
en attente (backtracking). On prconise l'emploi de fail plutt que
l'utilisation d'un prdicat non dfini, afin d'viter d'avoir des messages
d'erreurs ou d'avertissement l'excution; voir ce sujet les primitives trace
et set_config.
PrologIA
249
findall(V, P, L)
Fonction
: Collection de solutions
Classe
Catgorie
: Contrle
Paramtres connus
: P
Messages d'erreur
: Aucun
Description :
Unifie la liste L avec la collection de toutes les solutions V lorsqu'on efface P.
Le but P doit tre suffisamment connu pour tre excut.
Exemple :
> list;
age(paul, 22) -> ;
age(jean, 28) -> ;
age(bruno, 25) -> ;
{}
> findall(<N,A>,
age(N,A),
L);
{ L=[<paul,22>,<jean,28>,<bruno,25>] }
>
250
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
find_pattern(S1, S2, N)
Fonction
: Recherche de sous-chane
Classe
Catgorie
Paramtres connus
: S1, S2
Messages d'erreur
: Non
Description :
Pose la contrainte {N = D} o D est la position du dbut de la chane S2 dans
la chane S1. Si la chane S2 n'est pas trouve, alors find_pattern choue.
Exemple :
> find_pattern("1234567890","3456",p);
{ p=3 }
> find_pattern("1234567890","abcd",p);
>
Voir galement :
conc_string, substring
PrologIA
251
free(T)
Fonction
: Vrifie que T ne reprsente pas un terme suffisamment connu
Classe
Catgorie
: Contrle
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
free(T) est excut avec succs si
l'on ne connat pas l'tiquette initiale de T
et
l'on ne sait pas si le nombre de ses fils est nul ou non.
Echoue dans tous les autres cas.
T = E[L]
known(L)
known(L)
known(E)
free(T)
known(E)
known(T)
Exemples :
> free(X);
{ X=V1[V2] }
> free((+X)[U]);
{ X !num, U !tuple }
> free(X(1,2,3));
> free(sommet[L]);
> free(sommet(X,Y,Z);
> free(sommet[L])
{L
<>};
>
Voir galement :
free_label, known, bound, bound_tree, bound_tree'
252
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
free_label(T)
Fonction
: Vrifie que l'tiquette du terme T n'est pas connue
Classe
Catgorie
: Contrle
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
free_label(T) est excut avec succs si l'on ne connat pas l'tiquette initiale
de T . Echoue dans tous les autres cas.
Exemples :
> free_label(X);
{ X=V1[V2] }
> free_label(+X);
{ X !num }
> free_label(X(1,2,3));
{}
> free_label(exemple[L]);
>
Voir galement :
free, known, bound, bound_tree, bound_tree'
PrologIA
253
freeze(T, P)
Fonction
: Retardement de l'excution d'un but
Classe
Catgorie
: Contrle
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Retarde l'excution du but P tant que le terme T n'est pas connu. On
remarquera notamment que si le terme T est rduit une variable numrique ou boolenne, l'ensemble de contraintes courant peut rduire suffisamment le domaine des valeurs possibles de cette variable pour
provoquer l'excution de P.
Un terme est connu lorsque l'on connait l'tiquette initiale de l'arbre
qu'il reprsente et que l'on sait si c'est une feuille ou non (si son nombre
de fils est nul ou non nul)
Remarque :
Lorsque T devient connu, les buts gels sur T viennent s'insrer en tte de la
rsolvante. Pour des raisons d'efficacit, l'ordre dans lequel ils seront
excuts n'est pas spcifi.
Voir galement :
known, free
254
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
garbage_collection
Fonction
: Rcupration de mmoire
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Provoque l'excution du mcanisme de rcupration de mmoire. Ceci est
utile dans la mesure o Prolog III gre automatiquement la mmoire qui lui
est alloue chaque tape de la rsolution. Il peut ainsi s'avrer ncessaire,
pour traiter une tape particulirement coteuse, de provoquer ce
mcanisme par programme, de manire pouvoir disposer du maximum
d'espace disponible. En effet, la place occupe avant le traitement de cette
tape peut n'tre pas suffisamment importante pour motiver un
dclenchement automatique du rcuprateur de mmoire.
Voir galement :
state
PrologIA
255
gcd(N1, N2, N3)

Fonction
: Calcul du plus grand commun diviseur
Classe
Catgorie
Paramtres connus
: N1, N2
Messages d'erreur
: Non
Description :
Pose la contrainte {N3 = N3'}, o N3' est le plus grand commun diviseur des
entiers N1 et N2. Le plus grand commun diviseur calcul ne tient pas compte
du signe. gcd choue si N1 et N2 ne sont pas connus ou pas entiers.
Exemples :
> gcd(24,16,P);
{ P = 8 }
> gcd(24,-16,P);
{ P = 8 }
>
Voir galement :
lcm
pgcd, ppcm
256
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
get_config(S,V)
Fonction
: Etat courant de configuration
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Si S est une chane, pose la contrainte {V = S'}, o S' est la valeur courante
associe au champ S. Sinon, get_config numre par backtracking les champs
possibles pour S et leur valeur courante pour V. Pour la liste complte de
ces champs et de ces valeurs, on se reportera aux explications donnes
set_config.
Exemple :
> get_config("syntax",S).
{ S = "Edimbourg" }
>
Voir galement :
set_config, set_configuration, get_configuration
PrologIA
257
get_configuration(U)
Fonction
: Etat courant des configurations
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Pose la contrainte {U = U'}, o U' est un tuple de doublets <champ, valeur>
qui dcrit l'tat de tous les paramtres courants. Pour la liste des champs et
de leurs valeurs possibles, voir set_config.
Exemple :
> get_configuration(X).
{ X=<<"echo",0>,<"epsilon_float",7.450580596923828e-09>,
<"format_decimal",3>,<"format_float","%.15le">,
<"format_out_num","Fnormal">,<"statistics",0>,
<"syntax","Edimbourg">,<"trace",0>,<"tty_wrap",200>,
<"undefined_rule","fail">> }
>
Voir galement :
set_config, set_configuration, get_config
258
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
getenv(S1,S2)
Fonction
: Obtenir la valeur d'une variable de l'environnement
Classe
Catgorie
: Environnement
Paramtres connus
: S1
Messages d'erreur
: Non
Description :
Pose la contrainte {S2 = S2'}, o S2' est la valeur associe au sein du systme
d'exploitation la variable d'environnement de nom S1. Par exemple, sous
UNIX une telle association pourra se faire par le biais de la commande shell
setenv .
Exemple :
$ setenv
essai
17
$ prolog3
.....
> getenv("essai",S);
{ S = "17" }
>
PrologIA
259
ident(I)
Fonction
: Vrifie que I reprsente un identificateur connu
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Vrifie que le terme I reprsente un identificateur connu, et choue dans le
cas inverse.
Exemples :
> ident(nuit_blanche);
{}
> ident("nuit_blanche");
>
ident('*');
{}
> ident(`*`);
>
Remarques :
Dans le troisime exemple, le but est excut avec succs, car il s'agit d'un
identificateur quot. Dans le quatrime, c'est un caractre, et donc un chec.
Voir galement :
is_ident
260
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
in_char(C)
Fonction
: Lecture d'un caractre
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
: Fin de fichier inattendue
Description :
Lit un caractre sur l'unit active d'entre. Si une fin de fichier est dtecte,
une erreur est signale et tout se passe comme si on avait fait un close_input.
Exemples :
> in_char(X)
in_char(Y);
a
{ X=`\12`, Y=à` }
> in_char(X);1
{ X=`1` }
>
Voir galement :
in_char', in_ident, in_integer, inl, in_real, in_sentence, in_string, in_term,
next_char, next_char'
PrologIA
261
in_char'(C)
Fonction
: Lecture d'un caractre qui ne soit pas un caractre

de formatage
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
Description :
Lit le premier caractre dont le code ASCII n'est pas infrieur ou gal 32
(caractres de formatage, espace, retour chariot, tabulations, etc) sur
l'unit active d'entre. Si une fin de fichier est dtecte, une erreur est
signale et tout se passe comme si on avait fait un close_input.
Exemples :
> in_char'(C);
a
{ C = à` }
> in_char'(C);
a
{ C = à` }
> in_char'(C)
in_char(C');
a
{ C = à`, C' = `\15` }
>
Voir galement :
in_char, in_ident, in_integer, inl, in_real, in_sentence, in_string, in_term,
262
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
in_ident(I)
Fonction
: Lecture d'un identificateur
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
Description :
Lit un identificateur sur l'unit active d'entre. Si une fin de fichier est
dtecte, une erreur est signale et tout se passe comme si on avait fait un
close_input.
Exemples :
> in_ident(I);
ceci_est_un_identificateur
{ I = ceci_est_un_identificateur }
> in_ident(I);
'->'
{ I = '->' }
> in_ident(I);
[]
>
in_ident(I);
V_ariable
>
Voir galement :
in_char, in_char', in_integer, inl, in_real, in_sentence, in_string, in_term,
PrologIA
263
in_integer(N)
Fonction
: Lecture d'un entier
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
Description :
Lit un entier sur l'unit active d'entre. Si une fin de fichier est dtecte, une
erreur est signale et tout se passe comme si on avait fait un close_input.
Exemples :
> in_integer(N);
124578956810000
{ N = 124578956810000 }
> in_integer(N);
ceci
n'est
manifestement
pas
un
entier
>
in_integer(N)
in_ident(I);
123nous_irons_au_bois
{ N = 123, I = nous_irons_au_bois }
> in_integer(N)
in_real(R);
1213.06
{ N = 1213, R = 6.000000000000000e-02 }
>
Remarque :
in_integer lit un objet ayant la syntaxe d'un entier. Par exemple 12/2 ne sera
pas lu comme l'entier 6, seul l'entier 12 sera pris en compte par in_integer.
Voir galement :
in_char, in_char', in_ident, inl, in_real, in_sentence, in_string, in_term,
264
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
in_real(R)
Fonction
: Lecture d'un flottant
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
Description :
Lit un flottant sur l'unit active d'entre. Si une fin de fichier est dtecte, une
erreur est signale et tout se passe comme si on avait fait un close_input.
Exemples :
> in_real(R);
52.451278952645213E17
{ R = 5.245127895264521e+18 }
> in_real(R);
100.00
{ R = 1.000000000000000e+02 }
> in_real(R);
100
>
Remarque :
in_real lit un objet ayant la syntaxe d'un flottant, l'exclusion des entiers (i.e.
le point dcimal est obligatoire).
Voir galement :
in_char, in_char', in_ident, in_integer, inl, in_sentence, in_string, in_term,
PrologIA
265
in_sentence(T1,T2,T3)
Fonction
: Lecture d'une phrase
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
Description :
Lit une phrase qui se termine par ".", "?" ou "!" et la met sous la forme de trois
listes, respectivement unifies avec T 1 , T 2 et T 3 . T 1 est la liste des units
lexicales (mots, nombres, caractres spciaux, etc) constituant la phrase ; T3
est la liste obtenue en remplaant chaque lettre majuscule apparaissant dans
un lment de T 1 par la lettre minuscule correspondante. T 2 est la mme
chose que T3, mais chaque lment de T3 qui correspond un identificateur
connu dans la famille du prfixe par dfaut du contexte courant a t
remplac par le symbole conventionnel <> pour indiquer ce fait.
Exemple :
> fleuve(Rhone)->;
> in_sentence(T1,T2,T3);
La
vie
est
un
long
fleuve
tranquille.
{ T1 = <"La","vie","est","un","long","fleuve","tranquille",".">,
T2 = <"la","vie","est","un","long",<>,"tranquille",".">,
T3 = <"la","vie","est","un","long","fleuve","tranquille","."> }
>
Voir galement :
in_char, in_char', in_ident, in_integer, inl, in_real, in_string, in_term,
266
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
in_sentence'(T)
Fonction
: Lecture d'une phrase
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
Description :
Lit une phrase qui se termine par ".", "?" ou "!" et la met sous la forme d'une
liste unifie avec T. La listeT contient les units lexicales (mots, nombres,
caractres spciaux, etc) constituant la phrase.
Exemple :
> fleuve(Rhone)->;
> in_sentence(T);
La
vie
est
un
long
fleuve
tranquille.
{ T1 = <"La","vie","est","un","long","fleuve","tranquille","."> }
>
Voir galement :
in_char, in_char', in_ident, in_integer, inl, in_real, in_string, in_term,
PrologIA
267
in_string(S)
Fonction
: Lecture d'une chane quelconque
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
Description :
Lecture d'une chane de caractres sur l'unit d'entre courante. Si une fin de
fichier est dtecte, une erreur est signale et tout se passe comme si on avait
fait un close_input.
Exemples :
> in_string(S);
"ceci
est
une
chaine"
{ S = "ceci est une chaine" }

> in_string(S);
ceci
n'est
pas
une
chaine
>
in_string(S);
"126/45"
{ S = "126/45" }
> in_string(S);
"123\
456"
{ S = "123456" }
>
Voir galement :
in_char, in_char', in_ident, in_integer, inl, in_real, in_sentence, in_term,
268
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
in_term(T)
Fonction
: Lecture d'un terme quelconque
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
: Erreur dans assert ou in_term

Fin de fichier inattendue
Description :
Lecture d'un terme Prolog sur l'entre courante.
Lit la plus grande suite x de caractres qui constituent un terme. Le terme
doit se terminer par un point-virgule, qui n'est pas lu.
Exemples :
> in_term(X);
arbre(-3/4,<a,b>)
in_char(Y);
{ X=arbre(-3/4,<a,b>), Y=`;` }
> in_term(X);
terme1(u)
terme2(v),
<
{ X=terme1(u), u !num }
>
Remarques :
1. Eviter d'inclure des espaces dans tout ce qui n'est pas parenths.
2. Seul le premier terme est pris en compte.
3. Il peut y avoir un systme de contraintes qui, lui, est pris en compte.
Voir galement :
in_char, in_char', in_ident, in_integer, inl, in_real, in_sentence, in_string,
PrologIA
269
inl(S)
Fonction
: Lecture dune ligne
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
Description :
Lit une ligne jusqu'au premier retour chariot (\n) sur l'unit active d'entre.
Le rsultat est donn dans la chaine de caractres S. Si une fin de fichier est
dtecte, une erreur est signale et tout se passe comme si on avait fait un
close_input.
Voir galement :
in_char, in_char', in_ident, in_integer in_real, in_sentence, in_string,
in_term, next_char, next_char'
270
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
input(F)
Fonction
: Dfinition de l'unit d'entre courante
Classe
Catgorie
: Entres/sorties
Paramtres connus
Messages d'erreur

Impossible d'ouvrir le fichier
Description :
L'unit dont le nom est F devient l'unit d'entre courante. Si cette unit ne
figure pas parmi les units ouvertes, alors le fichier correspondant est
recherch et ouvert. Sinon, cette unit passe au sommet de la pile, sauf si elle
s'y trouvait dj, auquel cas le message Fichier dj ouvert est produit.
Un fichier de commandes ouvert par input peut lui-mme contenir une
commande input, la nouvelle unit courante est alors empile au-dessus de la
prcdente.
Voir galement :
input_is, output, output_is
PrologIA
271
input_is(F)
Fonction
: Fournit l'unit d'entre courante
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur

Description :
Pose la contrainte {F = S}, ou S est une chane de caractres dcrivant
l'unit d'entre courante.
Exemples :
> input_is(X);
{ X = "console" }
>
Voir galement :
input, output, output_is
272
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
insert
Fonction
: Insertion de rgles partir de l'unit courante
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
: Erreur de syntaxe. Paquet dj existant

Fin de fichier inattendue
Description :
Cette rgle prdfinie fait basculer le systme dans un mode pour lequel les
rgles lues sur l'unit d'entre courante sont ajoutes au programme en
cours, dans l'ordre dans lequel elles sont lues. Les requtes rencontres sont
ignores. Le mode insert se termine soit quand une rgle vide est trouve,
soit si l'on rencontre la fin du fichier d'entre.
Exemple :
> insert;
conc([],y,y)
->;
conc([e|x],y,[e|z])
->
conc(x,y,z);;
>

ou jusqu' la fin de la ligne sur l'unit console) sont ignors.
insert provoque une erreur lorsque un paquet lu existe dj, alors que
reinsert remplace l'ancien paquet par la nouvelle dfinition.
Voir galement :
insert(F), reinsert, reinsert(F)
PrologIA
273
insert(F)
Fonction
: Insertion de rgles partir d'un fichier
Classe
Catgorie
: Entres/sorties
Paramtres connus
: F, qui doit tre une chane.
Messages d'erreur
: Fin de fichier inattendue.

Erreur de syntaxe. Paquet dj existant
Description :
Cette rgle prdfinie permet d'ajouter des rgles, dans l'ordre dans lequel
elles sont lues partir du fichier F. Les requtes rencontres sont ignores.
La lecture se termine soit lorsque l'on rencontre la fin du fichier, soit
lorsqu'on rencontre une rgle vide, c'est--dire (en syntaxe de base) ne
contenant qu'un ; .
certain nombre de caractres (en principe tous les caractres jusqu' un ;)
sont ignors, puis l'insertion reprend.
insert provoque une erreur lorsque un paquet lu existe dj. Dans ce cas,
Prolog III sort du mode insertion , mais ne ferme pas les fichiers qui
taient ouverts : il continue donc lire le(s) fichier(s) en cours : les rgles sont
insres et les requtes excutes.
Selon que l'on a par ailleurs activ ou non le mode cho (cf. rgle echo) les
rgles sont affiches sur la console au fur et mesure de leur lecture.
Voir galement :
insert, reinsert, reinsert(F)
274
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
integer(N)
Fonction
: Vrifie que I est un nombre entier connu
Classe
Catgorie
: Vrifications de types
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
S'excute avec succs si N reprsente un nombre entier connu. Echoue dans
tous les autres cas.
Exemples :
> integer(0);
{}
> integer(-1234*4567);
{}
> integer(X+2);
>
Voir galement :
num, is_num
PrologIA
275
is_bool(B)
Fonction
: Vrifie que B reprsente une valeur boolenne.
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Vrifie que le terme B reprsente une valeur boolenne, c'est dire que la
contrainte {b !bool} appartient au systme de contraintes courant. Echoue
dans le cas contraire.
Exemples :
> is_bool(1');
{}
> is_bool(B),
{B
!bool};
{B
!boolt};
{ B !bool }
> is_bool(B),
>
Voir galement :
bool
276
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
is_char(C)
Fonction
: Vrifie que C reprsente un caractre
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Vrifie que le terme C reprsente un caractre, c'est dire que la contrainte
{C !char} appartient au systme courant. Echoue dans le cas contraire.
Exemples :
> is_char(`$`);
{}
> is_char(C)
{C
!char};
{ C !char }
> is_char('$')
>
Remarques :
On rappelle que les caractres sont nots entre anti-quotes (voir exemples 1
ci-dessus). C'est la raison pour laquelle l'exemple 3 choue ('$' est un
identificateur quot). Pour vrifier que C est un caractre connu, utiliser
char(C).
Voir galement :
char, string, is_string
PrologIA
277
is_ident(I)
Fonction
: Vrifie que I reprsente un identificateur
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Vrifie que le terme I reprsente un identificateur connu, c'est dire que la
contrainte {I !id} appartient au systme courant. Echoue dans le cas
contraire.
Exemples :
> is_ident(gwendoline);
{}
> is_ident('ceci
en
est
un
aussi');
{}
> is_ident([]);
{}
> is_ident(I)
{I
!idt};
>
Remarques :
Dans le second exemple, 'ceci en est un aussi', est un identificateur quot, et le
but est excut correctement.
Voir galement :
ident
278
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
is_leaf(T)
Fonction
: Vrifie que T reprsente une feuille
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Vrifie que le terme T reprsente un arbre rduit une feuille, c'est dire
que la contrainte {T :: 0} appartient au systme courant. Echoue dans le cas
contraire.
Exemples :
> is_leaf(X[<>]);
{ X::0 }
> is_leaf(B1|B2);
{ B1 !bool, B2 !bool }
> is_leaf(U.V)
{U::2};
>
Voir galement :
bound_tree, bound_tree'
PrologIA
279
is_num(R)
Fonction
: Vrifie que R reprsente un nombre
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Vrifie que le terme R reprsente une valeur numrique, c'est dire que la
contrainte { R !num } appartient au systme courant. Echoue dans le cas
contraire.
Exemples :
> is_num(91252525);
{}
> is_num(3.12e12*X);
{ X !num }
> is_num(X);
>
Voir galement :
num, integer
280
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
is_tuple(U)
Fonction
: Vrifie que U reprsente un tuple
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Vrifie que le terme U reprsente un tuple, c'est dire que la contrainte
{ U !tuple } appartient au systme courant. Echoue dans le cas contraire.
Exemples :
> is_tuple(<A,B,C>);
{}
> is_tuple(U),{X
E[U]};
{ X = E[U] }
> is_tuple("une
chaine
cache
un
tuple
!");
{}
> is_tuple([A,B,C]);
>
Voir galement :
tuple
PrologIA
281
is_univ(T)
Fonction
: Vrifie que le terme T reprsente un arbre non

typ
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Russit si le terme T n'est pas typ caractre, identificateur, numrique,
boolen, tuple ou liste binaire.
Exemples :
> is_univ(X);
{}
> is_univ(E[U]);
{ E :: 0,
U !tuple }
> is_univ(arbre(1,A));
{}
> is_univ((+X)(A,B,C));
{ X !num }
> is_univ(ident);
>
is_univ([1,2,3]);
>
is_univ(2X+4);
>
is_univ(B)
!bool
};
>
282
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
kill_module(S)
Fonction
: Suppression des rgles d'un module
Classe
Catgorie
Paramtres connus
: S
Messages d'erreur
: Pas d'identificateur avec ce prfixe
Description :
Supprime toutes les rgles du module dsign par la chane de caractres S.
Les tableaux du module sont dsallous, et les assignations des
identificateurs du module sont dfaites.
Exemple :
> essai1
->;
> essai2
->;
> assign(essai3,0);
{}
> list
val(essai3,X);
essai1 ->
essai2 ->
{ X = 0 }
> kill_module("");
{}
> list
val(essai3,X);
{ X = essai3 }
>
Voir galement :
new
PrologIA
283
known(T)
Fonction
: Vrifie que T reprsente un terme connu
Classe
Catgorie
: Contrle
Paramtres connus
: T
Messages d'erreur
: Non
Description :
S'excute avec succs si le terme T reprsente un terme suffisamment connu,
c'est dire un arbre :
dont l'tiquette est connue
dont on sait si le nombre de fils est nul ou non
Echoue dans le cas contraire.
T = E[L]
known(L)
known(L)
known(E)
free(T)
known(E)
known(T)
Exemples :
> known(E[<>]);
>
known(arbre[U]);
>
known(arbre[U]),
{U#<>};
{ U=X1.X2, X1::1 }
> known(+X);
>
Voir galement :
free, bound
284
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
known_part(U1, U2, U3)

Fonction
: Extraction de la partie connue d'un tuple
Classe
Catgorie
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
Pose la contrainte {U1 = U2.U3}, o U2 est un tuple form de la plus grande
suite connue des premiers lments de U1. Par connu on entend : avoir
une tiquette connue et savoir si le nombre de fils est nul ou pas
Exemples :
> known_part(U1,U2,U3),
{U1
=<1,2,3>.<4,X,6>};
{ U1 = <1,2,3,4,X,6>,
U2 = <1,2,3,4,X,6>,
U3 = <> }
{U1
=<1,2,3>.<X>.L};
{ U1 = <1,2,3,X>.L,
U2 = <1,2,3,X>,
U3 = L }
{U1
=<1,2,3>.<X>.L,L#<>};
{ U1 = <1,2,3,X>.L,
U2 = <1,2,3,X>.V1,
U3 = V2,
L = V1.V2,
V1::1 }
>
PrologIA
285
lcm(N1, N2, N3)

Fonction
: Calcul du plus petit commun multiple
Classe
Catgorie
Paramtres connus
: N1, N2
Messages d'erreur
: Non
Description :
Pose la contrainte {N3 = N3'}, o N3' est le plus petit commun multiple des
entiers N1 et N2. lcm choue si N1 et N2 ne sont pas connus ou pas entiers.
Exemples :
> lcm(12,18,P);
{ P = 36 }
> lcm(12,-18,P);
{ P = -36 }
>
Voir galement :
ppcm
pgcd, gcd
286
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
line
Fonction
: Saut de ligne
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Ecrit un retour chariot sur l'unit de sortie courante
Exemple :
> line;
{}
>
Remarques :
Cette procdure externe pourra peut-tre se passer de remarques.
Voir galement :
outl, outml
PrologIA
287
list
Fonction
: Impression de rgles
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Liste sur l'unit courante de sortie toutes les rgles du module dtermin par
le prfixe par dfaut du contexte courant.
Remarque :
Les rgles sont d'abord dcodes, puis ensuite listes sur l'unit courante de
sortie. Elles peuvent donc avoir une forme qui diffre lgrement de leur
forme d'origine.
288
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
list(T)
Fonction
Classe
Catgorie
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Argument de mauvais type, Rgle inexistante
Description :
Liste sur la sortie courante le ou les paquets de rgles indiqus par T qui doit
tre un terme de la forme indique ci-dessous (s dsigne une chane de
caractres, i un identificateur, et v une variable) :
s
Tous les paquets de rgles du module correspondant au prfixe s
i
Le(s) paquet(s) de rgles ayant i pour accs.
[i1, i2, in]
Tous le(s) paquet(s) de rgles ayant i 1 pour accs puis le(s)

paquet(s) ayant i2 pour accs, etc
Tous les paquets de rgles du module correspondant au prfixe
par dfaut. v est unifi avec une liste de doublets de la forme
<ident, arit>.
PrologIA
289
list(<I, A>)
Fonction
Classe
Catgorie
Paramtres connus
: Voir ci-aprs
Messages d'erreur
Description :
Liste le(s) paquet(s) de rgles de nom I et d'arit A du module dtermin
par le prfixe par dfaut du contexte courant (V dsigne une variable).
<I, A> Toutes les rgles composant le paquet de nom i et d'arit A.
<I, V> Toutes les rgles dont l'accs est I, quelque soit leur arit.
<V, A> Toutes les rgles d'arit A appartenant au module ayant le
prfixe par dfaut du contexte de lecture et criture courant dont
l'arit est A.
290
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
list([<I1, A1>, , <In, An>])

Fonction
Classe
Catgorie
Paramtres connus
: Voir ci-aprs
Messages d'erreur
Description :
Liste chacun des paquets de rgles dsigns par les lments de la liste de la
mme faon que list(<A,I>).
PrologIA
291
list(<I, A>,N)
Fonction
Classe
Catgorie
Paramtres connus
: Voir ci-aprs
Messages d'erreur
Description :
Liste sur l'unit courante de sortie la rgle numro N du paquet
correspondant au nom I et l'arit (nombre d'arguments) A. Chacun des
paramtres I, A, ou N peut tre reprsent par une variable.
292
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
list_string(L, S)
Fonction
: Conversion liste/chane
Classe
Catgorie
: Conversions
Paramtres connus
: L
Messages d'erreur
: Non
Description :
Pose la contrainte {S = L'}, o L' est une chane compose des caractres qui
forment la liste L.
Exemple :
> list_string([`H`,è`,`l`,`l`,ò`],
X);
{ X = "Hello" }
>
Voir galement :
split
PrologIA
293
list_tuple(L, U)
Fonction
: Conversion liste/tuple
Classe
Catgorie
: Conversions
Paramtres connus
: L
Messages d'erreur
: Non
Description :
Pose la contrainte {S = U'}, o U' est un tuple compose des lments qui
forment la liste L.
Exemple :
> list_tuple([1/12,aaa,1',"rhino"],
{ X = <1/12,aaa,1',"rhino"> }
> list_tuple([1,[2,[3]]],
{ X = <1,[2,[3]]> }
>
Voir galement :
split
294
PrologIA
X);
X);
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
lower_bound(R1, R2)
Fonction
: Borne infrieure d'une expression numrique
Classe
Catgorie
Paramtres connus
: R1
Messages d'erreur
: Expression non borne (Erreur 59)

Arguments de mauvais type (Erreur 60)
Description :
Calcule la borne infrieure m (i.e. le plus grand des minorants) de R1 et
ajoute au systme de contraintes courant la contrainte R2 = m .
Provoque une erreur lorsque R1 ne peut tre typ numrique (Erreur 60) ou
encore lorsque l'expression numrique R1 n'est pas borne infrieurement
(Erreur 59).
Exemples :
> lower_bound(R,R'),{R
2X+Y,
X>=2,
Y>3};
2X+Y,
X>=2};
{ R' = 7, R = ... }
> lower_bound(R,R'),{R
Err 59 : Expression non bornee lors d'un calcul d'extremum

> lower_bound(R,R),{R
2X+Y,
X>=2,
Y>3};
>
Remarques :
On rappelle que, dans l'ensemble des rels, toute partie non vide qui possde
un minorant admet une borne infrieure. On veillera donc au pralable
borner R1 infrieurement.
On notera galement que l'excution de lower_bound(R1, R2) ne pose pas la
contrainte R1 = R2.
On pourra utiliser la primitive block pour la rcupration des erreurs.
Voir galement :
upper_bound, maximum, minimum, maximize, minimize
PrologIA
295 mxxxiii
upper_bound(R1, R2)
Fonction
: Borne suprieure d'une expression numrique
Classe
Catgorie
Paramtres connus
: R1
Messages d'erreur

Description :
Calcule la borne suprieure m (i.e. le plus petit des majorants) de R1 et ajoute
au systme de contraintes courant la contrainte R2 = m .
encore lorsque l'expression numrique R1 n'est pas borne suprieurement
(Erreur 59).
Exemples :
> upper_bound(R,R'),{R
2X+Y,
X<=2,
Y<3};
2X+Y,
X<=2};
{ R' = 7, R = ... }
> upper_bound(R,R'),{R

> upper_bound(R,R),{R
2X+Y,
X<=2,
Y<3};
>
Remarques :
On rappelle que, dans l'ensemble des rels, toute partie non vide qui possde
un majorant admet une borne suprieure. On veillera donc au pralable
borner R1 suprieurement.
On notera galement que l'excution de upper_bound(R1, R2) ne pose pas la
contrainte R1 = R2.
Voir galement :
lower_bound, maximum, minimum, maximize, minimize
295 mxxxiv
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
maximum(R1, R2)
Fonction
: Maximum d'une expression numrique
Classe
Catgorie
Paramtres connus
: R1
Messages d'erreur

Description :
Calcule le maximum m de R1 et ajoute au systme de contraintes courant la
contrainte R2 = m .
Echoue lorsque R1 est born suprieurement sans pour autant avoir un
maximum (la borne suprieure ne peut tre atteinte par R1).
encore lorsque l'expression numrique R1 n'est pas borne suprieurement
(Erreur 59).
Exemples :
> maximum(R,R'),{R
2X+Y,
X<=2,
2X+Y,
X<=2};
Y<=3};
{ R' = 7, R = ... }
> maximum(R,R'),{R

> maximum(R,R'),{R
2X+Y,
X<=2,
Y<3};
>
Remarque :
Voir galement :
minimum, lower_bound, upper_bound, maximize, minimize
PrologIA
295 mxxxv
maximize(R)
Fonction
: Maximiser une expression numrique
Classe
Catgorie
Paramtres connus
: R
Messages d'erreur

Argument de mauvais type (Erreur 60)
Description :
Equivalent (mais plus performant) maximum(R, R)
Calcule le maximum m de R et ajoute au systme de contraintes courant la
contrainte R = m .
Echoue lorsque R est born suprieurement sans que le maximum puisse
tre atteint par R.
Provoque une erreur lorsque R ne peut tre typ numrique (Erreur 60) ou
encore lorsque l'expression numrique R n'est pas borne suprieurement
(Erreur 59).
Exemples :
> maximize(R),{R
2X+Y,
X<=2,
Y<=3};
{ R = 7 , X = 2 , Y = 3 }
> maximize(R);
> maximize(R),{R
!numt,
R::2};
Err 60 : Argument de mauvais type pour un calcul d'extremum

> maximize(R),{R
2X+Y,
X<=2,
Y<3};
>
Remarque :
Voir galement :
minimize, maximum, minimum, lower_bound, upper_bound
295 mxxxvi
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
minimum(R1, R2)
Fonction
: Minimum d'une expression numrique
Classe
Catgorie
Paramtres connus
: R1
Messages d'erreur

Description :
Calcule le minimum m de R1 et ajoute au systme de contraintes courant la
contrainte R2 = m .
Echoue lorsque R1 est born infrieurement sans pour autant avoir un
minimum (la borne infrieure ne peut tre atteinte par R1).
encore lorsque l'expression numrique R1 n'est pas borne infrieurement
(Erreur 59).
Exemples :
> minimum(R,R'),{R
2X+Y,
X>=2,
2X+Y,
X>=2};
Y>=3};
{ R' = 7, R = ... }
> maximum(R,R'),{R

> maximum(R,R'),{R
2X+Y,
X>=2,
Y>3};
>
Remarque :
Voir galement :
maximum, lower_bound, upper_bound, maximize, minimize
PrologIA
295 v
minimize(R)
Fonction
: Minimiser une expression numrique
Classe
Catgorie
Paramtres connus
: R
Messages d'erreur

Argument de mauvais type (Erreur 60)
Description :
Equivalent (mais en plus performant) minimum(R, R) .
Calcule le minimum m de R et ajoute au systme de contraintes courant la
contrainte R = m .
Echoue lorsque R est born infrieurement sans que le minimum puisse tre
atteint par R.
Provoque une erreur lorsque R ne peut tre typ numrique (Erreur 60) ou
encore lorsque l'expression numrique R n'est pas borne infrieurement
(Erreur 59).
Exemples :
> minimize(R),{R
2X+Y,
X>=2,
Y>=3};
{ R = 7 , X = 2 , Y = 3 }
> minimize(R);
> minimize(R),{R
!numt,
R::2};
Err 60 : Argument de mauvais type pour un calcul d'extremum

> minimize(R),{R
2X+Y,
X>=2,
Y>3};
>
Remarque :
Voir galement :
maximize, maximum, minimum, lower_bound, upper_bound
296
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
mod(N1, N2, N3)

Fonction
: Reste de la division entire
Classe
Catgorie
Paramtres connus
: N1 et N2 entier, N2 non nul
Messages d'erreur
: Division par zro
Description :
Pose la contrainte {N3 = R}, o R est le reste de la division entire de la valeur
absolue de N1 par la valeur absolue de N2. On prendra garde ne pas
confondre le prdicat avec la fonction valuable du mme nom (voir la rgle
prdfinie val).
Exemples :
> mod(9,2,R);
{ N = 1 }
> mod(7,N1,N2);
>
Voir galement :
div
trunc
PrologIA
297
Aociation
module(P1, S1, S2, P2)

Fonction
: Dclaration de dbut de module
Classe
Catgorie
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
Dfinit toutes les rgles comprises entre les appels des primitives module et
end_module comme dcrivant un mme module. On se reportera, pour ces
notions assez complexes au chapitre "Environnement". On rappelle
cependant pour mmoire que P1 est le prfixe du module, S1, la suite
explicite, S2, la suite implicite, et P2 le prfixe par dfaut.
On peut utiliser module avec seulement le premier, les deux premiers ou les
trois premiers arguments dans les conditions dcrites prcisment au
chapitre "Environnement" :
module(P)
module(P, S)
est quivalent
est quivalent
module(P, [], ["sys"], P)

module(P, S, ["sys"], P)
module(P, S, I)
est quivalent
module(P, S,
Voir galement :
end_module
298
PrologIA
Prolog
HERITAGE
I,
P)
Aociation
Prolog
HERITAGE
mult(N1, N2, N3)

Fonction
: Multiplication avec retardement
Classe
Catgorie
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
Pose la contrainte {N3 = N1*N2} avec, s'il y a lieu, les retardements
ncessaires.
Exemples :
> mult(X,Y,Z);
{ Z = X * Y }
>
Voir galement :
bound_mult
PrologIA
299
new
Fonction
: Suppression des rgles d'un module
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Supprime toutes les rgles du module dtermin par le prfixe par dfaut du
contexte courant. Contrairement kill_module les tableaux du module ne
sont pas dsallous, et les assignations des identificateurs du module ne sont
pas dfaites.
Exemple :
> essai1
->;
> essai2
->;
> assign(essai3,10);
{}
> list
val(essai3,X);
essai1 ->
essai2 ->
{ X = 10 }
> new;
{}
> list
val(essai3,X);
{ X = 10 }
>
Voir galement :
kill_module
300
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
next_char(C)
Fonction
: Lecture anticipe d'un caractre
Classe
Catgorie
: Entre/Sorties
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Pose la contrainte {C = C'}, o C' est le prochain caractre rencontr sur
l'unit d'entre courante sans toutefois le lire effectivement.
Voir galement :
in_term, next_char'
PrologIA
301
next_char'(C)
Fonction
: Lecture anticipe d'un caractre qui ne soit pas un

caractre de formatage
Classe
Catgorie
: Entre/Sorties
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Pose la contrainte {C = C'}, o C' est le prochain caractre rencontr qui ne
soit pas un caractre de formatage sur l'unit d'entre courante sans
toutefois le lire effectivement. En fait, tous les caractres dont le code ASCII
est infrieur ou gal 32 sont ignors.
Voir galement :
in_term, next_char
302
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
no_debug
Fonction
: Annule le mode debug
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Annule l'effet des primitives debug ou de tout passage en mode debug
provoqu par l'utilisation de la primitive set_config.
Voir galement :
debug, trace, no_trace,
PrologIA
303
no_echo
Fonction
: Annule l'cho sur la console
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Annule l'effet de la primitive echo.
Voir galement :
echo
303 i
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
no_spy(<I, N>)
no_spy(S)
Fonction
: Annule l'espionnage de paquets de rgles
Classe
Catgorie
: Environnement
Paramtres connus
: S, au moins un parmi I et N
Message d'erreur
: Module inexistant
Description :
Enlve tout point-espion install sur un ou plusieurs paquets de rgles.
Dans la premire forme, I dsigne l'identificateur de paquet et N l'arit de ce
paquet, et au moins l'une des deux informations doit tre connue l'appel.
Un chec survient dans le cas contraire.
Dans la deuxime forme, S est un nom de module sous la forme d'une
chane de caractre. Toutes les rgles du module S sont alors concernes.
Provoque une erreur s'il n'existe aucune rgle de prfixe S.
Prolog III pour de plus amples informations.
Voir galement :
spy
debug, no_debug
PrologIA
303 ii
no_trace
Fonction
: Annule la trace
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Annule l'effet des primitives trace ou de toute trace provoque par
l'utilisation de la primitive set_config. Revient au mode normal d'excution
d'un programme Prolog III.
Voir galement :
trace, debug, no_debug, suspend_trace, resume_trace
304
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
not(T)
Fonction
: Ngation par chec
Classe
Catgorie
: Contrle
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
Ralise une ngation par chec. Voici la rgle not(T) in extenso :
not(P) -> P ! fail;
not(P) ->;
Et en syntaxe Edinburgh :
not(P) :- P, !, fail .
not(P) .
Remarque :
Puisque not lance un but, son comportement peut dpendre du positionnement du paramtre "undefined_rule" de la primitive set_config , si on
est susceptible de lancer des buts non-dfinis.
PrologIA
305
num(R)
Fonction
: vrifie que R reprsente un nombre connu
Classe
Catgorie
Paramtres connus
: R
Messages d'erreur
: Non
Description :
Cette rgle prdfinie vrifie que R est un terme reprsentant une valeur
numrique connue. Si ce n'est pas le cas num(R) choue.
Exemples :
> num(1960);
{}
> num(3X+2);
>
num(X),{X>0,Y>0,X+Y=12,2X+4Y=34};
{ X = 7, Y = 5 }
>
Remarques :
Cette rgle prdfinie ne teste pas seulement que R reprsente une valeur
numrique (la rgle prdfinie is_num(R) effectue cette vrification).
Le terme R peut tre contraint reprsenter une valeur numrique connue
dans le cas o, pour toutes les solutions du systme de contraintes courant, R
reprsente la mme valeur (voir le troisime exemple ci-dessus).
306
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
numden(R, N1, N2)

Fonction
: Calcul du numrateur et du dnominateur d'un

rationnel
Classe
Catgorie
Paramtres connus
: R
Messages d'erreur
: Non
Description :
Pose les contraintes {N1 = N1', N2 = N2'}, o N1' est le numrateur de R, et
N2' le dnominateur de R. Echoue si R n'est pas connu.
Exemples :
> numden(17,N1,N2);
{ N1 = 17,N2 = 1 }
> numden(9/6,N1,N2);
{ N1 = 3,N2 = 2 }
> numden(R,14,2);
>
PrologIA
307
out(T)
Fonction
: Ecriture de termes
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Ecrit le terme T sur l'unit de sortie courante, sans les contraintes associes
aux variables qui peuvent figurer dans ce terme.
Voir galement :
outc, outl, outm, outml
308
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
outc(T)
Fonction
: Ecriture de termes avec contraintes
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Ecrit le terme T sur l'unit de sortie courante, avec les contraintes associes
aux variables qui peuvent figurer dans ce terme.
Voir galement :
out, outl, outm, outml
PrologIA
309
outl(T)
Fonction
: Ecriture de termes avec <CR>
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Ecrit le terme T sur l'unit de sortie courante, sans les contraintes associes
aux variables qui peuvent figurer dans ce terme, suivis d'un retour-chariot.
Voir galement :
out, outc, outm, outml
310
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
outm(S1, S2, , SN)

Fonction
: Ecriture de chanes
Classe
Catgorie
: Entres/sorties
Paramtres connus
: S1, S2, , SN
Messages d'erreur
: Argument de mauvais type
Description :
Ecrit les chanes S1, S2, , SN (N 1) sur l'unit de sortie courante. Une
erreur est signale si une de ces chanes n'est pas connue.
Voir galement :
out, outc, outl, outml
PrologIA
311
outml(S1, S2, , SN)

Fonction
: Ecriture de chanes avec <CR>
Classe
Catgorie
: Entres/sorties
Paramtres connus
: S1, S2, , SN
Messages d'erreur
Description :
Ecrit les chanes S1, S2, , SN (N 1) sur l'unit de sortie courante, suivies
d'un retour chariot. Une erreur est signale si une de ces chanes n'est pas
connue.
Voir galement :
out, outc, outl, outm
312
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
output(F)
Fonction
: Dfinition de l'unit de sortie courante
Classe
Catgorie
: Entres/sorties
Paramtres connus
: F, qui doit tre une chane.
Messages d'erreur
: Non
Description :
L'unit dont le nom est F devient l'unit de sortie courante. Si cette unit ne
figure pas parmi les units ouvertes, alors un fichier ayant le nom F est cre.
Sinon, cette unit passe au sommet de la pile, sauf si elle s'y trouvait dj.
Voir galement :
output_is, close_output, input
PrologIA
313
output_is(F)
Fonction
: Fournit l'unit de sortie courante
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Pose la contrainte {F = S}, ou S est une chane de caractres dcrivant l'unit
de sortie courante.
Exemples :
> output_is(X);
{ X = "console" }
>
Voir galement :
input, input_is, output
314
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
particular_value(R1, R2)
Fonction
: Recherche d'une solution particulire
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Pose la contrainte {R2 = R1'}, o R1' est une valeur quelconque du terme R1
qui satisfait l'ensemble de contraintes courant.
Exemples :
> particular_value(X,Y)
{X<=9,X>=9};
{ X = 9, Y = 9 }
particular_value(X,
>
Y),{X<9};
{ X = 9-S$1,
S$1 > 0,
Y = 9 }
> particular_value(X,
X),{X<9};
>
Remarques :
Deux cas peuvent se prsenter :
Soit la valeur de R1 qui satisfait le systme de contraintes courant est
unique. R2 reprsente alors cette valeur.
Soit l'ensemble des valeurs possibles qui satisfont le systme de
contraintes courant est infini. La valeur particulire choisie est alors
indpendante de la contrainte , et des contraintes d'ingalits strictes.
On est cependant assur qu'une valeur trs proche de celle exhibe
existe.
PrologIA
315
pgcd(N1, N2, N3)

Fonction
: Calcul du plus grand commun diviseur
Classe
Catgorie
Paramtres connus
: N1, N2
Messages d'erreur
: Non
Description :
Pose la contrainte {N3 = N3'}, o N3' est le plus grand commun diviseur des
entiers N1 et N2. Le plus grand commun diviseur calcul ne tient pas compte
du signe. pgcd choue si N1 et N2 ne sont pas connus ou pas entiers.
Exemples :
> pgcd(24,16,P);
{ P = 8 }
> pgcd(24,-16,P);
{ P = 8 }
>
Voir galement :
gcd
ppcm, lcm
316
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
ppcm(N1, N2, N3)

Fonction
: Calcul du plus petit commun multiple
Classe
Catgorie
Paramtres connus
: N1, N2
Messages d'erreur
: Non
Description :
Pose la contrainte {N3 = N3'}, o N3' est le plus petit commun multiple des
entiers N1 et N2. ppcm choue si N1 et N2 ne sont pas connus ou pas entiers.
Exemples :
> ppcm(12,18,P);
{ P = 36 }
> ppcm(12,-18,P);
{ P = -36 }
>
Voir galement :
lcm
pgcd, gcd
PrologIA
317
predefined(T)
Fonction
: Teste si le terme T est une rgle prdfinie ou un

prdicat valuable
Classe
Catgorie
: Contrle
Paramtres connus
: T
Messages d'erreur
: Non
Description :
S'efface avec succs si T est un terme correspondant l'appel d'une rgle
prdfinie ou un prdicat valuable.
Exemples :
> predefined(list);
{}
> predefined(predefined[U]);
{ U !tuple, U :: 1 }
> predefined(myrule);
>
318
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
prologIII
Fonction
: Bascule en syntaxe Prolog III
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Bascule en syntaxe Prolog III si l'on se trouve en syntaxe Edimbourg. Se
comporte en fait exactement de la mme manire que l'appel de la primitive
set_config("syntax","Prolog III") .
Voir galement :
edinburgh, set_config, set_configuration
PrologIA
319
quit
Fonction
: Quitter Prolog III
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Fait quitter Prolog III sans rien sauver.
Voir galement :
quit(N)
320
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
quit(N)
Fonction
: Quitter Prolog III
Classe
Catgorie
: Environnement
Paramtres connus
: N
Messages d'erreur
: Non
Description :
Fait quitter Prolog III sans rien sauver. Si N a pour valeur 0, cette valeur est
convertie dans le code correspondant pas d'erreur pour le systme
d'exploitation; les autres valeurs de N ne sont pas converties. Ce code est
ensuite envoy au systme d'exploitation titre de statut de terminaison.
Remarques :
La forme, quit, quivaut quit(0).
Voir galement :
quit
PrologIA
321
rational(R)
Fonction
: Vrifie que R est un nombre rationnel connu
Classe
Catgorie
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
S'excute avec succs si R reprsente une valeur rationnelle non entire et
connue. Echoue dans tous les autres cas.
Exemples :
> rational(3004/1960);
{}
> rational(31.897);
>
rational(6/3);
>
rational(X);
>
322
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
real(F)
Fonction
: Vrifie que R est un nombre flottant connu
Classe
Catgorie
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
S'excute avec succs si F reprsente un nombre flottant connu. Echoue dans
tous les autres cas.
Exemples :
> real(3004.1960e20);
{}
>
real(31/897);
>
real(1.0);
{}
> real(X+2.0);
>
PrologIA
323
redef_array(I,N)
Fonction
: Modifie la taille d'un tableau
Classe
Catgorie
Paramtres connus
: I, N
Messages d'erreur
: Voir ci-aprs
Description :
Modifie la taille alloue un tableau cr par la primitive def_array.
Exemples :
> def_array(tab,100)
assign(tab(50),3);
{}
> val(tab(50),X);
{ X = 3 }
> redef_array(tab,200)
assign(tab(154),2);
{}
> val(tab(154),X);
{ X = 2 }
> redef_array(tab,40);
{}
> val(tab(50),X);
>
Voir galement :
assign, def_array, undef_array, val
324
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
reinsert
Fonction
: Insertion de rgles partir de l'unit d'entre
Classe
Catgorie
: Entres/sorties
Paramtres connus
: Aucun
Messages d'erreur
: Voir ci-aprs
Description :
Cette rgle prdfinie fait basculer le systme dans un mode pour lequel les
rgles lues sur l'unit d'entre courante sont ajoutes au programme en
cours, dans l'ordre dans lequel elles sont lues. Le mode reinsert se termine
soit quand une rgle vide est trouve, soit si l'on rencontre la fin du fichier
d'entre.
Exemple :
> reinsert;
conc([],y,y)
->;
conc([e|x],y,[e|z])
->
conc(x,y,z);;
>

ou jusqu' la fin de la ligne sur l'unit console) sont ignors. Contrairement
la primitive insert, reinsert remplace un paquet dj existant par sa nouvelle
dfinition. Attention ceci peut tre dangereux : par exemple une erreur sur
une rgle l'intrieur d'un paquet peut provoquer, avec reinsert,
l'crasement des rgles prcdentes quand on continuera lire le paquet.
Voir galement :
insert
PrologIA
325
reinsert(F)
Fonction
: Insertion de rgles partir d'un fichier
Classe
Catgorie
: Entres/sorties
Paramtres connus
: F
Messages d'erreur
: Voir ci-aprs
Description :
Insre des rgles partir du fichier de nom F. La seule diffrence avec le
prdicat insert est que si un paquet existe dj, reinsert remplace l'ancien
paquet par sa nouvelle dfinition. Attention ceci peut tre dangereux : une
erreur sur le nombre d'argument d'une rgle l'intrieur d'un paquet,
provoquera avec reinsert l'crasement des rgles prcdentes quand on
continuera lire le paquet.
Voir galement :
insert
326
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
reload(F, L)
Fonction
: Chargement de modules sauvs
Classe
Catgorie
: Entres/sorties
Paramtres connus
: F, L
Messages d'erreur
: Chane attendue, Argument de mauvais type
Description :
Chargement de modules sauvs. F (chane de caractres) est un nom de
fichier et L est une liste de substitution de prfixes . Cette commande
produit le chargement des modules sauvegards dans le fichier indiqu;
celui-ci doit avoir t produit par une des commandes save ou exit.
L est une liste de la forme [ <pref1 , subs1> , , <prefk , subsk> ] qui spcifie le
renommage des modules chargs : pref1 sera substitu par subs1, pref2 par
subs2, etc
Exemple :
> reload("myfile.mo",[<"data","donnees">]);
{}
>
Remarques :
Une tentative de chargement d'un lment (rgle ou tableaux) dj connu
donne lieu au remplacement de l'ancienne version par la nouvelle.
Les modules sauvegards sont sous forme de code objet (et non texte).
PrologIA
327
remove_implicit(S1, S2)
Fonction
: Modification de contexte
Classe
Catgorie
Paramtres connus
: S1, S2
Messages d'erreur
: Voir ci-aprs
Description :
Enlve l'identificateur ayant le nom abrg S2 de la partie ferme de la
famille correspondant au prfixe S1.
Voir galement :
add_implicit, dictionary
module, end_module
328
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
repeat
Fonction
: Boucles
Classe
Catgorie
: Contrle
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Il s'agit simplement du prdicat suivant :
repeat -> ;
repeat -> repeat;
PrologIA
329
reset_cpu_time
Fonction
: Initialisation du chronomtre
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Rinitialise le chronomtre.
Voir galement :
cpu_time
330
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
resume_trace
Fonction
: Relance la trace si celle-ci a t inhibe par la

primitive suspend_trace
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Relance la trace, si celle-ci, active, a t inhibe par la primitive suspend_trace.
La runion de ces deux primitives est extrmement utile lorsque l'on dsire
supprimer la trace de certains prdicats particuliers. Il suffit alors d'encadrer
ces prdicats par les primitives suspend_trace et resume_trace. Si aucune trace
n'est active, les appels suspend_trace et resume_trace s'excutent sans actions
particulires.
Exemples :
> essai ->
suspend_trace
outml("sans trace")
resume_trace ;
> trace line essai line;
line
essai = essai
suspend_trace
sans trace
line
{}
> no_trace;
no_trace
{}
> essai;
sans trace
{}
>
Voir galement :
trace, no_trace, set_config, suspend_trace
PrologIA
331
retract(T,Q)
Fonction
: Suppression des rgles correspondant un

modle donn.
Classe
Catgorie
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
Recherche et supprime les rgles dont la tte s'unifie avec T et dont les buts
s'unifient avec les lments de la liste Q. Le terme T doit cependant tre
suffisamment connu pour qu'il n'existe aucune ambigut quant au nom des
rgles vises.
Exemples :
toto(aa) ->;
toto(bb) ->;
toto(x) -> titi(x,y) tutu(z,y);
retract(toto(X),[]);
{ X = aa }
{ X = bb }
> list;
toto(x) ->
titi(x,y)
tutu(z,y) ;
{}
> retract(toto(aa),[titi[U],
tutu[V]]);
{ U = <aa,y_8>, V = <z_8,y_8> }
> list;
{}
>
>
>
>
>
Voir galement :
suppress, assert, list, rule
332
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
rule(T,Q)
Fonction
: Recherche de rgles
Classe
Catgorie
Paramtres connus
: T
Messages d'erreur
: Rgle inexistante
Description :
Recherche des rgles correspondant un modle donn. Cette primitive
s'efface autant de fois qu'il existe de rgles dont la tte s'unifie avec T et la
queue avec Q. Si une telle rgle n'existe pas, alors rule(T,Q) produit une
erreur.
Exemple :
> list;
conc([],L,L)->;
conc([A/L],L',[A/L'']) ->
conc(L,L',L'');
> rule(conc(X,Y,Z),Q);
{ X = [], Z = Y, Q = [] }
{ X = [v149/v150], Z = [v149/v151],
Q = [conc(v150,y,v151)] }
> rule(concatener(X,Y,Z),Q);
>
Remarque :
T doit tre de type !idt.
PrologIA
333
rule(N,T,Q)
Fonction
Classe
Catgorie
Paramtres connus
: T
Messages d'erreur
: Rgle inexistante
Description :
recherche la rgle dont la tte s'unifie avec T, la queue avec Q et qui est de
rang N dans son paquet. Si une telle rgle n'existe pas, alors rule(N,T,Q)
produit une erreur.
Exemple :
> list;
conc([],L,L)->;
conc([A/L],L',[A/L'']) ->
conc(L,L',L'');
> rule(2,conc(X,Y,Z),Q);
{ X = [v149/v150], Z = [v149/v151],
Q = [conc(v150,y,v151)] }
>
Remarque :
T doit tre de type !idt.
334
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
rule(N,A,T,Q)
Fonction
Classe
Catgorie
Paramtres connus
: A
Messages d'erreur
: Rgle inexistante
Description :
s'efface autant de fois qu'il existe de rgles dont la tte ou encore
l'identificateur de tte s'unifie avec A. On peut affiner le modle en prcisant
la tte T, la queue Q et le rang dans le paquet N. Si une telle rgle n'existe
pas, alors rule(N,A,T,Q) produit une erreur.
Exemple :
> list;
conc([],L,L)->;
conc([A/L],L',[A/L'']) ->
conc(L,L',L'');
> rule(1,conc,T,Q);
{ T = conc([],v149,v149), Q = [] }
> rule(2,conc(X,Y,Z),T,Q);
{ X = [v149/v150], Z = [v149/v151],
T = conc([v149/v150],y,[v149/v151])
Q = [conc(v150,y,v151)] }
>
Remarque :
A doit tre de type !idt.
PrologIA
335
rule_nb(<I,A>,N)
Fonction
: Nombre de rgles d'un paquet
Classe
Catgorie
Paramtres connus
: I,A
Messages d'erreur
: Rgle inexistante
Description :
Compte les rgles du paquet dtermin par l'identificateur I et l'arit A.
N est alors unifi avec le nombre de rgles de ce paquet. Echoue si I et A ne
sont pas connus ou si le paquet n'existe pas.
Exemple :
> list;
conc([],L,L)->;
conc([A/L],L',[A/L'']) ->
conc(L,L',L'');
> rule_nb(<conc,3>,N);
{ N = 2 }
>
Voir galement :
rule, current_predicate
336
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
save
Fonction
: Sauvegarde de modules
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Sauvegarde de modules. Cette commande produit la sauvegarde dans le
fichier de nom prolog3.psv de tous les lments (rgles, variables statiques
et tableaux) de tous les modules.
Remarque :
charg dans un autre environnement Prolog III au moyen de la commande
reload .
Voir galement :
reload
exit, quit
PrologIA
337
save(S)
Fonction
Classe
Catgorie
: Environnement
Paramtres connus
: S
Messages d'erreur
: Chane attendue
Description :
Sauvegarde de modules. Cette commande produit la sauvegarde dans le
fichier de nom S (chane de caractres) de tous les lments (rgles, variables
statiques et tableaux) de tous les modules.
Remarque :
charg dans un autre environnement Prolog au moyen de la commande
reload .
Voir galement :
reload
exit, quit
338
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
save(L,S)
Fonction
Classe
Catgorie
: Environnement
Paramtres connus
: L,S
Messages d'erreur
: Chane attendue, Fin de liste attendue, Prfixe

inexistant
Description :
Sauvegarde de modules. S est un nom de fichier (chane de caractres) et L
une liste de prfixes (chanes de caractres). Cette commande produit la
sauvegarde dans le fichier indiqu de tous les lments (rgles, variables
statiques et tableaux) des modules correspondant aux prfixes donns dans
la liste L.
Exemple:
> save(["","data","dict"],
"myfile.mo");
{}
>
Remarque :
charg dans un autre environnement Prolog III au moyen de la commande
reload . Ce n'est donc pas un fichier texte et il ne faut utiliser ni insert ni input
avec ce fichier.
Voir galement :
reload
exit, quit
PrologIA
339
Aociation
set_config(S, V)
Fonction
: Modification de certains paramtres
Classe
Catgorie
: Environnement
Paramtres connus
: S, V
Messages d'erreur
: Non
Description :
Cette primitive permet de spcifier le comportement de Prolog III pour les
points indiqus ci-dessous. En regard de chaque point, on indique la chane
fournir comme premier paramtre :
le mode de fonctionnement de l'interprteur
l'impression des termes sous debugger
l'cho
l'excution d'un prdicat non dfini
la gestion de l'interruption de programme
la syntaxe utilise
"machine_mode"
"tracemode"
"echo"
"undefined_rule"
"interrupt_is_error"
"syntax"
la taille maximale d'une ligne pour l'affichage

le format numrique pour l'affichage
"tty_wrap"
"format_out_num"
le format d'affichage des flottants

le nombre de chiffres aprs le point dcimal
l'erreur relative dans les calculs sur les flottants
"format_float"
"format_decimal"
"epsilon_float"
les statistiques lies l'excution
"statistics"
Voici prsent les valeurs possibles pour chacun de ces paramtres, ainsi
que les valeurs par dfaut :
machine_mode :
0:
1:
2, 3 :
Fonctionnement normal (sans debugger ni trace).

Fonctionnement en mode trace.
Fonctionnement en mode debugger.
Valeur par dfaut : 0
340
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
tracemode :
1 : Trace de niveau 1 : affichage du nom du prdicat.
2:
3:
Trace de niveau 2 : affichage du nom du prdicat et de ses arguments.

Trace de niveau 3 : affichage du nom du prdicat, de ses arguments
et du systme de contraintes relatif aux variables qui interviennent
dans les arguments.

echo :
0:
1:
Pas d'cho.
Affichage sur l'unit courante de sortie de toutes les rgles ou
requtes lues sur l'unit courante d'entre. Ces rgles, lorsqu'elles

sont valides, sont d'abord codes sous une forme canonique, puis
ensuite dcodes et listes sur la sortie courante.
undefined_rule :
Dtermine le comportement de l'interprteur lors de
l'appel d'un but non excutable :
"fail" :
"warning" :
"error" :
Echec Prolog sans message d'avertissement ni erreur.

Echec Prolog, avec message d'avertissement (paquet non
dfini ou but non excutable).
Produit une erreur (Accs non dfini).
Valeur par dfaut : "warning"

interrupt_is_error :
0:
L'interruption de programme ( <Ctrl-C> sur certaines

machines) n'est pas traite comme une erreur Prolog. Un
dialogue, dcrit dans le manuel d'utilisation, est prsent
l'utilisateur, et lui permet de continuer, de stopper, de
tracer l'excution du programme ou de sortir de la
1:
session Prolog.
L'interruption de programme gnre une erreur Prolog,
avec le message d'erreur : Err 16: Interruption
utilisateur. Dans ce cas l'interruption peut tre intercepte par le mcanisme de block.
PrologIA
341

syntax :
"Prolog III" :
Mode syntaxique de type Prolog III (II+).
"Edinburgh" :
Mode syntaxique de type Edimbourg.
Valeur par dfaut : "Prolog III"
Remarque :
Il est possible de se retrouver directement sous le mode syntaxique
Edimbourg, pour chaque session Prolog III. Pour cela, il suffit une premire
fois de positionner l'option "syntax" "Edinburgh", puis de sauver l'tat
courant l'aide de la commande exit. On invitera chaque utilisateur
renommer auparavant le fichier initial3.psv afin d'en conserver une version
l'tat d'origine.
tty_wrap :
Un entier compris entre 10 et 4000 reprsentant la longueur maximale
admise pour l'criture d'une ligne sur l'unit de sortie courante.
format_float :
Une chane reprsentant un format d'entre/sortie accept par la fonction
printf() du langage C. Cette chane doit de plus commencer par le
caractre % et contenir moins de 19 caractres.
Valeur par dfaut : "%.15le"
format_out_num :
"Fnormal" :
"Fexact" :
Affichage des rationnels en prcision infinie, et des flottants en notation scientifique.

Affichage des rationnels en prcision infinie, les flottants
"Fdecimal" :
"Ffloat" :
sont convertis en rationnels.

Affichage sous forme dcimale.
Affichage en notation scientifique.
"Fint+fract" :
Affichage sous la forme partie entire + partie fractionnaire si cette dernire est non nulle.
Valeur par dfaut : "Fnormal"
Exemples :
> set_config("format_out_num","Fnormal")
{X = 120/36, Y = 1.5};
342
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
{ X = 10/3, Y = 1.500000000000000e+00 }
> set_config("format_out_num","Fexact")
{X = 120/36, Y = 1.5};
{ X = 10/3, Y = 3/2 }
> set_config("format_out_num","Fdecimal")
{X = 120/36, Y = 1.5};
{X = 3.333, Y = 1.5 }
> set_config("format_out_num","Ffloat")
{X = 120/36, Y = 1.5};
{X = 3.333333333333333e+00, Y = 1.500000000000000e+00 }
> set_config("format_out_num","Fint+fract")
{X = 120/36, Y = 1.5};
{ X = (3+1/3), Y = (1+1/2) }
>
format_decimal :
Un entier compris entre 0 et 7 reprsentant le nombre de chiffres affichs
aprs le point (partie dcimale). Cette option est utilise quand l'option
"format_out_num" est positionne "Fdecimal" .
epsilon_float :
Nombre flottant compris entre 10-4 et 10-12 reprsentant l'intervalle de
tolrance relatif, admis lors de la comparaison de nombres flottants.
Valeur par dfaut : 10-7
statistics :
0 : Pas de statistiques.
1 : Affiche les statistiques lies l'excution.
Voir galement :
set_configuration, get_config, get_configuration
echo, no_echo, trace, no_trace, debug, no_debug
edinburgh, prologIII
PrologIA
343
set_configuration(U)
Fonction
: Modification de certains paramtres
Classe
Catgorie
: Environnement
Paramtres connus
:U
Messages d'erreur
: Non
Description :
Mme fonctionnalit que set_config, mais U est un tuple de doublets <champ,
valeur>. On peut donc spcifier les valeurs de plusieurs champs
simultanment.
Exemple :
> set_configuration(<<"syntax","Edinburgh">,
<"format_out_num","Ffloat">>);
{}
?- {X = 12}.
{ X = 1.200000000000000e+01 }
?-
Voir galement :
set_config, get_config, get_configuration
344
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
set_context (I, S, S', D)

Fonction
: Description et activation d'un contexte
Classe
Catgorie
Paramtres connus
: I, S, S', D
Messages d'erreur
: Non
Description :
Cette commande permet la fois de dcrire un contexte, et de l'installer
comme le contexte courant de lecture/criture. Lorsqu'un nouveau contexte
est activ, l'ancien contexte n'est plus pris en compte.
contrle et l'environnement des programmes pour la signification des
arguments :
I
S
S'
D
: nom du contexte nouvellement dfini

: suite explicite
: suite implicite
: prfixe par dfaut
Lorsque Prolog III est lanc, le contexte courant de lecture/criture est le

contexte dfini par la commande :
set_context("",
[],
["sys"],
PrologIA
"")
345
set_ident (I, N)
Fonction
: Affectation d'un attribut un identificateur
Classe
Catgorie
Paramtres connus
: I, N
Messages d'erreur
: Oui, voir le manuel d'utilisation
Description :
Cette primitive permet d'associer un nombre et un identificateur. Elle est
utilise principalement pour associer un nom logique et un nombre utilis
dans le fichier userrule.c pour dfinir une procdure externe. On consultera le
manuel d'utilisation pour plus de dtails concernant la dfinition de
primitives par l'utilisateur.
346
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
size(U, N)
Fonction
: Taille d'un tuple
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Pose la contrainte {U :: N}, avec les retardements ncessaires si N ou U ne
sont connus.
Voir galement :
bound_size
PrologIA
347
split(U, L)
Fonction
: Dcomposition d'un tuple
Classe
Catgorie
: Conversion
Paramtres connus
: U
Messages d'erreur
: Non
Description :
Dcompose un tuple (ou, donc, une chane) en la liste de ses lments, c'est
dire pose la contrainte {L = U'}, o U' est la liste des lments du tuple U.
Echoue si U n'est pas connu l'excution.
Exemples :
> split("abcde",V);
{ V = [à`,`b`,`c`,`d`,è`] }
> split(<1,2,3>,V);
{ V = [1,2,3] }
> split(U,V),
{U
!tuple,
U::3};
{ U = <X1,X2,X3>, V = [X1,X2,X3] }
>
Nous avons renomm les variables intermdiaires cres par Prolog III.
Voir galement :
list_string, list_tuple
348
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
spy(<I, N>)
spy(S)
Fonction
: Espionnage de paquets de rgles
Classe
Catgorie
: Environnement
Paramtres connus
: S, au moins un parmi I et N
Messages d'erreur
: Module inexistant
Description :
Surveille un ou plusieurs paquets de rgles en installant des points-espion .
Dans la premire forme, I dsigne l'identificateur de paquet et N l'arit de ce
paquet, et au moins l'une des deux informations doit tre connue l'appel.
Un chec survient dans le cas contraire.
Dans la deuxime forme, S est un nom de module sous la forme d'une
chane de caractre. Toutes les rgles du module S sont alors concernes.
Provoque une erreur s'il n'existe aucune rgle de prfixe S.

Prolog III pour obtenir la dfinition et l'emploi des points-espion.
Voir galement :
no_spy
debug, no_debug
PrologIA
348 i
348 ii
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
state
Fonction
: Affiche l'occupation de certaines zones Prolog
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Affiche l'tat courant des piles.
Exemple :
> state;
copy stack
: 977/799900 lwords
0 %
back stack
: 0/200000 lwords
0 %
rule space
: 48235/100000 lwords
48 %
dictionary (acces)
: 20556/36864 bytes
55 %
dictionary (names)
: 4053+12144/32784 bytes
49 %
{}
>
PrologIA
349
string(S)
Fonction
: Vrifie que S est une chane connue
Classe
Catgorie
: Vrifications de type
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
S'excute avec succs si S reprsente une chaine entirement connue.
Echoue dans tous les autres cas.
Exemples :
> string("a
l'abordage");
{}
> string(<`C`,Ì`,À`>);
{}
> string("debut".<A,B,C>);
>
string(`X`);
>
string(not_a_string);
>
350
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
string_bool(S, B)
Fonction
: Conversion d'une chane en un boolen
Classe
Catgorie
: Conversions
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
Si S est connu : pose l'ensemble de contraintes {B = S'} o S' est un
boolen form partir des caractres de la chane S.
Si B est connu : pose l'ensemble de contraintes {S = B'}, o B' est une
chane forme des caractres qui composent le boolen B.
Exemples :
> string_bool(S,1');
{ S = "1'" }
> string_bool("0'",B);
{ B = 0' }
>
PrologIA
351
string_ident(S,I)
Fonction
: Conversion d'une chane en un identificateur
Classe
Catgorie
: Conversions
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
Si S est connu : pose l'ensemble de contraintes {I = I'}, o I' est un
identificateur compos des caractres de la chane qui le reprsente.
Si I est connu : pose l'ensemble de contraintes {S = S'} o S' est une chane
compose des caractres de l'identificateur I.
Exemples :
> string_ident(S,histoire:valmy);
{ S = "histoire:valmy" }
> string_ident("histoire:valmy",I);
{ I = histoire:valmy }
>
352
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
string_ident(P,S,I)
Fonction
: Conversion d'une chane en un identificateur
Classe
Catgorie
: Conversions
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
Si I est connu : pose l'ensemble de contraintes {S = S', P = P'} o S' est une
chane compose des caractres de la reprsentation abrge de
l'identificateur I, et P' une chane compose des caractres formant le
prfixe de l'identificateur I.
Si S et P sont connus : pose l'ensemble de contraintes {I = I'}, o I' est un
identificateur compos des caractres de la chane reprsentant son
prfixe, P, et de celle reprsentant sa notation abrge, S.
Exemples :
> string_ident(P,S,histoire:valmy);
{ P = "histoire", S = "valmy" }
> string_ident("histoire","valmy",I);
{ I = histoire:valmy }
> string_ident("geographie:fleuve","Seine",I);
{ I = 'geographie:fleuve:Seine' }
> string_ident("geographie","fleuve:Seine",I);
>
PrologIA
353
string_integer(S,N)
Fonction
: Conversion d'une chane en un entier
Classe
Catgorie
: Conversions
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Entier attendu
Description :
Si S est connu : pose l'ensemble de contraintes {I = S'} o S' est un entier
form partir des caractres de la chane S.
Si N est connu : pose l'ensemble de contraintes {S = N'}, o N' est une
chane forme des caractres qui composent l'entier N.
Exemples :
> string_integer("12",N);
{ N = 12 }
> string_integer(S,24/2);
{ S = "12" }
> string_integer("12.3",N);
Erreur 234 : entier attendu
>
354
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
string_real(S,F)
Fonction
: Conversion d'une chane en un flottant
Classe
Catgorie
: Conversions
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
Si S est connu : pose l'ensemble de contraintes {F = S'} o S' est un flottant
form partir des caractres de la chane S.
Si F est connu : pose l'ensemble de contraintes {S = F'}, o F' est une
chane forme des caractres qui composent le flottant F.
Exemples :
> string_real("3.14e5",F);
{ F = 3.140000 e+05 }
> string_real(S,3.14e5);
{ S = "3.140000 e+05" }
>
PrologIA
355
substring(S1, N1, N2, S2)

Fonction
: Extraction de sous-chanes
Classe
Catgorie
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
Pose la contrainte {S2 = S1'}, o S1' est la sous-chane de S1 commenant
la position N1, de longueur N2. Echoue si une telle sous-chane n'existe pas
ou si S1 n'est pas connue.
Exemple :
> substring("1234567890",3,4,X);
{ X = "3456" }
>
356
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
suppress(I)
Fonction
: Suppression d'un paquet de rgles
Classe
Catgorie
Paramtres connus
: I
Messages d'erreur
: Aucun
Description :
Supprime tout le paquet de rgles de nom I. Echoue si I est inconnu, ou bien
s'il n'existe pas de paquet de rgles convenant.
Exemples :
> essayons(1)->;
> essayons(2)->;
> essayons(1,2)->;
> essayons(X);
{ X = 1 }
{ X = 2 }
> suppress(essayons);
{}
> essayons(X);
>
essayons(X,Y);
>
PrologIA
357
suppress(I, A)
Fonction
Classe
Catgorie
Paramtres connus
: I et A
Messages d'erreur
: Aucun
Description :
Supprime tout le paquet de rgles de nom I, et d'arit A. Echoue si I ou A
sont inconnus, ou bien s'il n'existe pas de paquet de rgles convenant.
Exemples :
> essayons(1)->;
> essayons(2)->;
> essayons(1,2)->;
> essayons(X);
{ X = 1 }
{ X = 2 }
> suppress(essayons,1);
{}
> essayons(X);
>
essayons(X,Y);
{ X = 1,Y = 2 }
>
358
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
suppress(I, A, N)
Fonction
: Suppression d'une rgle
Classe
Catgorie
Paramtres connus
: I, A, et N
Messages d'erreur
: Aucun
Description :
Supprime la rgle numro N du paquet de rgles de nom I, et d'arit A.
Russit, mais sans rien effacer, si aucune rgle ne correspond. Echoue si les
arguments sont inconnus ou de mauvais type.
Exemples :
> essayons(1)->;
> essayons(2)->;
> essayons(1,2)->;
> essayons(X)
essayons(Y,Z);
{ X = 1, Y = 1, Z = 2 }
{ X = 2, Y = 1, Z = 2 }
> suppress(essayons,1,2);
{}
> essayons(X)
essayons(Y,Z);
{ X = 1, Y = 1, Z = 2 }
>
PrologIA
359
suspend_trace
Fonction
: Annule la trace si celle-ci est active
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Annule la trace, si celle-ci est active jusqu'au prochain resume_trace. La
runion de ces deux primitives est extrmement utile lorsque l'on dsire
supprimer la trace de certains prdicats particuliers. Il suffit alors d'encadrer
ces prdicats par les primitives suspend_trace et resume_trace. Si aucune trace
n'est active, les appels suspend_trace et resume_trace n'ont pas d'effets
particuliers.
Exemples :
> essai ->
suspend_trace
outml("sans trace")
resume_trace ;
>
trace line essai line;
line
essai = essai
suspend_trace
sans trace
line
{}
> no_trace;
no_trace
{}
> essai;
sans trace
{}
>
Voir galement :
trace, no_trace, set_config, resume_trace
360
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
sys_command(S)
Fonction
: Excution
d'une
commande
du
systme
d'exploitation
Classe
Catgorie
: Environnement
Paramtres connus
: S
Messages d'erreur
: Aucun
Description :
Excute une commande du systme d'exploitation, reprsente par la chane
S. Consultez le manuel d'utilisation relatif votre systme d'exploitation
pour connatre la liste et la syntaxe des commandes disponibles.
PrologIA
361
trace
Fonction
: Trace de l'excution d'un programme
Classe
Catgorie
: Environnement
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Mode de trace d'un programme, avec impression, sur l'unit courante de
sortie de trace, des contraintes d'galit entre les buts et les ttes de rgles
avant unification, et visualisation des points de backtracking.
Cette primitive trace correspond l'appel :
set_config("machine_mode", 1)
La primitive no_trace permet de sortir de ce mode.
Voir galement :
no_trace, debug, no_debug, trace_file, suspend_trace, resume_trace
set_config, set_configuration, get_config, get_configuration,
362
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
trace_file(S)
Fonction
: Redirection de la trace
Classe
Catgorie
: Environnement
Paramtres connus
: S
Messages d'erreur
: Non
Description :
Redirection, dans le fichier de nom dtermin par la chane de caractres S,
de la trace d'excution d'un programme.
Si la chaine de caractre est la chaine vide, la trace est redirige sur l'unit de
trace dfinie au dmarrage de Prolog III.
Le fichier en question ne sera ferm qu'au prochain trace_file (on pourra par
exemple utiliser trace_file("") )
Voir galement :
trace, no_trace
PrologIA
363
trunc(R, N)
Fonction
: Partie entire
Classe
Catgorie
Paramtres connus
: R
Messages d'erreur
: Aucun
Description :
Pose la contrainte {N = R'}, o R' est la partie entire du nombre R.
Exemples :
> trunc(5/4,N);
{ N = 1 }
> trunc(-3.56,N);
{ N = -4 }
>
364
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
tuple(U)
Fonction
: Vrifie que U est un tuple connu
Classe
Catgorie
Paramtres connus
: U
Messages d'erreur
: Aucun
Description :
S'excute avec succs si U reprsente un tuple connu, c'est--dire dont on sait
si le nombre de fils est nul ou pas. Echoue dans tous les autres cas.
Exemples :
> tuple(<>);
{}
> tuple(<1,0',ceslawi>);
{}
> tuple("connu");
{}
> tuple(<>[X]);
>
tuple(<A,B,C>);
{}
> tuple(U),
{U
!tuple};
>
PrologIA
365
undef_array(I)
Fonction
: Dsalloue un tableau cr par def_array
Classe
Catgorie
Paramtres connus
: I
Messages d'erreur
: Voir ci-aprs
Description :
Dsalloue un tableau cr par la primitive def_array et rcupre la place
correspondante.
Exemples :
assign(tab(50),3);
{}
> val(tab(50),X);
{ X = 3 }
> undef_array(tab);
{}
> val(tab(50),X);
>
undef_array(X11);
Erreur 233: Identificateur attendu (2)
>
Voir galement :
assign, def_array, redef_array, val
366
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
val(T1, T2)
Fonction
: Evalue une expression construite partir de

fonctions valuables
Classe
Catgorie
: Contrle
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Voir ci-aprs
Description :
Evalue l'expression T1 et produit le rsultat T2. L'expression valuer est
construite rcursivement partir des constantes, des identificateurs, des
lments de tableau et des fonctions valuables.
Exemples :
> val(add(mul(2,add(3,4)),1000),x);
{ X = 1014 }
> val(2*(3+4)+1000,x);
{ X = 1014 }
>
Remarques :
Chaque fonction valuable doit avoir des arguments d'un type prcis : il n'y
a pas de conversion automatique de type. Quand une fonction a un nombre
incorrect d'arguments ou quand certains de ses arguments sont du mauvais
type, val produit une erreur.
La valeur d'un nombre ou d'une chane est gale ce nombre ou cette
chane.
La valeur d'un tableau (externe ou interne) indic est gale la valeur de
l'lment correspondant de ce tableau.
PrologIA
367

Exemples:
assign(tab[50],3);
{}
> val(tab[50],X);
{ X = 3 }
>
La valeur d'un identificateur i est dfinie comme suit :

(1) si une constante k a t affecte i (au moyen de la rgle assign) alors la
valeur de i est k.
(2) si i n'a pas fait l'objet d'une affectation pralable, alors la valeur de i est i
lui-mme.
Exemples:
> assign(un,
1);
{}
> val(un,
x)
val(deux,
y);
{ x=1,y=deux }
>
Voici toutes les fonctions valuables :

add(t1, t2)
valeur(add(t1, t2)) = valeur(t1) + valeur(t2).
Les valeurs de t1 et t2 doivent tre numriques.
sub(t1, t2)
valeur(sub(t1, t2)) = valeur(t1) - valeur(t2).
mul(t1, t2)
valeur(mul(t1, t2)) = valeur(t1) valeur(t2).
div(t1, t2)
valeur(t1)
valeur(div(t1, t2)) =
valeur(t ) Il s'agit du quotient entier par dfaut.
2
Les valeurs de t1 et t2 doivent tre des nombres entiers.
368
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
mod(t1, t2)
valeur(mod(t1, t2)) = valeur(t1) modulo valeur(t2).
Les valeurs de t1 et t2 doivent tre des nombres entiers.
trunc(t1)
valeur(trunc(t1)) = partie entire de valeur(t1).
La valeur de t1 doit tre numrique.
eql(t1, t2)
valeur(eql(t1, t2)) = si valeur(t1) = valeur(t2) alors 1 sinon 0.
Les valeurs de t1 et t2 doivent tre des constantes de mme type.
inf(t1, t2)
valeur(inf(t1, t2)) = si valeur(t1) < valeur (t2) alors 1 sinon 0.
Les valeurs de t1 et t2 doivent tre des constantes de mme type. Pour les
entiers et les rels, on prend la relation "<" entre les nombres. Pour les
chanes, on prend l'ordre lexicographique et pour les identificateurs on
prend l'ordre lexicographique sur les chanes associes.
infe(t1, t2)
valeur(infe(t1, t2)) = si valeur(t1) valeur (t2) alors 1 sinon 0.
sup(t1, t2)
valeur(sup(t1, t2)) = si valeur(t1) > valeur (t2) alors 1 sinon 0.
supe(t1, t2)
valeur(supe(t1, t2)) = si valeur(t1) valeur (t2) alors 1 sinon 0.
if(t, t1, t2)
valeur(if(t, t1, t2)) = si (valeur(t)0) alors valeur(t1) sinon valeur(t2)
abs(t)
valeur(abs(t)) = valeur absolue de valeur(t).
PrologIA
369

Les fonctions suivantes donnent un rsultat de type rel. Les fonctions
trigonomtriques travaillent avec des angles exprims en radians.
atan(t)
valeur (atan(t)) = arc tangente de valeur(t).
cos(t)
valeur (cos(t)) = cosinus(valeur(t)).
exp(t)
valeur (exp(t)) = exponentielle(valeur(t)).
ln(t)
valeur(ln(t)) = logarithme nprien(valeur(t)).
rad(t)
valeur (rad(t)) = conversion en radian(valeur(t)).
sin(t)
valeur(sin(t)) = sinus(valeur(t)).
sqrt(t)
valeur(sqrt(t)) = racine carre(valeur(t)).
tan(t)
valeur(tan(t)) = tangente(valeur(t)).
Voir galement :
assign, def_array, undef_array, redef_array
370
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Index des rgles prdfinies, procdures externes

et fonctions valuables
abs 369
add 368
def_array 232
default 234
add_implicit 202
arg 203
arg2 204
dictionary 235
dif 237
div 238; 368
arg3 205
assert 206
dot 239
echo 240; 341
assert'' 208
asserta 207
assertz 208
edinburgh 241
edit 242
end_module 243
assign 209
atan 370
block 212
block_exit 212
bool 214
bound 215
bound_conc 216
bound_mult 217
bound_size 218
bound_tree 219
bound_tree' 220
enum 244
epsilon_float 342
eq 246
eql 369
exit 247
exp 370
fail 249
find_pattern 251
findall 250
format_decimal 342
format_float 342
char 221
char_code 222
close_context_dictionary 223
format_out_num 341
Fdecimal 341
Fexact 341
close_input 224
close_output 225
conc3 226
Ffloat 341
Fint+fract 341
Fnormal 341
conc_string 227
free 252
cos 370
cpu_time 228
current_context 229
current_predicate 230
free_label 253
freeze 254
garbage_collection 255
gcd 256
cut 231
get_config 257
PrologIA
371

get_configuration 258
getenv 259
mod 297; 369

module 298
ident 260
if 369
in_char 261
mul 368
mult 299
new 300
in_char' 262
in_ident 263
next_char 301
next_char' 302
in_integer 264
in_real 265
in_sentence 266
no_echo 303
no_trace 304
not 305
in_sentence' 267
in_string 268
num 306
numden 307
in_term 269
inf 369
infe 369
inl 270
input 271
input_is 272
insert 273
integer 275
is_bool 276
is_char 277
is_ident 278
is_leaf 279
is_num 280
is_tuple 281
is_univ 282
out 308
outc 309
outl 310
outm 311
outml 312
output 313
output_is 314
particular_value 315
pgcd 316
ppcm 317
predefined 318
prologIII 319
quit 320
rad 370
rational 322
kill_module 283
real 323
known 284
known_part 285
lcm 286
line 287
redef_array 324
reinsert 325
reload 327
remove_implicit 328
list 288
list_string 293
list_tuple 294
repeat 329
reset_cpu_time 330
resume_trace 331
ln 370
max_value 295
retract 332
rule 333
min_value 296
rule_nb 336
372
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
save 337
set_config 340
trunc 364; 369

tty_wrap 342
echo 341
epsilon_float 342
format_decimal 342
tuple 365
undef_array 366
undefined_rule 343
format_float 342
format_out_num 341
error 343
fail 343
statistics 342
syntax 342
trace 340
warning 343
val 367
abs 369
tty_wrap 342
undefined_rule 343
add 368
atan 370
set_configuration 344
set_context 345
set_ident 346
sin 370
size 347
split 348
sqrt 370
state 349
string 350
string_bool 351
string_ident 352
string_integer 354
string_real 355
sub 368
substring 356
cos 370
div 368
eql 369
exp 370
if 369
inf 369
infe 369
ln 370
mod 369
mul 368
rad 370
sin 370
sqrt 370
sub 368
sup 369
sup 369
supe 369
supe 369
suppress 357
suspend_trace 360
syntax 342
tan 370
trunc 369
Edinburgh 342
Prolog III 342
sys_command 361
tan 370
trace 340; 362
trace_file 363
PrologIA
373
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Rgles prdfinies et procdures

externes
pour la syntaxe Edimbourg

Ce chapitre regroupe par ordre alphabtique toutes les rgles prdfinies et
disponibles en Prolog III depuis le seul mode Edimbourg .
La plupart de ces prdicats ayant t adapts aux fonctionnalits spcifiques de
Prolog III, la compatibilit n'est pas totale. Certains sont des synonymes des
primitives dcrites dans le chapitre prcdent, d'autres sont plus originaux.
Dcembre 1990
PrologIA
Rgles prdfinies Edimbourg
Identificateur - Arit
Il est coutume en syntaxe Edimbourg de trouver au niveau de la gestion des
rgles des termes de la forme I/N , I reprsentant un identificateur et N un
entier dsignant une arit. Pour des raisons videntes, il est impossible en
Prolog III de former de tels termes (il n'est pas possible de diviser un
identificateur par un entier). Il nous faut donc une autre convention pour
dsigner ces termes. La notation de tuple a t prfre. On dfinira donc le
couple ident/arit par <ident,arit> .
Rgles sous forme de termes

On manipule parfois les rgles en tant que termes, la plupart du temps au
sein de primitives de gestion de rgles. Dans ces cas l, il faut se souvenir
que les rgles Prolog III ont quatre formes possibles,
tete
(1)
tete { contraintes }
(2)
tete :- but, , but
(3)
tete :- but, , but { contraintes }
(4)
et que l'oprateur compos {} est l'oprateur principal dans les formes (2)
et (4) .
376
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
abolish(I)
abolish(<I, A>)
Fonction
Classe
: Primitive Edimbourg
Catgorie
Paramtres connus
: L'argument doit tre un identificateur connu ou

un tuple <ident connu, Arit connue>
Message d'erreur
: Non
Description :
Premire forme : Supprime tout le paquet de rgles de nom I. Se comporte comme suppress(I) .
Deuxime forme : Supprime tout le paquet de rgles de nom I dont l'arit
est A . Se comporte alors comme suppress(I, A ) . Echoue lorsque les
arguments ne sont pas connus.
Voir galement :
retract
PrologIA
377
Aociation
assert(T)
assertz(T)
Fonction
: Ajout d'une rgle la fin de son paquet
Classe
Catgorie
Paramtres connus
: T
Messages d'erreur
: Si T est une rgle incorrecte
Description :
Ajout d'une rgle, la fin de son paquet. T doit tre un terme ayant l'une
des formes dcrites en introduction. La tte de la rgle doit tre un arbre
tiquet par un identificateur connu.
L'effacement de assert(T) ajoute la rgle ou le fait T au-dessous du groupe de
rgles ayant le mme nom que la tte de T. Par exemple, les deux
commandes suivantes
?-
assert(conc([],Y,Y),[]).
{}
?- assert(
conc([E|X],Y,[E|Z]):-
conc(X,Y,Z)
).
{}

conc([], Y, Y).
conc([E|X], Y, [E|Z]) :- conc(X, Y, Z).
Ajouter des rgles comportant un systme de contraintes peut tre ralis de
deux faons. Une premire faon pose des contraintes en dehors de l'appel :
378
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
?- assert(hors_de(X,[]),[]).
{}
?- assert(
hors_de(X,[Y|Q]):-hors_de(X,Q)
{X # Y } .
{ X # Y }
?- list.
hors_de(X,[]) .
hors_de(X,[Y | Q]) :hors_de(X, Q)
{ X # Y }.
{}
Une seconde mthode consiste passer toute la rgle en argument (puisque

le tout est un terme). Dans ce cas, assert traduit si possible les termes placs
entre accolades en vritables contraintes. Ces contraintes-l ne sont pas
conserves aprs l'appel.
?- assert(
hors_de(X,
[Y|Q]:-
hors_de(X,Q)
{X#Y}
).
{}
?- list.
hors_de(X,[Y | Q]) :hors_de(X, Q)
{ X # Y }.
{}
Dans le cas o la rgle en argument contient des buts spars par une ou
plusieurs virgules, il faut parenthser celle-ci pour lever l'ambigut entre les
deux types de virgules (virgule d'arguments et virgule de queue de rgle).
?- assert((a
:-
b,
c)).
{}
PrologIA
379
Aociation
asserta(T)
Fonction
: Ajout d'une rgle en dbut de son paquet
Classe
Catgorie
Paramtres connus
: T
Messages d'erreur
: Si T est une rgle incorrecte
Description :
Ajout d'une rgle, au dbut de son paquet. T doit tre un terme ayant l'une
des formes dcrites en introduction. La tte de la rgle doit tre un arbre
tiquet par un identificateur connu.
L'effacement de assert(T) ajoute la rgle ou le fait T au-dessus du groupe de
rgles ayant le mme nom que la tte de T. Par exemple, les deux
commandes suivantes
?- asserta(
conc([E|X],Y,[E|Z]):-
conc(X,Y,Z)
{}
?-
asserta(conc([],Y,Y),[]).
{}

conc([], Y, Y).
conc([E|X], Y, [E|Z]) :- conc(X, Y, Z).
Toutes les remarques concernant assertz sont valables ici.
380
PrologIA
Prolog
HERITAGE
).
Aociation
Prolog
HERITAGE
atom(T)
Fonction
: Vrifie que T est un identificateur connu
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Vrifie que T est un identificateur connu. Echoue sinon. atom(T) se comporte
comme le but ident(T) .
PrologIA
381
atomic(T)
Fonction
: Vrifie que T est un atome
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Vrifie que T est un atome connu; c'est dire vrifie d'une part que T est
connu, et que d'autre part T est un nombre, ou un identificateur, ou un
boolen, ou un caractre, ou bien le tuple vide <> . Echoue dans tous les
autres cas. Notons qu'une chane de caractre n'est pas un atome puisqu'on
peut la dcouper en caractres.
Voir galement :
bound, known
382
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
call(P)
Fonction
: Effacement d'un but
Classe
Catgorie
: Contrle
Paramtres connus
: P
Messages d'erreur
: Non
Description :
Excute le but P.
La primitive Call est dfinie par la rgle :
call(X) :- X .
PrologIA
383
clause(T, Q)
Fonction
: Obtient la tte et la queue d'une rgle
Classe
Catgorie
Paramtres connus
: T
Messages d'erreur
: Non
Description :
Unifie T et Q respectivement avec la tte et la queue de toutes les clauses
dont l'accs est dfini par T. Se comporte comme rule la structure de la
queue prs. Celle-ci est reprsent par l'identificateur sys:true lorsqu'elle est
vide, par un terme lorsqu'elle ne comporte qu'un seul but, par une structure
peigne, d'tiquette ',' sinon.
Remarques :
Il n'est pas possible de rcuprer sous forme de termes l'ensemble des
contraintes de cette rgle. En effet, ces contraintes sont poses ds
l'unification de la tte, et portent donc sur les variables de T et de Q .
Exemples :
?- consult("user").
differents(A, B) { A#B }.
regle(A,B) :- a(A) { A#B }.
longue_regle(A,B) :- a(A),b(B) { A#1 }. .
{}
?- clause(differents(U,V),
Queue).
{ Queue=true, U#V }
?- clause(regle(U,V),
Queue).
{ Queue=a(U), U#V }
?- clause(longue_regle(U,V),
Queue).
{ Queue=','(a(U), b(V)), U#1 }
voir galement :
rule
384
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
consult(S)
Fonction
: Insertion de rgles
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: S, qui doit tre une chane ou un identificateur
Messages d'erreur
: Fin de fichier inattendue, Impossible d'ouvrir le

fichier
Description :
Cette rgle prdfinie permet d'ajouter des noncs (rgles), dans l'ordre
dans lequel ils sont lus partir du fichier S. Lorsque S est un identificateur,
c'est la chane correspondant son abrviation qui est prise en compte
comme nom de fichier (on ignore donc le prfixe). Lorsque cette chane est
"user", le fichier de lecture est la console. La lecture se termine lorsque l'on
rencontre la fin du fichier ou bien quand une rgle vide est lue (une rgle
vide tant constitue d'un . suivit d'un espace).
certain nombre de caractres (en principe tous les caractres jusqu' un .)
sont ignors, puis l'insertion reprend.
consult provoque une erreur lorsque un paquet lu existe dj. Dans ce cas,
Prolog III sort du mode insertion , mais ne ferme pas les fichiers qui
taient ouverts : il continue donc lire le(s) fichier(s) en cours : les faits et les
requtes sont excutes, les rgles provoquent des erreurs de syntaxe .
L'appel consult(S) est quivalent insert(S), lorsque S est une chane de
caractres. consult("user") est lui quivalent insert .
Voir galement :
reconsult, insert
PrologIA
385
functor(T, E, N)
Fonction
: Constructeur gnral d'arbre
Classe
Catgorie
: Arbres, listes et tuples
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Associe un arbre T son tiquette E et son arit N . Cette primitive est
actuellement dcrite par la rgle :
functor(E[U],E,N) {U::N}.
Elle impose E d'tre un feuille et N d'tre numrique (aucun n'tant
forcment connus l'appel).
Exemples :
?- functor(a(b,c),
X,
N).
{ X=a, N=2 }
?-
functor(T,
a,
2).
{ T=a[U_1], U_1::2 }
386
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
get(X)
Fonction
: Rend le code d'un caractre non blanc lu
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: Aucun
Messages d'erreur
: Fin de fichier d'entre
Description :
X est unifi avec le numro de code ASCII du premier caractre non blanc lu
sur l'entre courante. La primitive sous-jacente est in_char'. La conversion
du caractre en code ASCII est faite par la primitive char_code.
Voir galement :
in_char', get0
PrologIA
387
get0(X)
Fonction
: Rend le code du prochain caractre lu
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: Aucun
Messages d'erreur
: Fin de fichier d'entre
Description :
X est unifi avec le numro de code ASCII du prochain caractre lu sur
l'entre courante. La primitive sous-jacente est in_char . La conversion du
caractre en code ASCII est faite par la primitive char_code .
Voir galement :
in_char, get
388
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
is(X, T)
X is T
Fonction
: Evaluation d'un arbre
Classe
Catgorie
: Evaluation de fonctions prdfinies
Paramtres connus
: T
Messages d'erreur
: Erreur dans val
Description :
Le terme T est valu, et la valeur obtenue est unifie X . L'valuation d'un
identificateur donne lui-mme moins qu'il lui ait t auparavant assign
une constante. is est implante l'aide de la primitive val :
X is Y :- val(Y, X).
Remarque :
Les oprateurs <, >, =<, >= ne sont pas disponibles dans le membre droit de
is, il faut utiliser respectivement inf, sup, infe, supe en notation fonctionnelle.
Exemples :
?- X
is
add(exp(1.0),
1).
{ X=3.7182818284590e+00 }
?-
Y is 3*4, X is add(2Y/4, sin(1)).
{ Y=12, X=6.8414709848078e+00 }
?- X is 3*4 < 44/3 .
% mettre un blanc entre 3 et .
Erreur dans val

?- X
is
inf(3,4).
{ X=1 }
Voir galement :
val
PrologIA
389
listing
listing(I)
listing(<I, A>)
Fonction
Classe
Catgorie
Paramtres connus
: I et A
Messages d'erreur
Description :
Ces primitives sont respectivement quivalentes :
list, list(I), list(<I,A>)
390
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
member(X, L)
Fonction
: Recherche d'un lment dans une liste classique
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
La primitive member est dcrite par les rgles suivantes :
member(X, [X|L]).
member(X, [_|L]) :- member(X, L).
Exemples :
?- member(X,
[1,2,3]).
{ X=1 }
{ X=2 }
{ X=3 }
?- member(3,
[1,2,3]).
{}
?-
member(2,
[1,3,X]).
{ X=2 }
PrologIA
391
name(X, L)
Fonction
: Conversion de constantes en liste de codes de

caractres
Classe
Catgorie
Paramtres connus
: Soit X , soit L
Messages d'erreur
: Ce n'est pas un identificateur
Description :
Si X est un identificateur, un nombre, un caractre ou un boolen, L est
unifi avec la liste des codes ASCII des caractres qui constituent le symbole
X.
Si L est une liste de codes ASCII des lettres d'un identificateur, X est instanci
avec l'identificateur dtermin par les conventions courantes de prfixages.
Exemples :
?- name(12345678,
L).
{ L=[49,50,51,52,53,54,55,56] }
?- name(X,
[97,98,99]).
{ X=abc }
?- name(X,
[65,66]).
%codes Ascii de A et de B
Erreur: Ce n'est pas un identificateur
Voir galement :
string_ident, string_integer, string_real, string_bool, .
392
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
nl
Fonction
: Imprime un retour chariot sur la sortie courante
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Ecrit un retour chariot sur l'unit de sortie courante . Se comporte comme la
primitive line .
Voir galement :
line, outl, outml
PrologIA
393
nonvar(T)
Fonction
: Vrifie que T a une tiquette connue ou une liste

de fils connue.
Classe
Catgorie
: Contrle
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
nonvar(T) se comporte comme not(free(T)), c'est--dire que nonvar russi si
l'tiquette de T est connue ou bien si on sait si la liste des fils est vide ou pas.
Echoue dans les autres cas. L'appel nonvar(T) russit quand var(T) choue et
vice-versa .
Voir galement :
free, known, bound, var
394
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
number(R)
Fonction
: Vrifie que R est un nombre connu.
Classe
Catgorie
Paramtres connus
: Voir ci-aprs
Messages d'erreur
: Non
Description :
Cette rgle prdfinie vrifie que R est un terme reprsentant une valeur
numrique connue. Si ce n'est pas le cas number(R) choue. number est un
synonyme de la primitive num .
Voir galement :
num, integer, real, rationnal
PrologIA
395
op(N, I1, S)
op(N, I1, S, I2)
Fonction
: Dclaration d'oprateur
Classe
Catgorie
Paramtres connus
: N,I1,S,I2
Messages d'erreur
: Non
Description :
Dclare l'oprateur S avec la prcdence N et le type de parenthsage I1 . S
est un soit un identificateur non quot, soit une chane de caractres.
Dans le cas o S est une chane, son contenu ne doit dbuter ni par une
constante ni par une variable ni par espace. Dans la forme 3 arguments, S
peut tre une liste, la dclaration s'applique alors chaque lment de la liste.
Le symbole fonctionnel reprsent par S est I2 si celui-ci est fourni, sinon le
symbole S quot. L'associativit est prcise par un identificateur ou une
chane de caractres combinant une, deux ou trois des lettres f,x,y avec les
conventions suivantes :
f reprsente l'oprateur.
x reprsente un expression de prcdence infrieure f
y reprsente un expression de prcdence infrieure ou gale f
Les combinaisons possibles sont les suivantes : f fx fy xf yf xfx yfx xfy .
Lorsque N est gal 0, op a pour effet de supprimer la dclaration existante
pour l'oprateur S.
Exemples :
?- op(400,
xfx,
'@@').
{}
?- write(X
@@
Y).
'@@'(X,Y){}
396
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
put(X)
Fonction
: Envoie sur l'unit courante le code ASCII X
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: X , qui doit tre entier
Messages d'erreur
: Non
Description :
Le code de caractre ASCII X est envoy sur l'unit de sortie courante.
Echoue si X n'est pas un entier.
Exemples :
?- put(65),
put(66),
put(67),
nl.
ABC
{}
Voir galement :
out, outm
PrologIA
397
read(T)
Fonction
: Lit un terme sur l'unit courante d'entre
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: Aucun
Messages d'erreur
: Erreurs de syntaxe diverses
Description :
Lit le prochain terme se trouvant sur l'entre courante. Celui-ci doit se
terminer par un point suivit d'un espace (ces caractres sont lus).
L'argument T est alors unifi avec ce terme. Cette primitive est bas sur
in_term .
Exemples :
?- read(T).
[1,2].
{ T=[1,2] }
Voir galement :
in_term
398
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
retract(X)
Fonction
: Suppression de rgles selon un certain modle
Classe
Catgorie
Paramtres connus
: X
Messages d'erreur
: Non
Description :
Supprime toutes les rgles qui s'unifient avec X. X doit tre un terme ayant
l'une des formes dcrites en introduction. La tte de la rgle dtermine par
X doit tre un arbre tiquet par un identificateur connu. Au nombre
d'arguments prs, retract(X) se comporte comme la primitive retract d'arit 2
.
Exemples :
?- consult("user").
titi(1)
:-
aa.
titi(2)
:-
aa.
titi(3)
:-
aa.
.
?- retract(titi(X)
:-
aa
{X#2}).
{ X=1 }
{ X=3 }
Voir galement :
abolish, suppress, retractall
PrologIA
399
retractall(T)
Fonction
: Suppression de rgles selon un certain modle
Classe
Catgorie
Paramtres connus
: T
Messages d'erreur
: Non
Description :
Supprime toutes les rgles dont la tte s'unifie avec T , lequel n'est donc pas
une rgle mais une tte de rgle. T doit tre un terme dont l'tiquette est un
identificateur connu et dont le nombre de fils est connu.
Exemples :
?- consult("user").
titi(1)
:-
aa.
titi(2)
:-
bb.
titi(3)
:-
cc.
.
?- retractall(titi(X))
{X#2}.
{X=1}
{X=3}
Voir galement :
abolish, retract, suppress
400
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
see(F)
Fonction
: Dfinition de l'unit courante d'entre
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: F qui doit tre une chane ou un identificateur
Messages d'erreur
: Fin de fichier inattendue, Impossible d'ouvrir le

fichier
Description :
Se comporte comme input(F) si F est une chane. Dans le cas o F est un
identificateur, c'est la chane correspondant son abrviation qui est prise en
compte comme nom d'unit passe input (c'est--dire que le prfixe est
ignor).
Voir galement :
input, close_input, seen
PrologIA
401
seen
Fonction
: Fermeture de l'unit courante d'entre
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: Aucun
Messages d'erreur
Description :
Se comporte comme close_input.
Voir galement :
input, close_input, see
402
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
tab(N)
Fonction
: Impression de N blancs sur la sortie courante
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: N qui doit tre un entier connu
Messages d'erreur
Description :
Envoie N blancs sur l'unit courante de sortie. Lorsque N n'est pas un entier
connu, un message d'erreur est affich.
Voir galement :
line, outm, put, writeq
PrologIA
403
tell(F)
Fonction
: Dfinition de l'unit de sortie courante
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: F, qui doit tre une chane ou un identificateur.
Messages d'erreur
: Non
Description :
Se comporte comme output(F) si F est une chane. Dans le cas o F est un
identificateur, c'est la chane correspondant son abrviation qui est prise en
compte comme nom d'unit passe la primitive output (c'est--dire que le
prfixe est ignor).
Voir galement :
output, close_output, told
404
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
told
Fonction
: Fermeture de l'unit de sortie courante
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: Aucun
Messages d'erreur
Description :
Se comporte comme close_output.
Voir galement :
output, close_output, tell
PrologIA
405
true
Fonction
: Russite
Classe
Catgorie
: Contrle
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
S'efface toujours avec succs.
Voir galement :
clause
406
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
var(T)
Fonction
: Vrifie que T est une variable libre
Classe
Catgorie
: Contrle
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
var(T) est excut avec succs si l'on ne connat pas l'tiquette initiale de T et
que l'on ne sait pas si le nombre de ses fils est nul ou non. Echoue dans tous
les autres cas. Se comporte comme free .
Exemple :
?- var(X).
{}
?- var((+X)[U]).
{ X !num, U !tuple }
?- var(+X).
?- var(X(1,2,3)).
?- var(sommet[L]).
?- var(sommet(X,Y,Z)).
?- var(sommet[L])
{L
<>}.
?-
Voir galement :
free, bound, known, nonvar
PrologIA
407
write(T)
Fonction
: Impression de termes sans dlimiteurs
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Si T est un identificateur, une chane ou un caractre, write crit T sans les
dlimiteurs. Sinon crit le terme comme le fait la primitive out. Actuellement
ne tient pas compte des dclarations d'oprateurs et emploie la notation
fonctionnelle.
Exemple :
?- write('X').
X{}
?- write("chaine").
chaine{}
?- write(`c`).
c{}
?- write(a('X',1+2X,"str")).
a('X',2X+1,"str"){}
Voir galement :
out, outm, writeq
408
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
writeq(T)
Fonction
: Impression de termes
Classe
Catgorie
: Entres/Sorties
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Ecrit le terme T sur l'unit courante de sortie, sans les contraintes associes
aux variables qui peuvent figurer dans ce terme. writeq se comporte comme
la primitive out. Actuellement writeq ne tient pas compte des dclarations
d'oprateurs et emploie la notation fonctionnelle.
Exemple :
?- writeq('X').
'X'{}
?- writeq("chaine").
"chaine"{}
?- writeq(a('X',1+2X,"str")).
a('X',2X+1,"str"){}
Voir galement :
out, outm, write
PrologIA
409
Aociation
X =.. Y
Fonction
: Eclatement de termes
Classe
Catgorie
Paramtres connus
: X ou Y
Messages d'erreur
: Non
Description :
Si l'arit de X est connue, Y est unifi avec une liste dont le premier lment
est l'tiquette de X, et les lments suivants les ventuels arguments dans
l'ordre. Sinon, X est d'arit inconnue, et Y doit tre une liste (et non pas une
paire pointe) dont le premier lment est atomique, c'est--dire une feuille;
X est alors unifi avec le terme construit ayant le premier lment de la liste
comme foncteur, et les autres lments comme arguments. Echoue donc si X
est d'arit inconnue et Y n'est pas une liste, ou bien si X et Y sont libre (var) .
Exemples :
?- out(X,a)
=..
Y.
{Y=[out,X,a]}
?- X
=..
[toto,1,2,3].
% X = toto(1,2,3)
{X=toto[<1,2,3>]}
?-
label[U]
=..
[label,1,2|R].
?- X =.. Y.
?-
Voir galement :
functor
410
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
X<Y
X>Y
X =< Y
X >= Y
Fonction
: Evaluation et vrifications des relations
Classe
Catgorie
Paramtres connus
: X et Y
Messages d'erreur
: Erreur dans val
Description :
X et Y sont values (voir val). Les comparaisons sont ensuite effectues
entre leurs valeurs, qui peuvent tre de type numrique, identificateur ou
chane de caractres. Dans le cas des chanes, la comparaison est
alphabtique, Dans le cas des identificateurs, la comparaison lieu sur les
chanes composant leur partie abrge. Ces quatres primitives sont dfinies
comme suit :
X<Y
:- val(inf(X,Y), 1).
X=<Y
:- val(infe(X,Y), 1).
X>Y
X>=Y
:- val(sup(X,Y), 1).
:- val(supe(X,Y), 1).
Exemples :
?- X>3.
Erreur dans val
?- 3*4X > Y
{X=1/4, Y=1}.
{ X=1/4, Y=1 }
?- "ABC"
<
"BCD".
{}
?-
label
>=
labelle.
?-
Voir galement :
val, is
PrologIA
411
X=Y
Fonction
: Unification de deux termes
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Se comporte comme la rgle prdfinies eq . Cette primitive est dfinie
comme suit :
X=X.
Exemples :
?- X = 1.
{ X=1 }
?- X = f(X).
{ X=f(X) }
?- f(f(X))
f(f(f(X))).
{ X=f(X) }
Voir galement :
eq
412
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
X == Y
Fonction
: Egalit formelle de deux termes
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Russit quand les termes X et Y sont formellement gaux, c'est--dire quand
l'ensemble de solutions de X est le mme que celui de Y . Sinon chec. Cette
rgle prdfinie est dfinie comme suit :
X == Y :- not(dif(X,Y)) .
Exemples :
?- X == 1.
?- X == X.
{}
?- X == Y.
?-
Voir galement :
not, dif
PrologIA
413
X \== Y
Fonction
: Non-galit formelle de deux termes
Classe
Catgorie
Paramtres connus
: Aucun
Messages d'erreur
: Non
Description :
Russit quand les termes X et Y ne sont pas formellement gaux. Cette
rgle prdfinie est dclare comme suit :
X \== Y :- not(not(dif(X,Y))) .
Exemples :
?- X \== 1.
{}
?- X \== X.
?- X \== Y.
{}
Voir galement :
not, dif
414
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
X =:= Y
Fonction
: Egalit des valeurs de deux termes
Classe
Catgorie
Paramtres connus
: X et Y
Messages d'erreur
: Erreur dans val
Description :
Evalue les termes X et Y. Russit quand la valeur de X est gale la valeur
de Y , sinon chec. Cette rgle prdfinie est dcrite comme ceci :
X =:= Y :- val(eql(X,Y), 1) .
Exemples :
?- ln(exp(1)) =:= 1 .
{}
?- X =:= X.
Erreur dans val
Voir galement :
val, eql, =\=
PrologIA
415
X =\= Y
Fonction
: Non-galit des valeurs de deux termes
Classe
Catgorie
Paramtres connus
: X et Y
Messages d'erreur
: Erreur dans val
Description :
Evalue les termes X et Y. Russi quand la valeur de X est diffrente de la
valeur de Y , choue sinon. Cette rgle prdfinie est dcrite comme ceci :
X =\= Y :- val(eql(X,Y), 0) .
Exemples :
?- exp(1) =\= ln(1) .
{}
?- X =\= 2.
Erreur dans val
Voir galement :
val, eql, =:=
416
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
X -> Y
Fonction
: Si-Alors
Classe
Catgorie
: Contrle
Paramtres connus
: X et Y qui doivent tre connus leur appel
Messages d'erreur
: Non
Description :
Tente d'effacer X une fois. Si c'est possible, excute alors Y de toutes les
faons possibles. Voici cette rgle prdfinie :
X -> Y :- X , ! , Y .
PrologIA
417
X,Y
Fonction
: Squence d'excution
Classe
Catgorie
: Contrle
Paramtres connus
Messages d'erreur
: Non
Description :
Excute X. Si c'est un succs, excute alors Y. C'est le mcanisme principal
d'une queue de rgle. Voici cette rgle prdfinie
X , Y :- X , Y .
418
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
X;Y
Fonction
: Alternative d'excution
Classe
Catgorie
: Contrle
Paramtres connus
Messages d'erreur
: Non
Description :
Installe un point de choix. Voici ces rgles prdfinies
X ; Y :- X .
X ; Y :- Y .
Exemples :
?- write(1)
write(2).
1{}
2{}
PrologIA
419
'[]'(X, Y)
[X|Y]
[]
Fonction
: Liste de buts excuter
Classe
Catgorie
: Contrle
Paramtres connus
Messages d'erreur
: Non
Description :
Excute les buts X puis Y. Se comporte comme ',' . Cette primitive est
dcrite comme ceci
'[]'.
'[]'(X, Y) :- X, Y .
Exemples :
?- [out(a),out(b),out(c)].
abc{}
?- [].
{}
420
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Index des rgles prdfinies, procdures externes

et fonctions valuables pour la syntaxe Edimbourg
, 418
-> 417
put 397
read 398
< 411
= 412
=.. 410
retract 399
retractall 400
see 401
=:= 415
=< 411
seen 402
tab 403
== 413
=\= 416
> 411
tell 404
told 405
true 406
>= 411
[] 420
\== 414
abolish 377
assert 378
asserta 380
assertz 378
atom 381
atomic 382
call 383
clause 384
var 407
write 408
writeq 409
consult 385
functor 386
get 387
get0 388
is 389
listing 390
member 391
name 392
nl 393
nonvar 394
number 395
op 396
PrologIA
421
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Les syntaxes de Prolog III
1. Introduction
- Choix du mode syntaxique
- Points communs, diffrences
- Conventions grammaticales
- Jeu de caractres
- Constantes communes
2. Syntaxe de base
- Variables
- Identificateurs
- Termes
- Contraintes
- Rgles et requtes
- Quelques remarques
3. Syntaxe d'Edimbourg
- Variables
- Identificateurs
- Termes
- Contraintes
- Rgles et requtes
- Quelques remarques
4. Remarques gnrales
Vous pouvez utiliser Prolog III travers deux syntaxes diffrentes, appeles ici
syntaxe de base et syntaxe Edimbourg ; leur description est l'objet de ce
chapitre.
Dcembre 1990
PrologIA
Syntaxes
Aociation
1 . Introduction
Choix du mode syntaxique
Au dmarrage dune session Prolog III, la syntaxe utilise est la syntaxe de

base. Vous pouvez en changer en excutant la commande
>
{}
?-
edinburgh;
L'apparition du prompt dEdimbourg, ?- vous indique le succs de votre

manipulation. Les requtes peuvent tre donnes immdiatement; par
contre, pour l'entre des rgles, il faut utiliser les prdicats prdfinis insert
ou consult. Vous devez savoir que pour revenir en syntaxe de base, il vous
suffit d'excuter
?- prologIII.
{}
>
Points communs, diffrences
Disons brivement que la syntaxe de base et tire en grande partie de celle

de Prolog II, et que son style est empreint de notations mathmatiques. La
syntaxe Edimbourg est plus rpandue dans le monde travers ses
dialectes. En voici un de plus, tendu bien sr aux fonctionnalits de
Prolog III.
424
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Syntaxes
HERITAGE
Bien que ces deux syntaxes puissent paratre trs diffrentes, au moins par
leur prsentation et leur esprit, un travail important de mise en commun a
t ralis, permettant, pour un programme Prolog III donn, une
traduction trs aise d'une syntaxe vers l'autre. Il tait indispensable quun
lecteur habitu la syntaxe Edimbourg ne soit pas pnalis, voire induit en
erreur par ses habitudes syntaxiques.
Passons aux points communs et diffrences. On peut noter comme point
commun le jeu de caractres (en premire approximation), mais surtout
lensemble des constantes aux identificateurs prs. Il existe toutefois une
syntaxe commune didentificateur, dite d identificateur quot, malheureusement peu lisible. Les variables ont des syntaxes distinctes, mais l
encore, il existe une forme commune dite de variable underline1. Insistons
sur le fait quil existe des moyens de se passer de ces formes alternatives, car
les deux syntaxes de variables ont une intersection non-vide et quil en va de
mme pour les identificateurs.
Les termes sous notation fonctionnelle ainsi que les tuples et les listes
scrivent de faon identique dans les deux syntaxes. Le point de divergence
est le moment o, en syntaxe Edimbourg, on dcrit sous forme de termes les
contraintes, rgles et requtes; cette vision des choses tant grandement
favorise par lintroduction des oprateurs, ces symboles qui permettent des
notations infixes, postfixes ou prfixs. Mais si on examine ce quon peut
produire avec ces syntaxes, on saperoit rapidement que les contraintes
scrivent de la mme faon ( une exception prs) et que les rgles et
requtes se forment peu prs selon un patron commun.
Conventions grammaticales
Les grammaires de Prolog III sont dcrites sous forme densembles de rgles
hors contexte augmentes de quelques signes spciaux. Le signe de
rcriture est "::=" et le membre gauche dune rgle nest pas rpt lorsquil
est identique celui de la rgle prcdente.
Underline est le nom anglo-saxon du caractre _ qu'on surnomme blanc soulign.
Prolog IA
425
Syntaxes
Aociation
Les non-terminaux sont des suites de mots entours par "<" et ">" .
Les terminaux du langage sont crits en caractres gras. Le mot espace
dsigne quant lui un caractre parmi les caractres barre
despacement, touche de tabulation, retour-chariot, et autres caractres
non-imprimables1. Les blancs qui figurent dans les rgles ne sont pas
significatifs.
On appelle lment tout terminal, non-terminal ou toute suite
dlments parenthss par les signes "[" et "]" ou bien par "{" et "}".
Les crochets "[" et "]" dlimitant une suite dlments indiquent que sa
prsence est facultative.
Les accolades "{" et "}" indiquent que la suite dlments quils
parenthsent peut tre absente ou se rpter une ou plusieurs fois.
La barre "| " dsigne une alternative dans une rgle et permet de ne
pas rpter ce qui prcde.
Un commentaire est un texte en italique.
Dans les cas o une rgle syntaxique sexprimerait formellement de manire
trop complexe (et serait donc incomprhensible), on se permettra une
entorse aux conventions ci-dessus en donnant une rgle simplifie et un
commentaire concernant sa validit ou ses exceptions.
Jeu de caractres
Voici le jeu de caractres utilis par Prolog III :

<jeu de caractres>
::= <caractre spcial>
::= <lettre>
::= <chiffre>
426
Prolog
HERITAGE
Ce sont les caractres dont le code ASCII est compris entre 1 et 32.
PrologIA
Aociation
Prolog
Syntaxes
HERITAGE
<caractre spcial>
::= + | - | * | / | _ | !
::= ( | ) | { | } | [ | ] | < | >
::= . | | | & | ~ | , | ; | : | #
::= $ | ' | ` | ;
::= espace
<lettre>
::= <minuscule>
::= <majuscule>
<minuscule>
::= a | b | | z les accents sont pour plus tard
<majuscule>
::= A | B | | Z
<chiffre>
::= 0 | 1 | | 9
<chiffre octal>
::= 0 | 1 | | 7
<chiffre hexa>
::= 0 | 1 | | 9 | A | | F | a | | f
Nous verrons la fin de ce chapitre, une fois la syntaxe entirement dcrite,
le statut particulier du caractre espace .
Constantes
Les constantes sont les donnes les plus simples. On distingue les constantes
suivantes :
les identificateurs,
les nombres entiers non-ngatifs, rels non-ngatifs,
les boolens,
Prolog IA
427
Syntaxes
Aociation
la liste vide,
les constantes caractres,
les chanes de caractres.
<constante>
::= <identificateur>
::= []
::= <boolen>
liste classique vide
::= <entier>
::= <liste vide>
::= <rel>
tuple vide
::= <constante caractre>

::= <chane de caractres>
Voici la syntaxe de ces diffrentes constantes, l'exception des identificateurs
dcrits plus loin :
<entier>
::= <chiffre> { _ | <chiffre> }
1_123_456
ou 432513
<boolen>
::= 0' | 1'
<liste vide>
::= <>
<rel>
::= <mantisse> [ <exposant> ]
<mantisse>
::= <suite de chiffres> . <suite de chiffres>
::= <suite de chiffres> .
::= . <suite de chiffres>
<exposant>
::= <Ee> [ <signe> ] <suite de chiffres>
428
Prolog
HERITAGE
PrologIA
comme 1.4e-17
Aociation
Prolog
Syntaxes
HERITAGE
<signe>
::= + | <Ee>
::= E | e
<suite de chiffres>
::= <chiffre>
::= <chiffre> <suite de chiffres>
Pour les rels la syntaxe est simple : au moins un chiffre pour la mantisse, le
point y est obligatoire mais lexposant est facultatif. Attention : le rel lu est
le plus long possible, cela peut crer des situations confuses (2.0f6 se lit
2 f6 , o f6 est une variable, mais 2.0e6 se lit 2 000 000 ).
Des exemples dentiers corrects :
1234
1_234_567
815915283247897734345611269596115894272000000000
Des exemples dentiers incorrects :

variable
suite de deux entiers
_27
12
34
98.0
0.
Quelques rels valides :

1.e6
rels
106
3.14e-6
0,5 106
3,14 10-6
4.
.666
0,666
.5e6
Et dautres qui nen sont pas :

e10
.e10
1.2e
3e10
cest la variable ou lidentificateur e10

la mantisse doit avoir au moins un chiffre
valeur de lexposant absent
absence du point de la mantisse (3e10)
Prolog IA
429
Syntaxes
Aociation
Nous allons maintenant introduire le caractre dchappement \ . Celui-ci

nous permettra, lintrieur dune chane ou dune constante de type
caractre, de reprsenter certains caractres parfois indisponibles au clavier,
ou bien dy masquer certains caractres inopportuns, comme le retour
chariot que lon doit taper pour que le tampon du clavier ne dborde pas
lorsquon frappe une ligne trop longue.
Nous introduisons ici la dfinition dun caractre dsign, qui est trs proche
de ce qui ce passe dans le langage C ce niveau.
<caractre dsign>
::= \ <lettre sauf x>
::= \ <caractre spcial>
::= \ <chiffre octal> <chiffre octal> <chiffre octal>
::= \ <chiffre octal> <chiffre octal>
::= \ <chiffre octal>
::= \ x <chiffre hexa> <chiffre hexa>
::= \ x <chiffre hexa>
Si le caractre \ est suivi :
- dun retour chariot, celui-ci est ignor. (aucun caractre)
- dun entier compos de trois chiffres octaux au plus, le caractre
dsign reprsente le caractre dont le code ASCII est cet entier en base
8.
- de la lettre x et dun entier compos de deux chiffres hexadcimaux au
plus, le caractre dsign reprsente le caractre dont le code ASCII est
cet entier en base 16.
430
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Syntaxes
HERITAGE
- dun des caractres du clavier, alors on a la correspondance suivante

entre les caractres dsigns et les caractres quils reprsentent :
\b
rubout
ASCII
\t
tabulation
"
\l
linefeed
"
10
\f
formfeed
"
11
\r
return
newline
escape
"
13
"10 ou 13 (machine)1
"
27
\n
\e
Pour tout c nappartenant pas lensemble des caractres n, e, f, l, r,

t, b, x , la squence \ c dsigne le caractre c . En particulier \ \
reprsente \ , et \" le caractre " , ce qui permet notamment leur

utilisation lintrieur des chanes. Nous pouvons maintenant dfinir
ce que sont une constante caractre et une chane de caractres.
<constante caractre>
::= ` <caractre constant> `
il sagit de laccent grave
<chane de caractres>
::= " { <caractre constant sauf "> | "" } "
<caractre constant>
::= <caractre du clavier sauf retour-chariot>
::= <caractre dsign>
Voici quelques exemples de caractres constants :
à`
reprsente le caractre a
`\\`
`\n`
reprsente le caractre \
reprsente le caractre retour la ligne
`\170`
reprsente le caractre z
Quelques exemples de chanes de caractres :

"Toto
va
(1)
l'ecole"
Ce code est dpendant de la machine, utilisez\n au lieu de \012 ou \r !
Prolog IA
431
Syntaxes
"Toto
a
Aociation
va
(2)
l'ecole"
"Cette
"Les
chaine
crochets
contient\nun
\"[\"
et
retour
\"]\"
chariot"
indiquent..."
(3)
(4)
Les chanes (1) et (2) sont identiques; il en est de mme pour les chanes (3)
et (4) . La chane (5) a pour contenu :
Les
crochets
"["
et
"]"
indiquent...
Les chanes de caractres suivantes sont incorrectes :

"""
"a"b"
2 . Syntaxe de base
Variables
Les caractres utilisables dans une variable sont les suivants :

<alphanumrique tendu>
::= <lettre>
::= <chiffre>
::= '
::= _
::= $
apostrophe
underline
dollar
Dans toutes les modes syntaxiques (syntaxe de base et syntaxe Edimbourg),

on peut crire une variable de la faon suivante :
<variable>
::= _ { <alphanumrique tendu> }
par exemple : _x
432
Prolog
HERITAGE
_1
_toto'
_F_F_
PrologIA
_underline
_'
Aociation
Prolog
Syntaxes
HERITAGE
Un cas particulier de nom de variable est le nom _, dont chaque occurence

reprsente une nouvelle variable que l'on ne souhaite pas nommer. A cette
exception prs, cette notation reste exceptionnelle et on lui prfre la forme
suivante, spcifique la syntaxe de base :
<variable>
avec la restriction que le deuxime caractre (sil existe)

ne doit pas tre une lettre.
Voici des exemples de variables syntaxiquement correctes :

x
z'
p2c
x78x
m68000
x__y'
u'2
z''
a_
n_ouvelle_variable' I'can
N.B. : L'usage du caractre $ est dconseill ; Prolog III l'utilise pour nommer
des variables qu'il est amen crer de manire interne.
Identificateurs
Un identificateur peut tre complet ou abrg. Il est complet sil est prfix :
<prfixe>
::= [ <nom> { : <nom> } ]
orbis:lex
<nom>
<identificateur>
Prolog IA
sys:outm
outm
433
Syntaxes
Aociation
::= <lettre> <lettre> { <alphanumrique tendu> }
On remarquera que la syntaxe des identificateurs abrgs est trs proche de
celle des variables. La diffrence retenir est quune variable dbute par une
lettre au plus alors quun identificateur commence par au moins deux lettres.
La forme prcdente est spcifique de la syntaxe de base. Dans les deux
syntaxes, un identificateur abrg peut aussi scrire :
::= ' { <caractre constant sauf ' > | '' } '
Voici des exemples didentificateurs corrects :
pommme
pommme'
xx'1
xx'2'
zZ44a_45b__c46'
en voici dautres qui sont incorrects (ce sont en fait des variables) :
t_iti
I'm_happy
B29
Termes
<terme>
::= <terme1>
::= <terme> <=> <terme1>
::= <terme> => <terme1>
<terme1>
::= <terme2>
::= + <terme2>
::= - <terme2>
::= <terme1> + <terme2>
::= <terme1> - <terme2>
::= <terme1> | <terme2>
434
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Syntaxes
HERITAGE
<terme2>
::= <terme3>
::= <terme2> & <terme3>
::= <terme2> * <terme3>
::= <terme2> / <terme3>
<terme3>
::= <terme4>
::= ~ <terme3>
<terme4>
::= <terme5>
::= <terme5> ( <suite de termes> )
::= <terme5> [ <terme> ]
::= [ <suite de termes> ]
::= [ <suite de termes> | <terme> ]
::= <terme4> . <terme5>
liste classique
liste classique
<terme5>
::=
::=
::=
::=
<variable>
<constante>
< <suite de termes> >
( <terme> )
<constante>
::= []
liste vide
::= <boolen>
::= <entier>
::= <liste vide>
tuple vide
::= <rel>
Prolog IA
435
Syntaxes
Aociation
<multiplicande>
::= <entier>
::= <rel>
::= ( <terme> )
<suite de termes>
::= <terme>
::= <terme> , <suite de termes>
Cette syntaxe va nous permettre de construire des expressions numriques
laide en particulier des quatres oprateurs + - * / , des expressions
boolennes grce aux oprateurs boolens | & ~ <=> =>, de construire
des tuples avec le constructeur de tuple < > et loprateur de concatnation
., de former des arbres laide des parenthses () ou des crochets [] .
Les expressions numriques de Prolog III sont formes laide de constantes
numriques, de variables, des quatre oprations +-*/ Donnons quelques
exemples dexpressions numriques correctes :
-x
355/113
-3/2
-3x/4
(1000-1*2*3*4*5*6*7)y
-
(2x-1)y
(1-3/4)*(x+y-2z/5)
(14-22/7)x
+
(a-b)/(x-y)
et des exemples incorrects :

5/4x
est un arbre dont ltiquette est 5

est syntaxiquement incorrecte
xy
est un identificateur et non pas x y
3*-x
doit scrire 3*(-x)
5(x+y)
Les expressions boolennes sont formes laide de variables, de boolens et
des oprateurs de priorits dcroissantes non, et, ou, quivalent et implique,
nots respectivement ~ & | <=> =>. Le parenthsage permet de modifier
les priorits. Voici des exemples dexpressions boolennes correctes :
436
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Syntaxes
HERITAGE
x
1'
x|y
~~y
x&~x
c&1'
(u3 & ( ~x1 <=> x3 )) | 0'
Arbres et Termes
Sur le plan strictement syntaxique, un terme est un couple constitu dune
tiquette et dune liste (ventuellement vide) de fils. Un arbre est un terme
sans variables. Une feuille est un terme sans fils que lon confond avec son
tiquette. Quelques exemples de termes corrects :
(ff(x,y))(a,b,c)
(4z+y)(caractere(`c`,
"caractere
`c`"))
<1,2,A,B>.Z
E[<a,b,c>.R]
[1,2,3
L]
le constructeur gnral darbre.

une liste classique.
- On notera que lon a parenths ltiquette des deux premiers termes .

- Dans le dernier exemple la barre est le sparateur de paire-pointe et non pas
lopration ou-boolen. Si on souhaite exprimer la liste contenant lexpression
boolenne A|B, il faut crire [(A|B)] au lieu de [A|B].
- On insistera fortement sur le fait que syntaxiquement correct ne signifie pas
smantiquement correct.
Des exemples de termes syntaxiquement incorrects :
toto(x,y)(z,t)
toto()
Contraintes
Les contraintes sont toujours exprimes lintrieur dun ensemble entre

accolades {} , appel systme de contraintes . On distingue quatre familles de
contraintes :
Prolog IA
437
Syntaxes
Aociation
les contraintes gnrales dgalit et de diffrence de termes,

les contraintes de typage de termes,
les contraintes numriques infrieur et suprieur (ou gal),
la contrainte boolenne implique .
Voici la syntaxe des systmes de contraintes :
::= { }
<contrainte>
::= <terme> = <terme>
::= <terme> # <terme>
::= <terme> => <terme>
::= <contrainte de typage>
::= <contrainte Sup>
::= <contrainte Inf>
::= <variable> !freeze( <terme> )
<contrainte Sup>
::= <terme> <terme>
::= <contrainte Sup> <terme>
a>b
<contrainte Inf>
::= <terme> <inf> <terme>
::= <contrainte Inf> <inf> <terme>
<inf>
::= < | <=

::= > | >=
Nous pouvons donner la syntaxe des contraintes de typage :
438
Prolog
HERITAGE
PrologIA
1>a>b>c
Aociation
Prolog
Syntaxes
HERITAGE
<type darbre>
::= !idt | !boolt | !numt | !chart | !tuple
::= !id | !bool | !num | !char
<contrainte de typage>
::= <terme> <type d'arbre>
::= <terme> :: <terme>
Les systmes de contraintes suivants sont quivalents :
{ t !id }
et
{ t !idt,
t::0
{ t !bool }
et
!boolt,
t::0
{ t !num }
et
!numt,
t::0
{ t !char }
et
!chart,
t::0
Donnons quelques exemples de contraintes correctes :

{
x!num,
f!idt,
b(i,j),
f::3,
l::7n+u*v
"toto"=z,
a=>b&c,
}
t
<
3x/4+5y
Rgles et requtes
<rgle>
::= <tte> -> { <but> } [ , <systme de contraintes> ] ;
<requte>
::= { <but> } [ , <systme de contraintes> ] ;
<but>
::= / | !
slash ou cut c'est la mme chose
::= <terme>
<tte>
::= <terme>
Prolog IA
439
Syntaxes
Aociation
avec les restrictions suivantes :

la simple vrification des contraintes comme elles sont crites dans la
rgle doit imposer au terme de <tte> :
- d'avoir une tiquette qui est un identificateur connu
- d'avoir un nombre de fils connu
un but (lorsque cest un terme) doit tre de type !idt.
les buts, lorsquils sont prsents, doivent tres spars par des
caractres espaces.
les rgles sont ranges par paquets ayant mme nom de prdicat
daccs (identificateur de tte) et par sous-paquets o ces prdicats ont
la mme arit.
Voici quelques exemples de rgles syntaxiquement correctes :
repas(x,y,z)
->
add(a,b,<a,b,c>)
hors_d_oeuvre(x)
->
,{l!tuple,
chats_oiseaux_pattes_tetes(c,
plat(y)
b!num,
o,
4c+2o,
dessert(z);
c=a+b*b};
c+o)
->;
quelques exemples de requtes syntaxiquement correctes :

repas(salade,viande,d);
repas(h,sole,d)
add(a,b,c)
{h#salade};
add(c,d,e)
circuit(c,a,b)
,{a<0',
,{c|a&~b
e>0};
456,
d=>c,
d#b};
Rappelons quune rgle ou une requte peut tre syntaxiquement correcte

sans quelle soit pour autant valide et accepte par le systme Prolog III. Les
restrictions smantiques (par le typage par exemple) rduisent fortement les
constructions potentielles permises par la syntaxe.
440
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Syntaxes
HERITAGE
Quelques remarques
Caractre espace.
Formulons quelques remarques sur le statut du espace. Il peut tre insr
partout sans effet de bord, sauf lintrieur :
- dune variable,
- dune constante,
- dun but de la forme tt(gg) , o un espace entre tt et la parenthse
crerait une scission en deux buts tt et (gg) , ou une erreur de
syntaxe.
De mme, espace peut tre enlev de partout sauf lintrieur dune
constante et aux endroits o son retrait provoque la fusion de deux units
lexicales en une seule.
Continuation de ligne.
La squence \<retour-chariot> est compltement ignore pendant la lecture
de terme et de rgles. Cela rsout des problmes de prsentation (chaine ou
nombre trop long). Par exemple,
regle(123456\
78912)
->;
(le 7 tant bien en dbut de la seconde ligne) est la mme chose que :
regle(12345678912)
->;
Prolog IA
441
Syntaxes
Aociation
Les diffrents commentaires

Un commentaire est une suite de caractres parenthss par les groupements
particuliers /* et */ . Il peut apparatre partout o un caractre espace
serait non-significatif. On peut aussi parenthser les commentaires laide de
groupements forms par la rptition de /* pour louverture et de */ pour
la fermeture, avec un mme facteur de rptition. Ceci permet demboter
les commentaires. Voici des exemples :
/* ceci est un
commentaire
/*/*
le
tenant
texte
/*
sur
deux
commentaire
lignes*/
*/
est
inclus
*/*/
Un autre type de commentaire est celui introduit par le caractre % et qui se

termine la fin de la ligne courante.
texte
commenter
commentaire
3 . Syntaxe d'Edimbourg
Variables
Les caractres utilisables dans une variable sont les suivants :

<alphanumrique tendu>
::= <lettre>
::= <chiffre>
::= '
::= _
apostrophe
underline
::= $
dollar
Dans toutes les modes syntaxiques (syntaxe de base et syntaxe Edimbourg),

on peut crire une variable de la faon suivante :
442
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Syntaxes
HERITAGE
<variable>
::= _ { <alphanumrique tendu> }
par exemple : _x
_1
_toto'
_F_F_
_underline
_'
Un cas particulier de nom de variable est le nom _, dont chaque occurence

reprsente une nouvelle variable que l'on ne souhaite pas nommer. A cette
exception prs, cette notation reste exceptionnelle et on lui prfre la forme
suivante, spcifique la syntaxe Edimbourg :
<variable>
::= <majuscule> { <alphanumrique tendu> }
Voici des exemples de variables syntaxiquement correctes :
X
W'
Z''
P2c
Nouvelle_variable
X__y'
U'2
A_
I'can
N.B. : L'usage du caractre $ est dconseill ; Prolog III l'utilise pour nommer
des variables qu'il est amen crer de manire interne.
Identificateurs
Un identificateur peut tre complet ou abrg. Il est complet sil est prfix :
<prfixe>
::= [ <nom> { : <nom> } ]
orbis:lex
<nom>
<identificateur>
Prolog IA
sys:outm
outm
443
Syntaxes
Aociation
::= <minuscule> { <alphanumrique tendu> }
On remarquera que la syntaxe des identificateurs abrgs est trs proche de
celle des variables. La diffrence retenir est quune variable dbute par une
lettre majuscule alors quun identificateur commence par une lettre
minuscule.
La forme prcdente est spcifique de la syntaxe Edimbourg. Dans les deux
syntaxes, un identificateur abrg peut aussi scrire entre simples guillemets
:
::= ' { <caractre constant sauf ' > | '' } '
Voici des exemples didentificateurs corrects :
pommme
pommme'
x'1
xx'2'
a_
zZ44a_45b__c46'
en voici dautres qui sont incorrects (ce sont en fait des variables) :
Titi
I'm_happy
B29
Les identificateurs entre guillemets ne sont pas des

chaines de caractres.
Termes
Oprateurs
Les oprateurs permettent d'exprimer de faon simples les arbres et
expressions. Leur syntaxe est la suivante :
444
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Syntaxes
HERITAGE
<oprateur>
::= <constante>
::= <variable>
::= <suite de caractres>
avec la restriction que <suite de caractres> ne commence ni par une constante ni
par une variable ni par un espace ni par % ni par /* .
La longueur de cette suite dpend des dclarations doprateurs connues de
Prolog III au moment de la lecture. Cette suite est la plus longue possible
parmi ces dclarations.
On distingue quatre sortes d'oprateurs : ceux qui sont prfixs et admettent
un oprande droite, ceux postfixs qui ont un oprande gauche, les
oprateurs infixes ayant deux oprandes ( droite et gauche) et ceux qui
sont isols (sans oprandes).
Nous noterons ces types d'oprateurs fz zf zfz f qui rsument la faon
dont l'expression est construite ( f dsignant l'oprateur et le ou les z
dsignant les oprandes). On attribue tout oprateur sa priorit (ou
prcdence) sous la forme d'un nombre entier n. Par convention, la
prcdence des oprandes se calcule l'aide de cet n et de la forme exacte du
type de l'oprateur (xf, yf, .f , ) de la faon suivante : si en lieu d'un
oprande (z) on trouve x la prcdence est n-1, si on trouve y la prcdence
est n, sinon on trouve un . et la prcdence est un nombre indpendant de
n et fourni en mme temps que l'oprateur. Indiquons de suite que la forme
o l'un des oprandes est un point (.fx, ) ne sert que pour construire des
termes composs1. Voici un tableau rcapitulatif du calcul des prcdences :
type
xf
yf
fx
fy
xfx
xfy
yfx
prcdence op.
n-1
n-1
n-1
n-1
n-1
prc. op. gauche (g)

prc. op. droite
(d)
n-1
Le prdicat prdfini op ne permet pas de dfinir de tels oprateurs composs.
Prolog IA
445
Syntaxes
Aociation
(suite )
type
.f
f.
xf.
.fx
yf.
.fy
prcdence op.
prcdence fournie
prc. op. gauche (g)
n-1
n-1
prc. op. droite
(d)
<f, n>
::= <oprateur>
<fz, n, d>
::= <oprateur>
<zf, n, g>
::= <oprateur>
<zfz, n,g,d>
::= <oprateur>
Les termes
<termes:, n>
::= <fz, n,d> <terme, d>
::= <terme, g> <zfz, n,g,d> <terme, d>
::= <terme, g> <zf, n,g>
::= <f, n>
::= <terme, n-1>
::= <terme compos, n>
<terme compos, n>
::= <f. ,n,M> <terme, M> <.f,n,M>
+x
a*b
x-18
(x)
::= <f. ,n,M> <terme,M> <.fz,n,M,d> <terme, d> (2+1)x

::= <terme, g> <zf. , n,g,M> <terme, M> <.f, n,M>
f[x]
Cette dernire rgle <terme compose, n> permet de dcrire sous forme
d'oprateurs les divers mcanismes de parenthsage par des symboles
comme les parenthses, crochets, chevrons, et tout couple d'oprateurs
simples que l'on souhaite mettre en correspondance.
Nous allons maintenant dcrire les oprateurs travers un tableau dont le
contenu ligne par ligne a la forme suivante :
446
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Syntaxes
HERITAGE
les caractres composant l'oprateur (sauf s'il s'agit d'une famille

d'oprateurs comme entier, en italique)
un nom interne qui nous servira prciser ce qu'on a construit.
le type de l'oprateur .
la prcdence de l'oprateur.
la prcdence fournie (dans le cas o l'oprateur est destin a tre
appair un autre; ils doivent dans ce cas avoir une mme prcdence
fournie).
une action parmi {empile, dpile, teste, teste non} qui permet de
manipuler et tester le contexte1 courant. Il faut que l'action russisse
pour que l'oprateur soit applicable. Ces actions ont pour paramtre
un caractre; voici leurs effets respectifs :
- empile car
tablit le nouveau contexte car .
- dpile car teste que le contexte est bien car et
restitue le prcdent contexte.
- teste car
teste que le contexte est bien car .
- teste non car
teste que le contexte n'est PAS car .
Une action russi lorsque le test est vrifi (empile russi toujours).
Oprateur
Nom Interne
{
{
}
:;
,
,
,
,
,
!
=
#
=>
CONTR
CONTR
CONTR
FLECHE
PVIRG
VLISTE
VFONCT
VTUPLE
VCONTR
VIRG
CUT
EGAL
DIFF
IMPLIQUE
Type
xf.
f.
.f
xfx
xfy
xfy
xfy
xfy
xfy
xfy
f
xfx
xfx
xfx
Prc. op
Prc. bis
1300
1300
1300
1200
1100
1000
1010
1010
1010
1010
700
650
650
650
10001
10001
10001
Action
empile '{'
empile '{'
dpile '}'
teste
teste
teste
teste
'['
'f'
'<'
'{'
On appelle ici contexte le sommet dune pile de caractre (vide au dpart).
Prolog IA
447
Syntaxes
Aociation
::
!tuple
!boolt
!bool
!numt
!num
!chart
!char
!idt
!id
!freeze(
)
DEUXPTS
TYPTUPLE
TYPBOOLT
TYPBOOL
TYPNUMT
TYPNUM
TYPCHART
TYPCHAR
TYPIDT
TYPID
TYPFREEZE
TYPFREEZE
Oprateur
Nom Interne
<
=<
>
>=
INF
INFEG
SUP
SUPEG
xfx
xfx
xfx
xfx
650
650
650
650
EQUIV
BARRE
OU
yfx
xfx
yfx
600
1002
500
ADD2
SUB2
ET
MULT
DIV
ADD1
SUB1
NON
CONC
yfx
yfx
yfx
yfx
yfx
fy
fy
fy
yfx
500
500
400
400
400
200
200
200
100
TUPLE
TUPLE
GENERAL
GENERAL
LISTE_ED
LISTE_ED
FONCTION
FONCTION
PARENTH
PARENTH
PARENTH
NUMVAR
ENTIER
f.
.f
xf.
.f
f.
.f
xf.
.f
f.
.fx
.f
fx
f
50
50
50
50
50
50
50
50
2
2
2
2
2
<=>
|
|
'['
+
&
*
/
+
~
.
<
>
[
]
[
]
(
)
(
)
)
entier
entier
448
Prolog
HERITAGE
xfx
xf
xf
xf
xf
xf
xf
xf
xf
xf
xf.
.f
Type
650
650
650
650
650
650
650
650
650
650
650
650
10002
10002
Prc. op
Prc. bis
PrologIA
empile 'z'
dpile 'z'
Action
teste '['
teste
non
10003
10003
10004
10004
10005
10005
10006
10006
10007
10007
10007
empile '<'
dpile '<'
empile 'c'
dpile 'c'
empile '['
dpile '['
empile 'f'
dpile 'f'
empile '('
dpile '('
dpile '('
Aociation
Prolog
Syntaxes
HERITAGE
ident.
[]
carac.
boolen
chane
<>
flottant
flottant
variable
IDENT
IDENT
CHAR
BOOL
CHAINE
VIDE
NUMVAR
FLOAT
VAR
f
f
f
f
f
f
fx
f
f
2
2
2
2
2
2
2
2
1
On peut constater que certains oprateurs se retrouvent

sur deux lignes avec des types ou prcdences
diffrentes.
Par exemple, e n t i e r peut tre un oprateur prfix
(produit par dfaut d'un nombre et d'une variable en
l'occurence).
Ce tableau tant quelque peu abrupt, nous allons aussi prsenter la syntaxe
des termes sous une forme plus habituelle dans laquelle les oprateurs
composs et oprateurs isols (f) n'apparaissent plus en tant que tels, mais
forment le corps des rgles de grammaire.
<terme>
::= <terme, 1300>
<terme, 1300>
::= <terme, 1299> [ <systme de contraintes> ]
::= <systme de contraintes>
::= { <terme, 999> {, <terme, 999> } }
<terme, n>
::= <fz, n,d> <terme, d>
::= <terme, g> <zfz, n,g,d> <terme, d>
::= <terme, g> <zf, n,g>
::= <terme, n-1>
+x
a*b
x--
Prolog IA
449
Syntaxes
Aociation
<terme, 50>
::= <terme, 49>
::= <terme, 49> ( <suite de termes> )
::= <terme, 49> [ <terme> ]
::= [ <suite de termes> ]
::= [ <suite de termes> | <terme, 999> ]
::= <terme, 50> . <terme, 49>
fonction
constructeur d'arbre
liste classique
paire pointe
concatnation
<terme, 2>
::= <variable>
::= <constante>
::= < <suite de termes> >
::= ( <terme, 1300> )
<constante>
::= []
::= <boolen>
::= <entier>
::= <liste vide>
::= <rel>
<multiplicande>
::= <entier>
::= <rel>
::= ( <terme, 1300> )
<suite de termes>
::= <terme, 999>
::= <terme, 999> , <suite de termes, 999>
450
Prolog
HERITAGE
PrologIA
tuple
produit par dfaut
liste vide
tuple vide
Aociation
Prolog
Syntaxes
HERITAGE
Cette syntaxe va nous permettre de construire des expressions numriques

laide en particulier des quatres oprateurs + - * / , des expressions
boolennes grce aux oprateurs boolens | & ~ <=> =>, de construire
des tuples avec le constructeur de tuple < > et loprateur de concatnation
., de former des arbres laide des parenthses () ou des crochets [] .
Les expressions numriques autorises par Prolog III sont formes laide
de constantes numriques, de variables, des quatre oprations +-*/
Ces
expressions reprsentent des nombres. Donnons quelques exemples
dexpressions numriques correctes :
-X
355/113
-3/2
-3X/4
(1000-1*2*3*4*5*6*7)Y
-
(2X-1)Y
(1-3/4)*(X+Y-2Z/5)
(14-22/7)X
+
(A-B)/(X-Y)
Insistons sur le fait qu'une expression numrique reste

une feuille et ne forme donc pas un arbre de profondeur
suprieure zro.
et des exemples incorrects :

5(X+Y)
est un arbre dont ltiquette est 5
5/4X
est syntaxiquement incorrecte
XY
est bien sr une variable et non pas X Y
Les expressions boolennes sont formes laide de variables, de boolens et
des oprateurs de priorits dcroissantes non, et, ou, quivalent et implique,
nots respectivement ~ & | <=> => . Le parenthsage permet de modifier
les priorits. Toute expression boolenne reprsente un boolen (connu ou
pas). Voici des exemples dexpressions boolennes correctes :
X
1'
~~Y
X&~X
X|Y
Prolog IA
451
Syntaxes
Aociation
C&1' => D
(U3 & ( ~X1 <=> X3 )) | 0'
Ici encore, toute expression boolenne reste une feuille et

ne forme donc pas un arbre de profondeur suprieure
zro.
Arbres et Termes
Sur le plan strictement syntaxique, un terme est un couple constitu dune
tiquette et dune liste (ventuellement vide) de fils. Un arbre est un terme
sans variables. Une feuille est un terme sans fils que lon confond avec son
tiquette. Voici quelques exemples de termes corrects :
(ff(X,Y))(A,B,C)
(4Z+Y)(caractere(`c`,
"caractere
`c`"))
<1,2,A,B>.Z
a(B,C)
{A<B,
:C
b,
{B=1}
<1,2>}
E[<a,b,c>.R]
le constructeur gnral darbre.
[1,2,3
une liste classique.
L]
- On notera que lon a parenths ltiquette des deux premiers termes .

- Dans le dernier exemple la barre est le sparateur de paire-pointe et non pas
lopration ou-boolen. Si on souhaite exprimer la liste contenant lexpression
boolenne A|B , il faut crire [(A|B)] au lieu de [A|B] .
- On insistera fortement sur le fait que syntaxiquement correct ne signifie pas
smantiquement correct.
Des exemples de termes syntaxiquement incorrects :
toto(x,y)(z,t)
E[1,2]
(1,2)X
toto()
{C=<1,2>}
452
Prolog
HERITAGE
mettre des blancs autour du =
PrologIA
Aociation
Prolog
Syntaxes
HERITAGE
Contraintes
Les contraintes sont toujours exprimes lintrieur dun ensemble entre

accolades {} , appel systme de contraintes . On distingue quatre familles de
contraintes :
les contraintes gnrales dgalit et de diffrence de termes,
les contraintes numriques infrieur et suprieur (ou gal),
la contrainte boolenne implique ,
les contraintes de typage de termes,
Bien qu'un systme de contraintes puisse s'exprimer sous forme de terme,
nous allons en donner un apercu plus cible de sa syntaxe.
<contrainte>
::= <terme, 650>
Prolog IA
453
Syntaxes
Aociation
<terme, 650>
::= <terme, 649> = <terme, 649>
galit gnrale
::= <terme, 649> # <terme, 649>

::= <terme, 649> => <terme, 649>
::= <terme, 649> < <terme, 649>
diffrence gnrale
implique
infrieur
::= <terme, 649> =< <terme, 649>

::= <terme, 649> > <terme, 649>
infrieur ou gal
suprieur
::= <terme, 649> >= <terme, 649>

::= <terme, 649> :: <terme, 649>
::= <terme, 649> !tuple
suprieur ou gal
contrainte de taille
typage
::= <terme, 649> !boolt

::= <terme, 649> !bool
typage
typage
::=
::=
::=
::=
::=
::=
::=
typage
typage
typage
typage
typage
typage
gel
<terme, 649>
<terme, 649>
<terme, 649>
<terme, 649>
<terme, 649>
<terme, 649>
<terme, 649>
!numt
!num
!chart
!char
!idt
!id
!freeze( <terme> )
Les systmes de contraintes suivants sont quivalents :

{ t !id }
et
{ t !idt,
t::0
{ t !bool }
!boolt,
t::0
{ t !num }
et
et
!numt,
t::0
{ t !char }
et
!chart,
t::0
Donnons quelques exemples de contraintes correctes :

{
X!num,
F!idt,
B(I,J),
F::3,
L::7N+U*V
"toto"=Z,
A=>B&C,
}
T
<
3X/4+5Y
Voici quelques exemples de contraintes invalides :

{ X<Y<Z }
{
ff(1,2)
on ne peut pas emboiter les <

ce n'est pas une contrainte
Dans les cas o les contraintes nagissent pas, (quand elles sont en position
de sous-terme par exemple), celle-ci se comportent comme tout arbre. Il en
va de mme avec les systmes. Voici alors ce qui est produit :
454
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Syntaxes
HERITAGE
t1 = t2
construit l'arbre
sys:'='(t1, t2)
t1 # t2
"
sys:'#'(t1, t2)
t1 < t2
"
sys:'<'(t1, t2)
t1 =< t2
construit l'arbre
sys:'=<'(t1, t2)
t1 > t2
"
sys:'>'(t1, t2)
t1 >= t2
"
sys:'>='(t1, t2)
t1 !tuple
"
sys:'!tuple'(t1)
t1 !boolt
"
sys:'!boolt'(t1)
"
t1 !freeze(t2)
"
sys:'!freeze'(t1, t2)
t1 {t2}
"
sys:'{}'(t1, t2)
{t1}
"
sys:'{}'(t1)
{t1, t2}
"
sys:'{}'(sys:','(t1, t2))
t1 => t2
calcule le terme
t1 => t2
Notez bien la dernire ligne qui reprsente un exception

dans le mcanisme gnral de construction. En effet
i m pl i que est une relation dans une contrainte et une
opration partout ailleurs.
Prolog IA
455
Syntaxes
Aociation
Rgles et requtes
<rgle>
::= <terme> <stop>
<requte1>
::= [ ?- ] <terme> <stop>
<stop>
::= . espace
De faon plus pragmatique, rgle et requte ont la forme suivante :
<rgle>
::= <terme> [ <systme de contraintes> ] <stop>
::= <terme> :- <queue> [ <systme de contraintes> ] <stop>
<requte>
::= [ ?- ] [ <queue> ] [ <systme de contraintes> ] <stop>
<queue>
::= <terme>
::= <terme> , <queue>
Sur toute rgle ou requte portent les restrictions suivantes :
la simple vrification des contraintes comme elles sont crites dans la
rgle doit imposer au terme de tte (s'il existe) :
- d'avoir une tiquette qui est un identificateur connu
- d'avoir un nombre de fils connu
un but (lorsque cest un terme) doit tre de type !idt.
les rgles sont ranges par paquets ayant mme nom de prdicat
daccs (identificateur de tte) et par sous-paquets o ces prdicats ont
la mme arit.
456
Prolog
HERITAGE
Dans cette implmentation, :- ne peut servir dbuter une requte.
PrologIA
Aociation
Prolog
Syntaxes
HERITAGE
Il est important de noter que les seules contraintes qui vont agir sont celles
en position indique par les rgles qui prcdent. En effet, l'intrieur d'un
terme (donc en position de sous-terme), elles se comportent comme un
arbre. Il en va de mme avec les oprateurs formant les rgles (comme :-
, , et ; ). Dans ce cas les termes construits sont les suivants :
t1 :- t2
construit l'arbre
sys:':-'(t1, t2)
t1 , t2
"
sys:','(t1, t2)
t1 ; t2
"
sys:';'(t1, t2)
Voici quelques exemples de rgles syntaxiquement correctes :

repas(X,Y,Z)
:-
add(a,B,<A,B,B>)
hors_d_oeuvre(X),
plat(Y),
{L!tuple,
C=A+B*B}.
B!num,
chats_oiseaux_pattes_tetes(C,
O,
4C+2*O,
dessert(Z).
c+O).
quelques exemples de requtes syntaxiquement correctes :

repas(salade,viande,D).
repas(H,sole,D)
?-
sub(A,B,C),
circuit'(B,
{H#salade}.
add(C,D,E)
A,B),
{A<0',
{C|A&~B
E>0}.
456,
D=>C,
D#B}.
Rappelons quune rgle ou une requte peut tre syntaxiquement correcte

sans quelle soit pour autant valide et accepte par le systme Prolog III. Les
restrictions smantiques (par le typage par exemple) rduisent fortement les
constructions potentielles permises par la syntaxe.
Quelques remarques
Caractre espace.
Formulons quelques remarques sur le statut du caractre espace. Il peut
tre insr partout sans effet de bord, sauf lintrieur dune variable ou
dune constante.
Prolog IA
457
Syntaxes
Aociation
De mme, espace peut tre enlev de partout sauf lintrieur dune

constante et aux endroits o son retrait provoque la fusion de deux units
lexicales en une seule (problme typique des oprateurs).
Un espace doit suivre imprativement le caractre . (point) de fin de rgle
ou de requte. C'est ainsi quon distingue ce point final de celui de la
concatnation.
Continuation de ligne.
La squence \<retour-chariot> est compltement ignore pendant la lecture
de terme et de rgles. Cela rsoud des problmes daffichage (chaine ou
nombre trop long). Par exemple,
regle(123456\
78912)
->;
(le 7 tant bien en dbut de la seconde ligne) est la mme chose que :
regle(12345678912)
->;
Les diffrents commentaires

Un commentaire est une suite de caractres parenthss par les groupements
particuliers /* et */ . Il peut apparatre partout o un caractre espace
serait non-significatif. On peut aussi parenthser les commentaires laide de
groupements forms par la rptition de /* pour louverture et de */ pour
la fermeture, avec un mme facteur de rptition. Ceci permet demboter
les commentaires. Voici des exemples :
/* ceci est un
commentaire
/*/*
le
tenant
texte
/*
sur
deux
commentaire
lignes*/
*/
est
inclus
*/*/
Un autre type de commentaire est celui introduit par le caractre % et qui se

termine la fin de la ligne courante.
texte
458
Prolog
HERITAGE
commenter
PrologIA
commentaire
Aociation
Prolog
Syntaxes
HERITAGE
Ooprateurs Edimbourg
D'autres oprateurs Edimbourg ne servant pas directement Prolog III
sont dclars dans cette syntaxe. En voici la liste et ce qui est construit :
Oprateur
Type
Prcdence
is
==
=\=
=:=
\==
->
=..
xfx
xfx
xfx
xfx
xfx
xfx
xfx
700
700
700
700
700
700
700
Construction
sys:is(t1,t2)
sys:'=='(t1,t2)
sys:'=\='(t1,t2)
sys:'=:='(t1,t2)
sys:'\=='(t1,t2)
sys:'->'(t1,t2)
sys:'=..'(t1,t2)
Etrangets
Le terme '+'(X,Y) provoque une erreur de syntaxe (conflit de type); en
effet, ce terme est quivalent +(X,Y) qui est lopration +unaire applique
au terme (X,Y) lequel ne peut tre numrique. Si on souhaite contruire le
terme tiquet par '+' et ayant deux arguments X et Y, il faut crire
('+')(X,Y)
Le but suivant sera mal compris par le systme :
?- X is 3*4.
En effet, le nombre 4 suivit de . est compris en tant que nombre flottant et

le systme reste en attente de la suite du but (nayant pas vu le stop). Il faut
mettre un blanc entre le 4 et le point final.
Lcriture des termes avec oprateurs ne se fait pas au mieux dans cette
implmentation. Ainsi la notation fonctionnelle est utilise pour les
oprateurs qui ne sont pas ceux manipuls au cur de Prolog III.
?- out(X is
is(X,12).
3*4).
Prolog IA
459
Syntaxes
Aociation
{}
4 . Remarques gnrales
Diffrences des modes
Terminons ce chapitre par quelques diffrences entre ces deux modes
syntaxiques.
Les oprateurs + et unaires ne sont pas de mme priorits dans ces
deux syntaxes. En syntaxe de base ils sont au mme niveau que les + et
binaires .
Il n'est pas possible en syntaxe Edimbourg dcrire une cascade de
contraintes infrieur (resp. suprieur).
Le programmeur ne peut pas dfinir doprateur dans la syntaxe de
base. (en syntaxe Edimbourg, voir le prdicat op)
En syntaxe Edimbourg, le => (implique) a une priorit infrieur celle
de <=> (quivalent), alors quelles sont gales en syntaxe de base.
En syntaxe de base, il est possible de rentrer directement des rgles. En
mode Edimbourg, certaines rgles (faits) ressemblants syntaxiquement
des requtes, il tait ncessaire de possder un mode requte et un
mode insertion de rgle (voir les prdicats insert et consult) .
Cohabitation des deux syntaxes

Un point gnant la cohabitation de rgles dans les deux syntaxes est celui de
laffichage de termes provenant de lautre syntaxe et contenant des
variables. Un exemple sera plus explicite :
> egal(x,x) ->;
> edinburgh;
{}
?- list(egal).
egal(x,x).
% x na pas ici la syntaxe de variable
{}
% bien quelle SOIT une variable
?- egal(1,B).
{B=1}
?- assert(titi(Var,Var)).
460
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Syntaxes
HERITAGE
{}
?- prologIII.
{}
> list(titi);
titi(Var, Var) ->;
{}
> titi(11, X);
{ X = 11 }
>
% Var a lair ici d un identificateur

% mais c'est une variable
Ceci nest pas gnant tant quon ne demande pas dcriture de terme (par
solution ou par les prdicats prdfinies trace, out, write, ). Dans ces cas, les
termes crits peuvent sembler confus. Indiquons que dans cette version,
assert utilise lcriture.
Prolog IA
461
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Primitives Graphiques
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
Introduction et conventions
Primitives de gestion des fentres
Dessin et positionnement
Usage de la souris
Modes de dessin et d'criture
Primitives spciales de lecture et d'criture
Primitive de description de menus
Gestion des botes de dialogue
Boutons actifs
Primitives de manipulation de fichiers
Le systme Prolog III comporte un dispositif asynchrone de gestion des vnements

permettant le fonctionnement de l'environnement (fentrage, menus, ...) sans que
l'utilisateur ait rorganiser son programme sous la forme de boucle de gestion des
vnements. La plupart des vnements tels que le redimensionnement d'une
fentre, le dfilement des fentres de texte ..., sont grs automatiquement.
L'utilisateur peut associer des procdures Prolog certains vnements comme la
slection d'un menu, ou le rafrachissement d'une fentre graphique. Les
vnements de type position de la souris ou ralisation d'un clic peuvent tre tests
par programme, ce qui permet de raliser des boucles d'vnements souris.
Dcembre 1990
PrologIA
Primitives graphiques
1 . Introduction et conventions
Ce chapitre dcrit une bibliothque des primitives mises la disposition du
programmeur Prolog III pour la ralisation d'interfaces graphiques. Il
suppose du lecteur une certaine pratique des environnements graphiques
multi-fentres et de leurs botes outils.
Sous Unix ou VMS, on suppose qu'on est plac dans un environnement de
type XWindows (X11) ou SunView. Il faut avoir au pralable lanc Prolog III
avec l'option -W correspondant l'environnement graphique disponible, qui
sont -WS pour SunView, -WX pour XWindows.
Sur ces machines, le graphique est initialis par la commande Prolog III :
>
load_graphic
Le terme console dsigne la fentre de lancement de Prolog III (celle o

apparat la bannire PrologIA).
Les fentres graphiques que l'on peut ouvrir partir de Prolog III sont de
deux types : GRAPHICS ou MODAL.
Les objets attachs une fentre peuvent tre de nature varie : champs
ditables, botes de choix, boutons (actifs ou non), menus de type pop-up,
textes et dessins, etc. Les botes de dialogue (cf. gr_dialog) utilisent en
particulier des fentres de type MODAL , ce qui a pour effet de rendre la
saisie obligatoire dans cette fentre.
Tous les effets graphiques obtenus ici doivent tre considrs, du point de
vue de Prolog, comme des effets de bord. En particulier, un objet dessin
n'est jamais effac au backtracking. De mme, la position du point d'criture
est une variable globale.
464
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Par dfaut, l'image bitmap d'une fentre n'est pas sauvegarde, ce qui veut
dire que le rafrachissement n'est pas assur. Il est possible de le forcer par
l'option <SAVE> des primitives new_window et set_window.
On reprsentera un point de coordonnes d'abscisse X et d'ordonne Y sous
la forme d'un doublet de nombres <X, Y> . De mme, un rectangle sera
donn sous la forme d'un quadruplet de nombres 1 <X,Y, X',Y'>,
correspondant au schma suivant :
X'
Y'
y
On reprsentera un paquet de rgles de nom Identificateur et d'arit arit
sous la forme d'un doublet <Identificateur, arit> .
Enfin, par convention, les primitives qui n'ont d'effet que dans une fentre
graphiques sont prfixes par gr_ . Ces rgles utilisent directement les
procdures du systme graphique de la machine sous-jacente.
Un signe dans la marge indique une primitive ou une caractristique spcifique

au Macintosh. Vous ne devez pas l'utiliser si vous dsirez porter vos programmes
sur d'autres machines.
Un signe X dans la marge indique une primitive ou une caractristique spcifique
l'environnement XWindows ou SunView.
Il est possible d'utiliser la forme [<X,Y> | <X',Y'>] pour reprsenter un
rectangle (ce terme est une paire pointe de doublets reprsentant deux des points du
rectangle). L'emploi de cette forme obsolte n'est pas conseille.
PrologIA
465
Les descriptions des diffrents environnements ont t regroupes dans un
seul document pour mettre en vidence les diffrences qui existent encore
entre ces environnements.
2 . Primitives de gestion des fentres

file_window(s1)
file_window(s1,s2)
Cre, si elle n'existe pas dj, une fentre de nom s2 initialise
avec le texte contenu dans le fichier de nom s1. file_window(s1)
quivaut file_window(s1,s1).
front_window(s)
Unifie s avec le nom de la fentre se trouvant au premier plan.
get_screen(x,y)
get_screen(x,y,N)
Unifie x et y respectivement avec la largeur et la hauteur de l'cran
en pixels. Dans la forme trois arguments, N est unifi avec 1 si
l'cran ne possde que deux couleurs (noir et blanc), un nombre
suprieur 1 sinon.
get_window(s,b,x1,y1,x2,y2)
get_window(s,b)
Unifie successivement (par backtracking) les paramtres
s,b,x1,y1,x2,y2 avec les valeurs correspondantes chacune des
fentres existantes. Voir set_window pour la signification des
paramtres.
new_window(s,t)
new_window(s,t,v,x1,y1,x2,y2)
new_window(s,t,v,r)
Cre une nouvelle fentre, et une nouvelle unit d'entre/sortie
de nom s et de type t, o s est une chane diffrente de celles des
units existant dj. Le nom s est insr dans le menu Fentres.
466
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
t est de la forme type, ou bien [type|liste_attributs].

type dtermine le type de la fentre, et donc les oprations
pouvant lui tre appliques.
Ses valeurs possibles sont :
"EDIT"
cration d'une fentre d'dition. On peut dans cette
fentre crire, lire, et diter (c'est dire agir directement
sur la fentre, hors primitives d'E/S Prolog) : ces fentres
fonctionnent comme des fichiers. L'criture se fait
toujours la fin du texte contenu dans la fentre.
"GRAPHICS"
cration d'une fentre avec les mmes fonctionnalits que
la fentre "graphic". Le but gr_window(s) permet de la
dfinir comme unit graphique courante.
"TTY"
cration d'une fentre avec les mmes fonctionnalits que
la fentre "console".
"MODAL"
cration d'une fentre graphique modale. Cette fentre
reste au dessus de toutes les autres fentres, et tous les
vnements extrieurs la fentre sont dsactivs
(except l'interruption utilisateur). Les vnements
extrieurs la fentre sont ractivs lorsque la fentre est
tue. Les fentres modales peuvent tre empiles.
Les attributs possibles dpendent du type texte ("EDIT" ou
"TTY") ou graphique ("GRAPHICS" ou "MODAL") de la fentre :
X
<"DISTANCE",n>
n est un entier qui indique en pourcentage par rapport
la hauteur de la partie dessinable de la fentre, l'en-tte
rserv pour une zone de cration de boutons. Cet
attribut est valable pour tout type de fentre.
<"NLINES",n>
n est un entier qui indique le nombre de lignes sauver
lors d'un scrolling dans une fentre de type "TTY".
PrologIA
467
<"SHAPE",n>
n est un entier qui dtermine la forme de la fentre. Les
formes standard sont 0 : fentre avec titre et barres de
dfilement; 1 : fentre cadre. Par dfaut les fentres
modales ont l'attribut 1, et les fentres de texte l'attribut 0.
Cet attribut est valable pour tout type de fentre. On
notera que les fentres graphiques n'ont pas de barres de
dfilement.
<"SAVE", r >
Cet attribut ne peut tre appliqu qu' une fentre
graphique ou modale. Il dfinit le rectangle r de la fentre
auquel est associ un bitmap de rafrachissement (dans le
cas des machines couleur une grande zone peut
demander une place mmoire importante).
<"SAVE", b >
b est un entier (0 ou 1 ) indiquant si un bitmap de
rafrachissement est associ la fentre. La valeur par
dfaut est b = 0.
Si b =1, un bitmap de rafrachissement de la taille de la
fentre est cr.
X Si b =1, un bitmap de rafrachissement de la taille de
l'cran est cr.
<"FONTSIZE", n >
Dfinit la taille de la police de caractres utilise dans une
fentre de texte.
<"FONT", n >
Dfinit le numro n de la police de caractres utilise pour
le texte d'une fentre type texte. La fonte associe n est
dpendante du systme hte.
v est un entier (1 ou 0) indiquant si la fentre doit tre visible (1)
ou pas (0).
Les quatres derniers paramtres que l'on peut remplacer par
l'arbre r , sont :
x1,y1
qui reprsentent les coordonnes du coin suprieur
gauche de la partie dessinable de la nouvelle fentre par
rapport l'cran.
468
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
x2,y2
qui reprsentent les coordonnes du coin infrieur droit
de la partie dessinable de la nouvelle fentre, l'origine
tant situe au coin suprieur gauche de l'cran.
Exemple de cration d'une fentre graphique avec sauvegarde
automatique:
>
new_window("query",["GRAPHICS",<"SAVE",1>]);
Limitations :
On ne peut ouvrir simultanment plus de 28
fentres, sachant que, dans l'environnement disponible sous
XWindows ou SunView, un menu compte pour une fentre et
une icne compte double.

save_window(s1, s2)
save_window(s1)
Sauve le contenu de la fentre de texte s1 dans le fichier de nom
s 2 . La forme un argument est quivalente
save_window(s1,s1).
set_window(s,b,x1,y1,x2,y2)
Permet de manipuler la visibilit et l'emplacement des fentres
dj cres par Prolog III.
s
Nom de la fentre sous forme d'une chane de caractres
("console", "graphic" pour les fentres prdfinies).
b
Entier qui indique si la fentre sera visible (0 si invisible, 1
si visible).
x1,y1
sont les coordonnes, par rapport l'cran, du coin
suprieur gauche de la zone dessinable de la fentre.
PrologIA
469
x2,y2
sont les coordonnes du coin infrieur droit de la zone
dessinable de la nouvelle fentre, l'origine tant situe au
coin suprieur gauche de l'cran.
Exemple :
>
set_window("graphic",1,50,50,300,300);
set_window(s,b)
Mme chose que ci-dessus, mais pour manipuler les attributs
d'une fentre. b peut tre :
soit un entier : il indique alors si la fentre sera visible (0 si
invisible, 1 si visible),
soit un attribut (voir new_window). Les attributs possibles
sont respectivement,
pour les fentres graphiques et modales :
<"SAVE", 0 >
<"SAVE", 1 >

<"SAVE", r > o r est un rectangle.
pour une fentre texte :

<"FONT", n >

<"FONTSIZE", n >
Exemple :
>
X
X
X
set_window("console",<"FONTSIZE",12>);
create_window(s,t,v,r1,r2)
create_window(s,t,v,r1)
create_window(s,t,r1)
Similaire new_window, mais permet de dfinir un systme de
coordonnes avec chelle.
470
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
r1
est de la forme <x1,y1,x2,y2> o x1,y1,x2,y2 sont des rels
indiquant les coordonnes de la partie dessinable de la
fentre dans un cran [0,1] x [0,1]. Le coin suprieur
gauche de la fentre doit tre dans l'cran, donc x1 et y1
dans l'intervalle [0,1] .
r2
est de la forme <x1,y1,x2,y2> o x1,y1,x2,y2 sont des
entiers (de type court, c'est--dire infrieur 32700)
dfinissant un systme de coordonnes locales
l'utilisateur. Ce paramtre n'est prciser que pour des
fentres de type graphique ("GRAPHICS" ou "MODAL").
Si le paramtre r2 n'est pas spcifi, les coordonnes
graphiques dans la fentre seront donnes en pixels.
Exemple de cration d'une fentre :
>
create_window("wind","GRAPHICS",1,
<0.1,0.1,0.6,0.7>,<0,0,100,100>);
quelle que soit la taille de l'cran, un rectangle dessin par

gr_rect(1,0,0,100,100) la remplira, gr_moveto(50,50) positionnera au
centre etc...
reset_window(s)
Repositionne le pointeur de lecture au dbut d'une fentre
d'dition de nom s. Echoue si s n'est pas une fentre d'dition
cre par new_window.
clear_window(s)
Efface le contenu de la fentre de nom s.
gr_window(s)
La fentre graphique s devient l'unit graphique courante.
PrologIA
471
gr_window_is(s)
Unifie s avec le nom de l'unit graphique courante. Au lancement
de Prolog III, l'unit graphique courante est la fentre prdfinie
"graphic" .
kill_window(s)
Tue la fentre de nom s. Si la fentre s tait l'unit graphique
courante, alors la fentre prdfinie "graphic" redevient l'unit
graphique courante.
Le nom s ne peut tre celui d'une fentre prdfinie (i.e. ce doit
tre une fentre cre par new_window.)

print_window(s,f,t)
print_window(s)
Imprime le contenu de la fentre de texte s avec la fonte f de taille
t. La forme avec un seul argument imprime la fentre avec la
fonte courante de la fentre.
option fermeture
Lorsque l'on clique dans la case de fermeture d'une fentre, l'unit
correspondante est ferme et son nom est retir du menu
contenant les noms des fentres, except pour les fentres
prdfinies. Il est possible de rendre une fentre invisible sans la
fermer en appuyant sur la touche option en mme temps que la
case de fermeture est clique.
Rafrachissement de la fentre graphique

Les fentres graphiques peuvent tre rafrachies automatiquement par un
bitmap auxiliaire en crant ces fentres avec l'attribut <"SAVE",1> (voir la
primitive new_window).
Il existe une coroutine attache aux fentres graphiques qui est toujours
dclenche ds que ces fentres ncessitent un rafrachissement. Cette
coroutine est :
:gr_update(u)
o u reprsente le nom de la fentre rafrachir.
472
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
La rgle :gr_update n'est pas dfinie dans l'environnement standard.

L'utilisateur peut donc, en crivant une rgle <:gr_update, 1>, dfinir par
programme ce que doit tre le rafrachissement d'une fentre graphique u
sans utiliser de bitmap auxiliaire.
3 . Dessin et positionnement
Dans toutes les rgles exposes ci-dessous, x et y reprsentent les
coordonnes horizontales (x) et verticales (y). L'axe positif des y est dirig
vers le bas. Se rappeler que l'origine par dfaut (x=0, y=0) concide avec le
coin intrieur en haut et gauche de l'lment de rfrence. Ce dernier est
toujours la fentre graphique courante, sauf pour les primitives de
positionnement des fentres pour lesquelles l'lment de rfrence est
l'cran.
Les coordonnes x ou y peuvent tre exprimes indiffremment par des
nombres entiers, rels ou rationnels.
gr_moveto(x,y)
Positionne le point d'criture (crayon) de la fentre graphique
courante en x,y.
gr_lineto(x,y)
Tire un trait depuis la position courante jusqu'au point x,y, en
dplaant le crayon.
gr_move(x,y)
Modifie, sans tracer, la position du crayon de x pixels dans le sens
horizontal et de y pixels dans le sens vertical. Si la position
courante tait (x0, y0) la nouvelle position est (x0+x, y0+y)
gr_line(x,y)
Tire un trait depuis la position courante (x0, y0) jusqu'au point
(x0+x, y0+y) qui devient la nouvelle position.
PrologIA
473
gr_penloc(x,y)
Donne en coordonnes entires la position du crayon dans la
fentre graphique courante.
gr_erase
Efface le contenu de la fentre graphique courante et repositionne
le crayon en haut et gauche.
gr_setorigin(x,y)
Change l'origine des axes de sorte que x et y reprsentent les
coordonnes de l'angle haut et gauche de la fentre. L'aspect de la
fentre n'est pas modifi.
gr_rect(n,r)
gr_rect(n,x1,y1,x2,y2)
Permet d'appeler les routines de bases pour tout dessin
s'inscrivant l'intrieur d'un cadre rectangulaire. r est un arbre
correspondant la position du rectangle. Cet arbre doit tre de la
forme :
<x1,y1,x2,y2>
x1,y1 sont les coordonnes du coin suprieur gauche, et x2,y2
celles du coin infrieur droit.
Le premier argument n , qui reprsente un entier ou un
identificateur, dtermine la procdure appele :
0, :frameRect, :frame
Dessine le primtre du rectangle.
1, :paintRect, :paint
Remplit le rectangle avec le motif associ au crayon.
2, :eraseRect, :erase
Efface le rectangle et son contenu.
3, :invertRect, :invert
Inverse la couleur de chaque points de l'intrieur du
rectangle. Si le rectangle a un coloriage autre que noir et
blanc le rsultat est dpendant de la machine .
4, :frameOval
Dessine le primtre de l'ovale inscrit dans le rectangle.
5, :paintOval
Remplit l'ovale avec le motif associ au crayon.
474
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
6, :eraseOval
Efface l'ovale et son contenu.
7, :invertOval
Inverse les bits de l'ovale.
8, :frameRoundRect
Identique :frameRect mais avec des coins arrondis.
9, :paintRoundRect
Identique paintRect mais avec des coins arrondis.
10, :eraseRoundRect
Identique eraseRect mais avec des coins arrondis.
11, :invertRoundRect
Identique invertRect mais avec des coins arrondis.
12, :clipRect
Dfinit un rectangle dont le contour n'est pas trac. Seule
la partie des dessins ultrieurs situe l'intrieur du
rectangle sera visible. Autrement dit, on dfinit un
rectangle de visibilit pour tous les dessins venir. Pour
en annuler l'effet , refaire gr_rect(12,r) en donnant pour r
un rectangle arbitrairement grand, comme par exemple
<-1000, -1000, 1000, 1000> .
gr_polygon(n,L)
Dessin d'un polygone dans la fentre graphique courante. L est
une liste binaire de doublets <x,y> indiquant les coordonnes des
points dfinissant le polygone.
0, :frame
Dessine le primtre du polygone.
1, :paint
Remplit le polygone avec le motif associ au crayon.
2, :erase
Efface le contenu du polygone (certaines lignes brises

formant le contour du polygone peuvent subsister).
3, :invert
Inverse la couleur de chaque point de l'intrieur du
polygone. Le rsultat est dpendant de la machine si le
polygone a un coloriage autre que noir et blanc.
PrologIA
475
Aociation
gr_arc(n,r,a1,a2)1
gr_arc(n,x1,y1,x2,y2,a1,a2)2
Dessine un arc d'ellipse inscrit dans le rectangle r entre les angles
a1 et a2. Les angles a1 et a2 sont donns en degrs.
0, :frame
Dessine l'arc d'ellipse.
1, :paint
Remplit le secteur dfini par l'arc d'ellipse avec le motif
associ au crayon.
2, :erase
Efface l'arc d'ellipse et le contenu du secteur.
3, :invert
Inverse les bits du secteur dfini par l'arc d'ellipse. Le
rsultat est dpendant de la machine si le secteur a un
coloriage autre que noir et blanc.
Exemple :
>
gr_arc(:frame,100,100,200,170,20,110);
a2
x1,y1
a1
x2,y2
1 2
476
Cette primitive n'est pas encore disponible sous Sunview.
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE

gr_arc'(n,r,a1,a2)
gr_arc'(n,x1,y1,x2,y2,a1,a2)
Dessine un arc d'ellipse inscrit dans le rectangle r , depuis l'angle
a1 et d'une amplitude a2. Les angles a1 et a2 sont donns en
degrs. Cette primitive se diffrencie de gr_arc par le fait qu'elle
correspond exactement la dfinition de la Toolbox (origine sur
l'axe vertical, a2 relatif la position a1, sens positif dans le sens des
aiguilles d'une montre).
Exemple :
>
gr_arc'(:frame,100,100,200,170,20,50);
a1
a2
x1,y1
x2,y2

gr_icon(n,x1,y1,x2,y2)
gr_icon(n,r)
Dessine dans l'unit graphique courante, et inscrit dans le
rectangle indiqu une icne dcrite dans une ressource 'ICON' de
numro n . Cette ressource est recherche d'abord dans
l'excutable Prolog III, puis dans le fichier systme. Le systme
contient toujours les icnes :
0 Panneau stop.
1 Notification.
2 Panneau danger.
Le meilleur rsultat est obtenu en donnant comme rectangle un
carr de cot gal 32.
PrologIA
477
4. Usage de la souris
Rgles pour manipuler les fentres l'aide du clavier et de la souris

Les rgles suivantes ne concernent que l'utilisateur XWindows ou
SunView disposant d'une souris 3 boutons.
Dplacement
bouton central maintenu appuy
Agrandissement
touches SHIFT + CONTROL + bouton central

maintenu appuy
ou
bouton gauche dans le coin infrieur droit de
la fentre
Menus
clic du bouton droit pour les faire apparatre

clic du bouton gauche pour valider le choix
Ramener une fentre au premier plan

touche SHIFT + clic du bouton central
Faire passer une fentre en arrire-plan
touche CONTROL + clic du bouton central
Reprage de la souris
Dans ce qui suit, les variables commenant par r reprsenteront des arbres
correspondant des rectangles, c'est dire de la forme <x1,y1,x2,y2> .
478
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
gr_click(b,x,y)
Teste si un bouton de la souris a t press depuis le dernier appel
de gr_erase ou gr_click. Si c'est le cas, x et y sont unifis avec les
coordonnes entires du point o se trouvait la souris lorsque cet
vnement, appel clic, s'est produit. Sinon agit en fonction de
b, entier qui doit tre connu au moment de l'appel. La signification
des valeurs de b est la suivante :
b=1
Attendre qu'un nouveau clic se produise dans la fentre
graphique courante.
b=0
Ne pas attendre et raliser un backtracking s'il n'y a aucun
clic en attente.
gr_click(b,x,y,m)
Identique gr_click(b,x,y) mais donne en plus l'tat des
principales touches de modification en unifiant m avec la somme
des valeurs suivantes :
1
La touche SHIFT est appuye.
2
La touche CONTROLE1 est appuye.
4
La touche OPTION est appuye.
8
La touche COMMANDE est appuye.
16
La touche MAJUSCULE-VERROUILLEE est enfonce.
Si m = 0 aucune touche de modification n'est appuye durant le
clic.
Cette touche est absente sur le clavier du Macintosh +.
PrologIA
479
gr_getmouse(x,y)
gr_getmouse(x,y,b)
Donne la position actuelle de la souris dans la fentre graphique
courante en coordonnes entires relatives l'origine de la
fentre. Rend pour b la valeur 0 si le(s) bouton(s) de la souris sont
relevs au moment de l'appel, sinon le numro du bouton press
en commenant par la gauche pour une souris plusieurs boutons
(le premier bouton a le numro 1).
5 . Modes de dessin et d'criture

gr_color(d,c)
Dtermine la couleur du fond (si d= 0) ou du crayon (si d=1) de la
fentre graphique courante. L'argument c est un entier
reprsentant une des 8 couleurs possibles parmi les valeurs :
33 : noir, 30 : blanc, 69 : jaune, 137 : magenta, 205 : rouge,
273 : cyan, 341 : vert, 409 : bleu.
gr_color2(f,c)
Impose la couleur f du fond et c du crayon pour la fentre
graphique courante. Les arguments f et c sont des entiers
reprsentant une des couleurs possibles parmi les valeurs :
0 : blanc, 1 : rouge, 2 : vert, 3 : bleu, 4 : rose, 5 : orange, 6 : marron,
7 : rose1, 8 : violet, 9 : vert1, 10 : jaune, 11 : bleu1, 12 : jaune1,
13 : magenta, 14 : cyan, 15 : noir.
gr_color3(r,v,b)
Dfinit la couleur du crayon graphique en composantes r rouge, v
vert, b bleu. Si les valeurs sont des nombres flottants, elles doivent
tre comprises entre 0.0 et 1.0, et correspondent des
pourcentages d'intensit pour chaque composante (0.0 est
l'absence de cette composante, 1.0 est sa prsence avec une
intensit maximale). Si les valeurs sont entires, ce sont les valeurs
spcifiques de la machine qui doivent tre utilises (de 0 65535
sur Macintosh).
480
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
gr_choosecolor(p, c, i, f)
Affiche le dialogue de slection de couleur au point p (de la forme
<x,y>) de l'cran. c est une chane qui sera affiche dans le
dialogue. i et f sont des triplets d'entiers compris entre 0 et 65535;
un triplet <r, v, b> reprsente une couleur en composantes r
rouge, v vert, b bleu. i est la couleur initiale du dialogue et doit
tre connu au moment de l'appel, f sera unifi avec la couleur
choisie. Echoue si l'utilisateur clique le bouton Annuler.
gr_pen(l,m)
gr_pen(l,h,m)
Dfinit la taille en pixels du crayon graphique, et son motif.
l = largeur1
h = hauteur
m = motif.
0 blanc
1 noir
2 gris
3 gris clair
4 gris fonc
gr_stringwidth(s,n)
Unifie n avec la longueur de la chane s en fonction du jeu de
caractre , de la taille et du style dfinis pour la fentre graphique
courante.
gr_mode(b,m)
Dfinit le mode d'application du motif sur le fond, pour l'unit
graphique courante.
b=0
Concerne le dessin et donc le motif du crayon.
b=1
Concerne le texte et donc le motif correspondant au
caractre.
La largeur n'a pas d'effet sous Sunview.
PrologIA
481
Il existe quatre oprations de base : Copy, Or, Xor et Bic.
L'opration Copy remplace simplement les pixels de destination
par les pixels du motif ou de la source, dessinant sur la destination
sans se proccuper de son tat initial. Les oprations Or, Xor, et
Bic laissent inchangs les pixels de destination situs sous la partie
blanche du motif ou de la source. Elles traitent diffremment les
pixels situs sous la partie noire :
Or (ajout)
Xor (inversion)
les remplace par des pixels noirs.

les remplace par leur contraire.
Bic (effacement) les remplace par des pixels blancs.

Suivant le mode, l'opration est ralise partir du motif luimme (src), ou bien partie de son inverse (notSrc). Voici les
valeurs de m pour les diffrents modes.

m
0
1
2
3
4
5
6
7
modes de transfert
srcCopy
srcOr
srcXor
srcBic
notSrcCopy
notSrcOr
notSrcXor
notSrcBic
gr_text(f,t,s)
Permet de dfinir la fonte, la taille et le style des sorties dans la
fentre graphique courante.
f = numro de la fonte
t = taille de la fonte
s = liste de numros de style.
482
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
N
0
fonte
systemFont
N
0
style
gras
1
2
applFont
newYork
1
2
italique
soulign
3
4
geneva
monaco
3
4
relief
ombr
venice
condens
6
7
london
athens
tal
san Franscico
...
La liste binaire vide pour s reprsente le texte normal. La
combinaison par dfaut est gr_text(4,12,[]).
Par exemple gr_text(3,18,[1,3,4]) correspond geneva taille 18,
italique, relief et ombr.
Il est possible d'appeler cette rgle en donnant en argument des
identificateurs auxquels on a assign les constantes appropries.
Exemple :
>
assign(Geneva,3)
assign(Italic,1)
assign(Relief,3);
{}
>
gr_text(Geneva,18,[Italic,Relief])
output("graphic")
outm("Hello")
output("console");
affiche Hello dans la fentre graphique.

X
gr_font(f)
Charge la fonte de nom f pour la fentre graphique courante. La
fonte de base est courier; les fontes proposes sont des
variations sur la hauteur et l'paisseur des caractres :
"ft7r", "ft12r", "ft12b", "ft14r", "ft14b", "ft19r".
7, 12, 14, et 19 dsigne la taille de la fonte, r reprsente une
paisseur standard et b une plus grande paisseur.
PrologIA
483
Aociation
Exemple :
>
gr_font("ft12r");
6 . Primitives spciales de lecture et

d'criture au clavier et la souris
Simulation de boutons
gr_draw_buttons(b)
Dessine un ou plusieurs boutons dans la fentre graphique
courante.
La dfinition d'un bouton est donne par une rgle Prolog III de
nom b et d'arit 3.
Les 3 arguments sont, respectivement :
- le rectangle dans lequel il s'inscrit
- la chane affiche par le bouton
- un terme permettant de coder une information
supplmentaire (par exemple, une action associer ce bouton).
Tous les boutons dfinis par le paquet <b,3> sont dessins.
Exemple de base de donnes de boutons :
484
Prolog
HERITAGE
wtButton(<5,160,50,175>,
"Edit",
wtButton(<5,180,50,195>,
"Set",
PrologIA
edit)
[])
->
->
;
Aociation
Prolog
HERITAGE
Lorsque cette base est charge, les deux boutons sont dessins par le
but :
>
gr_draw_button(wtButton)
gr_button_hit(b,<x,y>,t)
b est l'identificateur d'accs la base de donnes de boutons
dcrite ci-dessus.
Cette rgle s'efface si x et y sont les coordonnes d'un point
intrieur l'un des boutons de la base de donnes <b,3>.
On unifie ensuite t avec le troisime argument du bouton
concern.
La primitive gr_button_hit combine avec gr_click permet
d'crire facilement une boucle de scrutation des boutons.
Saisie de texte
gr_editf(<s1,p1,p2>,r,s,k)
gr_editf(<s1,p1,p2>,x1,y1,x2,y2,s,k)
Cre un rectangle d'dition dans la fentre graphique courante. La
fin d'dition est provoque par un retour chariot, un caractre de
tabulation ou un clic en dehors du rectangle d'dition. Si k n'est
pas une variable, le rectangle et son texte sont seulement dessins
sans dition.
s1
est la chane qui sert initialiser le champ d'dition.
p1, p2
sont des entiers dfinissant la position de dbut et de fin
de slection du texte (reprsente en vido inverse). La
valeur 0 pour p1 indique la position qui prcde le
premier caractre du texte; p2 est la position du caractre
qui suit le dernier dans la slection. Initialiser avec un
champ vide correspond aux valeurs: <"",0,0>.
PrologIA
485
r
dfinit la position du rectangle englobant. Le texte est
cadr automatiquement en mode paragraphe avec
justification gauche.
s
est la variable qui sera unifie avec la chane dite.
k
Si k est une variable, celle-ci est unifie en sortie avec le
mode de terminaison :
0
si retour chariot
1
si clic souris dans la fentre 1 (en dehors du

rectangle d'dition)
2
si caractre TAB.
Si k est une constante en entre, sortie immdiate aprs
affichage de la zone.
Une forme plus simple de la rgle est galement utilisable pour
une chane initiale vide : gr_editf(<>,x1,y1,x2,y2,s,k)
get_key(c)
get_key(a,t,m)
get_key sert prendre un caractre au vol. Il n'y a aucun cho de
ce caractre dans aucune fentre que ce soit. Cette primitive
permet donc de saisir un mot-de-passe. Le fonctionnement
dtaill est donn dans la description de stty .
get_key(c)
rend dans c un caractre.
get_key(a, t, m) rend trois entiers :
- dans a le code ascii tendu
- dans t le numro de touche (virtual key code dcrit
dans Inside Macintosh vol. V p.192))
- dans m l'tat des touches de modifications (voir
la primitive gr_click)
486
On pourra lire sa position avec gr_click(0,x,y) .
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
stty("USEGETKEY", t)
rglemente d'usage du prdicat get_key.
t=0
mode par dfaut, dans lequel get_key choue toujours.
Les caractres taps sont insrs dans les fentres texte le
cas chant. Dans ce mode, l'utilisateur peut diter des
fentres texte pendant que Prolog III travaille.
t<0
get_key prendra un caractre qui ne peut tre plus g
que t ticks (1/60sec) avant l'appel. Echoue si, au moment
de l'appel, aucun caractre n'est disponible, ou si le
caractre est trop vieux .
t>0
get_key attendra un caractre pendant au plus t ticks.
Echouera si aucun caractre n'est disponible au bout de ce
laps de temps. get_key n'attend pas que le dlai soit coul
pour russir, si on lui fournit un caractre dans les temps.
Un caractre peut avoir t tap l'avance. Ce mode
permet de saisir un mot-de-passe en un temps donn.
Exemples :
>
stty("USEGETKEY",
-60);
Le prochain appel get_key chouera si aucun caractre non lu n'a t

tap moins d'une seconde avant cet appel (1 s = 60 ticks).
>
stty("USEGETKEY",
300);
Le prochain appel get_key chouera si aucun caractre non lu ne peut

tre obtenu dans les cinq secondes suivant cet appel (1 s = 60 ticks). Le
caractre peut avoir t tap l'avance. get_key russira de suite aprs
avoir obtenu le caractre sans attendre que le dlai soit coul.
PrologIA
487
stty("FLUSH")
Enlve tous les caractres de la queue d'vnements. Ils ne sont
plus disponibles pour get_key. (permet get_key de saisir une
rponse qui n'a pas t tape l'avance.)
gtty(s, v)
Rcupre la valeur d'un paramtre concernant le terminal :
gtty("USEGETKEY", v) rend 0 ou un nombre sign de ticks.
gtty("TERM", x) rend actuellement "TTY" ou "MPW".
Botes de choix
gr_list(r, Liste, InSel, InTop, OutSel, OutTop, op)
La rgle gr_list gre un choix d'lment(s) dans une liste. Cette
dernire s'affiche dans la fentre graphique courante.
r
Le rectangle englobant (ascenseurs compris) de la
forme <x1,y1,x2,y2>.
Liste
La liste d'items. C'est une liste binaire de constantes
ventuellement mixtes (chane, entier, rel, ident ...).
InSel
C'est la slection initiale, sous la forme d'une liste binaire
d'entiers qui sont les rangs ( partir de 1) dans Liste des
lments que l'on veut slectionner. Mettre [] si aucun
lment n'est slectionn au dpart.
InTop
C'est le rang de l'lment qui doit apparatre tout en haut
de l'affichage de la bote (scrolling initial). On peut
mettre 1 par exemple.
OutSel
Donne en sortie la liste des rangs des items slectionns
(mme convention que pour InSel).
OutTop
Donne en sortie le rang du premier item visible tout en
haut de la bote de choix.
op
Dcrit l'opration raliser. 4 possibilits :
488
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
<0>
Dessine seulement (pas de saisie possible).
<1,k> Dessine et prend la main jusqu' ce qu'un
vnement de type entre de caractre ou clic
l'extrieur de la liste se produise. Ni le clic ni le
caractre ne sont lus. Rend pour k :
0 : retour chariot tap
1 : clic en dehors de la liste
2 : TAB t tap
3 : un autre caractre que RC ou TAB t tap
<2,x,y,m>
Dessine la liste et traite le clic x,y,m (donn
par exemple par gr_click(b,x,y,m) ). Sort tout de suite
aprs.
<3,x,y,m,k> Dessine, traite le clic x,y,m (donn par
exemple par gr_click(b,x,y,m) ) et prend la main jusqu'
ce qu'un vnement de type clavier ou un clic
l'extrieur du rectangle se produise. Ni le clic ni le
caractre ne sont lus. Rend pour k :
0 : retour chariot tap
1 : clic en dehors de la liste
2 : TAB t tap
3 : un autre caractre que RC ou TAB a t tap.
sys:gr:gr_list'(r, L, f, Sel, ISel, ITop, OSel, OTop, op)

est la primitive de base utilise. Son 3 m e argument est
actuellement inutilis (il doit tre libre) et son 4me est le type de
slection des items. Si vous dsirez modifier le type de slection
par dfaut vous pouvez remplacer la rgle gr_list de "sys" (
l'aide de reinsert, ou de suppress puis assert) par celle-ci, dans
laquelle vous aurez chang le 28 par le type de votre choix :
gr_list(r,
L,
ISel,
ITop,
sys:gr:gr_list'(r,
OSel,
L,
OSel,
_,
OTop,
28,
OTop,
op)
ISel,
->
ITop,
op);
Quelques types de slections possibles parmi d'autres (Inside

Macintosh IV-267) :
0 shift et command
28
shift ou command seulement (valeur par dfaut)
PrologIA
489
-128

Aociation
un seul item a la fois peut tre slectionn.
gr_popupItem(r,l,n1)
gr_popupItem(r,l,n1,n2)
Cre un champ valeurs proposes. Ceci correspond ce qui est
appel un menu "pop-up", dans la Toolbox. Il ne faut pas confondre
ce type d'objet avec les menus fugitifs lis des fentres, menus
activs par option-clic et permettant de lancer des actions de faon
asynchrone.
Descriptions des arguments :

l est une liste de constantes.
r est le rectangle dans lequel est affich l'item numro n1 de la liste
l.
Si n2 est absent, l'item est simplement dessin.
Si n2 est prsent, un menu prsentant la liste des choix l vient
recouvrir l'item, et l'inversion des champs est gre tant que le
bouton de la souris reste appuy. Lorsque le bouton est relch, le
champ slectionn est dessin dans le rectangle la place du
prcdent, et n2 est unifi avec le numro de l'lment slectionn
(n1 si aucun champ n'est slectionn).
Exemple lorsque la fentre graphique est rendu visible :
>
gr_popupItem(<20,20,120,40>,
["aa","bb","cc","dd",3,4],
2)
gr_click(1,x,y)
gr_popupItem(<20,20,120,40>,
["aa","bb","cc","dd",3,4],
2,
i);
Lorsque vous cliquez dans la fentre en maintenant le bouton appuy :
490
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
aa
bb
cc
dd
3
4
Impression de fentres

gr_print(s)
gr_print(s,r_x,r_y,x0,y0)
gr_print(s,r1,r2)
Imprime le contenu de la fentre graphique s .
On peut spcifier, grce la troisime forme, la zone imprimer,
qui est le contenu du rectangle r1, le rsultat sur papier se situant
dans le rectangle r2. Les rductions et translations ventuelles
sont automatiques. La forme avec un seul argument imprime la
fentre sans modification de format.
La forme 5 arguments permet de spcifier la rduction selon les
axes des X, des Y sous la forme de deux nombres r_x et r_y
compris entre 0.0 et 1.0. On peut donner, en x0 et y0 la position de
l'origine de l'impression sur le papier.
Exemple :
>
gr_print("graphic",
0.5,
0.5,
0,
0);
imprimera la fentre "graphic", rduite au quart (chaque dimension

tant rduite de moiti).
PrologIA
491
7 . Primitive de description de menus

Un menu regroupe une suite d'items disposs verticalement. Un item peut
tre soit terminal, soit lui-mme un menu (on parle alors de menu
hirarchique). A tout item terminal d'un menu hirarchique est associ un
but Prolog III qui est activ immdiatement, en suspendant le programme
en cours, lorsque l'item est slectionn.
Lorsque la barre de menu existe, chaque item de cette barre se comporte
comme un item d'un menu hirarchique.
Il est possible d'attacher un menu fugitif (pop-up) particulier toute unit de
type fentre. La primitive set_menu dcrite ici, permet de dfinir ou de
redfinir de tels menus .
L'activation d'un menu fugitif se fait soit en appuyant sur le bouton droit de
la souris ( l'intrieur de la fentre concerne), lorsque la souris comporte
plusieurs boutons, soit en appuyant simultanment une touche option et le
bouton de la souris, si la souris ne possde qu'un seul bouton.
set_menu(u,c,v)
Permet de dfinir ou de redfinir par v la valeur de l'item indiqu
par c dans le menu de l'unit u.
u (unit)
Reprsente l'unit concerne : l'entier 0 pour la barre de
menu (et ses descendants), le nom d'une fentre sinon.
c (chemin)
Liste binaire de chanes indiquant un chemin de slection
dans le menu hirarchique de l'unit u. L'lment terminal
de ce chemin est remplac par v.
Si une telle hirarchie n'existe pas, elle est cre.
Si la liste est [], c'est tout le menu qui est concern.
v (valeur)
Arbre de description de la nouvelle valeur. Celle-ci peut
tre soit une feuille, soit une hirarchie.
Valeur de type feuille.
Une feuille est reprsente par un tuple de la forme :
<"Nom item", Identificateur, n>
La chane "Nom item" donne le nom de l'item.
492
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Identificateur est le nom d'une rgle Prolog d'arit 1

attache l'item.
n est un entier (0 ou 1) qui indique si l'item est ou non
coch (une marque prcde le nom de l'item coch).
Lorsqu'un item d'un menu est slectionn et valid, le
programme en cours est suspendu, et le but
Identificateur(u) est immdiatement activ. Si le but se
termine sans erreur, le programme reprend
normalement.
Il est possible d'utiliser des formes simplifies :
soit avec un tuple deux arguments :
<"Nom item", Identificateur>
( quivalent : <"Nom item", Identificateur, 0> ),
soit avec simplement un identificateur : Identificateur
( quivalent : <"Identificateur", Identificateur, 0> ).
Exemple, en supposant que l'on ait la fentre d'dition "menu.p3"
ouverte :
> set_menu(0,
["Controle",
<"Inserer
"Inserer
la
fenetre",
set_menu("menu.p3",
<"Inserer",
la
fenetre"],
insertion_fen>)
["Inserer"],
insertion_fen>);
{}
insertion_fen(0)
->
front_window(u)
reinsert(u);
insertion_fen(u)
->
string(u)
reinsert(u);
Valeur de type hirarchie

Une hirarchie est reprsente par un tuple deux
arguments de la forme :
<"Nom item", Liste_de_valeurs>
PrologIA
493
Aociation
Chaque lment 1 de Liste de valeurs reprsente luimme une valeur de type feuille ou une valeur de type
hirarchie.
Il est possible d'utiliser une forme simplifie :
Liste_de_valeurs
Dans ce cas le nom de l'item est celui indiqu la fin du
chemin c. Ceci revient apposer la hirarchie sous
l'item indiqu.
Exemple :
>
set_menu("graphic", [],
<"File",
[reinsert]>,
<"Do",
[goal1,<"Stop",goal2>]>,
<"Size",
<"1",size1>,
<"2",size2,1>,
<"3",size3>
]>
] )
insert;
size1(u)
->
gr_window(u)
gr_text(1,10,[]);
size2(u)
->
gr_window(u)
gr_text(1,12,[]);
goal1(u)
->
...
File
Do
Size
File
Do
Size
1
2
3
goal1
Stop
Dans les primitives ci-dessous, le premier et le deuxime argument suivent

les mmes conventions que pour set_menu :
Sous Sunview, chaque lement de la liste de valeurs doit tre une feuille (un
seul niveau).
494
Prolog
HERITAGE
PrologIA
Aociation
Prolog
HERITAGE
check_item(u,c,v)
Cette primitive positionne ou enlve le cochage d'un item.
v indique la prsence du cochage d'un item : 0 indique non coch,
1 indique coch avec la marque standard de la machine.
Si v est un entier plus grand que 1, le caractre ayant le code
v est utilis comme marque.
Exemple :
>
check_item(0,["Fenetres","trace"],1);
command_menu(u,c,v)
v est le code du caractre utilis en conjonction de la touche
commande (pomme), utilise comme raccourci pour activer l'item
spcifi par les deux premiers arguments.
Exemple de cration du raccourci T pour activer la trace Prolog III :
>
char_code(`T`,n)
command_menu(0,["Controle","trace"],n);
enable_menu(u,c,v)
Permet de dsactiver (v =0) ou de ractiver (v =1) un menu ou un
item.
Exemple pour dsactiver tout le menu d'dition :
>
enable_menu(0,["Editer"],0);
PrologIA
495
style_menu(u,c,v)
Spcifie le style d'un item de menu. v est un entier dont chaque bit
reprsente un des styles spcifis avec l'ordre dfini dans la
primitive gr_text.
Exemple mettant en italique soulign l'item trace du menu Fentres (bit
1 + bit 2 positionns) :
>
style_menu(0,["Fenetres","trace"],6);
clear_menubar
Appelle save_menubar puis efface la barre de menu standard.
Cette primitive permet la redfinition complte de la barre de
menus.
save_menubar
Mmorise la barre de menu courante. Cette rgle ne peut tre
appele qu'une fois.
restore_menubar
Restaure la barre de menu sauve avec save_menubar.
add_stdmenu(s)
Cette primitive permet de rinsrer un ou plusieurs menus
standard aprs un appel clear_menubar. La chane s doit tre
l'une des suivantes :
"apple"
: pour rinsrer le menu pomme
"file"
: pour rinsrer le menu Fichier
496
"edit"
"find"
"control"
: pour rinsrer le menu Editer

: pour rinsrer le menu Recherche
: pour rinsrer le menu Contrle
"window"
: pour rinsrer le menu Fentres
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
8 . Gestion des botes de dialogue
Dfinition d'un dialogue standard

gr_dialog(d,l1,l2)
gr_dialog(p,d,l1,l2)
L'utilisation de cette primitive ncessite le chargement pralable
du module dial.mo3. Ce module contient le gestionnaire de
dialogue Prolog III permettant de crer et activer les dialogues
dcrits par le deuxime argument d.
Dans sa deuxime forme la primitive gr_dialog accepte un
argument supplmentaire p permettant de paramtrer la position
de l'angle suprieur gauche du dialogue sous la forme d'un
doublet <x,y>.
d
est soit un arbre dcrivant un dialogue, soit l'identificateur
d'une rgle unaire avec un tel arbre en argument.
l1
est une liste (ventuellement vide) de paires
[nom_de_zone | valeur_initiale]
o nom_de_zone reprsente un identificateur ou une
constante. Cette liste est utilise pour dfinir ou redfinir le
contenu des zones.
l2
En sortie, si l2 est une variable, elle est unifie avec la liste
des paires [nom_de_zone | valeur_finale] du dialogue. Si l2 est
une liste de paires [nom_de_zone | X], chaque paire est
unifie avec le couple correspondant.
Un dialogue est dcrit avec des objets primitifs (zone de texte,
zone d'dition, boutons, ...) et des primitives d'agencement en
colonne ou en range. Ces primitives ralisent un ajustement
dynamique de la taille des zones en fonction de leur contenu. Les
zones dont la valeur peut tre modifie sont identifies par un
nom, ce qui permet de redfinir leur valeur au moment de l'appel.
Exemple :
PrologIA
497
>
Aociation
reload("dial.mo3");
{}
>
gr_dialog(["Hello"|buttonD("OK")],[],L);
>
gr_dialog(<50,50>,
["Name:",
editf(10,field1),
buttonD("OK")],
[[field1|"John"]],
L);
Les primitives de description d'objet sont les suivantes :

:text(s) ou s
Dcrit une ligne de texte non ditable reprsente par s o s
est une chane.
:text(i)
Dcrit une ligne de texte non ditable dont le nom de zone
est i o i est un identificateur. Si une valeur est associe i
dans l1 c'est cette valeur qui est la valeur initiale du champ,
sinon c'est la chane vide. Il n'est jamais associ de valeur
finale cette zone, puisqu'elle n'est pas modifiable.
498
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
:cb(i), :cb(i,v)
Dcrit une bote cocher reprsente par une des deux
valeurs entires possibles de v qui sont soit 1 soit 0. Si la
valeur de v n'est fournie ni en argument, ni dans la liste l1,
c'est la valeur 0 qui est donne par dfaut. Lorsque v est
redfinie dans l1, c'est toujours cette dernire valeur qui est
prise en compte.
:rb(<g,i>), :rb(<g,i>,v)
Dcrit un radio-bouton i d'un groupe g (o g est un
identificateur, et i une constante). Ce radio-bouton de valeur
0 ou 1, fait partie du groupe g, avec au plus une valeur
possible 1 dans le groupe. Si la valeur de v n'est fournie ni
en argument, ni dans la liste l1, c'est la valeur 0 qui est prise
par dfaut. Lorsque v est redfinie dans l1, c'est toujours
cette dernire valeur qui est prise en compte. En sortie,
nom_de_zone est reprsent par <g,i>1, et valeur_finale par 0
ou 1, et ceci pour chacun des radio-boutons du groupe.
:rb1(<g,i>), :rb(<g,i>,v)
Mme chose que rb mais avec deux diffrences : les lments
du groupe ne peuvent tre tous zro; seul l'lment ayant
la valeur 1 figure dans la liste de sortie. nom_de_zone est alors
reprsent par g, et valeur_finale par i. Ce format de sortie
est donc diffrent et plus simple que celui fourni par rb.
:editf(n,i), :editf(n,i,s)
Dcrit une zone d'une ligne de texte ditable de nom i, o i
est un identificateur. s reprsente la valeur initiale de la zone
d'dition. Cette valeur initiale est la chane vide si elle n'est
spcifie ni en argument, ni dans la liste l1. L'entier n
reprsente le nombre minimum de caractres de la zone. Si s
est plus grand, la zone est dynamiquement tendue.
Contrairement Prolog II+, le doublet <g,i> ne reprsente pas le mme arbre

que g(i).
PrologIA
499
:button(s,i)
Dcrit un bouton avec le label s auquel est associ l'action
dfinie par l'identificateur i. Lorsque le bouton est activ,
une action est ralise :
- Si i est fail, le dialogue est termin, et gr_dialog choue.
- Si i est [], rien n'est fait.
- Sinon, le but i(l) est activ, l tant la liste binaires des
paires [nom|valeur] des zones du dialogue au moment o le
bouton est cliqu.
Lorsque le but correspondant la rgle <i, 1> a t excut,
la gestion du dialogue reprend en l'tat. Pour arrter le
dialogue en cours, on peut programmer dans i l'excution
d'un block_exit(<fail,L>) qui provoquera un bactracking de
gr_dialog, ou un block_exit(<[],L>) qui conduira une
terminaison normale.
:button2(s,i)
Cet item a le mme comportement que l'item :button, mais
cette fois-ci la rgle i est appele avec deux arguments. Le
premier est une liste dcrivant l'tat des items du dialogue.
Le deuxime est l'appel une variable qui doit tre
instancie par la rgle <i,2> avec la liste des items dont la
valeur est modifie. Cette rgle est crite par l'utilisateur, et
permet donc d'attacher une smantique quelconque aux
boutons. La rgle dfinit une relation entre le premier
argument (argument d'entre reprsentant la liste des
valeurs actuelles), et le deuxime argument (argument de
sortie reprsentant la liste des valeurs nouvelles).
:buttonD, :buttonD(s), :buttonD(s,i)
Dcrit un bouton de terminaison de dialogue avec le label s
auquel est associ l'action i dfinie comme pour :button(s,i).
Usuellement s est la chane "OK", et i est []. La frappe du
retour chariot actionne ce bouton .
:glist(l, c, i, l_init)
Dfinit une liste de valeurs avec barre de dfilement
verticale. La signification des arguments est :
500
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
l
Entier qui reprsente le nombre d'items qui doivent tre
visibles. La hauteur du rectangle est calcule
automatiquement en fonction de ce paramtre.
c
Entier qui reprsentent le nombre de caractres qui
doivent tre visible pour un item. La largeur du rectangle
est calcule automatiquement en fonction de ce
paramtre.
i
Identificateur servant donner un nom interne au
gestionnaire. Il est utilis pour donner le rsultat en sortie.
l_Init
Liste de constantes (chanes, identificateurs, nombres) qui
reprsente la liste des valeurs initiales. Il est possible de
proposer une slection initiale en fournissant pour l_Init
un triplet dcrivant un tat du gestionnaire. Ce triplet doit
alors avoir la forme suivante :
<ListeInit, NoSelectionns, NoHaut>
- Le premier argument est une liste de constantes
reprsentant la liste des valeurs initiales.
- Le deuxime argument est la liste ordonne des
numros d'ordre des items composant la slection
initiale. Cette liste peut comporter 0 (pas de slection),
1, ou plusieurs lments.
- Le troisime argument indique le numro de l'item
prsenter en haut du rectangle d'affichage.
Ce triplet correspond la reprsentation interne de l'tat
du gestionnaire. Ainsi, la paire :
[ Identificateur |<ListeInit, NoSelectionns, NoHaut> ]
intervient dans la liste des valeurs transmise aux actions
associes aux boutons. La valeur retourne par ces actions
pour dcrire un nouvel tat du gestionnaire est galement
de cette forme (voir exemples).
PrologIA
501
En sortie du dialogue, le rsultat est donn par un couple
[ Identificateur | ListeDesItemsSlectionns ] ,
o ListeDesItemsSlectionns est forme partir de
ListeInit et de NoSelectionns :
:userItem(t, i, e, s)
Permet d'tendre les items traits par un dialogue.
L'utilisateur doit alors fournir un paquet de rgles <i,2>
capable de rpondre un certain nombre d'actions requises
par le gestionnaire de dialogue qui prend en charge la
gestion des vnements et des activations. Les paramtres
ont la signification suivante :
t
Terme identifiant l'item en question et utilis comme
nom de zone si la valeur est extractible.
i
Identificateur d'une rgle deux arguments crite par
l'utilisateur pour grer les actions concernant cet item
(voir plus loin les actions possibles).
e
Valeur dcrivant l'tat de l'item et gre par l'utilisateur
lors des actions.
s
Dcrit le type d'actions possibles sur cet item :
0
insensible.
1
activable par un clic.
2
activable par un clic ou une entre de texte (TAB).
Les primitives d'agencement sont bases sur la notion de

combinaison de rectangles: mettre deux rectangles en colonne
dfinit un nouveau rectangle englobant les deux autres.
:col(l), ou l
Dcrit une colonne aligne gauche, dont le contenu est
dcrit par l. Si l est une liste, la primitive calcule la taille de
chaque lment de la liste, et constitue une colonne
d'lments disposs les uns au dessus des autres, et aligns
sur leur ct gauche.
502
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
:ccol(l)
Dcrit une colonne centre verticalement, dont le contenu
est dcrit par la liste l.
:row(l)
Dcrit une range horizontale dcrite par la (liste de)
primitive(s) l, et dont les lments sont aligns sur leur bord
suprieur: si l est une liste, la primitive calcule la taille de
chaque lment de la liste, et constitue une range
d'lments disposs cte cte, et aligns sur leur bord
suprieur.
:crow(l)
Dcrit une range d'objets dcrits par l et centrs
horizontalement, c'est dire disposs de manire ce que
leurs points mdians soient tous aligns sur une mme
horizontale.
:vfill(n)
Dcrit un espacement vertical de n pixels, o n est un entier.
:hfill(n)
Dcrit un espacement horizontal de n pixels, o n est un
entier.
La primitive de groupement suivante permet de grer l'activation
ou la dsactivation de zones entires pendant la saisie du dialogue.
:group([ identificateur | valeur ], DescriptionDesItems)
Permet d'associer un identificateur un ensemble d'items
regroups gographiquement et smantiquement.
valeur indique si le groupe est actif ou non (0 pour inactif, 1
pour actif). Lorsque le groupe est inactif, il est dessin en
gris et l'tat de ses items ne peut tre modifi. L'tat d'un
groupe ne peut tre modifi dans la version actuelle que par
les actions associes aux boutons. L'tat d'un groupe n'est
pas donn dans la liste de sortie, il est par contre fourni, dans
la liste des tats passe aux boutons, sous la forme d'une
paire :
[ identificateur | valeur ]
PrologIA
503
Aociation
Exemples:
>
gr_dialog(<50,50>,
: c c o l ( [ "Voulez-vous
recommencer
le
test?",
:buttonD,
:button("Annuler",fail)
]
),
[],
L );
>
gr_dialog(
["Choose
the
color
you
want",
:crow([ :rb(<rb1,red>,1),"Red",
:rb(<rb1,green>),"Green"]
: c r o w ( [ :cb(cb1,0),"Extended
: c c o l ( [ :buttonD("Show
),
colors"]
),
Color"),
:button("Cancel",fail)]
],
[[cb1|1]],
[[cb1|C],[<rb1,red>|R],[<rb1,green>|G]]
504
Prolog
HERITAGE
PrologIA
);
Aociation
Prolog
HERITAGE
{ C = 1, R = 1, G = 0 }
>
PrologIA
505
>
Aociation
gr_dialog(<50,50>,
[:crow([
"abcdefgh",
:ccol([ :button("Stop",fail),
:buttonD("OK",[]),
:button("Cancel",fail),
"HELLO
]
WORLD"
),
"ijklmnopq"
] )
],
[],
l );
>
gr_dialog(
[:glist(5,
10,
liste1,
<[rouge,vert,bleu,jaune,
violet,noir,blanc,orange],
),
:buttonD],
[],
L);
506
Prolog
HERITAGE
PrologIA
[4,6],
2>
Aociation
Prolog
HERITAGE
{ L = [[list1, jaune, noir]] }

>
>
enable(l1,
l3)
->
set_item(l1,
zone1,
1,
l2)
set_item(l2,
zone2,
0,
l3);
disable(l1,
l3)
->
set_item(l1,
zone1,
0,
l2)
set_item(l2,
zone2,
1,
l3);
set_item([],
i,
b,
block_exit(816,
[])
->
["set_item,
set_item([[i,_]|l],
i,
b,
set_item([e|l],
b,
[e|l'])
set_item(l,
i,
i,
b,
l')
absent:
[[i,b]|l])
->
"|i]);
!
->
PrologIA
507
>
gr_dialog(
[:group(
[zone1,0],
[ "Hello",
:crow([:rb1(<color,red>),"Red"]),
:crow([:rb1(<color,green>,1),"Green"]),
:editf(5,ed1,"aa"),
:button2("Disable",disable)
] ),
:group(
[zone2,1],
:button2("Enable",enable)),
:buttonD
],
[],
L);
{ L = [[color|green], [ed1|"aa"]] }
508
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Extensions utilisateur
Un user_item est un objet lmentaire apparaissant dans une boite de
dialogue. L'utilisateur a la possibilit de dfinir ses propres items.
Il faut pour dfinir un user_item, lui donner un nom (TermeIdentifiant), une
sensibilit (0, 1 ou 2), la valeur initiale de son tat, et lui associer un paquet
des rgles d'arit 2 . Ces 2 arguments seront respectivement la requte et la
valeur de retour.
Ce paquet <IdentificateurdeRgle, 2> sert prciser :
la taille du rectangle englobant (requte size),
le dessin correspondant l'objet (requte draw)
l'action associe un clic (requte click)
la rponse la frappe de caractres (requte edit)
l'information retourne au gestionnaire de dialogue en cas
d'activation de cet item par un clic ou une dition (requte extract).
La sensibilit de l'item est dfinie de la faon suivante :
Sensibilit
0
1
2
Requte
size, draw.
size, draw, clic, extract.
size, draw, clic, edit, extract.
L'tat d'un user_item est un terme structur par l'utilisateur selon ses
besoins.
:userItem(TermeIdentifiant, IdentificateurdeRgle, Etat, Sensibilit).
Au moment de l'appel, le premier argument de la rgle
<IdentificateurdeRgle, 2> contient la requte avec les paramtres
pertinents extraits de l'item, et le deuxime argument est une
variable libre qui devra tre instancie avec le rsultat de la
requte. Si la rgle choue, l'opration est ignore.
PrologIA
509
Description de chacune des requtes :
:size(TermeIdentifiant,Etat)
Demande de calcul de la taille de l'item lors de l'initialisation
du dialogue. Le rsultat doit tre un doublet <dx,dy> en
nombre de pixels.
:draw(TermeIdentifiant,Etat,Rectangle,Actif)
Demande de dessin de l'item TermeIdentifiant dans le
rectangle Rectangle (de la forme <x1,y1,x2,y2>) avec la
description d'tat Etat et situ dans un groupe activ si Actif
est 1, dsactiv si Actif est 0 (il est conseill de ne pas montrer
les valeurs de champ dans les zones dsactives). Le rsultat
est ignor.
:click(TermeIdentifiant,Etat,Rectangle,PointCliqu)
Demande de raliser l'action associe un clic sur l'item.
PointCliqu est de la forme <x,y,m> (voir <gr_click,4>).
Le rsultat est un doublet <NouvelEtat,Terminaison> o :
NouvelEtat remplacera le champ Etat du userItem.
Terminaison sera de la forme :
<>
Si aucune interaction n'a t faite avec
l'utilisateur.
<n>
Si la rgle gre une boucle locale de traitement
de l'item et que l'interaction se termine par un caractre
RC (n=0) ou TAB (n=2) ou un clic non lu (n=1).
<x,y,m> Si la rgle gre une boucle locale de traitement
de l'item et que l'interaction se termine par un clic situ
l'extrieur du rectangle de l'item.
Si l'tat de l'item change, il doit tre redessin avant la
terminaison.
:edit(TermeIdentifiant,Etat,Rectangle)
Demande de saisie de caractres dans l'item. Le rsultat sera
de la mme forme que ci-dessus.
510
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
:extract(TermeIdentifiant,Etat)
Demande d'extraction de la valeur courante de l'item pour
former le couple [TermeIdentifiant | Valeur] qui est fourni en
sortie ou pass aux items avec des actions sur le dialogue
(:button2 par exemple). Si la requte choue, on suppose qu'il
n'y a pas de rsultat associer l'item. Sinon le rsultat doit
tre la partie valeur.
Exemple de cration d'un item faisant dfiler, lorsqu'on clique dessus,
les diffrents lments d'une liste :
>
circ_list(:size(_,<N,L>),
max_width(L,
20,
<x,20>)
x);
circ_list(:draw(_,V,R,
_actif),
monItemDraw(V,
_actif);
R,
circ_list(:extract(_,<N,L>),
arg2(N,
L,
V)
mod(N,
L,
M,
_)
->
<<N1,L>,<>>)
N1-1)
X,
max_width([S|L],
X+4)
X,
Y,
_)
->;
X')
gr_stringwidth(S,
max(X,
->
M)
circ_list(:draw(i,<N1,L>,R,1),
max_width([],
->
V);
circ_list(:click(i,<N,L>,R,P),
arg2(0,
->
->
Y)
X0)
max_width(L,
X0,
maxof(X,Y,
X)
->
maxof(X,Y,
Y)
->
X');
{X>Y};
PrologIA
511
monItemDraw(<N,L>,
arg2(N,
L,
r,
_actif)
y1+14)
gr_rect(:eraseRect,
r)
gr_rect(:frameRect,
r)
outItem(S,
{r
->
S)
gr_moveto(x+2,
_actif)
<x1,y1,x2,y2>};
outItem(S,
1)
->
outItem(S,
0)
->;
>
Aociation
outml(S);
gr_dialog(
[:row(
[:userItem(
monItem(liste1),
circ_list,
<1,["FIRST","abcd","e","LAST"]>,
,1),
"<--
user
Item"
] ),
:buttonD
],
[],
L);
{ L = [[monItem(liste1) | "e"]] }
512
Prolog
HERITAGE
PrologIA
Aociation
Prolog
HERITAGE
Exemple de cration d'un item affichant des icnes, et changeant

d'icne lorsque l'on clique dessus :
>
iconManager(:size(_,_),
iconManager(:draw(_,V,
gr_icon(V,
<32,32>)
R,
_),
_)
->
V)
->
iconManager(:click(N,V,R,P),
3,
<V2,<>>)
->
V2)
iconManager(:draw(N,V2,R,1),
>
R);
iconManager(:extract(_,V),
mod(V+1,
->
gr_dialog(
[:row( [ :userItem(myIcon,iconManager,1,1),
"<--
user
Item"
] ),
:buttonD
[],
],
L);
{ L = [[myIcon | 1]] }
PrologIA
513
9 . Boutons actifs
Les primitives dcrites dans cette section permettent d'associer des buts
Prolog des boutons, ces buts tant lancs ds que le bouton est press de
manire similaire l'activation d'un but par menu, c'est dire en suspendant
l'excution en cours. Prolog III se charge du rafrachissement du bouton.
X
create_button(s,f,p,x1,y1)
Cration d'un bouton de nom s dans la fentre de nom f (s et f
doivent tre des chanes)
x1,y1
reprsentent les coordonnes du bouton par rapport au
coin suprieur gauche de la fentre.
p
est l'identificateur du but (sans argument) qui sera lanc
lorsque le bouton est cliqu.
activate_button(s)
Rend activable le bouton de nom s.
deactivate_button(s)
Rend inactif le bouton de nom s. Le texte est alors gris.
kill_button(s)
Destruction du bouton de nom s.
1 0 . Primitives de manipulation de
fichiers
input(x)
Avec x variable libre, affiche un dialogue de slection d'un fichier
(de type texte seulement) et unifie x avec le nom avec chemin du
fichier choisi aprs l'avoir ouvert en lecture. Il y a chec si le
bouton Annuler est cliqu. (voir aussi la primitive sfgetfile).
514
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
output(x)
Avec x variable libre, affiche un menu de dialogue de saisie de
nom de fichier et unifie x avec le nom avec chemin du fichier saisi
aprs l'avoir ouvert en criture. Il y a chec si le bouton Annuler
est cliqu. (voir aussi la primitive sfputfile).
gr_load(s)
Dessine dans la fentre graphique courante le contenu d'un fichier
graphique de nom s et de type MacPaint ou MacDraw :
"PNTG" (MacPaint)
ou "PICT"
(MacDraw sauv en
format PICT). Il est possible de dessiner des endroits diffrents
des parties slectionnes d'un fichier en jouant sur les primitives
gr_setorigin et gr_rect(:clipRect,..).
sfgetfile(s)
Affiche une zone de dialogue permettant de slectionner un
fichier de type texte sur le disque, et unifie s avec le nom avec
chemin de ce fichier (le fichier n'est pas ouvert). La rgle choue si
le bouton Annuler est press. Cette rgle est une forme simplifie
de la primitive suivante.
sfgetfile(point, L_types, filtre, s)

Affiche une zone de dialogue permettant de visualiser, parmi les
fichiers se trouvant sur le(s) disque(s), ceux dont le type est dans
L_types, et de slectionner un fichier parmi ceux-ci (sans que le
fichier ne soit ouvert).
point
est un point de format <x,y> indiquant l'endroit o est
affich le dialogue.
L_types
est une liste de types prcisant les fichiers proposer. Un
type est une chane de 4 caractres tel que dfini dans
Inside Macintosh.
Exemple : ["TEXT","APPL"] montrera les fichiers de type
texte et ceux de type application.
PrologIA
515
filtre
est une procdure de filtrage (en plus du type) pour
l'acceptation des fichiers proposer. Ce doit tre [] pour
l'instant.
s
est unifi avec la slection faite par l'utilisateur. Il est de la
forme : < C , T , N > o C est le crateur (chane de 4
caractres identifiant l'application qui a cr ce fichier), T
est le type du fichier (chane de 4 caractres comme
"TEXT", "APPL", ), et N est une chane indiquant le
chemin d'accs et le nom du fichier slectionn (le fichier
n'est pas ouvert).
La rgle choue si le bouton Annuler est press.
sfputfile(s)
Affiche un dialogue permettant de saisir un nom de fichier sur le
disque, et unifie s avec le nom avec chemin de ce fichier. Si
l'utilisateur tape un nom de fichier dj existant, une alerte le
prvient. Le fichier donn par l'utilisateur n'est ni cr, ni ouvert.
sfputfile(point, prompt, nomInitial, s)

Cette rgle est une forme paramtrable de la prcdente.
point
est un point de format <x,y> indiquant l'endroit o est
affich le dialogue.
prompt
est une chane, (ventuellement vide) contenant un
message destin l'utilisateur.
nomInitial
est une chane (ventuellement vide) permettant de
proposer un nom de fichier dans la zone d'dition. Ce
nom ne doit pas comporter de chemin.
s
est unifi avec le nom avec chemin valid par l'utilisateur
(le fichier n'est ni cr, ni ouvert).
516
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Index des primitives graphiques
:button 501
:button2 501
activate_button 515
add_stdmenu 497
:buttonD 502
:cb 500
"apple" 497
bitmap de rafrachissement 468
:ccol 504
:clipRect 476
:col 504
bote cocher 500

bouton 485; 501
bouton de terminaison 502
:crow 504
:editf 501
:erase 475; 476; 477
check_item 496
clear_menubar 497
clear_window 472
:eraseOval 475
:eraseRect 475
:eraseRoundRect 475
:frame 475; 476
:frameOval 475
:frameRect 475
:frameRoundRect 475
:glist 502
:group 505
:hfill 505
clic 480; 486; 490; 491; 504; 510

cochage d'un item 496
command_menu 496
console 464
"control" 497
coordonnes horizontales 473
coordonnes verticales 473
crayon 474; 481; 482
create_button 515
create_window 471
:invert 475; 476; 477

:invertOval 475
deactivate_button 515
dialogue de saisie de nom de fichier
:invertRect 475
516
:invertRoundRect 475
:paint 475; 476; 477
:paintOval 475
dialogue de slection d'un fichier 516

"DISTANCE" 468
"EDIT" 467
:paintRect 475
:paintRoundRect 475
:rb 500
"edit" 497
enable_menu 496
espacement horizontal 505
:rb1 501
:row 504
:text 500
espacement vertical 504

fentre graphique courante 473
"file" 497
:userItem 503
:vfill 504
file_window 466
"find" 497
PrologIA
517
Aociation
"FONT" 469; 471

fonte 472; 482; 483; 484
gr_window 472
gr_window_is 472
"FONTSIZE" 468; 471

front_window 466
get_key 487
"GRAPHICS" 467
groupe 500
gtty 489
get_screen 466
get_window 466
input 516
item coch 494
gr_arc 476
gr_arc' 477
gr_button_hit 486
kill_button 515
kill_window 472
ligne de texte ditable 501
gr_choosecolor 482
gr_click 479; 480
ligne de texte non ditable 500

load_graphic 464
gr_color 481
gr_color2 481
gr_color3 481
gr_dialog 498
gr_draw_buttons 485
gr_editf 486
gr_erase 474
gr_font 484
gr_getmouse 480
gr_icon 478
gr_line 474
gr_lineto 474
gr_list 489
gr_load 516
gr_mode 482
MacDraw 516
MacPaint 516
menu fugitif 493
menu hirarchique 493
menu pop-up 493
"MODAL" 467
modes de transfert 483
motif 482
"MPW" 489
new_window 467
"NLINES" 468
option fermeture 473
output 516
pixels 466; 471; 474; 482; 504; 511
police de caractres 469
gr_move 474
primitive de groupement 505
gr_moveto 474
gr_pen 482
gr_penloc 474
gr_polygon 476
primitives d'agencement 504

primitives de description 500
print_window 472
raccourci 496
gr_popupItem 491
gr_print 492
gr_rect 475
radio-bouton 500
rafrachissement de la fentre
graphique 473
gr_setorigin 474
gr_stringwidth 482
reset_window 472
restore_menubar 497
gr_text 483
retour chariot 486; 490; 502; 511
518
Prolog
HERITAGE
PrologIA
Aociation
Prolog
HERITAGE
"SAVE" 468; 470

save_menubar 497
save_window 469
set_menu 493
set_window 470
sfgetfile 516; 517
sfputfile 517; 518
"SHAPE" 468
souris 480
srcBic 483
srcCopy 483
srcOr 483
srcXor 483
stty 488
style 482; 483; 497
style_menu 497
tabulation 486; 490; 504; 511
taille de la fonte 472; 482; 483; 484
taille de la police de caractres 468
"TTY" 467; 489
user_item 510
userItem 510
"window" 497
PrologIA
519
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Annexes
A. Liste des messages d'erreur de Prolog III

B. Liste des rgles prdfinies par catgories
C. Quelques programmes Prolog III crits en syntaxe "Edimbourg"
A. Liste des messages d'erreur de

Prolog III
1: Debordement de l'espace de copie
2: Debordement de l'espace de backtracking
3: Debordement de l'espace auxiliaire
9: Debordement de l'espace des regles
10: Division par zero
12: Reel trop grand (1)
13: Reel trop grand (2)
14: Reel indefini (1)
15: Reel indefini (2)
Dcembre 1990
PrologIA
Annexes
Aociation
16: Fichier inexistant

17: Fin de fichier inattendue
18: Tete de regle incorrecte
19: Debordement de la pile de marquage
20: Debordement de l'espace auxiliaire (booleen)
21: Entier trop long
22: Predicat evaluable incorrect
23: Erreur de lecture
24: Nombre incorrect d'argument du predicat evaluable
25: Tuple trop grand (2)
26: Chaine trop grande
27: Identificateur trop long (1)
28: Probleme dans assert
29: Caractere incorrect
30: Conflit Pev Regle
31: Operande non arithmetique
32: Tuple trop grand (2)
33: Erreur de fermeture de fichier (1)
34: Erreur d'ouverture de fichier
35: Erreur de fermeture de fichier (2)
36 Plus de fichier d'entree
37: Trop de fichiers ouverts
38: Trop de fichiers de sortie
39: Plus de fichiers de sortie
40: Erreur dans assert ou in_term
41: Erreur dans in_term
41: Erreur dans assert (1)
42: Mode d'insertion inconnu
46: Regle deja definie
48: Debordement de l'espace auxiliaire (simplex)
49: Erreur lors du compactage de l'espace des regles
50: Block indefini
51: Memoire saturee (1)
52: Erreur d'ouverture du fichier Prolog3.log
53: Erreur dans assert (2)
54: Impossible d'ouvrir le fichier
524
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Annexes
HERITAGE
55: Impossible de fermer le fichier

100: Debordement lors de la simplification (equations)
101: Debordement lors de la simplification (inequations)
102: Debordement lors de la simplification
103: Debordement lors de la simplification (booleen)
201: Fin de liste attendue
202: C'est une liste infinie
203: Chaine attendue
204: Argument de mauvais type
205: Prefixe trop long
207: Identificateur trop long (2)
208: Contexte deja ferme
209: Identificateur inconnu
210: Famille non fermee
211: Regle inexistante (1)
212: Regle inexistante (1)
213: Identificateur attendu (1)
214: Memoire sature (fermeture context)
215: Ce n'est pas une syntaxe d'identificateur
216: Ce n'est pas une syntaxe de prefixe
217: Ce n'est pas un identificateur
218: Dictionnaire plein
219: Reel strictement positif attendu
220: Reel positif ou nul attendu
221: Symbole inconnu
222: Erreur d'ouverture de fichier (save)
223: Erreur entree/sortie
228: Argument de mauvais type
229: Type non defini
PrologIA
525
Annexes
Aociation
230: Dictionnaire plein

231: Longueur inconnue
232: Tableau trop grand
233: Identificateur attendu (2)
234: Entier attendu
235: Tableau deja defini
236: Tableau non defini
237: Debordement de tableau
238: Pas d'identificateur avec ce prefixe
239: Fichier non chargeable
240: Erreur de chargement
241: Prefixe inexistant
242: Erreur de chargement (2)
243: Dbordement de l'espace des regles
244: Fonction non evaluable
245: Erreur dans assign
246: Erreur dans val
247: Erreur dans string_ident
248: Variable PrologEdit non definie
249: Erreur dans end_module
250: Acces deja defini (PRO_BIND)
251: Acces non defini
400: Configuration inconnue
500: Plus assez d'espace. PrologIII abandonne ...
501: Demarrage PrologIII impossible ...
502: Fichier d'erreur non trouv !
503: Le systeme de contraintes de la requete est insatisfaisable.
504: Le systeme de contraintes de la regle est insatisfaisable.
505: Caractere illegal
506: Erreur dans insert ou assert ou in_term
507: Erreur interne (1)
509: Non implemente (1)
526
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Annexes
HERITAGE

1001: Programme abandonne
1016: Interruption utilisateur
1026: Reel trop grand.
1101: Erreur d'ouverture du fichier d'entree
1105: Eof ou erreur sur l'entree standard
1111: Erreur d'ouverture du fichier de sortie
1115: Le fichier est deja ouvert pour une autre operation
1130: L'unite d'entree/sortie existe deja
1255: Doublet attendu pour gr_polygon
1262: Les arguments du premier tuple doivent etre compris entre 0 et 1
1304: Erreur systeme
1362: 'page' et 'set_cursor' desactives
1363: Warning: fichier 'termcap' non trouve
1364: Warning: terminal inconnu pour 'termcap'
1365: Warning: 'clear_screen' non valable pour ce terminal
1366: Warning: variable 'term' non definie
1367: Warning: 'cursor_motion' non defini
1372: Coordonnees graphiques incorrectes
1386: La fenetre associee au bouton n'existe pas
1387: Argument autorise dans une fenetre de dessin uniquement
1388: Unite inexistante ou de mauvais type
1389: Regle predefinie non implantee
1390: Ecran non initialise pour le graphisme
1391: Font non definie
1392: Type de fenetre non valide
1393: Option non valide a la creation de la fenetre
1394: Nombre maximal d'items atteint pour ce menu
1395: Depassement du nombre de niveaux autorises
1396: L'item n'existe pas
PrologIA
527
Annexes
Aociation
1436: Impossible d'ouvrir un nouveau descripteur d'unite

1438: Depasse le nombre d'unites d'e/s ouvertes possibles
1462: Nb de points maximal d'un polygone depasse
1471: 'string_term': chaine trop longue
1548: 'lkload' : descripteur non present dans le fichier
1700: Erreur de lecture dans un co_process
1701: Erreur d'ecriture dans un co_process
1815: Echec interne dans 'gr_dialog'
1816: Echec dans une regle appelee par 'gr_dialog'
1817: Item incorrect dans 'gr_dialog'
1818: 'gr_dialog' : erreur interne
528
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Annexes
HERITAGE
B. Liste des rgles prdfinies par

catgorie
Rgles prdfinies Prolog III
Arbres, listes, chanes et tuples

AAarg(N, T1, T2)
arg2(N, L, T)
arg3(N, T1, T2)
bound_conc(U1, U2, U3)
bound_size(T, N)
bound_tree(T)
bound_tree'(T)
conc3(U1, U2, U3)
conc_string(S1, S2, S3)
find_pattern(S1, S2, N)
known_part(U1, U2, U3)
size(U, N)
substring(S1, N1, N2, S2)
Contrle
assign(I, T)
assign(tab(N), T)
block(E, B)
block_exit(E)
block(E, C, B)
block_exit(E, C)
bound(T)
cut
default(T1, T2)
dif(T1, T2)
eq(T1, T2)
fail
findall(v,p,l)
free(T)
freelabel(T)
PrologIA
529
Annexes
Aociation
freeze(T, P)
known(T)
not(T)
predefined(T)
repeat
val(T1, T2)
Contraintes numriques
bound_mult(N1, N2, N3)
div(N1, N2, N3)
enum(R)
enum(R, R1)
enum(R, R1, R2)
gcd(N1,N2,N3)
lcm(N1,N2,N3)
max_value(R1, R2)
min_value(R1, R2)
mod(N1, N2, N3)
mult(N1,N2,N3)
numden(R,N1,N2)
particular_value(R1, R2)
pgcd(A,B,P)
ppcm(A,B,P)
trunc(R, N)
Conversion
char_code(C, N)
list_string(L, S)
list_tuple(L, U)
split(U, L)
string_bool(S,B)
string_ident(P, S, I)
string_ident(S, I)
string_integer(S,N)
string_real(S,F)
Environnement
cpu_time(N)
edinburgh
edit(I)
exit
exit(S)
garbage_collection
get_config(S,V)
get_configuration(U)
getenv(S1,S2)
no_trace
prologIII
quit
530
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Annexes
HERITAGE
quit(N)
reset_cpu_time
resume_trace
save
save(L, F)
save(S)
set_config(S, V)
set_configuration(U)
state
suspend_trace
sys_command(S)
trace
trace_file(S)
Entres/Sorties
close_input
close_input(F)
close_output
close_output(F)
echo
in_char(C)
in_char'(C)
in_ident(I)
in_integer(N)
in_real(R)
in_sentence(T1,T2,T3)
in_sentence'(T)
in_string(S)
in_term(T)
inl(S)
input(F)
input_is(F)
insert
insert(F)
line
next_char(C)
next_char'(C)
no_echo
out(T)
outc(T)
outl(T)
outm(S1, S2, , SN)
outml(S1, S2, , SN)
output(F)
output_is(F)
reinsert
reinsert(F)
reload(F, L)
PrologIA
531
Annexes
Aociation
Gestion des rgles et des identificateurs

add_implicit(S1,S2)
assert(T, Q)
asserta(T, Q)
assertz(T, Q)
assert''(T,Q)
close_context_dictionary(S)
current_context(T0, T1, T2, T3)
current_context(T0)
current_predicate(<I, A>)
def_array(I, N)
dictionary
dictionary(L)
dictionary(M, L)
end_module
kill_module(S)
list
list(<I, A>)
list(<I, A>,N)
list([<I1,A1>,...,<In,An>])
list(T)
module
new
redef_array(tab,N)
remove_implicit(S1, S2)
retract(T,Q)
rule(N,AT, Q)
rule(N,T, Q)
rule(T, Q)
rule_nb(<I, A>, N)
set_context (I, S, S', D)
set_ident(I,N)
suppress(I)
suppress(I, A)
suppress(I, A, N)
undef_array(tab)
Vrification de types
bool(B)
char(C)
dot(T)
ident(I)
integer(N)
is_bool(B)
is_char(C)
is_ident(I)
is_leaf(T)
is_num(R)
is_tuple(U)
is_univ(T)
num(R)
532
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Annexes
HERITAGE
rational(R)
real(F)
string(S)
tuple(U)
Arbres, listes, chanes et tuples

'='(X, Y)
'=..'(X, Y)
'=='(X, Y)
'\=='(X, Y)
functor(T, E, N)
member(X, L)
name(X, L)
op(N, I1, S)
op(N, I1, S, I2)
Contrle
','(X, Y)
'->'(Y)
';'(X; Y)
'[]'(X, Y)
[]
[X|Y]
call(P)
nonvar(T)
true
var(T)
Evaluation de fonctions prdfinies

'<'(X, Y)
'=:='(X, Y)
'=<'(X, Y)
'=\='(X, Y)
'>'(X, Y)
'>='(X, Y)
is(X, T)
Entres/Sorties
consult(S)
get(X)
get0(X)
nl
put(X)
PrologIA
533
Annexes
Aociation
read(T)
see(F)
seen
tab(N)
tell(F)
told
write(T)
writeq(T)
Gestion des rgles et des identificateurs

abolish(<I, A>)
abolish(I)
assert(T)
asserta(T)
assertz(T)
clause(T, Q)
listing
listing(<I, A>)
listing(I)
retract(X)
retractall(T)
Vrification de types
atom(T)
atomic(T)
number(R)
534
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Annexes
HERITAGE
C. Quelques programmes Prolog III

crits en syntaxeEdimbourg
1.
2.
3.
4.
5.
6.
7.
8.
9.
Un petit exemple : menu.p3e

Calculs sur les grands nombres : fact.p3e
Calculs bancaires : bank.p3e
Manipulation d'arbres : leaves.p3e
Un peu de logique : god.p3e
Un problme de Lewis Caroll : lewis.p3e
Dtection de pannes dans un additionneur : circuit.p3e
Un puzzle numrique : send.p3e
Un problme de remplissage : rectangle.p3e
Les programmes d'exemples de cette annexe sont des traductions en syntaxe

Edimbourg des principaux programmes donns dans ce manuel.
PrologIA
535
Annexes
Aociation
1 . Un petit exemple : menu.p3e

Le programme :
%%% Le fameux repas equilibr .
repasLeger(H,P,D) :horsDoeuvre(H,I),
plat(P,J),
dessert(D,K)
{I>=0, J>=0, K>=0, I+J+K=<10}.
plat(P,I) :- viande(P,I).
plat(P,I) :- poisson(P,I).
horsDoeuvre(radis,1).
horsDoeuvre(pate,6).
viande(boeuf,5).
viande(porc,7).
poisson(sole,2).
poisson(thon,4).
dessert(fruit,2).
dessert(glace,6).
Une Question :
?- repasLeger(H,P,D).
536
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Annexes
HERITAGE
2 . Calculs sur les grands nombres :

fact.p3e
Le programme factorielle :
%%% Factorielle
N! = N*(N-1)*(N-2)*....*2*1
factorielle(0, 1).
factorielle(N, N*M) :- factorielle(N-1, M) {N >= 1}.
Questions (la 4me question peut ne pas marcher avec les nombres
flottants, selon l'implmentation des rels utilise sur votre
machine)
?- factorielle(10, X).
?- factorielle(100.0, X).
PrologIA
537
Annexes
Aociation
3. Calculs bancaires : bank.p3e

Le programme :
/* Calcul bancaire. Le taux d'intert est de 10% */
versementsCapital(<>, 0).
versementsCapital(.X, C) :versementsCapital(X, C+(10/100)C-I).
Quelques questions poses avec des nombres entiers ou flottants :

?- versementsCapital(<I, 2I, 3I>, 1000).
?- versementsCapital(<I, I, I>, 10000).
?- versementsCapital(<I, 2I, 3I>, 1000.0).
?- versementsCapital(<I, I, I>, 10000.0).
538
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Annexes
HERITAGE
4. Manipulation d'arbres : leaves.p3e

Le programme :
%%% Construit la liste des feuilles d'un arbre.
leavesOf(A, X) :leavesOfTree(A, X, <>).
leavesOfTree(E[<>], <E>.X, X) .
leavesOfTree(E[U], X, X') :leavesOfList(U, X, X')
{U # <>}.
leavesOfList(<>, X, X) .
leavesOfList(<A>.U, X, X'') :leavesOfTree(A, X, X'),
leavesOfList(U, X', X'').
Questions :
?- leavesOf(measures("Max", <1+75/100, metres>, 1'), X).
?- leavesOf(weighs("Max",<2 P + 1, kg>,male(1'),ò`,'H'),X).
PrologIA
539
Annexes
Aociation
5. Un peu de logique : god.p3e

Le programme :
valueOfSomethingHasAlwaysExisted(B)
{ A = 1',
A => (B | C) & ~(B & C),
A => (D | E) & ~(D & E),
D => B,
E => ~C }.
LA question :
?- valueOfSomethingHasAlwaysExisted(B).
540
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Annexes
HERITAGE
6. Un problme de Lewis Caroll :

lewis.p3e
Le programme :
%%%% Peut-on tre dput ? .
possibilite(X) :- casPossible(Y), sousEnsemble(X,Y).
sousEnsemble(<>,Y).
sousEnsemble(<E>.X,Y) :- elementDe(E,Y), sousEnsemble(X,Y).
elementDe(E,<E>.Y).
elementDe(E,<F>.Y) :- elementDe(E,Y) {E#F}.
casPossible(<
<A,"avoir l'esprit clair">,
<B,"avoir recu une bonne education">,
<C,"discourir sans cesse">,
<D,"employer son influence a des fins meritoires">,
<E,"etre affiche dans les vitrines">,
<F,"etre apte a etre depute">,
<G,"etre un bienfaiteur du peuple">,
<H,"etre digne d'eloges">,
<I,"etre populaire">,
<J,"etre sans pretention">,
<K,"etre une femme">,
<L,"laisser un souvenir imperissable">,
<M,"posseder une influence">,
<N,"savoir garder un secret">,
<O,"s'exprimer bien">,
<P,"valoir son pesant d'or">>)
{
(F & ~C) => G,
(A & O) => B,
(K & H) => N,
(G & ~D)=> ~F,
(P & H) => J,
(G & D) => H,
(~I & ~P) => ~N,
(C & F) => H,
(N & J) => (G & L),
(K & G) => I,
(P & C & L) => E,
(K & ~A & ~B) => ~F,
PrologIA
541
Annexes
Aociation
(N & ~C) => ~I,

(A & M & D) => G,
(G & J) => ~E,
(N & D) => P,
(~O & ~M) => ~K,
(I & H) => (G | J)
}.
Exemples de questions permettant de dcouvrir des liens (s'il en

existe) entre des proprits :
?- possibilite(<<A,"avoir l'esprit clair">,
<I,"etre populaire">,
<N,"savoir garder un secret">>).
?- possibilite(<<N,"savoir garder un secret">,
<F,"etre apte a etre depute">,
<P,"valoir son pesant d'or">>).
?- possibilite(<<K,"etre une femme">,
<F,"etre apte a etre depute">>)
{K!bool,F!bool}.
542
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Annexes
HERITAGE
7. Dtection de panne dans un

additionneur : circuit.p3e
Le programme :
/*Dtecteur de pannes
Notez que la 3me contrainte de la rgle suivante
contient le terme (U1|U2), parenths afin de pallier
une erreur dans l'analyse de cet oprateur OU (|) .
*/
circuit(<X1,X2,X3>, <Y1,Y2>, <P1,P2,P3,P4,P5>) :atMostOneTrue(<P1,P2,P3,P4,P5>)
{ ~P1 => ( U1 <=> X1 & X3 ),
~P2 => ( U2 <=> X2 & U3 ),
~P3 => ( Y1 <=> (U1 | U2) ),
~P4 => ( U3 <=> ~(X1 <=> X3)),
~P5 => ( Y2 <=> ~(X2 <=> U3)) }.
atMostOneTrue(P) :- orOnAtMostOneTrue(P,_p).
orOnAtMostOneTrue(<>, 0').
orOnAtMostOneTrue(<E>.P, E|V) :orOnAtMostOneTrue(P, V)
{E&V = 0'}.
%%% Ces rgles sont utilises par le second jeu de questions:
booleans(<>).
booleans(.L) :- boolean(B), booleans(L).
boolean(0').
boolean(1').
Premier jeu de questions :

?- circuit(<1',1',0'>,<0',1'>,<P1,P2,P3,P4,P5>).
?- circuit(<0',0',1'>,<0',1'>,<P1,P2,P3,P4,P5>).
?- circuit(<1',0',1'>,<0',0'>,<P1,P2,P3,P4,P5>).
?- circuit(<X1,X2,X3>,<Y1,Y2>,<P1,P2,1',P4,P5>).
PrologIA
543
Annexes
Aociation
Second jeu de questions :

?- circuit(<X1,X2,X3>,<Y1,Y2>,<P1,P2,1',P4,P5>),
booleans(<X1,X2,X3,Y1,Y2>).
booleans(<X1,X2,X3,Y1,Y2>),
circuit(<X1,X2,X3>,<Y1,Y2>,<P1,P2,0',P4,P5>).
booleans(<X1,X2,X3,Y1,Y2>),
not(circuit(<X1,X2,X3>,<Y1,Y2>,<P1,P2,0',P4,P5>)).
544
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Annexes
HERITAGE
8. Un puzzle numrique : send.p3e

Le programme :
/* L'addition doit tre rsolue avec des chiffres distincts :
SEND
+ MORE
-----MONEY
*/
solution(I, J, K) :allDifferentDigits(<M,S,O,E,N,R,D,Y>),
integers(<M,S,O,E,N,R,D,Y>)
{ S#0, M#0, I+J=K,
I =
1000S + 100E + 10N + D ,
J =
1000M + 100O + 10R + E ,
K = 10000M + 1000O + 100N + 10E + Y
}.
integers(<>).
integers(<E>.R) :- enum(E), integers(R).
allDifferentDigits(<>).
allDifferentDigits(<X>.S) :outsideOf(X, S),
allDifferentDigits(S)
{0 =< X, X =< 9}.
outsideOf(X, <>).
outsideOf(X, <Y>.S) :- outsideOf(X, S) {X#Y}.
La question :
?- solution(I,J,K).
PrologIA
545
Annexes
Aociation
9. Un problme de remplissage :
rectangle.p3e
Le programme :
%%% Remplir un rectangle 1 x A avec N carrs distincts .
remplirRectangle(A, C) :creerCarres(C),
remplirZone(<-1,A,1>, L, C, <>)
{A >= 1}.
creerCarres(<>).
creerCarres(.C) :creerCarres(C),
rendreDistinct(B, C)
{B > 0}.
rendreDistinct(B, <>).
rendreDistinct(B, <B'>.C) :rendreDistinct(B, C)
{B # B'}.
remplirZone(<V>.L, <V>.L, C, C)
{V >= 0}.
remplirZone(<V>.L, L''', .C, C'' ) :placerCarre(B, L, L'),
remplirZone(L', L'', C, C'),
remplirZone(<V + B, B>.L'', L''', C', C'')
{V < 0}.
placerCarre(B, <H, 0, H'>.L, L') :placerCarre(B, <H + H'>.L, L')
{B > H}.
placerCarre(B, <H, V>.L, <-B + V>.L)
{B = H}.
placerCarre(B, <H>.L, <-B , H - B>.L)
{B < H}.
Une question : comment remplir un rectangle de taille inconnue

avec 9 carrs diffrents et de tailles inconnues ?):
?- remplirRectangle(A, C)
546
Prolog
HERITAGE
{C :: 9}.
PrologIA
Aociation
Prolog
Index
HERITAGE
Index
! (coupure) 164
"apple" 497
, 418
-> 417
arbres 20; 70
arbres factuels 71
arbres infinis 75
/ (coupure) 164
< 411
<> (tuple vide) 27
= 412
arg 81; 203
=.. 410
=:= 415
=< 411
arithmtique 14
arg2 84; 204

arg3 80; 205
== 413
assert 186; 206; 378

assert'' 187; 208
asserta 186; 207; 380
=\= 416
> 411
>= 411
assertz 187; 208; 378

assign 173; 174; 209
atan 172; 370
[ ] (liste vide) 33
[ ] (symbole fonctionnel) 83
[] 420
\== 414
atom 381
atomic 382
A
abandon de l'excution
(block_exit) 166
abolish 377
abs 172; 369
activate_button 515
add 170; 368
add_implicit 183; 202
add_stdmenu 497
addition 30; 98
affectation 47
affectation (assign) 173
affectation boolenne 125
ajout d'une rgle (assert) 186
d'un
but

block 166; 212
block_exit 166; 212
bote cocher 500
bool 129; 214
boolens 16; 118
syntaxe 428
bouclage 162
bound 149; 167; 215
bound_conc 80; 216
bound_mult 105; 156; 217
bound_size 80; 151; 218
bound_tree 219
bound_tree' 220
bouton 485; 501
PrologIA
547
Index
buts 60
syntaxe 440
Aociation
consult 385
contexte courant 179
contexte de lecture-criture 24; 179
contraintes 54; 438
boolennes 16; 120
exemples 122
forme normale 123
call 383
simplification 127
contrainte de taille 76
caractres 25
caractre dchappement (\) 430
numriques 101
caractre dsign 430

espace 428
remarques 441
exemples 101
forme normale 102
syntaxe 431
retardes 156
retardes 151
chanes de caractres 13; 27; 71; 85

syntaxe 431
changement de signe 30
syntaxe 439
contraintes de type
char 221
!bool 53; 120
char_code 222
chargement d'un programme (input) 8
check_item 496
!boolt 53; 120

!char 53
clause 384
clear_menubar 497
clear_window 472
!id 53
!idt 53
!num 53; 100
clic 480; 486; 490; 491; 504; 510

close_context_dictionary 183; 223
!numt 53; 100

!tuple 53
close_input 9; 195; 224

close_output 11; 197; 225
command_menu 496
commentaire 442; 459
comparaisons numriques 52
conc3 80; 154; 226
conc_string 85; 227
concatnation 12; 76
retarde 154
connu (terme) 148
console 6; 464
constantes 23
boolennes 119
numriques 97
syntaxe 428
constructeur
darbres 72
de tuples 72
gnral darbres 72
548
Prolog
HERITAGE
!chart 53
contraintes numriques 14
"control" 497
contrle 162
cos 172; 370
coupure 164
cpu_time 198; 228
crayon 474; 481; 482
create_button 515
create_window 471
current_context 182; 229
current_predicate 187; 230
cut 231
cut (coupure) 164
D
def_array 174; 232
default 167; 234
PrologIA
Aociation
Prolog
Index
HERITAGE
dfinition de contexte (set_context) 180
expressions boolennes 43; 120
dialogue de saisie de nom de fichier 516
expressions numriques 42; 99

flottants 40
freeze 149
dictionary 184; 235
identificateurs 38
listes 84
dif 237
"DISTANCE" 468
modules 186
rgles 61
requtes 61
div 106; 171; 238; 368

division 31; 98
dot 239
termes 38; 45
utilisation de la coupure (/) 164
exemples de programmes
additionneur binaire 135
echo 197; 240; 341
au plus un vrai 131
edinburgh 241
"EDIT" 467
calcul bancaire 108

calcul des feuilles 87
"edit" 497
ChatsOiseaux 15
edit 242
galit 50
enable_menu 496
crible d'Eratosthne 90
element_de 13
K lments vrais 133
end_module 185; 243

ensemble de contraintes
boolennes 122
naive reverse 82
puzzle logique 143
quick sort 87
entre-sorties 192
remplissage d'un rectangle 110
enum 104; 244

epsilon_float 342
eq 246
RepasLeger 9
SEND + MORE = MONEY 109
eql 171; 369

escape 431
et 29; 119
excution d'un programme 64
exemples
arbres 71
caractres 40
chanes 41
constructeurs 73
contraintes 56
contraintes boolennes 122
contraintes sur les arbres 74
contraintes sur les chanes 85
contraintes sur les tuples 78
entiers 39
suite priodique 89
un ou sur 2 variables 129
un ou sur une liste 130
exit 198; 247
exp 172; 370
expressions
boolennes 43; 119; 437
numriques 42; 97; 436
maximum 105
minimum 105
prdicat val 168
F
fail 249
faits vrais 62
famille 178
partie ferme 178
Fdecimal 108
PrologIA
549
Index
Aociation
get_key 487
feuille 21
Fexact 108
get_screen 466
Ffloat 108
getenv 259
gr_arc 476
"file" 497
get_window 466
file_window 466
fin de session (quit) 11
gr_arc' 477
"find" 497
gr_choosecolor 482
gr_click 479; 480
find_pattern 85; 251

findall 250
Fint+fract 108
Fnormal 108
fonctions valuables 170
gr_button_hit 486
gr_color 481
gr_color2 481
gr_color3 481
gr_dialog 498
"FONT" 469; 471
gr_draw_buttons 485
fonte 472; 482; 483; 484

"FONTSIZE" 468; 471
gr_editf 486
gr_erase 474
format_decimal 342
gr_font 484
format_float 342
format_out_num 108; 341
gr_getmouse 480
gr_icon 478
Fdecimal 341
Fexact 341
gr_line 474
Ffloat 341
Fint+fract 341
Fnormal 341
gr_list 489
gr_load 516
formats d'entre-sorties 108

forme clausale 124
forme normale
forme normale conjonctive 123
formfeed 431
free 149; 168; 252
free_label 253
freeze 157; 254
front_window 466
functor 386
G
gcd 256
get 387
get0 388
get_config 257
550
Prolog
HERITAGE
gr_lineto 474
gr_mode 482
gr_move 474
gr_moveto 474
gr_pen 482
gr_penloc 474
gr_polygon 476
gr_popupItem 491
gr_print 492
gr_rect 475
gr_setorigin 474
gr_stringwidth 482
gr_text 483
gr_window 472
gr_window_is 472
"GRAPHICS" 467
groupe 500
gtty 489
I
ident 260
identificateurs 24; 433; 444
PrologIA
Aociation
Prolog
Index
HERITAGE
abrgs 177
syntaxe 177; 434; 444
complets 177
sparateur 177
kill_button 515
syntaxe 177; 434; 444
kill_module 12; 191; 283

kill_window 472
if 172; 369
implique (opration) 29; 119
implique (relation) 52; 120
in_char 193; 261
in_char' 262
in_ident 263
in_integer 264
in_real 265
in_sentence 194; 266
in_sentence' 267
in_string 268
in_term 269
ingalit 50; 101
inquations numriques 104
inf 171; 369
infe 171; 369
infrieur ou gal 101
infrieur strict 101
inl 270
input 8; 194; 271; 516
input_is 272
insert 188; 189; 273
integer 106; 275
interruption 167
is 389
is_bool 129; 276
is_char 277
is_ident 278
is_leaf 279
is_num 106; 280
is_tuple 81; 281
is_univ 282
item coch 494
J
jeu de caractres 427
known 148; 284

known_part 81; 152; 285
L
lcm 286
line 197; 287
linefeed 431
list 7; 9; 11; 189; 288
list_string 86; 293
list_tuple 84; 294
liste vide 84
syntaxe 429
listes 33; 83
listing 390
littral 124
ln 172; 370
load_graphic 464
M
MacDraw 516
machine Prolog III 65; 162
MacPaint 516
max_value 105; 295
maximum d'une expression numrique 105
member 391
menu fugitif 493
menu pop-up 493
min_value 105; 296
minimum d'une expression numrique 105
mod 106; 171; 297; 369
"MODAL" 467
module 24; 178; 298
objet 186
PrologIA
551
Index
Aociation
oprateurs 445
source 185
boolens
module(directive) 185
modules
quivalent 119
et 119
exemples 186
moins unaire 98
implique 119
motif 482
"MPW" 489
non 119
ou 119
Edimbourg 459
mul 170; 368
numriques 98
oprations 28
mult 105; 157; 158; 299

multiplication 31; 98
arithmtiques 30; 98
boolennes 29
concatnation de tuples 32; 76
naive_reverse 82
construction d'arbre 31; 71
name 392
new 300
construction de tuple 32; 71

construction gnrale d'arbre 32; 71
ou 29; 119
new_window 467
newline 431
next_char 301
next_char' 302
out 195; 308

outc 196; 309
outl 195; 310
outm 196; 311
nil 33
nl 393
"NLINES" 468
outml 7; 196; 312

output 11; 197; 313; 516
output_is 314
no_echo 197; 303

no_trace 304
nombres 14
entiers 26
syntaxe 428
flottants 26; 94
syntaxe 429
fractionnaires 94
rationnels 94
non 29; 119
non (prdicat) 166
nonvar 394
not 305
num 106; 306
number 395
numden 307
O
omission de l'oprateur de multiplication
99
op 396
552
Prolog
HERITAGE
paire pointe 33; 83

paramtres graphiques
:button 501
:button2 501
:buttonD 502
:cb 500
:ccol 504
:clipRect 476
:col 504
:crow 504
:editf 501
:erase 475; 476; 477
:eraseOval 475
:eraseRect 475
:eraseRoundRect 475
:frame 475; 476
:frameOval 475
PrologIA
Aociation
Prolog
Index
HERITAGE
:frameRect 475
:frameRoundRect 475
:glist 502
:group 505
qualifieur 24
:hfill 505
quit 8; 198; 320
:invert 475; 476; 477

:invertOval 475
:invertRect 475
:paint 475; 476; 477
:paintOval 475
:paintRect 475
:paintRoundRect 475
:rb 500
:rb1 501
:row 504
:text 500
:userItem 503
:vfill 504
parasite 164
particular_value 105; 315
partie ferme d'une famille 179
pgcd 316
pixels 466; 471; 474; 482; 504; 511
R
raccourci 496
rad 172; 370
radio-bouton 500
rafrachissement de la fentre graphique
473
rational 106; 322
read 398
real 106; 323
rcapitulatif
oprations et relations boolennes 123
oprations et relations dfinies sur les
arbres et les tuples 79
redef_array 324
rgles 60
prdfinies
boolens 128
numrique 104
plus unaire 98
ppcm 317
prcision parfaite 26; 94
predefined 190; 318
prfixe 24
syntaxe 177; 434; 444
primitives
boolens 128
conversions de chanes 86
numrique 104
tuples 80
print_window 472
priorits
des oprateurs boolens 119
des oprateurs numriques 98
projection sur un sous-vocabulaire 127
prologIII 319
put 397
tuples 80
syntaxe 440; 456
reinsert 188; 189; 325
relations 49
boolennes 120
de type 53
galit 50
implication 52; 120
ingalit 50
nombre de fils 74
numriques 100
unaires 53
reload 191; 327
remove_implicit 183; 328
repeat 329
requtes 61
syntaxe 440; 456
reset_cpu_time 198; 330
reset_window 472
PrologIA
553
Index
Aociation
rsolution des systmes de contraintes 57
trace 340
restore_menubar 497
restrictions
tty_wrap 342
concatnation 77
linarit 102
nombres entiers 102
taille 76
resume_trace 331
retardements
concatnation 154
contraintes non-linaires 106
freeze 149
tailles 151
retour chariot 486; 490; 502; 511
retract 190; 332; 399
undefined_rule 343
set_context 180; 182; 345
set_ident 346
set_menu 493
set_window 470
sfgetfile 516; 517
sfputfile 517; 518
"SHAPE" 468
si_alors_sinon 166
simplification
sin 172; 370
size 80; 152; 347
return 431
rubout 431
solution d'un systme de contraintes 57

boolennes 126
souris 480
rule 190; 333

rule_nb 336
soustraction 31; 98
split 81; 348
sqrt 173; 370

srcBic 483
srcCopy 483
sauvegarde d'un module 11

sauvegarde de modules (save) 192
srcOr 483
srcXor 483
"SAVE" 468; 470

save 192; 337
state 349
string 87; 350
string_bool 86; 351
string_ident 86; 352
string_integer 86; 354
string_real 86; 355
stty 488
style 482; 483; 497
style_menu 497
sub 170; 368
substring 86; 356
sup 171; 369
supe 172; 369
suprieur ou gal 101
suprieur strict 101
suppress 10; 15; 191; 357
suppression
de rgles (suppress) 10; 191
suspend_trace 360
symboles relationnels
retractall 400
save_menubar 497
save_window 469
see 401
seen 402
smantique 62
dclarative 62
des termes 46
oprationnelle 62
sparateur 177
set_config 108; 340
echo 341
epsilon_float 342
format_decimal 342
format_float 342
format_out_num 341
statistics 342
syntax 342
554
Prolog
HERITAGE
PrologIA
Aociation
Prolog
Index
HERITAGE
warning 343
boolens 120
numriques 100
syntax 342
Edinburgh 342
units d'entre/sortie 192

user_item 510
userItem 510
Prolog III 342

syntaxes
choix du mode syntaxique 424
syntaxe de base 424
V
val 169; 367
syntaxe Edimbourg 425

sys_command 361
abs 369
add 368
systmes de contraintes 54
atan 370
syntaxe 438; 454
cos 370
div 368
eql 369
exp 370
tab 403
tableaux (def_array) 174
if 369
inf 369
tabulation 431; 486; 490; 504; 511

infe 369
ln 370
mod 369
mul 368

tailles 76
retardes 151
rad 370
sin 370
sqrt 370
tan 173; 370

tell 404
termes 35
sub 368
sup 369
connus 148
sans variable 37
syntaxe 435; 447; 450
tte de rgle 60
told 405
trace 340; 362
trace_file 363
true 406
trunc 106; 172; 364; 369
"TTY" 467; 489
tty_wrap 342
tuple 81; 365
tuples 12; 22; 71; 76
supe 369
tan 370
trunc 369
valeurs boolennes 25
var 407
variables 34
d'carts 104
syntaxe 433; 443
W
"window" 497
write 408
writeq 409
undef_array 366
undefined_rule 343
error 343
fail 343
PrologIA
555
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Prolog III
Version 1.3
Manuel d'Utilisation
Macintosh
Dcembre 1990
PrologIA
Aociation
Prolog
HERITAGE
limitation.
Droits d'auteur
Dcembre 1990
PrologIA
Aociation
Prolog
HERITAGE
Utilisation de Prolog III

sur Macintosh
1.
2.
3.
4.
5.
6.
Installation de Prolog III

Utilisation de Prolog III
Spcificits de Prolog III Macintosh
A propos de l'environnement
Ajout de rgles
Appel de Prolog III depuis le langage C

Ce chapitre explique toutes les caractristiques du systme Prolog III qui dpendent
de la machine utilise ou de son systme d'exploitation.
Il y est question principalement de la procdure d'installation du systme Prolog III
et des particularits de son activation (paramtres d'excution, tailles des espaces,
etc).
Ce chapitre explique aussi comment ajouter Prolog III, travers C, vos propres
rgles prdfinies externes, crites dans n'importe quel langage de programmation.
Dcembre 1990
PrologIA
Utilisation de Prolog III sur Macintosh
1 . Installation de Prolog III

Ce paragraphe dcrit la procdure d'installation du logiciel Prolog III sur
Apple Macintosh. Il est recommand de le lire en entier avant de
commencer l'installation.
Matriel et logiciel requis
Prolog III est disponible sur toute la gamme Macintosh, du Mac Plus au Mac
II. Il faut au minimum 2,5 Mo1 de mmoire vive; 4 Mo ou plus sont
souhaitables pour une utilisation confortable. Prolog III est compatible avec
MultiFinder et peut fonctionner en tche de fond. Bien qu'il ne soit pas
impossible de travailler avec deux disquettes, un disque dur est fortement
conseill.
Pour ajouter Prolog III des rgles prdfinies implantes par des sousprogrammes externes, vous aurez besoin en outre de l'environnement de
programmation MPW Version 2 d'Apple, avec le compilateur C et les
logiciels et bibliothques qui lui sont associs, ou bien le compilateur de tout
autre langage compatible avec MPW C (c'est--dire, permettant les appels
inter-langages de sous-programmes). Ici, la taille des fichiers objets et de
l'application construire impose la prsence d'un disque dur.
Contenu du kit d'installation
Le kit de distribution de Prolog III se compose de trois disquettes de 800 Ko.

Les disque 1 et disque 2 contiennent surtout les fichiers dont vous
avez besoin pour utiliser Prolog III. Le dossier sources et objets du
disque 2 et disque 3 contiennent les fichiers requis pour augmenter
Prolog III par l'ajout de vos propres rgles prdfinies crites en C ou tout
autre langage, ou bien augmenter votre application par des appels Prolog :
Avec un tout petit systme, et sans multifinder.
1002
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Fichiers indispensables pour utiliser Prolog III

Prolog III
Fichier excutable contenant l'interprte de Prolog III. C'est une

application Macintosh ordinaire que l'on dmarre la souris par
un double clic.
prolog3.bst
Fichier ncessaire au dmarrage de l'interprte.

prolog3.lex
Fichier de donnes pour l'analyseur syntaxique de Prolog III.

prolog3.sya
Messages d'erreur de l'analyseur (version anglaise).

prolog3.syf
Messages d'erreur de l'analyseur (version franaise).

prolog3.syn
Messages d'erreur de l'analyseur. Il s'agit en fait d'une copie de l'un

des fichiers prolog3.sya ou prolog3.syf.
prolog3.era
Messages d'erreur de l'interprte (version anglaise).

prolog3.erf
Messages d'erreur de l'interprte (version franaise).
PrologIA
1003

prolog3.err
Messages d'erreur de l'interprte. Il s'agit en fait d'une copie de l'un

des fichiers prolog3.era ou prolog3.erf.
initial3.psv
Etat sauv initial : contient notamment les dclarations, sous une

forme code, des rgles prdfinies.
prolog3.prf
Fichier de prfrences : contient une configuration sous la forme

d'une ligne de commande qui peut tre modifie (voir le paragraphe
suivant).
edinburg.mo
Module contenant les dclarations, sous une forme code, des rgles
prdfinies utilisables en syntaxe Edimbourg. On peut s'en passer si
on ne souhaite pas utiliser ces rgles-l.
Fichiers annexes
exemples
Ce dossier contient un certain nombre de programmes-sources

Prolog III.
Le rle des fichiers du disque 3 et du dossier sources et objets est expliqu
dans la section Ajout de rgles prdfinies de ce chapitre.
Procdure d'installation
Sur disque dur

Copiez les fichiers et dossiers des volumes de distribution dans votre disque
de travail, puis rangez les volumes de distribution en un lieu sr. Pour
utiliser Prolog en consommant le moins d'espace disque, vous pouvez ne
recopier que les fichiers qualifis d'indispensables dans la liste prcdente. Il
vaut mieux copier dans un mme dossier les fichiers Prolog III, initial3.psv,
prolog3.bst, prolog3.err, prolog3.syn et prolog3.prf.
1004
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Sur Disquettes
Il faut disposer d'au moins deux lecteurs. Mettre sur la disquette systme le
fichier initial3.psv et sur une nouvelle disquette une copie des autres fichiers
dits indispensables. Vous devez dmarrer partir du dossier contenant
initial3.psv (en le cliquant par exemple).
2 . Utilisation de Prolog III

Activation de Prolog III
Pour commencer une session, ouvrez l'application Prolog III ou bien un

document qui lui est associ (initial3.psv par exemple, ou bien un fichier texte
ou module cre par une prcdente session). Dans tous les cas, le rpertoire
par dfaut (c.a.d. celui pour lequel les fichiers n'auront pas besoin d'avoir un
nom complet) est celui dans lequel on a slectionn le ou les documents
ouvrir (ou cliquer)
Pour terminer une session, excutez (sous Prolog III) la requte quit; ou bien
choisissez l'item Quit du menu Fichier.
Paramtrisation de l'interprte Prolog III
Si vous souhaitez activer Prolog III en redirigeant les entres/sorties (ce qui
suppose une utilisation non interactive de Prolog III) ou bien en fixant des
paramtres dexcution quon modifie rarement, il vous suffit de crer un
fichier prolog3.prf dans le dossier contenant l'application Prolog III. Ce fichier
doit contenir une ligne de texte qui possde en ralit la syntaxe et la
signification de la commande qui activerait Prolog III dans un
environnement de type UNIX,
Seule la premire ligne du fichier prolog3.prf est prise en compte. Celle-ci doit
commencer par Prolog3. En voici un exemple relativement complexe (le texte
suivant serait en ralit crit sur une seule ligne) :
PrologIA
1005

Prolog3
c10000
u200
b2000
Aociation
r100000
Osortie.log
Ientree.log
Ces spcifications configurent la session Prolog III de la manire suivante : la

pile de copie (c) a une taille de 10000 mots, la pile de restauration (b) une
taille de 2000 mots, lespace des rgles (r) dispose de 100000 mots et lespace
auxiliaire des algbres (u) comporte 200 mots. Dans tous les cas il s'agit de
mots de quatre octets. En outre, la sortie standard (O) est redirig vers le
fichier sortie.log et les entres (I) sont lues sur le fichier entree.log.
Finalement, l'affichage des messages informatifs autres que les messages
derreurs est supprim.
De manire gnrale, la liste des options a la structure suivante (le signe
signifie qu'un argument doit tre prsent, coll loption) :
I O Y c u b r m -i -e q
Ifichier
spcification d'un fichier d'entre qui, ds de dbut de la

session Prolog III, prendra la place du clavier. Ceci implique
une utilisation non interactive de Prolog III ; pour cette
raison, cette option et sa suivante sont d'un usage
exceptionnel.
Ofichier
spcification d'un fichier de sortie qui remplacera l'cran.
Yfichier
spcification d'un fichier de messages d'erreur. Par dfaut,

le fichier utilis est le fichier prolog3.syn livr.
ctaille
spcification de la taille, en nombre de mots de 4 octets, de la

pile de copie (espace pour la construction des structures)
Valeur minimum conseille : 20 000.
btaille

pile de restauration (ou de backtracking) Valeur minimum
conseille : 10 000.
rtaille
spcification de la taille, en nombre de mots de 4 octets, de

l'espace des rgles. Valeur minimum conseille : 80 000.
utaille
spcification de la taille, en nombre de mots de 4 octets, de

l'espace auxiliaire des algbres. Valeur minimum conseille :
200.
1006
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
mtaille

pile pour la rcupration de mmoire. Valeur minimum
conseille : 1000 .
-itaille
spcification de la taille, en octets, du dictionnaire interne

(lie au nombre de paquets de rgles). Valeur minimum
conseille : 35000 .
-etaille
spcification de la taille, en octets, du dictionnaire externe

(contenant les noms de tous les identificateurs). Valeur
minimum conseille : 32000 .
cette option supprime l'affichage des avertissements et de

tous les messages autres que les messages d'erreur.
Interruption d'un programme
Sur Macintosh, l'interruption d'un programme s'obtient :

soit en choisissant l'item Stop du menu Contrle
soit en pressant simultanment les touches Commande et ;
A la suite d'une telle interruption, Prolog III affiche le dialogue :
Les boutons ont la signification suivante :

Continue
Continuer, comme s'il n'y avait pas eu d'inter

ruption.
Kill
Avorter le programme en cours (retour au niveau

suprieur de l'interprte Prolog III).
PrologIA
1007

Trace
Bascule de la trace (activation ou dsactivation).
Quit
Abandon de la session Prolog III (retour au finder).
Il est possible de taper la premire lettre du bouton choisi au lieu de le

cliquer. Les touches ENTER et retour chariot correspondent au bouton par
dfaut Continue. Il est galement possible de taper un des chiffres de 0 3,
indiquant le niveau de trace (0 si pas de trace, 2 si on dsire la trace
ordinaire). On se rfrera la primitive trace pour plus de dtails.
Il est noter que la rcupration de mmoire n'est pas interruptible.
3 . Spcificits de Prolog III Macintosh

Valeurs extrmes des constantes arithmtiques
1. Les nombres entiers ne sont limits que par la taille de la mmoire de

votre ordinateur, et la restriction suivante : le nombre de mots de quatre
octets requis pour reprsenter l'entier en question doit tre infrieur
16 777 215 (cela fait un entier vraiment trs grand !).
2. Les nombres flottants sont implments avec le type numrique extended,
conformment la norme IEEE 754. Cod sur 80 bits, c'est un type plus
prcis que les double classiques sur 64 bits.
1008
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE

Espaces et tailles par dfaut
Espace principal
50 000 (option c )
Pile de backtracking
10 000 (option b )
Espace secondaire
10 000 (option u )
Espace du code
80 000 (option r )
Pile pour la rcupration de mmoire
1 000 (option m )
Dictionnaire interne
36 000 (option -i )
Dictionnaire externe
32 760 (option -e )
Toutes ces tailles sont exprimes en nombres de mots de quatre octets,

l'exception des deux dictionnaires o cette taille est donne en octets.
4 . A propos de l'environnement
de Prolog III sur Macintosh
Utilisation d'un diteur hte
La question de l'utilisation d'un diteur de textes plus ou moins perfectionn

ne se pose pour ainsi dire pas sur le Macintosh. Sauf la fentre console, toutes
les fentres de texte ouvertes sous Prolog III comportent un diteur de
textes avec les fonctionnalits standard : copier-coller, rechercher, etc
PrologIA
1009

La fentre console est la seule depuis laquelle on peut lancer un programme
Prolog III1 ; en contrepartie, elle ne possde pas les fonctions d'dition des
autres fentres. Comme un terminal classique, cette fentre grossit par ajout
de lignes la suite de celles dj crites. La dernire ligne de console possde
certains privilges :
la frappe de la touche retour chariot produit la lecture par Prolog III de
cette dernire ligne (sans l'ventuel prompt que Prolog aurait
pralablement affich) et l'excution de la commande que cette ligne
reprsente.
la frappe de la touche enter (sur le pav numrique) produit
- si aucun texte n'est slectionn, le mme effet que la touche retourchariot
- si un texte est slectionn, n'importe o dans la fentre console, la
recopie de ce texte sur la dernire ligne et la lecture et excution du
tout par Prolog III
Bien entendu, la dernire ligne est ditable et peut tre corrige par les
moyens habituels (souris, etc) aussi longtemps que la frappe de retourchariot n'a pas termin la lecture.
5 . Ajout de rgles prdfinies

Cette section montre comment ajouter de nouvelles rgles prdfinies
l'ensemble standard, et dcrit les procdures d'interface. Ces rgles peuvent
soit tre entirement crites en Prolog III (cela ne fait alors intervenir aucun
concept nouveau), soit faire rfrence des fonctions externes crites en C
ou tout autre langage compatible avec C.
Des procdures de
communication permettent le passage de paramtres entre les rgles Prolog
et le programme externe ; ces paramtres doivent tre de type entier, rel
La convention par dfaut adopte dans Prolog III n'est pas la mme que celle de
l'environnement MPW, o toute fentre comporte simultanment un diteur de textes et un
interprte de commandes, ce qui a la consquence d'obliger rapprendre l'emploi de
touches parmi les plus courantes, comme retour chariot et enter. Il est nanmoins
possible de se mettre en mode d'dition MPW l'aide de la commande stty .
1010
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE

ou chane de caractres. La fonction externe peut russir ou, au contraire,
provoquer un backtracking.
Le module utilisateur (fichier userrule.c, livr avec le systme Prolog III) sert
de relais entre Prolog et les routines de l'utilisateur crites en C ou dans un
autre langage compatible avec C. De cette manire il est possible d'avoir
simultanment des rgles prdfinies dans les deux langages.
Marche suivre
Quand Prolog III est lanc pour la premire fois, l'tat initial standard de la
mmoire de travail (fichier initial3.psv) est charg. Pour ajouter de nouvelles
rgles prdfinies crites dans un autre langage il convient de procder de la
faon suivante :
choisir un nombre entier spcifique, diffrent de tous ceux dj utiliss
dans ce but, pour faire le lien entre l'identificateur qui sera le nom de la
rgle dans Prolog III et celui qui sera le nom de la procdure externe
associer, dans l'univers Prolog III, ce nombre-relais et le nom de la
nouvelle rgle ; cela se fait l'aide de la primitive set_ident(nom-de-largle, numro). Ultrieurement, il faudra sauvegarder cette dclaration
dans une nouvelle version du fichier initial3.psv, qui jouera par la suite
le rle d'tat initial enrichi .
associer, dans l'univers C, le nombre-relais et l'appel de la fonction qui
constitue l'implantation effective de la nouvelle rgle. Cela se fait en
ajoutant un cas la table d'aiguillage qui se trouve dans le module
userrule.c, et en recompilant ce module.
dfinir l'implantation externe en C (ou Fortran ou tout autre langage

externe compatible) de la rgle en question, et la compiler.
Il faut enfin faire l'dition de liens entre le programme externe et les
modules objets qui constituent Prolog III, pour produire un excutable
contenant la nouvelle rgle.
PrologIA
1011

Appel d'une rgle externe
L'interface entre la forme Prolog III d'une rgle externe et son implantation
effective dans un autre langage est ralise par une fonction C, qui constitue
l'essentiel du fichier userrule.c, et qui possde l'en-tte suivant :
long UserRule(Ptr_vers_PEV, Num_ident_du_PEV)
char *Ptr_vers_PEV;
long int Num_ident_du_PEV;
Le listing du fichier userrule.c se trouve la fin de ce chapitre. Vous devez
savoir que, pour excuter une rgle externe, Prolog III appelle cette fonction
avec pour arguments les valeurs suivantes :
Ptr_vers_PEV est l'adresse du terme Prolog III correspondant
l'appel de la rgle externe (c'est--dire l'adresse du but
effacer). Il s'agit donc un arbre, dont l'tiquette est le nom de la
rgle externe et dont les fils sont les arguments de l'appel.
Num_ident_du_PEV est un nombre entier identifiant la rgle externe
en question.
UserRule(Ptr_vers_PEV, Num_ident_du_PEV)
La valeur retourne par la fonction UserRule dtermine si l'excution de la
rgle externe a russi ou chou. Si UserRule renvoie une valeur non nulle
(par exemple, la constante TRUE) alors Prolog III considre que, pour ce qui
concerne le programme externe, l'effacement a russi. Si au contraire
UserRule renvoie zro (FALSE) alors l'excution de la rgle externe est
considre comme se soldant par un chec, ce qui produira un backtracking.
L'essentiel de la fonction UserRule est constitu par une instruction

d'aiguillage (switch) portant sur la valeur Num_ident_du_PEV. Pour ajouter
une nouvelle rgle externe Prolog III, il vous suffit d'ajouter un cas cet
aiguillage, en correspondance avec le numro choisi pour reprsenter la
rgle. En gnral, pour une nouvelle rgle externe vous ajouterez les
instructions C suivantes :
d'abord, un certain nombre d'appels de la fonction GetArg, pour
obtenir des pointeurs vers les arguments de l'appel de la rgle externe
1012
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE

en correspondance avec les prcdents, un certain nombre d'appels des
fonctions Convert_MachinP_to_TrucC , pour amener aux conventions
de C le codage des valeurs des arguments
ensuite, l'appel d'une fonction C, crite par vous, qui constitue l'implantation effective de la rgle externe
au retour de cette fonction, un certain nombre d'appels de fonctions de
conversion Convert_TrucC_to_MachinP , afin de coder les rsultats
selon les conventions internes Prolog III
finalement, des appels de la fonction PutArg, pour donner ces rsultats
pour valeurs certains des arguments de la rgle d'appel.
sans oublier de prciser la valeur (vraie ou fausse) qui doit tre
retourne par la fonction UserRule titre de compte rendu (succs ou
chec) de l'excution de la rgle externe.
Vous trouverez dans les paragraphes suivants plusieurs exemples
d'implantation de rgles externes.
Procdures de transfert de donnes
Seuls des entiers, des rels et des chanes de caractres peuvent actuellement
tre changs entre un programme Prolog III et des routines externes crites
en C ou un autre langage. Deux jeux distincts de procdures de transfert de
donnes sont fournis, correspondant deux manires lgrement
diffrentes d'organiser le travail :
PrologIA
1013

un premier systme, form des procdures C :
GetArity
GetArg
PutArg
Convert_StringC_to_StringP
Convert_LongIntC_to_IntP
Convert_ExtendedC_to_NumP
Convert_DoubleC_to_NumP
Convert_StringP_to_StringC
Convert_NumP_to_ExtendedC
Convert_NumP_to_DoubleC
Convert_IntP_to_LongIntC
un deuxime systme de transfert de donnes, compatible avec celui de
Prolog II+, form des procdures C :
get_integer
get_real
get_string
put_integer
put_real
put_string
Premier protocole de transfert de donnes.

Le premier systme se compose d'un jeu de fonctions gnrales et de
fonctions de conversion. Il faut donc procder en deux temps.
Pour rcuprer une donne partir d'une structure Prolog, rcuprer
l'argument correspondant (fonction GetArg()) puis le convertir.
Pour fournir une donne une structure Prolog, convertir cette donne en
un terme Prolog puis instancier l'argument correspondant (fonction
PutArg()).
Fonctions gnrales :
long GetArity(term)
adr term;
adr GetArg(no_arg,term)
long int no_arg;
adr term;
1014
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
long PutArg(no_arg,term,value)
long int no_arg;
adr term;
adr value;
term dsigne l'adresse1 d'un terme, dont on s'intresse l'arit
(GetArity) ou un fils (GetArg, PutArg). En gnral, term
pointera l'appel de la rgle externe, obtenue travers
l'argument Ptr_vers_PEV de l'appel de UserRule. Notez
cependant que cela n'est pas obligatoire, et qu'on peut utiliser
GetArity, GetArg et mme PutArg pour manipuler des termes
autres que celui de l'appel de la rgle externe.
no_arg est un entier qui, lorsqu'il est suprieur ou gal 1,
reprsente le rang du fils du terme prcdent auquel on
s'intresse, que ce soit pour obtenir sa valeur (GetArg) ou pour
la dfinir (PutArg).
value donne l'adresse de la reprsentation interne d'un terme Prolog
III, provenant gnralement d'un appel d'une des fonctions de
conversion : Convert_StringC_to_StringP, Convert_LongIntC_to_IntP, Convert_DoubleC_to_NumP.
GetArity(term)
Retourne l'arit, ou nombre d'arguments, du terme point par term.
GetArg(no_arg, term)
Retourne un pointeur vers le terme qui est le fils de rang no_arg du terme
point par term. Il se produit une erreur si cet argument n'existe pas,
indique par le fait que la fonction retourne NULL.
En outre, GetArg(0, term) retourne un pointeur vers l'tiquette de term.
PutArg(no_arg, term, value)
Unifie le terme point par value avec le fils de rang no_arg du terme point
par term. Il se produit une erreur si un tel fils n'existe pas ou si une telle
unification n'est pas possible.
En outre,PutArg(0,term,value) unifie le terme point par value avec l'tiquette
de term.
Le type adr reprsente l' adresse la plus gnrale i.e. le type char *
PrologIA
1015
Fonctions de conversion :
adr Convert_StringC_to_StringP(buf)
char* buf;
long Convert_StringP_to_StringC(t,buf,size_buf)
adr t;
char* buf;
long int size_buf;
adr Convert_LongIntC_to_IntP(n)
long int n;
int Convert_IntP_to_LongIntC(t,i)
adr t;
long int* i;
adr Convert_DoubleC_to_NumP(f)
double f;
int Convert_NumP_to_DoubleC(t,f)
adr t;
double* f;
adr Convert_ExtendedC_to_NumP(f)
double f;
int Convert_NumP_to_ExtendedC(t,f)
adr t;
double* f;
Convert_StringC_to_StringP(buf)
Transforme la chane C (termine par zro) pointe par buf en une chane
Prolog III et retourne l'adresse du terme ainsi construit, ou NULL si la
transformation n'a pas pu tre faite.
1016
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE

Convert_StringP_to_StringC(t,buf,size_buf)
Transformation rciproque de la prcdente : t doit tre l'adresse d'un terme
Prolog III de type chane de caractres ; buf est l'adresse d'un espace ayant
pour taille au moins size_buf caractres. Cette fonction transforme la chane
Prolog pointe par t en une chane C termine par zro, range partir de
l'adresse buf. Si la taille de la chane Prolog dpasse la valeur size_buf, alors
la chane est tronque.
Convert_LongIntC_to_IntP(n)
Transforme l'entier long n en un nombre Prolog III et retourne l'adresse du
terme ainsi construit, ou NULL si la transformation n'a pas pu tre faite.
Convert_IntP_to_LongIntC(t,i)
Transformation rciproque de la prcdente ; t doit tre l'adresse d'un terme
Prolog III de type nombre (entier). Cette fonction dpose dans la variable
entire pointe par i la valeur de ce nombre. Une erreur se produit si la
transformation ne peut pas tre faite. La fonction retourne 0 (FALSE) en cas
d'erreur, une valeur non nulle (TRUE) autrement.
Convert_ExtendedC_to_NumP(f)
Convert_DoubleC_to_NumP(f)
Transforme le rel de grande prcision f en un nombre Prolog III et
retourne l'adresse du terme ainsi construit, ou NULL si la transformation n'a
pas pu tre faite.
Dans le premier cas, il s'agit du type extended (flottant sur 80 bits) associ la
bibliothque SANE ; dans le second, il s'agit du type double standard.
Puisque le C du Macintosh transforme tous les flottants en extended pour
l'valuation des expressions arithmtiques, si on ne regarde que l'efficacit
ou la prcision du programme on a intrt travailler avec des extended. Si
au contraire on tient beaucoup la portabilit, alors on prfrera le type
double.
PrologIA
1017

Convert_NumP_to_ExtendedC(t,f)
Convert_NumP_to_DoubleC(t,f)
Transformation rciproque de la prcdente ; t doit tre l'adresse d'un terme
Prolog III de type nombre. Cette fonction dpose dans la variable relle de
grande prcision pointe par f la valeur de ce nombre. Une erreur se
produit si la transformation ne peut pas tre faite. La fonction retourne 0
(FALSE) en cas d'erreur, une valeur non nulle (TRUE) autrement.
Second protocole de transfert de donnes.

Le deuxime systme offre, pour chacun des types de donnes permis
(entiers, rels, chanes), une fonction associe pour transfrer cette donne
depuis Prolog vers le programme externe, et une autre pour la transfrer
depuis le programme externe vers Prolog. Pour chaque argument de la
rgle externe (c'est--dire du but effacer), la fonction adquate doit tre
appele avec comme paramtre le rang de cet argument.
Transfert de donnes simples de Prolog vers C.
Ces fonctions sont appeles par le programme externe pour obtenir les
valeurs effectives des arguments de la rgle externe. Une fonction spcifique
est associe chaque type de donne.
Si le type de l'argument effectif n'est pas celui attendu, la fonction de
communication renvoie une erreur et force le programme backtracker.
Attention : il est alors impratif de sortir immdiatement de la fonction
externe.
Voici les fonctions disponibles pour les types simples :
get_integer(no_arg,value,err)
int no_arg;
long *value;
int *err
1018
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
get_real(no_arg,value,err)
int no_arg;
float *value;
int *err;
get_string(no_arg,value,err)
int no_arg;
char *value;
int *err;
no_arg est un entier donnant le rang de l'argument choisi dans
l'appel de la rgle externe. Le premier argument de la rgle
externe a le rang 1, le second a le rang 2 et ainsi de suite. Si la
valeur effective de no_arg ne correspond pas un argument
effectif dans la rgle externe, alors il se produit une erreur.
value est l'adresse de la variable qui est l'argument de rang no_arg
dans la rgle externe. Si son type ne correspond pas celui
requis par la fonction, un backtracking est automatiquement
gnr. Pour les paramtres de type chane de caractres, value
doit tre l'adresse d'un tableau, de taille suffisante pour
contenir la chane, dfini dans le programme externe.
err est une variable positionne 1 si une erreur s'est produite, ou si
un backtracking a t gnr. Le programme externe n'est pas
autoris rcuprer ce type d'erreur. Pour un comportement
correct du systme de gestion des erreurs, on doit
immdiatement sortir du programme externe si err est non
nulle.
Ces fonctions retournent une valeur qui est l'oppose, en tant que valeur
boolenne, de l'argument err.
get_integer(no_arg,value,err)
Vrifie que l'argument de rang no_arg est un entier (pouvant tenir dans un
int C) et le transfre dans la variable (ou la zone mmoire) dont value est
l'adresse.
PrologIA
1019

get_real(no_arg,value,err)
Vrifie que l'argument de rang no_arg est un flottant et le transfre dans la
variable (ou la zone mmoire) dont value est l'adresse.
get_string(no_arg,value,err)
Copie la chane de caractres originale (depuis la mmoire de travail de
Prolog) dans une variable (ou zone mmoire) dfinie dans le programme
externe. Un caractre nul indique la fin de la chane.
La zone d'accueil doit tre de taille suffisante pour contenir les caractres et
le caractre nul.
Transfert de donnes simples de C vers Prolog.
Ces fonctions sont appeles par le programme externe pour unifier une
valeur avec un argument de la rgle externe. Si l'unification choue, un
backtracking est automatiquement gnr par la fonction de communication. Voici les fonctions disponibles :
put_integer(no_arg,value,err)
int no_arg;
long value;
int *err
put_real(no_arg,value,err)
int no_arg;
float value;
int *err;
put_string(no_arg,value,err)
int no_arg;
char *value;
int *err;
no_arg est un entier donnant le rang de l'argument dans l'appel de la
rgle externe. Si la valeur effective de no_arg ne correspond pas
un argument effectif dans la rgle externe, alors il se produit
une erreur.
value est la valeur devant tre unifie sur l'argument de rang no_arg
dans la rgle externe.
1020
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE

Pour les paramtres de type chane de caractres, value est
l'adresse d'une chane de caractres termine par zro, dfinie
dans le programme externe. put_string copie cette chane de
caractres dans la mmoire de travail de Prolog avant d'unifier
la valeur avec l'argument de la rgle externe.
err est une variable positionne 1 si une erreur s'est produite, ou si
un backtracking a t gnr. Le programme externe n'est pas
autoris rcuprer ce type d'erreur. Pour un comportement
correct du systme de gestion des erreurs, on doit
immdiatement sortir du programme externe si err est non
nulle.
put_integer(no_arg,value,err)
Unifie l'argument de rang no_arg avec l'entier contenu dans value.
put_real(no_arg,value,err)
Unifie l'argument de rang no_arg avec le flottant contenu dans value.
put_string(no_arg,value,err)
Copie la chane de caractres pointe par value dans la mmoire de travail
de Prolog et l'unifie avec l'argument de rang no_arg .
Noter qu'un caractre nul doit indiquer la fin de la chane originale.
Ces trois fonctions retournent une valeur qui est l'oppose, en tant que
valeur boolenne, de l'argument err. Ainsi, on peut considrer que la
fonction est value TRUE lorsqu'il n'y a pas eu d'erreur, FALSE
lorsqu'une erreur s'est produite. Cela rend quivalentes les deux formes
d'appel suivantes :
...
put_integer(n,v,err);
if (*err)
return;
...
et
...
if ( ! put_integer(n,v,err))
return;
...
PrologIA
1021

Un exemple complet
Voici un exemple complet, dcrivant l'ensemble des oprations excuter

pour crer une nouvelle rgle prdfinie implante par un programme
externe.
Supposons que vous programmiez en C et que vous vouliez ajouter la rgle
prdfinie roots(a, b, c, x, y) qui calcule les deux racines relles x et y de
l'quation : ax2 + bx + c = 0 si elles existent et qui provoque un backtracking
sinon.
S'agissant du Macintosh, vous devez possder l'atelier de programmation
MPW. Nous supposerons que c'est le cas, et que vous connaissez le mode
d'emploi de ce logiciel. Etape par tape, la marche suivre est la suivante :
1. Crer le fichier myproc.c suivant :
#include "macuser.h"
#include <SANE.h>
real_roots(a, b, c, x, y)
extended a, b, c, *x, *y;
{
extended d;
if (a == 0 || (d = b * b - 4 * a * c) < 0)
return 0;
else
{
*x = (-b + sqrt(d)) / (2 * a);
*y = -b / a - *x;
return 1;
}
}
2. Compiler le fichier myproc.c :

C
-s
_MYSEGT_
myproc.c
3. Modifier la fonction UserRule du fichier user_rule.c en ajoutant l'appel du

nouveau programme externe. Par exemple, en donnant le numro 504 la
nouvelle rgle :
long int UserRule(Ptr_vers_PEV, Num_ident_du_PEV)
adr Ptr_vers_PEV;
1022
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
{
...
switch (Num_ident_du_PEV)
{
...
case 504:
{
adr t;
extended a, b, c, x, y;
return ( ! ((t = GetArg(1, Ptr_vers_PEV))
&& Convert_NumP_to_ExtendedC(t, &a)
&& (t = GetArg(2, Ptr_vers_PEV))
&& Convert_NumP_to_ExtendedC(t, &b)
&& (t = GetArg(3, Ptr_vers_PEV))
&& Convert_NumP_to_ExtendedC(t, &c)
&& real_roots(a, b, c, &x, &y)
&& (t = Convert_ExtendedC_to_NumP(x))
&& PutArg(4, Ptr_vers_PEV, t)
&& (t = Convert_ExtendedC_to_NumP(y))
&& PutArg(5, Ptr_vers_PEV, t)))
? FALSE : TRUE;
}
...
}
}
4. Modifier la commande Link dans le fichier prolink3 pour tenir compte du

nouveau fichier (faites attention ne pas laisser de blanc aprs le caractre
) :
...
Link -p -d -c 'PRO4' -t APPL -o 'Prolog III'.new
-b -sn edit=Main
myproc.c.o
prolog3.o userRule.c.o promain.c.o
{Libraries}RunTime.o {Libraries}interface.o
{CLibraries}CRuntime.o {CLibraries}StdCLib.o
{CLibraries}CInterface.o {CLibraries}Math.o
{CLibraries}CSANELib.o
Setfile -a B 'Prolog III'.new
...
5. Refaire la compilation de userrule.c et l'dition de liens de Prolog III :

make -f prolink3 > tmp ; tmp
6. Lancer une session Prolog III utilisant le nouvel excutable et l'ancien tat
initial, dfinir le nom de la nouvelle primitive et l'ajouter la partie ferme
de la famille "sys" :
PrologIA
1023

PROLOG III, v1.2 Decembre 1990 (C) PrologIA 1989-90
> set_ident(sys:roots, 5 0 4 ) ;
{}
> add_implicit("sys","roots");
{}
>
7. Essayer la nouvelle rgle :

> roots(1,-5,6,x,y);
{x=2, y=3}
> roots(1,4,8,x,y);
>
8. Sortir de Prolog III en sauvant l'tat courant. Celui-ci devient l'tat initial
pour les futures sessions Prolog III :
> exit("initial3.psv");
1024
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
6. Appeler Prolog III depuis le langage C

Introduction
Appeler Prolog III depuis C se fait de faon simple puisque trois fonctions C
autorisent ce mcanisme.
De par la ncessit dallouer et dinitialiser ses propres donns, Prolog III ne
pourra tre appel quune fois la fonction Pro3Initial excute. Les appels
Prolog III se font ensuite par lusage de la fonction gnrique Pro3Goal, qui
envoie Prolog III une commande sous la forme dune chane de caractres.
Dans le cas o on n'aurait plus besoin de Prolog III dans la suite de
lexcution, la fonction Pro3Final peut tre appele; celle-ci permet
notamment de rcuprer la place mmoire occupe par la session Prolog III.
On ne pourra plus partir de ce moment-l appeler Prolog III moins de
recommencer le processus en utilisant nouveau Pro3Initial, etc.
Description des fonctions
Initialisation
int Pro3Initial(argc, argv, autoprolog)

int argc, autoprolog;
char *argv[];
argc, argv ont la mme smantique que les arguments de la fonction
main() de tout programme C. Ils servent passer des options
Prolog III. Dans le cas o on ne souhaite pas utiliser cette
facilit, on peut passer 0 pour argc et N U L L pour argv.
Rappelons que, lorsquil existe un fichier nomm prolog3.prf
dans le rpertoire courant (ou dans celui contenu dans la
variable denvironnement PrologDir3 (si elle est dfinie)), sa
premire ligne est interprt comme une ligne de commande
unix et les options y sont lues. Dans ce cas, les arguments argc et
argv sont ignors.
PrologIA
1025

autoprolog informe Prolog III quil est le programme principal ou
quil est seulement appel de temps autre. Les valeurs
possibles donner sont :
PROMAIN
si Prolog III est le programme principal
PROCALL
externe
si Prolog III est utilis comme module
Pro3Initial(argc, argv, autoprolog)

Cette fonction alloue puis initialise Prolog III. Cette initialisation comprend le
dmarrage de Prolog III . Il peut se passer un assez long moment avant quil
ne rende la main (selon la taille de ltat quil doit charger).
Cette fonction retourne un statut derreur, lequel est ERR3_NOERR lorsqu'il
ny a pas derreur et que Prolog III a pu allouer, charger, initialiser son
espace, dmarrer, .
Toutes les constantes PROMAIN, PROCALL, ERR3_NOERR, etc, sont dfinies
dans le fichier dentte macuser.h quil faut donc inclure.
Appel
int Pro3Goal(g)
char *g;
Pro3Goal(g)
On appelle Prolog III travers cette unique fonction. Son argument g est une
chane de caractres C (termine par '\0') qui contient une requte
Prolog III. On notera quavec cette version le passage de donnes ne se fait
que de C vers Prolog III, celui-ci donnant ses rsultats sur la sortie courante
de Prolog III (laquelle peut-tre modifie).
Cette fonction retourne galement un statut derreur. Quand il ny a pas eu
derreur, ERR3_NOERR est retourn. Sinon est retourn :
un nombre positif correspondant une erreur pendant lexcution de
Prolog III.
ERR3_NOINI
1026
Si Prolog III nest pas initialis.
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
ERR3_ERRANA
Sil y a une faute de syntaxe dans la commande.
Par exemple, lappel :

err = Pro3Goal("enum(x), {0<x<4};");
produira lexcution les affichages suivants :
{x = 1}
{x = 2}
{x = 3}
et la variable err vaudra ERR3_NOERR.
Terminaison
int Pro3Final()
Pro3Final()
Rcupre les espaces allous par Prolog III. Lappel de cette fonction ne se
justifie gure que pour rcuprer une importante place mmoire. Cest ici
galement que les fichiers ouverts par Prolog III sont ferms. Les retours
possibles de cette fonction sont les deux statuts derreur suivants :
ERR3_NOERR
pas derreurs
ERR3_NOINI
Prolog III ntait pas initialis
Un petit exemple
Voici comme illustration un petit exemple rsumant ce qui a t dit plus

haut. Dans cet exemple, Prolog III est suppos tre utilis intensment en
deux endroits du programme, et on souhaite rcuprer lespace Prolog III
entre les deux.
/* fichier monprog.c */
main()
{
int err;
...travail....
PrologIA
1027

err
Pro3Initial(0,
NULL,
Aociation
PROCALL);
if ( err != ERR3_NOERR ) {
printf("Pas
pu
initialiser
Prolog
III\n");
exit(1);
}
...travail....
err
Pro3Goal("out(c),
{c=1/2};");
...travail....
err
Pro3Goal("out(c)
line,
{c=1/4};");
...travail....
Pro3Final();
...travail....
...travail....
...travail....
err
Pro3Initial(0,
NULL,
PROCALL);
if ( err != ERR3_NOERR ) {
printf("Impossible
d'initialiser
Prolog\n");
exit(1);
}
...travail....
err
Pro3Goal("out(c),
{c=1};");
...travail....
err
Pro3Goal("outl(c)
fail,
{c=2};");
...travail....
Pro3Final();
...travail....
}
En supposant que les lignes ...travail.... sont vides, compilons ce fichier en le

liant Prolog III. On va produire lexcutable nomm monprog :
c
-o
monprog.c.o
monprog.c
Il faut pour l'dition de lien modifier le fichier prolink3 en remplaant

promain.c.o par monProg.c.o et en renommant aprs le link le fichier
'Prolog III'.new en monProg :
...
Link -p -d -c 'PRO4' -t APPL -o 'Prolog III'.new
-b -sn edit=Main
monProg.c.o
prolog3.o userRule.c.o
{Libraries}RunTime.o {Libraries}interface.o
{CLibraries}CRuntime.o {CLibraries}StdCLib.o
{CLibraries}CInterface.o {CLibraries}Math.o
1028
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
{CLibraries}CSANELib.o
Setfile -a B 'Prolog III'.new
Move 'Prolog III'.new
monProg
...
On refait la compilation de userrule.c et l'dition de liens de monProg :

make -f prolink3 > tmp ; tmp
Lanons-le et voyons les rsultats affichs dans la console :

1/2{c = 1/2}
1/4
{c = 1/4}

1{c = 1}
2
Listings
Fichier macuser.h :
#include <stdio.h>
#define TRUE 1
#define FALSE 0
#define
#define
#define
#define
#define
ERR3_NOERR
ERR3_NOINI
ERR3_ERRANA
ERR3_DEJAINI
ERR3_ABANDON
0
-2
-3
-4
-5
#define PROMAIN 1
#define PROCALL 0
typedef char* adr;
extern FILE *entree, *sortie, *sorerr;
extern adr
GetArg(/* long int n, adr t */),
Convert_StringC_to_StringP(/* char* buf */),
PrologIA
1029

Convert_LongIntC_to_IntP(/* long int n */),
Convert_DoubleC_to_NumP(/* double d */);
extern long int
GetArity(/* adr terme */) ,
PutArg(/* long int n, adr T, adr t */),
Convert_StringP_to_StringC(/*adr t, char* buf,
long int size_buf */),
Convert_NumP_to_DoubleC(/* adr t, double *f */),
Convert_IntP_to_LongIntC(/* adr t, long int* i */);
int Pro3Initial(/* int argc, char** argv, int autoprolog */);
int Pro3Goal(/* char *g */);
int Pro3Final();
#ifdef mpw
extern adr
Convert_ExtendedC_to_NumP(/* extended d */);
long int
Convert_NumP_to_ExtendedC(/* adr t, extended *f */);
#endif
1030
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Fichier userrule.c :
extern adr TheCurrentPev;
long int UserRule(Ptr_vers_PEV, Num_ident_du_PEV)
adr Ptr_vers_PEV;
{
int err = 0, err_nb = 0;
TheCurrentPev = Ptr_vers_PEV;
switch (Num_ident_du_PEV)
{
/* Utilisez des numeros */

/* superieurs a 500
*/
/* inserez ici vos propres regles */

default:
ProPrintf(sorerr,
"User Rule (%ld) Not Defined.\n",
Num_ident_du_PEV);
return FALSE;
}
}
PrologIA
1031
1032
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
Index Gnral
HERITAGE
Index
! (coupure) 164
appels externes Prolog III 1025
, 418
-> 417
"apple" 497
arbres 20; 70
arbres factuels 71
/ (coupure) 164
< 411
<> (tuple vide) 27
= 412
arbres infinis 75
=.. 410
=:= 415
=< 411
arg3 80; 205
arg 81; 203

arg2 84; 204
== 413
arithmtique 14
assert 186; 206; 378
assert'' 187; 208
=\= 416
> 411
>= 411
asserta 186; 207; 380

assertz 187; 208; 378
assign 173; 174; 209
[ ] (liste vide) 33
[ ] (symbole fonctionnel) 83
[] 420
\== 414
atan 172; 370

atom 381
atomic 382
A
abandon de l'excution
(block_exit) 166
abolish 377
abs 172; 369
activate_button 515
add 170; 368
add_implicit 183; 202
add_stdmenu 497
addition 30; 98
affectation 47
affectation (assign) 173
affectation boolenne 125
ajout d'une rgle (assert) 186
d'un
but

block 166; 212
block_exit 166; 212
bote cocher 500
bool 129; 214
boolens 16; 118
syntaxe 428
bouclage 162
bound 149; 167; 215
bound_conc 80; 216
bound_mult 105; 156; 217
bound_size 80; 151; 218
bound_tree 219
bound_tree' 220
PrologIA
1033
Index Gnral
Aociation
de tuples 72
bouton 485; 501

buts 60
syntaxe 440
gnral darbres 72
consult 385
contexte courant 179
contexte de lecture-criture 24; 179
contraintes 54; 438
boolennes 16; 120
call 383
exemples 122
caractres 25
caractre dchappement (\) 430
forme normale 123

simplification 127
caractre dsign 430
contrainte de taille 76
espace 428
remarques 441
numriques 101
exemples 101
forme normale 102
syntaxe 431
retardes 156
chanes de caractres 13; 27; 71; 85
retardes 151
syntaxe 439
syntaxe 431
changement de signe 30
char 221
contraintes de type
char_code 222
chargement d'un programme (input) 8
check_item 496
!bool 53; 120

!boolt 53; 120
clause 384
clear_menubar 497
clear_window 472
!chart 53
!id 53
!idt 53
clic 480; 486; 490; 491; 504; 510

close_context_dictionary 183; 223
!num 53; 100

!numt 53; 100
close_input 9; 195; 224

close_output 11; 197; 225
command_menu 496
commentaire 442; 459
conc3 80; 154; 226
conc_string 85; 227
concatnation 12; 76
retarde 154
configuration de Prolog III 1006
connu (terme) 148
console 6; 464; 1009
constantes 23
boolennes 119
numriques 97
syntaxe 428
constructeur
darbres 72
1034
Prolog
HERITAGE
!char 53
!tuple 53
"control" 497
contrle 162
Convert_DoubleC_to_NumP 1014; 1017
Convert_ExtendedC_to_NumP 1014; 1017
Convert_IntP_to_LongIntC 1014; 1017
Convert_LongIntC_to_IntP 1014; 1017
Convert_NumP_to_DoubleC 1014; 1018
Convert_NumP_to_ExtendedC 1014; 1018
Convert_StringC_to_StringP 1014; 1016
Convert_StringP_to_StringC 1014; 1017
cos 172; 370
coupure 164
cpu_time 198; 228
crayon 474; 481; 482
create_button 515
create_window 471
PrologIA
Aociation
Prolog
Index Gnral
HERITAGE
current_context 182; 229
espace principal (taille) 1009
current_predicate 187; 230

cut 231
espace secondaire (taille) 1009

cut (coupure) 164

et 29; 119
excution d'un programme 64
exemples
arbres 71
caractres 40
def_array 174; 232

default 167; 234
dfinition de contexte (set_context) 180
chanes 41
constructeurs 73
dialogue de saisie de nom de fichier 516

contraintes 56
dictionary 184; 235

dictionnaire externe (taille) 1009
contraintes sur les arbres 74
dictionnaire interne (taille) 1009

dif 237
contraintes sur les chanes 85

contraintes sur les tuples 78
"DISTANCE" 468
entiers 39
expressions boolennes 43; 120
expressions numriques 42; 99
div 106; 171; 238; 368

division 31; 98
dot 239
flottants 40
freeze 149
identificateurs 38
listes 84
echo 197; 240; 341

edinburgh 241
modules 186
rgles 61
requtes 61
edinburg.mo 1004
"EDIT" 467
"edit" 497
edit 242
diteur de textes hte 1009
galit 50
enable_menu 496
end_module 185; 243
ensemble de contraintes
boolennes 122
enter 1010
entre-sorties 192
entree.log 1006
enum 104; 244
epsilon_float 342
eq 246
eql 171; 369
escape 431
espace du code (taille) 1009
termes 38; 45
utilisation de la coupure (/) 164
exemples de programmes
additionneur binaire 135
au plus un vrai 131
calcul bancaire 108
calcul des feuilles 87
ChatsOiseaux 15
communications Prolog III/C 1022
crible d'Eratosthne 90
element_de 13
K lments vrais 133
naive reverse 82
puzzle logique 143
quick sort 87
remplissage d'un rectangle 110
RepasLeger 9
SEND + MORE = MONEY 109
suite priodique 89
PrologIA
1035
Index Gnral
un ou sur 2 variables 129
Aociation
forme normale
un ou sur une liste 130

exit 198; 247
exp 172; 370
forme normale conjonctive 123
expressions
formfeed 431
free 149; 168; 252
boolennes 43; 119; 437

numriques 42; 97; 436
maximum 105
minimum 105
prdicat val 168
free_label 253
freeze 157; 254
front_window 466
functor 386
fail 249
faits vrais 62
famille 178
gcd 256
get 387
partie ferme 178
get0 388
Fdecimal 108
feuille 21
get_config 257
get_integer 1014; 1018; 1019
Fexact 108
Ffloat 108
"file" 497
get_key 487
get_real 1014; 1019; 1020
get_screen 466
file_window 466
get_string 1014; 1019; 1020
fin de session (quit) 11

"find" 497
find_pattern 85; 251
get_window 466
GetArg 1014; 1015
GetArity 1014; 1015
findall 250
Fint+fract 108
Fnormal 108
fonctions externes C 1010
fonctions valuables 170
"FONT" 469; 471
fonte 472; 482; 483; 484
"FONTSIZE" 468; 471
format_decimal 342
format_float 342
format_out_num 108; 341
Fdecimal 341
getenv 259
gr_arc 476
gr_arc' 477
gr_button_hit 486
gr_choosecolor 482
gr_click 479; 480
gr_color 481
gr_color2 481
gr_color3 481
gr_dialog 498
gr_draw_buttons 485
gr_editf 486
Fexact 341
Ffloat 341
Fint+fract 341
Fnormal 341
formats d'entre-sorties 108
forme clausale 124
1036
Prolog
HERITAGE
gr_erase 474
gr_font 484
gr_getmouse 480
gr_icon 478
gr_line 474
gr_lineto 474
PrologIA
Aociation
Prolog
Index Gnral
HERITAGE
gr_list 489
infrieur ou gal 101
gr_load 516
gr_mode 482
infrieur strict 101

initial3.psv 1004
gr_move 474
inl 270
gr_moveto 474
input 8; 194; 271; 516

input_is 272
gr_pen 482
gr_penloc 474
gr_polygon 476
gr_popupItem 491
gr_print 492
gr_rect 475
gr_setorigin 474
gr_stringwidth 482
gr_text 483
gr_window 472
gr_window_is 472
insert 188; 189; 273

installation 1002
installation de Prolog III 1002
integer 106; 275
interruption 167; 1008
d'un programme 1007
is 389
is_bool 129; 276
is_char 277
"GRAPHICS" 467
is_ident 278
is_leaf 279
groupe 500
gtty 489
is_num 106; 280

is_tuple 81; 281
is_univ 282
item coch 494
I
ident 260
identificateurs 24; 433; 444
abrgs 177
syntaxe 177; 434; 444
complets 177
sparateur 177
syntaxe 177; 434; 444
if 172; 369
implique (opration) 29; 119
implique (relation) 52; 120
in_char 193; 261
in_char' 262
in_ident 263
in_integer 264
in_real 265
in_sentence 194; 266
in_sentence' 267
in_string 268
in_term 269
ingalit 50; 101
inquations numriques 104
inf 171; 369
infe 171; 369
J
jeu de caractres 427
K
kill_button 515
kill_module 12; 191; 283
kill_window 472
kit de distribution 1002
known 148; 284
known_part 81; 152; 285
L
lcm 286
line 197; 287
linefeed 431
list 7; 9; 11; 189; 288
list_string 86; 293
list_tuple 84; 294
PrologIA
1037
Index Gnral
Aociation
liste vide 84
newline 431
syntaxe 429
listes 33; 83
next_char 301
next_char' 302
listing 390
nil 33
littral 124
nl 393
ln 172; 370
load_graphic 464
"NLINES" 468
no_echo 197; 303
no_trace 304
nombres 14
entiers 26
syntaxe 428
MacDraw 516
flottants 26; 94
machine Prolog III 65; 162

MacPaint 516
syntaxe 429
fractionnaires 94
max_value 105; 295

maximum d'une expression numrique 105
member 391
menu fugitif 493
rationnels 94
non 29; 119
non (prdicat) 166
nonvar 394

menu pop-up 493
min_value 105; 296
not 305
minimum d'une expression numrique 105
num 106; 306

number 395
numden 307
mod 106; 171; 297; 369

"MODAL" 467
modifications de la taille des piles 1006

module 24; 178; 298
objet 186
omission de l'oprateur de multiplication

99
source 185
utilisateur 1011
module(directive) 185
modules
exemples 186
moins unaire 98
motif 482
"MPW" 489
mul 170; 368
mult 105; 157; 158; 299
multiplication 31; 98
N
naive_reverse 82
name 392
new 300
new_window 467
1038
Prolog
HERITAGE
op 396
oprateurs 445
boolens
quivalent 119
et 119
implique 119
non 119
ou 119
Edimbourg 459
numriques 98
oprations 28
arithmtiques 30; 98
boolennes 29
concatnation de tuples 32; 76
construction d'arbre 31; 71
construction de tuple 32; 71
construction gnrale d'arbre 32; 71
PrologIA
Aociation
Prolog
Index Gnral
HERITAGE
:userItem 503
ou 29; 119
out 195; 308
outc 196; 309
:vfill 504
parasite 164
outl 195; 310
particular_value 105; 315
outm 196; 311
partie ferme d'une famille 179
outml 7; 196; 312

output 11; 197; 313; 516
pgcd 316
pile de backtracking (taille) 1009
output_is 314
pile pour la rcupration de mmoire

(taille) 1009
pixels 466; 471; 474; 482; 504; 511

plus unaire 98
paire pointe 33; 83
paramtres graphiques
:button 501
ppcm 317
prcision parfaite 26; 94
:button2 501
predefined 190; 318
:buttonD 502
:cb 500
:ccol 504
prfixe 24
syntaxe 177; 434; 444
:clipRect 476
:col 504
:crow 504
primitives
boolens 128
conversions de chanes 86
numrique 104
:editf 501
:erase 475; 476; 477
:eraseOval 475
:eraseRect 475
tuples 80
:eraseRoundRect 475
:frame 475; 476
:frameOval 475
:frameRect 475
:frameRoundRect 475
print_window 472
priorits
des oprateurs boolens 119
:glist 502
:group 505
:hfill 505
:invert 475; 476; 477
:invertOval 475
:invertRect 475
:paint 475; 476; 477
:paintOval 475
:paintRect 475
:paintRoundRect 475
:rb 500
:rb1 501
:row 504
:text 500
des oprateurs numriques 98

Pro3Final 1025; 1027
Pro3Goal 1025; 1026
Pro3Initial 1025
projection sur un sous-vocabulaire 127
prolog3.bst 1003
prolog3.era 1003
prolog3.erf 1004
prolog3.err 1004
prolog3.lex 1003
prolog3.prf 1004
prolog3.sya 1003
prolog3.syf 1003
prolog3.syn 1003
prologIII 319
protocole de transfert de donnes 1014;
1018
put 397
PrologIA
1039
Index Gnral
Aociation
put_integer 1014; 1020; 1021
repeat 329
put_real 1014; 1020; 1021

put_string 1014; 1020; 1021
rpertoire exemples 1004

requtes 61
syntaxe 440; 456
PutArg 1014; 1015
reset_cpu_time 198; 330
reset_window 472
qualifieur 24
rsolution des systmes de contraintes 57

restore_menubar 497
quit 8; 198; 320; 1008
restrictions
concatnation 77
linarit 102
nombres entiers 102

taille 76
raccourci 496
resume_trace 331
retardements
rad 172; 370

radio-bouton 500
concatnation 154
contraintes non-linaires 106
rafrachissement de la fentre graphique

473
rational 106; 322
read 398

freeze 149
real 106; 323

rcapitulatif
oprations et relations boolennes 123
oprations et relations dfinies sur les
arbres et les tuples 79
redef_array 324
rgles 60
prdfinies
ajout de nouvelles 1010
boolens 128
numrique 104
tuples 80
syntaxe 440; 456
reinsert 188; 189; 325
relations 49
boolennes 120
de type 53
galit 50
implication 52; 120
ingalit 50
nombre de fils 74
numriques 100
unaires 53
reload 191; 327
remove_implicit 183; 328
1040
Prolog
HERITAGE
tailles 151
retour chariot 486; 490; 502; 511; 1008; 1010
retract 190; 332; 399
retractall 400
return 431
rubout 431
rule 190; 333
rule_nb 336
S
sauvegarde d'un module 11
sauvegarde de modules (save) 192
"SAVE" 468; 470
save 192; 337
save_menubar 497
save_window 469
see 401
seen 402
smantique 62
dclarative 62
des termes 46
oprationnelle 62
sparateur 177
set_config 108; 340
echo 341
PrologIA
Aociation
Prolog
Index Gnral
HERITAGE
epsilon_float 342
suprieur ou gal 101
format_decimal 342
format_float 342
suprieur strict 101

suppress 10; 15; 191; 357
format_out_num 341
suppression
statistics 342
de messages 1007
syntax 342
trace 340
de rgles (suppress) 10; 191

suspend_trace 360
tty_wrap 342
symboles relationnels
undefined_rule 343
set_context 180; 182; 345
boolens 120
numriques 100
syntax 342
set_ident 346; 1011

set_menu 493
set_window 470
Edinburgh 342
Prolog III 342
syntaxes
sfgetfile 516; 517

sfputfile 517; 518
choix du mode syntaxique 424

syntaxe de base 424
"SHAPE" 468
syntaxe Edimbourg 425
si_alors_sinon 166
simplification
sys_command 361
systmes de contraintes 54

sin 172; 370
size 80; 152; 347
solution d'un systme de contraintes 57
boolennes 126
sortie.log 1006
souris 480
soustraction 31; 98
split 81; 348
sqrt 173; 370
srcBic 483
srcCopy 483
srcOr 483
srcXor 483
state 349
string 87; 350
string_bool 86; 351
string_ident 86; 352
string_integer 86; 354
string_real 86; 355
stty 488
style 482; 483; 497
style_menu 497
sub 170; 368
substring 86; 356
sup 171; 369
supe 172; 369
syntaxe 438; 454
T
tab 403
tableaux (def_array) 174
tabulation 431; 486; 490; 504; 511
tailles 76
retardes 151
tan 173; 370
tell 404
termes 35
connus 148
sans variable 37
syntaxe 435; 447; 450
tte de rgle 60
told 405
trace 340; 362; 1008
trace_file 363
true 406
trunc 106; 172; 364; 369
"TTY" 467; 489
tty_wrap 342
tuple 81; 365
PrologIA
1041
Index Gnral
Aociation
tuples 12; 22; 71; 76
"window" 497
undef_array 366
undefined_rule 343
error 343
write 408
writeq 409
fail 343
warning 343
units d'entre/sortie 192
user_item 510
userItem 510
UserRule 1012; 1015; 1022
userrule.c 1011
V
val 169; 367
abs 369
add 368
atan 370
cos 370
div 368
eql 369
exp 370
if 369
inf 369
infe 369
ln 370
mod 369
mul 368
rad 370
sin 370
sqrt 370
sub 368
sup 369
supe 369
tan 370
trunc 369
valeurs boolennes 25
var 407
variables 34
d'carts 104
syntaxe 433; 443
1042
Prolog
HERITAGE
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Prolog III
Version 1.3
Manuel de mise au point
Dcembre 1991
PrologIA
Aociation
Prolog
HERITAGE
limitation.
Droits d'auteur
Dcembre 1991
PrologIA
Aociation
Prolog
HERITAGE
Dbuggeur et mise au point de

programmes Prolog III
1.
2.
2.
3.
4.
5.
6.
Introduction et conseils
Trace d'excution
Aperu du modle des boites
Des exemples
Rgles prdfinies de mise au point
Mise au point avance
Dtection d'appels non-dfinis
Le propre de tout programme est de pouvoir tre faux. Aucun langage de

programmation ne permet en effet de rentrer en machine l'algorithme que l'on a en
tte sans laisser la porte ouverte aux erreurs, qu'elles soient conceptuelles ou bien
de simples fautes de frappe. Ce chapitre dcrit les outils de mise au point mis la
disposition des programmeurs. On verra galement que ces outils permettent plus
que la simple correction d'erreur puisque le suivi d'excution d'un programme
permet d'amliorer, voire de saisir le comportement de l'algorithme programm.
Novembre 1991
PrologIA
Outils de mise au point
1 . Introduction
Les fautes qui ne provoquent pas d'erreur de syntaxe peuvent-tre classes
dans deux catgories :
Celles qui sont dtectables statiquement, c'est a dire en
examinant l'ensemble des rgles courantes que le programme est
susceptible d'utiliser. Le cas le plus frquent est l'appel une rgle
non-dfinie. On utilisera l'outil XRef pour vrifier qu'un
programme ne contient pas un moment donn, de tels appels.
Celles qui ncessitent l'excution du programme
Le couple (identificateur, arit) identifie un paquet de rgles
Faute de frappe dans un identificateur, faute d'inattention lorsqu'on appelle
une rgle forme d'un ident
Une des premires sources d'erreur est l'appel de rgles non-dfinies (ou, du
moins, pas encore dfinies au moment de l'appel dans le cas ou on utilise
l'insertion dynamique de rgles par les primitives assert, insert, reload). Ici,
non-dfinies dsigne aussi bien un 'bon' identificateur et une mauvaise arit.
Il faut se mettre en mode undefined_rule = warning ou error.
2002
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
2 . Trace dexcution
Le mode trace est un mode d'excution permettant de visualiser le
droulement d'un programme Prolog III. On peut entrer et sortir de ce
mode dynamiquement par des appels des prdicats spcifiques1. Il est
galement possible de modifier les options de traage en interrompant
l'excution en cours, en changeant les options en question, puis en
poursuivant l'excution du programme.
Ce traage consiste essentiellement en une suite d'impressions, sur la sortie
courante de trace, des contraintes d'galit entre buts et tte de rgles avant
unification et de visualisation des points de backtracking. Ce listing contient
des lignes de la forme :
but = tete_de_regle_a_essayer1
<<<<<<
but = tete_de_regle_a_essayer2
autre_but = autre_regle
%
%
%
%
%
indique une tentative

c'est un chec
une autre tentative
l'effacement du but
prcdent est un succs
La prcision de la trace est paramtrable : on peut se placer dans un des trois

modes d'impression des buts, selon la quantit d'information que l'on
souhaite voir dfiler l'cran.
mode 1 :
mode 2 :
mode 3 :
impression des noms des prdicats appels, sans leurs

ventuels arguments.
impression des appels avec arguments.
impression des appels avec arguments et des contraintes
portant sur les variables figurant dans le but et/ou la
tte de rgle essayer.
Dans tous les cas, cette trace n'est pas interactive et ne permet qu'un suivi
difficile de l'excution d'un programme en raison notamment de la grande
quantit d'informations affiche. Trs souvent, on souhaite ne voir qu'une
1 Voir trace, no_trace, suspend_trace, resume_trace, set_config, etc....
PrologIA
2003
Aociation
ou quelques portions restreintes de l'excution. Bien qu'il soit possible

d'utiliser les prdicats spcifiques 1 en des endroits stratgiques du
programme, ceci ne peut se faire qu'on prix d'une rinsertion des rgles
modifies et reste donc lourd d'emploi. Pour ces raisons, le dbuggeur est
prfr au simple traage. Son interactivit permet de dterminer avec
prcision l'endroit ou l'on se trouve, de parcourir la dmonstration en
cours, d'imprimer des informations pertinentes, d'viter les impressions
superflues, de reprendre ou modifier l'excution d'une section de
programme, et bien d'autres choses encore.
3 . Aperu du modle des boites

Le dbuggeur Prolog III est bas sur le modle des boites que l'on trouve
dans la plupart des dbuggeurs Prolog plus classiques. Le concept important
de ce modle est que chaque appel peut tre considr comme une boite,
opaque ou transparente selon le dsir de l'utilisateur d'avoir une trace
d'excution plus ou moins dtaille. Les boites de ce modle comportent en
gnral 4 ouvertures, appeles portes, mais un nombre de portes plus lev
est accessible l'utilisateur Prolog III et sont dcrites plus loin.
CALL
EXIT
FAIL
REDO
fig 1. Une boite opaque et ses quatre portes.
Ces portes correspondent des endroits prcis de l'excution d'un but. Elles
schmatisent :
l'activation d'un paquet de rgles (CALL),
la terminaison correcte d'une des rgles du paquet (EXIT),
le retour au sein de ce paquet par backtracking (REDO),
la dsactivation de ce paquet par puisement de ses choix (FAIL).
2004
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Voici un exemple d'excution, dans lequel ce qui est en gras doit tre tap
par le programmeur. On insre deux petites rgles, puis on se place en mode
dbug et on lance le but toto(x); . Le dbuggeur attend une rponse la fin de
chacune des lignes affichant le prompt (DBG) . On se contentera pour
l'instant de taper la lettre s signifiant step (on avance pas--pas) :
> toto(10) ->;

> toto(11) ->;
> debug;
{}
> toto(x);
1[1]CALL
: toto(x) (DBG) s
1[1]EXIT(r1): toto(10) (DBG) s
0[0]EXIT(r1): $query$ (DBG) s
{x=10}
0[0]REDO(r1): $query$ (DBG) s
1[1]REDO(r1): toto(x) (DBG) s
1[1]EXIT(r2*): toto(11) (DBG) s
{x=11}
>
fig 2.
Dans le cas d'un appel une rgle prdfinie on obtient la squence :
> debug;
{}
> line;
1[1]CALL
: line (DBG) s
1[1]EXIT(rC): line (DBG) s

{}
>
fig 3.
PrologIA
2005
Aociation
Revenons la figure 1. On constate que la plupart des lignes sont construites

selon un mme schma. Voici la dnomination puis l'explication des
diffrents champs de ce schma :
4[5]EXIT(r2):unbut(a1,a2) (dbg)
Numro de la
rgle utilise
But appel
Prompt
Nom de la porte
Niveau de l'appel
Profondeur de l'appel
Quelques dfinitions
Nom de la porte :
C'est une des chanes CALL, RULE, {ok}, {no}, EXIT, REDO, FAIL .
Profondeur d'un appel (numro de boite) :
C'est le numro d'ordre de cet appel dans la branche courante de la
dmonstration. On peut dire que la profondeur d'un appel est son niveau
dans l'arbre ET de la dmonstration courante. La profondeur d'appel du
premier but de la question1 est 1. Ce numro augmente en gnral d'une
unit d'un appel au suivant, mais l'effacement de prdicats prdfinis peut
donner lieu des variations suprieures l'unit. Ce numro est trs
important car il sert identifier les boites vivantes de faon unique. On se
rappellera que chaque boite correspond un appel.
Profondeur de la dmonstration :
C'est la profondeur de l'appel courant. Ce nombre augmente quand un
appel est excut avec succs, et diminue lorsque l'appel choue.
Niveau d'un appel :
1 A moins que des contraintes retardes ne figurent dans la requte.
2006
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Le niveau d'un appel correspond au niveau d'imbrication des boites et

vrifie donc les deux conditions :
Tous les buts de la question sont au niveau 1.
Tous les sous-buts immdiats d'un corps de rgle sont au mme niveau,
lequel est suprieur d'une unit au niveau de l'appel de cette rgle.
4 . Les commandes du dbuggeur
1. Le langage de commande
Voici en quelques points la description du langage de commande du
dbuggeur Prolog III :
Une commande est une suite de un ou plusieurs mots, termine par une
fin de ligne ou un point-virgule.
Les mots de cette suite sont spars par des espaces ou tabulations.
Le premier mot est le nom de la commande, les mots suivants tant ses
arguments.
Les mots qui doivent contenir des blancs ou des tabulations doivent tre
parenthss.
Les noms de commandes doivent respecter les majuscules et
minuscules.
Par dfaut, une ligne vide (ne contenant que des blancs et retourchariot) signale l'excution de la ligne prcdemment fourni au
dbuggeur (on peut dsactiver cette option nomme nlrepeat par la
commande :
(DBG) set nlrepeat 0
Un mcanisme d'alias permet de dfinir de nouvelles commandes en

combinant des commandes plus lmentaires. Un certain nombre de
commandes sont prdfinies de cette faon.
PrologIA
2007

Les commandes sont excutes chaque point d'arrt. S'il n'y a aucune
commande en attente d'excution, le prompt est affich et l'utilisateur a
la main.
2. Points d'impression et points d'arrt

Par dfaut, tout passage une porte provoque l'impression de son statut. En
mode pas--pas (step), ce point d'impression est aussi un point d'arrt. Des
commandes y seront lu et excutes.
Il y a deux sortes de points d'arrt, selon que l'on souhaite dbugger un
appel particulier ou tous les appels un paquet de rgles. Pour dbugger la
rgle appelante, il faut utiliser la commande breakat, alors que pour dbugger
tous les appels un paquet on utilise la commande spy. La diffrence entre
ces commandes est que breakat met un point d'arrt sur une boite de la
dmonstration courante alors que spy met un point d'arrt sur l'ensemble
des boites potentielles (qui existeront peut-tre plus tard dans la
dmonstration).
3. Classifications des commandes

On peut classer les diffrentes commandes du dbuggeur en plusieurs
catgories :
Les commandes de progression du dmonstrateur Prolog III, utilises
pour faire des sauts plus ou moins grands :
step, next, nextp, nextc, cont, C
Les commandes utilises pour imprimer des informations :
chpt, locus, ls, resol, rs, printbox
Les commandes qui installent ou suppriment des points d'arrt :
spy, nospy, breakat, unbreak
Les commandes permettant de modifier l'excution d'un programme :
changechpt, fail, FAIL, RULE
Les commandes qui grent les options du dbuggeur :
set, show, p4, p7, t1, t2, t3, no_debug, kill
2008
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Les commandes classes nulle-part ailleurs :

alias, eof, flush, help, source
4. Progression
step, next, n, N, nextp, nextc, cont, C
step
tous ports
SYNTAXE :
step
DESCRIPTION :
C'est la commande de base pour suivre la progression de l'interprte. Elle
permet de se dplacer petit pas, de port en port. Seuls, les ports dcrits
dans l'option printport sont des points d'impression et points d'arrt pour
step. L'alias s est un raccourci de step.
REMARQUE :
Si l'option print est mise 0, step ne fait qu'un grand pas, seulement
interrompu par un ventuel point d'arrt.
next, n, N
tous ports
SYNTAXE :
next
n
N
DESCRIPTION :
Cette commande permet la progression de l'interprte avec une granularit
moins fine que step. En particulier next ne rend la main qu'une fois atteint
un port qui n'est pas un niveau suprieur au niveau courant. Les ports
intermdiaires sont ou ne sont pas imprims selon la valeur de l'option print.
PrologIA
2009
Aociation
Les points d'arrt franchis par le dplacement sont actifs ou pas selon la
valeur de l'option break. Seuls, les ports dcrits par l'option breakport sont des
points d'arrive pour next. La commande n se comporte comme next la
diffrence qu'aucune impression des ports de boites intrieures n'a lieu. La
commande N agit comme n, sauf que les point d'arrts ne sont pas actifs. N
et n sont des alias utilisant next.
cont, C
tous ports
SYNTAXE :
cont
C
DESCRIPTION :
Ces commandes sont gnralement utilises conjointement avec l'utilisation
de points d'arrt. cont lche la bride l'interprteur, qui ne reviendra au
mode interactif que lors de la rencontre d'un point d'arrt. L'impression des
ports a lieu ou pas selon la valeur des options print et printport . L'alias C se
comporte comme cont la diffrence qu'il n'y a pas d'impression, et rend les
points d'arrt actifs.
nextp
tous ports
SYNTAXE :
nextp
DESCRIPTION :
Cette variante de next permet de se dplacer jusqu'au prochain port de cette
boite. Elle permet par exemple de passer du port EXIT au port REDO. Un cas
particulier est de faire nextp alors qu'on sort irrmdiablement de la boite
courante, que ce soit par le port EXIT sans REDO possible, soit par le port
FAIL. Dans ces cas, l'option warnnext donne le comportement de nextp. Si
l'option warnnext est 1, un message d'erreur est imprim et aucune action
n'est accomplie. Si warnnext est 0, un step est fait en lieu de nextp.
2010
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
5. Informations
On a la possibilit d'obtenir l'impression de diverses informations sur la
dmonstration courante au moyen des commandes locus, ls, resol, rs, et sur
les diffrents choix en attente grce la commande chpt. la commande sol
montre l'tat du systme de contraintes portant sur les variables de la
requte. printbox sert rafrachir le statut du port courant.
chpt
tous ports
SYNTAXE :
chpt
DESCRIPTION :
Affiche les points de choix en attente, du plus rcent au plus ancien (du haut
vers le bas). L'impression est au format suivant :
--\/-- CHOICE POINTS (new)\/-5[2] (r3*): Dessert(glace,6)
4[3] (r2*): Viande(porc,7)
3[2] (r2*): Plat(p,i)
2[2] (r2): HorsDoeuvre(pate,6)
--/\-- CHOICE POINTS (old)/\-Les nombres affichs correspondent ceux du format d'une ligne de
description de port, c.a.d. la profondeur, le niveau entre [ et ], le numro de
rgle utiliser entre ( et ). Les termes imprims correspondent aux ttes de
rgle en attente d'essai. Cet exemple indique que la rgle n3 (* indique que
c'est la dernire) du paquet de nom Dessert sera essaye en premier.
REMARQUES :
Pour les prdicats prdfinies, un point d'interrogation remplace les
informations inconnues ou caches.
locus
tous ports
PrologIA
2011

SYNTAXE :
locus
locus nb_niveau
DESCRIPTION :
Affiche l'endroit le niveau courant de la dmonstration sous la forme
approximative d'une rgle avec indication du niveau du corps de la rgle et
de la position de l'appel courant (boite courante) au sein de cette rgle. Cette
position est indique1 par le caractre . Quand un nombre est donn en
argument, celui-ci dsigne le nombre de niveau que l'on souhaite voir
affich, ligne par ligne, partir du bas de l'arbre de dmonstration (dans
l'ordre des niveaux dcroissants). Le niveau 0 correspond l'appel virtuel du
but $query$ dont le corps de rgle serait la requte tape par l'utilisateur. Un
point d'arrt (pas les points-espions) est not au moyen du caractre *, plac
devant le littral o il a t install. Notons que l'interprtation de l'affichage
du niveau affich en premier dpend du port courant (le peut tre avant
ou aprs un appel selon le port correspondant cet appel).
> aa(x) -> bb(x) cc(x);

> bb(x) -> eq(x,1);
> aa(u);
--------new query-------1[1]CALL
: aa(u) (DBG) s
1[1]RULE(r1*): aa(u) = aa(x_1) (DBG)
1[1]{ok}(r1*): aa(u) (DBG)
2[2]CALL
: bb(u) (DBG)
2[2]RULE(r1*): bb(u) = bb(x_2) (DBG)
2[2]{ok}(r1*): bb(u) (DBG)
3[3]CALL
: eq(u,1) (DBG)
3[3]EXIT(r1*): eq(1,1) (DBG) locus
[3] bb(1) -> eq(1,1)
(DBG) locus 10
[3] bb(1) -> eq(1,1) ;
[2] aa(1) -> bb(1) cc(1) ;
[1] aa(1) ;
[0] $query$
(DBG)
1 Ce caractre dpend de l'implantation.
2012
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
REMARQUE :
Si l'on n'tait pas en mode dbug au moment o la requte est lance, locus
ne peut donner d'information complte concernant la dmonstration
ralise en amont du passage en mode dbug.
ls
tous ports
SYNTAXE :
ls
DESCRIPTION :
Cette commande, implante par un alias utilisant locus, est simplement un
raccourci pour indiquer qu'on souhaite afficher la dmonstration courante
c.a.d. l'ensemble des appels depuis la requte.
resol
tous ports
SYNTAXE :
resol
resol
nb_resolvantes
DESCRIPTION :
Cette commande, assez similaire la commande locus, permet de montrer
les rsolvantes locales (restes de corps de rgles), par niveau, celles-ci
correspondant aux littraux qui restent effacer. L'impression correspond
en gros au buts situs droite du caractre visible par la commande locus.
Avec un argument, nb_resolvantes correspond au nombre de niveaux
imprimer partir du bas de l'arbre
PrologIA
2013
Aociation
> aa(x) -> bb(x) cc(x);

> bb(x) -> eq(x,1);
> aa(u);
--------new query-------1[1]CALL
: aa(u) (DBG) s
1[1]RULE(r1*): aa(u) = aa(x_1) (DBG)
1[1]{ok}(r1*): aa(u) (DBG)
2[2]CALL
: bb(u) (DBG)
2[2]RULE(r1*): bb(u) = bb(x_2) (DBG)
2[2]{ok}(r1*): bb(u) (DBG)
3[3]CALL
: eq(u,1) (DBG) resol
eq(u,1) ;
(DBG) resol 10
eq(u,1) ;
cc(u) ;
(DBG)
rs
tous ports
SYNTAXE :
rs
DESCRIPTION :
Cette commande, implante par un alias utilisant resol, est simplement un
raccourci pour indiquer qu'on souhaite afficher toutes les rsolvantes c.a.d.
l'ensemble des littraux en attente d'effacement.
sol
tous ports
SYNTAXE :
sol
DESCRIPTION :
Provoque l'affichage de l'tat courant du systme de contraintes portant sur
les variables de la question. C'est le format utilis lors de l'affichage des
solutions Prolog III. Si la dmonstration courante n'aboutit pas (on est sur
FAIL, ou sur {no} sans autre choix possible), la chane none est imprime
en place du systme, qui est dans ces cas-l insoluble.
2014
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
printbox
tous ports
SYNTAXE :
printbox
DESCRIPTION :
Cette commande permet d'imprimer la ligne formatte contenant les
informations sur le port courant de la boite courante. L'alias p est un
raccourci de printbox.
6. Installer des points d'arrt

Les points-espions sont installs par spy et enlevs par nospy. Les points
d'arrts proprement dits, que l'on place dans la dmonstration courante,
sont installs par breakat et enlevs pas unbreak.
spy
tous ports
SYNTAXE :
spy
spy identificateur arit
DESCRIPTION :
Cette commande permet de surveiller tous les appels un paquet de rgle.
Elle ne surveille donc pas un appel particulier comme le fait la commande
breakat. Sans arguments, le nom et l'arit du paquet de rgles correspondent
ceux de la boite courante. Avec arguments, dcrit le paquet
identificateur arit .
spy Dessert 2
Il est galement possible d'ajouter des points-espions avec la primitive
Prolog III spy .
PrologIA
2015

nospy
Aociation
tous ports
SYNTAXE :
nospy
nospy
identificateur arit
DESCRIPTION :
Cette commande permet d'enlever tous les appels un paquet de rgle. Sans
arguments, le nom et l'arit du paquet de rgles correspondent ceux de la
boite courante. Avec arguments, dcrit le paquet dcrit par le couple
identificateur arit .
nospy Dessert 2
Il est galement possible d'enlever des points-espions avec la primitive
Prolog III no_spy .
breakat
tous ports
SYNTAXE :
breakat
breakat
n_boite
breakat
niveau
DESCRIPTION :
n_littral
Cette commande permet de surveiller un appel de la dmonstration

courante en y mettant un point d'arrt. Sans arguments, met un point
d'arrt sur la boite courante. Avec un argument, met un point d'arrt sur la
boite n_boite. Avec deux arguments, dcrit l'appel surveiller en donnant
en coordonnes cartsiennes sa localisation, dans l'affichage produit par la
commande ls ou locus . Dans cet affichage, niveau dcrit est le nombre
indiqu en dbut de chaque ligne, et n_littral est le nombre de termes,
compts partir de la gauche, la tte de rgle tant comprise et en position 1.
2016
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
L'ensemble des noms de ports sur lequel le point d'arrt s'arrtera est la
valeur de l'option breakport 1 au moment de l'installation du point d'arrt.
Un point d'arrt install par breakat apparait sous la forme du caractre *
dans l'affichage produit par la commande ls ou locus . Les points d'arrt sont
rendus inactifs en mettant l'option break 0. Si l'option break est 1, une
commande de type cont ou C s'arrtera sur ce point d'arrt2 pour les ports
convenus lors de l'installation.
> aa(x) -> bb(x) cc(x);

> bb(x) -> eq(x,1);
> cc(1) ->;
> aa(X);
--------new query-------** 1[1]CALL
: aa(X) (DBG) s
** 1[1]RULE(r1*): aa(X) = aa(x_1) (DBG)
** 1[1]{ok}(r1*): aa(X) (DBG) ls
[2] aa(X) -> bb(X) cc(X) ;
[1] aa(X) ;
[0] $query$
(DBG) breakat 2 3
(DBG) ls
[2] aa(X) -> bb(X) *cc(X) ;
Un point d'arrt sur cc(X)
[1] aa(X) ;
[0] $query$
(DBG) C
On va jusqu'au prochain point d'arrt
**
4[2]CALL
: cc(1) (DBG) Point d'arrt atteint
unbreak
tous ports
SYNTAXE :
unbreak
unbreak
unbreak
n_boite
niveau
n_littral
DESCRIPTION :
1 Les options sont positionne par la commande set,

2 Si on y arrive, un backtracking pouvant trs bien se produire entre temps.
PrologIA
2017
Aociation
Cette commande, de syntaxe similaire breakat, permet d'enlever des point

d'arrts de la dmonstration courante. Contrairement breakat, tous les
ports sont concerns, sans tenir compte de la valeur de l'option breakport.
7. Modifier le droulement de l'excution

Quelques commandes permettent de modifier le droulement d'un
programme; ce sont : changechpt, fail, FAIL, RULE.
RULE et changechpt permettent de modifier des points de choix.
FAIL et fail provoquent des backtracking.
changechpt
tous ports
SYNTAXE :
changechpt
nboite
nrgle
DESCRIPTION :
Change le numro de rgle suivante du point de choix de la boite de numro
nboite la rgle de numro nrgle .
Cette commande permet de modifier un point de choix et modifie donc
l'arbre de recherche, qui est parcouru par l'interprteur. Appelons ici arbre
de recherche l'arbre des dmonstration dont les nuds sont des 'OU' dont
les fils correspondent aux alternatives au sein d'un paquet de rgles. Cette
commande ne modifie pas le parcours de la branche courante puisqu'elle
modifie une alternative situe dans le pass de cette branche.
changechpt permet d'laguer certaines branches quand on sait qu'elles sont
striles, ou qu'on souhaite progresser plus vite dans la recherche d'une
erreur. Il est galement possible d'en rexcuter certaines qui ont dj t
parcourues. Cette commande utilise les informations affiches par la
commande chpt .
Voici deux exemples o on modifie des choix en attente. Dans le celui-ci, on
saute une solution :
2018
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
> dizaine(10) ->;

> dizaine(20) ->;
> dizaine(30) ->;
> dizaine(x);
--------new query-------1[1]CALL
: dizaine(x) (DBG) s
1[1]EXIT(r1): dizaine(10) (DBG)
0[0]EXIT(r1): $query$ (DBG) chpt
--\/ CHOICE POINTS (new)\/-1[1] (r2): dizaine(20)
__/\ CHOICE POINTS (old)/\__
(DBG) changechpt 1 3
(DBG) chpt
--\/ CHOICE POINTS (new)\/-1[1] (r3*): dizaine(30)
(DBG) s
{x = 10}
et la prochaine solution
0[0]REDO(r1): $query$ (DBG)
1[1]REDO(r1): dizaine(x) (DBG)
1[1]EXIT(r3*): dizaine(30) (DBG)
0[0]EXIT(r1): $query$ (DBG)
{x = 30}
>
sera 30
Dans celui-l, on repasse deux fois par la mme solution :
PrologIA
2019

> dizaine(x);
--------new query-------1[1]CALL
0[0]EXIT(r1): $query$ (DBG) chpt
(DBG) changechpt 1 1
(DBG) chpt
(DBG) s
{x = 10}
et la prochaine solution
0[0]REDO(r1): $query$ (DBG)
1[1]REDO(r1): dizaine(x) (DBG)
{x = 10}
...
{x = 20}
...
{x = 30}
>
Aociation
sera 10
REMARQUES :
Le point de choix induit par le port RULE n'est rellement install et
exploitable avec les commandes chpt et changechpt que lorsque l'on
passe sur le port {ok} , et ce, condition que la cration d'un point de
choix soit justifie (il n'y a pas de choix quand on excute la dernire
rgle d'un paquet).
On ne peut pas modifier un point de choix attach un prdicat
prdfini crit en C (comme enum) .
Un point de choix est susceptible de disparatre si un appel cut ou au
garbage collector se produit avant qu'on soit revenu cette alternative.
fail
tous ports
SYNTAXE :
fail
2020
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
DESCRIPTION :
La commande fail fait chouer l'action en cours et dpend donc du port
courant. On peut considrer cette commande comme l'excution immdiate
de la rgle prdfinie fail. Cette commande agit comme step lorsqu'on va en
marche arrire (backtracking).
Le descriptif suivant indique les changements d'tats, qui sont en fait assez
intuitifs :
CALL
va en FAIL (sort de la boite)
RULE
va sur un autre RULE ou sur FAIL
{ok}
va sur {no}
{no}
fait step (va sur RULE ou FAIL)
EXIT
fait REDO ou FAIL (selon la prsence ou pas d'un point de

choix)
REDO
fait step (va sur RULE ou un autre REDO intrieur)
FAIL
fait step (va sur d'autres FAIL ou REDO extrieurs)
FAIL
tous ports
SYNTAXE :
FAIL
DESCRIPTION :
La commande FAIL (d'aprs le nom du port) fait immdiatement passer au
port FAIL de la boite courante. Fait step dans le cas o on tait dj au port
FAIL (c'est la poursuite du backtracking). Cette commande FAIL est plus
nergique que la commande fail , qui est plus fine.
RULE
RULE, {no}, FAIL
SYNTAXE :
RULE nrgle
PrologIA
2021
Aociation
DESCRIPTION :
La commande RULE (d'aprs le nom du port) permet de slectionner le
numro de la rgle utiliser, lorsqu'on est sur les ports RULE ou {no}. Cette
commande est activable sur le port FAIL si celui-ci est conscutif un port
{no} .
> dizaine(x);
--------new query-------1[1]CALL
1[1]RULE(r1): dizaine(x) = dizaine(10) (DBG) RULE 3
1[1]RULE(r3*): dizaine(x) = dizaine(30) (DBG) s
1[1]{ok}(r3*): dizaine(30) (DBG)
1[1]EXIT(r3*): dizaine(30) (DBG)
{x = 30}
>
REMARQUES :
Il y a bien sr erreur lorsque le numro fourni ne correspond aucune
rgle au sein du paquet. Aucune action n'est alors faite.
8. Gestion des options du dbuggeur

Ces options sont imprimables avec la commande show, et modifiables avec la
commande set (dcrites la fin de cette section). Elle servent de
paramtrage du dbuggeur et en modifient le comportement,
essentiellement au niveau de la quantit d'information affiche.
tracemode
valeur : 1/2/3
valeur par dfaut : 2
Cette option indique quelle est la prcision de l'impression des termes (voir
trace) et prend donc une valeur parmi les nombre 1, 2 ou 3.
maxlevel
valeurs : -1
valeur par dfaut : -1
Indique quelle est le niveau maximal d'impression complte des arbres. Le

niveau maximal d'un arbre tant 0 quand c'est une feuille, un entier plus
grand sinon. Par exemple, si maxlevel vaut 0, le terme eq(x, gg(y)) sera
imprim e q ( . . . , . . . ) et, si m a x l e v e l vaut 1, il sera imprim
2022
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
eq(x, gg(...)) . La profondeur de cet arbre tant 2, positionner maxlevel

2 l'imprime compltement. Une valeur de -1 indique une impression
complte, sans restriction de niveau.
maxarg
valeurs : -1
Indique le nombre maximal d'arguments imprimer, que ce soit des

arguments de fonctions ou de tuple. Si maxarg vaut 0, le terme eq(x, gg(y))
sera imprim eq(..(2)..)) indiquant que deux arguments sont prsents et nonimprims. Si maxarg vaut 1, eq(x,..(1)..)) sera affich, ..(n).. indiquant qu'il
reste une suite de n arguments non-imprims. Une valeur de -1 indique une
impression de tous les arguments.
maxexpr
valeurs : -1
Indique le nombre maximal de monmes imprimer, au sein d'une

expression numrique. Cette option se comporte un peu comme maxarg, et
imprime le reste des monmes sous la forme ..(nm).., ou n est le nombre
de monmes restant. Par exemple, si m a x e x p r vaut 1, le terme
eq(z+4y+(18/7)x-t, u) sera imprim eq(z..(3m)..,u) . Une valeur de -1 indique
une impression de tous les monmes.
maxstr
valeurs : -1
Indique le nombre maximal de caractres imprimer, au sein d'une chane

de caractres (et non d'un tuple). Cette option se comporte comme maxexpr
et imprime le reste de chane sous la forme ..(nc).., ou n est le nombre
de caractres restant. Par exemple, si maxstr vaut 10, le terme eq(x, "cette
chaine est un peu trop longue") sera imprim : eq(x,"cette chai..(25c).."). Une
valeur de -1 indique une impression intgrale de la chane.
print
valeurs : 0/1
Cette option pilote l'impression des ports pendant le droulement d'un

programme et affecte donc le comportement des commandes de
progression, comme step, next et cont . En effet, tout point d'impression tant
un point d'arrt pour step, si cette option est mise 0, step n'est plus en
PrologIA
2023
Aociation
mesure de s'arrter 1 . Pendant l'excution de next, aucun des ports

correspondant des boites intrieures n'est imprim.
printport
valeurs : [cerfRYN]
valeur par dfaut : cerfRYN
Cette option sert limiter les impressions de ports ayant lieu pendant le
droulement du programme, que se soit par step, next ou cont. Cette option
prend pour valeur un ensemble de ports, chacun dcrit par une lettre, toutes
les lettres colles. Il est possible de rajouter ou de retrancher des ports cette
option, en utilisant les signe + ou - . Quelques exemples :
set printport cerf
set printport +YN
set printport -RYN
Cette option affecte directement le comportement de step. Elle n'est
exploite que lorsque l'option print est mise 1 .
break
valeurs : 0/1
Cette option indique si on permet qu'un point d'arrt, install par les
commandes breakat ou spy, provoque ou non une interruption du
droulement de la commande en cours. La commande next n'est pas affecte
par cette option.
breakport
valeurs : [cerfRYN]
valeur par dfaut : cerfRYN
Indique quels ports la commande next peut arrter sa progression. La

syntaxe est du mme type que pour l'option printport. L'autre usage de cette
option concerne les point d'arrts : la valeur de breakport au moment de
l'installation d'un point d'arrt par breakat indique quels ports ce point
d'arrt peut se rveiller. On rappelle que les points d'arrts ne peuvent se
rveiller que si l'option break est 1 .
echo
valeurs : 0/1
Imprime sur la sortie de trace les commandes qui sont excutes.

prompt
valeurs : chane de 19 car. maxi
valeur par dfaut : (DBG)
1 A moins qu'un point d'arrt n'ai t explicitement install.
2024
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
Cette option contient le prompt utilise par le dbuggeur. La chane doit

tre parenthse par ( et ) si elle contient des blancs ou point-virgules,
comme par exemple :
set prompt ( (DBG) )
valeurs : 0/1/2
catcherror
Positionne 1 ou 2, cette option indique si on souhaite localiser les erreurs

ou les excutions du prdicat prdfini block_exit . Si l'option vaut 0,
l'excution de la session de dbuggage ne sera pas interrompu par la
dtection d'erreur. Si l'option vaut 1, un message sera imprim indiquant le
type d'erreur (ou l'argument de block_exit) et le numro de la boite o sera
rcupre l'erreur le cas chant. Si l'option vaut 2, le message prcdent
est imprim et un port EXIT est affich, laissant la main l'utilisateur1.
valeurs : 0/1
nlrepeat
Quand cette option est positionne 1, indique si l'envoi d'une ligne vide
(retour-chariot seulement) correspond en fait l'envoi de la dernire ligne
non-vide (contenant une ou plusieurs commandes). Trs pratique quand on
a une mme suite de commande faire, mais aussi trs dangereux quand on
a fait une suite de fail et qu'on a oubli de taper step ou next pour avancer !
Si l'option est 0, l'envoi d'une ligne vide ne fait rien.
valeurs : 0/1
warnnext
Quand l'option vaut 1, informe le cas chant que les commandes nextp et
nextc n'ont pu tre excute normalement, gnralement parce qu'un
backtracking se produit, faisant sortir de la boite courante par le port FAIL.
option
print
valeurs
0/1
printport
[cerfRYN] cerfRYN
-- Print only specified ports
(unless 'printat' has been used).
0/1
1
-- Enable/disable Breaks (not Nexts).
break
dfaut
1
description
-- Enable/disable Printing.
breakport [cerfRYN] cerfRYN
-- Break and Next only at these ports.
1 Les commandes fail et FAIL ne sont pas active ce port particulier.
PrologIA
2025

maxlevel
maxarg
>= -1
>= -1
Aociation
-1 (all)
-1 (all)
-- Max. level of full printing.

-- Max. number of arguments printed.
maxexpr >= -1
maxstr
>= -1
tracemode 1/2/3
-1 (all)
-1 (all)
2
-- Max. number of monomials printed.

-- Max. number of characters printed.
-- Printing mode for goals and terms.
echo
prompt
0
-- Echo DBG commands before executing.
( (DBG) )
-- Dbg prompt string.
0/1
<19 chars
catcherror 0..2
nlrepeat
0/1
warnnext 0/1
2
-- 0 = ignore, 1 = print error, 2 = print
and catch (will print an EXIT port.)
1
-- if set, <CR> performs the previous
command line.
0
-- Warns when nextc or nextp can't be
done.
set
tous ports
SYNTAXE :
set
set
nom
nom
valeur
DESCRIPTION :
Donne la valeur valeur l'option nom parmi celles qui sont dcrites plus haut.
La forme deux arguments positionne l'option sa valeur par dfaut.
show
tous ports
SYNTAXE :
show
show nom
DESCRIPTION :
La forme un argument imprime la liste de toutes les options et leurs
valeurs dans un format rutilisable. La forme deux arguments permet de
n'avoir que l'information concernant l'option nom.
no_debug
2026
Prolog
HERITAGE
tous ports
PrologIA
Aociation
Prolog
HERITAGE
SYNTAXE :
no_debug
DESCRIPTION :
Cette commande sort du mode dbug et poursuit l'excution du
programme en cours. Aucun point d'arrt ou point-espion ne sera plus en
mesure de se faire connatre ( moins que les prdicats prdfinis debug ou
break ne soient employs par le programme).
REMARQUE :
Il existe une primitive Prolog III qui s'appelle galement no_debug .
kill
tous ports
SYNTAXE :
kill
DESCRIPTION :
Cette commande abandonne l'excution du programme en cours et renvoie
l'interprteur Prolog III qui attend un autre but. Le mode dbug reste actif.
p4
tous ports
SYNTAXE :
p4
DESCRIPTION :
Cette commande positionne les options breakport et printport, de sorte que
les seuls ports prendre en compte soient les quatre ports standard CALL,
EXIT, REDO, FAIL.
p7
tous ports
SYNTAXE :
PrologIA
2027
Aociation
p7
DESCRIPTION :
Cette commande positionne les options breakport et printport, de sorte que
les tous les ports soient pris en compte. Cette commande est dfinie par un
alias.
t1, t2, t3
tous ports
SYNTAXE :
t1
t2
t3
DESCRIPTION :
Cette commande positionne l'option tracemode en fonction du nombre qui
apparat dans la commande. On se refrera l'option tracemode et aux
diffrents niveaux de trace pour plus de dtails. Ces commandes sont
dfinies par des alias.
9. Commandes annexes
Cette section dcrit un certain nombre de commandes utilitaires. Certaines
permettent de personnaliser son environnement sous dbuggeur : alias, eof,
help, source .
alias
tous ports
SYNTAXE :
alias
alias
alias
nom
nouveau_nom
(dfinition)
alias
nouveau_nom
(dfinition)
2028
Prolog
HERITAGE
PrologIA
(aide)
Aociation
Prolog
HERITAGE
DESCRIPTION :
Permet de crer un synonyme d'un ensemble de commandes. La forme un
argument permet de lister l'ensemble des noms actuellement dfinis. La
forme deux arguments affiche la dfinition de l'alias de nom nom . La
forme trois arguments permet de dfinir nouveau_nom avec la dfinition
dfinition qui est une suite d'une ou plusieurs commandes spares par
un point-virgule. La forme quatre arguments est quivalente la forme
trois, et permet en plus d'ajouter une ligne d'aide visible travers la
commande help .
L'intrt d'un alias est de pouvoir donner un nom plus court (ou prfr) la
place du nom officiel d'une commande, ou bien de dfinir une nouvelle
commande en combinant des commandes plus lmentaires.
EXEMPLES :
alias x next
alias nls (locus 10000;next)
REMARQUES :
Les dfinitions ou aides contenant des blancs ou points-virgule

doivent tre parenthses.
Donner une dfinition vide au moyen de () efface un alias.
Alias ne sert qu' dfinir des commandes, ce n'est pas un mcanisme

gnral de dfinition de macros.
eof
tous ports
SYNTAXE :
eof
eof
all
DESCRIPTION :
PrologIA
2029
Aociation
eof termine la lecture et l'excution de commandes du dbuggeur lues dans le

fichier ou cette commande est prsente. Avec un paramtre, ferme tous les
fichiers de commandes actuellement ouverts.
REMARQUES :
eof ne ferme que les fichiers disque.
Voir la commande source pour lire un fichier de commandes.
help
tous ports
SYNTAXE :
help
help nom_de_commande
DESCRIPTION :
help permet simplement d'afficher la liste des commandes. Avec un
argument, help imprime quelques informations sur nom_de_commande si
celui-ci existe. Il est possible de documenter les alias (cf. alias).
source
tous ports
SYNTAXE :
source
nom_de_fichier
DESCRIPTION :
Cette commande permet d'ouvrir et de lire un fichier contenant des
commandes du dbuggeur Prolog III. Les commandes y sont lues, jusqu' la
fin du fichier, au fur et mesure des besoins du dbuggeur. Le fichier se
substitue donc temporairement la console. On utilise essentiellement cette
commande pour le chargement d'alias et le positionnement de certaines
options.
REMARQUES :
source est rentrant, et ce jusqu' une profondeur de cinq appels.
La commande eof permet de terminer une lecture de fichier.
2030
PrologIA
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
5 . Rgles prdfinies de mise au point

trace, no_trace, debug, no_debug, spy, no_spy, break
6 . Mise au point avance
1 Reprendre une dmonstration (retry)

Il est trs utile de pouvoir reprendre un dmonstration sans avoir la
recommencer partir du dbut, en particulier lorsque l'excution du
programme pister est fastidieuse de par le temps d'excution ou de la
difficult de se placer ce point prcis de la dmonstration.
Gnralement, lors de l'excution d'un programme erron, on a plus ou
moins la certitude qu'une erreur se produit entre deux points P1 et P2 de
cette dmonstration, et le but de la session de dbuggage est de rduire cet
intervalle en parcourant l'intrieur par des sauts de plus en plus petits, afin
de dtailler l'excution. Lors de cette recherche, souvent dichotomique, on
passe de temps en temps par dessus l'erreur, car on retrouve la machine
Prolog dans un tat qu'on juge incorrect vis--vis du programme parfait
qu'on a en tte. On a alors rapproch le nouveau point P2 de P1 et il n'y a
plus qu'a dbugger jusqu' P2, si possible. Il est bien pratique d'viter de
relancer la question si on a la possibilit de rester sous la session courante, et
de pouvoir revenir au point P1 afin de recommencer la section litigieuse du
programme.
Cette premire version du dbuggeur ne permet pas d'effectuer une reprise
automatique, mais fourni des moyens pour raliser une reprise manuelle .
Les commandes utiles cette tche sont dcrites un peu plus haut, dans cette
section; ce sont changechpt, fail, FAIL, RULE .
PrologIA
2031

Les points de choix sont des jalons naturels de toute dmonstration nondterministe et sont les candidats tout dsigns la reprise d'excution1 . La
manipulation consiste, pour refaire une portion de branche,
reprer le point de choix le plus proche possible du point erron, en
tant toutefois en amont (dans le pass) l'aide de la commande chpt
effectuer une suite de fail ou FAIL, en retournant dans les boites
pertinentes et se retrouver au port RULE correspondant la boite du
point de choix.
slectionner la rgle utiliser2 avec la commande RULE, afin de
reprendre l'excution.
La poursuite de l'excution va refaire cette branche. Un exemple (il s'agit
de "menu.p3") sera plus explicite :
EXEMPLE A REFAIRE
> RepasLeger(h,p,d);
--------new query-------1[1]CALL
: RepasLeger(h,p,d) (DBG)
1[1]RULE(r1*): RepasLeger(h,p,d) = RepasLeger(h_1,p_1,d_1) (DBG)

1[1]{ok}(r1*): RepasLeger(h,p,d) (DBG)
2[2]CALL
: HorsDoeuvre(h,i_1) (DBG) n
2[2]EXIT(r1): HorsDoeuvre(radis,1) (DBG)

3[2]CALL
: Plat(p,j_1) (DBG) n
3[2]EXIT(r1): Plat(boeuf,5) (DBG)
Supposons qu' ce moment nous souhaitions dtailler l'excution de la rgle

Plat, partir du port CALL. On va chercher, parmi les points de choix, celui
qui est avant la boite n3 , laquelle correspond Plat .
1 Ce qui veut dire que les programmes dterministes ne permettent pas d'tre repris.
2 C'est souvent la prcdente de celle qui est affiche.
2032
PrologIA
Aociation
Prolog
HERITAGE
Aociation
Prolog
HERITAGE
3[2]EXIT(r1): Plat(boeuf,5) (DBG) chpt

--\/ CHOICE POINTS (new)\/-4[3] (r2*): Viande(porc,7)
3[2] (r2*): Plat(p,i)
2[2] (r2*): HorsDoeuvre(pate,6)
La boite n 2 HorsDoeuvre possde un point de choix, il faut donc retourner

jusque dans cette boite par une suite de commandes FAIL et fail.
4[3]{ok}(r1): Viande(boeuf,5) (DBG) F

4[3]FAIL(r1): Viande(p,j_1) (DBG)
3[2]RULE(r2*): Plat(p,j_1) = Plat(p_3,i_3) (DBG)
3[2]FAIL(r2*): Plat(p,j_1) (DBG)
2[2]REDO(r1): HorsDoeuvre(h,i_1) (DBG) s
2[2]RULE(r1): HorsDoeuvre(h,i_1) = HorsDoeuvre(radis,1) (DBG)
2[2]{ok}(r1): HorsDoeuvre(radis,1) (DBG)
2. Rcuprer
une
erreur
Il n'est pas toujours facile de dterminer l'origine d'une erreur d'excution,

quand bien mme cette erreur a t rcupre par un mcanisme de blocs.
La dtection d'erreur se fait aisment puisque le positionnement de la seule
option catcherror permet de mettre un point d'arrt sur l'endroit ou cette
erreur est gnre.
> minimize(X);
--------new query-------1[1]CALL
: minimize(X) (DBG) c
** 1[1]: error (59) goes up to box 0[0]
1[1]EXIT(r1): minimize(X_1) (DBG) c
Err 60: Expression non-bornee lors d'un calcul d'extremum
>
PrologIA
2033
Aociation
On se rfrera l'option catcherror pour plus d'information sur la capture

d'erreurs. On notera galement que le mcanisme gnral des blocs peut
tre pist avec cette mme mthode.
BLA-BLA
Il faut noter qu' l'oppos des implantations existantes, notre modle est
complet et cohrent, reprsentant exactement une imbrication de boites
aussi bien en descente qu'en remonte, avec en particulier un comportement
symtrique des portes exit, redo et fail. Implanter ce modle de faon
complte a bien sr amen un surcot. Celui-ci est nul pour la porte call,
faible pour les portes exit et fail, plus important pour la porte redo qui a t
plus spcialement optimise. Bien sr, le fait que l'utilisateur soit susceptible
de demander des informations sur le programme en cours, et en particulier
des informations inutiles l'interprteur peut rendre une session de
debugging prohibitif, puisque pouvant entraver la rcupration de mmoire
qui n'est alors plus totale et complte.
Les portes supplmentaires implmentes visent dterminer plus
finement le point d'excution au sein de la boite et l'tat du systme de
contraintes, avant ou aprs l'unification de la tte; il n'y a pas de surcot
particulier ces portes.
ststs
2034
Prolog
HERITAGE
PrologIA

Documentation PrologIII Manuel PdfA

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Documentation PrologIII Manuel PdfA

Uploaded by

Copyright:

Available Formats

$%"!$%&'$*)#$&$%$(%$"" $'% !&**%)-%%"&"!

Flicitations ! Vous avez entre les mains le leader d'une nouvelle

Terminons ce premier contact en esprant que vous apprcierez la

Diffrences entre la version 1.2

Cette nouvelle version de Prolog III apporte un certain nombre de

Des primitives numriques plus performantes pour l'optimisation de

1 Et seront retires ds la version 1.4

Table des matires

Quelques petits exemples...................................................................12

Table des matires

Rsolution des systmes de contraintes ..........................................57

Arbres, tuples, chanes et listes ........................................................................69

Les tuples ..............................................................................................76

Rgles prdfinies sur les tuples........................................................80

Table des matires

Primitives sur les listes........................................................................84

Les contraintes numriques............................................................................... 93

Rgles prdfinies et procdures externes spcifiques................ 104

4. Retardement des contraintes non-linaires................................... 106

Les contraintes boolennes............................................................................. 117

Table des matires

Solution d'un ensemble de contraintes boolennes.................................126

3. Premiers exemples de programmes...............................................129

D'autres exemples .............................................................................135

3. Retardement de l'excution d'un but .............................................149

Le contrle et l'environnement des programmes ........................................161

Structuration, saisie et modification des rgles.............................176

Entres / sorties................................................................................. 192

Autres lments de l'environnement.............................................198

Rgles prdfinies et procdures externes..................................................199

Index des rgles prdfinies, procdures externes et fonctions

Table des matires

Les syntaxes de Prolog III............................................................................... 423

Syntaxe de base ................................................................................. 432

Syntaxe d'Edimbourg....................................................................... 443

Remarques gnrales ....................................................................... 460

Primitives Graphiques ..................................................................................... 463

Dessin et positionnement................................................................. 473

Table des matires

5. Modes de dessin et d'criture ..........................................................481

7. Primitive de description de menus .................................................493

9. Boutons actifs .....................................................................................515

Liste des messages d'erreur de Prolog III ...........................................523

Liste des rgles prdfinies par catgorie...........................................529

Quelques programmes Prolog III en syntaxe Edimbourg................535

Calculs sur les grands nombres : fact.p3e......................................537

3. Calculs bancaires : bank.p3e ...............................................................538

4. Manipulation d'arbres : leaves.p3e ....................................................539

Table des matires

Le programme :............................................................................ 539

5. Un peu de logique : god.p3e............................................................... 540

6. Un problme de Lewis Caroll : lewis.p3e......................................... 541

7. Dtection de panne dans un additionneur : circuit.p3e .................. 543

8. Un puzzle numrique : send.p3e ....................................................... 545

9. Un problme de remplissage : rectangle.p3e................................... 546

Index du manuel de rfrence ........................................................................ 547

Utilisation de Prolog III .................................................................. 1005

Spcificits de Prolog III Macintosh.............................................. 1008

A propos de l'environnement....................................................... 1009

Ajout de rgles prdfinies............................................................ 1010

Utilisation d'un diteur hte ........................................................... 1009

Table des matires

Fonctions de conversion :........................................................ 1016

6. Appeler Prolog III depuis le langage C...........................................1025

$%"!$%&'$)#$&$%$(%$"" $'% !&*%)-%%"&"!