Chapitre 22  Les suites

22.1  Les suites récurrentes

22.1.1  L’énoncé d’une suite d’itérations

Soit la suite définie par :
u₀=1
u_n+1=1/10u_n(20−u_n)
Calculer u₁ édutier les variations de la fonction f(x)=1/10x(20−x).
En déduire que pour tout n u_n ∈ [0;10] et que u est croissante.
l’expression de u_n en fonction de n.

22.1.2  La réponse

On montre facilement que f est une bijection de [0;10] sur [0;10] et donc puisque u₀ ∈ [0;10] et que u_n+1=f(u_n), pour tout n≥ 0 u_n ∈ [0;10]. On a u_n+1−u_n=u_n(10−u_n)/10 donc puisque pour tout n u_n ∈ [0;10], la suite u est croissante et majorée par 10, donc u est convergente et sa limite l vérifie l≥ u₀ et l=1/10l(20−l) puisque f est continue.
Donc u converge vers l=10.

22.1.3  La réponse avec Xcas

On tape pour définir la fonction f :
f(x):=x*(20-x)/10
On tape pour voir les 6 premiers termes de la suite u :
plotseq(f(x),x=1,6)
On obtient :

On tape pour avoir le signe de u_n+1−u_n :
factor(f(un)-un)
On obtient :
(-(un-10)*un)/10
On tape pour résoudre l=1/10l(20−l) :
solve(f(x)=x)
On obtient :
[0,10]

22.1.4  L’énoncé

Soit la suite définie par :
u₀=1
u_n+1=u_n/3+n−1
Déterminer a et b pour que la suite :
v_n=k*u_n+a*n+b soit une suite géométrique dont on déterminera la raison.
En déduire l’expression de u_n en fonction de n.

22.1.5  La réponse

On a :
v_n+1=k*u_n+1+a*(n+1)+b=k*u_n/3+k*n−k+a*(n+1)+b
donc :
v_n+1=k*u_n/3+(a*n+b)/3+2*(a*n+b)/3+k*n+a−k
v_n+1=v_n/3+2*(a*n+b)/3+k*n+a−k
Si on veut que v soit une suite géométrique , il faut que :
2*(a*n+b)+3*k*n+3*a−3*k=0
ou encore :
2*a+3*k=0 et 2*b+3*a−3*k=0 cela donne :
3*k=−2*a et 2*b=−5*a
On choisit a=−6 et alors k=4 et b=15 et alors :
v_n+1=v_n/3 avec v_n=4*u_n−6*n+15 donc v₀=19
On en déduit que :
v_n= 19*1/3ⁿ
donc
u_n= 19/4*1/3ⁿ+3/2*n−15/4

22.1.6  L’énoncé

Soit la suite définie par :
u₀=1
n*u_n=(n+1)*u_n−1+1 si n>0
Calculer u₁,u₂,u₃,u₄,u₅.
À votre avis quelle est l’expression de u_n en fonction de n ?
Démontrez que cette expression est la bonne.
Généraliser lorsque u₀=a et n*u_n=(n+1)*u_n−1+1 si n>0

22.1.7  La réponse avec Xcas

On tape :
u(n):=ifte(n==0,1,u(n-1)*(n+1)/n+1/n)
u(n)$(n=0..5)
On obtient :
1,3,5,7,9,11
On pense que u_n=2*n+1 et on va le montrer par récurrence. La relation est vrai pour n=0 : u₀=2*0+1=1 Supposons que pour tout 0≤ k<n, u_k=2*k+1 donc u_n−1=2*n−1 On a n*u_n=(n+1)*(2*n−1)+1
On tape :
factor((n+1)*(2*n-1)+1)
On obtient :
(2*n+1)*n
donc n*u_n=(2*n+1)*n et comme n>0 on peut diviser par n donc u_n=2*n+1.
Généralisation
On tape :
u(n):=ifte(n==a,1,u(n-1)*(n+1)/n+1/n)
normal(u(n)$(n=0..5))
On obtient :
a,2*a+1,3*a+2,4*a+3,5*a+4,6*a+5
On pense que u_n=(n+1)*a+n et on va le montrer par récurrence. La relation est vrai pour n=0 : u₀=(0+1)*a+0=a Supposons que pour tout 0≤ k<n, u_k=(k+1)+k donc u_n−1=n*a+n−1 On a n*u_n=(n+1)*(n*a+n−1)+1
On tape :
factor((n+1)*(n*a+n-1)+1)
On obtient :
n*(a*n+a+n)
donc n*u_n=n*(a*n+a+n) et comme n>0 on peut diviser par n donc u_n=a*n+a+n=(n+1)*a+n.

