La recherche de seuils en Python, Maths

Fiche méthode

Recherche de seuils - Python

Introduction :

Dans cette fiche, nous allons voir comment programmer en Python un algorithme de seuil pour une suite numérique, c’est-à-dire un algorithme qui permet de donner le rang à partir duquel les termes de la suite respectent une condition donnée.

Par exemple, pour une suite strictement décroissante, qui diverge vers $-\infty$, nous souhaitons déterminer le rang à partir duquel les termes seront tous strictement inférieurs à une valeur donnée.
Nous commencerons donc par traiter un tel exemple. Puis, pour être complets, nous traiterons aussi le cas d’une suite strictement croissante et majorée – le principe restera toutefois le même. Enfin, un petit exercice d’application conclura le propos.

Dans les deux cas, nous travaillerons avec des suites définies par récurrence, dites arithmético-géométriques. Nous en donnerons ensuite la définition explicite, pour montrer comment alors simplifier l’algorithme.

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.

$\text{def seuil\textunderscore dec\textunderscore div(m):}$

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$.

$\begin{aligned} &\text{n = 0} \\ &\text{u = 1} \end{aligned}$

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.

$\text{while u >= m:}$

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.

$\begin{aligned} &\text{n = n + 1} \\ &\text{u = 1.5 }^{\ast}\text{ u - 2} \end{aligned}$

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}}$.

$\text{print(n)}$

Notre programme est terminé :

$\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{u = 1} \\ \textcolor{#A9A9A9}{\text{4}}&\quad\qquad\text{while u >= m:} \\ \textcolor{#A9A9A9}{\text{5}}&\quad\qquad\qquad\text{n = n + 1} \\ \textcolor{#A9A9A9}{\text{6}}&\quad\qquad\qquad\text{u = 1.5 }^{\ast}\text{ u - 2} \\ \textcolor{#A9A9A9}{\text{7}}&\quad\qquad\text{print(n)} \end{aligned}$

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.

$\text{def seuil\textunderscore crois\textunderscore maj(m):}$

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 :

$\text{if m < 25:}$

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$.

$\begin{aligned} &\text{v = 2} \\ &\text{n = 0} \\ \end{aligned}$

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}}$.

$\text{while v <= 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}}$.

$\begin{aligned} &\text{v = 0.8 $^\ast$ v + 5} \\ &\text{n = n + 1} \end{aligned}$

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.

$\text{print(n)}$

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

$\text{else:}$

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é :

$\begin{aligned} & \text{print($^{\backprime\backprime}$La suite est majorée par 25, aucun} \\ & \qquad \text{terme ne sera strictement supérieur à$^{\prime\prime}$,} \\ & \qquad \text{m)} \end{aligned}$

L’algorithme est terminé :

$\begin{aligned} \textcolor{#A9A9A9}{\text{1}}&\quad \text{def seuil\textunderscore crois\textunderscore maj(m):} \\ \textcolor{#A9A9A9}{\text{2}}&\quad\qquad\text{if m < 25:} \\ \textcolor{#A9A9A9}{\text{3}}&\quad\qquad\qquad\text{v = 2} \\ \textcolor{#A9A9A9}{\text{4}}&\quad\qquad\qquad\text{n = 0} \\ \textcolor{#A9A9A9}{\text{5}}&\quad\qquad\qquad\text{while v <= m:} \\ \textcolor{#A9A9A9}{\text{6}}&\quad\qquad\qquad\qquad\text{v = 0.8 $^\ast$ v + 5} \\ \textcolor{#A9A9A9}{\text{7}}&\quad\qquad\qquad\qquad\text{n = n + 1} \\ \textcolor{#A9A9A9}{\text{8}}&\quad\qquad\qquad\text{print(n)} \\ \textcolor{#A9A9A9}{\text{9}}&\quad\qquad\text{else:} \\ \textcolor{#A9A9A9}{\text{10}}&\quad\qquad\qquad \text{print($^{\backprime\backprime}$La suite est majorée par 25, aucun} \\ &\quad\qquad\qquad \text{terme ne sera strictement supérieur à$^{\prime\prime}$,} \\ &\quad\qquad\qquad \text{m)} \end{aligned}$

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$ ».