Suites Géométriques, Limites et Applications - Exercices BTS CIEL (Xcas & Trinket)

Correction Exercice 1 : Défragmentation d'un Disque Dur

Question 1 : Montrez que la suite $(F_n)$ est géométrique et déterminez sa raison.

Pour montrer qu'une suite $(F_n)$ est géométrique, nous devons vérifier que le rapport entre un terme et le terme précédent est constant, c'est-à-dire que $\frac{F_{n+1}}{F_n}$ est une constante pour tout $n$. Dans ce problème, la fragmentation est réduite de 15% à chaque passe. Cela signifie que si la fragmentation est $F_n$ après $n$ passes, la fragmentation après la passe suivante $F_{n+1}$ sera $F_n$ diminuée de 15% de $F_n$.

Mathématiquement, cela s'écrit :

$F_{n+1} = F_n - 0.15 \times F_n = F_n (1 - 0.15) = 0.85 \times F_n$.

Le rapport $\frac{F_{n+1}}{F_n} = 0.85$ est constant et ne dépend pas de $n$. Par conséquent, la suite $(F_n)$ est géométrique de raison $q = 0.85$.

Question 2 : Exprimez $F_n$ en fonction de $n$.

Pour une suite géométrique $(F_n)$ de premier terme $F_0$ et de raison $q$, l'expression du terme général $F_n$ en fonction de $n$ est donnée par la formule : $F_n = F_0 \times q^n$.

Dans notre cas, le premier terme est $F_0 = 60\%$ et la raison est $q = 0.85$. Donc, l'expression de $F_n$ en fonction de $n$ est :

$F_n = 60 \times (0.85)^n$.

Question 3 : Calculez avec Xcas le pourcentage de fragmentation après 4 passes. Arrondissez à deux décimales. Utilisez la console Xcas intégrée ci-dessous.

Pour calculer $F_4$, nous utilisons la formule trouvée à la question précédente avec $n=4$. Nous pouvons utiliser Xcas pour effectuer ce calcul. Dans la console Xcas, nous pouvons entrer la commande F(4) := 60*(0.85)^4; F(4);. Xcas retournera la valeur de $F_4$.

Exécution dans Xcas :

F(n) := 60 * (0.85)^n;
F(4);
                    

Xcas retourne environ 31.355025. En arrondissant à deux décimales, on obtient $31.36\%$. Donc, après 4 passes, le pourcentage de fragmentation est d'environ $31.36\%$.

Question 4 : Déterminez avec Xcas la limite de la suite $(F_n)$ lorsque $n$ tend vers l'infini. Interprétez ce résultat.

Pour déterminer la limite de la suite $(F_n)$ lorsque $n$ tend vers l'infini, nous devons analyser le comportement de $(0.85)^n$ lorsque $n$ devient très grand. Puisque la raison $q = 0.85$ est comprise entre $-1$ et $1$ (plus précisément, $-1 < 0.85 < 1$), nous savons que $\lim_{n \to +\infty} (0.85)^n = 0$.

Par conséquent, la limite de $F_n = 60 \times (0.85)^n$ lorsque $n \to +\infty$ est :

$\lim_{n \to +\infty} F_n = \lim_{n \to +\infty} 60 \times (0.85)^n = 60 \times \lim_{n \to +\infty} (0.85)^n = 60 \times 0 = 0$.

Nous pouvons vérifier cela avec Xcas en utilisant la commande limit(F(n), n = infinity);.

limit(F(n), n = infinity);
                    

Xcas confirme que la limite est 0.

Interprétation : La limite de la suite $(F_n)$ est 0. Cela signifie qu'à mesure que le nombre de passes de défragmentation augmente, le pourcentage de fragmentation tend vers 0%. En théorie, après un nombre infini de passes, le disque dur ne serait plus fragmenté. Bien sûr, en pratique, on ne peut pas effectuer un nombre infini de passes, mais cela indique que la fragmentation peut être réduite à un niveau négligeable avec suffisamment de passes.

Question 5 : Avec le Trinket Python en bas de page, écrivez un code Python utilisant une boucle `while` pour déterminer après combien de passes le pourcentage de fragmentation deviendra inférieur à 10%. Exécutez le code dans le Trinket et indiquez le nombre de passes.

Nous devons écrire un programme Python qui calcule les termes de la suite $(F_n)$ jusqu'à ce que $F_n < 10$. Nous allons utiliser une boucle `while` pour cela. Nous initialisons $F_n$ à $F_0 = 60$ et nous multiplions à chaque itération par la raison $0.85$. Nous comptons le nombre d'itérations (passes) jusqu'à ce que $F_n$ devienne inférieure à 10.

Voici le code Python à entrer dans le Trinket :

fragmentation = 60.0
raison = 0.85
seuil_fragmentation = 10.0
passes = 0
while fragmentation >= seuil_fragmentation:
    fragmentation = fragmentation * raison
    passes = passes + 1
print("Le pourcentage de fragmentation deviendra inférieur à %d%% après %d passes." % (int(seuil_fragmentation), passes))
                

En exécutant ce code dans le Trinket, on obtient le résultat : "Le pourcentage de fragmentation deviendra inférieur à 10% après 12 passes."

Réponse : Il faut 12 passes pour que le pourcentage de fragmentation devienne inférieur à 10%.

Correction Exercice 2 : Baisse du Taux d'Abandon de Panier

Question 1 : Justifiez que $(T_n)$ est une suite géométrique et déterminez sa raison.

Le taux d'abandon de panier est réduit de 5% chaque mois (en pourcentage relatif). Cela signifie que le nouveau taux d'abandon après un mois est obtenu en réduisant le taux actuel de 5%. Si $T_n$ est le taux d'abandon après $n$ mois, alors la réduction de 5% s'applique à $T_n$.

Donc, le taux d'abandon après $n+1$ mois, $T_{n+1}$, est égal à $T_n$ moins 5% de $T_n$. Mathématiquement :

$T_{n+1} = T_n - 0.05 \times T_n = T_n (1 - 0.05) = 0.95 \times T_n$.

Comme $T_{n+1} = 0.95 \times T_n$, et que $0.95$ est une constante indépendante de $n$, la suite $(T_n)$ est une suite géométrique de raison $q = 0.95$.

Question 2 : Exprimez $T_n$ en fonction de $n$.

Pour une suite géométrique $(T_n)$ de premier terme $T_0$ et de raison $q$, le terme général est donné par $T_n = T_0 \times q^n$. Ici, le premier terme est $T_0 = 70\%$ et la raison est $q = 0.95$. Donc, l'expression de $T_n$ en fonction de $n$ est :

$T_n = 70 \times (0.95)^n$.

Question 3 : Calculez avec Xcas le taux d'abandon après 6 mois. Arrondissez à deux décimales. Utilisez la console Xcas intégrée ci-dessous.

Nous devons calculer $T_6$. En utilisant la formule $T_n = 70 \times (0.95)^n$ avec $n=6$, nous obtenons $T_6 = 70 \times (0.95)^6$. Nous utilisons Xcas pour calculer cette valeur. Dans la console Xcas, entrez : T(n) := 70 * (0.95)^n; T(6);.

T(n) := 70 * (0.95)^n;
T(6);
                    

Xcas retourne environ 51.768759375. En arrondissant à deux décimales, nous obtenons $51.77\%$. Donc, après 6 mois, le taux d'abandon de panier sera d'environ $51.77\%$.

Question 4 : Déterminez avec Xcas la limite de la suite $(T_n)$ quand $n \rightarrow +\infty$. Interprétez cette limite.

Nous devons trouver la limite de $T_n = 70 \times (0.95)^n$ lorsque $n \rightarrow +\infty$. Puisque la raison $q = 0.95$ satisfait $-1 < 0.95 < 1$, nous savons que $\lim_{n \to +\infty} (0.95)^n = 0$.

Donc, la limite de $T_n$ est :

$\lim_{n \to +\infty} T_n = \lim_{n \to +\infty} 70 \times (0.95)^n = 70 \times \lim_{n \to +\infty} (0.95)^n = 70 \times 0 = 0$.

Nous pouvons vérifier avec Xcas en utilisant la commande limit(T(n), n = infinity);.

limit(T(n), n = infinity);
                    

Xcas confirme que la limite est 0.

Interprétation : La limite de la suite $(T_n)$ est 0. Cela signifie qu'en théorie, si les optimisations de l'UX continuent à réduire le taux d'abandon de 5% chaque mois, le taux d'abandon de panier tendra vers 0% à long terme. En d'autres termes, presque tous les visiteurs finiront par finaliser leurs achats après un temps suffisamment long. En pratique, d'autres facteurs peuvent intervenir et empêcher d'atteindre un taux de 0%, mais l'objectif est de réduire le taux d'abandon le plus possible.

Question 5 : Avec le Trinket Python en bas de page, écrivez un code Python avec une boucle `while` pour trouver après combien de mois le taux d'abandon passera sous les 50%. Exécutez le code dans le Trinket et indiquez le nombre de mois.

Nous devons utiliser une boucle `while` en Python pour déterminer le nombre de mois nécessaires pour que le taux d'abandon $T_n$ devienne inférieur à 50%. Nous initialisons le taux d'abandon à $T_0 = 70$ et le multiplions par la raison $0.95$ à chaque itération (mois). Nous comptons le nombre d'itérations jusqu'à ce que le taux d'abandon soit inférieur à 50.

Voici le code Python à entrer dans le Trinket :

taux_abandon = 70.0
raison = 0.95
seuil_abandon = 50.0
mois = 0
while taux_abandon >= seuil_abandon:
    taux_abandon = taux_abandon * raison
    mois = mois + 1
print("Le taux d'abandon passera sous les %d%% après %d mois." % (int(seuil_abandon), mois))
                    

En exécutant ce code dans le Trinket, on obtient le résultat : "Le taux d'abandon passera sous les 50% après 7 mois."

Réponse : Il faut 7 mois pour que le taux d'abandon de panier passe sous les 50%.

Correction Exercice 3 : Convergence d'une Série Géométrique

Question 1 : Calculez les 3 premières sommes partielles $S_1$, $S_2$, $S_3$ (manuellement ou avec Xcas).

La somme partielle des $n$ premiers termes d'une série géométrique est donnée par $S_n = \sum_{k=0}^{n-1} a \times r^k = a \times r^0 + a \times r^1 + \dots + a \times r^{n-1}$. Ici, le premier terme $a = 1$ et la raison $r = 0.5$.

Pour $S_1$ (somme du premier terme) :

$S_1 = \sum_{k=0}^{1-1} 1 \times (0.5)^k = (0.5)^0 = 1$.

Pour $S_2$ (somme des deux premiers termes) :

$S_2 = \sum_{k=0}^{2-1} 1 \times (0.5)^k = (0.5)^0 + (0.5)^1 = 1 + 0.5 = 1.5$.

Pour $S_3$ (somme des trois premiers termes) :

$S_3 = \sum_{k=0}^{3-1} 1 \times (0.5)^k = (0.5)^0 + (0.5)^1 + (0.5)^2 = 1 + 0.5 + 0.25 = 1.75$.

Avec Xcas, on peut utiliser la fonction sum : S(n) := sum(0.5^k, k=0..(n-1)); S(1); S(2); S(3);.

S(n) := sum(0.5^k, k=0..(n-1));
S(1); S(2); S(3);
                    

Xcas confirme que $S_1 = 1$, $S_2 = 1.5$, $S_3 = 1.75$.

Question 2 : Donnez l'expression de $S_n$ en fonction de $n$ en utilisant la formule de la somme des termes d'une suite géométrique. Vérifiez avec Xcas.

La formule pour la somme des $n$ premiers termes d'une suite géométrique de premier terme $a$ et de raison $r \neq 1$ est donnée par :

$S_n = a \times \frac{1 - r^n}{1 - r}$.

Ici, $a = 1$ et $r = 0.5$. Donc, l'expression de $S_n$ est :

$S_n = 1 \times \frac{1 - (0.5)^n}{1 - 0.5} = \frac{1 - (0.5)^n}{0.5} = 2 \times (1 - (0.5)^n) = 2 - 2 \times (0.5)^n = 2 - (0.5)^{n-1}$.

Pour vérifier avec Xcas, nous pouvons comparer l'expression de la somme directe avec la formule. Nous devons vérifier que la différence est nulle. Utilisons la commande : factor(sum(0.5^k, k=0..(n-1)) - (1 * (1-0.5^n) / (1-0.5)));.

factor(sum(0.5^k, k=0..(n-1)) - (1 * (1-0.5^n) / (1-0.5)));
                    

Xcas retourne 0, ce qui confirme que la formule est correcte.

Question 3 : Déterminez avec Xcas la limite de la suite $(S_n)$ lorsque $n$ tend vers l'infini.

Nous devons calculer la limite de $S_n = 2 - (0.5)^{n-1}$ lorsque $n \rightarrow +\infty$. Comme $-1 < 0.5 < 1$, on sait que $\lim_{n \to +\infty} (0.5)^{n-1} = 0$.

Donc, la limite de $S_n$ est :

$\lim_{n \to +\infty} S_n = \lim_{n \to +\infty} (2 - (0.5)^{n-1}) = 2 - \lim_{n \to +\infty} (0.5)^{n-1} = 2 - 0 = 2$.

Avec Xcas, nous utilisons limit(S(n), n = infinity);.

limit(S(n), n = infinity);
                    

Xcas confirme que la limite est 2.

Question 4 : Avec le Trinket Python en bas de page, écrivez un code Python avec une boucle `for` pour afficher les 10 premières sommes partielles $S_1$ à $S_{10}$. Exécutez le code dans le Trinket et notez les sommes partielles.

Nous allons utiliser une boucle `for` pour calculer et afficher les 10 premières sommes partielles $S_1, S_2, \dots, S_{10}$. Nous allons accumuler les termes de la série géométrique dans une variable somme_partielle.

Voici le code Python à entrer dans le Trinket :

raison = 0.5
somme_partielle = 0
print("Sommes partielles de la série géométrique :")
for n_index in range(1, 11):
    somme_partielle = somme_partielle + raison**(n_index-1) # Terme actuel à ajouter
    n = n_index
    print("S_%d: %.4f" % (n, somme_partielle))
                

En exécutant ce code dans le Trinket, on obtient les sommes partielles suivantes :

S_1: 1.0000

S_2: 1.5000

S_3: 1.7500

S_4: 1.8750

S_5: 1.9375

S_6: 1.9688

S_7: 1.9844

S_8: 1.9922

S_9: 1.9961

S_10: 1.9980

On observe que les sommes partielles se rapprochent de 2, ce qui est cohérent avec la limite que nous avons calculée à la question précédente.

Correction Exercice 4 : Limite de Suite Définie par Récurrence

Question 1 : Calculez avec Xcas les premiers termes $U_1$, $U_2$, $U_3$. Utilisez la console Xcas intégrée ci-dessous.

La suite est définie par récurrence $U_{n+1} = 0.8 U_n + 2$ et $U_0 = 5$. Pour calculer les premiers termes, nous appliquons la relation de récurrence de manière itérative.

Pour $U_1$ (en partant de $U_0 = 5$) :

$U_1 = 0.8 \times U_0 + 2 = 0.8 \times 5 + 2 = 4 + 2 = 6$.

Pour $U_2$ (en partant de $U_1 = 6$) :

$U_2 = 0.8 \times U_1 + 2 = 0.8 \times 6 + 2 = 4.8 + 2 = 6.8$.

Pour $U_3$ (en partant de $U_2 = 6.8$) :

$U_3 = 0.8 \times U_2 + 2 = 0.8 \times 6.8 + 2 = 5.44 + 2 = 7.44$.

