$course$/QCM de NSI/Première/Invariants et terminaison Preuve de correction et de terminaison d'une boucle :
invariant de boucle (propriété conservée à chaque
itération) et variant de boucle (quantité entière qui
décroît strictement). Application aux algorithmes
classiques (recherche, tri).

]]> Invariants et terminaison — Q01 : Invariant de boucle Qu'est-ce qu'un invariant de boucle ?

]]> L'invariant sert à prouver que la boucle calcule
bien ce qu'elle doit. À la sortie, l'invariant
combiné à la condition d'arrêt donne la
correction de l'algorithme.

]]> 1.0 0.0 0 true true abc Une variable dont la valeur ne change pas dans la boucle

]]> Trop restrictif : un invariant peut concerner
plusieurs variables ou des relations entre
elles.

]]> Une boucle qui ne se termine pas

]]> Erreur : une boucle infinie est un bug, pas
un invariant.

]]> Une exception levée pendant l'exécution de la boucle

]]> Une exception est une
erreur d'exécution. Un
invariant est, lui, une
propriété logique
maintenue tout au long
de la boucle.

]]> Une propriété conservée à chaque itération

]]> Bonne réponse : c'est une propriété
mathématique qu'on prouve vraie avant la
boucle, puis qu'on prouve conservée à chaque
tour. Elle reste vraie à la sortie.

]]> Invariants et terminaison — Q02 : Terminaison Qu'appelle-t-on terminaison d'un algorithme ?

]]> Distinction essentielle : un algorithme peut être
correct (donner le bon résultat s'il termine) sans terminer (boucle infinie).
On veut prouver les deux propriétés.

]]> 1.0 0.0 0 true true abc Le nom donné à la dernière instruction

]]> Erreur : la terminaison est une propriété
globale, pas une instruction particulière.

]]> Le fait que l'algorithme renvoie un résultat correct

]]> Erreur : c'est la correction.
Un algorithme peut être correct
(bon résultat s'il s'arrête) sans
terminer ; les deux propriétés se
prouvent séparément.

]]> L'algorithme s'arrête en un nombre fini d'étapes

]]> Bonne réponse : prouver la terminaison, c'est
montrer qu'aucune entrée valide ne fera
boucler indéfiniment l'algorithme.

]]> La présence d'une condition d'arrêt dans la boucle

]]> Erreur : la présence d'une
condition d'arrêt ne suffit
pas. Si elle ne devient
jamais fausse, la boucle est
infinie : la terminaison est
la propriété que l'algorithme
s'arrête réellement.

]]> Invariants et terminaison — Q03 : Variant de boucle Pour prouver la terminaison d'une boucle while,
on cherche un variant. Quelle propriété
doit-il avoir ?

]]> Variant typique : pour la dichotomie, c'est la
taille de l'intervalle d - g qui décroît
strictement. Pour while x > 0: x -= 1, c'est
x lui-même.

]]> 1.0 0.0 0 true true abc Un entier minoré qui décroît strictement

]]> Bonne réponse : si une quantité entière
décroît strictement et est minorée
(par exemple, par 0), elle ne peut décroître
qu'un nombre fini de fois.

]]> Être une chaîne de caractères qui change

]]> Erreur : un variant est une quantité entière (ou minorée), pas une chaîne.

]]> Croître à chaque itération

]]> Erreur : un variant croissant ne prouve pas
la terminaison (la suite peut être
non-bornée).

]]> Rester constant

]]> Erreur : un invariant, oui ; un variant,
non.

]]> Invariants et terminaison — Q04 : Exemple : recherche linéaire Dans une recherche linéaire avec for i in
range(len(liste)), quel est l'invariant à
l'entrée du tour i ?

]]> Combiner invariant + condition de sortie : à la
sortie (i = n et pas de return), invariant + (i
= n) ⇒ « cible absente ». L'invariant est l'âme
de la preuve.

]]> 1.0 0.0 0 true true abc La liste est triée

]]> Erreur : la recherche linéaire n'a pas besoin
du tri.

]]> La cible ne se trouve à aucun indice situé avant i

]]> Bonne réponse : à l'entrée de l'itération
i, on a déjà testé les indices 0 à i-1 et
aucun n'a satisfait le critère. Si on en
avait trouvé un, on aurait fait un return.

]]> La cible n'est dans aucune position de la liste

]]> Trop fort : on ne sait pas encore si la
cible est plus loin.

]]> La cible est plus grande que tous les éléments déjà testés

]]> Erreur : aucune relation d'ordre n'intervient
dans une recherche linéaire générale.

]]> Invariants et terminaison — Q05 : Variant for vs while Pour une boucle for i in range(n):, est-il
nécessaire de prouver la terminaison ?

]]> Astuce : si possible, écrire for plutôt que
while pour éviter de devoir prouver la
terminaison. C'est aussi plus lisible.

]]> 1.0 0.0 0 true true abc Non, un for sur un range fini termine seul

]]> Bonne réponse : Python garantit la
terminaison d'un for sur un range fini
ou une liste finie. Pas besoin de variant.

]]> Non, mais il faut prouver l'invariant

]]> Pertinent pour la correction mais hors
sujet ici (la question portait sur la
terminaison).

]]> Oui, comme pour toute boucle

]]> Trop strict : la terminaison est
automatique pour une boucle for sur un
range ou une liste.

]]> Oui, mais seulement lorsque n est un nombre pair

]]> La parité de n n'a
aucun rapport avec la
terminaison de la
boucle.

]]> Invariants et terminaison — Q06 : Distinction Invariant et variant : quelle est la différence
essentielle ?

]]> Mnémonique : « in » comme « invariable » →
reste vrai (correction) ; « variant » comme
« ça change vers le bas » → décroît strictement
(terminaison).

]]> 1.0 0.0 0 true true abc Les deux servent à compter les opérations

]]> Erreur : le compteur d'opérations est lié à la
complexité, pas à ces notions.

]]> L'invariant est de nature mathématique, le variant est de nature physique

]]> Cette distinction est
inexacte : ces deux
notions sont, l'une et
l'autre, des propriétés
mathématiques de la
boucle.

]]> Aucune, ce sont synonymes

]]> Erreur : ce sont deux notions distinctes.

]]> L'invariant prouve la correction, le variant prouve la terminaison

]]> Bonne réponse : invariant → résultat juste à
la sortie ; variant → la sortie est
atteinte.

]]> Invariants et terminaison — Q07 : Invariant : somme `python
somme = 0
for x in liste:
somme += x
`
Quel est l'invariant après k itérations ?

]]> C'est l'invariant le plus simple à formuler :
« la variable accumule progressivement ce
qu'elle doit ». Ce schéma apparaît dans tous
les calculs incrémentaux.

]]> 1.0 0.0 0 true true abc somme est strictement positive à chaque itération

]]> Erreur : la liste peut contenir des nombres
négatifs ou nuls, et somme peut donc être
négative ou nulle à tout moment.

]]> somme vaut la somme des k premiers éléments

]]> Bonne réponse : à l'entrée de l'itération
k+1, somme contient la somme des k
éléments déjà parcourus. À la sortie
(k = n), c'est la somme totale.

]]> somme vaut le premier élément liste[0] de la liste

]]> Erreur : c'est vrai seulement après la
première itération. Un invariant doit être
vrai après chaque itération.

]]> somme garde la valeur 0 tant que la boucle tourne

]]> Erreur : somme est modifiée à chaque tour
par somme += x ; elle ne reste nulle que si
tous les éléments parcourus sont nuls.

]]> Invariants et terminaison — Q08 : Variant simple `python
n = 10
while n > 0:
n -= 1
`
Quel est un variant valide ?

]]> Variant typique : la quantité contrôlée par la
condition d'arrêt, qui converge vers la
condition finale.

]]> 1.0 0.0 0 true true abc La constante 10

]]> Erreur : une constante ne décroît pas.

]]> La quantité 10 - n

]]> Erreur : 10 - n croît de 0 à 10 au
fil des tours. Un variant doit être un
entier positif ou nul qui décroît
strictement.

]]> Le booléen n > 0

]]> Erreur : un booléen ne décroît pas (au sens
numérique).

]]> n lui-même

]]> Bonne réponse : n est un entier ≥ 0 qui
décroît strictement (n -= 1 à chaque
tour). Quand n atteint 0, on sort.

]]> Invariants et terminaison — Q09 : Boucle infinie `python
i = 0
while i < 10:
print(i)
`
Pourquoi cette boucle ne termine-t-elle pas ?

]]> Bug très classique chez les débutants : oublier
de modifier la variable de boucle. Toujours
vérifier qu'un variant décroît à chaque tour.

]]> 1.0 0.0 0 true true abc Parce que la condition i < 10 n'est testée qu'une seule fois, au départ

]]> Erreur : la condition d'un while est
réévaluée avant chaque tour. Ici elle est
bien retestée, mais reste vraie à chaque
fois parce que i vaut toujours 0.

]]> Parce que i n'est jamais modifié : il n'y a pas de variant qui décroît

]]> Bonne réponse : la condition i < 10 reste
toujours vraie. Pas de progression vers la
terminaison. Solution : ajouter i += 1
dans la boucle.

]]> Parce que la condition devrait être i <= 10 et non i < 10

]]> Erreur : la borne n'est pas en cause. Avec
i <= 10, la boucle ne terminerait pas
davantage, car i ne change jamais.

]]> Parce que print(i) modifie la valeur de i à chaque tour

]]> Erreur : print se contente d'afficher son
argument, il ne le modifie pas. C'est
justement parce que rien ne modifie i que
la condition reste vraie.

]]> Invariants et terminaison — Q10 : Pourquoi prouver ? Pourquoi prouver la correction d'un algorithme
au lieu de simplement le tester ?

]]> Citation célèbre de Dijkstra : « Tester ne peut
jamais prouver l'absence de bugs ; au mieux,
cela peut prouver leur présence. »

]]> 1.0 0.0 0 true true abc Parce que c'est obligatoire en cours

]]> Argument scolaire, pas scientifique.

]]> Parce que les tests sont chers

]]> Erreur : les tests automatisés sont peu
coûteux.

]]> Aucun test fini ne couvre tous les cas, une preuve oui

]]> Bonne réponse : les tests valident sur les
cas testés ; la preuve garantit l'absence
de bugs sur toutes les entrées. Pour des
systèmes critiques (avions, médical),
c'est essentiel.

]]> Parce que les preuves sont plus rapides à écrire

]]> En pratique, c'est souvent l'inverse !

]]> Invariants et terminaison — Q11 : Trois étapes de preuve Une preuve d'invariant comporte combien
d'étapes ?

]]> Trois temps à retenir : l'invariant est vrai
au départ, chaque tour le conserve, et à la
sortie il donne, avec la condition d'arrêt,
le résultat voulu.

]]> 1.0 0.0 0 true true abc Cinq

]]> Erreur : trois suffisent.

]]> Une seule

]]> Une étape unique ne
permet pas d'établir
la correction d'une
boucle. Il faut au
minimum vérifier
l'initialisation, la
conservation et l'effet
obtenu en sortie.

]]> Aucune, la preuve d'invariant est totalement implicite

]]> Erreur : il faut bien la justifier.

]]> Trois : initialisation, hérédité, terminaison

]]> Bonne réponse : (1) Initialisation :
l'invariant est vrai avant la première
itération ; (2) Hérédité : s'il est
vrai à l'entrée d'un tour, il l'est à la
sortie ; (3) Terminaison : à la sortie
de la boucle, l'invariant + la condition
d'arrêt donnent le résultat voulu.

]]> Invariants et terminaison — Q12 : Invariant : minimum `python
m = liste[0]
for i in range(1, len(liste)):
if liste[i] < m:
m = liste[i]
`
Quel est l'invariant après l'itération sur les
k premiers éléments ?

]]> Schéma « accumulateur » : la variable m
agrège progressivement la propriété (ici, le
min) sur les éléments parcourus.

]]> 1.0 0.0 0 true true abc m vaut le dernier élément examiné par la boucle

]]> Erreur : m ne prend la valeur de l'élément
courant que s'il est plus petit ; sinon il
garde sa valeur.

]]> m vaut le minimum de la liste entière dès le premier tour

]]> Erreur : confusion entre invariant et
postcondition. Le minimum global n'est
garanti qu'à la sortie de la boucle, pas
pendant son exécution.

]]> m est le minimum des k premiers éléments parcourus

]]> Bonne réponse : à chaque tour, on met à
jour m si l'élément courant est plus
petit. À la fin, c'est le min de toute la
liste.

]]> m vaut toujours le premier élément liste[0]

]]> Erreur : m est mis à jour dès qu'un
élément plus petit que lui est rencontré.

]]> Invariants et terminaison — Q13 : Variant dichotomie Pour la recherche dichotomique itérative,
quel est le variant le plus naturel ?

]]> Le variant est ce qui « pousse » l'algorithme
vers sa fin. Pour la dichotomie, c'est
l'intervalle de recherche qui rétrécit.

]]> 1.0 0.0 0 true true abc La valeur de la cible recherchée

]]> Erreur : la cible ne change pas pendant la
recherche, elle ne peut donc pas décroître.

]]> La longueur totale de la liste parcourue

]]> Erreur : la longueur de la liste ne change pas
d'une itération à l'autre ; une quantité
constante ne peut pas servir de variant.

]]> La taille d - g + 1 de l'intervalle

]]> Bonne réponse : à chaque itération,
l'intervalle est divisé par 2 (donc
décroît strictement). Quand il atteint 0
(ou devient négatif), on sort.

]]> Le compteur d'itérations courant

]]> Erreur : un compteur croît à chaque tour,
alors qu'un variant doit décroître strictement
vers 0. On exprime le variant avec les
variables de l'algorithme.

]]> Invariants et terminaison — Q14 : La boucle de Syracuse La suite de Syracuse part d'un entier n ≥ 1 : si n est pair, on le
divise par 2, sinon on le remplace par 3n + 1. La conjecture de
Syracuse affirme que cette suite finit toujours par atteindre 1,
quel que soit l'entier de départ. Elle a été vérifiée par ordinateur
pour d'immenses valeurs de n, mais personne ne l'a démontrée.

