Les systèmes proies-prédateurs Grand Oral · mathématiques, SVT, HGGSP, SES Un support de connaissances pour construire sa propre question

← Tous les textes du Grand Oral

MathsSVTHGGSPSES

Dans la nature, le nombre d'individus d'une espèce n'est pas constant : certaines années il y a beaucoup de lièvres, d'autres années très peu. Quand deux espèces vivent ensemble et que l'une mange l'autre, leurs populations semblent parfois monter et descendre en alternance, comme une respiration. Peut-on comprendre ces variations avec des mathématiques ? Et peut-on prévoir ce qui se passe quand l'être humain s'en mêle, en pêchant, en chassant ou en épandant des insecticides ?

Ce texte part d'une question posée en 1925 par un biologiste italien sur la pêche en mer Adriatique, et explique, étape par étape, le modèle que le mathématicien Vito Volterra a construit pour y répondre. On y rencontre les équations différentielles (une notion que le programme de terminale aborde avec $y' = ay$), les suites, le tableur, le logarithme et le calcul intégral. Il rassemble des connaissances ; à chacun d'y choisir une direction et d'y construire sa question.

Sommaire
  1. Une question de pêcheurs
  2. Mettre une population en équation
  3. Le modèle proies-prédateurs, hypothèse par hypothèse
  4. Ce que l'on peut dire sans résoudre
  5. Calculer pas à pas : la méthode d'Euler, au tableur et en Python
  6. Les cycles et les moyennes
  7. Le principe de Volterra : la réponse à D'Ancona
  8. Au-delà des poissons
  9. Les limites du modèle
  10. Des directions pour construire sa question
Une question de pêcheurs Les statistiques de D'Ancona

Umberto D'Ancona (1896-1964) est un zoologiste italien. Au début des années 1920, il étudie les statistiques de la pêche dans le nord de la mer Adriatique, dans trois ports : Trieste, Fiume (aujourd'hui Rijeka, en Croatie) et Venise. Il s'intéresse à la proportion de sélaciens parmi les poissons vendus au marché. Les sélaciens, ce sont les requins et les raies : des poissons prédateurs, qui se nourrissent d'autres poissons. Les autres poissons pêchés, comme les sardines, sont surtout des proies.

Voici, pour le port de Fiume, le pourcentage de sélaciens parmi les poissons débarqués, année par année.

var opt = {fontSize: 11, useKatex: false, useMathJax: false, parse: false, anchorX: 'middle', fixed: true, highlight: false}; var an = [1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923]; var pc = [11.9, 21.4, 22.1, 21.2, 36.4, 27.3, 16.0, 15.9, 14.8, 10.7]; for (var i = 0; i < 10; i++) { var guerre = (an[i] >= 1915 && an[i] <= 1918); board.create('polygon', [[i + 0.12, 0], [i + 0.88, 0], [i + 0.88, pc[i]], [i + 0.12, pc[i]]], {fillColor: guerre ? '#c62828' : '#90a4ae', fillOpacity: 0.9, borders: {strokeWidth: 0}, vertices: {visible: false}, fixed: true, highlight: false}); board.create('text', [i + 0.5, pc[i] + 2, pc[i].toFixed(1).replace('.', ',')], opt); board.create('text', [i + 0.5, -2.2, "'" + String(an[i]).slice(2)], opt); } board.create('segment', [[0, 0], [10, 0]], {strokeColor: '#455a64', strokeWidth: 1, fixed: true, highlight: false}); board.create('text', [0.1, 45, 'en rouge : années de guerre en Adriatique'], Object.assign({}, opt, {anchorX: 'left', strokeColor: '#c62828'})); Pourcentage de sélaciens (requins et raies) parmi les poissons débarqués au port de Fiume, de 1914 à 1923, d'après les relevés de D'Ancona. Les années sont notées '14 pour 1914, etc.

On voit que la proportion de prédateurs a nettement augmenté pendant la Première Guerre mondiale, puis a baissé ensuite. Or, de 1915 à 1918, l'Adriatique était une zone de combats entre la marine italienne et celle de l'Autriche-Hongrie : les pêcheurs sortaient beaucoup moins. D'Ancona fait donc l'hypothèse suivante : la pêche défavorise les prédateurs et favorise les proies, et quand on pêche moins, la proportion de prédateurs remonte.

C'est surprenant. On pourrait penser que la pêche, qui prélève toutes les espèces, ne change rien aux proportions. D'Ancona n'arrive pas à l'expliquer. Il pose la question à son beau-père, un mathématicien célèbre : Vito Volterra.

Vito Volterra (1860-1940) Portrait photographique en noir et blanc d'un homme à barbe, en costume. Vito Volterra, vers 1910. Photo : auteur inconnu, Wikimedia Commons, domaine public.
  • Une enfance difficile. Vito Volterra naît en 1860 à Ancône, sur la côte Adriatique, dans une famille juive. Son père meurt quand il a deux ans ; il grandit pauvre, à Turin puis à Florence, chez un oncle. Très tôt passionné par les mathématiques et la physique, il obtient, grâce à l'un de ses professeurs, un poste d'assistant de laboratoire qui lui permet de poursuivre ses études.
  • Une carrière brillante. Il étudie à Pise et y devient professeur à $23$ ans, puis enseigne à Turin et à Rome. Ses travaux portent sur les équations dont l'inconnue est une fonction (les « équations intégrales », qui portent aujourd'hui son nom) et sur la mécanique. Il est nommé sénateur du royaume d'Italie en 1905.
  • La guerre. En 1915, à $55$ ans, il s'engage dans l'armée et travaille pour l'aviation naissante, notamment sur les dirigeables. Après la guerre, il fonde en 1923 le Conseil national de la recherche italien et en est le premier président.
  • Le refus du fascisme. Mussolini prend le pouvoir en 1922. En 1925, Volterra signe le manifeste des intellectuels antifascistes. En 1931, le régime exige de tous les professeurs d'université un serment de fidélité au fascisme : sur environ $1\,250$ professeurs, seuls $12$ refusent, et Volterra est l'un d'eux. Il perd sa chaire, puis sa place dans les académies scientifiques italiennes, et passe une grande partie des années suivantes à l'étranger. En 1938, les lois raciales du régime excluent les Juifs de la vie publique. Il meurt à Rome en 1940.

Quand D'Ancona lui pose sa question, Volterra a $65$ ans. Il construit un modèle mathématique, le publie en 1926, puis le développe dans un livre écrit en français, Leçons sur la théorie mathématique de la lutte pour la vie (1931).

Alfred Lotka (1880-1949)

