Termes prfixs et Nuplets Termes prfixs Codage Exemple

Termes préfixés et N-uplets • Termes préfixés – Codage – Exemple du calcul booléen – La négation • Les N-uplets – – – 9 avril 2001 N-uplets et ensembles N-uplets et termes préfixés Exemple : les arbres syntaxiques Liste des feuilles d’un arbre Arbres infinis

Codage des termes préfixés (1) • Donnons-nous une suite de propositions : • Il fait beau. • Jean habite Aix. • Pierre est le père de Marie. . . • Associons leur des variables P, Q, R, … • Si on les relie à l’aide de connecteurs et, ou, non, on obtient des formules de logiques. 9 avril 2001

Codage des termes préfixés (2) • Ces formules sont de la forme : • P et Q, P ou Q, non P, … • On peut alors construire : • (P et Q) ou (R et S) • P et (Q ou (R et non(S))) • Ce qui donne en notation préfixée (préférable) • ou(et(P, Q), et(R, S)) Exercice : faire l’autre 9 avril 2001

Codage des termes préfixés (3) • Ces formules sont représentées par des arbres. • Exercice : dessiner les arbres des 2 formules précédentes. • Ces structures sont appelées des termes préfixés. Cette notation est utilisée pour représenter : – des relations : parle(louis, chinois) – des fonctions. 9 avril 2001

Codage des termes préfixés (4) • Le nombre d’arguments ne dépend que de la relation ou de la fonction utilisées. • La seule restriction est que le terme qui sert à préfixer doit être un identificateur, il ne peut s’agir d’une variable. 9 avril 2001

Calcul booléen (1) • Illustration de l’utilisation des termes préfixés. • Attribuons : • la valeur 1 à une proposition vraie • la valeur 0 à une proposition fausse. • Exercice : écrire les règles du calcul booléen associées aux propositions suivantes : et(P, Q), ou(P, Q), non(P). 9 avril 2001

Calcul booléen (2) • Problème : écrire les règles qui calculent la valeur booléenne d’une formule. • Nous allons travailler sur l’exemple : • et(ou(0, non(1)), et(1, non(0))) • Exercice : représenter l’arbre associé à cette formule. 9 avril 2001

Calcul booléen (3) • Approche naturelle : • appeler les règles valeur-booleenne • y faire figurer 2 arguments : la formule à évaluer et le résultat de l'évaluation. • Il y a deux types de formules au sein de l’arbre représentatif : – les nœuds en et, ou, non – les feuilles 0 et 1 9 avril 2001

Calcul booléen (4) • Règles relatives aux feuilles : • R 1: valeur-booleenne(0, 0). • R 2: valeur-booleenne(1, 1). • Examinons les regles relatives à une formule et(P, Q) : • R 3: valeur-booleenne(et(P, Q), B) : valeur-booleenne(P, U), valeur-booleenne(Q, V), combiner-et(U, V, B). 9 avril 2001

Calcul booléen (5) • Avec : • • R 6: combiner-et(1, 1, 1). R 7: combiner-et(1, 0, 0). R 8: combiner-et(0, 1, 0). R 9: combiner-et(0, 0, 0). – Exercice : écrire les autres règles • R 4: valeur-booleenne(ou(P, Q), B) • R 5 : valeur-booleenne(non(P), B) • R 10 à R 15 : règles combiner-ou et combiner-non 9 avril 2001

Calcul booléen (6) • Commentaires : • Le programme est conçu de façon purement déclarative. • Chacune des règles correspond à un cas spécifique, il n’y a pas de remontée possible. • R 3, R 4, et R 5 sont des règles récursives. R 1 et R 2 sont les règles d'arrêt. C ’est une généralisation de la récursivité telle que nous l’avons traitée sur les listes. – Exercice : écrire l’arbre de recherche associé à la formule exemple. 9 avril 2001

Calcul booléen (7) • Améliorations du programme : • N’est-il pas possible d’arranger les règles ? – 1) remarque sur le et(0, _) et modification de valeurbooleenne – 2) introduction de coupure – 3) comment supprimer la coupure ? – 4) introduction de poursuivre-et – 5) simplification des règles – 6) adaptation du raisonnement à ou 9 avril 2001

Calcul booléen (8) • Amélioration 1 : • et(0, Q) donne toujours la valeur faux. Il n’est donc pas nécessaire d'évaluer Q. D’où la règle : • S 1: valeur-booleenne(et(P, Q), 0) : valeur-booleenne(P, 0). • S 2: valeur-booleenne(et(P, Q), B) : valeur-booleenne(P, U), valeur-booleenne(Q, V), combiner-et(U, V, B). 9 avril 2001

