Fiche méthode : Recherche de seuils - Python

Suite strictement décroissante qui diverge vers $-\infty$

Prérequis

Nous considérons la suite $(u_n)$ définie pour tout entier naturel $n$ par :

$$\begin{cases} u_0=1 \\ u_{n+1}=1,5u_n-2 \end{cases}$$

Nous admettons que $(u_n)$ :

• est strictement décroissante ;
• diverge vers $-\infty$.

Nous cherchons donc à connaître le rang $n_0$ à partir duquel les termes de la suite sont strictement inférieurs à un réel donné $m$.

Algorithme

Nous allons tout simplement demander au programme de calculer successivement les termes de la suite, en partant de $u_0=1$, de s’arrêter dès que le dernier terme calculé est strictement inférieur à la valeur indiquée, et d’afficher le rang de ce terme.

• Commençons par définir notre fonction, que nous nommons $\purple{\text{ seuil\textunderscore dec\textunderscore div}}$, qui prendra en paramètre $\purple{\text{m}}$, le nombre auquel les termes de la suite devront être inférieurs.

Puis, nous initialisons nos variables :

• Nous considérons la variable $\purple{\text{n}}$, qui contiendra les rangs successifs de la suite.
• Nous y assignons d’abord la valeur $n=0$.
• Puis nous considérons la variable $\purple{\text{u}}$ qui contiendra la valeur des termes successifs de la suite (dont le rang sera donné par $\purple{\text{n}}$).
• Nous y assignons pour commencer la valeur de $u_0=1$.

• Ce que nous souhaitons, c’est que l’algorithme calcule les termes successifs de $(u_n)$ tant qu’ils sont supérieurs ou égaux à $\purple{\text{m}}$, et qu’il s’arrête au premier terme strictement inférieur à $\purple{\text{m}}$.
• Nous utilisons pour cela l’instruction $\purple{\text{while}}$, avec la condition souhaitée.

Attention

Nous voulons savoir quand les termes de la suite deviendront inférieurs à $\purple{\text{m}}$, nous calculons donc les termes tant que ce n’est pas le cas.

• Il faut ainsi bien faire attention au fait que la condition de $\purple{\text{while u >= m}}$ est le contraire de ce que nous cherchons : $u_n < m$.

À l’intérieur de la boucle, nous allons donc calculer le terme suivant de la suite :

• Nous commençons par incrémenter $\purple{\text{n}}$, pour indiquer que nous sommes passés au terme suivant.
• Puis nous calculons, grâce à la définition de la suite, le terme suivant.

• Quand l’algorithme sera sorti de la boucle, la variable $\purple{\text{n}}$ contiendra donc le plus petit entier $n_0$ tel que : $u_{n_0} < \purple{\text{m}}$.
• Nous lui demandons donc d’afficher la valeur de $\purple{\text{n}}$.

• Notre programme est terminé :

Exemple

Nous souhaitons connaître le rang à partir duquel les termes de $(u_n)$ sont strictement inférieurs à $-1\,000$.
Nous entrons donc la commande $\purple{\text{seuil\textunderscore dec\textunderscore div(-1000)}}$.

• La fonction affichera en retour : $15$.

Ce que nous interprétons mathématiquement ainsi : pour tout $n \geq 15$ :

$$u_n < -1\,000$$

Remarque : si nous entrons en paramètre $\purple{\text{m}} > u_0$, la boucle ne sera pas exécutée et la fonction renverra $0$, i.e. tous les termes de la suite vérifient la condition.

Astuce

Admettons que le terme général de $(u_n)$ est donné, pour tout entier naturel $n$, par :

$$u_n=-3\times 1,5^n+4$$

• Remarquons au passage que cette définition explicite permet de montrer :
• que la limite de $(u_n)$ est $-\infty$ (par le théorème de la limite de $(q^n)$, avec $q > 1$) ;
• que, pour tout entier naturel $n$, $u_{n+1}-u_n=-1,5^{n+1} < 0$, autrement dit, que $(u_n)$ est strictement décroissante.

Nous pouvons alors éviter la création de la variable $\purple{\text{u}}$, puisque la seule connaissance du rang $n$ nous permet de connaître la valeur de $u_n$.

• Et nous intégrons alors dans la condition de $\purple{\text{while}}$ le calcul de $u_n$ :

