Université Abdelmalek Essaâdi

Ecole Nationale des Sciences Appliquées

Al Hoceima

Chapitre 2: Preuve d’algorithmes

Plan du chapitre
I. Présentation
II. Preuve des algorithmes itératifs
III. Preuve des algorithmes récursifs

ENSAH Preuve d'algorithmes E.W. DADI – page : 2

I. Présentation
1. Validité d’un algorithme
Prouver un algorithme c’est de :
Vérifier qu’il se termine (preuve de terminaison) : l’algorithme
effectue un traitement qui nécessite un nombre fini d’opérations
élémentaires c’est-à-dire qu’il aboutit au résultat au bout d’un
nombre fini d’étapes.
Vérifier qu’il est correct (preuve de correction) : l’algorithme
fait bien ce qu’il est supposé faire dans sa spécification c’est-à-
dire qu’il produit toujours le bon résultat pour toutes les
instances du problème.

ENSAH Preuve d'algorithmes E.W. DADI – page : 3

2. Preuve de terminaison
La première qualité attendue d'un algorithme est bien sûr sa
terminaison, c’est-à-dire qu'il n'admette aucune instance pour
laquelle l’exécution rentre dans une boucle infinie.
Ce n’est pas toujours évident de prouver qu'un algorithme se
termine. Par exemple, la communauté scientifique n'a pas réussi à
prouver la terminaison de l'algorithme suivant :
Fonction Syracuse(n : Entier) : mot;
Début
Tant Que ( n  1) Faire
Si (N est pair ) Alors
n:=n/2;
Sinon
n:=3*n+1;
FinSi
FinTq
Retourner fini;
Fin

ENSAH Preuve d'algorithmes E.W. DADI – page : 4

…. la suite
Pour prouver la terminaison d’un algorithme, il n’y a pas de
méthodes exactes car dans la plupart des cas ça dépend de la
nature de l’algorithme :
Pour les algorithmes itératifs, on analyse généralement la
condition d’arrêt de la boucle pour déterminer est ce qu’il y
a une instruction permettant de changer (incrémentation/
décrémentation) cette condition pour arriver à un stade où
la boucle s’arrêtera.
Pour les algorithmes récursifs on procède par récurrence.
Pour prouver la terminaison d’une fonction récursive, il
faut montrer que la fonction parvient toujours au traitement
des cas de base en un nombre fini d’appels récursifs.

ENSAH Preuve d'algorithmes E.W. DADI – page : 5

3. Preuve de correction
Pour le cas des algorithmes itératifs, la méthode générale
consiste à utiliser une propriété, dite « invariant de boucle »
liant les éléments variables d’une boucle et qui reste vraie
quelque soit le nombre de passage dans celle-ci. Cette
propriété se démontre par récurrence.
Pour le cas des algorithmes récursifs, on doit déterminer la
fonction calculée par l’algorithme. Pour prouver que
l’algorithme est correct, on applique aussi la démonstration par
récurrence.

ENSAH Preuve d'algorithmes E.W. DADI – page : 6

II. Preuve des algorithmes itératifs
1. Exemple 1 « Boucle pour »
Preuve de l’algorithme itératif suivant :
Fonction Somme(N : Entier) : Entier;
Var i, S : Entier;
Début
1. S := 0; // Initialisation
2. Pour i allant de 1 jusqu'à N Faire // Progression
3. S := S + i; // Approximation
4. Fin
5. Retourner S;
Fin
Preuve de terminaison : L’instruction (1) se termine. La boucle
(Pour) sera exécutée N fois. Le corps de la boucle est formé de
l’instruction (3) qui est composée d’une somme et d’une affectation,
donc elle se termine. Par conséquent, l’algorithme se termine.

ENSAH Preuve d'algorithmes E.W. DADI – page : 7

…. la suite
Preuve de correction :
a. Trouver un invariant de boucle : On notera par « Sj » la valeur de la
variable « S » à la fin de l’itération « j ».
Les faits :
- S0 = 0; i0 = 1; Sj = Sj-1 + ij-1; pour j > 0
- ij = ij-1 + 1; pour j > 0 alors ij = j + 1; pour j >= 0.
D’après ce qui précède on déduit l’invariant de boucle :
Sj = 1 + 2 + … + j; pour j > 0.
b. Démonstration par récurrence :
j

Pour notre exemple, on considère la propriété : « P(j) : j  i » S 

i 0

Reste à vérifier que la propriété est vraie pour tout N≥0 :