`python
def f(n):
while n != 1:
if n % 2 == 0:
n = n // 2
else:
n = 3 * n + 1
`

Que peut-on affirmer sur la terminaison de cette boucle pour tout
entier n ≥ 1 ?

]]> Pour prouver qu'une boucle termine, on cherche un variant : une quantité
entière positive qui décroît strictement à chaque tour. Ici, n monte
et descend, et personne n'a trouvé de variant : la terminaison de cette
boucle très simple reste une question ouverte.

]]> 1.0 0.0 0 true true abc Elle termine pour tout n, puisque la conjecture a été vérifiée par ordinateur

]]> Erreur : une vérification, même sur d'immenses valeurs, ne couvre pas
tous les entiers. Seule une démonstration permettrait d'affirmer que la
boucle termine pour tout n.

]]> Elle termine pour tout n, car un tour sur deux au moins divise n par 2

]]> Erreur : après 3 * n + 1, le nombre obtenu est pair et le tour suivant
le divise par 2, mais le résultat (3n + 1)/2 reste plus grand que
n. Cette remarque ne fournit donc aucun variant.

]]> Elle ne termine pas pour tout n, puisque 3 * n + 1 fait augmenter n

]]> Erreur : n augmente parfois, mais cela ne prouve pas que la boucle
tourne sans fin. Pour n = 3, la suite vaut 10, 5, 16, 8, 4,
2, 1 : elle monte puis redescend jusqu'à 1.

]]> On ne sait pas : il faudrait pour cela démontrer la conjecture

]]> Bonne réponse : la boucle s'arrête exactement quand la suite atteint 1.
Prouver qu'elle termine pour tout n revient donc à démontrer la
conjecture, ce que personne n'a encore réussi.

]]> Invariants et terminaison — Q15 : Pré et post-conditions Que sont les préconditions et
postconditions d'une fonction ?

]]> L'invariant relie pré et postcondition à
l'intérieur d'une boucle. En Python, des
assertions (assert) peuvent vérifier ces
conditions pendant l'exécution.

]]> 1.0 0.0 0 true true abc Des commentaires inutiles

]]> Erreur : ce sont des éléments de
spécification rigoureuse.

]]> Hypothèse sur les arguments, garantie sur le résultat

]]> Bonne réponse : « si X (précondition) est
vraie en entrée, alors Y (postcondition)
est vraie en sortie ». C'est un contrat.

]]> Le code situé juste avant et juste après l'appel à la fonction

]]> Cette interprétation
littérale du nom est
inexacte. Les pré- et
postconditions sont des
propriétés logiques sur
les arguments et le
résultat, et non des
fragments de code.

]]> Des tests écrits après coup pour chercher les bugs

]]> Erreur : tu confonds spécification et jeu de
tests. Les tests vérifient le programme sur
quelques exemples ; les préconditions et
postconditions énoncent ce qui doit être vrai
pour tous les appels.

]]> Invariants et terminaison — Q16 : Décroissance stricte Pourquoi le variant doit-il décroître
strictement (et pas seulement « ne pas
augmenter ») ?

]]> Une suite d'entiers strictement décroissante
et minorée par 0 ne peut prendre qu'un nombre
fini de valeurs. Cette propriété fonde la
preuve de terminaison.

]]> 1.0 0.0 0 true true abc Pour rendre la démonstration plus élégante visuellement

]]> La décroissance stricte
répond à un besoin
mathématique précis :
assurer que la boucle
ne stagne pas et finit
par s'arrêter.

]]> Parce que la preuve serait plus longue à rédiger sinon

]]> La longueur de la preuve n'est pas le motif :
sans décroissance stricte, le variant peut
stagner et la boucle ne jamais s'arrêter.

]]> Parce que Python l'exige

]]> Erreur : Python n'a pas cette contrainte.

]]> Une suite minorée non strictement décroissante peut stagner

]]> Bonne réponse : un variant qui stagne
autorise une boucle infinie. La décroissance
stricte garantit que l'on s'approche du
seuil de sortie à chaque tour.

]]> Invariants et terminaison — Q17 : Invariant : compteur d'occurrences `python
c = 0
for i in range(len(liste)):
if liste[i] == cible:
c = c + 1