Avec Xcas, nous pouvons effectuer ces calculs séquentiellement : U := 5; U := 0.8 * U + 2; U := 0.8 * U + 2; U := 0.8 * U + 2;.

U := 5; // Initialisation
U := 0.8 * U + 2; // U1
U := 0.8 * U + 2; // U2
U := 0.8 * U + 2; // U3 (affiche U3)
                    

Xcas affiche successivement 6, puis 6.8, puis 7.44, confirmant nos calculs : $U_1 = 6$, $U_2 = 6.8$, $U_3 = 7.44$.

Question 2 : Déterminez avec Xcas la limite $L$ de la suite $(U_n)$ en résolvant l'équation $L = 0.8L + 2$.

Si la suite $(U_n)$ converge vers une limite $L$, alors à la limite, $U_{n+1}$ et $U_n$ se rapprochent tous les deux de $L$. Donc, nous pouvons remplacer $U_{n+1}$ et $U_n$ par $L$ dans la relation de récurrence $U_{n+1} = 0.8 U_n + 2$ pour obtenir une équation permettant de trouver $L$ :

$L = 0.8L + 2$.

Nous devons résoudre cette équation pour $L$. Réarrangeons l'équation :

$L - 0.8L = 2$

$0.2L = 2$

$L = \frac{2}{0.2} = \frac{2}{\frac{2}{10}} = \frac{2 \times 10}{2} = 10$.

Donc, la limite possible est $L = 10$. Avec Xcas, nous pouvons résoudre directement l'équation : solve(L = 0.8*L + 2, L);.

solve(L = 0.8*L + 2, L);
                    

Xcas retourne $[L=10]$, confirmant que la limite est $L = 10$.

Question 3 : Avec le Trinket Python en bas de page, écrivez un code Python avec une boucle `while` qui calcule les termes de la suite jusqu'à ce que la différence entre deux termes consécutifs soit inférieure à $10^{-4}$. Exécutez le code dans le Trinket et notez la valeur approchée de la limite.

Nous allons utiliser une boucle `while` pour calculer les termes de la suite $(U_n)$. Nous continuerons à itérer tant que la différence absolue entre deux termes consécutifs $|U_{n+1} - U_n|$ est supérieure ou égale à $10^{-4}$. Lorsque cette différence devient inférieure à $10^{-4}$, nous considérons que la suite est suffisamment proche de sa limite et nous arrêtons l'itération. Nous afficherons alors la dernière valeur calculée de $U_{n+1}$ comme une approximation de la limite.

Voici le code Python à entrer dans le Trinket :

u_n = 5.0
u_n_plus_1 = 0.0
epsilon = 1e-4
iteration = 0
while True:
    u_n_plus_1 = 0.8 * u_n + 2
    iteration += 1
    if abs(u_n_plus_1 - u_n) < epsilon:
        break
    u_n = u_n_plus_1
print("Limite approchée après %d iterations : %.6f" % (iteration, u_n_plus_1))
                

En exécutant ce code dans le Trinket, on obtient un résultat proche de 10. Par exemple : "Limite approchée après 22 iterations : 10.000075". La valeur approchée de la limite est donc environ 10.000075, ce qui est très proche de la limite théorique $L=10$ que nous avons calculée précédemment.

Réponse : La valeur approchée de la limite obtenue par le code Python est environ 10.000075.

Correction Exercice 5 : Limite et Seuil de Précision

Question 1 : Calculez avec Xcas les premiers termes $V_0$, $V_1$, $V_2$. Utilisez la console Xcas intégrée ci-dessous.

La suite $(V_n)$ est définie par $V_n = \frac{3n+1}{n+2}$. Calculons les premiers termes en substituant $n=0, 1, 2$ dans l'expression de $V_n$.

Pour $V_0$ (en posant $n=0$) :

$V_0 = \frac{3 \times 0 + 1}{0 + 2} = \frac{1}{2} = 0.5$.

Pour $V_1$ (en posant $n=1$) :

$V_1 = \frac{3 \times 1 + 1}{1 + 2} = \frac{4}{3} \approx 1.333...$.

Pour $V_2$ (en posant $n=2$) :

$V_2 = \frac{3 \times 2 + 1}{2 + 2} = \frac{7}{4} = 1.75$.

Avec Xcas, nous utilisons les commandes : V(n) := (3*n+1) / (n+2); V(0); V(1); V(2);.

V(n) := (3*n+1) / (n+2);
V(0); V(1); V(2);
                    

Xcas retourne $1/2$, $4/3$, $7/4$, confirmant nos calculs : $V_0 = 0.5$, $V_1 = \frac{4}{3} \approx 1.333...$, $V_2 = 1.75$.

Question 2 : Déterminez avec Xcas la limite $L$ de la suite $(V_n)$ lorsque $n$ tend vers l'infini.

Pour trouver la limite de $V_n = \frac{3n+1}{n+2}$ lorsque $n \to +\infty$, nous pouvons diviser le numérateur et le dénominateur par $n$ (le terme de plus haut degré) :

$V_n = \frac{3n+1}{n+2} = \frac{n(3 + \frac{1}{n})}{n(1 + \frac{2}{n})} = \frac{3 + \frac{1}{n}}{1 + \frac{2}{n}}$.

Lorsque $n \to +\infty$, $\frac{1}{n} \to 0$ et $\frac{2}{n} \to 0$. Donc, la limite de $V_n$ est :

$\lim_{n \to +\infty} V_n = \lim_{n \to +\infty} \frac{3 + \frac{1}{n}}{1 + \frac{2}{n}} = \frac{3 + 0}{1 + 0} = \frac{3}{1} = 3$.

Nous pouvons vérifier avec Xcas en utilisant limit(V(n), n = infinity);.

limit(V(n), n = infinity);
                    

Xcas confirme que la limite est 3.

Question 3 : Déterminez théoriquement (par calcul algébrique) à partir de quel rang $n_0$ on a $|V_n - L| < 0.01$. Détaillez le calcul.

Nous voulons trouver le plus petit entier $n_0$ tel que pour tout $n \geq n_0$, $|V_n - L| < 0.01$, où $L = 3$ et $V_n = \frac{3n+1}{n+2}$. Nous devons résoudre l'inéquation :

$|V_n - 3| < 0.01$

$\left| \frac{3n+1}{n+2} - 3 \right| < 0.01$

$\left| \frac{3n+1 - 3(n+2)}{n+2} \right| < 0.01$

$\left| \frac{3n+1 - 3n - 6}{n+2} \right| < 0.01$

$\left| \frac{-5}{n+2} \right| < 0.01$

Puisque $n \geq 0$, $n+2 > 0$, donc $\left| \frac{-5}{n+2} \right| = \frac{5}{n+2}$. L'inéquation devient :

$\frac{5}{n+2} < 0.01$

$\frac{5}{n+2} < \frac{1}{100}$

$5 \times 100 < n+2$

$500 < n+2$

$n > 500 - 2$

$n > 498$.

Puisque $n$ doit être un entier, le plus petit entier $n_0$ satisfaisant $n > 498$ est $n_0 = 499$. Donc, à partir du rang $n_0 = 499$, on a $|V_n - 3| < 0.01$.

Question 4 : Vérifiez avec le Trinket Python en bas de page, en écrivant un code Python avec une boucle `while` pour trouver le premier indice $n$ tel que $|V_n - L| < 0.01$. Exécutez le code dans le Trinket et indiquez cet indice.

Nous allons écrire un code Python qui calcule les termes $V_n$ et vérifie la condition $|V_n - 3| < 0.01$. Nous utiliserons une boucle `while` pour incrémenter $n$ à partir de 0 jusqu'à ce que la condition soit satisfaite pour la première fois. Nous afficherons alors cet indice $n$.

Voici le code Python à entrer dans le Trinket :

def v_n(n):
    return (3*n + 1) / (n + 2)

limite_l = 3
precision = 0.01
n_indice = 0
while abs(v_n(n_indice) - limite_l) >= precision:
    n_indice += 1
print("Le premier indice n tel que |V_n - L| < %.2f est : %d" % (precision, n_indice))
                    

En exécutant ce code dans le Trinket, on obtient le résultat : "Le premier indice n tel que |V_n - L| < 0.01 est : 499". Ce résultat correspond à notre calcul théorique, qui a trouvé $n_0 = 499$.

Réponse : Le premier indice $n$ tel que $|V_n - L| < 0.01$ est $n = 499$.

Correction Exercice 6 : Population de bactéries

Question 1 : Montrez que $(P_n)$ est géométrique et donnez sa raison.

La population de bactéries augmente de 10% par heure. Si $P_n$ est la population après $n$ heures, alors pour obtenir la population après $n+1$ heures, $P_{n+1}$, nous devons ajouter 10% de $P_n$ à $P_n$.

Mathématiquement :

$P_{n+1} = P_n + 0.10 \times P_n = P_n (1 + 0.10) = 1.10 \times P_n$.

Puisque $P_{n+1} = 1.10 \times P_n$, et que $1.10$ est une constante indépendante de $n$, la suite $(P_n)$ est une suite géométrique de raison $q = 1.10$.

Question 2 : Calculez avec Xcas la population après 5 heures.

Le premier terme est $P_0 = 1000$ et la raison est $q = 1.10$. L'expression de $P_n$ est donc $P_n = P_0 \times q^n = 1000 \times (1.10)^n$. Pour calculer la population après 5 heures, nous devons calculer $P_5 = 1000 \times (1.10)^5$.

Avec Xcas, utilisez les commandes : P(n) := 1000 * (1.1)^n; P(5);.

P(n) := 1000 * (1.1)^n;
P(5);
                    

Xcas retourne 1610.51. Donc, après 5 heures, la population de bactéries sera d'environ 1610.51 bactéries. Puisqu'il s'agit de bactéries, on pourrait arrondir à l'entier le plus proche, soit 1611 bactéries.

Question 3 : Déterminez avec Xcas la limite de $(P_n)$ si elle existait. Interprétez.

Nous devons trouver la limite de $P_n = 1000 \times (1.10)^n$ lorsque $n \to +\infty$. La raison est $q = 1.10$. Puisque $q = 1.10 > 1$, nous savons que $\lim_{n \to +\infty} (1.10)^n = +\infty$.

Donc, la limite de $P_n$ est :

$\lim_{n \to +\infty} P_n = \lim_{n \to +\infty} 1000 \times (1.10)^n = 1000 \times \lim_{n \to +\infty} (1.10)^n = +\infty$.

Avec Xcas, utilisez limit(P(n), n = infinity);.

limit(P(n), n = infinity);
                    

Xcas confirme que la limite est $\infty$.

Interprétation : La limite de la suite $(P_n)$ est $+\infty$. Cela signifie que si la population de bactéries continue d'augmenter de 10% chaque heure sans limitation, la population croîtra indéfiniment et tendra vers l'infini. En réalité, la croissance de la population de bactéries serait limitée par des facteurs tels que l'espace et les ressources disponibles, mais dans ce modèle simple, la population augmente sans borne.

Question 4 : Avec le Trinket Python en bas de page, déterminez après combien d'heures la population dépassera 5000 bactéries.

Nous devons utiliser une boucle `while` en Python pour déterminer après combien d'heures la population $P_n$ dépassera 5000. Nous initialisons la population à $P_0 = 1000$ et la multiplions par la raison $1.10$ à chaque itération (heure). Nous comptons le nombre d'itérations jusqu'à ce que la population dépasse 5000.

Voici le code Python à entrer dans le Trinket :

population = 1000
raison = 1.1
seuil_population = 5000
heures = 0
while population <= seuil_population:
    population = population * raison
    heures += 1
print("La population dépassera %d bactéries après %d heures." % (seuil_population, heures))
                    

En exécutant ce code dans le Trinket, on obtient le résultat : "La population dépassera 5000 bactéries après 17 heures."

Réponse : Il faut 17 heures pour que la population de bactéries dépasse 5000.

Correction Exercice 7 : Refroidissement d'un Composant Électronique

Question 1 : Justifiez que $(C_n)$ est géométrique et donnez sa raison.

Le composant électronique refroidit de 5% par minute. Si $C_n$ est la température après $n$ minutes, alors pour obtenir la température après $n+1$ minutes, $C_{n+1}$, nous devons réduire $C_n$ de 5%. C'est-à-dire, la température restante est $100\% - 5\% = 95\%$ de la température précédente.

Mathématiquement :

$C_{n+1} = C_n - 0.05 \times C_n = C_n (1 - 0.05) = 0.95 \times C_n$.

Puisque $C_{n+1} = 0.95 \times C_n$, et que $0.95$ est une constante indépendante de $n$, la suite $(C_n)$ est une suite géométrique de raison $q = 0.95$.

Question 2 : Calculez avec Xcas la température après 10 minutes.

La température initiale est $C_0 = 80^\circ C$ et la raison est $q = 0.95$. L'expression de $C_n$ est $C_n = C_0 \times q^n = 80 \times (0.95)^n$. Pour calculer la température après 10 minutes, nous devons calculer $C_{10} = 80 \times (0.95)^{10}$.

Avec Xcas, utilisez les commandes : C(n) := 80 * (0.95)^n; C(10);.

C(n) := 80 * (0.95)^n;
C(10);
                    

Xcas retourne environ 47.834543534. Donc, après 10 minutes, la température du composant électronique sera d'environ $47.83^\circ C$ (en arrondissant à deux décimales).

Question 3 : Déterminez avec Xcas la limite de $(C_n)$. Interprétez.

Nous devons trouver la limite de $C_n = 80 \times (0.95)^n$ lorsque $n \to +\infty$. La raison est $q = 0.95$. Puisque $-1 < 0.95 < 1$, nous savons que $\lim_{n \to +\infty} (0.95)^n = 0$.

Donc, la limite de $C_n$ est :

$\lim_{n \to +\infty} C_n = \lim_{n \to +\infty} 80 \times (0.95)^n = 80 \times \lim_{n \to +\infty} (0.95)^n = 80 \times 0 = 0$.

Avec Xcas, utilisez limit(C(n), n = infinity);.

limit(C(n), n = infinity);
                    

Xcas confirme que la limite est 0.

Interprétation : La limite de la suite $(C_n)$ est $0^\circ C$. Cela signifie qu'en théorie, si le composant continue de refroidir de 5% par minute, sa température tendra vers $0^\circ C$ à long terme. En réalité, la température ne peut pas descendre en dessous du zéro absolu, et dans un environnement ambiant, elle se stabilisera probablement à la température ambiante. Cependant, dans ce modèle simple, la température tend vers $0^\circ C$.

Question 4 : Avec le Trinket Python en bas de page, trouvez après combien de minutes la température sera inférieure à 50°C.

Nous devons utiliser une boucle `while` en Python pour déterminer après combien de minutes la température $C_n$ sera inférieure à $50^\circ C$. Nous initialisons la température à $C_0 = 80^\circ C$ et la multiplions par la raison $0.95$ à chaque itération (minute). Nous comptons le nombre d'itérations jusqu'à ce que la température soit inférieure à 50.

Voici le code Python à entrer dans le Trinket :

temperature = 80.0
raison = 0.95
seuil_temperature = 50.0
minutes = 0
while temperature >= seuil_temperature:
    temperature = temperature * raison
    minutes += 1
print("La température sera inférieure à %d°C après %d minutes." % (int(seuil_temperature), minutes))
                    

En exécutant ce code dans le Trinket, on obtient le résultat : "La température sera inférieure à 50°C après 11 minutes."

Réponse : Il faut 11 minutes pour que la température du composant électronique devienne inférieure à $50^\circ C$.

Correction Exercice 8 : Capitalisation d'Intérêts Composés

Question 1 : Montrez que $(K_n)$ est géométrique et donnez sa raison.