Cas de base P(0): S0 = 0 (correspond à la phase d’initialisation). Donc
P(0) est vraie.
Cas récursifs : soit N ≥ 1 et supposons que la propriété P(N) est vraie.
Montrons qu’elle N
est vraie
N 1
pour N+1. D’après les faits on a
S N 1  S N  N  1   i  ( N  1)   i , ce qui vérifier que l’algorithme est correct
i 0 i 0

ENSAH Preuve d'algorithmes E.W. DADI – page : 8

2. Exemple 2 « Boucle tant que »
Preuve de l’algorithme itératif suivant :
Fonction F(n : Entier) : Entier;
Var x, y : Entier;
Début
x := n;
y := n;
Tantque (y  0) Faire
x := x + 2;
y := y - 1;
FinTq
Retourner x;
Fin

ENSAH Preuve d'algorithmes E.W. DADI – page : 9

…. la suite
Preuve de terminaison : La condition de continuation de la boucle «
Tant Que » est y ≠ 0. La valeur initiale de y est n ≥ 0. Après chaque
itération, la valeur de y décroît d’une unité jusqu’à devenir 0. À ce
moment, la boucle « Tant Que » se termine après avoir été exécutée
n fois. Par suite, l’algorithme se termine.
Preuve de correction :
a. Trouver un invariant de boucle :
Les faits : D’après les faits:
 xj = xj-1 + 2
 x0 = n;
= xj-2 + 2 + 2
 y0 = n; = x0 + 2j = n + 2j
 xj = xj-1 + 2; pour j > 0  yj = yj-1 – 1
 yj = yj-1 - 1; pour j > 0 = yj-2 – 1 – 1
= y0 – j = n – j
Déduire l’invariant de boucle :
 xj + 2yj = n + 2j + 2n – 2j = 3n
 Alors l’invariant de boucle est xj + 2yj = 3n

ENSAH Preuve d'algorithmes E.W. DADI – page : 10

…. la suite
b. Démonstration par récurrence : Définissons la propriété suivante : «
P (j) : xj + 2yj = 3n » où n est l’argument de l’algorithme, xj et yj les
contenues des variables x et y après l’itération j de la boucle.
Montrons qu’il s’agit bien d’un invariant de boucle.
Cas de bas : on a x0 + 2y0 = n+2n=3n. Donc la propriété P(0) est
vraie.
Cas récursifs : soit i ≥ 1 et supposons que la propriété P(i) est
vraie, c’est-à-dire que xj + 2yj = 3n . Montrons que P(i +1) est
vraie. À la fin de l’itération (i +1), on a : xj+1 + 2yj+1 = xj + 2 +
2yj – 2 = xj + 2yj = 3n
Ce qui prouve P(i +1) est vérifiée. L’invariant de boucle est alors
prouvé.
Après la terminaison de l’exécution de la boucle, on a : yn = 0, xn =
3n - 2yn = 3n, Donc, l’algorithme retourne 3n.

ENSAH Preuve d'algorithmes E.W. DADI – page : 11

II. Preuve des algorithmes récursifs
1. Récursivité simple
Pour montrer comment prouver un algorithme récursif simple, on va utiliser l’exemple de
calcule de factorielle :
Fonction Factorielle(n: entier) :Entier
Début
Si (n = 0) Alors Retourner 1 ;
Sinon Retourner Factorielle(n −1) * n;
FinSi
Fin
Preuve de terminaison :
Cas de base : l’appel de la fonction Factorielle avec le paramètre n = 0 retourne
directement 1 sans faire aucun appel récursif. Dans ce cas l’algorithme se termine
immédiatement.
Cas récursifs : soit n ≥ 1 un entier et supposons que l’appel de la fonction Factorielle
avec le paramètre n se termine c’est-à-dire Factorielle(n)=Factorielle(n-1)*n. L’appel de
la fonction Factorielle avec le paramètre (n+1) entraîne un appel récursif à Factorielle
avec le même argument n (Factorielle(n+1)=Factorielle(n)*(n+1)). Ce dernier appel se
termine par hypothèse. Le résultat sera obtenu après multiplication de Factorielle(n) par
n+1; il s’agit ici d’une opération élémentaire qui se termine, alors, l’appel de Factorielle
avec l’argument (n+1) se termine aussi. Par conséquent, l’algorithme se termine.

ENSAH Preuve d'algorithmes E.W. DADI – page : 12

