Termes préfixés et N-uplets

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

2. 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.

3. 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

4. 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.

5. 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.

6. 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).

7. 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.

8. 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. Calcul booléen (4) • Règles relatives aux feuilles : • R1: valeur-booleenne(0, 0). • R2: valeur-booleenne(1, 1). • Examinons les regles relatives à une formule et(P, Q) : • R3: valeur-booleenne(et(P, Q), B) :- valeur-booleenne(P, U), valeur-booleenne(Q, V), combiner-et(U, V, B).

10. Calcul booléen (5) • Avec : • R6: combiner-et(1, 1, 1). • R7: combiner-et(1, 0, 0). • R8: combiner-et(0, 1, 0). • R9: combiner-et(0, 0, 0). • Exercice : écrire les autres règles • R4: valeur-booleenne(ou(P, Q), B) • R5 : valeur-booleenne(non(P), B) • R10 à R15 : règles combiner-ou et combiner-non

11. 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. • R3, R4, et R5 sont des règles récursives. R1 et R2 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.

12. 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 valeur-booleenne • 2) introduction de coupure • 3) comment supprimer la coupure ? • 4) introduction de poursuivre-et • 5) simplification des règles • 6) adaptation du raisonnement à ou

13. 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 : • S1: valeur-booleenne(et(P, Q), 0) :- valeur-booleenne(P, 0). • S2: valeur-booleenne(et(P, Q), B) :- valeur-booleenne(P, U), valeur-booleenne(Q, V), combiner-et(U, V, B).

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

15. 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 S2 aux cas où P est vraie. • S1: valeur-booleenne(et(P, Q), 0) :- valeur-booleenne(P, 0). • S2: valeur-booleenne(et(P, Q), B) :- valeur-booleenne(P, 1), valeur-booleenne(Q, V), combiner-et(1, V, B).

16. 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 S1 la source du problème. • S1: valeur-booleenne(et(P, Q), B) :- valeur-booleenne(P, U), poursuivre-et(U, Q, B). • S2: poursuivre-et(0, Q, 0). • S3: poursuivre-et(1, Q, B):- valeur-booleenne(Q, V), combiner-et(1, V, B).

17. Calcul booléen (12) • Amélioration 5: • La règle S2 prend en compte le cas où la valeur booléenne de P est nulle. On peut donc supprimer des déclarations dans combiner-et. 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.

18. 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é.

19. 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.

20. 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.

21. 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).

22. 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.

23. 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 quiest 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.

24. 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.

25. 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.

26. La négation (8) • Règles de la négation : • R1: non(P) :- P ! impasse. • R2: 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.

27. La négation (9) • On trouve alors dans R1 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 R2. 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).

28. 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.

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

30. Les N-uplets (2) • Les éléments de la suite sont les arguments du N-uplet. • 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 que celui d’une liste. Il occupe deux fois moins de place.

31. 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.

32. 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é.

33. 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.