On peut aussi chercher à calculer :
u_n−u_n−1 en fonction de u_n−1−u_n−2.
On a :
u_n−u_n−1=(n²*u_n−1−n²*u_n−2−u_n−1−1)/(n²−n)
On sait que :
u_n−1=n*u_n−2+n*u_n−1−1 donc
u_n−u_n−1=u_n−1−u_n−2=...=u₁−u₀=a+1
Ainsi, u_n est une suite arithmétique de raison a+1 et donc

Avec Xcas, on pose un=u_n, un1=u_n−1 et un2=u_n−2.
On tape :
un:=(n*un1+un1+1)/n
un1:=(n*un2+1)/(n-1)
simplify(un-un1)
On obtient :
(un2+1)/(n-1)
simplify(un1-un2)
On obtient :
(un2+1)/(n-1)
Donc u_n−u_n−1=u_n−1−u_n−2=...u₁−u₀=a+1.
Avec Xcas, si on veut obtenir directement un-un1=un1-un2, on doit faire la différence entre : un11=u_n−1 que l’on exprime en fonction de un2=u_n−2 et un1=u_n−1 qui ne doit pas changer. La difficulté ici est que dans un=u_n, il y a (n*u_n−1+u_n−1+1) et on doit laisser n*u_n−1 inchangé alors qu’il faut exprimer u_n−1+1 en fonction de un2=u_n−2.
On tape :
un:=(n*un1+un11+1)/n
un11:=(n*un2+1)/(n-1)
simplify(un-un11)
On obtient :
un1-un2
Donc on a :
u_n−u_n−1=u_n−1−u_n−2=...=u₁−u₀=a+1
Remarque
On peut aussi remarquer que l=−1 est solutipon de n*l=(n+1)*l+1.
Donc si v_n=u_n+1, alors v vérifie :
v₀=a+1 et nv_n=(n+1)v_n−1 ou encore
v_n=n+1/nv_n−1=n+1/n−1v_n−2=...=(n+1)v₀=(n+1)(a+1)
donc

22.1.8  Un énoncé du même type

Soit la suite définie par :
u₀=5=a
n*u_n=(n+2)*u_n−1+6 si n>0
et soit d_n=u_n+1−u_n.
Calculer u₁,u₂,u₃,u₄,u₅ et d₀,d1,d₂,d₃,d₄. À votre avis quelle est l’expression de d_n en fonction de n ? Démontrez que cette expression est la bonne. En déduire l’expression de u_n en fonction de n Généraliser lorsque u₀=a et n*u_n=(n+1)*u_n−1+1 si n>0

22.1.9  La solution

On peut suivre les questions et montrer que :
d_n=8(n+2) et que u_n=4n(n+3).
On peut aussi remarquer que l’équation en x :
n*x=(n+2)*x+6 a une solution indépendante de n qui est l=−3.
On pose alors v_n=u_n+3 et v vérifie :
v₀=u₀+3 et n*v_n=n*(u_n+3)=(n+2)*(u_n−1+3)=(n+2)*v_n−1, donc
v_n=n+2/nv_n−1=n+2/nn+1/n−1=....(n+2)(n+1)/2v₀
Donc

Pour a=5 on trouve :

22.2  Les suites homographiques

22.2.1  L’énoncé

Partie A

Soit f la fonction définie sur ]−∞;−1[∪]−1;+∞[ par f(x)=x+2/x+1.
1/ Résoudre f(x)=x.
On notera r₁ la racine positive et r₂ la racine négative.
2/ Soit (u) la suite définie par :
u₁=1
u_n=f(u_n−1) pour n>1
Calculer u_n pour n=1,2,3,4,5
3/ Soit (v) la suite définie par :
v_n=u_n−r₁/u_n−r₂=g(u_n)
a) Démontrer que (v) est une suite géométrique.
b) Expliciter v_n en fonction de n
c) Expliciter u_n en fonction de n
d) Calculer l=lim_{n → +∞} u_n
4/ Donner la plus petite valeur de n pour laquelle |u_n−l|<10⁻¹⁰⁰⁰

Partie B