…. la suite
Preuve de correction :
Pour ce faire, il faut savoir tout d’abord que calcule cet
algorithme pour un entier n donné en entrée.
Deux méthodes sont possibles pour cet algorithme:
Par le calcul des premières valeurs :
 Factorielle(0) = 1
 Factorielle(1) = Factorielle(0) * 1 = 1
 Factorielle(2) = Factorielle(1) * 2 = 2
 Factorielle(3) = Factorielle(2) * 3 = 1*2*3
 Factorielle(4) = Factorielle(3) * 4 = 1*2*3*4
 On peut faire la conjecture suivante : Factorielle(n) =n!
Par décomposition (itération) :
 Factorielle(n) = Factorielle(n −1)*n
= Factorielle(n −2)*(n −1)*n
= Factorielle(n −3)*(n −2)*(n −1)*n
= Factorielle (0)*… * (n −2)*(n −1)*n
= n!

ENSAH Preuve d'algorithmes E.W. DADI – page : 13

…. la suite
Il reste à prouver que l’algorithme calcule bien la factorielle pour tout n et
ceci en utilisant la démonstration par récurrence.
D’après l’algorithme on a :
 Factoriell e(0)  1

Factoriell en   Factoriell en  1 n, n  1
Montrons par récurrence pour tout entier naturel n on a :
Factorielle(n)=n!.
Cas de base : la propriété est vraie pour n = 0, car d’après
l’algorithme Factorielle(0)=1 = 0!.
Cas récursifs : soit n ≥ 1 et supposons que la propriété
Factorielle(n)=n! est vraie. Montrons qu’elle vraie pour n+1, c’est-
à-dire est ce que Factorielle(n+1)=(n+1)!
D’après l’algorithme on a : Factorielle(n+1) = Factorielle(n)*(n+1)
D’ après l’hypothèse on a Factorielle(n)= n!
Donc Factorielle(n+1) = (n+1)*n!=(n+1)! CQFD
Conclusion : l’algorithme est correct

ENSAH Preuve d'algorithmes E.W. DADI – page : 14

2. Récursivité multiple « simple »
Pour montrer comment prouver un algorithme récursif de type mutuelle,
on va utiliser l’exemple suivant :
Fonction F(n: entier) :Entier
Début
Si (n = 0) Alors Retourner 2 ;
Sinon Retourner F(n −1) * F(n −1) ;
FinSi
Fin
Preuve de terminaison :
Cas de base : l’appel de la fonction F avec le paramètre n = 0 retourne directement 2
sans faire aucun appel récursif. Dans ce cas l’algorithme se termine immédiatement.
Cas récursifs : soit n ≥ 1 un entier et supposons que l’appel de la fonction F avec le
paramètre n se termine c’est-à-dire F(n)=F(n-1)*F(n-1). L’appel de la fonction F avec le
paramètre (n+1) entraîne deux appels récursifs à F avec le même argument n
(F(n+1)=F(n)*F(n)). Ces deux derniers appels se terminent par hypothèse. Le résultat
sera obtenu après multiplication de ces deux appels et puisqu’il s’agit d’une opération
élémentaire qui se termine, alors, l’appel de F avec l’argument (n+1) se termine aussi.
Par conséquent, l’algorithme se termine.

ENSAH Preuve d'algorithmes E.W. DADI – page : 15

…. la suite
Preuve de correction :
Pour ce faire, il faut savoir tout d’abord que calcule cet
algorithme pour un entier n donné en entrée (déterminer le terme
général).
Deux méthodes sont possibles pour cet algorithme:
Par le calcul des premières valeurs (premiers termes):
 F(0) = 2
 F(1) = F(0) * F(0) = 22
 F(2) = F(1) * F(1) = 22 * 22 = 24
 F(3) = F(2) * F(2) = 24 * 24 = 28
On peut faire la conjecture suivante : F (n)  2 2
n

Par décomposition (itération) :
 F(n) = F(n −1)2
= (F(n −2)2)2
= ((F(n −3)2)2)2
 F (0)  2
2n 2n

ENSAH Preuve d'algorithmes E.W. DADI – page : 16

…. la suite
Il reste à prouver que l’algorithme calcule bien F n  22 pour
n

tout n et ceci en utilisant la démonstration par récurrence.

D’après l’algorithme on a :
 F (0)  2

 F n   F n  1  F n  1  F n  12
, n  1
Montrons par récurrence pour tout entier naturel n on a : F n  2 2n

Cas de base : la propriété est vraie pour n = 0, car F 0  22  2

0

Cas récursifs : soit n ≥ 1 et supposons que la propriété F n   2

n
2

est vraie. Montrons qu’elle vraie pour n+1.

D’ après l’algorithme on a : F n  1  F n F n  F n
2

