ATLAS Ouvrir dans l'atlas →

ExerciceTerminale, chapitre 5 — Fonctions exponentielle et logarithme · Exercices de synthèse

Exercice 30 L'algorithme de Briggs

AlgorithmiqueProblèmeDémonstration

Henry Briggs, cité dans l'introduction du cours, a construit ses tables de logarithmes sans calculatrice, à partir d'une seule opération : l'extraction de racines carrées. Cet exercice reconstitue son idée.

Partie A : le principe

Soit xx un réel strictement positif. On définit la suite (un)(u_{n}) par u0=xetun+1=unu_{0}=x \qquad\text{et}\qquad u_{n+1}=\sqrt{u_{n}}

1. Démontrer par récurrence que un>0u_{n}>0 pour tout entier naturel nn.

2. Démontrer par récurrence que, pour tout entier naturel nn : ln⁡(un)=ln⁡(x)2 n\ln\left(u_{n}\right)=\frac{\ln(x)}{2^{\,n}}

3. En déduire la limite de ln⁡(un)\ln\left(u_{n}\right), puis celle de unu_{n}.

4. On pose vn=2 n(un−1)v_{n}=2^{\,n}\left(u_{n}-1\right). Démontrer que, tant que un≠1u_{n}\neq 1 : vn=ln⁡(x)×un−1ln⁡(un)v_{n}=\ln(x)\times\frac{u_{n}-1}{\ln\left(u_{n}\right)}

5. On pose tn=un−1t_{n}=u_{n}-1. Justifier que tnt_{n} tend vers 00, puis que un−1ln⁡(un)=tnln⁡(1+tn)\frac{u_{n}-1}{\ln\left(u_{n}\right)}=\frac{t_{n}}{\ln\left(1+t_{n}\right)}

6. En utilisant la limite lim⁡t→0ln⁡(1+t)t=1\displaystyle\lim_{t\to 0}\frac{\ln(1+t)}{t}=1 du cours, conclure que la suite (vn)(v_{n}) converge vers ln⁡(x)\ln(x).

Partie B : l'algorithme

7. Recopier et compléter la fonction Python suivante, qui renvoie la valeur approchée vnv_{n} du logarithme de xx :

from math import sqrt

def briggs(x, n):
    u = x
    for i in range(n):
        u = ...
    return ...

8. On applique cet algorithme à x=2x=2. Recopier et compléter le tableau suivant, à l'aide d'une calculatrice ou d'un ordinateur.

n51020304050vn\begin{array}{|c|c|c|c|c|c|c|} \hline n & 5 & 10 & 20 & 30 & 40 & 50 \\ \hline v_{n} & & & & & & \\ \hline \end{array}

On rappelle que ln⁡(2)≈0,693 147 180 6\ln(2)\approx 0{,}693\,147\,180\,6.

9. Décrire ce que l'on observe lorsque nn dépasse 3030. Le résultat se rapproche-t-il encore de ln⁡(2)\ln(2) ?

10. Proposer une explication. On pourra remarquer que unu_{n} devient extrêmement proche de 11, et réfléchir à ce que devient la soustraction un−1u_{n}-1 dans une machine qui ne conserve qu'une quinzaine de chiffres significatifs.

11. Quelle valeur de nn conseilleriez-vous à un utilisateur de cet algorithme ?

Corrigé

Partie A

1. Démontrons par récurrence la propriété Pn:« un>0 »P_n : \text{« } u_{n}>0 \text{ »}.

Initialisation : u0=x>0u_{0}=x>0 par hypothèse, donc P0P_0 est vraie.

Hérédité : Soit k∈ℕk\in\mathbb{N}. Supposons uk>0u_{k}>0. Alors uk\sqrt{u_{k}} existe et est strictement positif, donc uk+1>0u_{k+1}>0 : la propriété Pk+1P_{k+1} est vraie.

Conclusion : Par principe de récurrence, un>0 pour tout n∈ℕ.\boxed{u_{n}>0 \text{ pour tout } n\in\mathbb{N}.}

Cette étape n'est pas une formalité : elle garantit que la racine carrée et le logarithme utilisés ensuite ont bien un sens.

2. Démontrons par récurrence la propriété Pn:« ln⁡(un)=ln⁡(x)2 n »P_n : \text{« } \ln\left(u_{n}\right)=\dfrac{\ln(x)}{2^{\,n}} \text{ »}.

Initialisation : Pour n=0n=0 : ln⁡(u0)=ln⁡(x)\ln\left(u_{0}\right)=\ln(x) et ln⁡(x)20=ln⁡(x)\dfrac{\ln(x)}{2^{0}}=\ln(x). Vrai.

Hérédité : Soit k∈ℕk\in\mathbb{N}. Supposons ln⁡(uk)=ln⁡(x)2 k\ln\left(u_{k}\right)=\dfrac{\ln(x)}{2^{\,k}}. Alors, en utilisant ln⁡(a)=12ln⁡(a)\ln\left(\sqrt{a}\right)=\dfrac{1}{2}\ln(a) : ln⁡(uk+1)=ln⁡(uk)=12ln⁡(uk)=12×ln⁡(x)2 k=ln⁡(x)2 k+1\ln\left(u_{k+1}\right)=\ln\left(\sqrt{u_{k}}\right)=\frac{1}{2}\ln\left(u_{k}\right) =\frac{1}{2}\times\frac{\ln(x)}{2^{\,k}}=\frac{\ln(x)}{2^{\,k+1}}