Au même moment, de l'autre côté de l'Atlantique, Alfred James Lotka, né à Lemberg (aujourd'hui Lviv, en Ukraine), chimiste puis statisticien dans une compagnie d'assurances américaine, étudie la même question sans connaître les travaux de Volterra. Il avait publié des équations semblables dès 1910 et 1920, à propos de réactions chimiques, puis les avait appliquées aux êtres vivants dans son livre Elements of Physical Biology (1925). Les deux hommes sont arrivés au même modèle chacun de leur côté ; on l'appelle aujourd'hui le modèle de Lotka-Volterra.

Mettre une population en équation D'abord une seule espèce, année par année

Avant de mélanger deux espèces, regardons une seule population, par exemple $1\,000$ lapins sur une île sans prédateur, dont le nombre augmente de $10\,\%$ par an. Notons $u_n$ le nombre de lapins au bout de $n$ années.

  • Augmenter de $10\,\%$, c'est multiplier par $1 + \dfrac{10}{100} = 1{,}1$. Donc $u_{n+1} = 1{,}1\,u_n$.
  • La suite $(u_n)$ est géométrique, de raison $1{,}1$ et de premier terme $u_0 = 1\,000$, donc $u_n = 1\,000 \times 1{,}1^n$.
  • Par exemple $u_1 = 1\,100$, $u_2 = 1\,210$, et $u_{10} = 1\,000 \times 1{,}1^{10} \approx 2\,594$.

Ce modèle avance par sauts d'un an. Mais une population ne change pas seulement le 1er janvier : des lapins naissent et meurent tous les jours. Pour décrire une évolution continue, on utilise une fonction du temps et sa dérivée.

La dérivée, une vitesse de variation

Notons $X(t)$ le nombre d'individus à l'instant $t$ (en années). Entre l'instant $t$ et un instant un peu plus tard $t + h$, la population varie de $X(t+h) - X(t)$. Divisée par la durée $h$, cette variation donne une vitesse moyenne d'évolution, en individus par an :

$$\frac{X(t+h) - X(t)}{h}.$$

C'est le taux d'accroissement vu en première. Quand $h$ devient très petit, ce taux se rapproche du nombre dérivé $X'(t)$ : $X'(t)$ est la vitesse instantanée de variation de la population. Si $X'(t) > 0$, la population augmente à cet instant ; si $X'(t) < 0$, elle diminue.

Le nombre de lapins est un entier, et une fonction à valeurs entières ne peut pas avoir de dérivée intéressante (elle avance par sauts). On fait donc une approximation : on traite $X(t)$ comme un nombre réel, ce qui n'est raisonnable que pour de grandes populations, par exemple comptées en milliers d'individus. C'est une première limite du modèle : pas question de l'appliquer à dix lapins et cinq renards.

Le modèle de Malthus : $X' = aX$

Sans prédateur et avec assez de nourriture, plus il y a d'individus, plus il y a de naissances. Il est naturel de supposer que la vitesse d'augmentation est proportionnelle au nombre d'individus : deux fois plus de lapins, deux fois plus de naissances par an. On écrit, avec un nombre $a > 0$ appelé taux de croissance,

$$X'(t) = aX(t).$$

C'est une équation différentielle : une équation dont l'inconnue est une fonction, et qui relie cette fonction à sa dérivée. On cherche toutes les fonctions $X$ qui vérifient cette relation à chaque instant.

La solution : $X(t) = X_0\,\mathrm{e}^{at}$

Ces fonctions conviennent. Soit $X_0$ un réel et $X(t) = X_0\,\mathrm{e}^{at}$. La dérivée de $t \mapsto \mathrm{e}^{at}$ est $t \mapsto a\,\mathrm{e}^{at}$, donc $X'(t) = X_0 \times a\,\mathrm{e}^{at}$, c'est-à-dire $X'(t) = aX(t)$. De plus, $X(0) = X_0\,\mathrm{e}^0 = X_0$ : $X_0$ est la population initiale.

Ce sont les seules. Soit $X$ une fonction telle que $X' = aX$. Posons $g(t) = X(t)\,\mathrm{e}^{-at}$. Par la formule de dérivation d'un produit (la dérivée de $t \mapsto \mathrm{e}^{-at}$ étant $t \mapsto -a\,\mathrm{e}^{-at}$),

$$g'(t) = X'(t)\,\mathrm{e}^{-at} - aX(t)\,\mathrm{e}^{-at}.$$

On factorise par $\mathrm{e}^{-at}$ : $g'(t) = \big(X'(t) - aX(t)\big)\,\mathrm{e}^{-at}$, et ce nombre est nul car $X'(t) = aX(t)$. La fonction $g$ a une dérivée nulle sur un intervalle : elle est constante, égale à $g(0) = X(0) = X_0$. Donc $X(t)\,\mathrm{e}^{-at} = X_0$, c'est-à-dire $X(t) = X_0\,\mathrm{e}^{at}$.

Le lien avec les lapins : au bout d'un an, la population est multipliée par $\mathrm{e}^{a}$. Pour retrouver $10\,\%$ par an, il faut $\mathrm{e}^a = 1{,}1$, soit $a = \ln(1{,}1) \approx 0{,}095$. Le modèle continu et la suite géométrique donnent alors les mêmes valeurs chaque 1er janvier.

Ce modèle porte le nom de Thomas Malthus, qui affirmait en 1798 que les populations croissent de façon géométrique. Il a un défaut évident : la population augmente sans limite. En réalité, la nourriture et la place finissent par manquer. Le Belge Pierre-François Verhulst a proposé en 1838 un modèle qui en tient compte (le modèle logistique, dont la version en suite est étudiée dans le texte Suites récurrentes et chaos). Ce qui limite les lapins peut aussi être… un prédateur.

Le modèle proies-prédateurs, hypothèse par hypothèse

Considérons maintenant deux espèces : des proies (des sardines, des lièvres…) et des prédateurs qui les mangent (des requins, des lynx…). Notons $X(t)$ le nombre de proies et $Y(t)$ le nombre de prédateurs à l'instant $t$, en milliers d'individus. Volterra traduit en équations quatre hypothèses simples, une par une.

Hypothèse 1 : sans prédateurs, les proies se multiplient

Si les prédateurs n'existaient pas, les proies auraient assez de nourriture (les sardines mangent du plancton, les lièvres de l'herbe) et se multiplieraient comme dans le modèle de Malthus :

$$X'(t) = aX(t), \quad a > 0.$$

Le nombre $a$ est le taux de reproduction des proies.

Hypothèse 2 : sans proies, les prédateurs meurent de faim

Si les proies n'existaient pas, les prédateurs n'auraient rien à manger et leur population diminuerait. Là encore, on suppose la diminution proportionnelle au nombre de prédateurs :

$$Y'(t) = -cY(t), \quad c > 0.$$

Le nombre $c$ est le taux de mortalité des prédateurs. Le signe moins traduit la diminution : d'après la partie précédente, $Y(t) = Y_0\,\mathrm{e}^{-ct}$, qui tend vers $0$.

Hypothèse 3 : les rencontres

Tout se joue quand un prédateur rencontre une proie. Combien y a-t-il de rencontres par an ? Raisonnons sur un exemple.

  • Imaginons $100$ lièvres et $10$ lynx dans une forêt, et supposons qu'il y ait $50$ rencontres par an.
  • Si le nombre de lynx double ($20$ lynx), chaque lièvre croise deux fois plus de lynx : $100$ rencontres.
  • Si le nombre de lièvres double ($200$ lièvres, $10$ lynx), chaque lynx croise deux fois plus de lièvres : $100$ rencontres.
  • Si les deux doublent, le nombre de rencontres est multiplié par $2 \times 2 = 4$ : $200$ rencontres.

Le nombre de rencontres est donc proportionnel au produit $X(t) \times Y(t)$. On suppose qu'une partie fixe de ces rencontres se termine par la mort de la proie : les proies perdent, par an, un nombre d'individus égal à $b\,X(t)\,Y(t)$, avec $b > 0$. L'équation des proies devient

$$X' = aX - bXY = (a - bY)X.$$

