Le langage Prolog Structures de données

Présentation au sujet: "Le langage Prolog Structures de données"— Transcription de la présentation:

1 Le langage Prolog Structures de données
Opérateurs et expressions arithmétiques Evaluation des expressions et prédicats de comparaison La coupure et la négation Les prédicats retardés Entrées-sorties 26 mars 2001

2 Structures de données Déjà vu : objets atomiques (nombres et variables) Il existe aussi une structure de données plus complexe appelée arbre Prolog ou structure Prolog. Prolog connaît aussi les listes. Ces structures feront l’objet des prochains cours. 26 mars 2001

3 Les opérateurs (1) Ils permettent d’utiliser une syntaxe infixée, préfixée ou suffixée pour écrire des prédicats. Ce terme n’est pas réservé aux opérateurs arithmétiques (+, - , * et / sont des opérateurs infixés). Ils ont des priorités différentes. 26 mars 2001

4 Les opérateurs (2) Trois types :
Opérateur binaire infixé : il figure entre ses 2 arguments et désigne un arbre binaire X + Y Opérateur unaire préfixé : il figure avant son argument et désigne un arbre unaire -X Opérateur unaire suffixé : il figure après son argument et désigne un arbre unaire (Ex : X^2) 26 mars 2001

5 Les opérateurs (3) Associativité : A gauche : A droite :
X op Y op Z est lu comme (X op Y) op Z A droite : X op Y op Z est lu comme X op (Y op Z) Non associatif : les parenthèses sont obligatoires la syntaxe X op Y op Z est interdite 26 mars 2001

6 Les opérateurs (4) Déclaration des opérateurs :
possibilité de modifier la syntaxe Prolog en définissant de nouveaux opérateurs définition : par l’enregistrement de faits de la forme suivante op(Priorite, Specif, Nom) Nom : nom de l’opérateur Priorite :compris entre 0 (le plus prioritaire) et 1200 Specif :type de l'opérateur (infixé, associatif…) 26 mars 2001

7 Les opérateurs (5) Exemple de déclaration d’un opérateur :
op(1000, xfx, aime) définit un opérateur infixé non associatif aime Dans ce cas, Prolog traduira une expression du type X aime Y en le terme aime(X, Y), et si Prolog doit afficher le terme aime(X, Y), il affichera X aime Y. Exercice: définissez les opérateurs et (conjonction), ou (disjonction), non (négation) et => (implication) afin de pouvoir écrire par ex : (A ou non A)... 26 mars 2001

8 Les expressions arithmétiques (1)
Prolog connaît les entiers et les nombres flottants. Les expressions arithmétiques sont construites à partir de nombres, de variables et d'opérateurs arithmétiques. Evaluation : par l’utilisation de l'opérateur is par exemple dans X is 26 mars 2001

9 Les expressions arithmétiques (2)
Opérations habituelles : addition, soustraction, multiplication, division entière (symbole //), division flottante (symbole /). Selon les systèmes Prolog, différentes fonctions mathématiques comme abs(X), ln(X), sqrt(X) Représentées par des arbres Prolog 26 mars 2001

10 Les expressions arithmétiques (3)
Expressions et unification : attention à certaines tentatives d ’unification la tentative d’unification entre 3+2 et 5 échouera. En effet, l’expression 3+2 est un arbre alors que 5 est un nombre. L'évaluation des expressions ne fait pas partie de l’algorithme d’unification. 26 mars 2001

11 Les prédicats de comparaison
Comparaison des expressions arithmétiques X =:= Y se traduit par X est égal à Y X \= Y se traduit par X est différent de Y X < Y X =< Y X > Y X >= Y Il y a évaluation puis comparaison. 26 mars 2001

12 Notion de coupure (1) Différents noms : coupure, cut ou coupe-choix
Introduit un contrôle du programmeur sur l'exécution de ses programmes en élaguant les branches de l’arbre de recherche rend les programmes plus simples et efficaces Différentes notations : ! ou / sont les plus courantes 26 mars 2001

13 Notion de coupure (2) Le coupe-choix permet de signifier à Prolog qu’on ne désire pas conserver les points de choix en attente Utile lors de la présence de clauses exclusives Ex : les 2 règles suivantes humain(X) :- homme(X). s'écrit humain(X) :- homme(X)!. humain(X) :- femme(X). s'écrit humain(X) :- femme(X)!. 26 mars 2001

14 Notion de coupure (3) Le coupe-choix permet :
d'éliminer des points de choix d'éliminer des tests conditionnels que l’on sait inutile => plus d'efficacité lors de l'exécution du programme Quand Prolog démontre un coupe-choix, il détruit tous les points de choix créés depuis le début de l’exploitation du paquet des clauses du prédicat où le coupe-choix figure. 26 mars 2001

15 Notion de coupure (4) Exemples d’utilisation :
Pour prouver que a est un élément d’une liste, on peut s'arrêter dès que la première occurrence de a a été trouvée. Pour calculer la racine carrée entière d’un nombre, on utilise un générateur de nombres entiers entier(k). L’utilisation du coupe-choix est alors indispensable après le test K*K>N car la génération des entiers n’a pas de fin. entier(0). entier(N) :- entier(N1), N is N+1. racine(N, R) :- entier(K), K*K >N, ! , R is K-1. 26 mars 2001

16 Notion de coupure (5) Repeat et fail :
Le prédicat fail/0 est un prédicat qui n’est jamais démontrable, il provoque donc un échec de la démonstration où il figure. Le prédicat repeat/0 est une prédicat prédéfini qui est toujours démontrable mais laisse systématiquement un point de choix derrière lui. Il a une infinité de solutions. L’utilisation conjointe de repeat/0, fail/0 et du coupe-choix permet de réaliser des boucles. 26 mars 2001

17 Notion de coupure (6) Dangers du coupe-choix :
Considérez les programmes suivants : enfants(helene, 3). ---> enfants(helene, 3) :- !. enfants(corinne, 1). ---> enfants(corinne,1) :- !. enfants(X, 0). ---> enfants(X, 0). et l’interrogation enfant(helene, N). dans les deux cas. 1) N=3 et N=0 2) N=3 mais enfant(helene, 3). donne YES. Le programme correct serait : enfant(helene,N) :- !, N=3. 26 mars 2001

