Termes préfixés et N-uplets

Présentation au sujet: "Termes préfixés et N-uplets"— Transcription de la présentation:

1 Termes préfixés et N-uplets
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 9 avril 2001

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. 9 avril 2001

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 9 avril 2001

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. 9 avril 2001

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. 9 avril 2001

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). 9 avril 2001

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. 9 avril 2001

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 avril 2001

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). 9 avril 2001

10 Calcul booléen (5) Avec : Exercice : écrire les autres règles
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 9 avril 2001

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. 9 avril 2001

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 9 avril 2001

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). 9 avril 2001

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). 9 avril 2001

15 valeur-booleenne(P, 1), valeur-booleenne(Q, V),
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). 9 avril 2001

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). 9 avril 2001

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. 9 avril 2001

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é. 9 avril 2001

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. 9 avril 2001

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. 9 avril 2001

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). 9 avril 2001

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. 9 avril 2001

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

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. 9 avril 2001

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. 9 avril 2001

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

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). 9 avril 2001

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. 9 avril 2001

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 9 avril 2001

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. 9 avril 2001

31 Les N-uplets (3) N-uplets et termes préfixés 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

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é. 9 avril 2001

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. 9 avril 2001