1/ Exprimer u_2n en fonction de u_n.
2/ Determiner et étudier la fonction f₂ telle que u_2n=f₂(u_n).
3/ Soit (w) la suite définie par :
w₀=1 et w_n=f₂(w_n−1) pour tout n>0.
Montrer que (w) a la même limite l que (u).
4/ Donner la plus petite valeur de n pour laquelle |w_n−l|<10⁻¹⁰⁰⁰

Partie C

1/ Exprimer u_3n en fonction de u_n.
2/ Determiner et étudier la fonction f₃ telle que u_3n=f₃(u_n).
3/ Soit (t) la suite définie par :
t₀=1 et t_n=f₃(t_n−1) pour tout n>0.
Montrer que (t) a la même limite l que (u).
4/ Donner la plus petite valeur de n pour laquelle |t_n−l|<10⁻¹⁰⁰⁰

Partie D

Étant donné p entier positif, refaire la même chose à partir de la fonction :
f(x)=x+p/x+1
pour trouver une valeur approchée de √p.

22.2.2  La correction

Partie A

1/ On tape :
f(x):=(x+2)/(x+1)
puis :
solve(f(x)=x)
On obtient :
[-sqrt(2),sqrt(2)]

2/ On tape :
1 puis :
f(ans())
puis :
enter enter enter enter
On obtient :
3/2, 7/5, 17/12, 41/29

3/ On a :
v_n=u_n−√2/u_n+√2
On tape :
g(x):=(x-sqrt(2))/(x+sqrt(2))
Puis, on tape :
v(n):=g(u(n))
puis :
h(x):=solve(g(y)=x,y)[0] puis :
h(x)
On obtient :
(x*sqrt(2)+sqrt(2))/(-x+1) donc
u_n=√2 v_n+1/−v_n+1 et
v_n+1=g(v_n+1)=g(f(u_n))=g(f(h(v_n)))
On tape :
k:=g@f@h puis :
normal(k(x))
On obtient :
((sqrt(2)-2)*x)/(sqrt(2)+2)
donc v_n+1=(√2−2)*v_n/√2+2
la suite (v) est donc une suite géométrique de raison :
(sqrt(2)-2)/(sqrt(2)+2)=2*sqrt(2)-3
puis on tape :
normal(expand(mult_conjugate(g(1))))
On obtient :
2*sqrt(2)-3
Donc :
v_n=(2*√2−3)ⁿ
Donc on tape h(v_n) :
h((2*sqrt(2)-3)^n)
On obtient u_n :
((2*sqrt(2)-3)^n*sqrt(2)+sqrt(2))/(-(2*sqrt(2)-3)^n+1)
On sait que (v) converge vers 0 car on a :
v_n=(2*√2−3)ⁿ et −1<2*√2−3<0.
Quand x tend vers 0, h(x) tend vers h(0)=√2, donc (u) converge vers √2.
On a normal(h(x)-h(0))=(-(2*sqrt(2))*x)/(x-1)

4/ On tape :
normal(diff(h(x)))
On obtient :
(2*sqrt(2))/(x^2-2*x+1)
On a :
pour tout n, −|v₀|=−3+2√2 ≤ v_n ≤ 3−2√2=|v₀|, donc :
−1.2<−4+2 √2 ≤ v_n−1 ≤ 2−2 √2<−0.8, donc :
si −3+2 √2 ≤ x ≤ 3−2√2,
On a
|h′(x)|<(2*√2)/(2−2*√2)²=(3*√2+4)/2
et
|u_n−√2|=|h(v_n)−h(0)|<|v_n|*(3*√2+4)/2 <5* (0.2)ⁿ
On tape :
solve(5*0.2^n<10^-1000,n)
log10(5)+n*log10(0.2)<−1000
donc
n>=1432>(1000+log10(5))/(1−log10(2))>1431

Partie B

1/ On a :
v_2n=(2√2−3)⁽2n)=v_n²,
donc
u_2n=h(v_2n)=h(v_n²)=h((g(u_n))²

2/ On tape puisque sq(x)=x^2 :
f2(x):=normal((h@sq@g)(x))
puis
f2(x)
On obtient :
((x^2+2)*1/2)/x
On reconnait la fonction obtenue par la méthode de Newton et qu’il faut itérer pour obtenir une approximation de √2.

3/ On a :
w₀=u₁
w₁=f₂(w₀)=f₂(w₁)=u₂
w₂=f₂(w₁)=f₂(u₂)=u₄
w₃=f₂(w₂)=f₂(u₄)=u₈
....donc
w_n=u_2ⁿ

4/ Si on prend 2ⁿ ≥ 1432, on aura |w_n−l|<10⁻¹⁰⁰⁰
On tape :
solve(2^n>1432.,n)
On obtient :
n>10.48...
Donc si n≥ 11), on aura |w_n−l|<10⁻¹⁰⁰⁰