18 Notion de coupure (fin)
En résumé, les utilités du coupe-choix sont : éliminer les points de choix menant à des échecs certains supprimer certains tests d’exclusion mutuelle dans les clauses permettre de n’obtenir que la première solution de la démonstration assurer la terminaison de certains programmes contrôler et diriger la démonstration 26 mars 2001

19 La négation (1) Problème de la négation et de la différence en Prolog
Pas de moyen en Prolog de démontrer qu’une formule n’est pas déductible. 26 mars 2001

20 La négation (2) Négation par l'échec
Si F est une formule, sa négation est notée not(F) ou not F. L'opérateur not est préfixé associatif. Prolog pratique la négation par l'échec, c’est-à-dire que pour démontrer not(F) Prolog va tenter de démontrer F. Si la démonstration de F échoue, Prolog considère que not(F) est démontrée. Pour Prolog, not(F) signifie que la formule F n’est pas démontrable, et non que c’est une formule fausse. C ’est ce que l’on appelle l'hypothèse du monde clos. 26 mars 2001

21 La négation (3) Elle est utilisée pour vérifier qu’une formule n’est pas vraie. La négation par l'échec ne doit être utilisée que sur des prédicats dont les arguments sont déterminés et à des fins de vérification. Son utilisation ne détermine jamais la valeur d’une variable 26 mars 2001

22 La négation (4) Dangers : Considérez le programme suivant :
p(a). Et interrogez Prolog avec : ?- X = b, not p(X). YES {X = b} Prolog répond positivement car p(b) n’est pas démontrable. 26 mars 2001

23 La négation (5) Par contre, interrogez le avec :
?- not p(X), X=b. NO Prolog répond négativement car p(X) étant démontrable avec {X = a}, not p(X) est considéré comme faux. => Incohérence qui peut être corrigée si l’on applique la règle vue précédemment : n’utiliser la négation que sur des prédicats dont les arguments sont déterminés. 26 mars 2001

24 La négation (6) Le coupe-choix et la négation :
not P :- call(P), !, fail. not P. Le prédicat prédéfini call/1 considère son argument comme un prédicat et en fait la démonstration. Pour démontrer not P, Prolog essaie de démontrer P à l ’aide de call(P). S’il réussit, un coupe-choix élimine les points de choix éventuellement créés durant cette démonstration puis échoue. Le coupe-choix ayant éliminé la deuxième règle, c’est la démonstration de not P qui échoue. Si la démonstration de call(P) échoue, Prolog utilise la deuxième règle qui réussit. 26 mars 2001

25 La négation (7) L’unification : Prédicat binaire infixé : X = Y
Pour démontrer X = Y, Prolog unifie X et Y ; s’il réussit, la démonstration est réussie, et le calcul continue avec les valeurs des variables déterminées par l’unification. ?- X = 2. YES ?- X = 2, Y = 3, X = Y. NO 26 mars 2001

26 La négation (fin) La différence est définie comme le contraire de l’unification Elle est notée : X \= Y. Elle signifie que X et Y ne sont pas unifiables, et non qu’ils sont différents. Ex : Z \= 3. Sera faux car Z et 3 sont unifiables. Elle peut être définie comme: X \= Y :- not X = Y. ou X \= X :- !, fail. X \= Y. 26 mars 2001

27 Les prédicats retardés
Prédicats dif/2 et freeze/2 Introduits dans le système Prolog II par A. Colmerauer et M. Van Caneghem Apportent une plus grande souplesse dans l’utilisation des prédicats arithmétiques Préservent la modularité des algorithmes classiques de Prolog tout en permettant leurs optimisations 26 mars 2001

