Replace \R by \mathbb{R}

Author: xadupre

_doc/c_algo/edit_distance.rst

@@ -117,7 +117,7 @@ On peut définir la distance d'édition :
     .. math::
 
         \begin{array}{crcl}
-        d : & \mathcal{S}_\mathcal{C} \times \mathcal{S}_\mathcal{C} & \longrightarrow & \R^+\\
+        d : & \mathcal{S}_\mathcal{C} \times \mathcal{S}_\mathcal{C} & \longrightarrow & \mathbb{R}^+\\
         & \pa{m_1,m_2} & \longrightarrow & \underset{ \begin{subarray} OO \text{ séquence} \\ \text{d'opérations} \end{subarray}}{ \min} \, d\pa{m_1,m_2,O}
         \end{array}
 
@@ -140,7 +140,7 @@ Ce paragraphe a pour objectif de démontrer que la
 
     Soit :math:`\mathcal{C}' = \mathcal{C} \bigcup \acc{.}`
     l'ensemble des caractères ajouté au caractère vide ``.``.
-    On note :math:`c : \pa{\mathcal{C}'}^2 \longrightarrow \R^+`
+    On note :math:`c : \pa{\mathcal{C}'}^2 \longrightarrow \mathbb{R}^+`
     la fonction coût définie comme suit :
 
     .. math::
@@ -197,7 +197,7 @@ en utilisant les mots acceptables :
 
         \begin{eqnarray}
         \begin{array}{crcl}
-        d : & \mathcal{S}_\mathcal{C} \times \mathcal{S}_\mathcal{C} & \longrightarrow & \R^+\\
+        d : & \mathcal{S}_\mathcal{C} \times \mathcal{S}_\mathcal{C} & \longrightarrow & \mathbb{R}^+\\
             & \pa{m_1,m_2} & \longrightarrow &
                             \min \acc{  \sum_{i=1}^{+\infty} c\pa{M_1^i, M_2^i} |
                                         \pa{M_1,M_2} \in acc\pa{m_1} \times acc\pa{m_2}}
@@ -334,7 +334,7 @@ serait tenté de définir une nouvelle distance d'édition inspirée de la préc
 
         \begin{eqnarray*}
         \begin{array}{crcl}
-        d' : & \mathcal{S}_\mathcal{C} \times \mathcal{S}_\mathcal{C} & \longrightarrow & \R^+\\
+        d' : & \mathcal{S}_\mathcal{C} \times \mathcal{S}_\mathcal{C} & \longrightarrow & \mathbb{R}^+\\
         & \pa{m_1,m_2} & \longrightarrow & d'\pa{m_1,m_2} = \dfrac{d^*\pa{m_1,m_2}}{ \max \acc {l\pa{m_1}, l\pa{m_2}}} \\ \\
         & & & \text{où } l\pa{m} \text{ est la longueur du mot } m
         \end{array}
@@ -604,7 +604,7 @@ par descente de gradient. Les coûts sont donc appris en deux étapes :
 
     Dans cette étape, les coefficients :math:`\alpha_{ik}\pa{\Omega}`
     restent constants. Il suffit alors de minimiser la fonction
-    dérivable :math:`E\pa{\Omega}` sur :math:`\R^n`, ceci peut être
+    dérivable :math:`E\pa{\Omega}` sur :math:`\mathbb{R}^n`, ceci peut être
     effectué au moyen d'un algorithme de descente de gradient
     similaire à ceux utilisés pour les réseaux de neurones.
 

_doc/c_clus/kmeans.rst

@@ -29,12 +29,12 @@ critère appelé *inertie* ou variance *intra-classe*.
 
     .. math::
 
-        \left(X_i\right)_{1\leqslant i\leqslant P}\in\left(\R^N\right)^P
+        \left(X_i\right)_{1\leqslant i\leqslant P}\in\left(\mathbb{R}^N\right)^P
 
     A chaque point est associée une classe :
     :math:`\left(c_i\right)_{1\leqslant i\leqslant P}\in\left\{1,...,C\right\}^P`.
     On définit les barycentres des classes :
-    :math:`\left( G_i\right)_{1\leqslant i\leqslant C}\in\left(\R^N\right)^C`.
+    :math:`\left( G_i\right)_{1\leqslant i\leqslant C}\in\left(\mathbb{R}^N\right)^C`.
 
     *Initialisation*
 
@@ -86,9 +86,9 @@ La démonstration du théorème nécessite le lemme suivant.
     :tag: Lemme
     :lid: lemme_inertie_minimum
 
-    Soit :math:`\vecteur{X_1}{X_P} \in \pa{\R^N}^P`,
-    :math:`P` points de :math:`\R^N`, le minimum de la quantité
-    :math:`Q\pa{Y \in \R^N}` :
+    Soit :math:`\vecteur{X_1}{X_P} \in \pa{\mathbb{R}^N}^P`,
+    :math:`P` points de :math:`\mathbb{R}^N`, le minimum de la quantité
+    :math:`Q\pa{Y \in \mathbb{R}^N}` :
 
     .. math::
         :nowrap:
@@ -100,16 +100,16 @@ La démonstration du théorème nécessite le lemme suivant.
     est atteint pour :math:`Y=G=\dfrac{1}{P} \sum_{i=1}^{P} X_i`
     le barycentre des points :math:`\vecteur{X_1}{X_P}`.
 
-Soit :math:`\vecteur{X_1}{X_P} \in \pa{\R^N}^P`,
-:math:`P` points de :math:`\R^N`.
+Soit :math:`\vecteur{X_1}{X_P} \in \pa{\mathbb{R}^N}^P`,
+:math:`P` points de :math:`\mathbb{R}^N`.
 
 .. math::
     :nowrap:
 
     \begin{eqnarray*}
                         \sum_{i=1}^{P} \overrightarrow{GX_{i}} = \overrightarrow{0}
     &\Longrightarrow&      \sum_{i=1}^{P} d^2\pa{X_i,Y} = \sum_{i=1}^{P} d^2\pa{X_i,G}+ P \, d^2\pa{G,Y} \\
-    &\Longrightarrow&     \underset{Y\in\R^N}{\arg\min} \; \sum_{i=1}^{P} d^2\pa{X_i,Y} = \acc{G}
+    &\Longrightarrow&     \underset{Y\in\mathbb{R}^N}{\arg\min} \; \sum_{i=1}^{P} d^2\pa{X_i,Y} = \acc{G}
     \end{eqnarray*}
 
 On peut maintenant démontrer le théorème.
@@ -166,7 +166,7 @@ Homogénéité des dimensions
 ++++++++++++++++++++++++++
 
 Les coordonnées des points
-:math:`\left(X_i\right) \in \R^N` sont généralement non homogènes :
+:math:`\left(X_i\right) \in \mathbb{R}^N` sont généralement non homogènes :
 les ordres de grandeurs de chaque dimension sont différents.
 C'est pourquoi il est conseillé de centrer et normaliser chaque dimension.
 On note : :math:`\forall i \in \intervalle{1}{P}, \; X_i = \vecteur{X_{i,1}}{X_{i,N}}` :
@@ -225,7 +225,7 @@ par la suivante :
 
     .. math::
 
-        X=\left(X_i\right)_{1\leqslant i\leqslant P}\in\left(\R^N\right)^P
+        X=\left(X_i\right)_{1\leqslant i\leqslant P}\in\left(\mathbb{R}^N\right)^P
 
     A chaque point est associée une classe :
     :math:`\left(c_i\right)_{1\leqslant i\leqslant P}\in\left\{1,...,C\right\}^P`.
@@ -279,7 +279,7 @@ que :ref:`l-kmeanspp` mais plus rapide et parallélisable.
 
     .. math::
 
-        X=\left(X_i\right)_{1\leqslant i\leqslant P}\in\left(\R^N\right)^P
+        X=\left(X_i\right)_{1\leqslant i\leqslant P}\in\left(\mathbb{R}^N\right)^P
 
     A chaque point est associée une classe :
     :math:`\left(c_i\right)_{1\leqslant i\leqslant P}\in\left\{1,...,C\right\}^P`.
@@ -429,7 +429,7 @@ Maxima de la fonction densité
 L'article [Herbin2001]_ propose une méthode différente pour estimer
 le nombre de classes, il s'agit tout d'abord d'estimer la fonction
 densité du nuage de points qui est une fonction de
-:math:`\R^n \longrightarrow \R`. Cette estimation est effectuée au moyen
+:math:`\mathbb{R}^n \longrightarrow \mathbb{R}`. Cette estimation est effectuée au moyen
 d'une méthode non paramètrique telle que les estimateurs à noyau
 (voir [Silverman1986]_)
 Soit :math:`\vecteur{X_1}{X_N}` un nuage de points inclus dans une image,
@@ -451,15 +451,15 @@ d'image qui ne peut pas être résolu par la méthode des nuées
 dynamiques puisque la forme des classes n'est pas convexe,
 ainsi que le montre la figure suivante. La fonction de densité
 :math:`f` est seuillée de manière à obtenir une fonction
-:math:`g : \R^n \longrightarrow \acc{0,1}` définie par :
+:math:`g : \mathbb{R}^n \longrightarrow \acc{0,1}` définie par :
 
 .. math::
 
     g \pa{x} = \indicatrice{f\pa{x} \supegal s}
 
 .. index:: composante connexe
 
-L'ensemble :math:`g^{-1}\pa{\acc{1}} \subset \R^n`
+L'ensemble :math:`g^{-1}\pa{\acc{1}} \subset \mathbb{R}^n`
 est composée de :math:`N` composantes connexes notées
 :math:`\vecteur{C_1}{C_N}`, la classe d'un point :math:`x`
 est alors l'indice de la composante connexe à la
@@ -499,7 +499,7 @@ L'inertie de ce nuage de points est définie par :
     I  =  \sum_{x \in X} \; \norme{ x - y_{C\pa{x} }}^2
 
 On définit tout d'abord une distance
-:math:`\alpha \in \R^+`, puis l'ensemble
+:math:`\alpha \in \mathbb{R}^+`, puis l'ensemble
 :math:`V\pa{y,\alpha} = \acc{ z \in Y \sac d\pa{y,z} \infegal \alpha }`,
 :math:`V\pa{y,\alpha}` est donc l'ensemble des voisins des
 centres dont la distance avec :math:`y` est inférieur à :math:`\alpha`.
@@ -877,7 +877,7 @@ lors de l'estimation des centres des classes, l'algorithme évite la formation d
     Soit un nuage de points :math:`\vecteur{X_1}{X_N}`,
     soit :math:`C` vecteurs :math:`\vecteur{\omega_1}{\omega_C}`
     initialisés de manière aléatoires.
-    Soit :math:`F : \pa{u,t} \in \R^2 \longrightarrow \R^+`
+    Soit :math:`F : \pa{u,t} \in \mathbb{R}^2 \longrightarrow \mathbb{R}^+`
     croissante par rapport à :math:`u`.
     Soit une suite de réels :math:`\vecteur{u_1}{u_C}`,
     soit une suite :math:`\epsilon\pa{t} \in \cro{0,1}` décroissante où :math:`t`

_doc/c_clus/kohonen.rst

@@ -35,12 +35,12 @@ linéaire, rectangulaire, triangulaire.
     :tag: Algorithme
     :lid: classification_som_algo
 
-    Soient :math:`\vecteur{\mu_1^t}{\mu_N^t} \in \pa{\R^n}^N`
-    des neurones de l'espace vectoriel :math:`\R^n`. On
+    Soient :math:`\vecteur{\mu_1^t}{\mu_N^t} \in \pa{\mathbb{R}^n}^N`
+    des neurones de l'espace vectoriel :math:`\mathbb{R}^n`. On
     désigne par :math:`V\pa{\mu_j}` l'ensemble des neurones
     voisins de :math:`\mu_j` pour cette carte de Kohonen.
     Par définition, on a :math:`\mu_j \in V\pa{\mu_j}`.
-    Soit :math:`\vecteur{X_1}{X_K} \in \pa{\R^n}^K` un nuage de points.
+    Soit :math:`\vecteur{X_1}{X_K} \in \pa{\mathbb{R}^n}^K` un nuage de points.
     On utilise une suite de réels positifs
     :math:`\pa{\alpha_t}` vérifiant
     :math:`\sum_{t \supegal 0} \alpha_t^2 < \infty` et
@@ -49,7 +49,7 @@ linéaire, rectangulaire, triangulaire.
     *initialisation*
 
     Les neurones :math:`\vecteur{\mu_1^0}{\mu_N^0}`
-    sont répartis dans l'espace :math:`\R^n`
+    sont répartis dans l'espace :math:`\mathbb{R}^n`
     de manière régulière selon la forme de leur voisinage.
     :math:`t \longleftarrow 0`.
 

_doc/c_metric/roc.rst

@@ -90,12 +90,12 @@ La courbe ROC s'obtient en faisant varier :math:`s`.
     On suppose également que tous les scores sont indépendants.
     On note :math:`F_Y` et :math:`F_X` les fonctions de répartition de ces variables.
     :math:`F_Y(s)=\pr{Y \infegal s}` et :math:`F_X(s)=\pr{X \infegal s}`.
-    On définit en fonction d'un seuil :math:`s \in \R` :
+    On définit en fonction d'un seuil :math:`s \in \mathbb{R}` :
 
     * :math:`R(s) = 1 - F_Y(s) = \pr{Y > s}`
     * :math:`E(s) = 1 - F_X(s) = \pr{X > s}`
 
-    La courbe ROC est le graphe :math:`\pa{E(s),R(s)}` lorsque :math:`s` varie dans :math:`\R`.
+    La courbe ROC est le graphe :math:`\pa{E(s),R(s)}` lorsque :math:`s` varie dans :math:`\mathbb{R}`.
 
 :math:`TP(s)` désigne les true positifs au-dessus du seuil :math:`s`,
 avec les notations *TP*, *FP*, *FN*, *TN*, cela revient à :
@@ -181,7 +181,7 @@ De plus, soit :math:`g` une fonction intégrable quelconque, on pose :math:`u =
 
 .. math::
 
-    \int_{\R} g(x) \, f(x) \,dx = \int_{\cro{0,1}} g(F^{-1}(u)) \, du
+    \int_{\mathbb{R}} g(x) \, f(x) \,dx = \int_{\cro{0,1}} g(F^{-1}(u)) \, du
 
 **Démonstration**
 
@@ -337,7 +337,7 @@ est construite une courbe ROC (voir :ref:`Courbe ROC <def_roc_2>`).
     :lid: algo_courb_ROC
 
     On suppose qu'on dispose d'un ensemble de points :math:`\pa{X_i,\theta_i}
-    \in \R \times \acc{0,1}` pour :math:`i \in \ensemble{1}{n}`.
+    \in \mathbb{R} \times \acc{0,1}` pour :math:`i \in \ensemble{1}{n}`.
     `X_i` est le score obtenu pour l'expérience :math:`i`,
     `\theta_i` vaut 1 si elle a réussi et 0 si elle a échoué.
     On suppose également que cette liste est triée par ordre croissant :
@@ -405,7 +405,7 @@ On s'inspire pour cela des méthodes de `bootstrap <https://fr.wikipedia.org/wik
     :lid: roc_boostrap_algo
 
     On dispose toujours du nuage de points
-    :math:`E = \pa{X_i,\theta_i} \in \R \times \acc{0,1}` avec :math:`i \in \ensemble{1}{n}`.
+    :math:`E = \pa{X_i,\theta_i} \in \mathbb{R} \times \acc{0,1}` avec :math:`i \in \ensemble{1}{n}`.
     On choisit :math:`C \in \N` le nombre de courbes ROC qu'on désire tracer.
     Pour chaque courbe :math:`c \in \ensemble{1}{C}` :
 

_doc/c_ml/index_reg_lin.rst

@@ -10,8 +10,8 @@ est le modèle prédictif le plus simple et celui qu'on préfère
 quand il marche car il est facilement interprétable à l'inverse
 des modèles non linéaires qui gardent leurs secrets si on s'en tient
 seulement à leurs coefficients. Concrètement, on dispose d'un nuage
-de point :math:`(X_i, y_i)` où :math:`X_i \in \R^d` est un vecteur
-de dimension *d* et :math:`y_i \in \R` un réel. La régression
+de point :math:`(X_i, y_i)` où :math:`X_i \in \mathbb{R}^d` est un vecteur
+de dimension *d* et :math:`y_i \in \mathbb{R}` un réel. La régression
 linéaire consiste à construire une fonction prédictive
 :math:`\hat{y_i} = f(X_i) = <X_i, \beta> = X_i \beta` où
 :math:`\beta` est un vecteur de dimension *d*. Dans le cas le plus

_doc/c_ml/index_reg_log.rst

@@ -10,7 +10,7 @@ est le modèle prédictif le plus simple et celui qu'on préfère
 quand il marche car il est facilement interprétable à l'inverse
 des modèles non linéaires qui gardent leurs secrets si on s'en tient
 seulement à leurs coefficients. Concrètement, on dispose d'un nuage
-de point :math:`(X_i, y_i)` où :math:`X_i \in \R^d` est un vecteur
+de point :math:`(X_i, y_i)` où :math:`X_i \in \mathbb{R}^d` est un vecteur
 de dimension *d* et :math:`y_i \in \acc{0, 1}` un entier binaire.
 Le problème de la régression linéaire consiste à
 construire une fonction prédictive

_doc/c_ml/kppv.rst

@@ -426,7 +426,7 @@ et l'élément :math:`x` soit connue et que l'ensemble
     :nowrap:
 
     \begin{eqnarray*}
-    \exists \pa{\alpha,\beta} \in \R^+_* \text{ tels que } && \nonumber\\
+    \exists \pa{\alpha,\beta} \in \mathbb{R}^+_* \text{ tels que } && \nonumber\\
     \forall \pa{x,y} \in E^2, \; \forall i\, && \alpha \, d\pa{x,y} \supegal
                     \abs{d\pa{x,p_i} - d\pa{p_i,y}} \label{space_metric_cond_1} \\
     \forall \pa{x,y} \in E^2, && \underset{i}{\max} \; \abs{d\pa{x,p_i} - d\pa{p_i,y}} \supegal
@@ -496,7 +496,7 @@ Et un petit théorème.
 
         p\pa{x,r} = P_X \pa{B\pa{x,r}} = \pr{  Z \in B\pa{x,r}}
 
-    On suppose qu'il existe :math:`d > 0` et une fonction :math:`f : X \longrightarrow \R`
+    On suppose qu'il existe :math:`d > 0` et une fonction :math:`f : X \longrightarrow \mathbb{R}`
     tels que :
 
     .. math::

_doc/c_ml/lr_trees.rst

@@ -21,7 +21,7 @@ Parallèle entre un neurone et une régression logistique
 Les paragraphes :ref:`rn-classification` et
 :ref:`nn-classification` présente le problème de la classification
 qui consiste à trouver une fonction *f* qui maximise la vraisemblance
-du nuage de points :math:`(X_i, y_i)_i` où :math:`X_i \in \R^d`
+du nuage de points :math:`(X_i, y_i)_i` où :math:`X_i \in \mathbb{R}^d`
 et :math:`y_i \in \acc{0, 1}`.
 
 .. math::
@@ -241,8 +241,8 @@ On remarque que :
 
     \begin{array}{rcl}
     f(x) &=& \frac{1}{1 + e^{-x}} \\
-    \Rightarrow f(-x) &=& \frac{1}{1 + e^{x}} = \frac{e^{-x}}{1 + e^{-x}} \\
-    \Rightarrow f(x) + f(-x) &=& \frac{1}{1 + e^{-x}} + \frac{e^{-x}}{1 + e^{-x}} = 1
+    \mathbb{R}ightarrow f(-x) &=& \frac{1}{1 + e^{x}} = \frac{e^{-x}}{1 + e^{-x}} \\
+    \mathbb{R}ightarrow f(x) + f(-x) &=& \frac{1}{1 + e^{-x}} + \frac{e^{-x}}{1 + e^{-x}} = 1
     \end{array}
 
 Cela explique pour on utilise souvent cette fonction pour transformer

_doc/c_ml/missing_values_mf.rst

@@ -206,9 +206,9 @@ a montré que :
 
     \begin{eqnarray*}
     S =
-    \underset{ \begin{subarray}{c} W \in M_{p,d}\pa{\R} \\ W'W = I_d \end{subarray} } { \arg \max } \;
+    \underset{ \begin{subarray}{c} W \in M_{p,d}\pa{\mathbb{R}} \\ W'W = I_d \end{subarray} } { \arg \max } \;
                         \cro { \sum_{i=1}^{N} \norm{W'X_i}^2 } &=&
-    \underset{ W \in M_{p,d}\pa{\R} } { \arg \min } \;  \cro { \sum_{i=1}^{N} \norm{WW'X_i - X_i}^2 }
+    \underset{ W \in M_{p,d}\pa{\mathbb{R}} } { \arg \min } \;  \cro { \sum_{i=1}^{N} \norm{WW'X_i - X_i}^2 }
     \end{eqnarray*}
 
 Dans notre cas, chaque ligne de la matrice :math:`M` est un vecteur :math:`X_i`.

_doc/c_ml/piecewise.rst

@@ -31,7 +31,7 @@ dans la pull request `Model trees (M5P and co)
 qui répond à au problème posée dans
 `Model trees (M5P) <https://github.com/scikit-learn/scikit-learn/pull/13732>`_
 et originellement implémentée dans
-`Building Model Trees <https://github.com/ankonzoid/LearningX/tree/master/advanced_ML/model_tree>`_.
+`Building Model Trees <https://github.com/ankonzoid/LearningX/tree/main/advanced_ML/model_tree>`_.
 Cette dernière implémentation réestime les modèles comme l'implémentation
 décrite au paragraphe :ref:`l-decisiontree-reglin-piecewise-naive`
 mais étendue à tout type de modèle.
@@ -232,7 +232,7 @@ on peut utiliser la librairie :epkg:`LAPACK`. Je ne vais pas plus loin
 ici car cela serait un peu hors sujet mais ce n'était pas une partie
 de plaisir. Cela donne :
 `piecewise_tree_regression_criterion_linear.pyx
-<https://github.com/sdpython/mlinsights/blob/master/mlinsights/mlmodel/piecewise_tree_regression_criterion_linear.pyx>`_
+<https://github.com/sdpython/mlinsights/blob/main/mlinsights/mlmodel/piecewise_tree_regression_criterion_linear.pyx>`_
 C'est illustré toujours par le notebook
 :epkg:`DecisionTreeRegressor optimized for Linear Regression`.
 
@@ -375,7 +375,7 @@ On en déduit que :
     :lid: algo_decision_tree_mselin
 
     On dipose qu'un nuage de points :math:`(X_i, y_i)` avec
-    :math:`X_i \in \R^d` et :math:`y_i \in \R`. Les points sont
+    :math:`X_i \in \mathbb{R}^d` et :math:`y_i \in \mathbb{R}`. Les points sont
     triés selon une dimension. On note *X* la matrice composée
     des lignes :math:`X_1, ..., X_n` et le vecteur colonne
     :math:`y=(y_1, ..., y_n)`.
@@ -520,7 +520,7 @@ Synthèse mathématique
     :lid: algo_gram_schmidt_reglin
 
     Soit une matrice :math:`X \in \mathcal{M}_{nd}` avec
-    :math:`n \supegal d`. Et un vecteur :math:`y \in \R^n`.
+    :math:`n \supegal d`. Et un vecteur :math:`y \in \mathbb{R}^n`.
     D'après l':ref:`algorithme de Gram-Schmidt <algo_gram_schmidt>`,
     il existe deux matrices telles que
     :math:`X P = T` ou :math:`P' X' = T'`.

_doc/c_ml/regression_quantile.rst

@@ -78,8 +78,8 @@ problème de régression.
     :tag: Définition
 
     On dispose d'un ensemble de *n* couples
-    :math:`(X_i, Y_i)` avec :math:`X_i \in \R^d`
-    et :math:`Y_i \in \R`. La régression quantile
+    :math:`(X_i, Y_i)` avec :math:`X_i \in \mathbb{R}^d`
+    et :math:`Y_i \in \mathbb{R}`. La régression quantile
     consiste à trouver :math:`\alpha, \beta` tels que la
     somme :math:`\sum_i \abs{\alpha + \beta X_i - Y_i}`
     est minimale.
@@ -230,8 +230,8 @@ pour un quantile autre que la médiane.
     :tag: Définition
 
     On dispose d'un ensemble de *n* couples
-    :math:`(X_i, Y_i)` avec :math:`X_i \in \R^d`
-    et :math:`Y_i \in \R`. La régression quantile
+    :math:`(X_i, Y_i)` avec :math:`X_i \in \mathbb{R}^d`
+    et :math:`Y_i \in \mathbb{R}`. La régression quantile
     consiste à trouver :math:`\alpha, \beta` tels que la
     somme :math:`\sum_i p \abs{\alpha + \beta X_i - Y_i}^+ + (1-p) \abs{\alpha + \beta X_i - Y_i}^-`
     est minimale.