Calcul booléen (9) • Amélioration 2 : • L’amélioration 1 n’a rien apportée car si P vaut 0, S 1 s’applique, et le programme se poursuit. Lors de la remontée, il applique S 2 !! • S 1: valeur-booleenne(et(P, Q), 0) : valeur-booleenne(P, 0) !. • S 2: valeur-booleenne(et(P, Q), B) : valeur-booleenne(P, U), valeur-booleenne(Q, V), combiner-et(U, V, B). 9 avril 2001

Calcul booléen (10) • Amélioration 3: • Problème du cut : détruit l’aspect déclaratif du programme en introduisant un contrôle sur l’exécution. Pour le supprimer, il suffit de réserver S 2 aux cas où P est vraie. • S 1: valeur-booleenne(et(P, Q), 0) : valeur-booleenne(P, 0). • S 2: valeur-booleenne(et(P, Q), B) : valeur-booleenne(P, 1), valeur-booleenne(Q, V), combiner-et(1, V, B). 9 avril 2001

Calcul booléen (11) • Amélioration 4 : • On n’a pas progressé car P est toujours évalué 2 fois. Le programme est toujours inefficace. C’est S 1 la source du problème. • S 1: valeur-booleenne(et(P, Q), B) : valeur-booleenne(P, U), poursuivre-et(U, Q, B). • S 2: poursuivre-et(0, Q, 0). • S 3: poursuivre-et(1, Q, B): - valeur-booleenne(Q, V), combiner-et(1, V, B). 9 avril 2001

Calcul booléen (12) • Amélioration 5: • La règle S 2 prend en compte le cas où la valeur booléenne de P est nulle. On peut donc supprimer des déclarations dans combiner-et(1, 1, 1). combiner-et(1, 0, 0). • Mais si on efface combiner-et(1, V, B) sur ces deux règles, V et B prendront la même valeur. On peut donc supprimer combiner-et en identifiant V et B. 9 avril 2001

Calcul booléen (13) • On a donc les règles : valeur-booleenne(et(P, Q), B) : valeur-booleenne(P, U), poursuivre-et(U, Q, B). poursuivre-et(0, Q, 0). poursuivre-et(1, Q, B) : - valeur-booleenne(Q, B). • Exercice : écrire de la même façon les règles de ou(P, Q) et de non(P). • La première version était plus lisible, mais nous avons supprimé 4 règles et gagné énormément en efficacité. 9 avril 2001

La négation (1) • Nouvelle interprétation des règles et de l’effacement : • Les règles d’un programme constituent un ensemble de définitions. • Un but qui s’efface est une formule qui est vraie, relativement à ces définitions. • Effacer un but revient à démontrer que, pour certaines valeurs des variables, ce but est vrai, et l'interpréteur Prolog n’est autre qu’un démonstrateur automatique de théorèmes. 9 avril 2001

La négation (2) • Autre approche de valeur-booleenne : • On peut remarquer que des formules comme et(P, Q) ont syntaxiquement la même forme que menu(X, Y, Z). • Tous les programmes construits le sont à partir de termes préfixés. • Il est donc parfaitement possible de donner à effacer et(P, Q) à condition d’en donner les règles correspondantes. 9 avril 2001

La négation (3) • Autre formulation du programme : • La valeur booléenne d’une formule est 1 si cette formule est vraie. Cela se traduit par la règle : valeur-booleenne(P, 1) : - P. • Par contre, si cette formule ne s’efface pas, sa valeur booléenne sera 0. valeur-booleenne(P, 1) : - P !. valeur-booleenne(P, 0). 9 avril 2001

La négation (4) • La coupure est nécessaire pour empêcher qu’une formule vraie ait successivement la valeur 1 puis 0, lors de la remontée. • Considérons ce qui peut arriver lorsque l’on cherche à effacer une formule : – (a) et(P, Q) est vrai (s’efface), si P et Q sont vrais. Soit : et(P, Q) : - P, Q. – (b) ou(P, Q) est vrai, si P est vrai, ou si Q est vrai. Soit : ou(P, Q) : - P. ou(P, Q) : - Q. 9 avril 2001