Partie C

1/ On a :
v_3n=(2√2−3)⁽3n)=v_n³,
donc :
u_3n=h(v_3n)=h(v_n³)=h((g(u_n))³

2/ On tape :
p3(x):=x^3
f3(x):=normal((h@p3@g)(x))
puis
f3(x)
On obtient :
(x^3+6*x)/(3*x^2+2)

3/ On a :
t₀=u₁
t₁=f₃(t₀)=f₃(u₁)=u₃
t₂=f₃(t₁)=f₃(u₃)=u₉
t₃=f₃(t₂)=f₃(u₉)=u₂7
....donc
t_n=u_3ⁿ

4/Si on prend 3ⁿ ≥ 1432, on aura |t_n−l|<10⁻¹⁰⁰⁰ On tape :
solve(3^n>1432.,n)
On obtient :
n>6.61...
Donc si n≥ 7), on aura |w_n−l|<10⁻¹⁰⁰⁰

Partie D

1/ Étant donné p entier positif, on peut refaire la même chose pour trouver une valeur approchée de √p en prenant comme fonction f :
f(x)=x+p/x+1
On tape :
f(x):=(x+p)/(x+1)
On tape :
solve(f(x)=x,x)
On obtient :
[-(sqrt(p)),sqrt(p)]
On tape :
g(x):=(x-sqrt(p))/(x+sqrt(p))
On tape :
h(x):=solve(g(y)=x,y)[0]
On obtient :
(x*sqrt(p)+sqrt(p))/(-x+1)
donc
u_n=√p v_n+1/−v_n+1 et
v_n+1=g(v_n+1)=g(f(u_n))=g(f(h(v_n)))
On tape :
k:=g@f@h puis :
normal(k(x))
On obtient :
((sqrt(p)-p)*x)/(sqrt(p)+p)
donc
v_n+1=((√p−p)*v_n)/(√p+p)
La suite (v) est donc une suite géométrique de raison :
(sqrt(p)-p)/(sqrt(p)+p)=-g(1)
puis on tape :
normal(expand(mult_conjugate(k(1))))
On obtient :
(-p-1+2*sqrt(p))/(p-1)
la suite (v) est donc une suite géomtrique de raison :
(-p-1+2*sqrt(p))/(p-1)
Donc :
v_n=((−p−1+2*√p)/(p−1))ⁿ
Donc on tape h(v_n) :
h((((sqrt(p)-p)*x)/(sqrt(p)+p))^n)
On obtient u_n :
((((sqrt(p)-p)*x)/(sqrt(p)+p))^n*sqrt(p)+sqrt(p))/
(-(((sqrt(p)-p)*x)/(sqrt(p)+p))^n+1)

2/ On a :
v_2n=v_n², donc u_2n=h(v_2n)=h(v_n²)=h((g(u_n))²) car v_2n=v(n)² et v(n)=g(u(n))
On tape puisque sq(x)=x^2 :
f2(x):=normal((h@sq@g)(x))
puis
f2(x)
On obtient :
((x^2+p)*1/2)/x
On reconnait la fonction obtenue par la méthode de Newton et qu’il faut itérer pour obtenir une approximation de √p.

3/ On a :
v_3n=v_n³, donc u_3n=h(v_3n)=h(v_n³)=h((g(u_n))³)
On tape :
p3(x):=x^3 f3(x):=normal((h@p3@g)(x))
puis
f3(x)
On obtient :
(x^3+3*p*x)/(3*x^2+p)

Avec le tableur

Avec le tableur, on voit les différentes vitesses de convergences des suites (u), (v) et (t). Il faut prévoir 6 colonnes : une colonne des valeurs exactes des termes de la suite et une colonne donnant les valeurs approchées des termes de la suite et cela pour chacune des suites.

22.3  Exemple d’une suite instable

22.3.1  L’énoncé