Conclusion : Pour tout n∈ℕ, ln⁡(un)=ln⁡(x)2 n.\boxed{\text{Pour tout } n\in\mathbb{N},\ \ln\left(u_{n}\right)=\dfrac{\ln(x)}{2^{\,n}}.}

3. Le numérateur ln⁡(x)\ln(x) est un nombre fixé, tandis que 2 n→+∞2^{\,n}\to+\infty : lim⁡n→+∞ln⁡(un)=0\boxed{\lim_{n\to+\infty}\ln\left(u_{n}\right)=0} Comme un=eln⁡(un)u_{n}=\mathrm{e}^{\ln\left(u_{n}\right)} et que la fonction exponentielle est continue en 00 : lim⁡n→+∞un=e0=1\boxed{\lim_{n\to+\infty}u_{n}=\mathrm{e}^{0}=1}

4. De la question 2 on tire 2 n=ln⁡(x)ln⁡(un)2^{\,n}=\dfrac{\ln(x)}{\ln\left(u_{n}\right)}, valable tant que ln⁡(un)≠0\ln\left(u_{n}\right)\neq 0, c'est-à-dire tant que un≠1u_{n}\neq 1. En reportant : vn=2 n(un−1)=ln⁡(x)×un−1ln⁡(un)v_{n}=2^{\,n}\left(u_{n}-1\right) =\boxed{\ln(x)\times\frac{u_{n}-1}{\ln\left(u_{n}\right)}}

5. D'après la question 3, un→1u_{n}\to 1, donc tn=un−1⟶0\boxed{t_{n}=u_{n}-1\longrightarrow 0}. De plus un=1+tnu_{n}=1+t_{n}, d'où un−1ln⁡(un)=tnln⁡(1+tn)\frac{u_{n}-1}{\ln\left(u_{n}\right)}=\boxed{\frac{t_{n}}{\ln\left(1+t_{n}\right)}}

6. La limite du cours lim⁡t→0ln⁡(1+t)t=1\displaystyle\lim_{t\to 0}\frac{\ln(1+t)}{t}=1 donne, par passage à l'inverse, tnln⁡(1+tn)⟶1\dfrac{t_{n}}{\ln\left(1+t_{n}\right)}\longrightarrow 1. Par produit : vn=ln⁡(x)×tnln⁡(1+tn)⟶ln⁡(x)×1v_{n}=\ln(x)\times\frac{t_{n}}{\ln\left(1+t_{n}\right)}\longrightarrow \ln(x)\times 1

lim⁡n→+∞vn=ln⁡(x)\boxed{\lim_{n\to+\infty}v_{n}=\ln(x)} L'algorithme calcule donc bien un logarithme, à partir de la seule extraction de racines carrées — ce que Briggs savait faire à la main.

Partie B

7.

from math import sqrt

def briggs(x, n):
    u = x
    for i in range(n):
        u = sqrt(u)
    return 2**n * (u - 1)

8. Pour x=2x=2 :

n51020304050vn0,700 7090,693 3820,693 14740,693 14720,693 1150,5\begin{array}{|c|c|c|c|c|c|c|} \hline n & 5 & 10 & 20 & 30 & 40 & 50 \\ \hline v_{n} & 0{,}700\,709 & 0{,}693\,382 & 0{,}693\,1474 & 0{,}693\,1472 & 0{,}693\,115 & 0{,}5 \\ \hline \end{array}

9. Jusqu'à n=30n=30, l'approximation s'améliore régulièrement : l'erreur passe de 8×10−38\times 10^{-3} à 2×10−92\times 10^{-9}. Puis tout se dégrade brutalement. Pour n=40 on perd cinq deˊcimales, et pour n=50 le reˊsultat 0,5 est absurde.\boxed{\text{Pour } n=40 \text{ on perd cinq décimales, et pour } n=50 \text{ le résultat } 0{,}5 \text{ est absurde.}} En poursuivant, on obtiendrait même 00 pour n=60n=60.

10. Le nombre unu_{n} devient extrêmement proche de 11. Or une machine ne conserve qu'une quinzaine de chiffres significatifs : lorsque unu_{n} vaut par exemple 1,000 000 000 000 61{,}000\,000\,000\,000\,6, la soustraction un−1u_{n}-1 ne conserve qu'un seul chiffre exact, tous les autres ayant été perdus au moment de l'arrondi de unu_{n}. C’est le pheˊnomeˋne de 𝐜𝐚𝐧𝐜𝐞𝐥𝐥𝐚𝐭𝐢𝐨𝐧 : soustraire deux nombres treˋs prochesdeˊtruit la preˊcision. Le facteur 2 n amplifie ensuite l’erreur commise.\boxed{\begin{array}{l} \text{C'est le phénomène de \textbf{cancellation} : soustraire deux nombres très proches}\\[1mm] \text{détruit la précision. Le facteur } 2^{\,n} \text{ amplifie ensuite l'erreur commise.} \end{array}}

11. Le meilleur compromis se situe autour de n=25 aˋ 30\boxed{n=25 \text{ à } 30} : assez grand pour que tnt_{n} soit petit, assez petit pour que la soustraction reste fiable.

Il est remarquable qu'augmenter le nombre d'itérations puisse dégrader le résultat : en analyse numérique, plus de calculs ne signifie pas toujours plus de précision.

Dans l'édifice

Thèmes

logarithme, limite, suite, récurrence, Python

Notions

logarithme, suite

Ouvrir dans l'atlas interactif →