while,d - g qui décroîtwhile x > 0: x -= 1, c'estx lui-même.]]>for i in
range(len(liste)), quel est l'invariant ài ?]]>liste[:i] (déjà parcourus)]]>i, on a déjà testé les indices 0 à i-1 etreturn.]]>for i in range(n):, est-ilfor plutôt quewhile pour éviter de devoir prouver lafor sur un itérateur fini termine seul]]>for sur un range finifor sur unsomme = 0
for x in liste:
somme += xsomme garde la valeur 0 tant que la boucle tourne]]>somme est modifiée à chaque toursomme += x ; elle ne reste nulle que sisomme est strictement positive à chaque itération]]>somme peut donc êtresomme vaut le premier élément liste[0] de la liste]]>somme vaut la somme des k premiers éléments]]>somme contient la somme des kn = 10
while n > 0:
n -= 1n lui-même]]>n est un entier ≥ 0 quin -= 1 à chaque10 - n]]>10 - n croît de 0 à 10 aun > 0]]>i = 0
while i < 10:
print(i)i <= 10 et non i < 10]]>i <= 10, la boucle ne terminerait pasi ne change jamais.]]>i n'est jamais modifié : il n'y a pas de variant qui décroît]]>i < 10 restei += 1print(i) modifie la valeur de i à chaque tour]]>print se contente d'afficher soni quei < 10 n'est testée qu'une seule fois, au départ]]>while esti vaut toujours 0.]]>m = liste[0]
for x in liste[1:]:
if x < m:
m = xmm vaut toujours le premier élément liste[0]]]>m est mis à jour dès qu'unm vaut le dernier élément examiné par la boucle]]>m ne prend la valeur de l'élémentm est le minimum des k premiers éléments parcourus]]>m si l'élément courant est plusm vaut le minimum de la liste entière dès le premier tour]]>d - g + 1 de l'intervalle]]>def f(n):
while n != 1:
if n % 2 == 0:
n = n // 2
else:
n = 3 * n + 1n = 3n + 1 augmente n. Il n'yicontract), mais ce n'est pas lac = 0
for i in range(len(liste)):
if liste[i] == cible:
c = c + 1i, avant le test liste[i] == cible ?]]>c représente pourliste[:i]. À lai = len(liste)), il donne lac est le nombre d'occurrencesc est le nombre d'occurrences de cible dans liste[:i]]]>i, seuls lesi premiers éléments ont été examinés, etc a été incrémenté une fois par occurrenceliste = [3, 7, 3, 3] etcible = 3, c vaut 0, 1, 1, 2 à l'entréec est le nombre d'occurrences de cible dans toute la liste]]>c vaut 0 alors que[3, 7, 3, 3] contient trois fois lac vaut i, le nombre de tours déjà effectués]]>c ne compte que les tours où le[3, 7, 3, 3] aveccible = 3, à l'entrée du tour 2 on ai = 2 mais c = 1.]]>c est le nombre d'éléments de liste[:i] différents de cible]]>[3, 7, 3, 3] avec cible = 3, c vaut 1g (l'indice de gauche) seul comme variant ?]]>n - i) comme variant.g peut rester constant si c'estd qui change.]]>g n'est pas vraiment un entier]]>g est bien un entier.]]>g ne décroît pas (il augmente)]]>g qui augmente, iln - g ou biend - g.]]>assert sont une excellente pratique :# TODO placé dans la boucle]]>assert de l'invariant dans la boucle]]>assert m == min(liste[:i+1]). SiAssertionError et indique le bug.]]>print() qui signale automatiquement l'invariant faux]]>print affiche une valeur sans laliste[0..k-1] (en Python : liste[:k]) estliste[k..n-1]liste[k:]). Les deuxliste[0] et leliste[1], ce serait « trié »liste[0..k-1] (en Python :liste[:k]) triés mais contenant deswhile a > b:
a = a - ba, b entiers, b > 0). Quel est una mod b (reste de laa]]>a -= bb > 0, donc a décroît strictement,a > b > 0). Laa <= b.]]>b]]>b ne change pas dans la boucle,b - a]]>a > bb - a est strictement négatif, etP(k) à prouver par récurrence sur k.]]>r = 0
n = N
while n > 0:
n = n // 2
r = r + 1n est divisé par 2, pasr reste égal à 0 pendant toute la boucle]]>r = r + 1 l'incrémente à chaquen == N // 2^r ; r compte les tours]]>n (qui décroîtn ne devenant jamais nul]]>n // 2 ramène n à 0 en log₂(N)for i in range(n) se termine, sans qu'on ait besoin de prouver de variant]]>for sur un itérateuri de la boucle externe, quel invariantliste[:i+1] contient les mêmes éléments, mais triés]]>i + 1 premiersi = n - 1, toute la liste est triée.]]>i,i + 1 premiers éléments sonti premiers éléments sont les plus grands]]>i premiers éléments sont triés et plus petits que tous les autres]]>i-ème élément à sadef pgcd(a, b):
while b != 0:
a, b = b, a % b
return aa, b entiers naturels, b > 0 àpgcd(a, b) = pgcd(a₀, b₀) (la valeurb. À la sortie, l'invariantpgcd(a, 0) = a, ce qui est bien leb]]>ba % b, qui est strictementb. Comme b est un0, la suite desb est strictement décroissantepgcd(a, b) restea + b]]>pgcd(5, 12) : avant, a + b = 17 ;a + b = 12 + 5 = 17. Donc pas dea]]>a ne décroît pas forcément àa = 5,b = 12, après une itération on aa = 12, b = 5, donc a a augmenté.]]># vérification de l'invariant]]>assert exprimant l'invariant attendu]]>assert lèveAssertionError si lapython -O) en production.]]>assert vérifiant que le variant décroît à chaque tour]]>print affichant la valeur courante de la variable]]>