Le capital est placé à un taux d'intérêt annuel de 3% capitalisés annuellement. Si $K_n$ est le capital après $n$ années, alors pour obtenir le capital après $n+1$ années, $K_{n+1}$, nous devons ajouter 3% d'intérêts à $K_n$. C'est-à-dire, le nouveau capital est $100\% + 3\% = 103\%$ de l'ancien capital.

Mathématiquement :

$K_{n+1} = K_n + 0.03 \times K_n = K_n (1 + 0.03) = 1.03 \times K_n$.

Puisque $K_{n+1} = 1.03 \times K_n$, et que $1.03$ est une constante indépendante de $n$, la suite $(K_n)$ est une suite géométrique de raison $q = 1.03$.

Question 2 : Calculez avec Xcas le capital après 20 ans.

Le capital initial est $K_0 = 1000€$ et la raison est $q = 1.03$. L'expression de $K_n$ est $K_n = K_0 \times q^n = 1000 \times (1.03)^n$. Pour calculer le capital après 20 ans, nous devons calculer $K_{20} = 1000 \times (1.03)^{20}$.

Avec Xcas, utilisez les commandes : K(n) := 1000 * (1.03)^n; K(20);.

K(n) := 1000 * (1.03)^n;
K(20);
                    

Xcas retourne environ 1806.11123467. Donc, après 20 ans, le capital sera d'environ 1806.11€ (en arrondissant à deux décimales).

Question 3 : Déterminez avec Xcas la limite de $(K_n)$ si elle existait. Interprétez.

Nous devons trouver la limite de $K_n = 1000 \times (1.03)^n$ lorsque $n \to +\infty$. La raison est $q = 1.03$. Puisque $q = 1.03 > 1$, nous savons que $\lim_{n \to +\infty} (1.03)^n = +\infty$.

Donc, la limite de $K_n$ est :

$\lim_{n \to +\infty} K_n = \lim_{n \to +\infty} 1000 \times (1.03)^n = 1000 \times \lim_{n \to +\infty} (1.03)^n = +\infty$.

Avec Xcas, utilisez limit(K(n), n = infinity);.

limit(K(n), n = infinity);
                    

Xcas confirme que la limite est $\infty$.

Interprétation : La limite de la suite $(K_n)$ est $+\infty$. Cela signifie qu'en théorie, si les intérêts sont capitalisés annuellement à un taux de 3%, le capital croîtra indéfiniment et tendra vers l'infini à long terme. C'est le principe de la capitalisation des intérêts : plus le temps passe, plus les intérêts générés s'ajoutent au capital et génèrent à leur tour des intérêts, conduisant à une croissance exponentielle.

Question 4 : Avec le Trinket Python en bas de page, déterminez après combien d'années le capital aura doublé.

Nous devons utiliser une boucle `while` en Python pour déterminer après combien d'années le capital $K_n$ aura doublé, c'est-à-dire deviendra au moins $2 \times 1000 = 2000€$. Nous initialisons le capital à $K_0 = 1000€$ et le multiplions par la raison $1.03$ à chaque itération (année). Nous comptons le nombre d'itérations jusqu'à ce que le capital soit au moins 2000€.

Voici le code Python à entrer dans le Trinket :

capital = 1000
raison = 1.03
capital_double = 2 * capital
annees = 0
while capital <= capital_double:
    capital = capital * raison
    annees = annees + 1
print("Le capital aura doublé après %d années." % (annees))
                    

En exécutant ce code dans le Trinket, on obtient le résultat : "Le capital aura doublé après 24 années."

Réponse : Il faut 24 ans pour que le capital initial double.

Correction Exercice 9 : Décroissance Radioactive

Question 1 : Justifiez que $(M_n)$ est géométrique et donnez sa raison.

La substance radioactive perd 2% de sa masse chaque siècle. Si $M_n$ est la masse restante après $n$ siècles, alors pour obtenir la masse restante après $n+1$ siècles, $M_{n+1}$, nous devons réduire $M_n$ de 2%. C'est-à-dire, la masse restante est $100\% - 2\% = 98\%$ de la masse précédente.

Mathématiquement :

$M_{n+1} = M_n - 0.02 \times M_n = M_n (1 - 0.02) = 0.98 \times M_n$.

Puisque $M_{n+1} = 0.98 \times M_n$, et que $0.98$ est une constante indépendante de $n$, la suite $(M_n)$ est une suite géométrique de raison $q = 0.98$.

Question 2 : Calculez avec Xcas la masse restante après 10 siècles.

La masse initiale est $M_0 = 500g$ et la raison est $q = 0.98$. L'expression de $M_n$ est $M_n = M_0 \times q^n = 500 \times (0.98)^n$. Pour calculer la masse restante après 10 siècles, nous devons calculer $M_{10} = 500 \times (0.98)^{10}$.

Avec Xcas, utilisez les commandes : M(n) := 500 * (0.98)^n; M(10);.

M(n) := 500 * (0.98)^n;
M(10);
                    

Xcas retourne environ 409.13523387. Donc, après 10 siècles, la masse restante sera d'environ $409.14g$ (en arrondissant à deux décimales).

Question 3 : Déterminez avec Xcas la limite de $(M_n)$. Interprétez.

Nous devons trouver la limite de $M_n = 500 \times (0.98)^n$ lorsque $n \to +\infty$. La raison est $q = 0.98$. Puisque $-1 < 0.98 < 1$, nous savons que $\lim_{n \to +\infty} (0.98)^n = 0$.

Donc, la limite de $M_n$ est :

$\lim_{n \to +\infty} M_n = \lim_{n \to +\infty} 500 \times (0.98)^n = 500 \times \lim_{n \to +\infty} (0.98)^n = 500 \times 0 = 0$.

Avec Xcas, utilisez limit(M(n), n = infinity);.

limit(M(n), n = infinity);
                    

Xcas confirme que la limite est 0.

Interprétation : La limite de la suite $(M_n)$ est $0g$. Cela signifie qu'en théorie, si la substance radioactive continue de perdre 2% de sa masse chaque siècle, la masse restante tendra vers $0g$ à long terme. C'est le principe de la décroissance radioactive : la substance se désintègre progressivement, et en théorie, après un temps infiniment long, il ne restera plus de substance radioactive.

Question 4 : Avec le Trinket Python en bas de page, déterminez après combien de siècles la masse restante sera inférieure à 250g (la moitié de la masse initiale).

Nous devons utiliser une boucle `while` en Python pour déterminer après combien de siècles la masse restante $M_n$ sera inférieure à $250g$, qui est la moitié de la masse initiale de $500g$. Nous initialisons la masse à $M_0 = 500g$ et la multiplions par la raison $0.98$ à chaque itération (siècle). Nous comptons le nombre d'itérations jusqu'à ce que la masse soit inférieure à 250g.

Voici le code Python à entrer dans le Trinket :

masse = 500.0
raison = 0.98
seuil_masse = 250.0
siecles = 0
while masse >= seuil_masse:
    masse = masse * raison
    siecles += 1
print("La masse restante sera inférieure à %d g après %d siècles." % (int(seuil_masse), siecles))
                    

En exécutant ce code dans le Trinket, on obtient le résultat : "La masse restante sera inférieure à 250 g après 34 siècles."

Réponse : Il faut 34 siècles pour que la masse restante de la substance radioactive devienne inférieure à 250g.

Correction Exercice 10 : Propagation d'une Rumeur

Question 1 : Montrez que $(R_n)$ est géométrique et donnez sa raison.

Le nombre de personnes au courant de la rumeur double chaque jour. Si $R_n$ est le nombre de personnes connaissant la rumeur après $n$ jours, alors pour obtenir le nombre de personnes après $n+1$ jours, $R_{n+1}$, nous devons doubler le nombre de personnes du jour précédent.

Mathématiquement :

$R_{n+1} = 2 \times R_n$.

Puisque $R_{n+1} = 2 \times R_n$, et que $2$ est une constante indépendante de $n$, la suite $(R_n)$ est une suite géométrique de raison $q = 2$.

Question 2 : Calculez avec Xcas le nombre de personnes au courant après 7 jours.

Le nombre initial de personnes au courant est $R_0 = 10$ et la raison est $q = 2$. L'expression de $R_n$ est $R_n = R_0 \times q^n = 10 \times 2^n$. Pour calculer le nombre de personnes au courant après 7 jours, nous devons calculer $R_7 = 10 \times 2^7$.

Avec Xcas, utilisez les commandes : R(n) := 10 * (2)^n; R(7);.

R(n) := 10 * (2)^n;
R(7);
                    

Xcas retourne 1280. Donc, après 7 jours, 1280 personnes seront au courant de la rumeur.

Question 3 : Déterminez avec Xcas la limite de $(R_n)$ si on ne considérait pas la taille finie de la population. Interprétez.

Nous devons trouver la limite de $R_n = 10 \times 2^n$ lorsque $n \to +\infty$. La raison est $q = 2$. Puisque $q = 2 > 1$, nous savons que $\lim_{n \to +\infty} 2^n = +\infty$.

Donc, la limite de $R_n$ est :

$\lim_{n \to +\infty} R_n = \lim_{n \to +\infty} 10 \times 2^n = 10 \times \lim_{n \to +\infty} 2^n = +\infty$.

Avec Xcas, utilisez limit(R(n), n = infinity);.

limit(R(n), n = infinity);
                    

Xcas confirme que la limite est $\infty$.

Interprétation : La limite de la suite $(R_n)$ est $+\infty$. Cela signifie que si la rumeur continue de se propager en doublant le nombre de personnes au courant chaque jour sans limitation, le nombre de personnes au courant tendra vers l'infini à long terme. Cependant, dans une population finie de 2000 personnes, le nombre de personnes au courant ne peut pas dépasser 2000. Le modèle géométrique simple de doublement suggère une croissance très rapide, mais il ne tient pas compte de la saturation due à la taille finie de la population.

Question 4 : Avec le Trinket Python en bas de page, déterminez après combien de jours plus de la moitié de la population (1000 personnes) sera au courant de la rumeur.

Nous devons utiliser une boucle `while` en Python pour déterminer après combien de jours le nombre de personnes au courant $R_n$ dépassera 1000 personnes (la moitié de la population de 2000). Nous initialisons le nombre de personnes au courant à $R_0 = 10$ et le multiplions par la raison $2$ à chaque itération (jour). Nous comptons le nombre d'itérations jusqu'à ce que le nombre de personnes au courant dépasse 1000.

Voici le code Python à entrer dans le Trinket :

rum_initial = 10
raison = 2
seuil_rum = 1000 # Moitié de la population
jours = 0
rum_courante = rum_initial
while rum_courante <= seuil_rum:
    rum_courante = rum_courante * raison
    jours += 1
print("Plus de la moitié de la population sera au courant après %d jours." % (jours))
                    

En exécutant ce code dans le Trinket, on obtient le résultat : "Plus de la moitié de la population sera au courant après 7 jours."

Réponse : Il faut 7 jours pour que plus de la moitié de la population (plus de 1000 personnes) soit au courant de la rumeur.