28 La différence retardée
Comparaison entre dif(X, Y) et X\=Y Pas de différence si X et Y sont instanciées Si X ou Y n ’est pas instanciée, le prédicat dif/2 autorise Prolog à retarder la vérification de la différence jusqu’à ce que les deux variables soient instanciées. Permet de poser des contraintes de différence sur les variables. On parle de contraintes passives car elles sont simplement mémorisées. 26 mars 2001

29 Le gel des prédicats Généralisation de la différence retardée à n’importe quel prédicat. Syntaxe : freeze(Variable, Formule) signifie que cette formule sera démontrée lorsque cette variable sera instanciée. Par exemple : dif(X, Y) :- freeze(X, freeze(Y, X\=Y)) 26 mars 2001

30 Les prédicats retardés (fin)
Danger : c’est à vous de vous assurer que toutes les formules seront effectivement démontrées. Certains Prolog signalent les prédicats qui n’ont pas été dégelés suite à la non-instanciation d’une variable En résumé : disponibles dans tous les systèmes Prolog récents permettent de retarder la démonstration d’une formule utilisation dans la déclaration de contraintes passives prolongement naturel : programmation par contraintes 26 mars 2001

31 Les entrées-sorties (1)
Ecriture sur l'écran ou dans un fichier Lecture à partir du clavier ou d’un fichier Affichage de termes : write(1+2) affiche 1+2 write(X). affiche X sur l'écran, sous la forme _245 qui est le nom interne de la variable. nl/0 permet de passer à la ligne tab/1 tel que tab(N) affiche N espaces 26 mars 2001

32 Les entrées-sorties (2)
Affichage de termes (suite) : display/1 agit comme write/1 mais en affichant la représentation sous forme d’arbre Ex : write(3+4), nl, display(3+4), nl. Affiche : 3+4 +(3,4) YES 26 mars 2001

33 Les entrées-sorties (3)
Affichage de caractères et de chaînes put/1 s’utilise en donnant le code ASCII d’un caractère : put(97). affiche : a Prolog connaît aussi les chaînes de caractères. Elles sont notées entre «  ». Mais pour Prolog la chaîne est une liste de codes ASCII des caractères la composant . 26 mars 2001

34 Les entrées-sorties (4)
Lecture de termes : read/1 admet n’importe quel terme en argument. Il lit un terme au clavier et l’unifie avec son argument. Le terme lu doit être obligatoirement suivi d’un point. Certains systèmes Prolog affichent un signe d’invite lorsque le prédicat read/1 est utilisé. Exemple : ?- read(X). : a(1,2). YES {X = a(1,2)} 26 mars 2001

35 Les entrées-sorties (5)
Autre exemple : calculateur :- repeat, (*boucle*) read(X), (*lecture expression*) eval(X,Y), (*évaluation*) write(Y), nl, (*affichage*) Y = fin, ! (*condition d'arrêt*) eval(fin, fin) :- ! (*cas particulier*) eval(X, Y) :- Y is X (*calcul d’expressions*) lit des expressions arithmétiques, les évalue et les imprime jusqu'à ce que l’utilisateur rentre « fin » au clavier. 26 mars 2001

36 Les entrées-sorties (6)
Le prédicat eval/2 traite le cas particulier de l’atome fin. Lorsque fin est lu, le coupe-choix final est exécuté et met fin à la boucle. Sinon Y = fin échoue et le prédicat retourne en arrière jusqu'à repeat/0. Exemple d’utilisation : ?- calculateur. : (*noter l’espace entre 3 et . Pour éviter de penser qu’il sagit d’un réel*) 5 : fin. fin YES 26 mars 2001

37 Les entrées-sorties (7)
Lecture de caractères : get/1 et get0/1. Tous les deux prennent en argument un terme unifié avec le code ASCII du caractère lu. Si l’argument est une variable, celle-ci prendra pour valeur le code ASCII du caractère lu. get/1 ne lit que les caractères de code compris entre 33 et 126. Les fichiers : Un fichier peut être ouvert en lecture ou écriture. 26 mars 2001

38 Les entrées-sorties (8)
En écriture : mode write : son contenu est effacé avant que Prolog y écrive. mode append : Prolog écrira à partir de la fin du fichier. Ouverture d’un fichier : prédicat open/3 argument 1 : nom du fichier argument 2 : mode d’ouverture write, append ou read argument 3 : variable qui va recevoir un identificateur de fichier appelé flux ou stream. (dépend du système Prolog utilisé). 26 mars 2001

39 Les entrées-sorties (9)
Tous les prédicats read, write et autres vus auparavant admettent un second argument : le flux identifiant le fichier. Ex : write(Flux, X). où Flux est un identificateur de fichier Ex : read(Flux,X), get(Flux, X), get0(Flux,X) Fermeture du fichier : prédicat close/1 qui prend en argument le flux associé au fichier. 26 mars 2001

40 Les entrées-sorties (fin)
Exemple d’utilisation ecrire(T) :- open(‘ a.prl ’, append, Flux), (*ouverture*) write(Flux, T), nl(Flux), (*écriture*) close(Flux) (*fermeture*) 26 mars 2001