On s'intéresse aux réseaux de neurones, mais nous n'allons pas rentrer dans le vif du sujet tout-de-suite. On commence par décrire l'objet le plus général en la matière qu'est un programme, écrit dans un langage rudimentaire, calculant une fonction dans une structure mathématique.
On commence par décrire les structures de type fini, c'est à dire engendrées par un nombre fini d'opérateurs générateurs d'arité fixe. Puis on définit plusieurs niveaux de langage de programmation rudimentaire sur ces structures.
Nous construirons par étape une axiomatique, en ajoutant un à un des axiomes, définissant à chaque fois des objets plus précis. Et des alternatives se présenterons, plusieurs voies seront à explorer, développant une arborescence, constituant une classification d'objets, jusqu'à aboutire à celui appelé réseaux de neurones.
Les mathématiques étant ingrates contrairement à l'informatique, on programmera en Go ces différents objets et réseaux de neurones, que nos lecteurs pourront tester et utiliser. Le développement informatique libre constitue un nouveau vecteur de propagande au sens positif du terme, et doit prendre sa place pleinement dans notre communication.
"L'objet le plus général en la matière est un programme écrit dans un langage rudimentaire calculant une fonction dans une structure mathématique" disais-je, c'est-à-dire un procédé de calcul sur une structure `K` ayant `n` entrées et `m` sorties. Un tel programme définit une fonction de `K^n"→" K^m`, et plus que cela, puisqu'il donne un moyen rudimentaire et exacte de la calculer.
Supposons par exemple que la structure `K` possède comme générateurs `{a,f"(.)",g"(.,.)"}`. Les éléments de `K` sont engendrés par ces trois opérateurs c'est-à-dire sont calculables par une composition finie de ces trois opérateurs.
Dans une structure de type fini, la notion d'élément engendré généralise la notion d'élément rationnel.
Une structure `K` se définit constructivement à l'aide d'une présentation `P` et d'une théorie `T` de langage `P` devant trancher l'égalité entre élément c'est-à-dire satisfaisant :
`AA(x,y)"∈<"P">"^2, (T|-- x"="y) "ou" (T|-- x"≠"y)`
La présentation regroupe les opérateurs générateurs et engendre une structure libre `"<"P">"`, tandis que la théorie définie dans cette structure libre une relation d'équivalence `"≃"` satisfaisant :
`AA(x,y)"∈<"P">"^2, (x"≃"y) <=> (T|-- x"="y)`
La structure `K` est l'ensemble des classes d'équivalence et se note sous la forme d'un quotient, le quotient d'une structure par une théorie écrite dans le langage de la structure :
`K = ("<"P">")/T`
Prenons par exemple une structure `K` de présentation `P={a,f"(.)",g"(.,.)"}` et de théorie `T`. Les suffixes `(.)` et `(.,.)` sont là uniquement pour déclarer ou rappler l'arité de l'opérateur. Et ils ne sont pas nécessaire si on connais déjà l'arité. Ainsi, `a` est un élément de `K`, puis `f` est une fonction de `K"→"K` et `g` est une fonction de `K^2"→"K`.
La présentation `P={a,f,g}` peut être vu comme en ensemble de 3 opérateurs générateurs de `K`, ou bien comme un ensembles de 3 caractères. La structure `K` définit un langage où chaque mot de ce langage désigne un élément précis de `K`, un élément rationnel de `K` c'est à dire obtenu par une composition fini d'opérateurs générateurs.
Notez que dans certain cas, il est possible d'ajouter dans `K` d'autres éléments par extension élémentaire, qui ne sont pas le résultat d'une composition fini d'opérateurs générateurs, et qui étendent la structure tout en respectant sa théorie.
Il existe plusieurs niveaux de langage de programmation rudimentaire de calcul de fonction de `K^n"→"K^m`
Le niveau 1 correspond à la logique polonaise. Le langage utilisé `ccL_1` est l'ensemble des mots non-vides d'alphabet `P` qui se note sous forme d'une grammaire :
`ccL_1 = {S "/" S"→"{P, PS}, P"→"{a,f,g}}`
Chaque programme s'applique à la liste d'entrée `(x,y,z,...)` toujours la même, et que l'on note aussi `(x_1,x_2,x_3,...)`. Exemples :
`(x,y)"↦"(a,f(a),g(x,y))`
Le niveau 2 correspond à la logique polonaise avec point. Le langage utilisé est l'ensemble des mots non-vides d'alphabet `Puu{"."}` ne se terminant pas par un point, et qui se note :
`ccL_2 = {S "/" S"→"{P,PS,.S}, P"→"{a,f,g}}`
Chaque programme s'applique à la liste d'entrée `(x_1,x_2,x_3,...)` toujours la même. Exemples :
Le niveau 3 correspond à la composition générale des opérateurs générateurs. Elle utilise la logique polonaise en ajoutant les variables d'entrée `x,y,z,...` mais, on exige que chaque opérateur possède tous ses arguments présents. Ce langage se note sous forme de grammaire comme suit :
`ccL_3 = {S "/" S"→"{V,a,fS,gSS}, V"→"{x,y,z,...}}`
Chaque programme s'applique à la liste d'entrée `(x_1,x_2,x_3,...)` toujours la même, mais ici le programme peut choisir quel n° d'entrée il utilise. Exemples :
On comptabilise le nombre de programmes distincts pour chacun de ces langage et par strate `(n,m)` où les numéros de variables utilisées sont au plus égale à `n` et où l'arité de sortie est au plus égale à `m`. Les grammaires des langages permettent de programmer facilement des énumérateurs pour ces langages.
---- 7 mars 2022 ----
L'ensemble des fonctions calculables au sense stricte de `K^3"→"K` forme une structure mathématique identique à la structure étendue `K[x,y,z]`. Elle possède comme générateurs `{x,y,z}``uu``{,a,f"(.)",g"(.,.)"}`. Toutes les fonctions calculables de `K^3"→"K` sont engendrés par ces six opérateurs c'est-à-dire sont calculables par une composition finie de ces six opérateurs. Par exemple considérons la composition suivante :
`g(z,f(a)),g(a,f(x))`
Cette composition définie précisement un programme vectorielle de `K^3"→"K` si on choisie implicitement comme entrées `(x,y,z)`. Le programme se note comme suit :
`(x,y,z)"↦"g(z,f(a)),g(a,f(x))`
La fonction ne s'intéresse qu'au résultat tandis que le programme s'intéresse à comment est obtenu le résultat. Le programme correspond exactement à l'expression de la composition finie. Le langage de programmation est donc particulièrement simple.
Une fonction de `K^3"→" K^m` correspond à `m` fonctions de `K^3"→" K`. Puis, lorsque l'on s'intéresse aux détails des calculs, c'est à dire aux programmes, on s'aperçoit que ces `n` programmes peuvent posséder des calculs intermédiaires communs, et qu'il est inutile de les recalculer plusieur fois, et qu'il faut plutôt les partager. La mise en oeuvre du partage se visualise bien dans un graphe de flux.
Un programme de `K^3"→" K^m` est représentée par un multigraphe orienté sans circuit avec trois types de noeud :
Et où on choisit parmi tous les noeuds, les `m` noeuds qui serviront de noeud de sortie. Il n'y a pas de contrainte sur le nombre d'arcs partant d'un noeud, il peut être partagé autant de fois que l'on veut. Les arcs entrant dans un noeud sont dit numérotés car il y a un ordre de préséance, le premier arcs transporte le premier argument de la fonction, le deuxième arcs transporte le deuxième argument de la fonction, etc..
Par exemple, le programme `g(g(x,f(y)),g(a,g(f(y),x)))` où les noeuds `x, f(y)` sont partagés, se représente par le graphe suivant :
Les noeuds sont numérotés selon la première apparition dans la formule lue de gauche à droite. On perfectionne le langage des formules pour indiquer le partage de sous-terme, en introduisant les variable locales intermédiaires. Ainsi l'expression du graphe se transcrit par la formule suivante :
`L=f(y)`
`g(g(x,L),g(a,g(L,x)))`
Notez que le passages à la ligne ici, n'est qu'une autre représentation d'une énumération de deux termes séparé par une virgule, et que `L` est une variable locale utilisés pour exprimer un partage de donnée, et que le meta-opérateur égal `=` est ainsi ajouté au langage des formules pour pouvoir facilement exprimer les partages. On peut alors poser comme convention qu'aucun terme non-réduit à une constante, une variable d'entrée où une variable locale, n'est partagé.
Mais en procédant ainsi on crée une distinction arbitraire entre les noeuds de type 0 qui ne peuvent pas être calculés de façon redondante, et les noeuds des autres types qui peuvent être recalculés de façon redondante. Cela nous expose à un choix de faible importance sur le langage des formules. On peut alors poser comme autre convention qu'aucun terme non réduit à une variable locale, n'est partagé. La formule précédente se réécrit alors comme suit :
`L=f(y)`
`X=x`
`g(g(X,L),g(a,g(L,X)))`
Qu'est ce qu'une variable d'entré ? Cela est un calcul si elle est synthétisée, ou une prise de mesure qui s'apparente à un calcul, ou une copie mais alors le calcul s'est fait antérieurement. Le principe de la représentation est d'intégrer sous le concept de noeud l'ensemble des calculs permettant de calculer le résultat du noeud, et il y a deux sortes de calcul, le calcul directe du noeud commandé par son étiquette et le calcul de ses arguments. Qu'est ce qu'une constante génératrice ? cela est aussi un calcul. La constante est mémorisée. Sa mise en mémoire précédée de sa construction constitue un calcul. L'enjeux de cette reflexion est de pouvoir manipuler les programmes de manière générale, de pouvoir les composer de différentes façons sans introduire une plétore de règles spécifiques et arbitraires.
S'il existe un temps de calcul constant pour chaque opérateur générateur et chaque entrée, ainsi que pour le passage des données dans chaque arc, alors il est possible de calculer le temps de calcul d'un programme. Par exemple en posant le temps `tau` nécessaire pour le passage d'un arc, le temps `sfT(X)` nécessaire pour calculer le résultat du noeud `X`, le temps `sfT(g)` nécessaire pour effectuer le calcul directe du noeud étiqueté par `g` c'est à dire sans calculer ses argument, et en posant :
`tau=1`
`sfT(a)=2`
`sfT(f)=3`
`sfT(g)=4`
`sfT(x)=5`
`sfT(y)=6`
`sfT(z)=7`
Ainsi le programme du graphe `P = (L"="f(y),g(g(x,L),g(a,g(L,x))))` possède un temps de calcul égale à :
`sfT(L) = sfT(f)+tau+sfT(y)`
`sfT(L) = 3+1+6`
`sfT(L) = 10`
`sfT(P) = sfT(g)+tau+sfT(g)+tau+sfT(x)+tau+sfT(L)+tau+sfT(g)+tau+sfT(a)+tau+sfT(g)+tau+tau`
`sfT(P) = 4+1+4+1+6+1+10+1+4+1+2+1+4+1+1`
`sfT(P) = 42`
À chaque nouveau argument, on compte le temps de transport dans un arc, et le temps de calcul de l'argument, à chaque argument déjà calculé c'est-à-dire partagé, on compte seulement le temps de transport dans un arc, à chaque opérateur non-nullaire qui dans notre convention d'écriture ne partage pas son résultat, on compte seulement le temps de calcul de l'opérateur.
Dans une structure de type fini, la notion d'élément calculable au sens stricte généralise la notion d'élément rationnel.
La structure de corps des réels calculables au sens stricte est le corps des nombres rationnels `bbbQ`. Elle possède comme opérateurs générateurs `{1 ,"+(.,.)", "-(.)","∗(.,.)", "inv(.)"}` avec une petite difficulté du fait que la fonction inverse n'est pas défini en `0`. Cela signifie que tout réel calculable au sens stricte est calculable par une combinaison finie de ces 5 fonctions sous la contrainte de ne pas calculer au cours du calcul l'inverse de zéro.
La multipication pourra se noter par absence de symbole `x∗x"="xy` juste en juxtaposant les arguments du produit. L'inverse pourra se noter en prenant une puissance `"inv"(x)"="x^-1`. Pour parfaire la définition de la structure, il faut ajouter les `9` clauses suivant :
`AAxAAyAAz,`
On remarque que tous les opérateurs générateurs, s'ils sont d'arité supérieur à `1`, sont commutatifs. En effet `"+"` et `"∗"` sont commutatifs. De nombreuses structures courament utilisées ont cette propriété d'être engendrées par des opérateurs commutatifs. Un programme vectorielle sur ces structures commutatives sera représenté par un multigraphe orienté où les arcs entrant sur un sommet ne sont pas numérotés, puisque à cause de la commutativité l'ordre de préséance des arcs entrant n'a plus d'importance.
Un noeud possède des arcs entrant numérotés c'est-à-dire avec un ordre de préséance, tandis qu'un sommet possède des arcs entrant sans ordre de préséance.
Dans le corps des nombres rationnels `bbbQ`, tout calcul fini d'un élément se traduit en une composition fini d'opérateur parmi `{1 ,"+(.,.)", "-(.)","∗(.,.)", "inv(.)"}`
Parmi les structures de type fini c'est-à-dire engendrées par un nombre fini d'opérateurs, on peut donc définir deux catégories de structures :
On considère donc deux catégories de programmes vectorielle, ceux composés de calculs élémentaires correspondant à des opérateurs générateurs commutatif, et ceux composés de calculs élémentaires correspondant à des opérateurs générateurs dont au moins un n'est pas commutatif.
Nous allons utiliser au paragraphe suivant des variables vectorielles. Une variable vectorielle `vec x` désigne une séquence de composantes de taille fini non précisée pouvant même être de taille nulle, ce qui nous oblige pour une fonction multi-aire `varphi` à définir la valeur de `varphi` appliqué à une séquence vide d'argument noté `varphi()`.
Il convient de définir formellement cette notation et de l'introduire dans le langage logique sans laisser place à la moindre ambiguïté. Cela passe également par une grammaire un peu plus perfectionnée du langage, qui met en oeuve le typage par inférence, et que nous allons décrire. Voir préreflexion Langage de programmation idéal .
La séquence vide se note `"Seq"()`. Et une séquence de trois éléments `x,y,z` se note `"Seq"(x,y,z)`. Mais ces expressions sont peut utilisées. Car la séquence est utilisée pour désigner les arguments d'une fonction, et le symbole `"Seq"` est alors remplacé par le nom de la fonction. Etant donné une fonction ternaire `varphi`, son application sur la séquence d'arguments `x,y,z` se note `varphi(x,y,z)`.
La séquence d'un élément est toujours identifié à l'élément en question.
`"Seq"(x) =x`
Les séquences d'éléments constituent une autre catégorie d'élément, un autre type d'élément. Mais la séquence d'un élément est toujours identifié à l'élément en question. Autrement dit, ces deux catégories que sont les éléments et les séquences, possède une intersection commune qui est la sous-catégorie des séquences singletons.
La notation logique vectorielle permet d'introduire des séquences génériques de taille indéterminées (mais finie). La déclaration d'une nouvelle variable `vec x` désigne une telle séquence en nommant ses composantes par `x_1, x_2, x_3,...`
`vec x = "Seq"(x_1,x_2,x_3,... ,x_n)`
où `n` est un entier naturel indéterminé. Les séquences se distinguent des suites par le fait qu'elles ne s'emboitent pas mais s'insèrent ou se concatènent avec d'autres séquences.
Considérons une fonction `n`-aire `f` et l'appel `f(vecx)`. Si la taille de la séquence `vecx` est indéterminée, le typage par inférence fait que la séquence `vecx` est de taille `n`.
Une séquence de séquences d'éléments produit une séquence d'éléments :
`AAvecxAAvecy, "Sec"(vecx,vecy)="Seq"(x_1,x_2,...x_n, y_1,y_2,...,y_m),`
où `n` et `m` sont des entiers naturels indéterminés.
Si un opérateur binaire `varphi` est associatif c'est à dire si :
`AAxAAyAAz, varphi(x,varphi(y,z))= varphi(varphi(x,y),z)`
Alors il définit un opérateur multi-aire qui étend `varphi` et que l'on nomme pareillement `varphi`, et qui vérifie :
`AA vecx, varphi(vec x)= varphi(x_1,varphi(x_2,varphi(x_3,...)))`
Si un argument de `varphi` est lui même le résultat d'un opérateur `varphi`, ceux ci se regroupent en un opérateur `varphi` en insérant les arguments dans l'ordre.
`AA vecxAA vecyAAvecz, varphi(vecx,varphi(vecy) ,vecz)= varphi(vecx,vecy,vecz)`
L'autre propriété fondamentale de l'associativité est qu'elle définit un caractère fonctionnelle unaire pour les éléments arguments, les dotant ainsi d'un second rôle. Car tout semi-groupe est isormorphe à un ensemble d'applications unaires muni de la loi de composition.
Dans de nombreuse structure, tous les opérateurs générateurs, s'ils sont d'arité supérieur à `1`, sont associatifs. Par exemple `"+"` et `"∗"` dans `bbbQ` sont assocaitif. De nombreuses structures courament utilisées ont cette propriété d'être engendrées par des opérateurs associatifs.
Au lieu de n'utiliser que les opérateurs générateurs, on utilise leurs extensions multi-aire en les regroupants s'il ont même nature autant que possibles, faisant qu'un programme vectorielle sera représenté par un multigraphe orienté où chaque noeud d'arité supérieur à 1 ne peut aller que sur un noeud différent, car sinon on les fusionnes grâce à l'associativité.
On considère donc deux catégories de programmes vectorielle, ceux composés de calculs élémentaires correspondant à des opérateurs générateurs associatif, et ceux composés de calculs élémentaires correspondant à des opérateurs générateurs dont au moins un n'est pas associatif.
Dans la struture des rationnels, qui est celle des nombres réels calculables au sens strict. On choisie une présentation en énumérant un ensemble d'opérateurs générateurs que l'on met entre crochet `"<...>"` pour indiquer la clôture par composition fini. Et on choisie les opérateurs classiques, puis on quotiente par la théorie afin d'avoir une définition complète :
`bbbQ= (<1 ,"+(.,.)", "-(.)","∗(.,.)", "inv(.)">)/T`
Toute fonction vectorielle de `Q^2"→"Q` se calcule par une composition finie d'opérateurs parmi `{x,y}uu{1 ,"+(.,.)", "-(.)","∗(.,.)", "inv(.)"}`.
Et à bien y regarder, on voit que toute fonction vectorielle `f` de `Q^2"→"Q` se met sous la forme d'une série entières finie.
`f(x,y) = sum_(i,j) a_(i,j)x^iy^j`
où `a_(i,j)` sont des nombres rationnels.
---- 1 mai 2022 ----
Tout calcul paramétrique sur une structure mathématique s'apparente à un réseau de neurones, où les neurones sont tous particuliers et représentent pour chacun d'eux une étape du calcul muni de leur propres paramètres. Il faut donc que les paramètres soient localisés dans chaque neurone, et cela peut toujours se faire en les dédoublants autant que nécessaire.
On s'intéresse donc à un type de réseau de neurones plus général, où le neurone est une fonction n-aire quelconque, et où les paramètres font simplement partie des arguments de cette fonction. On s'intéresse aux neurones où la structure mathématique utilisée est le corps des réels, et où le mécanisme d'apprentissage qui va modifier les paramètres se fait par rétro-propagation du gradient. On commencera par un exemple simple pour décrire cette rétro-propagation. Et on décrira d'abord à la résolution approchée selon la méthode de Newton vectorielle.
Tout calcul paramétrique se traduit par un réseau de neurone. Prenons un exemple général de calcul avec comme données `x,y,z`, comme paramètres `a,b,c` et comme fonctions de calcul intermédiaire `f(".,.,.")`,`g(".,.")`,`h(".,.,.")`. On note `R,S` les résultats du réseau de neuronne appliqué aux données `x,y,z`, et aux paramètres `a,b,c` :
`R = h(a,f(b,x,y),f(h(a,x,z),c,g(x,f(b,x,y)))`
`S = f(f(b,x,y),g(f(h(a,x,z),c,g(x,f(b,x,y))),b)`
Chaque appel distinct de fontion correspond à un neurone. Les paramètres dans une formule générale ne sont pas forcement localisés dans chaque neurone. C'est pourquoi on les dédouble afin qu'ils soient localisés dans chaque neurone c'est-à-dire qu'ils ne puissent pas être argument directe de deux neurones distincts :
`R = h(a,f(b,x,y),f(h(p,x,z),c,g(x,f(b,x,y)))`
`S = f(f(b,x,y),g(f(h(p,x,z),c,g(x,f(b,x,y))),r)`
Les nouveaux paramètres sont : `{a,b,c,p"="a,q"="c,r"="b}`.
Remarquez que le paramètre `b` apparait dans quatre appels de fonction, parceque ce sont des appels de fonction de forme identique qui correspondent à un même neurone, un neurone qui partage son résultat. De même le paramètre `p` apparait dans deux appels de fonction de forme identique. De même le paramètre `c` apparait dans deux appels de fonction de forme identique.
Chaque appel de fonction de forme différente correspond à un neurone différent. Le réseau comprend `7` neurones, et forme un graphe comme suit :
L'appel `f(b,x,y)` correspond à un calcul intermédiaire et qui correspond au neurone n°2 noté `n_2`. Ce neurone calcule une donnée qui est partagée c'est à dire qui sert d'entrée directe à plusieurs autres neurones, les neurones n°1, n°6 et n°7. De même le neurone n°3 noté `n_3` correspond à l'appel `f(n_4,c,n_7)` et il est partagé puisqu'il alimente les neurones n°1 et n°5.
Le réseau de neurones ne possède pas de circuit fermé.
Le réseau de neurones possède une liste de neurones de sorties, dans l'exemple `(R,S)`.
Un paramètre s'apparente à une donnée d'entrée, mais comme il est localisé dans son neurone, c'est une donnée d'entrée non partagée qui n'est utilisée comme argument directe que par un seul neurone.
La formule servant de définition du réseau de neurone, induit un ordre des variables, un ordre des paramètres, un ordre des noeuds et un ordre des noeuds de sortie, ainsi que l'ordre de tous ces éléments en commun, définis toujours de la même façon selon la première apparition dans la formule lue de gauche à droite. Ainsi dans notre exemple, les variables sont dans l'ordre `x,y,z`, les paramètres sont dans l'ordre `a,b,p,c,q,r` et les noeuds sont dans l'ordre indiqué sur le graphique par leur numéro. Cela permet de définir une notation des éléments d'un réseau de neurones à `sfv` variables, `sfp` paramètres à `sfn` noeud dont `sfs` noeuds de sortie. Les variables peuvent être notées `(v_1,v_2,...,v_sfv) = vecv`. Les paramètres peuvent être notées `(p_1,p_2,...,p_sfp)=vecp`. Les noeuds peuvent être notées `(n_1,n_2,...,n_sfn)=vec n `. Et les noeuds de sortie peuvent être notées `(s_1,s_2,...,s_sfs)=vec s`. Avec cette notation nous avons les égalités suivantes :
`n_1 = f(a,n_2,n_3) = R`
`n_2 = f(b,x,y)`
`n_3 = f(n_4,c,n_7)`
`n_4 = h(c,x,z)`
`n_5 = g(n_3,r)`
`n_6 = (n_2,n_5,q)=S`
`n_7 = f(x,n_2)`
Les données de sortie du réseau se note explicitement par l'appel `(R,S)(x,y,z,a,b,q,c)` prenant en argument la liste des entrées dans l'ordre suivi de la liste des paramètres dans l'ordre, et qui se note de façon vectorielle par `vec s(vec v, vec p)`.
Puis on adopte la notation des physiciens définissant un système de coordonnée par défaut. Cela se fait par la déclaration du neurone mathématique `(R,S) ← (x,y,z,a,b,c,q)` ou `vec s←(vec v, vec p)`.
Délors `(R,S)` devient une fonction à `7` variables qui sont par défaut `(x,y,z,a,b,c,q)`. Ainsi `(R,S)``=``(R,S)(x,y,z,a,b,c,q)`. Et en notation vectorielle `vec s` devient une fonction vecrtorielle à `2` variables vectorielles qui sont par défaut `(vec v, vec p)`. Ainsi `vec s = vec s (vec v, vecp)`.
Puis on adopte la notation des physiciens pour les autres noeuds définissant un système de coordonnée par défaut pour chaque noeud. Cela se fait par la déclaration des neurones mathématiques suivants :
`n_1← (a,n_2,n_3) `
`n_2 ←(b,x,y)`
`n_3 ←(n_4,c,n_7)`
`n_4 ←(c,x,z)`
`n_5 ←(n_3,r)`
`n_6 ←(n_2,n_5,q)`
`n_7 ←(x,n_2)`
Tel qu'utilisé dans la méthode de Newton, le calcul des dérivées va constituer le principale moteur pour ajuster les paramètres d'un réseau de neurones, et mettre ainsi en oeuvre un mécanisme d'apprentissage. C'est pourquoi il convient de revoir les fondamentaux concernant la dérivée totale et les dérivées partielles, ainsi que les fonctions analytiques c'est à dire les fonctions développables en série entière.
---- 29 avril 2022 ----
On calcule la dérivée partielle de `R` selon chaque paramètre. Cela peut se faire soit théoriquement, ou soit empiriquement comme cela :
`delR"/"dela = (R(x,y,z,a"+"epsilon,b,c,q)-R)"/"epsilon`
`delR"/"delb = (R(x,y,z,a,b"+"epsilon,c,q)-R)"/"epsilon`
`delR"/"delc = (R(x,y,z,a,b,c"+"epsilon,q)-R)"/"epsilon`
`delR"/"delp = (R(x,y,z,a,b,c,q"+"epsilon)-R)"/"epsilon`
où `epsilon` est une grandeur négligeable devant les variations de chaque entrée ou paramètre.
---- 28 avril 2022 ----