Correction Exercice 11 : Amortissement Linéaire (Note: Il y a une erreur dans l'intitulé, il s'agit d'un amortissement géométrique, pas linéaire)

Question 1 : Montrez que $(V_n)$ est géométrique et donnez sa raison.

Le matériel informatique se déprécie de 10% par an. Si $V_n$ est la valeur après $n$ années, alors pour obtenir la valeur après $n+1$ années, $V_{n+1}$, nous devons réduire $V_n$ de 10%. C'est-à-dire, la valeur restante est $100\% - 10\% = 90\%$ de la valeur précédente.

Mathématiquement :

$V_{n+1} = V_n - 0.10 \times V_n = V_n (1 - 0.10) = 0.90 \times V_n$.

Puisque $V_{n+1} = 0.90 \times V_n$, et que $0.90$ est une constante indépendante de $n$, la suite $(V_n)$ est une suite géométrique de raison $q = 0.90$.

Question 2 : Calculez avec Xcas la valeur après 5 ans.

La valeur initiale est $V_0 = 5000€$ et la raison est $q = 0.90$. L'expression de $V_n$ est $V_n = V_0 \times q^n = 5000 \times (0.90)^n$. Pour calculer la valeur après 5 ans, nous devons calculer $V_5 = 5000 \times (0.90)^5$.

Avec Xcas, utilisez les commandes : V(n) := 5000 * (0.9)^n; V(5);.

V(n) := 5000 * (0.9)^n;
V(5);
                    

Xcas retourne 2952.45. Donc, après 5 ans, la valeur du matériel informatique sera d'environ $2952.45€$ (en arrondissant à deux décimales).

Question 3 : Déterminez avec Xcas la limite de $(V_n)$. Interprétez.

Nous devons trouver la limite de $V_n = 5000 \times (0.90)^n$ lorsque $n \to +\infty$. La raison est $q = 0.90$. Puisque $-1 < 0.90 < 1$, nous savons que $\lim_{n \to +\infty} (0.90)^n = 0$.

Donc, la limite de $V_n$ est :

$\lim_{n \to +\infty} V_n = \lim_{n \to +\infty} 5000 \times (0.90)^n = 5000 \times $\lim_{n \to +\infty} (0.90)^n = 5000 \times 0 = 0$.

Avec Xcas, utilisez limit(V(n), n = infinity);.

limit(V(n), n = infinity);
                    

Xcas confirme que la limite est 0.

Interprétation : La limite de la suite $(V_n)$ est $0€$. Cela signifie qu'en théorie, si le matériel continue de se déprécier de 10% par an, sa valeur tendra vers $0€$ à long terme. En réalité, la valeur du matériel ne deviendra peut-être jamais exactement 0€, mais elle deviendra négligeable après un certain nombre d'années, selon ce modèle de dépréciation.

Question 4 : Avec le Trinket Python en bas de page, déterminez après combien d'années la valeur sera inférieure à 2000€.

Nous devons utiliser une boucle `while` en Python pour déterminer après combien d'années la valeur $V_n$ sera inférieure à $2000€$. Nous initialisons la valeur à $V_0 = 5000€$ et la multiplions par la raison $0.90$ à chaque itération (année). Nous comptons le nombre d'itérations jusqu'à ce que la valeur soit inférieure à 2000€.

Voici le code Python à entrer dans le Trinket :

valeur = 5000
raison = 0.9
seuil_valeur = 2000
annees = 0
while valeur >= seuil_valeur:
    valeur = valeur * raison
    annees = annees + 1
print("La valeur sera inférieure à %d€ après %d années." % (seuil_valeur, annees))
                    

En exécutant ce code dans le Trinket, on obtient le résultat : "La valeur sera inférieure à 2000€ après 9 années."

Réponse : Il faut 9 ans pour que la valeur du matériel informatique devienne inférieure à $2000€$.

Correction Exercice 12 : Dilution en Série

Question 1 : Justifiez que $(C_n)$ est géométrique et donnez sa raison.

À chaque étape de dilution, on prélève 10% de la solution et on remplace par du solvant. Cela signifie que la quantité de soluté restante est $100\% - 10\% = 90\%$ de la quantité précédente. Comme le volume est constant, la concentration après une dilution est 90% de la concentration précédente. Si $C_n$ est la concentration après $n$ dilutions, alors la concentration après la dilution suivante, $C_{n+1}$, est 90% de $C_n$.

Mathématiquement :

$C_{n+1} = C_n - 0.10 \times C_n = C_n (1 - 0.10) = 0.90 \times C_n$.

Puisque $C_{n+1} = 0.90 \times C_n$, et que $0.90$ est une constante indépendante de $n$, la suite $(C_n)$ est une suite géométrique de raison $q = 0.90$.

Question 2 : Calculez avec Xcas la concentration après 6 dilutions.

La concentration initiale est $C_0 = 1$ mol/L et la raison est $q = 0.90$. L'expression de $C_n$ est $C_n = C_0 \times q^n = 1 \times (0.90)^n = (0.90)^n$. Pour calculer la concentration après 6 dilutions, nous devons calculer $C_6 = (0.90)^6$.

Avec Xcas, utilisez les commandes : C(n) := 1 * (0.9)^n; C(6);.

C(n) := 1 * (0.9)^n;
C(6);
                    

Xcas retourne environ 0.531441. Donc, après 6 dilutions, la concentration sera d'environ $0.53$ mol/L (en arrondissant à deux décimales).

Question 3 : Déterminez avec Xcas la limite de $(C_n)$. Interprétez.

Nous devons trouver la limite de $C_n = (0.90)^n$ lorsque $n \to +\infty$. La raison est $q = 0.90$. Puisque $-1 < 0.90 < 1$, nous savons que $\lim_{n \to +\infty} (0.90)^n = 0$.

Donc, la limite de $C_n$ est :

$\lim_{n \to +\infty} C_n = \lim_{n \to +\infty} (0.90)^n = 0$.

Avec Xcas, utilisez limit(C(n), n = infinity);.

limit(C(n), n = infinity);
                    

Xcas confirme que la limite est 0.

Interprétation : La limite de la suite $(C_n)$ est $0$ mol/L. Cela signifie qu'en théorie, si on continue les dilutions en série, la concentration de la solution tendra vers $0$ mol/L à long terme. En d'autres termes, en effectuant un nombre infini de dilutions, on obtiendrait une solution ne contenant plus de soluté, c'est-à-dire du solvant pur.

Question 4 : Avec le Trinket Python en bas de page, déterminez après combien de dilutions la concentration deviendra inférieure à 0.1 mol/L.

Nous devons utiliser une boucle `while` en Python pour déterminer après combien de dilutions la concentration $C_n$ deviendra inférieure à $0.1$ mol/L. Nous initialisons la concentration à $C_0 = 1$ mol/L et la multiplions par la raison $0.90$ à chaque itération (dilution). Nous comptons le nombre d'itérations jusqu'à ce que la concentration soit inférieure à $0.1$ mol/L.

Voici le code Python à entrer dans le Trinket :

concentration = 1.0
raison = 0.9
seuil_concentration = 0.1
dilutions = 0
while concentration >= seuil_concentration:
    concentration = concentration * raison
    dilutions += 1
print("La concentration sera inférieure à %.1f mol/L après %d dilutions." % (seuil_concentration, dilutions))
                    

En exécutant ce code dans le Trinket, on obtient le résultat : "La concentration sera inférieure à 0.1 mol/L après 22 dilutions."

Réponse : Il faut 22 dilutions pour que la concentration devienne inférieure à $0.1$ mol/L.

Correction Exercice 13 : Rebond d'une Balle

Question 1 : Montrez que $(H_n)$ est géométrique et donnez sa raison.

La balle perd 20% de sa hauteur à chaque rebond. Si $H_n$ est la hauteur du rebond après le $n$-ième rebond, alors pour obtenir la hauteur du rebond suivant, $H_{n+1}$, nous devons réduire $H_n$ de 20%. C'est-à-dire, la hauteur du rebond suivant est $100\% - 20\% = 80\%$ de la hauteur du rebond précédent.

Mathématiquement :

$H_{n+1} = H_n - 0.20 \times H_n = H_n (1 - 0.20) = 0.80 \times H_n$.

Puisque $H_{n+1} = 0.80 \times H_n$, et que $0.80$ est une constante indépendante de $n$, la suite $(H_n)$ est une suite géométrique de raison $q = 0.80$.

Question 2 : Calculez avec Xcas la hauteur du 4ème rebond.

La hauteur initiale (avant le premier rebond, donc $n=0$) est $H_0 = 2m$ et la raison est $q = 0.80$. L'expression de $H_n$ est $H_n = H_0 \times q^n = 2 \times (0.80)^n$. Pour calculer la hauteur du 4ème rebond (correspondant à $n=4$), nous devons calculer $H_4 = 2 \times (0.80)^4$.

Avec Xcas, utilisez les commandes : H(n) := 2 * (0.8)^n; H(4);.

H(n) := 2 * (0.8)^n;
H(4);
                    

Xcas retourne 0.8192. Donc, la hauteur du 4ème rebond sera de $0.8192m$ (ou $81.92cm$).

Question 3 : Déterminez avec Xcas la limite de $(H_n)$. Interprétez.

Nous devons trouver la limite de $H_n = 2 \times (0.80)^n$ lorsque $n \to +\infty$. La raison est $q = 0.80$. Puisque $-1 < 0.80 < 1$, nous savons que $\lim_{n \to +\infty} (0.80)^n = 0$.

Donc, la limite de $H_n$ est :

$\lim_{n \to +\infty} H_n = \lim_{n \to +\infty} 2 \times (0.80)^n = 2 \times \lim_{n \to +\infty} (0.80)^n = 2 \times 0 = 0$.

Avec Xcas, utilisez limit(H(n), n = infinity);.

limit(H(n), n = infinity);
                    

Xcas confirme que la limite est 0.

Interprétation : La limite de la suite $(H_n)$ est $0m$. Cela signifie qu'en théorie, si la balle continue de rebondir et de perdre 20% de sa hauteur à chaque rebond, la hauteur des rebonds tendra vers $0m$ à long terme. En d'autres termes, les rebonds deviendront de plus en plus petits jusqu'à ce que la balle s'arrête de rebondir.

Question 4 : Avec le Trinket Python en bas de page, déterminez après combien de rebonds la hauteur sera inférieure à 50cm (0.5m).

Nous devons utiliser une boucle `while` en Python pour déterminer après combien de rebonds la hauteur $H_n$ sera inférieure à $0.5m$ (50cm). Nous initialisons la hauteur à $H_0 = 2m$ et la multiplions par la raison $0.80$ à chaque itération (rebond). Nous comptons le nombre d'itérations jusqu'à ce que la hauteur soit inférieure à $0.5m$.

Voici le code Python à entrer dans le Trinket :

hauteur = 2.0 # mètres
raison = 0.8
seuil_hauteur = 0.5 # mètres (50cm)
rebonds = 0
while hauteur >= seuil_hauteur:
    hauteur = hauteur * raison
    rebonds += 1
print("La hauteur sera inférieure à %.2f m après %d rebonds." % (seuil_hauteur, rebonds))
                    

En exécutant ce code dans le Trinket, on obtient le résultat : "La hauteur sera inférieure à 0.50 m après 6 rebonds."

Réponse : Il faut 6 rebonds pour que la hauteur du rebond devienne inférieure à $50cm$.

Correction Exercice 14 : Propagation d'un Email Viral

Question 1 : Justifiez que $(E_n)$ est géométrique et donnez sa raison.

Chaque personne qui reçoit l'email le transfère à 3 nouveaux contacts. Si $E_n$ est le nombre de nouveaux emails envoyés à la $n$-ième génération, alors le nombre de nouveaux emails envoyés à la génération suivante, $E_{n+1}$, sera 3 fois le nombre d'emails envoyés à la génération précédente, car chaque personne de la $n$-ième génération envoie à 3 nouvelles personnes.

Mathématiquement :

$E_{n+1} = 3 \times E_n$.

Puisque $E_{n+1} = 3 \times E_n$, et que $3$ est une constante indépendante de $n$, la suite $(E_n)$ est une suite géométrique de raison $q = 3$.

Question 2 : Calculez avec Xcas le nombre de nouveaux emails envoyés à la 6ème génération.

Le nombre d'emails envoyés à la première génération (génération 0) est $E_0 = 5$. La raison est $q = 3$. L'expression de $E_n$ est $E_n = E_0 \times q^n = 5 \times 3^n$. Pour calculer le nombre de nouveaux emails envoyés à la 6ème génération (correspondant à $n=6$), nous devons calculer $E_6 = 5 \times 3^6$.

Avec Xcas, utilisez les commandes : E(n) := 5 * (3)^n; E(6);.

E(n) := 5 * (3)^n;
E(6);
                    

Xcas retourne 3645. Donc, à la 6ème génération, 3645 nouveaux emails sont envoyés.

Question 3 : Déterminez avec Xcas la limite de $(E_n)$ si on ne considérait pas de limitations. Interprétez.

Nous devons trouver la limite de $E_n = 5 \times 3^n$ lorsque $n \to +\infty$. La raison est $q = 3$. Puisque $q = 3 > 1$, nous savons que $\lim_{n \to +\infty} 3^n = +\infty$.

Donc, la limite de $E_n$ est :

$\lim_{n \to +\infty} E_n = \lim_{n \to +\infty} 5 \times 3^n = 5 \times \lim_{n \to +\infty} 3^n = +\infty$.

Avec Xcas, utilisez limit(E(n), n = infinity);.

limit(E(n), n = infinity);
                    

Xcas confirme que la limite est $\infty$.

Interprétation : La limite de la suite $(E_n)$ est $+\infty$. Cela signifie que si la propagation de l'email continue sans limitation (par exemple, sans tenir compte du nombre total d'adresses email disponibles ou de la lassitude des gens), le nombre de nouveaux emails envoyés à chaque génération croîtra indéfiniment et tendra vers l'infini. C'est caractéristique de la croissance exponentielle, où la quantité augmente de plus en plus vite à chaque étape.

Question 4 : Avec le Trinket Python en bas de page, calculez le nombre total d'emails envoyés jusqu'à la 10ème génération (somme des termes).

Nous devons calculer la somme des nombres d'emails envoyés de la génération 0 à la génération 10. C'est la somme des premiers termes de la suite géométrique $(E_n)$ de $n=0$ à $n=10$. Nous devons calculer la somme : $S_{11} = \sum_{n=0}^{10} E_n = \sum_{n=0}^{10} 5 \times 3^n = 5 \times (3^0 + 3^1 + 3^2 + \dots + 3^{10})$.

Nous pouvons utiliser une boucle `for` en Python pour calculer cette somme. Nous allons accumuler les termes $E_n$ dans une variable total_emails.

Voici le code Python à entrer dans le Trinket :

emails_initial = 5
raison = 3
total_emails = 0
for n_generation in range(11): # Jusqu'à la 10ème génération (indices de 0 à 10 inclus)
    emails_generation = emails_initial * (raison**n_generation)
    total_emails += emails_generation
print("Nombre total d'emails envoyés jusqu'à la 10ème génération : %d" % int(total_emails))
                    

En exécutant ce code dans le Trinket, on obtient le résultat : "Nombre total d'emails envoyés jusqu'à la 10ème génération : 442865".

Avec Xcas, on peut utiliser la commande sum(5*3^k, k=0..10); (notez que dans le code Xcas fourni, il faut adapter la borne supérieure à 10 pour la question 4).

sum(5*3^k, k=0..10);
                    

Xcas retourne 442865, ce qui confirme le résultat Python.

Réponse : Le nombre total d'emails envoyés jusqu'à la 10ème génération est 442865.

Correction Exercice 15 : Réduction du Bruit dans un Signal

Question 1 : Montrez que $(B_n)$ est géométrique et donnez sa raison.

Le filtre réduit le bruit de 25% à chaque itération. Si $B_n$ est le niveau de bruit après $n$ iterations, alors pour obtenir le niveau de bruit après $n+1$ iterations, $B_{n+1}$, nous devons réduire $B_n$ de 25%. C'est-à-dire, le niveau de bruit restant est $100\% - 25\% = 75\%$ du niveau de bruit précédent.

Mathématiquement :

$B_{n+1} = B_n - 0.25 \times B_n = B_n (1 - 0.25) = 0.75 \times B_n$.

Puisque $B_{n+1} = 0.75 \times B_n$, et que $0.75$ est une constante indépendante de $n$, la suite $(B_n)$ est une suite géométrique de raison $q = 0.75$.

Question 2 : Calculez avec Xcas le niveau de bruit après 8 iterations.

Le niveau de bruit initial est $B_0 = 10$ unités et la raison est $q = 0.75$. L'expression de $B_n$ est $B_n = B_0 \times q^n = 10 \times (0.75)^n$. Pour calculer le niveau de bruit après 8 iterations, nous devons calculer $B_8 = 10 \times (0.75)^8$.

Avec Xcas, utilisez les commandes : B(n) := 10 * (0.75)^n; B(8);.

B(n) := 10 * (0.75)^n;
B(8);
                    

Xcas retourne environ 1.00112915039. Donc, après 8 iterations, le niveau de bruit sera d'environ $1.00$ unité (en arrondissant à deux décimales).

Question 3 : Déterminez avec Xcas la limite de $(B_n)$. Interprétez.

Nous devons trouver la limite de $B_n = 10 \times (0.75)^n$ lorsque $n \to +\infty$. La raison est $q = 0.75$. Puisque $-1 < 0.75 < 1$, nous savons que $\lim_{n \to +\infty} (0.75)^n = 0$.

Donc, la limite de $B_n$ est :

$\lim_{n \to +\infty} B_n = \lim_{n \to +\infty} 10 \times (0.75)^n = 10 \times \lim_{n \to +\infty} (0.75)^n = 10 \times 0 = 0$.

Avec Xcas, utilisez limit(B(n), n = infinity);.

limit(B(n), n = infinity);
                    

Xcas confirme que la limite est 0.

Interprétation : La limite de la suite $(B_n)$ est $0$ unités. Cela signifie qu'en théorie, si le filtre continue de réduire le bruit de 25% à chaque itération, le niveau de bruit tendra vers $0$ unité à long terme. En pratique, il est impossible d'éliminer complètement le bruit, mais ce modèle suggère que le filtre peut réduire le bruit à un niveau négligeable avec suffisamment d'iterations.

Question 4 : Avec le Trinket Python en bas de page, déterminez après combien d'iterations le niveau de bruit sera inférieur à 1 unité.

Nous devons utiliser une boucle `while` en Python pour déterminer après combien d'iterations le niveau de bruit $B_n$ sera inférieur à $1$ unité. Nous initialisons le niveau de bruit à $B_0 = 10$ unités et le multiplions par la raison $0.75$ à chaque itération. Nous comptons le nombre d'itérations jusqu'à ce que le niveau de bruit soit inférieur à $1$ unité.

Voici le code Python à entrer dans le Trinket :

bruit = 10.0
raison = 0.75
seuil_bruit = 1.0
iterations = 0
while bruit >= seuil_bruit:
    bruit = bruit * raison
    iterations += 1
print("Le niveau de bruit sera inférieur à %d unités après %d iterations." % (int(seuil_bruit), iterations))
                    

En exécutant ce code dans le Trinket, on obtient le résultat : "Le niveau de bruit sera inférieur à 1 unités après 9 iterations."

Réponse : Il faut 9 iterations pour que le niveau de bruit devienne inférieur à $1$ unité.

Correction Exercice 16 : Dépréciation Réaliste d'un Serveur Informatique

Partie 1 : Dépréciation Annuelle

a. Calcul des dépréciations $D_1$, $D_2$, $D_3$ et nature de la suite $(D_n)$ :

Dépréciation la première année ($D_1$) :

La première année, le serveur perd 10% de sa valeur initiale de 10 000euros. Pour calculer $D_1$, on effectue le calcul suivant :

$D_1 = 10\% \times 10 000euros = \frac{10}{100} \times 10 000euros = 0.10 \times 10 000euros = 1000euros$

Donc, la dépréciation la première année est de 1000euros.

Dépréciation la deuxième année ($D_2$) :

La dépréciation annuelle diminue de 5% par rapport à l'année précédente. Cela signifie que la dépréciation de la deuxième année est de 95% de la dépréciation de la première année (car $100\% - 5\% = 95\% = 0.95$). On calcule $D_2$ comme suit :

