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 ?]]>i]]>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 range fini termine seul]]>for sur un range finifor sur unrange ou une liste.]]>somme = 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 i in range(1, len(liste)):
if liste[i] < m:
m = liste[i]mm 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 + 1Que peut-on affirmer sur la terminaison de cette boucle pour tout
entier $n \geq 1$ ?
3 * n + 1 fait augmenter $n$]]>3 * n + 1, le nombre obtenu est pair et le tour suivantassert) peuvent vérifier cesc = 0
for i in range(len(liste)):
if liste[i] == cible:
c = c + 1i, avant le test liste[i] == cible ?]]>c représente pouri. À la sortiei = len(liste)), il donne la postcondition :c est le nombre d'occurrences dans toute lac est le nombre d'occurrences de cible avant l'indice 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 différents de cible avant l'indice i]]>[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] et leliste[1], ce serait « trié »while 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, ett :
def indice_min(t):
assert len(t) > 0
k = 0
for i in range(1, len(t)):
if t[i] < t[k]:
k = i
return kOn veut vérifier, juste avant return k, la
postcondition « t[k] est inférieur ou égal à
chacun des éléments de t ». Quelles lignes
conviennent ?
assert len(t) > 0 en début de fonction,for j in range(len(t)):
assert t[k] < t[j]]]>j égal à k, t[k] < t[k]assert t[k] <= t[i]]]>i vaut let[k] qu'au dernier élément. Pour une listei n'est même pas définifor j in range(len(t)):
assert t[k] <= t[j]]]>t[k] àj vautk, ainsi que les minimums en double.]]>assert 0 <= k and k < len(t)]]>k est un indice valide. Elle resteraitr = 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 range finii 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 laassert vérifiant que le variant décroît à chaque tour]]>print affichant la valeur courante de la variable]]>assert s'avère fausse. Que se passe-t-il ?]]>assert condition vérifie une hypothèse à un instant précis deAssertionError, ce qui évite qu'une erreur se propage en silence.]]>AssertionError]]>AssertionError.]]>False et l'exécution se poursuit]]>assert ne renvoie aucune valeur. Une condition faussedef inverse(x):
return 1 / xassert x != 0]]>0, l'assertion arrête leassert x > 0]]>assert 1 / x != 0]]>1 / x. Avec x égal à 0, la division échoue avant même queassert x == 0]]>trier(t) doit réordonner la liste t par ordrereturn, vérifie correctement cettefor i in range(len(t) - 1):
assert t[i] <= t[i + 1]]]>for i in range(len(t) - 1):
assert t[0] <= t[i + 1]]]>[1, 5, 3, 7] passe ce test sansfor i in range(len(t) - 1):
assert t[i] < t[i + 1]]]>[2, 2, 3] est pourtant correctement triée, et cettefor i in range(len(t)):
assert t[i] <= t[i + 1]]]>i vaut len(t) - 1 et t[i + 1]assert n > 0, "n doit être
strictement positif" lorsque n vaut -3 ?]]>assert n'acceptant qu'une condition]]>n est remplacé par 3, valeur absolue de -3]]>i = 0
while i < 10:
i = i + 310 - i.]]>10 - i]]>10 - i est un entier qui diminue strictementi prend les valeurs $3$, $6$, et ainsi de suite,i, qui augmente]]>i augmente, il ne peut pas servir de variant, et lei, de $1$ en $1$]]>i avance de $3$ en $3$, pas de $1$ en $1$.]]>i ne valant jamais exactement $10$]]>i < 10, pas i != 10 ; dépassern est unx = 0
while x * x < n:
x = x + 1n - x ou n - x * x.]]>n - x, qui diminue de $1$ à chaque tour]]>x * x < n imposex < n, donc n - x est strictement positif, et chaque tour lex, qui augmente de $1$ à chaque tour]]>x * x, qui finit par dépasser n]]>x * x augmente lui aussi ; c'est l'écart avec nn, qui est positif pendant toute la boucle]]>n ne change pas pendant la boucle, il ne décroîtp et i à chaque passage dans la conditionp = 1
i = 0
while i < n:
p = p * 2
i = i + 1p = 2^i décrit ce que la boucle a construit jusqu'àp vaut $2^{i}$]]>p et augmente i de $1$. À la sortie,i vaut n et p vaut $2^n$.]]>p vaut $2 \times i$]]>p vaut $4$ et i vaut $2$, maisp vaut $8$ et $2 \times 3 = 6$.]]>p vaut $i^2$]]>p vaut $8$ et $i^2$ vaut $9$.]]>p vaut $n$]]>p change à chaque tour, il ne peut pas rester égal àn.]]>