Preuves d`algorithmes
Première partie
Cours
Lorsqu’on veut prouver qu’un algorithme fonctionne, on sépare souvent en deux étapes : d’abord vérifier que
l’algorithme se termine, puis que le résultat donné est le bon.
1 Terminaison d’une boucle
Dans les structures de programmation rencontrées jusqu’ici, la seule pouvant poser un problème de terminaison
est la boucle "tant que". Nous allons voir ici la méthode la plus fréquente pour démontrer qu’une boucle "tant que" se
termine.
1.1 Boucle pour
A priori une boucle "pour" pourrait planter si on modifiait l’indice de la boucle. Exemple :
pour ide1à10:
i←i−1
fin
C’est pourquoi nous adoptons le principe : Dans une boucle "pour", ne jamais faire varier l’indice de la boucle.
Si vous voulez contrôler vous-même l’indice, faites une boucle "tant que" !
Remarque: Essayez donc l’algo ci-dessus en python... Le résultat est assez surprenant. En fait, python calcule à
l’avance (dès qu’il voit la boucle "for") les valeurs que devra prendre i. Donc sur cet exemple [1,2,3,4,5,6,7,8,9,10].
C’est ailleurs assez clair vue la syntaxe utilisée : "for i in range(1,11)" est traduit par "for i in [1,2,3,4,5,6,7,8,9,10]".
Puis il fait avancer idans cette liste de valeurs, indépendamment de ce qui a pu arriver à ipendant la boucle.
D’autre langages, comme caml, interdisent purement et simplement de modifier l’indice de la boucle.
1.2 Boucle "tant que"
Le théorème principal pour montrer la terminaison d’une boucle "tant que" est celui-ci :
Théorème 1.1. Il n’existe pas de suite u ∈NNqui soit strictement décroissante.
Plus généralement il n’existe pas d’ensemble I ∈ P(N)infini et de suite u ∈NIstrictement décroissante.
Démonstration: Supposons par l’absurde l’existence d’un tel Iet d’une telle suite u. L’ensemble des valeurs prise par u(i.e.
u(I)i.e. {{|u}n;n∈I}) est un ensemble d’entier naturel, et non vide. Il admet donc un minimum, que nous notons m.
Par définition d’un minimum, mest atteint par u. Soit n0∈Itel que un0=m. Soit ensuite n∈Itel que n>n0(existe car Iest
infini). Alors un<un0car uest strictement décroissante. Ceci contredit le fait que mest le minimum de u!
Autrement dit, pour une suite u, la conjonction des propriétés suivantes est impossible :
—uest définie sur un ensemble infini
—uest à valeur dans N
—uest strictement décroissante.
Dit autrement, si uest une suite d’entier naturels, strictement décroissante, alors elle n’est pas définie sur un en-
semble infini, autrement dit elle s’arrête au bout d’un nombre fini de termes.
Dès lors, une méthode classique pour démontrer la terminaison d’une boucle "tant que" est la suivante : trouver
une quantité entière positive qui diminue strictement à chaque itération de la boucle. Vu le théorème ci-dessus, une
2
telle quantité ne peut pas continue à décroître strictement une infinité de fois, donc la boucle ne peut pas continuer à
s’exécuter une infinité de fois.
Exemple: tri dichotomique
Remarque: En cours, nous avons étudié la complexité avant la preuve de terminaison d’algorithme, pour la simple
raison que le calcul de complexité est souvent plus facile. Mais dans un exemple pratique, on va en générale commen-
cer par prouver la terminaison de l’algorithme, ce qui nous permettra de commencer à évaluer le nombre d’itération
effectué dans la (ou les) boucle(s), ce qui sera utile dans le calcul de complexité.
Exemple: Algorithme d’Euclide.
Entrées : a,b entier, tel que b,0
Sorties :a∧b, le pgcd de aet b
Variables : x,y entiers
début
x←a
y←b
tant que b,0:
x←y
x←reste de la division euclidienne de xpar y.
fin
renvoyer x
fin
Algorithme 1 : algorithme d’Euclide
Remarque: En python le reste de la division euclidienne de xpar ys’obtient ainsi : x%y.
Ici, nous prenons comme suite la suite des valeurs successives de y.
— Ce sont des nombres entiers.
— Une fois la première itération de la boucle passée, ycontient un nombre positif. En effet, le reste d’une division
euclidienne est un entier positif.
— Enfin, on sait que le reste d’une division euclidienne par yest <|y|. À partir de la deuxième itération, |y|=y, et
on obtient donc que la nouvelle valeur de yest <y.
Ainsi, la suite des valeurs prises par yvérifie les trois hypothèses : c’est une suite d’entiers positifs, strictement
décroissante. Elle ne peut donc pas prendre une infinité de valeurs, et la boucle ne peut pas s’effectuer une infinité de
fois.
2 Correction d’un algorithme
("correction" signifiant ici "le fait d’être correct", et pas "l’action de corriger".)
Quelques remarques générales : la preuve de la correction d’un algorithme peut être très compliquée. On ne la
demande généralement aux concours que pour les cas où une preuve simple est possible. Il est même fréquent qu’on
ne demande que la preuve de l’arrêt de la boucle, et pas de sa correction.
Quand l’algorithme est basé sur une boucle "pour", une simple récurrence est envisageable. Là encore, le problème
est surtout intéressant dans un algorithme basé sur une boucle "tant que". (Un algorithme contenant deux boucles sera
généralement considéré comme trop compliqué !)
Une méthode classique est de déterminer un "invariant de boucle" i.e. une quantité qui ne varie pas lors de l’exé-
cution de la boucle. Ainsi, elle sera la même à l’issue de la boucle qu’à l’entrée.
3
Remarque: "une quantité" est une expression un peu vague. Cela peut être un nombre entier, mais aussi un booléen
par exemple "x+y=z" (si x,y,zsont trois variables de l’algorithme).
Reprenons l’exemple de l’algorithme d’Euclide. Pour tout (a,b)∈Z2\ {(0,0)}, on notera a∧ble pgcd de aet b.
L’algorithme d’Euclide est basé sur les deux résultats suivants (vus en spécialité math en terminale, et pour tout le
monde dans le chapitre d’arithmétique du cours de math de MPSI)
Proposition 2.1. Soit a ∈Z∗. Alors a ∧0=a.
Proposition 2.2. Soit (a,b,q,r)∈Z4tels que a =b.q+r. Alors :
a∧b=b∧r.
Rappel de l’algorithme :
Entrées : a,b entier, tel que b,0
Sorties :a∧b, le pgcd de aet b
Variables : x,y entiers
début
x←a
y←b
tant que b,0:
x←y
x←reste de la division euclidienne de xpar y.
fin
renvoyer x
fin
Algorithme 2 : algorithme d’Euclide
Fixons (a,b)∈Z2tel que b,0, et démontrons à présent que l’algorithme d’Euclide appliquer à aet brenvoie
bien a∧b.
Nous allons démontrer que la quantité x∧yest un invariant de boucle. Autrement dit qu’à chaque itération de la
boucle, cette quantité est préservée :
Pour tout ninférieur au nombre d’itérations effectuées, notons xn,ynle contenu des variables xet y. Notons
également qn,rnquotient et reste de la division euclidienne de xnpar yn.
Pour tout n, on a alors :
xn+1=yn
yn+1=rn
xn=qn.yn+rn
D’après la proposition 2, on a xn∧yn=yn∧rn. Ce qui donne précisément que xn+1∧yn+1=xn∧yn.
En conclusion, la suite (xn∧yn)nest constante.
Ainsi, la quantité x∧yest la même avant la boucle "tant que" qu’après.
— Avant la boucle, elle vaut a∧b.
— A l’issue de la boucle, on a y≤0 (la condition du "tant que" n’étant plus vérifiée), mais aussi y≥0 car un
reste de division euclidienne est toujours ≥0. Donc y=0. Donc x∧y=x∧0=xpar la proposition 1.
Donc à l’issue de la boucle, x=a∧b. Comme on renvoie x, on a bien renvoyé le bon résultat.
4
1
/
4
100%