$D_2 = D_1 \times (1 - 0.05) = D_1 \times 0.95 = 1000euros \times 0.95 = 950euros$

La dépréciation la deuxième année est de 950euros.

Dépréciation la troisième année ($D_3$) :

De même, la dépréciation de la troisième année est de 95% de la dépréciation de la deuxième année :

$D_3$ = $D_2 \times 0.95$ = 950euros $\times$ 0.95 = 902.50euros

La dépréciation la troisième année est de 902.50euros.

Nature de la suite $(D_n)$ :

Pour montrer que la suite $(D_n)$ est géométrique, nous devons établir la relation de récurrence. On observe que chaque terme est obtenu en multipliant le précédent par une constante. En effet, on a : $D_2 = D_1 \times 0.95$ et $D_3 = D_2 \times 0.95$. Généralisons cette observation : par définition de l'énoncé, la dépréciation de l'année $n+1$ est égale à 95% de la dépréciation de l'année $n$. On a donc la relation de récurrence $D_{n+1} = 0.95 \times D_n$. Par conséquent, la suite $(D_n)$ est une suite géométrique de raison $q = 0.95$ et de premier terme $D_1 = 1000euros$.

b. Expression de $D_n$ en fonction de $n$ :

Pour une suite géométrique de premier terme $D_1$ et de raison $q$, le terme général $D_n$ est donné par la formule :

$D_n = D_1 \times q^{n-1}$

Dans notre cas, $D_1 = 1000$ et $q = 0.95$. Donc, l'expression de $D_n$ en fonction de $n$ est :

$D_n = 1000 \times (0.95)^{n-1}$

c. Calcul de $D_5$ avec Xcas :

Pour calculer la dépréciation durant la 5ème année ($D_5$), nous utilisons la formule $D_n = 1000 \times (0.95)^{n-1}$ avec $n=5$. Nous pouvons utiliser Xcas pour effectuer ce calcul :

D(n) := 1000 * (0.95)^(n-1);
                        D(5);
                        

Xcas retourne le résultat : 814.50625.

Donc, la dépréciation durant la 5ème année est d'environ 814.51euros (arrondi au centime près).

Partie 2 : Valeur du Serveur et Limite

4. Expression de $V_n$ en fonction de la valeur initiale et des dépréciations :

La valeur du serveur après $n$ années, $V_n$, est égale à la valeur initiale du serveur moins la somme des dépréciations des $n$ premières années. La valeur initiale est de 10 000euros. La somme des dépréciations des $n$ premières années est $D_1 + D_2 + ... + D_n = \sum_{k=1}^{n} D_k$. Donc, l'expression de $V_n$ est :

$V_n = 10000 - (D_1 + D_2 + ... + D_n) = 10000 - \sum_{k=1}^{n} D_k$

Nous savons que la somme des $n$ premiers termes d'une suite géométrique $(D_k)$ de premier terme $D_1 = 1000$ et de raison $q = 0.95$ est donnée par la formule : $\sum_{k=1}^{n} D_k = D_1 \times \frac{1 - q^n}{1 - q}$. On peut factoriser la somme des termes d'une suite géométrique $1+q+q^2+...+q^{n-1}$ pour faire apparaître cette formule. En effet, $(1-q)(1+q+q^2+...+q^{n-1}) = 1 + q + q^2 + ... + q^{n-1} -q - q^2 - ... - q^{n-1} - q^n = 1 - q^n$. Ainsi, $1+q+q^2+...+q^{n-1} = \frac{1-q^n}{1-q}$. Dans notre cas, on a :

$\sum_{k=1}^{n} D_k = D_1 \times \frac{1 - q^n}{1 - q} = 1000 \times \frac{1 - (0.95)^n}{1 - 0.95} = 1000 \times \frac{1 - (0.95)^n}{0.05} = 20000 \times (1 - (0.95)^n)$

Substituons cette somme dans l'expression de $V_n$ :

$V_n = 10000 - 20000 \times (1 - (0.95)^n) = 10000 - 20000 + 20000 \times (0.95)^n = 20000 \times (0.95)^n - 10000$

Ainsi, la valeur du serveur après $n$ années est donnée par :

$V_n = 20000 \times (0.95)^n - 10000$

5. Calcul de $V_{10}$ avec Xcas :

Pour calculer la valeur du serveur après 10 ans ($V_{10}$), nous utilisons la formule $V_n = 10000 - \sum_{k=1}^{n} D_k$ avec $n=10$, ou directement avec la fonction définie dans le code Xcas :

D(n) := 1000 * (0.95)^(n-1);
                        V(n) := 10000 - sum(D(k), k=1..n);
                        V(10);
                        

Xcas retourne le résultat : 4157.11981563.

Donc, la valeur du serveur après 10 ans est d'environ 4157.12euros (arrondi au centime près).

6. Limite de la suite $(V_n)$ lorsque $n$ tend vers l'infini :

Nous voulons déterminer la limite de la suite $(V_n)$ lorsque $n \rightarrow +\infty$. Nous avons l'expression :

$V_n = 20000 \times (0.95)^n - 10000$

Puisque $0 < 0.95 < 1$, nous savons que $\lim_{n \rightarrow +\infty} (0.95)^n = 0$. Par conséquent :

$\lim_{n \rightarrow +\infty} V_n = \lim_{n \rightarrow +\infty} (20000 \times (0.95)^n - 10000) = 20000 \times \lim_{n \rightarrow +\infty} (0.95)^n - 10000 = 20000 \times 0 - 10000 = -10000$

Interprétation de la limite pour la valeur résiduelle du serveur à long terme :

Mathématiquement, selon le modèle de dépréciation défini, la valeur du serveur tend vers -10000euros à long terme. Toutefois, il est crucial de comprendre que dans la réalité, la valeur d'un bien matériel comme un serveur ne peut pas devenir négative. L'énoncé précise que la valeur minimale est de 0euros. Bien que la formule mathématique donne une limite de -10000euros, la valeur résiduelle réelle du serveur à long terme sera donc de 0euros. Le modèle mathématique, bien que utile pour les premières années, atteint ici ses limites dans une interprétation réaliste à très long terme. La limite mathématique de -10000euros indique que selon le modèle, la dépréciation totale finirait par dépasser la valeur d'achat de 10000euros de 10000euros supplémentaires, ce qui n'est pas possible dans un contexte économique réel. En pratique, la valeur du serveur se stabilisera à 0euros.

4. 7. Estimation avec Trinket Python du nombre d'années pour que la dépréciation cumulée dépasse 9000euros :

   Pour estimer après combien d'années la valeur totale de dépréciation cumulée dépassera 9000euros (valeur du serveur inférieure à 1000euros), nous devons utiliser le Trinket Python fourni ou écrire un code Python équivalent.

   Voici un exemple de code Python que vous pouvez utiliser dans Trinket ou un autre environnement Python :

   valeur_initiale = 10000
                           valeur_serveur = valeur_initiale
                           depreciation_cumulee = 0
                           annee = 0
                           depreciation_annee = 0.10 * valeur_initiale # D1
   
                           while depreciation_cumulee <= 9000:
                               annee += 1
                               if annee == 1:
                                   depreciation_annee = 0.10 * valeur_initiale
                               else:
                                   depreciation_annee = depreciation_annee * 0.95
                               depreciation_cumulee += depreciation_annee
                               valeur_serveur -= depreciation_annee
                               print "Année", annee, ": Dépréciation annuelle =", "{:.2f}".format(depreciation_annee) + "euros,", "Dépréciation cumulée =", "{:.2f}".format(depreciation_cumulee) + "euros,", "Valeur serveur =", "{:.2f}".format(valeur_serveur) + "euros"
   
                           print "\nAprès", annee, "années, la dépréciation cumulée dépasse 9000euros et la valeur du serveur devient inférieure à 1000euros."
                           

   Exécutez ce code dans le Trinket Python (en cliquant sur "Charger Trinket" puis en modifiant le code et en cliquant sur "Run"). Le code simule la dépréciation année après année et affiche les valeurs. Il s'arrête lorsque la dépréciation cumulée dépasse 9000euros.

   En exécutant ce code, vous devriez observer que cela se produit après environ 7 années.

   Estimation avec Trinket : Après exécution du code Python, on constate qu'après 7 années, la dépréciation cumulée dépasse 9000euros et la valeur du serveur devient inférieure à 1000euros.

Correction Exercice 17 : Propagation d'un Virus Informatique - Croissance Doublée Chaque Jour

Partie 1 : Nombre de Nouvelles Infections Quotidiennes

a. Calcul des nouvelles infections $I_1$, $I_2$, $I_3$ et nature de la suite $(I_n)$ :

Nouvelles infections le premier jour ($I_1$) :

Initialement, 5 ordinateurs sont infectés. Le premier jour, le nombre d'ordinateurs contaminés double par rapport au nombre initial. Donc, le nombre de nouveaux ordinateurs infectés le premier jour est 2 fois le nombre initial d'ordinateurs infectés.

$I_1 = 2 \times 5 = 10$

Donc, 10 nouveaux ordinateurs sont infectés le premier jour.

Nombre total d'ordinateurs infectés après le premier jour :

Le nombre total d'ordinateurs infectés après le premier jour est le nombre initial plus les nouvelles infections du jour 1.

Nombre total après jour 1 = $5 + 10 = 15$

Nouvelles infections le deuxième jour ($I_2$) :

Le deuxième jour, le nombre d'ordinateurs contaminés double par rapport au nombre total d'ordinateurs infectés la veille (après le jour 1, soit 15 ordinateurs infectés). Donc, le nombre de nouveaux ordinateurs infectés le deuxième jour est 2 fois le nombre total d'ordinateurs infectés après le jour 1.

$I_2 = 2 \times 15 = 30$

Donc, 30 nouveaux ordinateurs sont infectés le deuxième jour.

Nombre total d'ordinateurs infectés après le deuxième jour :

Le nombre total d'ordinateurs infectés après le deuxième jour est le nombre total après le jour 1 plus les nouvelles infections du jour 2.

Nombre total après jour 2 = $15 + 30 = 45$

Nouvelles infections le troisième jour ($I_3$) :

Le troisième jour, le nombre d'ordinateurs contaminés double par rapport au nombre total d'ordinateurs infectés après le jour 2 (soit 45 ordinateurs infectés). Donc, le nombre de nouveaux ordinateurs infectés le troisième jour est 2 fois le nombre total d'ordinateurs infectés après le jour 2.

$I_3 = 2 \times 45 = 90$

Donc, 90 nouveaux ordinateurs sont infectés le troisième jour.

Nature de la suite $(I_n)$ :

Pour montrer que la suite $(I_n)$ est géométrique, nous devons établir la relation de récurrence. On observe que chaque terme est obtenu en multipliant le précédent par une constante. En effet, on a : $I_2 = I_1 \times 3$ et $I_3 = I_2 \times 3$. Généralisons cette observation : par définition de l'énoncé, le nombre de nouveaux infectés le jour $n+1$ est trois fois le nombre de nouveaux infectés le jour $n$. On a donc la relation de récurrence $I_{n+1} = 3 \times I_n$. Par conséquent, la suite $(I_n)$ est une suite géométrique de raison $q = 3$ et de premier terme $I_1 = 10$.

b. Expression de $I_n$ en fonction de $n$ :

Pour une suite géométrique de premier terme $I_1$ et de raison $q$, le terme général $I_n$ est donné par la formule :

$I_n = I_1 \times q^{n-1}$

Dans notre cas, $I_1 = 10$ et $q = 3$. Donc, l'expression de $I_n$ en fonction de $n$ est :

$I_n = 10 \times (3)^{n-1}$

c. Calcul de $I_7$ avec Xcas :

Pour calculer le nombre de nouveaux ordinateurs infectés le 7ème jour ($I_7$), nous utilisons la formule $I_n = 10 \times (3)^{n-1}$ avec $n=7$. Nous pouvons utiliser Xcas pour effectuer ce calcul :

I(n) := 10 * 3^(n-1);
I(7);

Xcas retourne le résultat : 7290.

Donc, le nombre de nouveaux ordinateurs infectés le 7ème jour est de 7290.

Partie 2 : Nombre Total d'Ordinateurs Infectés et Croissance

d. Expression de $C_n$ en fonction du nombre initial et des nouvelles infections :

Le nombre total d'ordinateurs infectés après $n$ jours, $C_n$, est égal au nombre initial d'ordinateurs infectés plus la somme des nouvelles infections de tous les jours jusqu'au jour $n$. Le nombre initial d'ordinateurs infectés est 5. La somme des nouvelles infections jusqu'au jour $n$ est $I_1 + I_2 + ... + I_n = \sum_{k=1}^{n} I_k$. Donc, l'expression de $C_n$ est :

$C_n = 5 + (I_1 + I_2 + ... + I_n) = 5 + \sum_{k=1}^{n} I_k$

Nous savons que la somme des $n$ premiers termes d'une suite géométrique $(I_k)$ de premier terme $I_1 = 10$ et de raison $q = 3$ est donnée par la formule : $\sum_{k=1}^{n} I_k = I_1 \times \frac{1 - q^n}{1 - q}$. On peut factoriser la somme des termes d'une suite géométrique $1+q+q^2+...+q^{n-1}$ pour faire apparaître cette formule. En effet, $(1-q)(1+q+q^2+...+q^{n-1}) = 1 + q + q^2 + ... + q^{n-1} -q - q^2 - ... - q^{n-1} - q^n = 1 - q^n$. Ainsi, $1+q+q^2+...+q^{n-1} = \frac{1-q^n}{1-q}$. Dans notre cas, on a :

$\sum_{k=1}^{n} I_k = I_1 \times \frac{1 - q^n}{1 - q} = 10 \times \frac{1 - (3)^n}{1 - 3} = 10 \times \frac{1 - 3^n}{-2} = -5 \times (1 - 3^n) = 5 \times (3^n - 1)$

Substituons cette somme dans l'expression de $C_n$ :

$C_n = 5 + 5 \times (3^n - 1) = 5 + 5 \times 3^n - 5 = 5 \times 3^n$

Ainsi, le nombre total d'ordinateurs infectés après $n$ jours est donné par :

$C_n = 5 \times 3^n$

e. Calcul de $C_{10}$ avec Xcas :

Pour calculer le nombre total d'ordinateurs infectés après 10 jours ($C_{10}$), nous utilisons la formule $C_n = 5 + \sum_{k=1}^{n} I_k$ avec $n=10$, ou directement avec la fonction définie dans le code Xcas :

C(n) := 5 + sum(I(k), k=1..n);
C(10);

Xcas retourne le résultat : 295240.

Donc, le nombre total d'ordinateurs infectés après 10 jours est de 295240.

f. Limite de la suite $(C_n)$ lorsque $n$ tend vers l'infini :

Nous voulons déterminer la limite de la suite $(C_n)$ lorsque $n \rightarrow +\infty$. Nous avons l'expression :

$C_n = 5 \times 3^n$

Puisque $3 > 1$, nous savons que $\lim_{n \rightarrow +\infty} 3^n = +\infty$. Par conséquent :

$\lim_{n \rightarrow +\infty} C_n = \lim_{n \rightarrow +\infty} (5 \times 3^n) = 5 \times \lim_{n \rightarrow +\infty} 3^n = +\infty$

Interprétation de la limite et nature de la croissance du virus :

La limite de la suite $(C_n)$ est $+\infty$. Cela signifie que le nombre total d'ordinateurs infectés augmente indéfiniment au fil des jours. La croissance du virus est exponentielle. Dans ce modèle, si la propagation du virus continue à ce rythme, il finira par infecter un nombre extrêmement grand d'ordinateurs. Ce type de croissance exponentielle est caractéristique des phénomènes de propagation rapide, comme les virus informatiques ou les épidémies, en l'absence de mesures de contrôle.