Quel invariant est vérifié à l'entrée du tour
i, avant le test liste[i] == cible` ?

]]> Un compteur suit le même schéma qu'une somme :
l'invariant décrit ce que c représente pour
la partie déjà parcourue, les éléments situés
avant l'indice i. À la sortie
(i = len(liste)), il donne la postcondition :
c est le nombre d'occurrences dans toute la
liste.

]]> 1.0 0.0 0 true true abc c est le nombre d'éléments différents de cible avant l'indice i

]]> Erreur : c'est le complémentaire de ce que
compte la boucle. À l'entrée du tour 1 sur
[3, 7, 3, 3] avec cible = 3, c vaut 1
alors qu'aucun élément déjà vu n'est
différent de 3.

]]> c vaut i, le nombre de tours déjà effectués

]]> Erreur : c ne compte que les tours où le
test a réussi. Sur [3, 7, 3, 3] avec
cible = 3, à l'entrée du tour 2 on a
i = 2 mais c = 1.

]]> c est le nombre d'occurrences de cible dans toute la liste

]]> Erreur : c'est la postcondition, vraie
seulement à la sortie de la boucle. À
l'entrée du tour 0, c vaut 0 alors que
[3, 7, 3, 3] contient trois fois la
cible 3.

]]> c est le nombre d'occurrences de cible avant l'indice i

]]> Bonne réponse : avant le tour i, seuls les
i premiers éléments ont été examinés, et
c a été incrémenté une fois par occurrence
rencontrée. Sur liste = [3, 7, 3, 3] et
cible = 3, c vaut 0, 1, 1, 2 à l'entrée
des tours 0, 1, 2, 3, puis 3 à la sortie.

]]> Invariants et terminaison — Q18 : Variant multivarié Pour la dichotomie itérative, peut-on choisir
g (l'indice de gauche) seul comme variant ?

]]> Astuce : si une variable augmente, prendre son
complément (par exemple n - i) comme variant.
Le choix du variant est souvent affaire de
reformulation.

]]> 1.0 0.0 0 true true abc Non, parce que g n'est pas vraiment un entier

]]> Erreur : g est bien un entier.

]]> Oui, parfait

]]> Erreur : g peut rester constant si c'est
d qui change.

]]> Oui, mais seulement si la liste est triée

]]> Erreur : la précondition de tri n'a aucun
rôle dans la terminaison.

]]> Non, g ne décroît pas (il augmente)

]]> Bonne réponse : on cherche une quantité
qui décroît. Avec g qui augmente, il
faut prendre par exemple n - g ou bien
la taille de l'intervalle d - g.

]]> Invariants et terminaison — Q19 : Bonne formulation Pour qu'un invariant soit utile à la preuve,
il faut qu'il soit :

]]> Trop faible : ne dit rien d'utile. Trop fort :
faux. Le bon niveau est celui qui, combiné à la
condition d'arrêt, donne exactement la
postcondition.

]]> 1.0 0.0 0 true true abc Long, lourd et particulièrement compliqué

]]> Au contraire, on cherche le plus simple
possible.

]]> Vrai au départ et assez fort en sortie

]]> Bonne réponse : un invariant trop faible
ne donne rien à la sortie ; un invariant
trop fort peut être faux. Trouver le bon
niveau est tout l'art.

]]> Codé dans Python

]]> Sans rapport : un invariant est une
propriété mathématique.

]]> Toujours faux

]]> Absurde : un invariant doit être vrai.

]]> Invariants et terminaison — Q20 : Outils Quel outil aide à détecter un bug dans un
invariant ?

]]> Les assert sont une excellente pratique :
ils transforment des invariants implicites en
vérifications explicites, attrapant les bugs
au plus tôt.

]]> 1.0 0.0 0 true true abc Un print() qui signale automatiquement l'invariant faux

]]> Erreur : print affiche une valeur sans la
comparer à rien. C'est à l'humain de repérer
l'anomalie dans le flot d'affichages, et rien
n'arrête le programme.

]]> Un assert de l'invariant dans la boucle

]]> Bonne réponse : par exemple
assert m == min(liste[:i+1]). Si
l'invariant échoue à un tour, Python lève
AssertionError et indique le bug.

]]> Un commentaire # TODO placé dans la boucle

]]> Erreur : un commentaire n'est pas exécuté et
ne vérifie rien.

]]> Un compteur du nombre de tours de la boucle

]]> Erreur : compter les tours renseigne sur la
terminaison (la boucle s'arrête-t-elle ?),
pas sur la correction. Une boucle peut faire
exactement le bon nombre de tours en
calculant un résultat faux.

]]> Invariants et terminaison — Q21 : Invariant insuffisant Pour le tri par sélection, l'invariant
« les k premiers éléments sont triés » est-il
suffisant ?

]]> Bon invariant pour la sélection : les k
premiers éléments sont triés et chacun
d'eux est inférieur ou égal à tous les
éléments d'indice k à n - 1. Les deux
conditions sont nécessaires.

]]> 1.0 0.0 0 true true abc Oui, à condition que la liste ne contienne aucun doublon

]]> Erreur : les doublons ne gênent ni le tri
par sélection ni sa preuve ; ce qui manque,
c'est que les k premiers éléments soient les
plus petits de la liste.

]]> Oui, à condition que la liste soit triée à l'avance

]]> Erreur : on n'a pas cette précondition.

]]> Oui, c'est suffisant

]]> Insuffisant : « les k premiers triés » ne
dit pas qu'ils sont les plus petits. Si le
maximum se retrouvait en liste[0] et le
minimum en liste[1], ce serait « trié »
(ordre 1 puis 2 éléments), mais incorrect.

]]> Non, il manque qu'ils soient les plus petits

]]> Bonne réponse : sans cette condition
supplémentaire, on ne peut pas prouver que
l'invariant se conserve : les k premiers
éléments pourraient être triés tout en
contenant de « gros » éléments, et le
résultat final serait faux.

]]> Invariants et terminaison — Q22 : Trouver le variant `python
while a > b:
a = a - b

