Vous êtes sur la page 1sur 52

Université de SOUK AHRAS

Faculté des sciences et technologie


Département de Mathématiques et Informatique

Programmation
Logique
Enseignant: Arous Mokdad
Niveau: 3eme Année Informatique
2016/2017
 Termes préfixés et N-uplets
1. Termes préfixés
 Termes préfixés
 Codage

 Exemple du calcul booléen


1.1. Codage des termes préfixés
 Donnons-nous une suite de propositions : P, Q,
R, …
 Si on les relie à l’aide de connecteurs et, ou,
non, on obtient des formules de logiques.
 Ces formules sont de la forme :
 P et Q, P ou Q, non P, …
1.1. Codage des termes préfixés
 On peut alors construire :
 (P et Q) ou (R et S)
 P et (Q ou (R et non(S)))

 Notation Infixée
1. 1. Codage des termes préfixés
 Les notations infixée, préfixée et postfixée sont
des formes d'écritures d'expressions
algébriques.
 Elles se distinguent par la position relative qu'y
prennent les opérateurs et leurs opérandes.

 E1 op E2 : notation infixée.
 op E1 E2 : notation préfixée (notation polonaise).
 E1 E2 op : notation postfixée (notation polonaise
inversée).
1. 1. Codage des termes préfixés
 Notation infixée :
 (P et Q) ou (R et S)
 P et (Q ou (R et non(S)))
 en notation préfixée (préférable)
 (P et Q) ou (R et S)
 ou (et (P, Q), et(R, S))
 P et (Q ou (R et non(S)))
 ???
 ((1 + 2) × 4) + 3
 ???
1. 1. Codage des termes préfixés
 Ces formules peuvent être représentées par
des arbres.

 Ces structures sont appelées des termes


préfixés.
1. 2. Calcul booléen
 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).
1. 2. Calcul booléen
 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)))

 représenter l’arbre associé à cette formule.


1. 2. Calcul booléen
 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
1. 2. Calcul booléen
 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).
1. 2. Calcul booléen
 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
1. 2. Calcul booléen
 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.

 Exercice : écrire l’arbre de recherche associé à la


formule exemple.
et(ou(0, non(1)), et(1, non(0)))
1. 2. Calcul booléen
 Améliorations du programme :
 N’est-il pas possible d’arranger les règles ?
remarque sur le et(0, _) et
 1)

modification de valeur-booleenne
 2) adaptation du raisonnement à ou
 3) introduction de coupure
1. 2. Calcul booléen
Exercice : En considérant le programme après
amélioration, donner l’arbre de recherche
associé à la formule :

et(ou(0, non(1)), et(1, non(0)))


2. Les N-uplets
2. Les N-uplets
 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
 Les éléments de la suite sont les arguments du N-
uplet.
2. Les N-uplets
?- (X,C,V)=(a,d,f).
X = a,
C = d,
V = f.

?- X=(a,d,f).
X = (a, d, f).
2. Les N-uplets
 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.
2. Les N-uplets
 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.
2. Les N-uplets
 On a donc 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.
Exemple: ou (P , et (R, S))
 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 -.
Exemple: (ou , P , (et , R, S))
(* , (+ , 5, 1) , 2)
2. Les N-uplets
Exemple:
?- (X, A, B) = (ou , P , (et , R, S)).
X = ou,
A = P,
B = (et, R, S).

?- (* , (+ , 5, 1) , 2) = (Op , A , B).
Op = (*),
A = ((+), 5, 1),
B = 2.
2. Les N-uplets
 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.
 Manipulation des arbres
3. Arbres en Prolog
À QUOI SERVENT LES ARBRES ?

 Les arbres, comme les listes, permettent de


représenter un nombre variable de données.

 Le principal avantage des arbres par rapport aux


listes est qu’ils permettent de ranger les données
de telle sorte que les recherches soient plus
efficaces.
3. Arbres en Prolog
DÉFINITION
 Un arbre est soit un nœud, soit un arbre vide
 Un nœud a des fils qui sont eux aussi des arbres
 Si tous les fils d’un nœud sont vides, alors le
nœud est qualifié de feuille
 Les nœuds portent des valeurs, ce sont les
données que l’on veut stocker
 Si tous les nœuds de l’arbre ont n fils, alors
l’arbre est dit n-aire
3. Arbres en Prolog
EXEMPLE D’ARBRE
3. Arbres en Prolog
ARBRES BINAIRES

Un arbre binaire est :

 soit l’arbre vide.

 soit un nœud qui a exactement deux fils


(éventuellement vides).
3. Arbres en Prolog
REPRÉSENTATION DES ARBRES BINAIRES
 Comment représenter un arbre ? ? ?
3. Arbres en Prolog
REPRÉSENTATION DES ARBRES BINAIRES
 Nous choisissons d’utiliser les listes pour
représenter les arbres.

 Un arbre vide sera représenté par la liste vide [].


 Un nœud sera une liste de 3 éléments:
 le premier est sa valeur.
 le deuxième son fils gauche.
 le troisième son fils droit.