g. Estimation avec Trinket Python du nombre de jours pour que le nombre total d'ordinateurs infectés dépasse 10 000 :

Pour estimer après combien de jours le nombre total d'ordinateurs infectés dépassera 10 000, nous devons utiliser le Trinket Python fourni ou écrire un code Python équivalent.

Voici un exemple de code Python que vous pouvez utiliser dans Trinket ou un autre environnement Python :

nombre_initial_infectes = 5
                        infectes = 5
                        jour = 0
                        
                        while infectes <= 10_000:
                            jour = jour + 1
                            infectes = infectes * 2
                            print("Jour", jour, ": Total infectés =", infectes)
                        
                        print("\nAprès", jour, "jours, le nombre total d'ordinateurs infectés dépasse 10 000.")
                    

Exécutez ce code dans le Trinket Python (en cliquant sur "Charger Trinket" puis en modifiant le code et en cliquant sur "Run"). Le code simule la propagation du virus jour après jour et affiche les valeurs. Il s'arrête lorsque le nombre total d'ordinateurs infectés dépasse 10 000.

En exécutant ce code corrigé, vous devriez observer que cela se produit après seulement 4 jours.

Correction Exercice 18 : Amélioration d'un Algorithme

Partie 1 : Réduction du Temps à Chaque Étape

1. Calcul des réductions de temps $R_1$, $R_2$, $R_3$ et nature de la suite $(R_n)$ :

   Réduction de temps à la première étape ($R_1$) :

   La première étape réduit le temps d'exécution de 10% du temps initial de 1 seconde. Pour calculer $R_1$, on effectue le calcul suivant :

   $R_1 = 10\% \times 1 \text{ seconde} = \frac{10}{100} \times 1 \text{ seconde} = 0.10 \times 1 \text{ seconde} = 0.1 \text{ seconde}$

   Donc, la réduction de temps à la première étape est de 0.1 seconde.

   Réduction de temps à la deuxième étape ($R_2$) :

   La réduction de temps à chaque étape diminue de 10% par rapport à l'étape précédente. Cela signifie que la réduction de la deuxième étape est de 90% de la réduction de la première étape (car $100\% - 10\% = 90\% = 0.90$). On calcule $R_2$ comme suit :

   $R_2 = R_1 \times (1 - 0.10) = R_1 \times 0.90 = 0.1 \text{ seconde} \times 0.90 = 0.09 \text{ seconde}$

   La réduction de temps à la deuxième étape est de 0.09 seconde.

   Réduction de temps à la troisième étape ($R_3$) :

   De même, la réduction de la troisième étape est de 90% de la réduction de la deuxième étape :

   $R_3$ = $R_2 \times 0.90$ = 0.09 seconde $\times$ 0.90 = 0.081 seconde

   La réduction de temps à la troisième étape est de 0.081 seconde.

   Nature de la suite $(R_n)$ :

   Pour montrer que la suite $(R_n)$ est géométrique, nous devons établir la relation de récurrence. On observe que chaque terme est obtenu en multipliant le précédent par une constante. En effet, on a : $R_2 = R_1 \times 0.9$ et $R_3 = R_2 \times 0.9$. Généralisons cette observation : par définition de l'énoncé, la réduction de l'étape $n+1$ est égale à 90% de la réduction de l'étape $n$. On a donc la relation de récurrence $R_{n+1} = 0.9 \times R_n$. Par conséquent, la suite $(R_n)$ est une suite géométrique de raison $q = 0.9$ et de premier terme $R_1 = 0.1$ seconde.

2. Expression de $R_n$ en fonction de $n$ :

   Pour une suite géométrique de premier terme $R_1$ et de raison $q$, le terme général $R_n$ est donné par la formule :

   $R_n = R_1 \times q^{n-1}$

   Dans notre cas, $R_1 = 0.1$ et $q = 0.9$. Donc, l'expression de $R_n$ en fonction de $n$ est :

   $R_n = 0.1 \times (0.9)^{n-1}$

3. Calcul de $R_4$ avec Xcas :

   Pour calculer la réduction du temps d'exécution lors de la 4ème étape ($R_4$), nous utilisons la formule $R_n = 0.1 \times (0.9)^{n-1}$ avec $n=4$. Nous pouvons utiliser Xcas pour effectuer ce calcul :

   R(n) := 0.1 * (0.9)^(n-1);
                           R(4);
                           

   Xcas retourne le résultat : 0.0729.

   Donc, la réduction du temps d'exécution lors de la 4ème étape est de 0.0729 seconde.

Partie 2 : Temps d'Exécution et Limite

4. Expression de $T_n$ en fonction du temps initial et des réductions :

   Le temps d'exécution après $n$ étapes d'optimisation, $T_n$, est égal au temps d'exécution initial moins la somme des réductions de temps des $n$ premières étapes. Le temps initial est de 1 seconde. La somme des réductions des $n$ premières étapes est $R_1 + R_2 + ... + R_n = \sum_{k=1}^{n} R_k$. Donc, l'expression de $T_n$ est :

   $T_n = 1 - (R_1 + R_2 + ... + R_n) = 1 - \sum_{k=1}^{n} R_k$

   Nous savons que la somme des $n$ premiers termes d'une suite géométrique $(R_k)$ de premier terme $R_1 = 0.1$ et de raison $q = 0.9$ est donnée par la formule : $\sum_{k=1}^{n} R_k = R_1 \times \frac{1 - q^n}{1 - q}$. On peut factoriser la somme des termes d'une suite géométrique $1+q+q^2+...+q^{n-1}$ pour faire apparaître cette formule. En effet, $(1-q)(1+q+q^2+...+q^{n-1}) = 1 + q + q^2 + ... + q^{n-1} -q - q^2 - ... - q^{n-1} - q^n = 1 - q^n$. Ainsi, $1+q+q^2+...+q^{n-1} = \frac{1-q^n}{1-q}$. Dans notre cas, on a :

   $\sum_{k=1}^{n} R_k = R_1 \times \frac{1 - q^n}{1 - q} = 0.1 \times \frac{1 - (0.9)^n}{1 - 0.9} = 0.1 \times \frac{1 - (0.9)^n}{0.1} = 1 \times (1 - (0.9)^n) = 1 - (0.9)^n$

   Substituons cette somme dans l'expression de $T_n$ :

   $T_n = 1 - (1 - (0.9)^n) = 1 - 1 + (0.9)^n = (0.9)^n$

   Ainsi, le temps d'exécution après $n$ étapes est donné par :

   $T_n = (0.9)^n$

5. Calcul de $T_6$ avec Xcas :

   Pour calculer le temps d'exécution après 6 étapes d'optimisation ($T_6$), nous utilisons la formule $T_n = 1 - \sum_{k=1}^{n} R_k$ avec $n=6$, ou directement avec la fonction définie dans le code Xcas :

   T(n) := 1 - sum(R(k), k=1..n);
                           T(6);
                           

   Xcas retourne le résultat : 0.531441.

   Donc, le temps d'exécution après 6 étapes d'optimisation est d'environ 0.531 seconde.

6. Limite de la suite $(T_n)$ lorsque $n$ tend vers l'infini :

   Nous voulons déterminer la limite de la suite $(T_n)$ lorsque $n \rightarrow +\infty$. Nous avons l'expression :

   $T_n = (0.9)^n$

   Puisque $0 < 0.9 < 1$, nous savons que $\lim_{n \rightarrow +\infty} (0.9)^n = 0$. Par conséquent :

   $\lim_{n \rightarrow +\infty} T_n = \lim_{n \rightarrow +\infty} (0.9)^n = 0$

   Interprétation de la limite pour le temps d'exécution minimal atteignable :

   La limite de la suite $(T_n)$ est 0. Cela signifie que théoriquement, en appliquant un nombre infini d'étapes d'optimisation, le temps d'exécution de l'algorithme tend vers 0 seconde. En pratique, on ne peut pas atteindre un temps d'exécution nul, mais cette limite indique qu'il est possible de réduire considérablement le temps d'exécution par des optimisations successives. Le temps d'exécution minimal atteignable théorique est donc de 0 seconde.

7. Estimation avec Trinket Python du nombre d'étapes pour que le temps d'exécution devienne inférieur à 0.5 seconde :

   Pour estimer après combien d'étapes le temps d'exécution deviendra inférieur à 0.5 seconde, nous devons utiliser le Trinket Python fourni ou écrire un code Python équivalent.

   Voici un exemple de code Python que vous pouvez utiliser dans Trinket ou un autre environnement Python :

   temps_initial = 1.0
   temps_execution = temps_initial
   etape = 0
   
   while temps_execution >= 0.5:
       etape += 1
       reduction_etape = temps_execution * 0.10 # Réduction de 10% du temps actuel
       temps_execution -= reduction_etape
       print(f"Étape {etape}: Réduction = {reduction_etape:.3f} s, Temps d'exécution = {temps_execution:.3f} s")
   
   print(f"\nAprès {etape} étapes, le temps d'exécution devient inférieur à 0.5 seconde.")
   

   Exécutez ce code dans le Trinket Python (en cliquant sur "Charger Trinket" puis en modifiant le code et en cliquant sur "Run"). Le code simule l'optimisation étape par étape et affiche les valeurs. Il s'arrête lorsque le temps d'exécution devient inférieur à 0.5 seconde.

   En exécutant ce code, vous devriez observer que cela se produit après environ 7 étapes.

   Estimation avec Trinket : Après exécution du code Python, on constate qu'après 7 étapes, le temps d'exécution devient inférieur à 0.5 seconde.

Correction Exercice 19 : Augmentation de la Bande Passante Réseau

Partie 1 : Augmentation Trimestrielle de la Bande Passante

1. a. Calcul des augmentations de bande passante $A_1$, $A_2$, $A_3$ et nature de la suite $(A_n)$ :

   Augmentation de bande passante au premier trimestre ($A_1$) :

   L'augmentation de bande passante au premier trimestre est de 5% de la bande passante initiale de 100 Mbps. Pour calculer $A_1$, on effectue le calcul suivant :

   $A_1 = 5\% \times 100 \text{ Mbps} = \frac{5}{100} \times 100 \text{ Mbps} = 0.05 \times 100 \text{ Mbps} = 5 \text{ Mbps}$

   Donc, l'augmentation de bande passante au premier trimestre est de 5 Mbps.

   Augmentation de bande passante au deuxième trimestre ($A_2$) :

   L'augmentation de bande passante à chaque trimestre augmente de 5% par rapport à l'augmentation du trimestre précédent. Cela signifie que l'augmentation du deuxième trimestre est de 105% de l'augmentation du premier trimestre (car $100\% + 5\% = 105\% = 1.05$). On calcule $A_2$ comme suit :

   $A_2 = A_1 \times (1 + 0.05) = A_1 \times 1.05 = 5 \text{ Mbps} \times 1.05 = 5.25 \text{ Mbps}$

   L'augmentation de bande passante au deuxième trimestre est de 5.25 Mbps.

   Augmentation de bande passante au troisième trimestre ($A_3$) :

   De même, l'augmentation du troisième trimestre est de 105% de l'augmentation du deuxième trimestre :

   $A_3$ = $A_2 \times 1.05$ = 5.25 Mbps $\times$ 1.05 = 5.5125 Mbps

   L'augmentation de bande passante au troisième trimestre est de 5.5125 Mbps.

   Nature de la suite $(A_n)$ :

   Pour montrer que la suite $(A_n)$ est géométrique, nous devons établir la relation de récurrence. On observe que chaque terme est obtenu en multipliant le précédent par une constante. En effet, on a : $A_2 = A_1 \times 1.05$ et $A_3 = A_2 \times 1.05$. Généralisons cette observation : par définition de l'énoncé, l'augmentation du trimestre $n+1$ est égale à 105% de l'augmentation du trimestre $n$. On a donc la relation de récurrence $A_{n+1} = 1.05 \times A_n$. Par conséquent, la suite $(A_n)$ est une suite géométrique de raison $q = 1.05$ et de premier terme $A_1 = 5$ Mbps.

2. b. Expression de $A_n$ en fonction de $n$ :

   Pour une suite géométrique de premier terme $A_1$ et de raison $q$, le terme général $A_n$ est donné par la formule :

   $A_n = A_1 \times q^{n-1}$

   Dans notre cas, $A_1 = 5$ et $q = 1.05$. Donc, l'expression de $A_n$ en fonction de $n$ est :

   $A_n = 5 \times (1.05)^{n-1}$

3. c. Calcul de $A_6$ avec Xcas :

   Pour calculer l'augmentation de bande passante durant le 6ème trimestre ($A_6$), nous utilisons la formule $A_n = 5 \times (1.05)^{n-1}$ avec $n=6$. Nous pouvons utiliser Xcas pour effectuer ce calcul :

   A(n) := 5 * (1.05)^(n-1);
                           A(6);
                           

   Xcas retourne le résultat : 6.3814078125.

   Donc, l'augmentation de bande passante durant le 6ème trimestre est d'environ 6.38 Mbps (arrondi au centième près).

Partie 2 : Bande Passante Totale et Limite

4. 4. Expression de $B_n$ en fonction de la bande passante initiale et des augmentations :

   La bande passante totale après $n$ trimestres, $B_n$, est égale à la bande passante initiale plus la somme des augmentations de bande passante des $n$ premiers trimestres. La bande passante initiale est de 100 Mbps. La somme des augmentations des $n$ premiers trimestres est $A_1 + A_2 + ... + A_n = \sum_{k=1}^{n} A_k$. Donc, l'expression de $B_n$ est :

   $B_n = 100 + (A_1 + A_2 + ... + A_n) = 100 + \sum_{k=1}^{n} A_k$

   Nous savons que la somme des $n$ premiers termes d'une suite géométrique $(A_k)$ de premier terme $A_1 = 5$ et de raison $q = 1.05$ est donnée par la formule : $\sum_{k=1}^{n} A_k = A_1 \times \frac{1 - q^n}{1 - q}$. On peut factoriser la somme des termes d'une suite géométrique $1+q+q^2+...+q^{n-1}$ pour faire apparaître cette formule. En effet, $(1-q)(1+q+q^2+...+q^{n-1}) = 1 + q + q^2 + ... + q^{n-1} -q - q^2 - ... - q^{n-1} - q^n = 1 - q^n$. Ainsi, $1+q+q^2+...+q^{n-1} = \frac{1-q^n}{1-q}$. Dans notre cas, on a :

   $\sum_{k=1}^{n} A_k = A_1 \times \frac{1 - q^n}{1 - q} = 5 \times \frac{1 - (1.05)^n}{1 - 1.05} = 5 \times \frac{1 - (1.05)^n}{-0.05} = -100 \times (1 - (1.05)^n) = 100 \times ((1.05)^n - 1)$

   Substituons cette somme dans l'expression de $B_n$ :

   $B_n = 100 + 100 \times ((1.05)^n - 1) = 100 + 100 \times (1.05)^n - 100 = 100 \times (1.05)^n$

   Ainsi, la bande passante totale après $n$ trimestres est donnée par :

   $B_n = 100 \times (1.05)^n$

5. 5. Calcul de $B_{20}$ avec Xcas :

   Pour calculer la bande passante totale après 20 trimestres ($B_{20}$), nous utilisons la formule $B_n = 100 + \sum_{k=1}^{n} A_k$ avec $n=20$, ou directement avec la fonction définie dans le code Xcas :

   B(n) := 100 + sum(A(k), k=1..n);
                           B(20);
                           

   Xcas retourne le résultat : 265.329770515.

   Donc, la bande passante totale après 20 trimestres (5 ans) est d'environ 265.33 Mbps (arrondi au centième près).