$\begin{aligned} \textcolor{#A9A9A9}{\text{1}}&\quad\text{def seuil\textunderscore dec\textunderscore div(m):} \\ \textcolor{#A9A9A9}{\text{2}}&\quad\qquad\text{n = 0} \\ \textcolor{#A9A9A9}{\text{3}}&\quad\qquad\text{while -3 }^\ast\text{ 1.5}^{\ast\ast}\text{n + 4 >= m:} \\ \textcolor{#A9A9A9}{\text{4}}&\quad\qquad\qquad\text{n = n + 1} \\ \textcolor{#A9A9A9}{\text{5}}&\quad\qquad\text{print(n)} \end{aligned}$

Suite strictement croissante et majorée

Prérequis

Nous considérons la suite $(v_n)$ définie pour tout entier naturel $n$ par :

$$\begin{cases} v_0=2 \\ v_{n+1}=0,8v_n+5 \end{cases}$$

Nous admettons que $(v_n)$ :

• est strictement croissante ;
• est majorée par $25$ ;
• converge vers $25$.

Nous cherchons donc à connaître le rang $n_0$ à partir duquel les termes de la suite sont strictement supérieurs à un réel donné $m$.

Algorithme

Cette fois, nous allons demander au programme de calculer successivement les termes de la suite, en partant de $v_0=2$, de s’arrêter dès que le dernier terme calculé est strictement supérieur à la valeur indiquée, et d’afficher le rang de ce terme.

• Nous nommons notre fonction $\purple{\text{ seuil\textunderscore crois\textunderscore maj}}$ et elle prendra aussi en paramètre $\purple{\text{m}}$, mais ce sera cette fois le nombre auquel les termes de la suite devront être supérieurs.

Nous allons procéder de même que pour la suite $(u_n)$.

• Mais, attention, nous avons dit en préambule que $(v_n)$ est majorée par $25$.
  Cela signifie que, si le paramètre $\purple{\text{m}}$ entré est supérieur ou égal à $25$ et que nous n’avons pas prévu le cas, alors l’algorithme tournera ad infinitum, jusqu’à ce qu’on l’arrête manuellement.
• Nous vérifions donc que le $\purple{\text{m}}$ entré est bien strictement inférieur à $25$, au moyen d’une condition :

Comme tout à l’heure, nous initialisons les variables (nous changeons l’ordre cette fois, pour montrer qu’il n’est pas important dans ce cas) :

• Nous assignons à $\purple{\text{v}}$ la valeur de $v_0=2$.
• Nous assignons à $\purple{\text{n}}$ le rang $0$.

• Dans le cas de $(v_n)$, qui est strictement croissante, nous souhaitons que l’algorithme s’arrête dès que le dernier terme calculé est strictement supérieur à $\purple{\text{m}}$.
• Nous utilisons l’instruction $\purple{\text{while}}$, en faisant bien attention à la condition associée : la boucle s’exécute tant que le dernier terme calculé est inférieur ou égal à $\purple{\text{m}}$.

Selon le même principe que dans la partie 1, mais là aussi en changeant l’ordre, qui n’est pas non plus important (à vous de voir la logique que vous préférez) :

• Nous calculons le terme suivant.
• Nous incrémentons $\purple{\text{n}}$.

• Au sortir de la boucle, $\purple{\text{n}}$ contiendra le plus petit entier $n_0$ tel que : $v_{n_0} > \purple{\text{m}}$.
• C’est cette valeur qui nous intéresse.

• Nous allons maintenant dire au programme ce qu’il doit faire si le $\purple{\text{m}}$ entré est supérieur ou égal à $25$ :

• Et, dans ce cas, nous demandons simplement à l’algorithme de rappeler que la suite est majorée par $25$ et qu’aucun terme de $(u_n)$ ne sera strictement supérieur au $\purple{\text{m}}$ entré :

• L’algorithme est terminé :

Exemple

Nous souhaitons connaître le rang à partir duquel les termes de $(v_n)$ sont strictement supérieur à $24,99$.
Nous entrons donc la commande $\purple{\text{seuil\textunderscore crois\textunderscore maj(24.99)}}$.

• La fonction affichera en retour : $35$.

C’est-à-dire que, pour tout $n \geq 35$ :

$$24,99 < v_n < 25$$

Remarque : si nous entrons en paramètre $\purple{\text{m}} < v_0$, la boucle ne sera pas exécutée et la fonction renverra $0$, i.e. tous les termes de la suite vérifient la condition.

Astuce

Admettons ici que le terme général de $(v_n)$ est donné, pour tout entier naturel $n$, par :

$$v_n=-23\times 0,8^n+25$$

• Remarquons là aussi que cette définition explicite permet de montrer :
• que la limite de $(v_n)$ est $25$ (par le théorème de la limite de $(q^n)$, avec $0 < q < 1$) ;
• que, pour tout entier naturel $n$, $v_{n+1}-v_n=4,6\times 0,8^n > 0$, autrement dit, que $(v_n)$ est strictement croissante.

Sachant cela, vous pouvez maintenant adapter et simplifier l’algorithme pour qu’il donne le même résultat.

Exercice : suite strictement décroissante et minorée

Soit la suite $(w_n)$ définie pour tout entier naturel $n$ par :

$$\begin{cases} w_0=50 \\ w_{n+1}=0,7w_n+3 \end{cases}$$

On admet que $(w_n)$ :

• est strictement décroissante ;
• est minorée par $10$ ;
• converge vers $10$.

Créer une fonction $\purple{\text{seuil\textunderscore dec\textunderscore min}}$ (ou du nom qui vous plaira) qui retourne le rang à partir duquel les termes de $(w_n)$ sont strictement inférieurs à un réel $m$ donné.

Voici des exemples de retour, pour que vous puissiez vérifier que votre algorithme fonctionne :

• $\purple{\text{seuil\textunderscore dec\textunderscore min(15)}}$ affiche : $6$.
• $\purple{\text{seuil\textunderscore dec\textunderscore min(10.5)}}$ affiche : $13$.
• $\purple{\text{seuil\textunderscore dec\textunderscore min(10.1)}}$ affiche : $17$.
• $\purple{\text{seuil\textunderscore dec\textunderscore min(10.001)}}$ affiche : $30$.
• $\purple{\text{seuil\textunderscore dec\textunderscore min(10.0001)}}$ affiche : $37$.
• $\purple{\text{seuil\textunderscore dec\textunderscore min(9.5)}}$ affiche : « La suite est minorée par $10$, aucun terme ne sera strictement inférieur à $9.5$ ».