3. Arbres en Prolog
Exemple de représentation d’un arbre binaire :
3. Arbres en Prolog
EXERCICE

Définir un prédicat qui vérifie qu’une liste


représente bien un arbre binaire.
3. Arbres en Prolog
PARCOURS D’ARBRES

 Un arbre contient un ensemble de données

 Pour utiliser ces données, il faut parcourir


l’arbre: en profondeur ou en largeur
3. Arbres en Prolog
 PARCOURS EN LARGEUR
3. Arbres en Prolog
 PARCOURS EN PROFONDEUR
3. Arbres en Prolog
PARCOURS EN PROFONDEUR : Principe

 Parcourir un arbre en profondeur consiste à


passer ses nœuds en revue, en commençant
toujours par le même fils, et en descendant le
plus profondément possible dans l’arbre.

 Lorsque l’on arrive sur un arbre vide, on remonte


jusqu’au nœud supérieur et on redescend dans
le fils encore inexploré.
3. Arbres en Prolog
EFFECTUE UN PARCOURS EN PROFONDEUR:

 Pour écrire un prédicat P sur un arbre A:


 Si A est vide, on retourne une valeur constante.
 Si A n’est pas vide :
 on rappelle P sur les deux fils de A, ce qui
retourne deux résultats : Rg et Rd
 puis on retourne un résultat qui ne dépend
que de Rg, Rd et de la valeur de A
3. Arbres en Prolog
EXEMPLE :
SOMME DES VALEURS D’UN ARBRE DE NOMBRES
3. Arbres en Prolog
EXEMPLE :
SOMME DES VALEURS D’UN ARBRE DE NOMBRES

somme([],0).

somme([N,G,D],M) :- somme(G,N1),
somme(D,N2), M is N+N1+N2.
3. Arbres en Prolog
EXEMPLE :
FONCTIONNEMENT SUR UN EXEMPLE
3. Arbres en Prolog
MODIFICATION ET CRÉATION D’ARBRES

• Exemple : écrire un prédicat qui ajoute 1 à tous


les nœuds d’un arbre qui contient des nombres.

• Il ne s’agit pas d’une modification (ajouter 1),


mais d’une création : écrire un prédicat qui
construit un arbre identique à celui donné, mais
dans lequel on a ajouté 1 à tous les nœuds.
3. Arbres en Prolog
PRÉDICAT AJOUTE1
3. Arbres en Prolog
PRÉDICAT AJOUTE1

ajoute1([],[]).

ajoute1([N,G,D],[N1,G1,D1]) :- N1 is N+1,
ajoute1(G,G1), ajoute1(D,D1).
3. Arbres en Prolog
EXERCICES
SOMME DES VALEURS DES FILS
3. Arbres en Prolog
PRÉDICAT SOMME-FILS
3. Arbres en Prolog
PRÉDICAT SOMME-FILS
som_fils([] , []).

som_fils([ N, [] , [] ] , [ N, [] , [] ]).

som_fils([ N, G , [] ] , [ N1 , [ G1, GG, GD ] , [] ]) :- som_fils( G , [ G1 , GG , GD ]),


N1 is N+G1.

som_fils([ N , [] , D ] , [ N1, [] , [ D1, DG, DD ] ]) :- som_fils( D , [ D1, DG, DD ] ),


N1 is N+D1.

som_fils([N, G, D] , [N1, [G1, GG, GD] , [D1, DG, DD ] ]) :- som_fils(G, [G1,GG,GD ] ),


som_fils(D, [D1, DG, DD]), N1 is N+G1+D1.
3. Arbres en Prolog
EXERCICES
SOMME DES VALEURS DES PÈRES
3. Arbres en Prolog
CALCUL EN REMONTANT OU EN DESCENDANT

 Dans tous les prédicats précédemment écrits, le


résultat dépendait des fils :
⇒ calcul en remontant.
 Ici, le résultat dépend du père:
⇒ calcul en descendant.
⇒ paramètre supplémentaire pour passer le
résultat du père au fils.
3. Arbres en Prolog
PRÉDICAT SOM_PERE

som_pere(A,A1) :- som_pere2(A,0,A1).

som_pere2([],_,[]).

som_pere2([N,G,D], V, [N1,G1,D1]) :- N1 is N+V,


som_pere2(G, N1, G1), som_pere2(D, N1, D1).
3. Arbres en Prolog
EXERCICES
1) Définir un prédicat qui calcule la hauteur d’un
arbre binaire :
• La hauteur d’une feuille est zéro.
• La hauteur d’un nœud est :
1+max(hauteur_fils_gauche, hauteur_fils_droit)

2) Définir un prédicat qui calcule le maximum d’un


arbre binaire de nombres.
3. Arbres en Prolog
EXERCICES
3) Tester l’appartenance d’un élément dans un
arbre binaire.

4) Définir un prédicat qui calcule la liste résultant


du parcours infixe d'un arbre binaire.

5) Définir un prédicat qui calcule la liste résultant


du parcours préfixe d'un arbre binaire.

Vous aimerez peut-être aussi