(avec a, b entiers, b > 0`). Quel est un
variant valide ?

]]> Cette boucle calcule a mod b (reste de la
division euclidienne). C'est un cas classique
illustrant variant et terminaison.

]]> 1.0 0.0 0 true true abc La quantité b - a

]]> Erreur : tant que la boucle tourne, a > b
donc b - a est strictement négatif, et
il croît à chaque tour. Un variant doit
être positif ou nul et décroître strictement.

]]> La variable a

]]> Bonne réponse : à chaque tour a -= b
avec b > 0, donc a décroît strictement,
tout en restant strictement positif tant
que la boucle tourne (a > b > 0). La
boucle se termine quand a <= b.

]]> La constante 1

]]> Erreur : une constante ne décroît pas.

]]> La variable b

]]> Erreur : b ne change pas dans la boucle,
ce n'est donc pas une quantité décroissante.

]]> Invariants et terminaison — Q23 : Vérifier une postcondition par assertion La fonction suivante doit renvoyer l'indice d'un
plus petit élément d'une liste non vide t :

`python
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 k

On 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 ?

]]> Des assertions garantissent des préconditions,
comme assert len(t) > 0 en début de fonction,
et des postconditions, vérifiées juste avant de
renvoyer le résultat. Une postcondition qui
porte sur tous les éléments se vérifie par une
boucle d'assertions.

]]> 1.0 0.0 0 true true abc `python
assert t[k] <= t[i]
`

]]> Erreur : après la boucle, i vaut le
dernier indice parcouru, donc on ne compare
t[k] qu'au dernier élément. Pour une liste
d'un seul élément, i n'est même pas défini
et cette ligne provoque une erreur.

]]> `python
assert 0 <= k and k < len(t)
`

]]> Erreur : cette assertion vérifie seulement
que k est un indice valide. Elle resterait
vraie si la fonction renvoyait l'indice du
plus grand élément.

]]> `python
for j in range(len(t)):
assert t[k] <= t[j]
`

]]> Bonne réponse : la boucle compare t[k] à
tous les éléments, et l'assertion échoue dès
que l'un d'eux est strictement plus petit.
L'inégalité large accepte le cas où j vaut
k, ainsi que les minimums en double.

]]> `python
for j in range(len(t)):
assert t[k] < t[j]
`

]]> Erreur : pour j égal à k, t[k] < t[k]
est faux, donc l'assertion échoue à chaque
appel, même quand la fonction est juste. Il
faut une inégalité large.

]]> Invariants et terminaison — Q24 : Inventer l'invariant `python
r = 0
n = N
while n > 0:
n = n // 2
r = r + 1
`
Que calcule cette boucle, et quel invariant
rend ce calcul évident ?

]]> Cet algorithme calcule le logarithme entier.
C'est aussi la base de la complexité O(log n)
de la dichotomie : on divise par 2 jusqu'à
atteindre 0.

]]> 1.0 0.0 0 true true abc La boucle compte simplement de 1 jusqu'à N

]]> Erreur : n est divisé par 2, pas
décrémenté.

]]> Invariant n == N // 2^r ; r compte les tours

]]> Bonne réponse : on divise par 2 jusqu'à
atteindre 0, en comptant. C'est le calcul
du logarithme entier en base 2. Le
variant : n (qui décroît
strictement par division entière).

]]> La boucle ne termine jamais, n ne devenant jamais nul

]]> Erreur : n // 2 ramène n à 0 en log₂(N)
étapes (par exemple 8, 4, 2, 1, 0).

]]> r reste égal à 0 pendant toute la boucle

]]> Erreur : r = r + 1 l'incrémente à chaque
tour.

]]> Invariants et terminaison — Q25 : Synthèse Parmi les affirmations suivantes sur les
invariants et la terminaison, laquelle est
fausse ?

]]> On prouve donc deux choses séparément : la
correction, à l'aide d'un invariant, et la
terminaison, à l'aide d'un variant. Il faut
les deux pour être sûr d'obtenir le bon
résultat.

]]> 1.0 0.0 0 true true abc Un variant doit être un entier (ou une quantité minorée) qui décroît strictement

]]> Vrai : sinon la décroissance peut être
infinie.

]]> Un programme correct est nécessairement un programme qui termine

]]> Faux (donc bonne réponse) : la correction
est une propriété conditionnelle :
« si le programme termine, le résultat
est juste ». La terminaison est une
propriété distincte, qu'il faut
prouver à part.

]]> Un invariant doit être vrai à chaque entrée d'itération

]]> Vrai : c'est sa définition.

]]> Toute boucle for i in range(n) se termine, sans qu'on ait besoin de prouver de variant

]]> Vrai : la boucle for sur un range fini
termine automatiquement.

]]> Invariants et terminaison — Q26 : Invariant : tri par insertion Dans le tri par insertion, après l'itération
i de la boucle externe, quel invariant
caractérise correctement l'état de la liste ?

]]> Différence clé avec le tri par sélection :
l'invariant de l'insertion porte sur le tri
d'une partie initiale (sans hypothèse sur les
valeurs), alors que celui de la sélection
ajoute la condition « plus petits que les
autres ».

]]> 1.0 0.0 0 true true abc Les i premiers éléments sont les plus grands

]]> Erreur : ce serait un tri décroissant ou
un tri par sélection inversé. Le tri par
insertion classique est croissant et ne
place pas les plus grands en tête.

]]> Les i premiers éléments sont triés et plus petits que tous les autres

]]> Erreur : c'est l'invariant du tri par
sélection. Le tri par insertion ne
place pas les plus petits en tête à chaque
étape ; il insère le i-ème élément à sa
place dans la partie déjà traitée.

]]> liste[:i+1] contient les mêmes éléments, mais triés

]]> Bonne réponse : c'est l'invariant clé du
tri par insertion. Les i + 1 premiers
éléments restent les mêmes (à l'ensemble
près) qu'avant la boucle, mais maintenant
ordonnés. À la dernière itération
i = n - 1, toute la liste est triée.

]]> La liste est entièrement triée

]]> Erreur : trop fort. À l'itération i,
seuls les i + 1 premiers éléments sont
triés ; les éléments suivants n'ont pas
encore été traités.

]]> Invariants et terminaison — Q27 : Terminaison de l'algorithme d'Euclide L'algorithme d'Euclide pour le PGCD s'écrit :
`python
def pgcd(a, b):
while b != 0:
a, b = b, a % b
return a

