Corrig exercice 1 de feuille de TD2

M1 Info AAC-TP 2008–2009
UFR d’IEEA – USTL
Correction Diviser pour Régner
Exercice 1 Recherche d’une valeur encadrée
//A4;
int m;
int g:=0;
int d:=n-1;
while (g <= d){
m:=(g+d)/2;
if (T[m] >= b) d:=m-1;
else if (T[m] <= a) g:=m+1;
else return true;
}
return false;
Preuve de correction partielle
Précondition et post-conditions
Pour prouver que l’algorithme est correct s’il termine, il faut d’abord déterminer les deux
post-conditions qui doivent être vérifiées si l’algorithme retourne true et s’il retourne false, et
établir une précondition que l’on peut déduire des données et des initialisations auxquelles on
procéde sur det g.
1. Pour qu’il soit correct de retourner true il faut prouver qu’il existe bien un indice itel que
a < T[i] < b, on défini donc :
Qt=∃i tq. a < T[i] < b
2. Pour qu’il soit correct de retourner false il faut prouver que toutes les cases du tableau
contiennent un entier soit supérieur ou égal à b, soit inférieur ou égale à a, on défini :
Qf=∀i∈0..n-1, T[i] leq a ou T[i] geq b
3. on défini finalement la post condition globale de l’algorithme : Q=Qtou Qf
Au début de l’algorithme on ne connaît que det g, la précondition va dépendre de ces deux
variables. Tout ce que l’on sait, c’est que g=0 et d=n-1, c’est-à-dire que gest l’indice de la
première case du tableau et dl’indice de la dernière case. On définit la précondition :
P=g=0 et d=n-1
Invariant de boucle
Pour prouver qu’une boucle effectue bien le calcul souhaité, il faut trouver un invariant I:
une assertion qui reste vraie quelle que soit l’itération de la boucle considérée.
Ici la boucle se termine soit par le cas où on retourne true et il faut prouver que Qtest vraie,
soit par le cas oùn on retourne false et il faut alors prouver Qf. On essaie donc de s’inspirer de
Qtet Qfpour orienté notre recherche de I.
Les deux post-conditions portent sur la relation entre les/une case du tableau et aet b, on
étudie un peu l’algorithme pour voir si on sait dire quelque chose qui impliquerait a,b,get det
pourrait être déduit de la précondition P. Comme le tableau est trié, on déduit de l’algorithme
que au début de chaque itération on doit avoir (il faut encore le prouver !) : ∀i < g, T[i] ≤
a et ∀j > d, T[j] ≥b, c’est ce qu’on prend pour invariant I.
1

Preuve partielle
//A4;
int m;
int g:=0;
int d:=n-1;
{P}
while (g <= d){
{I}
_
m:=(g+d)/2; |
if (T[m] >= b) d:=m-1; |
else if (T[m] <= a) g:=m+1; |
else | A
{Qt} |
|
return true; _|
}
{Qf}
return false;
En suivant ce qui est indiqué dans le cours, on doit prouver plusieurs choses pour arriver à la
conclusion PAlgorithme Q, c’est-à-dire que partant de P soit on trouve un indice qui marche,
soit on est certain qu’il n’y en a aucun.
Précondition →Invariant On doit commencer par vérifier : Pet (g ≤d)) ⇒I.
Comme get dsont respectivement la première et la dernière case du tableau, il n’y a aucune
case d’indice <g ou d’indice >d, donc l’invariant n’est pas faux : il est vrai.
Invariant →QfOn sort de la boucle lorsque g >d, mais l’invariant est (on le prouve juste
après) vrai. On doit déduire de tout celà que Qfest vraie, ie que Iet (g > d) ⇒Qf:
I=∀i < g, T[i] ≤a et ∀j > d, T[j] ≥b
donc, si g>d∀i∈0..n-1, T[i] ≤a ou T[i] ≥b, ce qui est exactement Qf.
Invariant →A→invariant On doit montrer que l’invariant de boucle reste vrai après avoir
executé le corps de la boucle (A) lorsque la condition d’arret du tant que n’est pas encore fausse.
Comme la partie A de l’algorithme a une structure conditionnelle on doit prouver trois choses :
1. {Iet (g ≤d) et (T[g+d
2]≥b)} d ←g+d 2−1{I}: comme le tableau est trié par
ordre croissant on peut déduire de (T[g+d
2]≥b) que ∀i≥g+d 2, T[i] ≥b, ainsi après
l’affectation d ←g+d
2−1on a ∀i>d, T[i] ≥b. La seconde moitié de Iconcernant g n’est
pas modifiée, donc Iest toujours vraie.
2. {Iet (g ≤d) et (T[g+d
2]<b) et (T[g+d 2]≤a)} g ←g+d 2+1 {I}: comme le ta-
bleau est trié par ordre croissant on peut déduire de (T[ g+d
2]≤a) que ∀i≤g+d 2, T[i]
≤a, ainsi après l’affectation g ←g+d
2+ 1 on a ∀i<g, T[i] ≤a. La seconde moitié de I
concernant d n’est pas modifiée, donc Iest toujours vraie.
2

3. {Iet (g ≤d) et (T[g+d
2]<b) et (T[g+d 2]>a)} ⇒{Qt}: on déduit directement
Qtde (T[g+d
2]<b) et (T[g+d 2]>a) : g+d 2est un indice du tableau (on peut le prouver en
alourdissant encore l’invariant avec (0≥g) et (d≥n-1), la condition (g≤d) et les affectations
effectuées font le reste) qui marche.
Conclusion : en partant de Pon arrive soit à Qtsoit à Qf, donc s’il termine l’algorithme est
correct.
3