Cette hypothèse suppose que les animaux se déplacent au hasard et se rencontrent « comme des molécules dans un gaz ». En chimie, c'est la même idée qui dit que la vitesse d'une réaction entre deux produits est proportionnelle au produit de leurs concentrations (la « loi d'action de masse ») : c'est par là que Lotka, chimiste, est arrivé à ces équations.

Hypothèse 4 : manger fait naître des prédateurs

Plus les prédateurs mangent, plus ils survivent et ont de petits. On suppose que les naissances de prédateurs sont, elles aussi, proportionnelles au nombre de rencontres, donc à $X(t)\,Y(t)$ : elles valent $d\,X(t)\,Y(t)$, avec $d > 0$. L'équation des prédateurs devient

$$Y' = -cY + dXY = (-c + dX)Y.$$
Le système de Lotka-Volterra

En réunissant les deux équations, on obtient un système de deux équations différentielles, à résoudre en même temps, avec les populations de départ $X(0) = X_0$ et $Y(0) = Y_0$ :

$$\left\{\begin{array}{l} X' = (a - bY)\,X \\[4pt] Y' = (-c + dX)\,Y \end{array}\right.$$

La difficulté, et tout l'intérêt, est que les deux équations sont couplées : la vitesse d'évolution des proies dépend du nombre de prédateurs, et inversement. On ne peut pas résoudre l'une sans l'autre, et l'on ne sait pas écrire les solutions avec les fonctions connues (exponentielle, logarithme, sinus…). Il faut donc d'autres méthodes : raisonner sur les signes (partie 4), calculer des valeurs approchées (partie 5), trouver des propriétés cachées (partie 6).

Les valeurs utilisées dans la suite. Pour faire des calculs, on choisit $a = 1$, $b = 0{,}1$, $c = 0{,}5$, $d = 0{,}02$, avec $40$ milliers de proies et $5$ milliers de prédateurs au départ. Ce sont des valeurs d'exemple, choisies pour que les calculs soient simples, pas des mesures sur une espèce réelle.

Ce que l'on peut dire sans résoudre Les points d'équilibre

Existe-t-il des populations qui ne bougent pas ? Il faudrait que les deux vitesses soient nulles : $X' = 0$ et $Y' = 0$.

  • $X' = (a - bY)X = 0$ quand $X = 0$ ou quand $a - bY = 0$, c'est-à-dire $Y = \dfrac{a}{b}$.
  • $Y' = (-c + dX)Y = 0$ quand $Y = 0$ ou quand $-c + dX = 0$, c'est-à-dire $X = \dfrac{c}{d}$.

En combinant les cas, il y a deux équilibres. Le premier, $X = 0$ et $Y = 0$, correspond à deux espèces disparues. Le second est celui qui nous intéresse :

$$X^* = \frac{c}{d}, \qquad Y^* = \frac{a}{b}.$$

Avec nos valeurs, $X^* = \dfrac{0{,}5}{0{,}02} = 25$ et $Y^* = \dfrac{1}{0{,}1} = 10$ : avec exactement $25$ milliers de proies et $10$ milliers de prédateurs, les naissances compensent exactement les morts, pour les deux espèces. Remarque étonnante : le nombre de proies à l'équilibre dépend des paramètres des prédateurs ($c$ et $d$), et inversement.

Le signe des dérivées : quatre phases

Les populations étant positives, le signe de $X' = (a - bY)X$ est celui de $a - bY$, et le signe de $Y' = (-c + dX)Y$ est celui de $-c + dX$ :

  • les proies augmentent quand $a - bY > 0$, c'est-à-dire quand $Y < 10$ : il y a peu de prédateurs ;
  • les prédateurs augmentent quand $-c + dX > 0$, c'est-à-dire quand $X > 25$ : il y a beaucoup de proies.

Suivons ce qui se passe à partir de $40$ milliers de proies et $5$ milliers de prédateurs.

  1. Peu de prédateurs, beaucoup de proies ($Y < 10$ et $X > 25$) : les deux populations augmentent. Les proies prolifèrent, et les prédateurs, bien nourris, se multiplient.
  2. Beaucoup de prédateurs, beaucoup de proies ($Y > 10$ et $X > 25$) : les prédateurs, devenus nombreux, mangent plus de proies qu'il n'en naît : les proies diminuent, les prédateurs augmentent encore.
  3. Beaucoup de prédateurs, peu de proies ($Y > 10$ et $X < 25$) : les prédateurs n'ont plus assez à manger : ils diminuent à leur tour, et les proies continuent de diminuer.
  4. Peu de prédateurs, peu de proies ($Y < 10$ et $X < 25$) : les proies, moins chassées, repartent à la hausse, pendant que les prédateurs continuent de diminuer. Quand les proies dépassent de nouveau $25$, on revient à la phase 1.

Sans avoir résolu le système, on comprend déjà le mécanisme : les populations tournent d'une phase à l'autre, et le pic des prédateurs arrive après celui des proies. Il reste à savoir si ce mouvement se répète à l'identique, s'amortit ou s'emballe. Pour le voir, il faut calculer.

Calculer pas à pas : la méthode d'Euler, au tableur et en Python L'idée, sur une équation que l'on sait résoudre

Commençons par l'équation $y' = y$ avec $y(0) = 1$, dont on connaît la solution, $y(t) = \mathrm{e}^t$, pour voir si la méthode donne de bonnes valeurs.

On a vu que, pour un petit nombre $h$, le taux d'accroissement est proche de la dérivée :

$$\frac{y(t+h) - y(t)}{h} \approx y'(t),$$

donc, en multipliant par $h$ puis en ajoutant $y(t)$,

$$y(t+h) \approx y(t) + h\,y'(t).$$

Autrement dit : la valeur un peu plus tard est à peu près la valeur actuelle, plus la durée multipliée par la vitesse actuelle. C'est exactement ce que fait un automobiliste qui roule à $90$ km/h et estime être $1{,}5$ km plus loin dans une minute. Géométriquement, on avance sur la tangente à la courbe au lieu d'avancer sur la courbe.

Le mathématicien suisse Leonhard Euler a proposé, en 1768, de répéter ce calcul. On choisit un pas $h$, et l'on note $y_n$ la valeur approchée de $y(nh)$. Comme ici $y' = y$ :

$$y_{n+1} = y_n + h\,y_n = (1 + h)\,y_n, \quad y_0 = 1.$$

La suite $(y_n)$ est géométrique de raison $1 + h$, donc $y_n = (1+h)^n$. Pour approcher $y(2) = \mathrm{e}^2 \approx 7{,}389$, il faut $n = \dfrac{2}{h}$ pas :

pas $h$nombre de pasvaleur approchée de $y(2)$
$0{,}5$$4$$1{,}5^4 \approx 5{,}063$
$0{,}25$$8$$1{,}25^8 \approx 5{,}960$
$0{,}1$$20$$1{,}1^{20} \approx 6{,}727$
$0{,}01$$200$$1{,}01^{200} \approx 7{,}316$

Plus le pas est petit, meilleure est l'approximation, mais plus il faut de calculs. On peut montrer que $\left(1 + \frac{2}{n}\right)^n$ tend vers $\mathrm{e}^2$ quand $n$ tend vers $+\infty$ : la méthode d'Euler donne la bonne valeur à la limite.

var opt = {fontSize: 12, useKatex: false, useMathJax: false, parse: false, fixed: true, highlight: false}; var h = 0.5; board.create('functiongraph', [function (t) { return Math.exp(t); }, 0, 2.1], {strokeColor: '#2e7d32', strokeWidth: 2, highlight: false}); var eul = board.create('curve', [[0], [1]], {strokeColor: '#c62828', strokeWidth: 2, highlight: false}); var pts = board.create('curve', [[0], [1]], {strokeColor: '#c62828', strokeWidth: 0, highlight: false, curveType: 'plot', dash: 0}); eul.updateDataArray = function () { this.dataX = []; this.dataY = []; var y = 1; for (var n = 0; n * h <= 2 + 1e-9; n++) { this.dataX.push(n * h); this.dataY.push(y); y = y + h * y; } }; board.create('text', [0.05, 10.5, 'courbe de exp (vert) et méthode d\'Euler (rouge)'], opt); board.create('text', [0.05, 9.7, function () { var n = Math.round(2 / h); return 'h = ' + String(h).replace('.', ',') + ' : y(2) ≈ ' + Math.pow(1 + h, n).toFixed(3).replace('.', ',') + ' au lieu de 7,389'; }], opt); var hs = [0.5, 0.25, 0.1]; var lab = ['h = 0,5', 'h = 0,25', 'h = 0,1']; for (var k = 0; k < 3; k++) { (function (k) { board.create('button', [0.05 + 0.62 * k, 8.8, lab[k], function () { h = hs[k]; board.update(); }], {fontSize: 11, useKatex: false, useMathJax: false, parse: false}); })(k); } board.update(); La méthode d'Euler pour $y' = y$, $y(0) = 1$ : on avance de segment en segment, chacun dans la direction de la tangente au point de départ. Plus le pas $h$ est petit, plus la ligne brisée rouge suit la courbe verte.
La méthode d'Euler pour les proies et les prédateurs

On applique la même idée aux deux populations en même temps. On note $x_n$ et $y_n$ les valeurs approchées de $X(nh)$ et $Y(nh)$. Pour passer d'un instant au suivant, on ajoute à chaque population la durée $h$ multipliée par sa vitesse actuelle, donnée par le système :

$$x_{n+1} = x_n + h\,(a - b\,y_n)\,x_n$$ $$y_{n+1} = y_n + h\,(-c + d\,x_n)\,y_n$$

On obtient deux suites définies par récurrence, et chacune a besoin de l'autre pour avancer. Faisons les deux premiers pas à la main, avec $h = 0{,}1$ (un dixième d'année), $x_0 = 40$ et $y_0 = 5$.

Premier pas, de $t = 0$ à $t = 0{,}1$. On calcule d'abord les deux parenthèses avec les valeurs de départ, puis les nouvelles populations.

  • $a - b\,y_0 = 1 - 0{,}1 \times 5$, soit $a - b\,y_0 = 0{,}5$ ;
  • $-c + d\,x_0 = -0{,}5 + 0{,}02 \times 40$, soit $-c + d\,x_0 = 0{,}3$ ;
  • $x_1 = 40 + 0{,}1 \times 0{,}5 \times 40$, soit $x_1 = 40 + 2 = 42$ ;
  • $y_1 = 5 + 0{,}1 \times 0{,}3 \times 5$, soit $y_1 = 5 + 0{,}15 = 5{,}15$.

Deuxième pas, de $t = 0{,}1$ à $t = 0{,}2$, en repartant de $x_1 = 42$ et $y_1 = 5{,}15$ :

  • $a - b\,y_1 = 1 - 0{,}1 \times 5{,}15$, soit $a - b\,y_1 = 0{,}485$ ;
  • $-c + d\,x_1 = -0{,}5 + 0{,}02 \times 42$, soit $-c + d\,x_1 = 0{,}34$ ;
  • $x_2 = 42 + 0{,}1 \times 0{,}485 \times 42$, soit $x_2 = 42 + 2{,}037 = 44{,}037$ ;
  • $y_2 = 5{,}15 + 0{,}1 \times 0{,}34 \times 5{,}15$, soit $y_2 = 5{,}15 + 0{,}1751 = 5{,}3251$.

Attention à un piège : pour calculer $y_2$, on utilise $x_1$ et non $x_2$ : les deux nouvelles valeurs se calculent à partir des anciennes. Pour connaître les populations au bout de $30$ ans, il faut $300$ pas : c'est un travail pour un tableur.

Au tableur

On organise la feuille ainsi :

  • les paramètres dans des cellules à part : $a$ en B2, $b$ en B3, $c$ en B4, $d$ en B5, et le pas $h$ en B6 ;
  • à partir de la ligne 9, quatre colonnes : le numéro $n$ du pas (colonne A), l'instant $t$ (colonne B), les proies $x_n$ (colonne C) et les prédateurs $y_n$ (colonne D) ;
  • en ligne 9, les valeurs de départ : 0, 0, 40, 5.

En ligne 10, on traduit les formules de récurrence, en se référant à la ligne du dessus :

celluleformulesignification
A10=A9+1pas suivant
B10=B9+$B$6$t$ augmente de $h$
C10=C9+$B$6*($B$2-$B$3*D9)*C9formule de $x_{n+1}$
D10=D9+$B$6*(-$B$4+$B$5*C9)*D9formule de $y_{n+1}$

Les dollars, comme dans $B$6, « bloquent » la référence : quand on recopie la ligne 10 vers le bas, C9 devient C10, C11… mais $B$6 désigne toujours la cellule du pas. On sélectionne A10:D10 et on tire la poignée jusqu'à la ligne 309 (300 pas, donc $30$ ans). Il reste à tracer les colonnes C et D en fonction de la colonne B (diagramme de type « XY (dispersion) »). Le fichier est prêt à télécharger : format LibreOffice (.ods) ou format Excel (.xlsx).

Voici ce tableur, intégré à la page. On peut cliquer sur une cellule pour voir sa formule, modifier les paramètres dans les cellules B2 à B6 (puis appuyer sur Entrée) et observer l'effet sur toutes les colonnes. Attention : ce tableur utilise le point comme séparateur décimal (0.1 et non 0,1). Il s'arrête à la ligne 110, soit un peu plus de dix ans ; la figure qui suit prolonge le même calcul jusqu'à $30$ ans.

var opt = {fontSize: 12, useKatex: false, useMathJax: false, parse: false, fixed: true, highlight: false}; var etat = '', P = null; function lire() { var el = document.getElementById('lv-tab'); if (!el) { return null; } var st = el.getAttribute('data-state') || ''; if (st === etat && P) { return P; } etat = st; var c = {}; try { c = JSON.parse(st).cells || {}; } catch (e) { c = {}; } function v(k, d) { var x = parseFloat(String(c[k] === undefined ? d : c[k]).replace(',', '.')); return isFinite(x) ? x : d; } P = {a: v('B2', 1), b: v('B3', 0.1), c: v('B4', 0.5), d: v('B5', 0.02), h: Math.min(Math.max(v('B6', 0.1), 0.005), 1), x: v('C9', 40), y: v('D9', 5)}; return P; } function courbe(k) { var cu = board.create('curve', [[0], [0]], {strokeColor: k ? '#c62828' : '#2e7d32', strokeWidth: 2, highlight: false}); cu.updateDataArray = function () { var p = lire(); this.dataX = []; this.dataY = []; if (!p) { return; } var x = p.x, y = p.y; for (var n = 0; n * p.h <= 30 + 1e-9; n++) { this.dataX.push(n * p.h); this.dataY.push(k ? y : x); var nx = x + p.h * (p.a - p.b * y) * x, ny = y + p.h * (-p.c + p.d * x) * y; x = nx; y = ny; if (!isFinite(x) || !isFinite(y) || Math.abs(x) > 1e5 || Math.abs(y) > 1e5) { break; } } }; } courbe(0); courbe(1); board.create('text', [1, 98, 'proies x'], Object.assign({}, opt, {strokeColor: '#2e7d32'})); board.create('text', [12, 98, 'prédateurs y'], Object.assign({}, opt, {strokeColor: '#c62828'})); board.create('text', [25, -9, 't (ans)'], opt); var vu = ''; setInterval(function () { var el = document.getElementById('lv-tab'); var st = el ? el.getAttribute('data-state') : ''; if (st !== vu) { vu = st; board.update(); } }, 500); Les deux colonnes du tableur tracées sur $30$ ans, par la méthode d'Euler. La figure suit les paramètres du tableur : après avoir modifié une cellule de B2 à B6 (ou C9, D9) et appuyé sur Entrée, les courbes se mettent à jour.
En Python

Le même calcul en Python. La seule difficulté est celle du calcul à la main : il faut calculer les deux nouvelles valeurs avant de remplacer les anciennes. L'affectation simultanée x, y = …, … le fait automatiquement.

a, b, c, d = 1, 0.1, 0.5, 0.02 # paramètres du modèle h = 0.1 # pas : un dixième d'année x, y = 40, 5 # milliers de proies et de prédateurs au départ t = 0 for n in range(300): # 300 pas de 0,1 an : 30 ans if n % 10 == 0: # on affiche une ligne par an print("t =", round(t), " proies :", round(x, 1), " prédateurs :", round(y, 1)) x, y = x + h * (a - b * y) * x, y + h * (-c + d * x) * y t = t + h
Un défaut de la méthode

En regardant les résultats sur plusieurs dizaines d'années, on remarque que les pics deviennent de plus en plus hauts et les creux de plus en plus bas. Est-ce la réalité du modèle, ou une erreur due au calcul ? Pour le savoir, on recommence avec un pas dix fois plus petit, $h = 0{,}01$, et l'on compare avec un calcul très précis (fait par une méthode plus élaborée).

var opt = {fontSize: 12, useKatex: false, useMathJax: false, parse: false, fixed: true, highlight: false}; var a = 1, b = 0.1, c = 0.5, d = 0.02, h = 0.1; function f(x, y) { return [(a - b * y) * x, (-c + d * x) * y]; } var ex = board.create('curve', [[0], [0]], {strokeColor: '#2e7d32', strokeWidth: 2, highlight: false}); ex.updateDataArray = function () { var x = 40, y = 5, k = 0.01; this.dataX = [x]; this.dataY = [y]; for (var i = 0; i < 1000; i++) { var k1 = f(x, y), k2 = f(x + k/2*k1[0], y + k/2*k1[1]), k3 = f(x + k/2*k2[0], y + k/2*k2[1]), k4 = f(x + k*k3[0], y + k*k3[1]); x += k/6*(k1[0] + 2*k2[0] + 2*k3[0] + k4[0]); y += k/6*(k1[1] + 2*k2[1] + 2*k3[1] + k4[1]); this.dataX.push(x); this.dataY.push(y); } }; var eu = board.create('curve', [[0], [0]], {strokeColor: '#c62828', strokeWidth: 1.5, highlight: false}); eu.updateDataArray = function () { var x = 40, y = 5; this.dataX = [x]; this.dataY = [y]; for (var i = 0; i < Math.round(30 / h); i++) { var v = f(x, y); x = x + h * v[0]; y = y + h * v[1]; this.dataX.push(x); this.dataY.push(y); } }; board.create('text', [3, 39, function () { return 'rouge : Euler sur 30 ans, h = ' + String(h).replace('.', ','); }], Object.assign({}, opt, {strokeColor: '#c62828'})); board.create('text', [3, 35.5, 'vert : calcul très précis'], Object.assign({}, opt, {strokeColor: '#2e7d32'})); board.create('button', [58, 35.5, 'h = 0,1', function () { h = 0.1; board.update(); }], {fontSize: 11, useKatex: false, useMathJax: false, parse: false}); board.create('button', [77, 35.5, 'h = 0,01', function () { h = 0.01; board.update(); }], {fontSize: 11, useKatex: false, useMathJax: false, parse: false}); board.update(); En abscisse, les proies ; en ordonnée, les prédateurs (en milliers). Chaque point de la courbe représente un couple (proies ; prédateurs) à un instant donné. Le calcul précis (en vert) revient exactement à son point de départ : c'est une boucle fermée. La méthode d'Euler (en rouge) s'en écarte en spirale, beaucoup moins avec un petit pas.

Le résultat est net : la spirale vient de la méthode, pas du modèle. On peut en comprendre la raison. La vraie trajectoire tourne autour de l'équilibre en suivant une courbe fermée et bombée. À chaque pas, la méthode d'Euler avance en ligne droite selon la tangente ; or, sur une courbe bombée, la tangente part toujours vers l'extérieur. Chaque pas fait donc sortir un peu de la boucle, et ces petites erreurs s'accumulent. Avec un pas plus petit, chaque erreur est beaucoup plus petite et la spirale s'élargit beaucoup moins vite. C'est un point important : un ordinateur ne donne pas automatiquement la bonne réponse, et il faut savoir contrôler la méthode de calcul.

Les cycles et les moyennes Ce que montrent les courbes

Avec un calcul précis, voici l'évolution des deux populations au cours du temps.

var opt = {fontSize: 12, useKatex: false, useMathJax: false, parse: false, fixed: true, highlight: false}; var a = 1, b = 0.1, c = 0.5, d = 0.02; function f(x, y) { return [(a - b * y) * x, (-c + d * x) * y]; } var T = [0], X = [40], Y = [5], x = 40, y = 5, k = 0.01; for (var i = 1; i <= 3000; i++) { var k1 = f(x, y), k2 = f(x + k/2*k1[0], y + k/2*k1[1]), k3 = f(x + k/2*k2[0], y + k/2*k2[1]), k4 = f(x + k*k3[0], y + k*k3[1]); x += k/6*(k1[0] + 2*k2[0] + 2*k3[0] + k4[0]); y += k/6*(k1[1] + 2*k2[1] + 2*k3[1] + k4[1]); T.push(i * k); X.push(x); Y.push(y); } board.create('line', [[0, 25], [30, 25]], {straightFirst: false, straightLast: false, strokeColor: '#2e7d32', dash: 2, strokeWidth: 1, fixed: true, highlight: false}); board.create('line', [[0, 10], [30, 10]], {straightFirst: false, straightLast: false, strokeColor: '#c62828', dash: 2, strokeWidth: 1, fixed: true, highlight: false}); board.create('curve', [T, X], {strokeColor: '#2e7d32', strokeWidth: 2, highlight: false}); board.create('curve', [T, Y], {strokeColor: '#c62828', strokeWidth: 2, highlight: false}); board.create('text', [1, 68, 'proies (milliers)'], Object.assign({}, opt, {strokeColor: '#2e7d32'})); board.create('text', [15, 68, 'prédateurs (milliers)'], Object.assign({}, opt, {strokeColor: '#c62828'})); board.create('text', [25, -6, 't (ans)'], opt); Les proies (en vert) et les prédateurs (en rouge) sur $30$ ans, avec les valeurs d'exemple choisies plus haut. Les pointillés indiquent les valeurs d'équilibre $25$ et $10$.

On observe trois choses :

  • les deux populations oscillent et reviennent régulièrement aux mêmes valeurs : les mouvements sont périodiques, avec une période d'environ $9{,}5$ ans pour nos valeurs ;
  • chaque pic de prédateurs vient après un pic de proies, comme le prévoyait l'étude des signes ;
  • les courbes oscillent autour des valeurs d'équilibre $25$ et $10$, sans jamais s'y arrêter.

Une autre façon de voir la même chose est de placer, à chaque instant, le point de coordonnées (proies ; prédateurs). Ce point tourne autour du point d'équilibre $(25\,;10)$ en décrivant une boucle fermée. Chaque position de départ donne sa propre boucle.

var opt = {fontSize: 12, useKatex: false, useMathJax: false, parse: false, fixed: true, highlight: false}; var a = 1, b = 0.1, c = 0.5, d = 0.02, k = 0.01; function f(x, y) { return [(a - b * y) * x, (-c + d * x) * y]; } function orbite(x, y, n) { var X = [x], Y = [y]; for (var i = 0; i < n; i++) { var k1 = f(x, y), k2 = f(x + k/2*k1[0], y + k/2*k1[1]), k3 = f(x + k/2*k2[0], y + k/2*k2[1]), k4 = f(x + k*k3[0], y + k*k3[1]); x += k/6*(k1[0] + 2*k2[0] + 2*k3[0] + k4[0]); y += k/6*(k1[1] + 2*k2[1] + 2*k3[1] + k4[1]); X.push(x); Y.push(y); } return [X, Y]; } var o1 = orbite(40, 5, 950), o2 = orbite(32, 8, 1000), o3 = orbite(28, 9, 1000); board.create('curve', o1, {strokeColor: '#1565c0', strokeWidth: 2, highlight: false}); board.create('curve', o2, {strokeColor: '#78909c', strokeWidth: 1.5, highlight: false}); board.create('curve', o3, {strokeColor: '#b0bec5', strokeWidth: 1.5, highlight: false}); board.create('line', [[25, 0], [25, 22]], {straightFirst: false, straightLast: false, strokeColor: '#9e9e9e', dash: 2, strokeWidth: 1, fixed: true, highlight: false}); board.create('line', [[0, 10], [64, 10]], {straightFirst: false, straightLast: false, strokeColor: '#9e9e9e', dash: 2, strokeWidth: 1, fixed: true, highlight: false}); board.create('point', [25, 10], {name: 'équilibre', size: 3, color: '#000', fixed: true, label: {useKatex: false, parse: false, fontSize: 11, offset: [6, -12]}}); var j = 0, actif = false, vu = false; var p = board.create('point', [function () { return o1[0][j]; }, function () { return o1[1][j]; }], {name: '', size: 5, color: '#c62828', fixed: true}); board.create('text', [40, 21.5, function () { return 't = ' + (j * k).toFixed(1).replace('.', ',') + ' an(s)'; }], opt); board.create('text', [43, 14.5, '1'], Object.assign({}, opt, {fontSize: 14, strokeColor: '#1565c0'})); board.create('text', [43, 3.8, '4'], Object.assign({}, opt, {fontSize: 14, strokeColor: '#1565c0'})); board.create('text', [10, 14.5, '2'], Object.assign({}, opt, {fontSize: 14, strokeColor: '#1565c0'})); board.create('text', [10, 3.8, '3'], Object.assign({}, opt, {fontSize: 14, strokeColor: '#1565c0'})); if ('IntersectionObserver' in window) { new IntersectionObserver(function (e) { if (e[0].isIntersecting && !vu) { vu = true; actif = true; } }, {threshold: 0.5}).observe(board.containerObj); } else { actif = true; } setInterval(function () { if (!actif) { return; } j = (j + 4) % o1[0].length; board.update(); }, 40); Dans ce repère, l'abscisse est le nombre de proies et l'ordonnée le nombre de prédateurs. Le point rouge parcourt la boucle bleue (départ : $40$ proies, $5$ prédateurs), toujours dans le même sens. Les boucles grises partent d'autres populations initiales.

Attention au sens de lecture. Dans ce repère, le point ne se déplace pas dans l'espace : il représente les deux populations à un instant donné. Quand il va vers la droite, les proies augmentent ; quand il monte, les prédateurs augmentent. Les chiffres de $1$ à $4$ correspondent aux quatre phases de la partie 4.

Une quantité qui ne change jamais

Pourquoi les trajectoires sont-elles des boucles fermées ? Volterra a trouvé une quantité, calculée à partir de $X$ et $Y$, qui garde la même valeur pendant toute l'évolution. On admet que $X(t)$ et $Y(t)$ restent strictement positifs (ce que montrent les courbes), ce qui permet d'utiliser le logarithme. On pose

$$H(t) = dX - c\ln X + bY - a\ln Y,$$

où $X$ et $Y$ désignent $X(t)$ et $Y(t)$.

$H$ est constante

Dériver. La dérivée de $t \mapsto \ln X(t)$ est $\dfrac{X'}{X}$ (dérivée de $\ln u$). Donc

$$H' = dX' - c\,\frac{X'}{X} + bY' - a\,\frac{Y'}{Y}.$$

Utiliser le système. L'équation $X' = (a - bY)X$ donne, en divisant par $X$, $\dfrac{X'}{X} = a - bY$. De même, $\dfrac{Y'}{Y} = dX - c$. On regroupe les termes deux par deux.

Les deux premiers termes : $dX' = dX(a - bY)$ et $c\dfrac{X'}{X} = c(a - bY)$, donc, en factorisant par $(a - bY)$,

$$dX' - c\frac{X'}{X} = (dX - c)(a - bY).$$

Les deux derniers termes : $bY' = bY(dX - c)$ et $a\dfrac{Y'}{Y} = a(dX - c)$, donc, en factorisant par $(dX - c)$,

$$bY' - a\frac{Y'}{Y} = (dX - c)(bY - a).$$

