Termes prfixs et Nuplets

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 dun 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 à laide 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
  lautre

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 darguments 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
  sagir dune variable.

6
Calcul booléen (1)

• Illustration de lutilisation 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 dune formule.
• Nous allons travailler sur lexemple
• et(ou(0, non(1)), et(1, non(0)))
• Exercice représenter larbre 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 larbre
  représentatif
• les nuds 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 ny 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
  lavons traitée sur les listes.
• Exercice écrire larbre de recherche associé à
  la formule exemple.

12
Calcul booléen (7)

• Améliorations du programme
• Nest-il pas possible darranger 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 nest
  donc pas nécessaire d'évaluer Q. Doù 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
• Lamélioration 1 na rien apportée car si P vaut
  0, S1 sapplique, 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 laspect déclaratif du
  programme en introduisant un contrôle sur
  lexé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 na pas progressé car P est toujours évalué 2
  fois. Le programme est toujours inefficace. Cest
  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
  leffacement
• Les règles dun programme constituent un ensemble
  de définitions.
• Un but qui sefface 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 nest autre quun
  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 den donner les
  règles correspondantes.

21
La négation (3)

• Autre formulation du programme
• La valeur booléenne dune 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 sefface 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 quune
  formule vraie ait successivement la valeur 1 puis
  0, lors de la remontée.
• Considérons ce qui peut arriver lorsque lon
  cherche à effacer une formule
• (a) et(P, Q) est vrai (sefface), 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 seffacer. 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.

24
La négation (6)

• (d) P est la feuille 0. Alors P ne doit jamais
  seffacer 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 sefface, et, si cette
  équivalence est réelle pour et et ou, nous allons
  voir quil nen 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 nimporte
  quel terme P, dans nimporte quel programme
  Prolog.
• impasse nest pas un mot réservé ni un prédicat
  prédéfini de Prolog. Cest un terme impossible à
  effacer car napparaissant 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
  lun aléatoire, avec la tentative deffacement de
  P, et lautre certain, avec la tentative
  deffacement dimpasse. Par contre il ny a aucun
  échec possible sur R2. Cette règle effacera
  non(P) à chaque fois quelle sera utilisée.
• Conclusion les deux règles données provoquent,
  relativement à leffacement, 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 nuds ne sont pas seulement des
   . , mais des identificateurs. Nous allons
  maintenant voir des arbres dont les nuds peuvent
  être des variables, et plus seulement des
  identificateurs.

29
Les N-uplets (1)

• N-uplets et suites finies
• Nous avons vus quune 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 lt X1, X2, , Xngt, auquel on
  associe larbre

lt , , gt
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 lavons vu, a une longueur variable.
• (b) Le codage interne dun n-uplet est beaucoup
  plus économique que celui dune liste. Il occupe
  deux fois moins de place.

31
Les N-uplets (3)

• Conseils
• Si lon 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 lexpression par un
  n-uplet.
• On a la définition récursive suivante. Toute
  formule est
• Soit une feuille.
• Soit un doublet ltnon, Pgt, où P est une formule.
• Soit un triplet ltN, P, Qgt, où N prend les valeurs
  et/ou, P et q étant à nouveau des formules.