Aller au contenu principal

Débutant

Problème de Zermelo

Niveau de difficulté
Cadre mathématique
Temps continu
Espace continu
Fonction valeur
Bassin de capture
Contenu

Introduction

Le « problème de navigation de Zermelo » originel s'énonce comme suit : dans un plan illimité où la répartition du vent est définie par un champ de vecteurs dépendant de la position et du temps, un navire se déplace à vitesse constante par rapport à la masse d'air environnante. Comment le navire doit-il être dirigé pour rallier une destination donnée depuis un point de départ dans le temps le plus court ?

Ce problème peut-être modélisé sous la forme d'un système dynamique contrôlé dont on cherche la commande optimale, celle qui minimise le temps mis pour atteindre la cible.
Les variables d'état $x$ et $y$ désignent les coordonnées du navire en mouvement, tandis que $f(x, y)$ et $g(x, y)$ représentent les composantes de la vitesse du vent qui dépendent de la position. Deux variables de commande régissent l'évolution du navire : la vitesse $v$, dont la norme $||v||$ est bornée par un seuil dépendant de la position ($||v|| ≤ c(x,y)$), et la direction $u$, c'est-à-dire l'angle que forme le vecteur vitesse relative avec l'axe des $x$ qui est contrainte par les bornes $\alpha_{min}(x, y)$ et $\alpha_{max}(x, y)$.
L'évolution du navire est ainsi régie par le système dynamique contrôlé suivant :
\begin{equation}
\left\{
\begin{array}{l}
x'(t) &= f(x(t), y(t)) + v(t) \cos u(t) \\
y'(t) &= g(x(t), y(t)) + v(t) \sin u(t) \\
u(t) &\in [\alpha_{min}(x(t), y(t)),\alpha_{max}(x(t), y(t)] \text{ et } ||v(t)|| ≤ c(x(t), y(t)).
\end{array}
\right.
\end{equation}
 

Etant donné un point de départ $(x_0,y_0)$, il s'agit de trouver les fonctions de commande $u(t)$ et $v(t)$ qui permettent d'atteindre une cible en temps minimal. 

Le problème de Zermelo revisité avec les concepts de la théorie de la viabilité

Depuis

J.-P.AUBIN & H. FRANKOWSKA, « The viability kernel algorithm for computing value functions of infinite horizon optimal control problems », Journal of mathematical analysis and applications, vol. 201, 555–576, 1996.

des liens sont établis entre les problèmes de contrôle optimal et les noyaux de viabilité ou bassins de capture.

Le problème de temps minimal pour l'atteinte d'une cible en est un cas particulier et le problème de Zermelo a été souvent illustré. 

Dans leur livre

Aubin, J.-P., Bayen, A., & Saint-Pierre, P. Viability Theory: New Directions. Springer. 2011.

les auteurs revisitent le problème de Zermelo en remplaçant le "plan illimité" par un environnement $K\subset \mathbb{R}^2$ avec des obstacles, le « but » étant le port, il joue le rôle de la « cible » $C \subset K$ dans la terminologie de la théorie de la viabilité. Il s’agit bien entendu d’un problème plus complexe que le problème de Zermelo initial en raison de ces contraintes supplémentaires définies par l'ensemble $K$ dans lequel les trajectoires doivent rester. 

Associer à chaque point de l'environnement $K$ la valeur du temps minimal nécessaire pour atteindre la cible $C$ revient à calculer le bassin de capture dans la terminologie de la théorie de la viabilité pour le système initial augmenté d'une dimension, celle du coût associé au temps qui s'écoule. En effet, ce bassin de capture correspond à l'épigraphe de la fonction de temps minimal (i.e. l'ensemble des points situés au-dessus de sa courbe représentative).

Dynamiques Contrôles Incertitudes Contraintes Cible Concept de Viabilité

Temps continu

Continues en espace de dimension 2

$\left\{
\begin{array}{l}
x'(t) &= f(x(t), y(t)) + v(t) \cos u(t) \\
y'(t) &= g(x(t), y(t)) + v(t) \sin u(t) \\
\end{array}
\right.$

Fonction de coût : 

$c'(t)=-1$ 

$\left\{
\begin{array}{l}
u(t)&\in [\alpha_{min}(x(t), y(t)),\alpha_{max}(x(t), y(t)] \\
||v(t)|| &\leq c(x(t), y(t))
\end{array}
\right.
$

 

Aucune

$K\subset \mathbb{R}^2\times \mathbb{R}$

 

 

$C\subset K\times [0;+\infty[$

 

Bassin de capture

Résultats

Pour l'illustration numérique, nous choisissons comme zone de déplacement du bateau $K\subset [-6;1]\times[-2.5;2.5]$ privé de deux sous-ensembles représentant deux obstacles $0_1 =  [-4;3]\times[-0;2]$ et $0_2 =  [-2;-1]\times[-0.75;0.75]$ et comme cible $C = \{(x,y) | x^2+y^2\leq 0.04$. Ces sous-ensembles du plan sont dessinés dans le graphique ci-dessous :

La dynamique du courant est $f(x,y)=-0.25\tanh y $ et $g(x,y)=0$, sans contrainte sur le choix de l'angle de la vitesse relative $u(t) \in [0,2\pi]$ mais avec la norme de cette vitesse relative constante égale à 1, $|v(t)| =1$.  Ainsi,  l'évolution du navire est régie par l'équation :

\begin{equation}
\left\{
\begin{array}{l}
x'(t) &= \cos u(t) -0.25\tanh y(t)\\
y'(t) &= \sin u(t) \\
u(t) &\in [0,2\pi]
\end{array}
\right.
\end{equation}

Le bassin de capture est un sous-ensemble de dimension 3 (les 2 dimensions du problème initial + 1 dimension pour la fonction de coût associée au temps minimal).

Ce bassin de capture est épigraphique, c'est à dire qu'il se situe au-dessus de sa frontière inférieure dans la dimension de la fonction de coût. Nous reproduisons ci-dessous l'approximation de sa frontière inférieure calculée par le logiciel ViabLab à partir d'une grille de $701\times 501$ points dans l'espace initial de dimension 2 :


 

 
Les deux "trous" correspondent aux deux obstacles pour les points desquels la valeur du temps minimal pour atteindre la cible est $+\infty$.

Ce résultat peut également être visualisé sous forme de lignes de niveaux dans l'environnement du problème initial : 


 

 

Commentaires

Nous mettons à disposition ci-dessous les fichiers nécessaires pour calculer l'approximation ci-dessus à l'aide du logiciel ViabLab.

Veuillez consulter les supports de formation :

Diversité linguistique

Niveau de difficulté
Cadre mathématique
Temps continu
Espace continu
Noyau de viabilité
Contenu

Introduction

De nombreuses langues risquent de disparaître. Il est donc crucial de comprendre les mécanismes qui sous-tendent l'évolution du nombre de locuteurs et de déterminer s'il existe des mesures susceptibles d'aider à en préserver certaines.

Dans leur article,

Abrams, S. Strogatz, Modelling the dynamics of language death, Nature 424 (6951) (2003) 900

Abrams et Strogatz ont proposé un modèle mathématique pour étudier la concurrence entre les langues.
Ce modèle s'ajuste bien à plusieurs ensembles de données empiriques : il rend compte de manière satisfaisante des données historiques concernant le déclin du gallois,
du gaélique écossais, du quechua et d'autres langues menacées.

Dans le modèle d'Abrams et Strogatz ainsi que dans ceux qui en sont dérivés, on suppose que la taille de la population demeure constante. Par conséquent, les variables sont les proportions des différents groupes de locuteurs. Dans les modèles incluant le bilinguisme, la population se compose de trois groupes : les locuteurs monolingues de la langue A, les locuteurs monolingues de la langue B et les locuteurs bilingues AB ; le modèle est bidimensionnel, avec $\sigma_A$ représentant la proportion de locuteurs de la langue A et $\sigma_B$ la proportion de locuteurs de la langue B ($\sigma_{AB} = 1 - \sigma_A - \sigma_B$).

Au sein de toute sous-population linguistique, des forces et des influences amènent les membres d'un groupe à changer de langue au profit de l'autre. Dans le modèle d'Abrams et Strogatz, la vitesse à laquelle les locuteurs d'une langue apprennent la seconde langue dépend de l'attractivité de cette dernière. Dans leur définition la plus générale de l'attractivité, Abrams et Strogatz postulent qu'une langue est d'autant plus attractive qu'elle compte un grand nombre de locuteurs et qu'elle jouit d'un prestige élevé.

Dans leur article,

C. Bernard, S. Martin, Building strategies to ensure language coexistence in presence of bilingualism, Appl. Math. Comput. (2012), doi:10.1016/j.amc.2012.02.041

les auteurs modélisent uniquement les transitions des quatre types suivants : A → AB, AB → A, A → AB et AB → B ((les transitions A → B et B → A étant extrêmement rares en pratique). Ils supposent également une asymétrie entre monolingues et bilingues : A → AB (resp. B → AB) à un taux proportionnel à l'attractivité des locuteurs monolingues de A (resp. B) ; AB → A (resp. AB → B) à un taux proportionnel à l'attractivité de l'ensemble des locuteurs de A, y compris les bilingues (ainsi, certains bilingues peuvent devenir des locuteurs monolingues de A même si A ne compte aucun locuteur monolingue).
Par conséquent, le modèle bidimensionnel est défini par :

$$
\left\{\begin{array}{ll}
\sigma_A' &= (1-\sigma_A-\sigma_B)(1-\sigma_B)^as_A-\sigma_A\sigma_B^as_B\\
\sigma_B' &= (1-\sigma_A-\sigma_B)(1-\sigma_A)^as_B-\sigma_B\sigma_A^as_A
\end{array}\right.
$$

où $s_A$  (resp. $s_B$) désigne le prestige de la langue A (resp. B), et $a$ est un paramètre modélisant la manière dont l'attractivité d'une langue varie en fonction de la proportion de ses locuteurs.
Par commodité, les auteurs supposent que $s_A+s_B=1$ ce qui permet de substituer $s_A=s$ et $s_B=1-s$.

Le problème de la coexistence de deux langues

Bernard et Martin considèrent que le prestige, $s$, peut évoluer (sous l'effet de l'action publique, par exemple), mais que sa variation à chaque pas de temps est bornée. Ainsi, 

$$
s' = u\in U=[\underline{u};\bar{u}]
$$

Lorsque que $u>0$, le prestige de la langue A augmente et celui de B diminue, c'est l'inverse lorsque $u<0$.

La dynamique du système est ainsi décrite par :

$$
\left\{\begin{array}{ll}
\sigma_A' &= (1-\sigma_A-\sigma_B)(1-\sigma_B)^as-\sigma_A\sigma_B^a(1-s)\\
\sigma_B' &= (1-\sigma_A-\sigma_B)(1-\sigma_A)^a(1-s)-\sigma_B\sigma_A^as\\
s' &= u\in U=[\underline{u};\bar{u}]
\end{array}\right.
$$

Les auteurs proposent de rechercher des stratégies fondées sur les variations de prestige qui garantissent la coexistence des deux langues, c'est à dire qui maintiennent un niveau donné de locuteurs monolingues dans chacune des deux langues. L'ensemble des contraintes s'écrit donc :

$$
K:= [\underline{\sigma};1]\times[\underline{\sigma};1]\times [0;1]
$$

Résoudre ce problème, c'est trouver l'ensemble des états $(\sigma_A,sigma_B,s)$ à partir desquels il est possible de maintenir une certaine proportion des groupes monolingues en agissant sur la variation des prestiges relatifs des deux langues, c'est à dire le noyau de viabilité dans la terminologie de la théorie de la viabilité.

 

Dynamiques Contrôles Incertitudes Contraintes Cible Concept de Viabilité

Temps continu

Continues en espace de dimension 3

$
\left\{\begin{array}{ll}
\sigma_A' &= (1-\sigma_A-\sigma_B)(1-\sigma_B)^as-\sigma_A\sigma_B^a(1-s)\\
\sigma_B' &= (1-\sigma_A-\sigma_B)(1-\sigma_A)^a(1-s)-\sigma_B\sigma_A^as\\
s' &= u
\end{array}\right.
$

$(\sigma_A,\sigma_B,s)\in [0;1]\times[0;1]\times [0;1]\cap \{\sigma_A+\sigma_B\leq 1\}
$

Paramètres : $a$

$u\in U=[\underline{u};\bar{u}]$

Paramètres : $\underline{u},\bar{u}$

Aucune

$
K:= [\underline{\sigma};1]\times[\underline{\sigma};1]\times [0;1]
$

 

Paramètres : $\underline{\sigma}$

Aucune Noyau de viabilité

Résultats

Dans l'article cité ci-dessus, les auteurs ont établi une description analytique de la frontière du noyau de viabilité composée de courbes intégrales issues de points particuliers de la frontière de l'ensemble des contraintes.
Pour illustrer leur résultat, ils ont reproduit le noyau de viabilité pour les valeurs de paramètres $a=1.41$, $\underline{u}=-0.06$, $\bar{u}=0.06$, $\underline{\sigma}=0.1$.

Nous reproduisons ci-dessous 4 vues 3D de l'approximation du noyau de viabilité associé à ces valeurs de paramètres par le logiciel ViabLab à partir d'une grille de $201\times 201\times 201$ points (les lignes noires  représentent les arrêtes de l'ensemble de contraintes): 

Comme attendu, le noyau est invariant par la transformation $\sigma_A\rightarrow \sigma_B$, $\sigma_B\rightarrow \sigma_A$ et $s\rightarrow 1-s$.

Les situations non viables correspondent à des états à partir des desquels :

  • même une augmentation continue d'intensité maximale du prestige de la langue A jusqu'à sa valeur maximale 1 ne permettra pas d'éviter que la proportion de ses locuteurs ne passe le seuil $\underline{\sigma}$,
  • ou même une augmentation continue d'intensité maximale du prestige de la langue B jusqu'à sa valeur maximale 1 ne permettra pas d'éviter que la proportion de ses locuteurs ne passe le seuil $\underline{\sigma}$.
Commentaires

Nous mettons à disposition ci-dessous les fichiers nécessaires pour calculer l'approximation ci-dessus à l'aide du logiciel ViabLab.

Veuillez consulter les supports de formation :

Gestion du pâturage - biomasses des tiges et couronnes

Niveau de difficulté
Domaine
Cadre mathématique
Espace continu
Noyau de viabilité
Temps continu
Contenu

Introduction

L'un des enjeux majeurs de la gestion des prairies pâturées consiste à concilier des objectifs antagonistes : accroître les profits à court terme tout en préservant la viabilité à long terme du parcours. 
En effet, augmenter la charge pastorale (nombre d'animaux par hectare) permet d'accroître les gains à court terme, mais peut entraîner une dégradation pratiquement irréversible du milieu si la pression de pâturage qui en résulte est excessive. À l'inverse, maintenir une charge pastorale trop faible peut engendrer un manque à gagner considérable. 

Dans leur article 

Anderies, J., Janssen, M. & Walker, B. Grazing Management, Resilience, and the Dynamics of a Fire-driven Rangeland System. Ecosystems 5, 23–44 (2002). https://doi.org/10.1007/s10021-001-0053-9

les auteurs utilisent le modèle suivant pour rendre compte des interactions entre la pousse de l'herbe et la pression de pâturage : 

$$
\left\{\begin{array}{ll}
c' &= r_cs-\delta_cc\\
s'&= c(a_c+r_ss)(1-\frac{s}{s^*}-\alpha_{ws}(\frac{w}{w^*})^\beta)-\gamma_gs\\
w'&=r_ww(1-\frac{w}{w^*})
\end{array}\right.
$$

Concernant l'herbe, $c(t)$ et $s(t)$ représentent respectivement la biomasse de la couronne (racines plus points de croissance) et celle de la partie aérienne à l'instant $t$. Le paramètre $s^*$ correspond à la biomasse aérienne maximale par unité de surface, tandis que $\gamma_g\leq 1$ représente la fraction de la partie aérienne prélevée par la pression de pâturage exercée par l'ensemble des animaux présents. La couronne croît à un taux $r_cs$ en présence de parties aériennes et régresse à un taux $\delta_c$.
$a_c$ correspond au taux de croissance de la biomasse aérienne par unité de biomasse de la couronne, $r_s$ au taux de croissance de la biomasse aérienne par unité de biomasse de la couronne et par unité de biomasse aérienne.

La croissance de l'herbe est également affectée par la présence d'arbustes : $w(t)$ représente la biomasse des arbustes, $r_w$ le taux de croissance intrinsèque des arbustes, $w^*$ la biomasse maximale des arbustes par unité de surface, et $w_s(=w/w^*)$ modélise l'effet de compétition des arbustes sur l'herbe. Le paramètre $\beta$ mesure la non-linéarité relative de cet effet.

Le problème de viabilité du gestionnaire de pâtures

L'objectif de la gestion des parcours de pâturage consiste à identifier des stratégies d'intervention (modifications de la charge pastorale) permettant de concilier deux contraintes : nourrir suffisamment les animaux tout en préservant la qualité de l'herbe.

Dans l'article 

Martin S. Viability analysis as an approach for assessing the resilience of agroecosystems. In: Gardner SM, Ramsden SJ, Hails RS, eds. Agricultural Resilience: Perspectives from Ecology and Economics. Ecological Reviews. Cambridge University Press; 2019:273-294.

les auteurs étudient ce problème de viabilité en utilisant un modèle de pousse d'herbe simplifié en supposant que la biomasse de tiges maximale vaut 1 et que l'impact de la population d'arbustes est négligeable c'est à dire que : 

$$
s^* = 1 \text{ et } \alpha_{ws} = 0.$$

L'action possible sur le système est de faire varier la pression de pâturage et cette variation est supposée bornée, l'achat de nouveaux animaux  ou leur vente prend  un certain temps :

$$
\gamma'(t) = u(t) \in [u_{min},u_{max}].
$$

La dynamique du système est ainsi décrite par :

$$
\left\{\begin{array}{ll}
c' &= r_cs-\delta_cc\\
s'&= \frac{r_c}{\delta_c}s(a_c+r_ss)(1-s)-\gamma_gs\\
\gamma_g'&= u \in [u_{min},u_{max}]
\end{array}\right.
$$

La contrainte sur la qualité de l'herbe est modélisée par une valeur de la biomasse aérienne supérieure à un seuil, $s_{min}$, pour assurer la repousse. La contrainte sur la nourriture du bétail est modélisée par une pression de pâturage également supérieure à un seuil, $\underline{g}$, au cours du temps. L'ensemble des contraintes s'écrit donc :

$$
K(s_{min},\underline{g}):=R^+\times [s_{min},+\infty[\times  [\underline{g},1]
$$

Résoudre ce problème, c'est trouver l'ensemble des états $(c,s,\gamma_g)$ à partir desquels il est possible de nourrir le troupeau en conservant une herbe de qualité en agissant sur la variation du nombre d'animaux, c'est à dire le noyau de viabilité dans la terminologie de la théorie de la viabilité.

 

Dynamiques Contrôles Incertitudes Contraintes Cible Concept de Viabilité

Temps continu

Continues en espace de dimension 3

$
\left\{\begin{array}{ll}
c' &= r_cs-\delta_cc\\
s'&= \frac{r_c}{\delta_c}s(a_c+r_ss)(1-s)-\gamma_gs\\
\gamma_g'&= u 
\end{array}\right.
$

Paramètres : $r_c, \delta_c, a_c, r_s$

$u\in U=\left[ u_{min},u_{max}\right]$

Paramètres : $u_{min},u_{max}$

Aucune

$
K(s_{min},\underline{g}):=R^+\times [s_{min},+\infty[\times  [\underline{g},1]
$

 

Paramètres : $s_{min},\underline{g}$

Aucune Noyau de viabilité

Résultats

Dans l'article cité ci-dessus les valeurs des paramètres sont les suivantes : $r_c=1$, $\delta_c=1$, $a_c=0.1$,  $r_s=3$,  $s^*=1$, $u_{min} = -0.05$, $u_{max} = 0.05$, $s_{min} = 0.1$, $\underline{g}=0.65$.

Nous reproduisons ci-dessous l'approximation du noyau de viabilité associé à ces valeurs de paramètres par le logiciel ViabLab à partir d'une grille de 201*201*201 points : 

 

Vue de l'approximation du noyau de viabilité en 3D

 

 

 

Valeur maximale de pression de pâturage qui reste viable pour les différents valeurs de biomasses de tiges et de couronnes : $\max_{(c,s,\gamma_g)\in Viab(K)}\gamma_g$.

 

 

Comme attendu, lorsque l'on part d'une pression de pâturage plus élevée, l'ensemble des combinaisons de biomasses tiges et couronnes pour lesquelles le système est viable est plus restreint.

Cette restriction est d'autant plus forte que la capacité de diminution de cette pression est faible, c'est à dire quand $u_{min}$ se rapproche de 0.

 

Commentaires

Nous mettons à disposition ci-dessous les fichiers nécessaires pour calculer l'approximation ci-dessus à l'aide du logiciel ViabLab.

Veuillez consulter les supports de formation :

Gestion du pâturage - biomasse des tiges

Niveau de difficulté
Domaine
Cadre mathématique
Espace continu
Noyau de viabilité
Temps continu
Contenu

Introduction

L'un des enjeux majeurs de la gestion des prairies pâturées consiste à concilier des objectifs antagonistes : accroître les profits à court terme tout en préservant la viabilité à long terme du parcours. 
En effet, augmenter la charge pastorale (nombre d'animaux par hectare) permet d'accroître les gains à court terme, mais peut entraîner une dégradation pratiquement irréversible du milieu si la pression de pâturage qui en résulte est excessive. À l'inverse, maintenir une charge pastorale trop faible peut engendrer un manque à gagner considérable. 

Dans leur article 

Anderies, J., Janssen, M. & Walker, B. Grazing Management, Resilience, and the Dynamics of a Fire-driven Rangeland System. Ecosystems 5, 23–44 (2002). https://doi.org/10.1007/s10021-001-0053-9

les auteurs utilisent le modèle suivant pour rendre compte des interactions entre la pousse de l'herbe et la pression de pâturage : 

$$
\left\{\begin{array}{ll}
c' &= r_cs-\delta_cc\\
s'&= c(a_c+r_ss)(1-\frac{s}{s^*}-\alpha_{ws}(\frac{w}{w^*})^\beta)-\gamma_gs\\
w'&=r_ww(1-\frac{w}{w^*})
\end{array}\right.
$$

Concernant l'herbe, $c(t)$ et $s(t)$ représentent respectivement la biomasse de la couronne (racines plus points de croissance) et celle de la partie aérienne à l'instant $t$. Le paramètre $s^*$ correspond à la biomasse aérienne maximale par unité de surface, tandis que $\gamma_g\leq 1$ représente la fraction de la partie aérienne prélevée par la pression de pâturage exercée par l'ensemble des animaux présents. La couronne croît à un taux $r_cs$ en présence de parties aériennes et régresse à un taux $\delta_c$.
$a_c$ correspond au taux de croissance de la biomasse aérienne par unité de biomasse de la couronne, $r_s$ au taux de croissance de la biomasse aérienne par unité de biomasse de la couronne et par unité de biomasse aérienne.

La croissance de l'herbe est également affectée par la présence d'arbustes : $w(t)$ représente la biomasse des arbustes, $r_w$ le taux de croissance intrinsèque des arbustes, $w^*$ la biomasse maximale des arbustes par unité de surface, et $w_s(=w/w^*)$ modélise l'effet de compétition des arbustes sur l'herbe. Le paramètre $\beta$ mesure la non-linéarité relative de cet effet.

Le problème de viabilité du gestionnaire de pâtures

L'objectif de la gestion des parcours de pâturage consiste à identifier des stratégies d'intervention (modifications de la charge pastorale) permettant de concilier deux contraintes : nourrir suffisamment les animaux tout en préservant la qualité de l'herbe.

Dans l'article 

Martin, Sophie & Deffuant, Guillaume & Calabrese, Justin. (2011). Defining Resilience Mathematically: From Attractors To Viability. 10.1007/978-3-642-20423-4_2. 

les auteurs étudient ce problème de viabilité en utilisant un modèle de pousse d'herbe simplifié en supposant que la population d'arbuste est constante à la valeur d'équilibre et que la biomasse de la couronne prend instantanément la valeur d'équilibre associée à la biomasse aérienne : 

$$
w = w^* \text{ and  } c = \frac{r_c}{\delta_c}s.
$$

L'action possible sur le système est de faire varier la pression de pâturage et cette variation est supposée bornée, l'achat de nouveaux animaux  ou leur vente prend  un certain temps :

$$
\gamma'(t) = u(t) \in [u_{min},u_{max}].
$$

La dynamique du système est ainsi décrite par :

$$
\left\{\begin{array}{ll}
\gamma_g'&= u \in [u_{min},u_{max}]\\
s'&= \frac{r_c}{\delta_c}s(a_c+r_ss)(1-\frac{s}{s^*}-\alpha_{ws})-\gamma_gs.
\end{array}\right.
$$

La contrainte sur la qualité de l'herbe est modélisée par une valeur de la biomasse aérienne comprise entre deux bornes, la borne inférieure pour assurer le renouvellement, la borne supérieure pour préserver ses qualités nutritives. La contrainte sur la nourriture du bétail est modélisée par une pression de pâturage également supérieure à un seuil au cours du temps. L'ensemble des contraintes s'écrit donc :

$$
K(\underline{g},s_{min},s_{max}):=[\underline{g},1]\times [s_{min},s_{max}].
$$

Résoudre ce problème, c'est trouver l'ensemble des états $(s,\gamma_g)$ à partir desquels il est possible de nourrir le troupeau en conservant une herbe de qualité en agissant sur la variation du nombre d'animaux, c'est à dire le noyau de viabilité dans la terminologie de la théorie de la viabilité.

 

Dynamiques Contrôles Incertitudes Contraintes Cible Concept de Viabilité

Temps continu

Continues en espace de dimension 2

\begin{equation}
\left\{\begin{array}{ll}
\gamma_g'&= u\\
s'&= \frac{r_c}{\delta_c}s(a_c+r_ss)(1-\frac{s}{s^*}-\alpha_{ws})-\gamma_gs\\ 
\end{array}\right.
\end{equation}

Paramètres : $r_c, \delta_c, a_c, r_s, s^*,  \alpha_{ws}$

$u\in U=\left[ u_{min},u_{max}\right]$

Paramètres : $u_{min},u_{max}$

Aucune

$
K(\underline{g},s_{min},s_{max}):=[\underline{g},1]\times [s_{min},s_{max}].
$

 

Paramètres : $\underline{g}, s_{min},s_{max}$

Aucune Noyau de viabilité

Résultats

Pour les valeurs des paramètres de l'article cité ci-dessus ($r_c=1$, $\delta_c=1$, $a_c=0.3$,  $r_s=3$,  $s^*=1$,  $\alpha_{ws}=0.5$, $u_{min} = -0.02$, $u_{max} = 0.02$, $\underline{g}=0$, $s_{min} = 0.1$, $s_{max} = 0.18$), le noyau de viabilité peut être obtenu par le calcul de deux courbes intégrales (les auteurs de l'article n'ont pas développé ce point).

En effet, sa frontière est définie par une courbe fermée formée de sous-ensembles de la frontière de l'ensemble de contraintes $K$ et de deux courbes intégrales : 

  • l'une issue du point $(\gamma_g^1,s_{min}) $ avec $s'(\gamma_g^1,s_{min})) = 0$ qui suit la dynamique inverse : 
    \begin{equation}
    \left\{\begin{array}{ll}
    \gamma_g'&= -u_{min}\\
    s'&= -(\frac{r_c}{\delta_c}s(a_c+r_ss)(1-\frac{s}{s^*}-\alpha_{ws})-\gamma_gs)\\ 
    \end{array}\right.
    \end{equation}
  • l'autre issue du point $(\gamma_g^2,s_{max}) $ avec $s'(\gamma_g^2,s_{max})) = 0$ qui suit la dynamique inverse : 
    \begin{equation}
    \left\{\begin{array}{ll}
    \gamma_g'&= -u_{max}\\
    s'&= -(\frac{r_c}{\delta_c}s(a_c+r_ss)(1-\frac{s}{s^*}-\alpha_{ws})-\gamma_gs)\\ 
    \end{array}\right.
    \end{equation}

La figure suivante montre la frontière du noyau de viabilité sous cette forme de courbe fermée ainsi que l'approximation obtenue avec le logiciel ViabLab sur une grille de 2001 * 2001 points. Le résultat obtenu est cohérent avec le graphique de l'article original et bien plus précis dans la partie de la frontière du noyau qui coïncide avec la frontière de l'ensemble des contraintes ainsi que dans celle définie par les courbes intégrales.

Commentaires

Nous mettons à disposition ci-dessous les fichiers nécessaires pour calculer l'approximation ci-dessus à l'aide du logiciel ViabLab.

Veuillez consulter les supports de formation :

Exemple pour jouer : un disque dans un carré

Niveau de difficulté
Domaine
Cadre mathématique
Noyau de viabilité
Contenu

Voici un exemple dont on connaît le noyau de viabilité.

En effet, prenons une dynamique en deux dimensions dont l'orbite des points du cercle de centre l'origine du repère et de rayon $a$ est ce même cercle ; dont l'orbite des points de norme strictement inférieure à $a$ est une spirale qui tend vers l'origine et dont l'orbite des points de norme strictement supérieure à $a$ est une spirale qui diverge.

C'est le cas des solutions de l'équation $x'=f(x)$ avec 

$$
f(x_1,x_2):=(\frac{||x||-a}{||x||}x_1+x_2 ; -x_1+\frac{||x||-a}{||x||}x_2)
$$   

Prenons comme ensemble de contraintes, le carré  : 

$$
K := \{(x_1,x_2)\in R^2\,|\, |x_1|\leq c \text{ et } |x_2|\leq c \}.
$$

De manière évidente, l'ensemble des points dont sont issues des trajectoires qui restent dans $K$ indéfiniment  est le disque de centre l'origine du repère et de rayon $a$.

Cet exemple permet de tester la finesse d'approximations issues de logiciels génériques.

Dynamiques Contrôles Incertitudes Contraintes Cible Concept de Viabilité

Temps continu

Continues en espace de dimension 2

$f(x_1,x_2):=(\frac{||x||-a}{||x||}x_1+x_2 ; -x_1+\frac{||x||-a}{||x||}x_2)
$

Paramètres : $a$

Aucun Aucune

$\{(x_1,x_2)\in R^2\,|\, |x_1|\leq c \text{ et } |x_2|\leq c \}$

 

Paramètres : $c$

Aucune Noyau de viabilité

Ci-dessous la comparaison pour $a = 0.7$ et $c=1.5$ entre le résultat théorique (le disque dont la frontière est le cercle rouge) et le résultat approché obtenu avec le logiciel ViabLab sur une grille régulière de 2001*2001points (ensemble vert avec la frontière bleue) : 

 

Commentaires

Nous mettons à disposition ci-dessous les fichiers nécessaires pour calcuer les approximations susmentionnées à l'aide du logiciel ViabLab.

Veuillez consulter les supports de formation :

Fichier(s) de code

[Texte] ViabLab (version >=4.0) : exécuter les calculs des applications de viability-theory.org

Niveau de difficulté
Domaine
Thématique
Objectif

La section Applications du site propose des exemples de calculs de viabilité qui contiennent souvent les fichiers permettant de calculer les approximations dont des visualisations sont affichées sur le site.

Ce tutoriel propose la marche à suivre pour effectuer ses calculs en vous-mêmes. 

Pré-requis

Avoir installé ViabLab

Etre allé jusqu'au bout de la procédure qui se termine par les deux commandes cmake < suite à spécifier> puis make (tutoriel d'installation). 

Contenu

Pour exécuter les calculs de viabilité associés à une application décrite dans le site : 

  • Se rendre sur la page sui décrit cette application, par exemple : https://viability-theory.org/applications/julia 

  • Au bas de la page, lire la partie Commentaires et télécharger le fichier .cpp et le fichier .json qui correspondent au calcul de viabilité que vous souhaitez effectuer (Attention : les applications de niveau intermédiaire et expert peuvent proposer plusieurs calculs de viabilité). Les noms de ces fichiers suivent la même syntaxe : à partir d'une chaine de caractère spécifique du problème traité, par exemple "modele1", les deux fichiers sont nommés  data_modele1.cpp et modele1_params.json.

  • Copier le fichier .cpp dans le répertoire /source/data de ViabLab et le fichier .json dans le répertoire /INPUT.

  • Ouvrir un terminal (pour Windows : touche Windows + R, taper powershell)

    • Aller dans le répertoire /build de VIABLAB :

      cd <chemin à spécifier>/build/
    • exécuter les commandes cmake et make  pour compiler le code : 

      cmake ../source
      make
  • Exécuter ViabLab en précisant le calcul que vous souhaitez effectuer. Si on garde l'exemple du calcul associé à la chaine de caractères "modele1" : 

    ./viabLab data_modele1.so

Les fichiers résultats dont les noms commencent par "modele1" sont crées dans le répertoire /OUTPUT.

[Texte] Fichiers de sortie de ViabLab

Niveau de difficulté
Thématique
Objectif

Décrire la syntaxe des fichiers issus des calculs de ViabLab.

Contenu

Les fichiers issus de l'exécution de ViabLab sont enregistrés dans le répertoire /OUTPUT.

Un calcul génère plusieurs fichiers qui sont nommés avec le même préfixe.
Les suffixes correspondent aux types d'informations contenues dans les fichiers. Ainsi, tous les fichiers de même suffixe suivent la même syntaxe. Sont listés ci-dessous tous les types de fichiers qu'un calcul de ViabLab peut produire : 

<prefixe>-grid_data.dat
Fichier de grille - lire le descriptif 

Le fichier de grille est un fichier permettant de connaître les dimensions et paramètres de la grille régulière à partir de laquelle s'est effectué le calcul, et ainsi pouvoir lire les autres fichiers. 
Ci-dessous l'exemple d'une sortie (du modèle SimplePopGrowth), la description est ajoutée en commentaires après un # : 

2  # Dimension de l'espace d'états (STATE_DIMENSION)
# Valeurs minimales des coordonnées d'un état (STATE_MIN_VALUES)
# Il y a autant de valeurs que de dimension de l'espace des états (STATE_DIMENSION)
-2 # première coordonnée du point inférieur (dans toutes les dimensions) de la grille 
-2 # seconde coordonnée du point inférieur (dans toutes les dimensions) de la grille
# Valeurs maximales des coordonnées d'un état (STATE_MAX_VALUES)
# Il y a autant de valeurs que de dimension de l'espace des états (STATE_DIMENSION)
2  # première coordonnée du point supérieur (dans toutes les dimensions) de la grille
2  # seconde coordonnée du point supérieur (dans toutes les dimensions) de la grille
# Nombre de points de grille par dimension (STATE_GRID_POINTS)
4001 # nombre de points de la grille selon le premier axe
4001 # nombre de points de la grille selon le second axe
# Indice des dimensions à conserver pour la coupe (SLICE_DIRS)
0
0    
# Valeur souhaitée pour la dimension fixée (SLICE_VALUES) 
1
1

<prefixe>-viab.dat
Fichier de noyau de viabilité complet - lire le descriptif 

Ce fichier contient des lignes représentant les coordonnées des points de grille et leur appartenance au noyau. Chaque ligne contient STATE_DIMENSION coordonnées de points de grille séparées par des espaces et en dernier une valeur.

La signification de la valeur en fin de ligne diffère selon le type de noyau de viabilité calculé (spécfié  GRID_METHOD).

Si le noyau de viabilité est un ensemble quelconque (GRID_METHOD vaut “BS” (BitSet)), la dernière valeur vaut 1.0 si le point est dans le noyau de viabilité et 0.0 sinon. 
(A noter qu'il est possible de ne pas écrire les valeurs non contenues dans le noyau en mettant SAVE_VIABSET_LIGHT à True, dans quel cas le fichier ne contiendra que les lignes se terminant par 1.0.)

Si le noyau de viabilité est l'épigraphe d'une fonction valeur (GRID_METHOD vaut MM (MicroMacro)), la dernière valeur indique la valeur de la grille en cette position. La dernière valeur vaudra alors PLUS_INF (constante du programme valant 1015) si la valeur n’est pas contenue dans le noyau et une valeur strictement inférieure si elle appartient au noyau. Tout comme pour un méthode BS, il est possible de ne conserver que les lignes contenues dans le noyau de viabilité.


<prefixe>-viab-bound.dat
Fichier de la frontière du noyau de viabilité - lire le descriptif 

Ce fichier contient la liste des points représentant la frontière du noyau de viabilité, c'est à dire les coordonnées des points de la grille qui ont au moins un voisin qui n'appartient pas au noyau calculé. Ces points sont écrits sous forme de STATE_DIMENSION coordonnées séparées par des espaces. Il y a un point par ligne.


<prefixe>-traj-[i].dat et <prefixe>-traj-[i]-Discrete.dat 
Fichiers de trajectoires - lire le descriptif 

Les fichiers de trajectoire fonctionnent par paires. Chaque fichier de trajectoire “réelle” se terminant en -traj-[i].dat, avec i un entier, est accompagné d’un fichier de trajectoire discrète en traj-[i]-Discrete.dat.

Le fichier de trajectoire réelle est un ensemble de lignes représentant chacune un état, un temps (durée) depuis le début de la trajectoire et un contrôle. Chaque état est représenté par STATE_DIMENSION coordonnées et chaque contrôle par CONTROL_DIMENSION coordonnées.

Si jamais une trajectoire par stratégie est utilisée, et que le paramètre de trajectoire SAVE_PICKING_STRATEGY n’est pas false, la dernière colonne sera une liste de stratégies de la forme “NOM_STRATEGIE_1(indice_dans_liste_de_stratégies),NOM_STRATEGIE_2(indice_dans_liste_de_stratégies),…NOM_STRATEGIE_n(indice_dans_liste_de_stratégies)”. Chaque stratégie à l’intérieur de cette liste est alors une stratégie ayant contribué au choix (modifié la valeur) du contrôle retourné.

Une ligne est donc composée de:

  1. STATE_DIMENSION coordonnées séparées par des espaces représentant un état.
  2. Une durée depuis le début de la trajectoire.
  3. CONTROL_DIMENSION coordonnées séparées par des espaces représentant un contrôle.
  4. Optionellement, une liste de stratégies séparées par des virgules (,) au format “NOM(indice)”, avec “indice” un entier correspondant à l’indice dans la liste des stratégies et “NOM” le nom de la stratégie ayant cet indice dans le JSON.

Pour un schéma numérique donnée (Euler, Runge-Kutta d’ordre 2, Runge-Kutta d’ordre 4), il devrait être possible de retrouver la trajectoire obtenue à l’aide de la dynamique, notée $\Phi(x, u)$ avec $x$ l’état et $u$ le contrôle. On note $x_n$ l’état sur la ligne $n$, $t_n$ la durée en $n$ et $u_n$ le contrôle en $n$.

Pour la méthode d’Euler, on a par exemple que:

$$ x_{n+1} = x_n + (t_{n+1} - t_n)\Phi(x_n, u_n).$$


[Texte] ViabLab (version >=4.0) : première utilisation

Niveau de difficulté
Thématique
Objectif

Exécuter un des modèles déjà implémentés

En effet, vous avez peut-être remarqué qu'à la fin de l'installation en exécutant la commande 

make

les lignes suivantes listent le nom des modèles déjà implémentés :

[ 50%] Built target ARKerU_data
[ 52%] Built target ExempleViabi2D_data
[ 55%] Built target Exemple_multiDim_data
[ 57%] Built target VALIUM
[ 59%] Built target VALIUM_2f
[ 61%] Built target VALIUM_Hybrid
[ 64%] Built target ValiumGaranti_2f
[ 66%] Built target data_Coeur
[ 68%] Built target data_Demo
[ 70%] Built target data_Julia2D
[ 73%] Built target data_Lac
[ 75%] Built target data_LakeCollective
[ 77%] Built target data_LotkaVolterra
[ 79%] Built target data_SimplePopGrowth
[ 82%] Built target data_circle
[ 84%] Built target data_hybridTest
[ 86%] Built target data_labyrinthe
[ 88%] Built target equilibres4D_data
[ 91%] Built target pareto_data
[ 93%] Built target resilience_data
[ 95%] Built target testPendule_data
[ 97%] Built target zermelo_Lmin
[100%] Built target zermelo_tmin

 

Pré-requis

Avoir installé ViabLab

Etre allé jusqu'au bout de la procédure qui se termine par les deux commandes cmake < suite à spécifier> puis make (tutoriel d'installation). 

Contenu

Pour exécuter un code de modèle déjà présent, une seule ligne de commande est nécessaire. 

Pour le modèle SimplePopGrowth par exemple (qui utilise les fichiers data_SimplePopGrowth.cpp dans /source/data, et SimplePopGrowth_params.json dans /INPUT) :

  • Ouvrir un terminal (pour Windows : touche Windows + R, taper powershell).

  • Puis la commande :

./viabLab data_SimplePopGrowth.so

Les fichiers résultats dont les noms commencent par "SimplePopGrowth" sont crées dans le répertoire /OUTPUT.

[Texte] Désinstallation de ViabLab (version >=4.0)

Niveau de difficulté
Domaine
Thématique
Objectif

Désinstaller ViabLab

Contenu

Pour désinstaller ViabLab, il suffit de supprimer le répertoire qui le contient.

Pour désinstaller les librairies dont ViabLab dépend que vous avez peut-être dû installer (MySys2, gcc, cmake, make, boost, dlfcn, spdlog pour Windows ; gcc, g++, cmake, boost-devel/libboost-all-dev, spdlog-devel/libspdlog-dev, libcurl-devel/libcurl4 pour Linux ; gcc, g++, cmake, boost, spdlog, libomp pour MacOs) il faut vous reporter à leur propre guide de désintallation.

[Texte] Installation de ViabLab (version>= 4.0 ) à partir de GitHub

Niveau de difficulté
Thématique
Présentation formation

Comment installer et compiler ViabLab à partir de GitHub.

Contenu
MAC OS
Lire la suite 

Contenu à venir...


LINUX
Lire la suite 

FEDORA : 

Etape 1. Installation des dépendances

  • Mettre à jour le manager de paquets :

sudo dnf update
  • Installer les compilateurs C/C++:   

 Pour vérifier si gcc/g++ sont installés, dans un terminal : 

gcc --version
g++ --version

Si gcc/g++ ne sont pas installés sur votre système :        

sudo dnf install gcc
sudo dnf install g++
  • Installer Cmake (version >= 3.22.1) : 

Pour vérifier si cmake est installé et connaitre sa version, dans un terminal :

cmake --version

Si ce n'est pas la bonne version , supprimer les versions existantes de CMake, dans un terminal :

sudo dnf remove cmake

Puis

sudo dnf install cmake
  • Installer git (optionnel - si on souhaite cloner la dernière version de travail du code)

sudo dnf install git
  • Installer les librairies externes open source

sudo dnf install boost-devel
sudo dnf install spdlog-devel
sudo dnf install libcurl-devel

Etape 2. Copier VIABLAB à partir de GitHub 

Dans FileExplorer, créer un répertoire viablab qui contiendra le programme et les résultats

Pour copier ViabLab, trois possibilités :

      Dézipper VIABLAB-main.zip dans le répertoire viablab. 

  • Ouvrir un terminal dans le répertoire viablab et cloner le dépôt : 

git clone https://github.com/lastre-viab/VIABLAB.git

Etape 3. Compiler VIABLAB 

Vous êtes maintenant prêts à compiler le code de ViabLab. 

D'abord, aller dans le répertoire build (le créer s'il n'existe pas) de VIABLAB-main dans un terminal (le chemin dépend de votre installation). Par exemple : 

cd viablab/VIABLAB-main/build/

Ensuite, exécuter la commande cmake : 

cmake ../source

En cas d'erreur pendant le cmake, aller dans le répertoire build et effacer complètement son contenu avant de relancer la commande cmake.

Exécuter ensuite la commande make ci-dessous pour compiler le code : 

make

Lorsque la compilation est terminée, l'exécutable viabLab.exe est généré dans le répertoire build. 

 

UBUNTU :

Etape 1. Installation des dépendances

  • Mettre à jour le manager de paquets apt :

sudo apt update
  • Installer les compilateurs C/C++:   

 Pour vérifier si gcc/g++ sont installés, dans un terminal : 

gcc --version
g++ --version

Si gcc/g++ ne sont pas installés sur votre système :        

sudo apt install gcc
sudo apt install g++
  • Installer Cmake (version >= 3.22.1) : 

Pour vérifier si cmake est installé et connaitre sa version, dans un terminal :

cmake --version

Si ce n'est pas la bonne version , supprimer les versions existantes de CMake, dans un terminal :

sudo apt remove --purge cmake

Puis

sudo apt install cmake
  • Installer git (optionnel - si on souhaite cloner la dernière version de travail du code)

sudo apt install git
  • Installer les librairies externes open source

sudo apt install libboost-all-dev
sudo apt install libspdlog-dev
sudo apt install libcurl4

Etape 2. Copier VIABLAB à partir de GitHub 

Dans FileExplorer, créer un répertoire viablab qui contiendra le programme et les résultats

Pour copier ViabLab, trois possibilités :

      Dézipper VIABLAB-main.zip dans le répertoire viablab. 

  • Ouvrir un terminal dans le répertoire viablab et cloner le dépôt : 

git clone https://github.com/lastre-viab/VIABLAB.git

Etape 3. Compiler VIABLAB 

Vous êtes maintenant prêts à compiler le code de ViabLab. 

D'abord, aller dans le répertoire build (le créer s'il n'existe pas) de VIABLAB-main dans un terminal (le chemin dépend de votre installation). Par exemple : 

cd viablab/VIABLAB-main/build/

Ensuite, exécuter la commande cmake : 

cmake ../source

En cas d'erreur pendant le cmake, aller dans le répertoire build et effacer complètement son contenu avant de relancer la commande cmake.

Exécuter la commande make ci-dessous pour compiler le code : 

make

Lorsque la compilation est terminée, l'exécutable viabLab.exe est généré dans le répertoire build. 

 


WINDOWS 
Lire la suite 

 

Etape 1. Installer MSYS2 

Suivre les instructions https://www.msys2.org/

Télécharger et lancer l'installateur :

Welcome to the MSYS2 Setup 

Choisir le répertoire d'installation :

Installation folder

 

Suivre les étapes d'installation : 

Installation steps

Patienter jusqu'à la fin du processus d'installation : 

Wait...

 

Cliquer sur Finish : 

Finish

Une fois installé, le script bash MinGW64 peut être lancé depuis le menu Windows :

Windows menu

MinGW64

 

Etape 2. Installer les outils de compilation et les dépendances

Msys fournit un gestionnaire de paquets, appelé pacman, qui peut être utilisé pour installer tous les outils de compilation et les dépendances nécessaires. La documentation est ici : https://www.msys2.org/docs/package-management/

Installer les paquets suivants (utiliser les commandes ci-dessous ou chercher dans https://packages.msys2.org/queue en choisissant Mingw64 binaries) : 

  • GCC: 

    pacman -S mingw-w64-x86_64-gcc
  • CMake: 

    pacman -S mingw-w64-x86_64-ccmake
  • Make: 

    pacman -S mingw-w64-x86_64-make
  • Boost: 

    pacman -S mingw-w64-x86_64-boost
  • Dlfcn: 

    pacman -S mingw-w64-x86_64-dlfcn
  • Spdlog: 

    pacman -S mingw-w64-x86_64-spdlog

Pour finir l'installation, ajouter à la variable System Path le chemin d'accès aux binaires Mingw64

C:\msys64\mingw64\bin :

Add path variable

Cette opération peut nécessiter le redémarrage de votre ordinateur pour s'assurer que les modifications de la variable System Path ont bien été enregistrées.


Etape 3. Copier VIABLAB dans le répertoire de MSyS 

A l'adresse https://github.com/lastre-viab/VIABLAB, cliquer sur le bouton Code et télécharger le fichier .zip VIABLAB-main.zip. 

Par défaut, l'interpréteur de commandes MSyS est ouvert dans le dossier /home/nom_utilisateur. Vous pouvez le voir dans l'explorateur de fichiers. 



 

Ouvrir ce dossier dans FileExplorer, créer le dossier dev-cpp qui contiendra le program et les fichiers de sorties et y dézipper VIABLAB-main.zip. Example : 


Etape 5. Compiler VIABLAB dans le dossier MSyS 

Retourner dans l'interface MSyS MINGW64 (le script bash MinGW64 peut être lancé depuis le menu Windows). Vous êtes prêt pour compiler le code de ViabLab. 

First, go to the build folder (create it if it doesn't exist) of VIABLAB in bash (depending on your personal installation). With the example folder shown above : 

cd dev-cpp/VIABLAB-main/build/

Then cmake command : 

  • cmake -G"MinGW Makefiles" -D BUILD_LIB=OFF ../source

  • If you use Eclipse C++ IDE, you can use the cmake command below to generate Eclipse project settings and enable debugging in Eclipse :

    cmake -G"Eclipse CDT4 - MinGW Makefiles" -D CMAKE_BUILD_TYPE=Debug -D BUILD_LIB=OFF ../source

    After running CMake, the project is ready to be imported into Eclipse: the build directory (initially empty) contains the data generated by CMake.

    In Eclipse, go to the File menu => Import and select the Existing Projects into Workspace option.

    Click Next.

    Then, in the following window, select the build directory.

    Click Finish.

    After the import, you will see the project tree in the left panel.

Note that cmake command must be executed only once, on first installation; further, only the make command below will be sufficient to build the code : 

mingw32-make

Once the compilation process finished, the executable viabLab.exe is created in build folder.