Additionner. Comme $bY - a = -(a - bY)$, le second résultat est l'opposé du premier. Leur somme est nulle : $H' = 0$.

Conclure. La dérivée de $H$ est nulle à chaque instant : $H$ est constante. Elle garde la valeur qu'elle avait au départ, $H(0)$, calculée en remplaçant $X$ et $Y$ par les populations initiales $X_0$ et $Y_0$.

Conséquence : le point (proies ; prédateurs) reste toujours sur la courbe formée des points $(x\,;y)$ tels que $dx - c\ln x + by - a\ln y = H(0)$. On peut démontrer (c'est plus difficile, on l'admet) que cette courbe est une boucle fermée qui entoure l'équilibre. Le point la parcourt, revient à son point de départ, et recommence : les populations sont périodiques. C'est aussi ce qui permet de voir que la spirale de la méthode d'Euler est une erreur : on peut calculer $H$ avec les valeurs du tableur, et constater qu'elle change au lieu de rester constante.

Les moyennes sur un cycle

Les populations ne restent jamais à l'équilibre, mais Volterra démontre que en moyenne, sur un cycle complet, elles valent exactement les valeurs d'équilibre. Rappelons que la valeur moyenne d'une fonction $f$ sur $[0\,;T]$ est $\dfrac{1}{T}\displaystyle\int_0^T f(t)\,\mathrm{d}t$.