Soient les suites u et v définies par : u₀=11/2
u₁=61/11
u_n=111−1130/u_n−1+3000/u_n−1*u_n−2
et
v₀=5.5
v₁=evalf(61/11)
v_n=111−1130/v_n−1+3000/v_n−1*v_n−2
Quelles sont les limites possibles de ces suites ? À l’aide de Xcas, calculer la valeur approchée des 30 premiers termes de ces deux suites en utilisant 20 digits.

22.3.2  Le programme

On tape :

  instable(n,u0,u1):={
    local j,un;
    if (n==0) return u0;
    if (n==1) return u1;
    for(j:=2;j<=n;j++){
      un:=111-1130/u1+3000/(u0*u1);
      u0:=u1;
      u1:=un;
    }
    return un;
  }
:;

On a alors :
u_n=instable(n,11/2,61/11)
v_n=instable(n,5.5,evalf(61/11))

22.3.3  Les résultats

Soit f(x,y)=111−1130/x+3000/x*y.
Si une suite w vérifie la relation de récurrence : w_n=f(w_n−1*w_n−2), les limites possibles d’une telle suite sont les solutions de f(x,x)=x.
On tape :
solve(111-1130/x+3000/x^2=x,x)
On obtient :
[100,6,5]
Les limites possibles sont donc 5,6 et 100.
Remarque La suite v dépend de la valeur de evalf(61/11), donc dépend du nombre de digits utilisés et du mode de calcul utilisé.
On tape :

Digits:=20;
for(n:=0;n<=30;n++){
print(n);
print(instable(n,5.5,evalf(61/11)));
print(evalf(instable(n,11/2,61/11)));}

On obtient :

n:0
5.50000000000000000000
5.50000000000000000000
n:1
5.54545454545454545456
5.54545454545454545456
n:2
5.59016393442622950768
5.59016393442622950817
n:3
5.63343108504398826144
5.63343108504398826979
n:4
5.67464862051015081490
5.67464862051015096306
n:5
5.71332905238051293965
5.71332905238051554900
n:6
5.74912091970259238934
5.74912091970263804374
n:7
5.78181092048482174472
5.78181092048561557945
n:8
5.81131423828027015958
5.81131423829399572318
n:9
5.83765654872259110580
5.83765654895871196153
n:10
5.86095151847234420526
5.86095152251613197273
n:11
5.88137714686097474136
5.88137721584141860362
n:12
5.89915273314948416898
5.89915390579006532873
n:13
5.91450507580732900460
5.91452495067898343240
n:14
5.92740541888982367183
5.92774140777679525195
n:15
5.93338276962798092957
5.93905048546111815120
n:16
5.85317477456212541080
5.94868749248041657029
n:17
4.32520225792017284829
5.95687073191822040100
n:18
-0.317580966868753489379e2
5.96379872081940311587
n:19
0.124741088526995943127e3
5.96964914404788717708
n:20
0.101183955312637480034e3
5.97457902866672280000
n:21
0.100069905575441095835e3
5.97872572175269217080
n:22
0.100004176388280681510e3
5.98220835071100136336
n:23
0.100000249822052284540e3
5.98512953056300350037
n:24
0.100000014951746801213e3
5.98757715320858086895
n:25
0.100000000895227729755e3
5.98962614887996719755
n:26
0.100000000053619816097e3
5.99134015140329529141
n:27
0.100000000003212496604e3
5.99277302875661600204
n:28
0.100000000000192515177e3
5.99397026117232788471
n:29
0.100000000000011539180e3
5.99497016287623956976
n:30
0.100000000000000691764e3
5.99580495232911448068

Il semble que la suite u converge vers 6 alors que la suite v semble converger vers 100 alors qu’au début ces 2 suites sont très proches.
Cela ne provient pas d’erreurs d’arrondis car si on ne fait que du calcul formel et que l’on tape :

Digits:=20;
for(n:=0;n<=30;n++){
print(n);
print(evalf(instable(n,5.5,554545454545454545454/100000000000000000000)));
print(evalf(instable(n,11/2,61/11)));}

On obtient le même genre de résultat.