(avec a, b entiers naturels, b > 0` à
l'entrée). Quel est un variant qui prouve la
terminaison ?

]]> Une remarque profonde : ici, l'invariant
est pgcd(a, b) = pgcd(a₀, b₀) (la valeur
initiale du PGCD est conservée), tandis que le
variant est b. À la sortie, l'invariant
donne pgcd(a, 0) = a, ce qui est bien le
PGCD recherché.

]]> 1.0 0.0 0 true true abc La valeur de b

]]> Bonne réponse : à chaque itération, b
devient a % b, qui est strictement
inférieur à l'ancien b. Comme b est un
entier naturel minoré par 0, la suite des
valeurs de b est strictement décroissante
et finie. La boucle se termine donc.

]]> Le PGCD lui-même

]]> Erreur : l'invariant de l'algorithme est
précisément que pgcd(a, b) reste
constant à chaque itération. Une quantité
constante ne peut servir de variant (qui
doit décroître strictement).

]]> La valeur de a

]]> Erreur : a ne décroît pas forcément à
chaque tour. Par exemple avec a = 5,
b = 12, après une itération on a
a = 12, b = 5, donc a a augmenté.

]]> La somme a + b

]]> Erreur : la somme peut augmenter ou
stagner selon les cas. Par exemple
pgcd(5, 12) : avant, a + b = 17 ;
après, a + b = 12 + 5 = 17. Donc pas de
décroissance stricte.

]]> Invariants et terminaison — Q28 : Assertion d'invariant en pratique On suspecte qu'une boucle calcule mal une
somme. Quel ajout permet de détecter automatiquement une violation d'invariant
pendant l'exécution ?

]]> Bonne pratique : exprimer les invariants
critiques sous forme d'assertions pendant la
phase de développement. Cela transforme les
bugs silencieux en erreurs immédiates et
réduit considérablement le temps de
débogage.

]]> 1.0 0.0 0 true true abc Un assert vérifiant que le variant décroît à chaque tour

]]> Erreur : ce contrôle porte sur la
terminaison, pas sur la correction. Le
variant peut décroître parfaitement pendant
que la somme se calcule mal : une assertion
sur le variant ne détecte aucune violation
d'invariant.

]]> Une instruction assert exprimant l'invariant attendu

]]> Bonne réponse : assert lève
immédiatement une AssertionError si la
condition est fausse, ce qui localise
précisément l'itération où l'invariant a
été rompu. C'est un outil de débogage très
efficace.

]]> Un commentaire # vérification de l'invariant

]]> Erreur : un commentaire est inerte. Il
n'est lu que par le programmeur, pas par
l'interpréteur Python. Aucun bug ne peut
être détecté ainsi.

]]> Un appel à print affichant la valeur courante de la variable

]]> Possible mais limité : il faut alors
inspecter la sortie à l'œil nu et
identifier visuellement une anomalie. Pas
de détection automatique.

]]> Invariants et terminaison — Q29 : Effet d'une assertion fausse Pendant l'exécution d'un programme Python, la condition d'une
instruction assert s'avère fausse. Que se passe-t-il ?

]]> assert condition vérifie une hypothèse à un instant précis de
l'exécution. Tant que la condition est vraie, l'instruction est
sans effet ; dès qu'elle est fausse, le programme s'arrête avec une
AssertionError, ce qui évite qu'une erreur se propage en silence.

]]> 1.0 0.0 0 true true abc Le programme s'arrête aussitôt en levant une AssertionError

]]> Bonne réponse : une assertion fausse interrompt l'exécution en
signalant la ligne fautive. C'est ce qui en fait un outil de
détection : l'erreur apparaît au plus près de sa cause.

]]> Python corrige la valeur fautive pour rendre la condition vraie

]]> Erreur : une assertion vérifie, elle ne répare rien. Python ne
sait pas quelle valeur serait correcte, il signale seulement que
l'hypothèse du programmeur est violée.

]]> L'instruction est ignorée et le programme continue normalement

]]> Erreur : une assertion n'est pas un simple commentaire. Si sa
condition est fausse, l'exécution s'arrête sur une
AssertionError.

]]> La fonction en cours renvoie False et l'exécution se poursuit

]]> Erreur : assert ne renvoie aucune valeur. Une condition fausse
déclenche une erreur qui arrête le programme.

]]> Invariants et terminaison — Q30 : Précondition d'une division La fonction suivante ne doit être appelée qu'avec un argument non
nul :
`python
def inverse(x):
return 1 / x
`
Quelle instruction, placée en première ligne du corps de la
fonction, exprime cette précondition ?

]]> Une précondition s'écrit comme une assertion sur les arguments,
placée au début de la fonction. Elle doit être exactement aussi
stricte que nécessaire, ni plus, ni moins.

]]> 1.0 0.0 0 true true abc assert x > 0

]]> Erreur : cette condition rejette aussi les nombres négatifs, pour
lesquels l'inverse existe pourtant. La précondition serait plus
restrictive que nécessaire.

]]> assert 1 / x != 0

]]> Erreur : pour évaluer cette condition, Python calcule d'abord
1 / x. Avec x égal à 0, la division échoue avant même que
l'assertion ne soit testée.

]]> assert x == 0

]]> Erreur : la condition est inversée. Elle arrêterait le programme
pour tous les arguments valides et laisserait passer le seul cas
interdit.

]]> assert x != 0

]]> Bonne réponse : la précondition porte sur l'argument reçu, avant
tout calcul. Si l'appelant fournit 0, l'assertion arrête le
programme avec un message clair au lieu de laisser la division
échouer.

]]> Invariants et terminaison — Q31 : Postcondition d'une fonction de tri Une fonction trier(t) doit réordonner la liste t par ordre
croissant, en acceptant les valeurs répétées. Quelle assertion,
placée juste avant le return, vérifie correctement cette
postcondition ?

]]> Une postcondition décrit le résultat garanti par la fonction. Pour
un tri, c'est l'ordre croissant au sens large : chaque élément est
inférieur ou égal à son voisin de droite. L'assertion doit tester
exactement cette propriété, sur toute la liste.

]]> 1.0 0.0 0 true true abc `python
for i in range(len(t) - 1):
assert t[i] < t[i + 1]
`

]]> Erreur : l'inégalité stricte interdit les valeurs répétées. La
liste [2, 2, 3] est pourtant correctement triée, et cette
assertion l'arrêterait.

]]> `python
for i in range(len(t)):
assert t[i] <= t[i + 1]
`

]]> Erreur : au dernier tour, i vaut len(t) - 1 et t[i + 1]
désigne un indice hors limites. L'assertion échoue par une
erreur d'indice, même sur une liste triée.

]]> `python
for i in range(len(t) - 1):
assert t[i] <= t[i + 1]
`

]]> Bonne réponse : une liste est triée par ordre croissant si
chaque élément est inférieur ou égal au suivant. Le parcours
vérifie cette propriété pour tous les couples d'éléments
voisins.

]]> `python
for i in range(len(t) - 1):
assert t[0] <= t[i + 1]
`

]]> Erreur : cette boucle vérifie seulement que le premier élément
est le plus petit. La liste [1, 5, 3, 7] passe ce test sans
être triée.

]]> Invariants et terminaison — Q32 : Une assertion avec message Que se passe-t-il à l'exécution de assert n > 0, "n doit être
strictement positif" lorsque n vaut -3 ?

]]> Un message d'assertion rend l'erreur lisible : au lieu d'une
condition cryptique, le programmeur voit l'hypothèse violée en
français.

]]> 1.0 0.0 0 true true abc Le message est ignoré, assert n'acceptant qu'une condition

]]> Erreur : le second argument, facultatif, est bien pris en
compte et affiché avec l'erreur.

]]> Le programme s'arrête, l'erreur affichant le message

]]> Bonne réponse : le texte après la virgule accompagne l'erreur.
Il explique au programmeur quelle hypothèse a été violée.

]]> n est remplacé par 3, valeur absolue de -3

]]> Erreur : une assertion ne corrige rien, elle signale.

]]> Le message est affiché et le programme continue normalement

]]> Erreur : une assertion fausse interrompt toujours le programme.

]]> Invariants et terminaison — Q33 : Le coût d'une assertion dans une boucle Pour vérifier l'invariant d'un tri, Nora ajoute dans la boucle
principale une assertion qui parcourt toute la partie triée. Quelle
conséquence ?

]]> Les assertions sont un outil de développement : on accepte leur
coût pour traquer les erreurs, puis on les allège dans la version
finale.

]]> 1.0 0.0 0 true true abc Un ralentissement net, l'assertion parcourant la liste à chaque tour

]]> Bonne réponse : un parcours par tour sur n tours ajoute un
coût quadratique. Utile pour mettre au point, l'assertion se
retire ou se désactive une fois le programme validé.

]]> Aucune conséquence, une assertion ne coûtant rien à l'exécution

]]> Erreur : l'expression de l'assertion est évaluée à chaque
passage, avec son coût propre.

]]> Le programme refuse de démarrer, une assertion étant interdite dans une boucle

]]> Erreur : rien n'interdit une assertion dans une boucle, c'est
même courant pendant la mise au point.

]]> Le tri devient incorrect, l'assertion modifiant la liste pendant le parcours

]]> Erreur : une assertion bien écrite ne modifie rien ; elle lit
seulement.

]]> Invariants et terminaison — Q34 : Compter les tours grâce au variant Combien de tours effectue cette boucle, et quel variant permet de
prouver qu'elle termine ?
`python
i = 0
while i < 10:
i = i + 3
`

]]> Un variant est une quantité entière, positive tant que la boucle
tourne, et qui décroît strictement à chaque tour : ici 10 - i.

]]> 1.0 0.0 0 true true abc 10 tours ; le variant est i, de 1 en 1

]]> Erreur : i avance de 3 en 3, pas de 1 en 1.

]]> Une infinité de tours, i ne valant jamais exactement 10

]]> Erreur : la condition est i < 10, pas i != 10 ; dépasser
10 suffit à sortir.

]]> 3 tours ; le variant est i, qui augmente

]]> Erreur : i augmente, il ne peut pas servir de variant, et le
dernier tour, qui fait dépasser 10, compte aussi.

]]> 4 tours ; le variant est 10 - i

]]> Bonne réponse : 10 - i est un entier qui diminue strictement
à chaque tour et la boucle s'arrête dès qu'il devient négatif
ou nul. i prend les valeurs 3, 6, et ainsi de suite,
jusqu'à atteindre ou dépasser 10 en 4 tours.

]]> Invariants et terminaison — Q35 : Un variant pour une variable qui augmente Quel variant prouve la terminaison de cette boucle, où n est un
entier positif ?
`python
x = 0
while x * x < n:
x = x + 1
`

]]> Quand une variable grandit vers une borne, le variant est la
distance à cette borne : n - x ou n - x * x.

]]> 1.0 0.0 0 true true abc x * x, qui finit par dépasser n

]]> Erreur : x * x augmente lui aussi ; c'est l'écart avec n
qui diminue.

]]> n - x, qui diminue de 1 à chaque tour

]]> Bonne réponse : tant que la boucle tourne, x * x < n impose
x < n, donc n - x est strictement positif, et chaque tour le
réduit de 1.

]]> x, qui augmente de 1 à chaque tour

]]> Erreur : un variant doit décroître ; une quantité qui augmente
ne borne pas le nombre de tours.

]]> n, qui est positif pendant toute la boucle

]]> Erreur : n ne change pas pendant la boucle, il ne décroît
donc pas.

]]> Invariants et terminaison — Q36 : L'invariant d'un calcul de puissance Quel invariant relie p et i à chaque passage dans la condition
de cette boucle ?
`python
p = 1
i = 0
while i < n:
p = p * 2
i = i + 1
`

]]> L'invariant p = 2^i décrit ce que la boucle a construit jusqu'à
présent ; combiné à la condition de sortie, il prouve le résultat.

]]> 1.0 0.0 0 true true abc p vaut 2ⁱ

]]> Bonne réponse : vrai au départ, p = 1 = 2⁰, et conservé par
chaque tour, qui double p et augmente i de 1. À la sortie,
i vaut n et p vaut 2ⁿ.

]]> p vaut n

]]> Erreur : p change à chaque tour, il ne peut pas rester égal à
n.

]]> p vaut i²

]]> Erreur : après trois tours, p vaut 8 et i² vaut 9.

]]> p vaut 2 × i

]]> Erreur : après deux tours, p vaut 4 et i vaut 2, mais
après trois tours p vaut 8 et 2 × 3 = 6.

]]>