6. 6. Limite de la suite $(B_n)$ lorsque $n$ tend vers l'infini :

   Nous voulons déterminer la limite de la suite $(B_n)$ lorsque $n \rightarrow +\infty$. Nous avons l'expression :

   $B_n = 100 \times (1.05)^n$

   Puisque $1.05 > 1$, nous savons que $\lim_{n \rightarrow +\infty} (1.05)^n = +\infty$. Par conséquent :

   $\lim_{n \rightarrow +\infty} B_n = \lim_{n \rightarrow +\infty} (100 \times (1.05)^n) = 100 \times \lim_{n \rightarrow +\infty} (1.05)^n = +\infty$

   Interprétation de la limite pour la bande passante maximale atteignable :

   La limite de la suite $(B_n)$ est $+\infty$. Cela signifie que théoriquement, si l'augmentation de 5% par trimestre se poursuit indéfiniment, la bande passante du réseau augmentera sans limite. En pratique, il y aura toujours des limitations physiques ou économiques qui empêcheront une croissance infinie. Cependant, mathématiquement, selon ce modèle, la bande passante maximale atteignable est infinie, indiquant une croissance exponentielle.

7. 7. Estimation avec Trinket Python du nombre de trimestres pour que la bande passante totale dépasse 200 Mbps :

   Pour estimer après combien de trimestres la bande passante totale dépassera 200 Mbps, nous devons utiliser le Trinket Python fourni ou écrire un code Python équivalent.

   Voici un exemple de code Python que vous pouvez utiliser dans Trinket ou un autre environnement Python :

   bande_passante_initiale = 100
   bande_passante_totale = bande_passante_initiale
   trimestre = 0
   
   while bande_passante_totale <= 200:
       trimestre += 1
       augmentation_trimestrielle = bande_passante_totale * 0.05 # Augmentation de 5% de la bande passante actuelle
       bande_passante_totale += augmentation_trimestrielle
       print(f"Trimestre {trimestre}: Augmentation = {augmentation_trimestrielle:.2f} Mbps, Bande passante totale = {bande_passante_totale:.2f} Mbps")
   
   print(f"\nAprès {trimestre} trimestres, la bande passante totale dépasse 200 Mbps.")
   

   Exécutez ce code dans le Trinket Python (en cliquant sur "Charger Trinket" puis en modifiant le code et en cliquant sur "Run"). Le code simule l'augmentation de la bande passante trimestre après trimestre et affiche les valeurs. Il s'arrête lorsque la bande passante totale dépasse 200 Mbps.

   En exécutant ce code, vous devriez observer que cela se produit après environ 15 trimestres.

   Estimation avec Trinket : Après exécution du code Python, on constate qu'après 15 trimestres, la bande passante totale dépasse 200 Mbps.

Correction Exercice 20 : Diminution du Temps de Latence Réseau

Partie 1 : Réduction Hebdomadaire de la Latence

1. a. Calcul des réductions de latence $R_1$, $R_2$, $R_3$ et nature de la suite $(R_n)$ :

   Réduction de latence la première semaine ($R_1$) :

   La première semaine, la latence est réduite de 8% de la latence initiale de 50 ms. Pour calculer $R_1$, on effectue le calcul suivant :

   $R_1 = 8\% \times 50 \text{ ms} = \frac{8}{100} \times 50 \text{ ms} = 0.08 \times 50 \text{ ms} = 4 \text{ ms}$

   Donc, la réduction de latence la première semaine est de 4 ms.

   Réduction de latence la deuxième semaine ($R_2$) :

   La réduction de latence à chaque semaine diminue de 8% par rapport à la semaine précédente. Cela signifie que la réduction de la deuxième semaine est de 92% de la réduction de la première semaine (car $100\% - 8\% = 92\% = 0.92$). On calcule $R_2$ comme suit :

   $R_2 = R_1 \times (1 - 0.08) = R_1 \times 0.92 = 4 \text{ ms} \times 0.92 = 3.68 \text{ ms}$

   La réduction de latence la deuxième semaine est de 3.68 ms.

   Réduction de latence la troisième semaine ($R_3$) :

   De même, la réduction de la troisième semaine est de 92% de la réduction de la deuxième semaine :

   $R_3$ = $R_2 \times 0.92$ = 3.68 ms $\times$ 0.92 = 3.3856 ms

   La réduction de latence la troisième semaine est de 3.3856 ms.

   Nature de la suite $(R_n)$ :

   Pour montrer que la suite $(R_n)$ est géométrique, nous devons établir la relation de récurrence. On observe que chaque terme est obtenu en multipliant le précédent par une constante. En effet, on a : $R_2 = R_1 \times 0.92$ et $R_3 = R_2 \times 0.92$. Généralisons cette observation : par définition de l'énoncé, la réduction de la semaine $n+1$ est égale à 92% de la réduction de la semaine $n$. On a donc la relation de récurrence $R_{n+1} = 0.92 \times R_n$. Par conséquent, la suite $(R_n)$ est une suite géométrique de raison $q = 0.92$ et de premier terme $R_1 = 4$ ms.

2. b. Expression de $R_n$ en fonction de $n$ :

   Pour une suite géométrique de premier terme $R_1$ et de raison $q$, le terme général $R_n$ est donné par la formule :

   $R_n = R_1 \times q^{n-1}$

   Dans notre cas, $R_1 = 4$ et $q = 0.92$. Donc, l'expression de $R_n$ en fonction de $n$ est :

   $R_n = 4 \times (0.92)^{n-1}$

3. c. Calcul de $R_5$ avec Xcas :

   Pour calculer la réduction de latence durant la 5ème semaine ($R_5$), nous utilisons la formule $R_n = 4 \times (0.92)^{n-1}$ avec $n=5$. Nous pouvons utiliser Xcas pour effectuer ce calcul :

   R(n) := 50 * 0.08 * (0.92)^(n-1);
                           R(5);
                           

   Xcas retourne le résultat : 2.725980928.

   Donc, la réduction de latence durant la 5ème semaine est d'environ 2.73 ms (arrondi au centième près).

Partie 2 : Latence Totale et Limite

4. 4. Expression de $L_n$ en fonction de la latence initiale et des réductions :

   La latence totale après $n$ semaines, $L_n$, est égale à la latence initiale moins la somme des réductions de latence des $n$ premières semaines. La latence initiale est de 50 ms. La somme des réductions des $n$ premières semaines est $R_1 + R_2 + ... + R_n = \sum_{k=1}^{n} R_k$. Donc, l'expression de $L_n$ est :

   $L_n = 50 - (R_1 + R_2 + ... + R_n) = 50 - \sum_{k=1}^{n} R_k$

   Nous savons que la somme des $n$ premiers termes d'une suite géométrique $(R_k)$ de premier terme $R_1 = 4$ et de raison $q = 0.92$ est donnée par la formule : $\sum_{k=1}^{n} R_k = R_1 \times \frac{1 - q^n}{1 - q}$. On peut factoriser la somme des termes d'une suite géométrique $1+q+q^2+...+q^{n-1}$ pour faire apparaître cette formule. En effet, $(1-q)(1+q+q^2+...+q^{n-1}) = 1 + q + q^2 + ... + q^{n-1} -q - q^2 - ... - q^{n-1} - q^n = 1 - q^n$. Ainsi, $1+q+q^2+...+q^{n-1} = \frac{1-q^n}{1-q}$. Dans notre cas, on a :

   $\sum_{k=1}^{n} R_k = R_1 \times \frac{1 - q^n}{1 - q} = 4 \times \frac{1 - (0.92)^n}{1 - 0.92} = 4 \times \frac{1 - (0.92)^n}{0.08} = 50 \times (1 - (0.92)^n)$

   Substituons cette somme dans l'expression de $L_n$ :

   $L_n = 50 - 50 \times (1 - (0.92)^n) = 50 - 50 + 50 \times (0.92)^n = 50 \times (0.92)^n$

   Ainsi, la latence après $n$ semaines est donnée par :

   $L_n = 50 \times (0.92)^n$

5. 5. Calcul de $L_{12}$ avec Xcas :

   Pour calculer la latence après 12 semaines ($L_{12}$), nous utilisons la formule $L_n = 50 - \sum_{k=1}^{n} R_k$ avec $n=12$, ou directement avec la fonction définie dans le code Xcas :

   L(n) := 50 - sum(R(k), k=1..n);
                           L(12);
                           

   Xcas retourne le résultat : 18.3015957785.

   Donc, la latence après 12 semaines est d'environ 18.30 ms (arrondi au centième près).

6. 6. Limite de la suite $(L_n)$ lorsque $n$ tend vers l'infini :

   Nous voulons déterminer la limite de la suite $(L_n)$ lorsque $n \rightarrow +\infty$. Nous avons l'expression :

   $L_n = 50 \times (0.92)^n$

   Puisque $0 < 0.92 < 1$, nous savons que $\lim_{n \rightarrow +\infty} (0.92)^n = 0$. Par conséquent :

   $\lim_{n \rightarrow +\infty} L_n = \lim_{n \rightarrow +\infty} (50 \times (0.92)^n) = 50 \times \lim_{n \rightarrow +\infty} (0.92)^n = 50 \times 0 = 0$

   Interprétation de la limite pour la latence minimale atteignable :

   La limite de la suite $(L_n)$ est 0. Cela signifie que théoriquement, en appliquant un nombre infini de semaines d'optimisation, la latence du réseau tend vers 0 ms. En pratique, on ne peut pas atteindre une latence nulle, mais cette limite indique qu'il est possible de réduire considérablement la latence par des optimisations successives. La latence minimale atteignable théorique est donc de 0 ms.

7. 7. Estimation avec Trinket Python du nombre de semaines pour que la latence devienne inférieure à 10 ms :

   Pour estimer après combien de semaines la latence deviendra inférieure à 10 ms, nous devons utiliser le Trinket Python fourni ou écrire un code Python équivalent.

   Voici un exemple de code Python que vous pouvez utiliser dans Trinket ou un autre environnement Python :

   latence_initiale = 50.0
   latence_actuelle = latence_initiale
   semaine = 0
   
   while latence_actuelle >= 10:
       semaine += 1
       reduction_semaine = latence_actuelle * 0.08 # Réduction de 8% de la latence actuelle
       latence_actuelle -= reduction_semaine
       print(f"Semaine {semaine}: Réduction = {reduction_semaine:.2f} ms, Latence = {latence_actuelle:.2f} ms")
   
   print(f"\nAprès {semaine} semaines, la latence devient inférieure à 10 ms.")
   

   Exécutez ce code dans le Trinket Python (en cliquant sur "Charger Trinket" puis en modifiant le code et en cliquant sur "Run"). Le code simule la réduction de latence semaine après semaine et affiche les valeurs. Il s'arrête lorsque la latence devient inférieure à 10 ms.

   En exécutant ce code, vous devriez observer que cela se produit après environ 20 semaines.

   Estimation avec Trinket : Après exécution du code Python, on constate qu'après 20 semaines, la latence devient inférieure à 10 ms.

Correction Exercice 21 : Analyse de la Complexité d'un Algorithme Récursif

Partie 1 : Nombre d'Appels Récursifs et Taille des Problèmes

1. a. Taille des problèmes aux niveaux de récursion 1, 2, et 3 et nature de la suite :

   Niveau de récursion 0 (initial) : Taille $N_0$.

   Niveau de récursion 1 : La taille du problème est divisée par 2, donc $N_1 = \frac{N_0}{2}$.

   Niveau de récursion 2 : La taille est encore divisée par 2 par rapport au niveau précédent, donc $N_2 = \frac{N_1}{2} = \frac{N_0}{2^2} = \frac{N_0}{4}$.

   Niveau de récursion 3 : De même, $N_3 = \frac{N_2}{2} = \frac{N_0}{2^3} = \frac{N_0}{8}$.

   La suite des tailles des problèmes $(N_k)$ est donnée par $N_0, \frac{N_0}{2}, \frac{N_0}{4}, \frac{N_0}{8}, ...$. On observe que chaque terme est obtenu en multipliant le précédent par $\frac{1}{2}$. Par conséquent, la suite $(N_k)$ est une suite géométrique de raison $q = \frac{1}{2}$ et de premier terme $N_0$.

2. b. Expression de $N_k$ en fonction de $k$ et $N_0$ :

   Pour une suite géométrique de premier terme $N_0$ et de raison $q = \frac{1}{2}$, le terme général $N_k$ (taille du problème au niveau de récursion $k$) est donné par la formule :

   $N_k = N_0 \times q^k = N_0 \times \left(\frac{1}{2}\right)^k = \frac{N_0}{2^k}$

   Donc, l'expression de la taille des problèmes au niveau de récursion $k$ en fonction de $k$ et $N_0$ est :

   $N_k = \frac{N_0}{2^k}$

3. c. Nombre total de niveaux de récursion :

   La récursion s'arrête lorsque la taille du problème atteint 1. Nous cherchons le niveau de récursion $p$ tel que $N_p = 1$. En utilisant l'expression de $N_k$ :

   $N_p = \frac{N_0}{2^p} = 1$

   $N_0 = 2^p$

   Pour trouver $p$ en fonction de $N_0$, nous utilisons le logarithme de base 2 :

   $p = \log_2(N_0)$

   Ainsi, le nombre total de niveaux de récursion est $p = \log_2(N_0)$. Puisque nous avons supposé $N_0 = 2^p$, $p$ est bien l'exposant tel que $N_0 = 2^p$.

Partie 2 : Temps d'Exécution Total et Limite

4. 4. Expression du temps d'exécution total $T_{total}$ :

   À chaque niveau de récursion $k$ (de 0 à $p-1$), l'algorithme effectue un travail de temps constant $c$ (combinaison des résultats, etc.). Au niveau final $p$, la taille est 1, et le temps est $T(1) = T_0$. Il y a $p$ niveaux de récursion (de 1 à $p$). Le nombre de niveaux où le coût $c$ est appliqué est $p = \log_2(N_0)$. Donc, le temps total est la somme des coûts à chaque niveau plus le coût de base $T_0$ au niveau final.

   $T_{total} = \underbrace{c + c + ... + c}_{p \text{ fois}} + T_0 = \sum_{k=1}^{p} c + T_0 = p \times c + T_0$

   La somme des temps passés à chaque niveau de récursion est une somme de termes constants, qui peut être vue comme une suite géométrique de raison $q=1$ (somme de $p$ termes égaux à $c$).

5. 5. Calcul de la somme des temps d'exécution jusqu'au niveau $p$ :

   Comme établi ci-dessus, le temps total d'exécution est la somme des temps constants $c$ pour chaque niveau de récursion (jusqu'au niveau $p-1$) plus le temps de base $T_0$ au niveau $p$. Avec $p$ niveaux de récursion, la somme des coûts constants est $p \times c$. Ajoutant le temps de base $T_0$, nous obtenons :

   $T_{total} = p \times c + T_0$

   Le temps total en fonction de $p$ et $c$ est donc $T_{total} = p \times c + T_0$.

6. 6. Expression de $T_{total}$ en fonction de $N_0$ et $c$ :

   Nous avons trouvé que $p = \log_2(N_0)$. Substituons cette expression de $p$ dans la formule pour $T_{total}$ :

   $T_{total} = p \times c + T_0 = (\log_2(N_0)) \times c + T_0$

   Donc, le temps d'exécution total $T_{total}$ en fonction de $N_0$ et $c$ est :

   $T_{total} = c \log_2(N_0) + T_0$