22.4  Suites doubles et calcul de 1/k pour k∈]0;2[

22.4.1  L’énoncé

Soient deux suites a_n et b_n définies par :
a₀=1, b₀=1−k où k est un réel de ]0;2[ et
a_n=a_n−1(1+b_n−1) et b_n=b_n−1²

• Montrer que b_n=b₀²ⁿ et que a_n=(1−b_n)/k.
• En utilisant le tableur afficher les valeurs de a_n et b_n pour k=0.25, 0.5, 0.75, 1.25, 1.5, 1.75. En déduire le comportement des suites a_n et b_n
• En déduire un programme qui calcule 1/k avec une précision donnée en ne faisant que des additions et des multiplications.

22.4.2  La correction avec Xcas

• Il est facile de montrer par récurrence que b_n=b₀²ⁿ, en effet :
  b₀=b₀²⁰=b₀¹
  si =b_n−1=b₀²ⁿ⁻¹ alors b_n=b_n−1²=b₀^2n−1*2=b₀²ⁿ.
  Montrons par récurrence que a_n=(1−b_n)/k, on a :
  a₀=(1−b₀)/x=1 et
  si a_n−1=(1−b_n−1)/k alors
  a_n=(1−b_n−1)/k*(1+b_n−1)=(1−b_n−1²)/k=(1−b_n)/k.
• On met dans la colonne A les valeurs de a_n :
  1 dans A0 puis
  =A0*(1+B0) dans A1 puis on remplit vers le bas,
  1−C0 dans B0 puis
  =B0² dans B1 puis on remplit vers le bas,
  On met dans C0 la valeur de k.
  On remarque la suite b_n converge vers 0 et que a_n converge vers 1/k. On a en effet :
  |b₀|=|1−k|<1 donc b_n=b₀²ⁿ tend vers 0 quand n tend vers l’infini,
  a_n=(1−b_n)/k tend donc vers 1/k quand n tend vers l’infini et on a :
  a_n−1/k=−b_n/k<0 et |a_n−1/k|=abs(b_n)/k<eps équivaut à |b_n|<k*eps

• Invers(k,eps):={
  local a,b;
  a:=1;
  b:=1-k;
  tantque k*eps<=abs(b) faire
  a:=a*(1+b);
  b:=b^2;
  ftantque;
  retourne a;  
  }:;
  

  On tape : Invers(1.75,1e-20)
  On obtient : 0.571428571428571428570

22.5  Encore des suites !

22.5.1  L’énoncé

Soient a∈[0;1[ et b∈[0;1[. On considère les suites a_n et b_n qui vérifient a₀=a et b₀=b et la même relation de récurrence :
si 2a_n−1<1, a_n=2a_n−1 et sinon a_n=1−2a_n−1.

• Écrire un programme qui calcule a₀,a₁...a_n.
• On considère la suite u_n=a_n−b_n Écrire un programme qui trace le graphe (n,u_n) pour n∈[0;100].
• On observe que pour n>=50 u_n=0. Qu’en pensez-vous?

22.5.2  La correction avec Xcas

• suite(a,n):={
    local u,u1,j,L;
    u:=a;
    L:=a;
    si a>=1 alors retourne "erreur"; fsi
    pour j de 1 jusque n faire
    u1:=2*u;
    si u1<1 alors 
       u:=u1;
    sinon 
       u:=u1-1;
    fsi;
    L:=L,u;
    fpour;
    retourne L;  
  }:;
  

  On tape : suite(0.4,6)
  On obtient :
  0.4,0.8,0.6,0.2,0.4,0.8,0.599999999999

• diffsuite(a,b,n):={
    local u,u1,v,v1,j,L;
    u:=a;
    v:=b;
    L:=point((a-b)*i);
    si a>=1 ou b>=1 alors retourne "erreur"; fsi
    pour j de 1 jusque n faire
    u1:=2*u;
    v1:=2*v;
    si u1<1 alors 
       u:=u1;
    sinon 
       u:=u1-1;
    fsi;
    si v1<1 alors 
       v:=v1;
    sinon 
       v:=v1-1;
    fsi
    L:=L,point(j+(u-v)*i);
    fpour;
    retourne L;  
  }:;
  

  On tape : diffsuite(0.4,0.82,100)
  On obtient :
  
• On tape : diffsuite(4/10,82/100,100)
  On obtient :
  La suite u_n=a_n+b_n semble être périodique quand a et b sont des nombres d’ecimaux et ce sont les erreurs d’arrondis qui font que u_n semble nulle pour n>50.
  On tape : diffsuite(pi-3,e-2,100)
  On obtient avec 20 chiffres significatifs :
  
• On tape : diffsuite(pi-3,e-2,100)
  On obtient avec 35 chiffres significatifs :
  

22.6  Le modèle de Volterra Lotka

L’objectif de l’exercice est de modéliser l’évolution de la population de 2 espèces, avec des hypothèses simples.

• La première espèce est une proie. Elle dispose de ressources en quantité illimitées
• La seconde espèce est un prédateur. Sa seule ressource est la proie.
• Les espèces sont isolées et n’interagissent qu’entre elles.

Le modèle de Volterra Lotka discret est un modèle d’évolution correspondant à ces hypothèses.
Le temps est discrétisé. À chaque entier n, on associe le nombre d’individus de la proie l_n (pour lapin) et du prédateur r_n (pour renard) à la n ième étape. L’évolution suit les règles suivantes :
l₀ et r₀ sont les populations initiales et pour tout n ∈ ℕ on a :
l_n+1− l_n = α l_n − β l_n r_n
r_n+1 − r _n = γ l _n r _n − δ r _n
α, β, γ, δ sont des coefficients réels strictement positifs.

1. Que se passe-t-il en l’absence de prédateur ?
2. Que se passe-t-il en l’absence de proie ?
3. Donner en fonction des paramètres une position d’équilibre du système.
4. Ecrire une fonction volterra(N,l0,r0,alpha,beta,gamma,delta) qui affiche à l’écran les N+1 premières valeurs des deux suites (r_n) et (l_n). L’affichage des valeurs doit se terminer si l’une des espèces s’éteint.
5. Modifier la fonction précédente pour produire le dessin des N+1 premières valeurs des deux suites. le couple (l_n, r_n) sera considéré comme un point. Les points seront reliés entre eux par des segments.
6. Utilisez la fonction précédente pour explorer le modèle, en jouant sur ses paramètres.
7. Le modèle de Volterra Lotka est un modèle sans saturation (En l’absence de prédateur, la population des proies croit exponentiellement, ce qui traduit l’hypothèse de ressources illimitées). Proposez un modèle avec saturation et simulez le.

La solution avec Xcas

1. En l’absence de prédateur on a pour tout n ∈ ℕ r_n=0 donc :
   l _n+1 =(1+ α) l_n
   l_n est une suite géométrique et l_n=l₀(1+ α)ⁿ avec 1+ α)>1.
   Donc en l’absence de prédateur, l(n tend vers +∞ quand n tend vers +∞
2. En l’absence de proie on a pour tout n ∈ ℕ l_n=0 donc :
   r _n+1 =(1− δ) r_n
   r_n est une suite géométrique et r_n=r₀(1− δ)ⁿ avec 1− δ)<1. Donc en l’absence de proie, r(n tend vers +∞ quand n tend vers 0
3. La position d’équilibre du système se fait lorsque à partir d’un certain rang n, on a : l _n+1 = l_n et r _n+1 =r_n.
   c’est à dire :
   α l_n − β l_n r_n =0 et
   γ l _n r _n − δ r _n=0

   ,

   On tape :
   assume(a>0)
   assume(b>0)
   assume(c>0)
   assume(d>0)
   normal(solve([x=(a+1)*x-b*x*y, y=c*x*y+(1-d)*y],[x,y]))
   On obtient :
   [[0,0],[d/c,a/b]]
   Donc une position déquilibre du système est pour un rang n :
   l_n=d/c et r_n=a/b.
   On tape :
   factor(solve([(a+1)*x-b*x*y=d/c,y*(1-d)+c*x*y=a/b],[x,y]))
   On obtient :
   [[d/c,a/b],[(d-1)/(c*(a+1)),(-a-1)/((d-1)*b)]]
   ce qui veut dire que si l_n=d/c et r_n=a/b c’est que l_n−1=d/c et r_n−1=a/b ou que
   l_n−1=(d−1)/(c*(a+1)) et r_n−1=−(a+1)/((d−1)*b) mais comme l_n>=0 et r_n>=0 cela entraine d=1 ce qui correspond à l’absence de proie.
4. On tape :

   volterra(N,l0,r0,a,b,c,d):={
   local l,r,n,la,L,k ;
   l:=l0;r:=r0;L:=NULL;
   L:=L,[l,r];  
   pour k de 1 jusque N faire
   la:=l;
   l:=l*(a+1)-b*l*r;
   r:=r*(1-d)+c*la*r;
   L:=L,[l,r];  
   si l<=0 ou r<=0 alors return L; fsi;
   fpour;
   return L;
   }:;