Alors : F n  1  (2 )  2
2 n 2 2n1
2n 2
2
D’où, la propriété est vraie pour n+1.
Conclusion : l’algorithme est correct.

ENSAH Preuve d'algorithmes E.W. DADI – page : 17

3. Récursivité multiple « linéaire »
Ce n’est pas toujours évident de trouver que calcule un algorithme récursif.
Il y a des algorithmes pour lesquels les deux méthodes (par calcul des
premiers valeurs /par décomposition) ne peuvent pas fonctionner.
Parmi ces algorithmes on trouve ceux qui présente une récurrence dite de
type linéaire. Exemple: la suite de Fibonacci :
Fonction Fibo(n: entier) :Entier
Début
Si (n < 2) Alors Retourner n;
Sinon Retourner Fibo(n −1) + Fibo(n −2);
FinSi
Fin
L’algorithme calcule la suite de Fibonacci qui prend la forme d’une suite
récurrente linéaire d’ordre 2.
Généralement en mathématiques, on appelle suite récurrente linéaire
d’ordre p, toute suite qui prend la forme suivante :
un p  a0un  a1un1  ...  a p1un p1

ENSAH Preuve d'algorithmes E.W. DADI – page : 18

…. la suite
L'étude des suites récurrentes linéaires d'ordre supérieur se ramène à un
problème d'algèbre linéaire. L'expression du terme général d'une telle
suite est possible pour peu qu'on soit capable de factoriser un polynôme qui
lui est associé, appelé polynôme caractéristique ; le polynôme
caractéristique associé à une suite vérifiant la relation de récurrence ci-
dessus est : p 1
P( x)  x   ai x  x  a p 1 x
p i p p 1
 ...  a1 x  a0
i 0
Le terme général d’une telle suite est :
U n  AnU 0
A est la matrice compagnon du polynôme caractéristique de la suite. Son
degré est ainsi égal à l'ordre de la relation de récurrence. En particulier,
dans le cas des suites d'ordre 2 (exemple suite de Fibonacci), le polynôme
est de degré 2 et peut donc être factorisé à l'aide d'un calcul de discriminant
(Delta=b2-ac).
Pour ce genre de suite : u au a u
n 2 1 n 1 0 n

dont le polynôme caractéristique est : P(x)=X2-a1X- a0.

ENSAH Preuve d'algorithmes E.W. DADI – page : 19

 ,
…. la suite
Soit f la fonction calculée par une suite d’ordre 2; son terme
général est donné comme suit :
f(n)= λrn1+ βrn2 , si r1 et r2 sont deux racines distinctes de P
f(n)= (λ+ βn)rn0, si r0 est un racine double de P
La détermination de(s) un/deux racine(s) r0 ( r1 et r2 )se fait
en calculant le discriminant (Delta).
Les réels λ et β peuvent être déterminés à partir de la
valeur de u0 et u1. Pour deux racines on les détermine par la
résolution du système suivant :
    u 0

r1  r2  u1

ENSAH Preuve d'algorithmes E.W. DADI – page : 20

 ,
…. la suite
Application sur la suite de Fibonacci :
On a 𝑓𝑖𝑏 𝑛 + 2 = 𝑓𝑖𝑏𝑜 𝑛 + 1 + 𝑓𝑖𝑏𝑜 𝑛
Son polynôme caractéristique est donné comme suit : 𝑃 𝑥 = 𝑥 2 − 𝑥 − 1
La résolution de cette équation de deux second de degré est :
Delta =5>0, alors :
1+ 5 1− 5
𝑟1 = , 𝑟2 =
2 2
Le terme général de la suite de Fibonacci est alors donné par :
𝑛 𝑛
1+ 5 1− 5
𝑓𝑖𝑏𝑜 𝑛 = 𝜆 +𝛽
2 2
Le calcul de 𝜆 𝑒𝑡 𝛽, se fait en utilisant les deux premiers termes de Fibonacci, cela consiste à résoudre
le système suivant :
0 = 𝑓𝑖𝑏𝑜 0 = 𝜆 + 𝛽
On a , 1+ 5 1− 5
1 = 𝑓𝑖𝑏𝑜 1 = 𝜆 +𝛽
2 2

1 1
𝜆= , 𝛽=−
5 5
Donc ∀𝑛 ∈ 𝑁,
𝒏 𝒏
𝟏 𝟏+ 𝟓 𝟏− 𝟓
𝒇𝒊𝒃𝒐 𝒏 = −
𝟓 𝟐 𝟐

ENSAH Preuve d'algorithmes E.W. DADI – page : 21