7. 7. Analyse de la croissance et limite de $T_{total}/p$ :

   Lorsque la taille du problème initial $N_0$ devient très grande (et donc $p = \log_2(N_0)$ tend vers l'infini), le temps d'exécution $T_{total} = c \log_2(N_0) + T_0$ augmente avec le logarithme de $N_0$. Ce type de croissance est logarithmique, ce qui est beaucoup plus lent que la croissance linéaire, polynomiale ou exponentielle. Cela indique que l'algorithme est relativement efficace pour les grandes tailles de problèmes.

   Considérons la limite de $T_{total}/p$ lorsque $p$ tend vers l'infini (ce qui correspond à $N_0$ tendant vers l'infini) :

   $\lim_{p \rightarrow \infty} \frac{T_{total}}{p} = \lim_{p \rightarrow \infty} \frac{p \times c + T_0}{p} = \lim_{p \rightarrow \infty} \left(c + \frac{T_0}{p}\right) = c + \lim_{p \rightarrow \infty} \frac{T_0}{p} = c + 0 = c$

   La limite de $T_{total}/p$ lorsque $p$ tend vers l'infini est $c$. Interprétation : Ce résultat signifie que pour chaque niveau de récursion supplémentaire (lorsque $p$ devient grand), le temps d'exécution augmente en moyenne d'environ $c$. En d'autres termes, le coût par niveau de récursion se stabilise autour de la constante $c$ pour les grandes tailles de problèmes. La complexité algorithmique est donc de l'ordre de $O(\log N_0)$, ce qui est caractéristique des algorithmes de type "diviser pour régner" qui réduisent la taille du problème de moitié à chaque étape et ont un coût de combinaison constant.

Correction Exercice 22 : Convergence d'une Méthode Numérique - Itérations Géométriques

Partie 1 : Réduction de l'Erreur à Chaque Itération

1. a. Calcul de $E_1$, $E_2$, $E_3$ et nature de la suite $(E_n)$ :

   Erreur après 1ère itération ($E_1$) :

   En utilisant la relation $E_{n+1} = q \times E_n$ avec $n=0$, on a $E_1 = q \times E_0$.

   Erreur après 2ème itération ($E_2$) :

   Avec $n=1$, on a $E_2 = q \times E_1 = q \times (q \times E_0) = q^2 \times E_0$.

   Erreur après 3ème itération ($E_3$) :

   Avec $n=2$, on a $E_3 = q \times E_2 = q \times (q^2 \times E_0) = q^3 \times E_0$.

   La suite des erreurs $(E_n)$ est donnée par $E_0, qE_0, q^2E_0, q^3E_0, ...$. On observe que chaque terme est obtenu en multipliant le précédent par $q$. Par conséquent, la suite $(E_n)$ est une suite géométrique de raison $q$ et de premier terme $E_0$.

2. b. Expression de $E_n$ en fonction de $n$, $E_0$ et $q$ :

   Pour une suite géométrique de premier terme $E_0$ et de raison $q$, le terme général $E_n$ est donné par la formule :

   $E_n = E_0 \times q^n$

   Donc, l'expression de l'erreur après $n$ itérations est :

   $E_n = E_0 \times q^n$

3. c. Calcul de $E_{10}$ avec Xcas pour $E_0=1$ et $q=0.5$ :

   Pour calculer l'erreur après 10 itérations avec $E_0 = 1$ et $q = 0.5$, nous utilisons la formule $E_n = E_0 \times q^n$ avec $n=10$, $E_0=1$ et $q=0.5$. Nous pouvons utiliser Xcas pour effectuer ce calcul :

   E(n, q, E0) := E0 * q^n;
                           E(10, 0.5, 1);
                           

   Xcas retourne le résultat : 0.0009765625.

   Donc, l'erreur après 10 itérations est de 0.0009765625.

Partie 2 : Limite de l'Erreur et Somme des Erreurs

4. 4. Limite de la suite $(E_n)$ lorsque $n \rightarrow \infty$ :

   Nous voulons déterminer la limite de la suite $(E_n = E_0 \times q^n)$ lorsque $n \rightarrow \infty$. Puisque $0 < q < 1$, nous savons que $\lim_{n \rightarrow \infty} q^n = 0$. Par conséquent :

   $\lim_{n \rightarrow \infty} E_n = \lim_{n \rightarrow \infty} (E_0 \times q^n) = E_0 \times \lim_{n \rightarrow \infty} q^n = E_0 \times 0 = 0$

   Interprétation : La limite de l'erreur est 0. Cela signifie que l'erreur tend vers zéro à mesure que le nombre d'itérations augmente. C'est la définition de la convergence d'une méthode numérique. Plus on effectue d'itérations, plus la solution approchée se rapproche de la solution exacte.

5. 5. Expression de la somme des erreurs cumulées $S_n = \sum_{k=0}^{n-1} E_k$ :

   La somme des erreurs cumulées est la somme des $n$ premiers termes de la suite géométrique $(E_k) = (E_0 \times q^k)$ pour $k$ allant de 0 à $n-1$. La formule de la somme des $n$ premiers termes d'une suite géométrique de premier terme $E_0$ et de raison $q \neq 1$ est :

   $S_n = \sum_{k=0}^{n-1} E_k = E_0 \times \frac{1 - q^n}{1 - q}$

   Donc, l'expression de la somme des erreurs cumulées $S_n$ est :

   $S_n = E_0 \times \frac{1 - q^n}{1 - q}$

6. 6. Limite de la somme des erreurs cumulées $S = \lim_{n \rightarrow \infty} S_n$ :

   Nous voulons calculer la limite de $S_n = E_0 \times \frac{1 - q^n}{1 - q}$ lorsque $n \rightarrow \infty$. Puisque $0 < q < 1$, $\lim_{n \rightarrow \infty} q^n = 0$. Donc :

   $S = \lim_{n \rightarrow \infty} S_n = \lim_{n \rightarrow \infty} \left(E_0 \times \frac{1 - q^n}{1 - q}\right) = E_0 \times \frac{1 - \lim_{n \rightarrow \infty} q^n}{1 - q} = E_0 \times \frac{1 - 0}{1 - q} = \frac{E_0}{1 - q}$

   La limite de la somme des erreurs cumulées est $S = \frac{E_0}{1 - q}$. Interprétation : Même si on effectue un nombre infini d'itérations, la somme totale des erreurs accumulées reste finie et est égale à $\frac{E_0}{1 - q}$. Cela est dû à la convergence rapide de la méthode, où l'erreur diminue géométriquement à chaque étape. La valeur $S$ représente une borne supérieure de l'erreur totale qui pourrait être "accumulée" durant le processus itératif infini.

7. 7. Estimation avec Trinket Python du nombre d'itérations pour que $E_n < 10^{-6}$ ($E_0=1, q=0.8$) :

   Pour estimer après combien d'itérations l'erreur $E_n$ devient inférieure à $10^{-6}$, nous devons utiliser le Trinket Python fourni ou écrire un code Python équivalent.

   Voici un exemple de code Python que vous pouvez utiliser dans Trinket ou un autre environnement Python :

   erreur_initiale = 1.0
   raison_q = 0.8
   erreur_actuelle = erreur_initiale
   iteration = 0
   tolerance = 1e-6
   
   while erreur_actuelle >= tolerance:
       iteration += 1
       erreur_actuelle *= raison_q
       print(f"Iteration {iteration}: Erreur = {erreur_actuelle:.8f}")
   
   print(f"\nAprès {iteration} iterations, l'erreur devient inférieure à {tolerance}.")
   

   Exécutez ce code dans le Trinket Python (en cliquant sur "Charger Trinket" puis en modifiant le code et en cliquant sur "Run"). Le code simule les itérations et affiche l'erreur à chaque itération. Il s'arrête lorsque l'erreur devient inférieure à $10^{-6}$.

   En exécutant ce code, vous devriez observer que cela se produit après environ 29 itérations.

   Estimation avec Trinket : Après exécution du code Python, on constate qu'après 29 itérations, l'erreur devient inférieure à $10^{-6}$.

Correction Exercice 23 : Propagation d'Information dans un Réseau - Somme Géométrique Infinie

Partie 1 : Nombre de Nouveaux Nœuds Informés à Chaque Étape

1. a. Calcul de $N_1$, $N_2$, $N_3$ et nature de la suite $(N_k)$ :

   Étape 1 ($N_1$) :

   Au temps $t=0$, le nœud source est informé. À l'étape 1, le nœud source informe une fraction $q$ de ses $V$ voisins. Donc, le nombre de nouveaux nœuds informés à l'étape 1 est $N_1 = V \times q$.

   Étape 2 ($N_2$) :

   À l'étape 2, chaque nœud informé à l'étape 1 (il y en a $N_1$) informe une fraction $q$ de ses voisins non encore informés. On suppose ici que chaque nœud informé à l'étape précédente a le même nombre effectif de voisins non encore informés pour simplifier, et que ce nombre est toujours $V$. Ainsi, le nombre de nouveaux nœuds informés à l'étape 2 est $N_2 = N_1 \times q = (V \times q) \times q = V \times q^2$.

   Étape 3 ($N_3$) :

   De même, à l'étape 3, chaque nœud informé à l'étape 2 (il y en a $N_2$) informe une fraction $q$ de ses voisins non encore informés. Le nombre de nouveaux nœuds informés à l'étape 3 est $N_3 = N_2 \times q = (V \times q^2) \times q = V \times q^3$.

   La suite des nouveaux nœuds informés $(N_k)$ est donnée par $N_1 = Vq, N_2 = Vq^2, N_3 = Vq^3, ...$. On observe que chaque terme est obtenu en multipliant le précédent par $q$. Par conséquent, la suite $(N_k)$ est une suite géométrique de raison $q$ et de premier terme $N_1 = V \times q$.

2. b. Expression de $N_k$ en fonction de $k$, $V$ et $q$ :

   Pour une suite géométrique de premier terme $N_1 = V \times q$ et de raison $q$, le terme général $N_k$ (nombre de nouveaux nœuds informés à l'étape $k$) est donné par la formule :

   $N_k = N_1 \times q^{k-1} = (V \times q) \times q^{k-1} = V \times q^k$

   Donc, l'expression du nombre de nouveaux nœuds informés à l'étape $k$ est :

   $N_k = V \times q^k$

3. c. Calcul de $N_5$ avec Xcas pour $V=10$ et $q=0.6$ :

   Pour calculer le nombre de nouveaux nœuds informés à la 5ème étape ($N_5$) avec $V = 10$ et $q = 0.6$, nous utilisons la formule $N_k = V \times q^k$ avec $k=5$, $V=10$ et $q=0.6$. Nous pouvons utiliser Xcas pour effectuer ce calcul :

   N(k, V, q) := V * q^k;
                           N(5, 10, 0.6);
                           

   Xcas retourne le résultat : 0.7776.

   Donc, le nombre de nouveaux nœuds informés à la 5ème étape est de 0.7776. En pratique, comme on parle de nombre de nœuds, il faudrait arrondir à l'entier le plus proche si nécessaire (ou considérer une interprétation en termes de probabilité moyenne).

Partie 2 : Nombre Total de Nœuds Informés et Limite

4. 4. Expression du nombre total de nœuds informés $T_n$ :

   Le nombre total de nœuds informés après $n$ étapes, $T_n$, est égal au nœud source initialement informé plus la somme des nouveaux nœuds informés à chaque étape de 1 à $n$. Donc :

   $T_n = 1 + (N_1 + N_2 + ... + N_n) = 1 + \sum_{k=1}^{n} N_k$

   En utilisant l'expression de $N_k = V \times q^k$, on a :

   $T_n = 1 + \sum_{k=1}^{n} (V \times q^k) = 1 + V \sum_{k=1}^{n} q^k$

   La somme $\sum_{k=1}^{n} q^k$ est la somme des $n$ premiers termes d'une suite géométrique de premier terme $q$ et de raison $q$.

5. 5. Expression simplifiée pour $T_n$ :

   La somme des $n$ premiers termes d'une suite géométrique de premier terme $q$ et de raison $q \neq 1$ est donnée par $q \times \frac{1 - q^n}{1 - q}$. Donc :

   $\sum_{k=1}^{n} q^k = q \times \frac{1 - q^n}{1 - q}$

   En substituant dans l'expression de $T_n$ :

   $T_n = 1 + V \times \left(q \times \frac{1 - q^n}{1 - q}\right) = 1 + \frac{Vq}{1 - q} (1 - q^n)$

   Ainsi, l'expression simplifiée pour le nombre total de nœuds informés après $n$ étapes est :

   $T_n = 1 + \frac{Vq}{1 - q} (1 - q^n)$

6. 6. Limite du nombre total de nœuds informés $T = \lim_{n \rightarrow \infty} T_n$ :

   Nous voulons déterminer la limite de $T_n = 1 + \frac{Vq}{1 - q} (1 - q^n)$ lorsque $n \rightarrow \infty$. Puisque $0 < q < 1$, $\lim_{n \rightarrow \infty} q^n = 0$. Donc :

   $T = \lim_{n \rightarrow \infty} T_n = \lim_{n \rightarrow \infty} \left(1 + \frac{Vq}{1 - q} (1 - q^n)\right) = 1 + \frac{Vq}{1 - q} (1 - \lim_{n \rightarrow \infty} q^n) = 1 + \frac{Vq}{1 - q} (1 - 0) = 1 + \frac{Vq}{1 - q}$

   La limite du nombre total de nœuds informés est $T = 1 + \frac{Vq}{1 - q} = \frac{(1 - q) + Vq}{1 - q} = \frac{1 - q + Vq}{1 - q} = \frac{1 + (V - 1)q}{1 - q}$. Interprétation : La limite $T$ représente le nombre total maximal de nœuds qui peuvent être informés dans le réseau si la propagation continue indéfiniment. Ce nombre est fini car $0 < q < 1$, et dépend de la fraction de propagation $q$ et du nombre de voisins du nœud source $V$.

7. 7. Analyse de la dépendance de $T$ par rapport à $q$ :

   Considérons la limite $T = \frac{1 + (V - 1)q}{1 - q}$ en fonction de $q$.

   Si $q$ se rapproche de 1 ($q \rightarrow 1^-$) : Le dénominateur $(1 - q)$ tend vers 0 par valeurs positives, et le numérateur $1 + (V - 1)q$ tend vers $1 + (V - 1) = V$. Donc, $T = \frac{1 + (V - 1)q}{1 - q} \rightarrow +\infty$. Si $q$ est très proche de 1, presque tous les voisins sont informés à chaque étape, et la propagation s'étend à un très grand nombre de nœuds, potentiellement à tout le réseau (si le réseau est infini ou suffisamment grand).

   Si $q$ se rapproche de 0 ($q \rightarrow 0^+$) : Le numérateur $1 + (V - 1)q$ tend vers 1, et le dénominateur $(1 - q)$ tend vers 1. Donc, $T = \frac{1 + (V - 1)q}{1 - q} \rightarrow \frac{1}{1} = 1$. Si $q$ est très proche de 0, presque aucun voisin n'est informé à chaque étape, et seul le nœud source reste informé, donc le nombre total de nœuds informés se rapproche de 1.

   Efficacité de la propagation : L'efficacité de la propagation de l'information dépend fortement de $q$. Pour une propagation efficace et une large diffusion de l'information, il est nécessaire que la fraction $q$ soit significativement grande, proche de 1. Si $q$ est petit, la propagation s'essouffle rapidement, et seule une petite partie du réseau est atteinte. En pratique, dans un réseau réel, le nombre de voisins non informés diminue à chaque étape, ce modèle est une simplification. Cependant, il illustre bien l'importance de la fraction de propagation $q$ dans la diffusion de l'information et le rôle des suites géométriques pour analyser ce type de phénomènes.