La moyenne des proies sur une période vaut $\dfrac{c}{d}$

Notons $T$ la période : au bout de la durée $T$, les populations reviennent à leurs valeurs de départ, en particulier $Y(T) = Y(0)$.

Étape 1. D'après l'équation des prédateurs, pour tout $t$, $\dfrac{Y'(t)}{Y(t)} = -c + dX(t)$.

Étape 2. On intègre les deux membres entre $0$ et $T$. À gauche, $\dfrac{Y'}{Y}$ est la dérivée de $\ln Y$, donc

$$\int_0^T \frac{Y'(t)}{Y(t)}\,\mathrm{d}t = \ln Y(T) - \ln Y(0) = 0$$

puisque $Y(T) = Y(0)$. À droite, par linéarité de l'intégrale, on intègre séparément $-c$ et $dX(t)$. L'intégrale de la constante $-c$ entre $0$ et $T$ vaut $-cT$, donc l'intégrale du membre de droite vaut

$$-cT + d\int_0^T X(t)\,\mathrm{d}t.$$

Étape 3. Les deux membres sont égaux, donc $0 = -cT + d\displaystyle\int_0^T X(t)\,\mathrm{d}t$, d'où

$$\frac{1}{T}\int_0^T X(t)\,\mathrm{d}t = \frac{c}{d}.$$

Le même raisonnement avec l'équation des proies donne une moyenne des prédateurs égale à $\dfrac{a}{b}$.

Avec nos valeurs, sur un cycle, il y a en moyenne $25$ milliers de proies et $10$ milliers de prédateurs, quelles que soient les populations de départ : une grande boucle et une petite boucle ont la même moyenne. Un calcul numérique sur la boucle bleue le confirme : on trouve $25{,}000$ et $10{,}000$. C'est ce résultat qui va répondre à la question de D'Ancona.

Le principe de Volterra : la réponse à D'Ancona Ajouter la pêche au modèle

Les pêcheurs ne choisissent pas : leurs filets attrapent proies et prédateurs. On suppose que la pêche retire chaque année une même fraction $e$ de chaque population ($e$ mesure l'intensité de la pêche). Elle retire donc $eX$ proies et $eY$ prédateurs par an :

$$\left\{\begin{array}{l} X' = (a - bY)X - eX \\[4pt] Y' = (-c + dX)Y - eY \end{array}\right.$$

On regroupe les termes en $X$ et en $Y$ :

$$\left\{\begin{array}{l} X' = \big((a - e) - bY\big)X \\[4pt] Y' = \big(-(c + e) + dX\big)Y \end{array}\right.$$

C'est encore un système de Lotka-Volterra ! Il suffit de remplacer $a$ par $a - e$ et $c$ par $c + e$. Tout ce qui précède s'applique donc (à condition que $e < a$), et les moyennes sur un cycle deviennent

$$\overline{X} = \frac{c + e}{d}, \qquad \overline{Y} = \frac{a - e}{b}.$$
  • Quand $e$ augmente, $\overline{X}$ augmente : la pêche augmente le nombre moyen de proies.
  • Quand $e$ augmente, $\overline{Y}$ diminue : la pêche diminue le nombre moyen de prédateurs.

C'est contre-intuitif : en pêchant les sardines, on finit en moyenne avec plus de sardines. L'explication : la pêche retire aussi des requins, et moins de requins, c'est beaucoup moins de sardines mangées.

La part des prédateurs dans les filets

Les filets ramènent les deux espèces dans la proportion où elles sont présentes. La part de prédateurs dans les prises, en moyenne, est

$$p = \frac{\overline{Y}}{\overline{X} + \overline{Y}} = \frac{1}{1 + \dfrac{\overline{X}}{\overline{Y}}}.$$

Quand la pêche augmente, $\overline{X}$ augmente et $\overline{Y}$ diminue, donc le quotient $\dfrac{\overline{X}}{\overline{Y}}$ augmente, le dénominateur aussi, et $p$ diminue. Avec nos valeurs :

intensité $e$$\overline{X}$$\overline{Y}$part de prédateurs $p$
$0{,}1$$30$$9$$\dfrac{9}{39} \approx 23\,\%$
$0{,}2$$35$$8$$\dfrac{8}{43} \approx 19\,\%$
$0{,}3$$40$$7$$\dfrac{7}{47} \approx 15\,\%$

La réponse à D'Ancona. Pendant la guerre, la pêche a diminué : $e$ a baissé, donc la part des prédateurs dans les prises a augmenté, exactement comme dans les statistiques de Fiume. Après la guerre, la pêche a repris, et la part des prédateurs est redescendue. Le modèle n'explique pas les valeurs exactes, mais il explique le sens du phénomène. C'est ce qu'on appelle le principe de Volterra : un prélèvement qui touche proies et prédateurs dans la même proportion favorise, en moyenne, les proies.

var opt = {fontSize: 12, useKatex: false, useMathJax: false, parse: false, fixed: true, highlight: false}; var a = 1, b = 0.1, c = 0.5, d = 0.02, k = 0.01; var e = board.create('slider', [[8, -3.8], [40, -3.8], [0, 0, 0.4]], {withLabel: false, snapWidth: 0.05}); board.create('text', [43, -3.8, function () { return 'pêche e = ' + e.Value().toFixed(2).replace('.', ','); }], opt); function orbite(x, y, A, C) { var X = [x], Y = [y]; function f(x, y) { return [(A - b * y) * x, (-C + d * x) * y]; } for (var i = 0; i < 1600; i++) { var k1 = f(x, y), k2 = f(x + k/2*k1[0], y + k/2*k1[1]), k3 = f(x + k/2*k2[0], y + k/2*k2[1]), k4 = f(x + k*k3[0], y + k*k3[1]); x += k/6*(k1[0] + 2*k2[0] + 2*k3[0] + k4[0]); y += k/6*(k1[1] + 2*k2[1] + 2*k3[1] + k4[1]); X.push(x); Y.push(y); } return [X, Y]; } var o0 = orbite(40, 5, a, c); board.create('curve', o0, {strokeColor: '#b0bec5', strokeWidth: 1.5, highlight: false}); board.create('point', [25, 10], {name: '', size: 2, color: '#78909c', fixed: true}); var cur = board.create('curve', [[0], [0]], {strokeColor: '#1565c0', strokeWidth: 2, highlight: false}); cur.updateDataArray = function () { var o = orbite(40, 5, a - e.Value(), c + e.Value()); this.dataX = o[0]; this.dataY = o[1]; }; board.create('point', [function () { return (c + e.Value()) / d; }, function () { return (a - e.Value()) / b; }], {name: 'moyenne', size: 3, color: '#1565c0', fixed: true, label: {useKatex: false, parse: false, fontSize: 11, offset: [6, 8]}}); board.create('text', [1, 25.5, function () { var X = (c + e.Value()) / d, Y = (a - e.Value()) / b; return 'moyennes : ' + X.toFixed(0) + ' proies, ' + Y.toFixed(1).replace('.', ',') + ' prédateurs'; }], opt); board.create('text', [1, 23.3, function () { var X = (c + e.Value()) / d, Y = (a - e.Value()) / b; return 'part de prédateurs : ' + (100 * Y / (X + Y)).toFixed(1).replace('.', ',') + ' %'; }], opt); board.update(); En gris, le cycle sans pêche ; en bleu, le cycle avec une pêche d'intensité $e$, choisie avec le curseur. Quand $e$ augmente, le point moyen se déplace vers la droite (plus de proies) et vers le bas (moins de prédateurs).
Au-delà des poissons Les lynx et les lièvres du Canada Un lynx du Canada naturalisé, debout, à côté d'un lièvre d'Amérique blanc, dans une vitrine de musée. Un lynx du Canada et un lièvre d'Amérique, au musée royal de l'Ontario, à Toronto. Photo : Thomas Quine, Wikimedia Commons, licence CC BY 2.0.

L'exemple le plus célèbre de cycles proies-prédateurs vient du Grand Nord canadien. La Compagnie de la baie d'Hudson, qui achetait des fourrures aux trappeurs, a conservé ses registres pendant près d'un siècle, de 1845 aux années 1930. Les nombres de peaux de lynx et de lièvres achetées montent et descendent avec une période d'environ dix ans, les pics de lynx suivant ceux des lièvres. Ces données, publiées par des écologues dans les années 1930 et 1940, sont devenues l'illustration classique du modèle.

Elles demandent pourtant un regard critique, qui peut nourrir une question de Grand Oral :

  • ce sont des fourrures vendues, pas des animaux comptés : elles dépendent aussi du nombre de trappeurs, du prix des peaux, des épidémies chez les populations autochtones qui chassaient ;
  • les cycles des lièvres semblent aussi liés à leur nourriture et à d'autres prédateurs, pas seulement aux lynx ;
  • sur certaines périodes, les pics de lièvres suivent ceux des lynx, à l'envers de ce que prévoit le modèle. En 1973, l'écologue Michael Gilpin en a tiré un article au titre provocateur : « Do hares eat lynx? » (Les lièvres mangent-ils les lynx ?).
Les insecticides et la coccinelle Une petite coccinelle rouge à taches noires sur une feuille verte. La coccinelle Rodolia cardinalis, prédatrice de la cochenille des agrumes. Photo : gailhampshire, Wikimedia Commons, licence CC BY 2.0.

À la fin du XIXe siècle, une cochenille venue d'Australie, Icerya purchasi, ravage les vergers d'agrumes de Californie. En 1888-1889, on fait venir d'Australie son prédateur naturel, une petite coccinelle, Rodolia cardinalis. La coccinelle se multiplie et ramène la cochenille à un niveau faible : c'est l'un des premiers grands succès de la lutte biologique, qui consiste à combattre un ravageur avec ses prédateurs.

Après la Seconde Guerre mondiale, on se met à pulvériser du DDT, un insecticide qui tue les cochenilles… et les coccinelles. Résultat observé : les cochenilles deviennent de nouveau nombreuses. C'est exactement le principe de Volterra : comme la pêche, un insecticide qui frappe proies et prédateurs favorise, en moyenne, les proies, c'est-à-dire le ravageur. Ce raisonnement compte aujourd'hui dans la façon de protéger les cultures en limitant les pesticides.

Les épidémies

En 1927, un an après Volterra, l'Écossais William Kermack et l'Anglais Anderson McKendrick publient un modèle d'épidémie construit sur la même idée de rencontres. La population est divisée en trois groupes : les personnes saines ($S$), infectées ($I$) et rétablies ($R$, « removed » en anglais). Les nouvelles infections viennent des rencontres entre une personne saine et une personne infectée : leur nombre est proportionnel au produit $S \times I$, comme le nombre de proies mangées était proportionnel à $X \times Y$ :

$$\left\{\begin{array}{l} S' = -\beta SI \\[3pt] I' = \beta SI - \gamma I \\[3pt] R' = \gamma I \end{array}\right.$$

Ici, $\beta$ mesure la contagiosité et $\gamma$ la vitesse de guérison. L'épidémie progresse tant que $I' > 0$, c'est-à-dire tant que $\beta S > \gamma$ : il faut assez de personnes saines à contaminer. Ce type de modèle, fondé sur le même raisonnement que celui de Lotka et Volterra, a été très utilisé pendant l'épidémie de Covid-19, avec la méthode d'Euler ou des méthodes voisines pour le calcul.

La chimie

Lotka, chimiste, avait d'abord étudié en 1910 et 1920 des réactions chimiques imaginaires dans lesquelles les concentrations de deux produits oscillent, avec exactement les mêmes équations. Pendant longtemps, on a cru que de telles réactions ne pouvaient pas exister vraiment. Dans les années 1950 et 1960, les chimistes soviétiques Boris Belooussov et Anatoli Jabotinski découvrent une réaction dont la couleur change périodiquement, du rouge au bleu et inversement : la réaction de Belooussov-Jabotinski (présentée aussi dans le texte Le triangle de Sierpiński). Son mécanisme est plus compliqué que le modèle de Lotka, mais il repose sur la même idée : un produit qui en fabrique un autre, qui le détruit à son tour.

L'économie : le cycle de Goodwin

En 1967, l'économiste britannique Richard Goodwin reprend les équations de Lotka-Volterra pour décrire les cycles de l'économie. Les deux « populations » sont le taux d'emploi (la part de la population active qui a un emploi), qui joue le rôle des proies, et la part des salaires dans la richesse produite, qui joue le rôle des prédateurs. Le raisonnement suit les quatre phases de la partie 4 :

  1. quand l'emploi est élevé, les salariés sont en position de force et obtiennent des hausses de salaires : la part des salaires augmente ;
  2. la part des profits diminue, donc les entreprises investissent moins : l'emploi baisse ;
  3. avec le chômage, les salaires progressent moins vite que la production : la part des salaires baisse ;
  4. les profits se reconstituent, l'investissement reprend, l'emploi remonte, et le cycle recommence.

Ce modèle est discuté par les économistes : il ne tient pas compte de l'État, du commerce extérieur ou de la monnaie. Il montre pourtant comment des cycles peuvent naître du seul jeu de deux grandeurs qui dépendent l'une de l'autre, sans choc venu de l'extérieur.

Les limites du modèle

Le modèle de Lotka-Volterra est un modèle très simplifié, et ses auteurs le savaient. Ses principales limites :

Malgré ces limites, ce modèle reste la base de toute l'écologie mathématique : il a montré qu'une interaction simple peut, à elle seule, produire des cycles, et il a permis d'expliquer un phénomène réel, celui de l'Adriatique, qui paraissait incompréhensible.

Des directions pour construire sa question

Ce texte n'est pas un Grand Oral. Il rassemble des connaissances dans lesquelles chacun peut choisir une direction, la creuser et formuler sa propre question. Quelques directions possibles :

Pour l'échange avec le jury : les notions du cours à maîtriser

Le jury peut interroger sur les chapitres de spécialité mobilisés. Avec ce thème, il est utile de connaître parfaitement : les suites géométriques et les suites définies par récurrence ; le nombre dérivé comme limite du taux d'accroissement ; la dérivation (produit, $\mathrm{e}^{u}$, $\ln u$) et le lien entre signe de la dérivée et variations ; la fonction exponentielle et l'équation différentielle $y' = ay$ ; la fonction logarithme ; les primitives, l'intégrale et la valeur moyenne d'une fonction.

Pour réviser ces chapitres, l'application Maths FlashBac reprend tout le cours de spécialité en cartes.

Pour aller plus loin