La négation (5) • ( c) La feuille 1 est une formule toujours vraie qui doit toujours s’effacer. Il nous faudrait donc écrire une règle de la forme : 1. ce qui est impossible puisque la tête de règle doit être un identificateur. Pour contourner cette difficulté, il suffira de remplacer les formules 1 et 0 par un et zero. Nous pouvons ainsi ajouter : un. Il ne faut pas confondre la formule qui se réduit à la feuille un, et le nombre 1 qui est la valeur booléenne des formules vraies. 9 avril 2001

La négation (6) • (d) P est la feuille 0. Alors P ne doit jamais s’effacer et nous ne donnerons aucune règle dont la tête soit zero, ainsi l'échec sera systématique. • Récapitulation du programme : valeur-booleenne(P, 1) : - P !. valeur-booleenne(P, 0). et(P, Q) : - P, Q. ou(P, Q) : - P. ou(P, Q) : - Q. un. 9 avril 2001

La négation (7) • Ce programme est court et rapide en exécution. • La présence du cut est désagréable. • Il admet en outre l'équivalence entre formule vraie et terme qui s’efface, et, si cette équivalence est réelle pour et et ou, nous allons voir qu’il n’en est pas de même pour la négation. 9 avril 2001

La négation (8) • Règles de la négation : • R 1: non(P) : - P ! impasse. • R 2: non(P). • Cette formulation est utilisable pour n’importe quel terme P, dans n’importe quel programme Prolog. • impasse n’est pas un mot réservé ni un prédicat prédéfini de Prolog. C’est un terme impossible à effacer car n’apparaissant jamais en tête de règle. Il y aura donc toujours un échec sur ce but. 9 avril 2001

La négation (9) • On trouve alors dans R 1 deux échecs possibles : l’un aléatoire, avec la tentative d’effacement de P, et l’autre certain, avec la tentative d’effacement d’impasse. Par contre il n’y a aucun échec possible sur R 2. Cette règle effacera non(P) à chaque fois qu’elle sera utilisée. • Conclusion : les deux règles données provoquent, relativement à l’effacement, des comportements opposés pour P et non(P). 9 avril 2001

Conclusion - termes préfixés • Nous avons généralisé la structure de liste en définissant les termes préfixés, ou encore des arbres dont le nœuds ne sont pas seulement des «. » , mais des identificateurs. Nous allons maintenant voir des arbres dont les nœuds peuvent être des variables, et plus seulement des identificateurs. 9 avril 2001

Les N-uplets (1) • N-uplets et suites finies : • Nous avons vus qu’une suite finie {X 1, X 2, …, Xn} peut être représentée par une liste. A la même suite on peut faire correspondre un autre objet appelé Nuplet, codée < X 1, X 2, …, Xn>, auquel on associe l’arbre : < , , … > X 1 9 avril 2001 X 2 Xn

Les N-uplets (2) • Les éléments de la suite sont les arguments du Nuplet. • Remarques : – (a) Un n-uplet a une longueur fixe, on ne peut pas modifier le nombre de ses arguments. Une liste, nous l’avons vu, a une longueur variable. – (b) Le codage interne d’un n-uplet est beaucoup plus économique celui d’une liste. Il occupe deux fois moins de place. 9 avril 2001

Les N-uplets (3) • Conseils : – Si l’on doit représenter une suite comprenant un petit nombre d'éléments, et dont le cardinal restera constant tout au cours du programme, il vaut mieux utiliser un n-uplet. – Par contre, si la suite est trop longue, ou si sa taille est variable, il faut utiliser une liste. • N-uplets et termes préfixés • Un terme préfixe peut être considéré comme une suite composée du préfixe et des arguments. 9 avril 2001

Les N-uplets (4) • On a donc encore le choix entre différents codages. Pour guider le choix, il est important de préciser les points suivants : – Un terme préfixé est plus lisible, mais son préfixe doit impérativement être un identificateur. – Un n-uplet est moins clair à la lecture, mais chacun de ses arguments, y compris le premier, peut être une variable ou un caractère tel que + ou -. – Si on rencontre une expression qui peut se représenter par un terme préfixé, si le préfixe est connu, et reste constant au cours du programme, alors il faut utiliser un terme préfixé. 9 avril 2001

Les N-uplets (5) – Si on souhaite traiter le préfixe comme une variable, alors il faut coder l’expression par un n-uplet. • On a la définition récursive suivante. Toute formule est : – Soit une feuille. – Soit un doublet <non, P>, où P est une formule. – Soit un triplet <N, P, Q>, où N prend les valeurs et/ou, P et q étant à nouveau des formules. 9 avril 2001