Le calcul différentiel utilise le concept d'élément différentiel, qui, au premier ordre, dévoile l'aspect linéaire local des fonctions dérivables. C'est pourquoi les opérateurs de dérivée partielle sont étudiés en même temps que les opérateurs linéaires que sont les matrices.
La formalisation du calcul différentiel comprend la formalisation d'un système de variables avec des coordonnées par défaut, la formalisation des fonctions analytiques, et la formalisation du corps des hyperréels `"*"RR`.
Qu'est ce qu'un système de variables avec des coordonnées par défaut ? Ce sont des variables évoluant dans un domaine de valeurs, et qui satisfont un certain nombre de dépendances de calcul inconnu ou connu, sous forme de fonction analytique et qui possèdent des arguments par défaut constituant des systèmes de coordonnées propres à chaque variable.
On adopte une notation inspirée des réseaux de neurones. Etant donnée trois variables `f,x,y` représentant des valeurs. On définit un lien de dépendance par la déclaration du neurone suivant :
`f"←"(x,y)`
Dès lors, la variable `f` devient une fonction analytique, pour l'instant inconnue, de `RR^2` vers `RR`, et on considère qu'elle s'applique par défaut sur `(x,y)`. Ainsi, l'expression `f` apparaissant dans une équation où l'on attend une valeur, représentera la valeur `f(x,y)`.
En résumé la variable `f` est une fonction à deux arguments, et d'autre part, ses arguments par défaut sont `(x,y)` qui constituent un système de coordonnées implicite pour la variable `f`, faisant que la valeur `f` est évaluée par défaut au point `(x,y)` :
` f = f(x,y)`
Les variables indépendantes qui n'apparaissent jamais à gauche d'un neurone, telles qu'ici `x` et `y`, ont leur valeur choisie librement.
La décalaration de dépendance `f"←"(x,y)` peut s'accompagner de la définition complète de la fonction qui permet concrètement de calculer `f` à partir de `x` et `y`. Par exemple :
`f"←"(x,y)`
`f(x,y) = 1/(1+x^2+y^2)`
Les deux assertions sont nécessaires. La première donne à `f` un système de coordonnée par défaut `f=f(x,y)`. Elle enrichie la syntaxe du langage des équations. La seconde est l'expression explicite de la contrainte qui permet de calculer concrétement `f` à partir de `(x,y)`. Dans l'exemple, la fonction `f` est :
`f : ((RR^2->RR),((x,y)|->1/(1+x^2+y^2) ))`
La fonction `f`, qu'elle soit explicite ou inconnue, s'appelle un neurone. Notez qu'un neurone au sens classique est plus précis et moins générale que cela. Le neurone classique est une fonction d'une somme de variables pondérés par des paramètres qui constituent la mémoire de l'apprentissage au niveau du neurone. Ici, le neurone est une fonction quelconque qui peut être inconnue, qui affirme que `f` est déterminée par les variables arguments mentionnées, et qui choisit ces mêmes variables arguments comme un système de coordonnées par défaut pour `f`, perfectionnant ainsi la syntaxe du langage des équations.
La variable `f` peut avoir d'autres liens de dépendance. Etant donné de nouvelles variables `u,v`. On définit par exemple un nouveau lien de dépendance de `f` en utilisant un autre type de parenthèse dans la liste `( , (: , [ , ❲ , ⦅ , ⟦` comme suit :
`f"←"(:u,v:)`
La variable `f` désigne alors deux neurones qui sont deux fonctions. C'est le type de parenthèse utilisée dans l'appel de fonction qui déterminera la fonction (le neurone) concernée. Ainsi `f(0,0)` désigne la valeur de `f` lorsque `x"="0` et `y"="0`, c'est à dire la valeur du neurone `f"←"(x,y)` appliqué au point `(0,0)`, tandis que `f(:0,0:)` désigne la valeur de `f` lorsque `u"="0` et `v"="0`, c'est à dire la valeur du neurone `f"←"(:u,v:)` appliqué au point `(0,0)`, et ces deux valeurs n'ont aucune raison d'être identique.
Parcontre, du fait que `f` ne désigne qu'une et une seule variable, nous avons de façon implicite les égalités suivantes sur ce que l'on appelle le point de mesure par défaut de `f` :
`f = f(x,y) = f(:u,v:)`
On note parfois `a≺b≺c` pour désigner que `a` est trés petit en norme devant `b` au point d'être négligeable devant `b` qui lui même est trés petit en norme devant `c` au point d'être négligeable devant `c`. Néanmoins ces appréciations ne sont pas exactes, seulement approchées.
Il existe un moyen de formaliser de façon exacte des ordres de valeur grâce aux hyperréels qui comprennent les valeurs infiniments petites, et donc aussi leurs inverses, les valeurs infiniments grandes. Délors une valeur est plus qu'un simple réel mais un hyperréel. On remplace le concept de valeur réel négligeable devant `x` par le concept de valeur hyperréel infiniment petite devant `x`, c'est à dire qui, multipliée par n'importe quel réel, aura une norme qui ne dépassera jamais celle de `x`. Et on utilise la même notation pour exprimer cette propriété. Ainsi `v"≺"x` signifie que l'ordre de `v` est plus petit que l'ordre de `x`, c'est à dire que `v` est infiniment petit devant `x`.
`v"≺"x <=> AAr"∈"RR^**, |rv|"⩽"|x|`
`v"≺"x <=> AAr"∈"RR^**, |v|"⩽"|rx|`
La négation de cette propriété, c'est à dire `v"⊀"x` ou dit autrement `v"≽"x` se définie donc comme suit :
`v"≽"x <=> EEr"∈"RR^**, |rv|"⩾"|x|`
`v"≽"x <=> EEr"∈"RR^**, |v|"⩾"|rx|`
Et on a remplacé `|rv|">"|x|` par `|rv|"⩾"|x|` car cela ne change pas la propriété, et parceque évoquer la relation d'ordre est plus simple que d'évoquer la relation d'ordre stricte. Ainsi `v"≽"x` signifie que l'ordre de `v` est plus grand ou égal à l'ordre de `x`, c'est à dire qu'il existe un multiple entier de `v` qui est supérieur en norme à la norme de `x`. La relation dans l'autre sens s'écrit de la même façon :
`v"≼"x <=> EEr"∈"RR^**, |rv|"⩽"|x|`
`v"≼"x <=> EEr"∈"RR^**, |v|"⩽"|rx|`
Ainsi `v"≼"x` signifie que l'ordre de `v` est plus petit ou égal à l'ordre de `x`, c'est à dire qu'il existe une division entière de `v` qui est inférieure en norme à la norme de `x`. Puis l'égalité d'ordre de valeur se définit comme suit :
`v"≍"x <=> v"≼"x"≼"v`
`v"≍"x <=> (EEr"∈"RR^**, |rv|"⩽"|x| "et" EEr"∈"RR^**, |rv|"⩾"|x|)`
Ainsi `v"≍"x`, signifie que l'ordre de `v` est égal à celui de `x`, c'est à dire qu'il existe un multiple entier de `v` qui est supérieur en norme à la norme `x`, et qu'il existe une division entière de `v` qui est inférieure en norme à la norme de `x`. L'ordre de `x` est noté `Theta(x)` :
`Theta(x) = {v "/" v"≍"x }`
La relation `"≍"` est une relation d'équivalence. L'ensemble des ordres de valeur `"*"RR"/≍"` est un ensemble totalement ordonné par la relation d'ordre `"≼"`.
`"*"RR"/≍" = {Theta(x) "/" x"∈" "*"RR}`
L'ordre de zéro est le singleton `{0}`.
Une grandeur est une valeur non nulle.
Un ordre de grandeur est un ordre de valeur autre que `{0}`.
Etant donné une application `g"(.,.)"` dans `E`. C'est à dire que `G "∈" (E"×"E"→"E)`. La notation ensembliste permet d'utiliser des sous-ensembles de `E` comme argument de l'application `g` comme suit :
`g(x,A) = {g(x,y) "/" y "∈" A}`
`g(A,y) = {g(x,y) "/" x "∈" A}`
`g(A,B) = {g(x,y) "/" x "∈" A, y "∈" B}`
Il en est de même pour les opérations `+, **` et autres opérations :
`x "+" A = {x"+"y "/" y "∈" A}`
`A "+" y = {x"+"y "/" x "∈" A}`
`A "+" B = {x"+"y "/" x "∈" A, y "∈" B}`
Puis, on adopte une autre convention d'écriture pour désigner une approximation formelle. Si `A` est une boule stable par les opérations `"+"` et `"-"`, c'est à dire si :
`AAxAAy, x"∈"A "et" |y|"<"|x| => y"∈"A`
`AAxAAy, x"∈"A "et" y"∈"A => x"+"y "∈" A`
`AAxAAy, x"∈"A "et" y"∈"A => x"-"y "∈" A`
Alors l'égalité de `x` et `y` à une constante près appartenant à `A` s'appelle une approximation formelle, et s'écrit :
`x = y"+"A`
Et c'est le typage et le contexte qui précisera si c'est une égalité d'ensemble où une approximation formelle. Maintenant, considérons l'équation suivante :
`x"+"A = y"+"A`
C'est une égalité d'ensemble.
`{x"+"a "/" a"∈" A}` = `{y"+"b "/" b"∈" A}`
Mais, si l'ensemble `A` est une boule stable par les opérations `"+"` et `"-"`, alors on constatera que cet équation est équivalente à une égalité entre `x` et `y` à une constante près appartenant à `A`. L'équation `x"+"A = y"+"A` est alors équivalente à l'approximation formelle `x = y"+"A`.
Pour exprimer les égalité à un ordre de grandeur près, ou à un ordre de grandeur inférieur près, ou à un ordre de grandeur inférieur strictement près, on utilise une notation ensembliste qu'est la notation de Landau, Le « grand `Theta` », le « grand O » et le « petit o » et qui définissent des approximations formelles.
`o(x) = {v "/" v"≺"x}` |
`o(x)` désigne l'ensemble des valeurs hyperreéls dont l'ordre de grandeur est plus petit que celui de `x`. Ce sont les valeurs infiniment petites devant `x`. |
`O(x) = {v "/" v"≼"x}` |
`O(x)` désigne l'ensemble des valeurs hyperréels dont l'ordre de grandeur est plus petit ou égale à celui de `x`. Ce sont les valeurs qui ne sont pas infiniment grandes devant `x`. |
`Theta(x) = {v "/" v"≍"x}` |
`Theta(x) ` désigne toutes les valeurs hyperreéls de même ordre de grandeur que celui de `x`. Ce sont les valeurs qui ne sont ni infiniment petites de devant `x`, ni infiniment grandes devant `x`. Ainsi `Theta(x)` représente l'ordre de `x`. |
On utilise l'opération ensembliste de différence exacte `∸` qui se définit comme suit : L'expression `A∸B` désigne la différence exacte, c'est à dire l'ensemble des éléments de `A` qui ne sont pas dans `B`, et affirme en même temps que `B` est inclus dans `A`. L'ordre de `x` s'obtient en retirant de l'ensemble des valeurs d'ordre plus petit ou égale à celui de `x`, l'ensemble des valeurs d'ordre plus petit que celui de `x`.
`Theta(x) = O(x)∸o(x)`
`Theta(x) = xO(1)∸x o(1)`
Et pour `x"="1` nous avons : `Theta(1) = O(1)∸o(1)`
Approximation formelle |
Définition logique |
Description littérale |
`x"="y"+"o(z)` |
`AAr"∈"RR^**, |x"-"y|"⩽"|rz|` |
l'écart entre `x` et `y` est un infiniment petit devant `z` |
`x"="y"+"O(z)` |
`EEr"∈"RR^**, |x"-"y|"⩽"|rz|` |
l'écart entre `x` et `y` est d'un ordre de grandeur inférieur où égal à celui de `z` |
| `x = y"+"Theta(z)` | `((EEr"∈"RR^**"," |x"-"y|"⩽"|rz|),(EEr"∈"RR^**"," |x"-"y|"⩾"|rz|))` |
l'écart entre `x` et `y` est d'un ordre de grandeur égal à celui de `z` |
L'ordre de `x` s'obtient en ajoutant à l'ensemble des réels multipliés par `x`, l'ensemble des valeurs d'ordre plus petit que `x`.
`Theta(x) = xRR^**+ o(x)`
`Theta(x) = xRR^**+ xo(1)`
`O(x) = xRR + o(x)`
`O(x) = xRR + xo(1)`
Et pour `x"="1` nous avons :
`Theta(1) = RR^**+ o(1)`
`O(1) = RR + o(1)`
On définit une numérotation logarithmique des ordres de grandeurs. Par convention, l'ordre de grandeur de `1`, qui est l'ensemble `Theta(1)`, est numéroté `0` et est noté `ccO^0`.
`ccO^0 = Theta(1) = RR^** "+" o(1) = {r"+"epsilon "/" r "∈" R^**, epsilon "∈" o(1)}`
Et l'ordre de valeur de `0`, qui est l'ensemble `Theta(0) ={0}`, est numéroté `-oo`, et est noté `ccO^-oo`.
`ccO^-oo = Theta(0) = {0}`
Les neurones sont des fonctions analytiques c'est à dire indéfiniment dérivable et de série de Taylor convergente. Considérons le neurone `f"←"(x)`. La fonction `f` est analytique, c'est à dire qu'elle possède des paramètres réels, ou simplement rationnels, `(a_k)_(k in NN)` satisfaisant :
`f = lim_(n->oo) sum_(k=0)^n a_k x^k`
La définition classique du passage à la limite dans `RR` est :
`AA mu "∈"RR^**, EE m "∈"NN, AAn">"m, sum_(k=0)^n a_k x^k∈sfB[f,mu]`
La notation `sfB[c,r]` désigne la boule de centre `c` et de rayon `r`. Sur une droite, cela désigne l'intervalle `[c"-"r,c"+"r]`. La définition peut s'exprimer de façon encore plus générale en utilisant le concept de voisinage à la place de celui de boule.
`AA V "∈" bbbV(f), EE m "∈"NN, AAn">"m, sum_(k=1)^n a_k x^k∈V`
Littéralement : Quelque soit un voisinage `V` de `f`, il existe un entier `m` à partir du quel toute les séries tronquées produisent un élément du voisinage `V`.
`bbbV(c)` désigne l'ensemble des voisinages de `c`. Un voisinnage de `c` est une partie de l'espace contenant un ouvert qui contient `c`. Un ouvert est une partie de l'espace telle que pour chaque point `e` de l'ouvert en question, il existe une suite de points `(e_i)_(i in NN)`, tous distincts de `e` et appartenant à l'ouvert en question, et dont la limite est `e`, c'est à dire tel que `lim_(i->oo) e_i = e`.
Considérons maintenant le neurone `f"←"(x,y)`. La fonction `f` possède les paramètres réels, ou simplement rationnels, `(a_(i,j))_((i,j) in NN^2)` satisfaisant :
`f= lim_(n->oo) sum_((i,j) in NN^2) a_(i,j) x^i y^j`
Rappelons que la limite, et d'une manière plus générale, l'adhérence, ne dépend pas de l'ordre des termes de la série. C'est pourquoi on ne précise pas dans quel ordre précisement sont disposés les termes de la série. La définition du passage à la limite dans `RR` s'écrit :
`AA mu "∈"RR^**, EE (m_1,m_2) "∈"NN^2, AAn_1">"m_1, AAn_2">"m_2, sum_(i=0)^(n_1) sum_(j=0)^(n_2) a_(i,j) x^i y^j ∈ sfB[f,mu]`
Remarquez que la fonction `f` est complètement définie aussi bien pour les réels que pour les hyperréels, en remplaçant `RR^**` par `"*"RR`.
On définie arbitrairement un étalon `epsilon` infinitésimal. C'est un infiniment petit devant `1`.
`epsilon "∈" o(1)`
L'ordre de grandeur d'`epsilon` est `Theta(epsilon)`. C'est aussi l'ordre de grandeur de `1` multiplié par `epsilon`. Cet ordre de grandeur est numéroté `-1`, et noté `ccO^-1`.
`ccO^-1 = Theta(epsilon)
`ccO^-1 = epsilon Theta(1)`
`ccO^-1 = epsilonRR^** + epsilon o(1)`
`ccO^-1 = epsilonRR^** + o(epsilon)`
`ccO^-1 = epsilonRR^** ∸ epsilon o(1)`
`ccO^-1 = epsilonRR^** ∸ o(epsilon)`
---- 15 novembre 2020 ----
`x = y + o(epsilon)`
Le dernier terme `o(1)` signifie que l'égalité est valable à une valeur infinitésimale près. Considérons l'égalité suivante :
`x = y + O(epsilon)`
Le dernier terme `O(epsilon)` signifie que l'égalité est valable à une valeur près de l'ordre d'`epsilon`. Remarquez que cette équation est plus contraigante que la précédente. Car `sqrt(epsilon)` appartient à `o(1)`, c'est un infinitésimal, mais il n'apartient pas à `O(epsilon)`. En effet, `sqrt(epsilon)` est d'un ordre plus grand que `epsilon`, c'est à dire que `epsilon` multiplié par n'importe quel réel ne dépassera jamais `sqrt(epsilon)`.
---- 12 novembre 2020 ----
On remarque alors que `epsilon^2` constitue une grandeur infiniment petite devant `epsilon`, c'est à dire que, multipliées par n'importe quel réel, il ne dépassera jamais `epsilon`, ce qui se note, `epsilon^2 ∈ o(epsilon)`. Ainsi nous avons :
Description |
Ordre |
||
`O(1)` |
Ensemble des valeurs réels non nuls augmenté d'une valeur infinitésimale. | 0 |
|
o(1) |
Ensemble des valeurs infinitésimales. | -0 |
|
`O(epsilon)` |
Ensemble des valeurs de l'ordre d`epsilon`. | -1 |
|
`o(epsilon)` |
Ensemble des valeurs infiniments petites par rapport à `epsilon`. | ||
| `O(epsilon^2)` | Ensemble des valeurs de l'ordre d`epsilon^2`. | ||
| `o(epsilon^2)` | Ensemble des valeurs infiniment petite par rapport à `epsilon^2`. | ||
| ... | |||
| `O(epsilon^n)` | Ensemble des valeurs de l'ordre d`epsilon^n`. | ||
| `o(epsilon^n)` | Ensemble des valeurs infiniment petite par rapport à `epsilon^n`. |
Notez qu'une valeur infinitésimal d'ordre `n` est en faite une valeur d'ordre `-n`. Les ordres sont numérotés :
Etant donné une fonction analytique `f"←"(x)`
`f(x) = a_0+a_1x+a_2x^2 + a_3x^3 + .... = sum_(k=0)^oo a_k x^k` donc `f(0) = a_0`
`f'(x) = a_1+2a_2x + 3a_3x^2 + .... = sum_(k=1)^oo k a_k x^(k-1)` donc `f'(0) = a_1`
`f''(x) = 2a_2 + (3!)a_3 + .... = sum_(k=2)^oo k(k-1) a_k x^(k-2)` donc `f''(0) = 2a_2`
`f'''(x) = (3!)a_3 + (4!)a_4 + .... = sum_(k=2)^oo k(k-1) a_k x^(k-2)` donc `f''(0) = (3!)a_3`
Et nous avons identité entre la série de la fonction analytique et sa série de Taylor :
`f^("("n")")(0) =(n!)a_n`
`f(x) = f(0) + f'(0)x + (f''(0))/2 x^2 +(f'''(0))/(3!) x^3 + ... = sum_(k=0)^oo (f^("("k")")(0))/(k!)`
----- 11 novembre 2020 -----
On remarque que :
`f(x"+"epsilon^n) = a_0+a_1(x"+"epsilon^n)+a_2(x"+"epsilon^n)^2+a_3(x"+"epsilon^n)^3 + ....`
`f(x"+"epsilon^n) = (a_0+a_1x+a_2x^2+a_3x^3 + ....)+epsilon^n(a_1+a_2epsilon^n+2a_2x+a_3epsilon^(2n)+3a_3xepsilon^n+3a_3x^2+...)`
`f(x"+"epsilon^n) = f(x) + O( epsilon^n )`
Cela signifie que les fonctions analytiques respectent les ordres de grandeurs.
L'équation limite se réécrit dans les hyperréels en utilisant les infinitesimaux `o(1)` :
`f(x+o(1)) = f(x)+o(1)`
---- 11 novembre 2020 ----
C'est à dire que `f'(x)` est un réel, et `u` est un réel qui temps vers zéro. L'équation se réécrit dans les hyperréels en utilisant un `epsilon` infiniment petit devant `1`, c'est à dire choisi tel que `epsilon = o(1)` :
`(f(x"+"epsilon)-f(x))/epsilon = f'(x) + o(1)`
Les neurones sont des fonctions supposées dérivables. La fonction `f` est dérivable, c'est à dire que quelque soit un réel `x` dans le domaine ouvert de `f`, la limite suivante existe :
`lim_(u->0) (f(x"+"u)-f(x))/u = f'(x)`
C'est à dire que `f'(x)` est un réel, et `u` est un réel qui temps vers zéro. L'équation se réécrit dans les hyperréels en utilisant un `epsilon` infiniment petit devant `1`, c'est à dire choisi tel que `epsilon = o(1)` :
`(f(x"+"epsilon)-f(x))/epsilon = f'(x) + o(1)`
---- 10 novembre 2020 ----
qui donc respectent les ordres de grandeur. Considérons une fonction `f"←"(x)`, nous avons :
`f(x+o(1)) = f(x)+o(1)`
Cela signifit que `f` appliquée à la valeur `x` augmentée d'une valeur infinitésimale quelconque du premier ordre, produit la valeur `f(x)` augmentée d'une valeur infinitésimale du premier ordre. C'est une propriété des fonctions continues.
On définie arbitrairement un étalon `epsilon`, une grandeur infiniment petit du premier ordre, c'est à dire qui, multipliées par n'importe quel réel, n'atteint jamais `1`. Autrement dit, `epsilon=o(1)`. On remarque alors que `epsilon^2` constitue une grandeur infiniment petit devant `epsilon`, c'est à dire que, multipliées par n'importe quel réel, il n'atteindra jamais `epsilon`. Ainsi nous avons :
Les neurones sont des fonctions analytiques qui donc respectent les ordres de grandeurs. Considérons une fonction `f"←"(x)`, nous avons :
`f(x+o(epsilon^n)) = f(x)+o(epsilon^n)`
Cela signifit que `f` appliquée à la valeur `x` augmentée d'une valeur infinitésimale quelconque du `n`-ième ordre, produit la valeur `f(x)` augmentée d'une valeur infinitésimale du `n`-ième ordre. C'est encore une propriété des fonctions continues.
Etant donné trois variables `f,x,y`. Les éléments différentiels `df, dx, dy`, traduisent une évolution infinitésimale du premier ordre du système constitué par ces trois variables `f,x,y`. L'élément différentiel est une variation infinitésimale du premier ordre.
`df = o(1)`
`dx = o(1)`
`dy = o(1)`
Les hyperréels permettent formaliser les ordres de grandeur. On choisit arbitrairement un infiniment petit étalon `epsilon`. La valeur `epsilon^n` constitue alors la grandeur étalon infinitésimales du `n`-ième ordre. `epsilon^nRR^**+o(epsilon^n)` désigne l'ordre de `epsilon^n`. Et le "petit o", `o(epsilon^n)` désigne l'ensemble des valeurs infinitésimales d'ordre `n"+"1`. Considérons maintenant le neurone suivant :
`f"←"(x,y)`
Cela signifie que `f` est une fonction analytique de `(x,y)` et possède comme arguments par défaut `(x,y)`. L'élément différentiel `df` devient alors également une fonction de `(x,y)` et aura également par défaut ces arguments.
`df"←"(x,y)`
Les éléments différentiels traduisent une évolution infinitésimale du système. Cela se traduit par l'équation suivante, qui porte sur deux ordres de grandeurs.
`f(x"+"dx"+"o(epsilon),y"+"dy"+"o(epsilon)) = f + df + o(epsilon)`
Le terme `o(epsilon)` désigne une valeur négligeable devant `epsilon`, c'est à dire de façon formelle, une valeur infinitésimale devant `epsilon`. L'égalité porte sur deux ordres de grandeurs ; l'ordre de `1`, et l'ordre d'`epsilon`.
`x` et `y` étant libre, les éléments différentiels `dx,dy` qui traduisent leur évolution infinitésimale, sont également libres c'est à dire qu'ils peuvent être choisis arbitrairement du moment qu'ils restent infinitésimaux. Parcontre l'élément `df` est déterminé dans l'ordre des grandeurs de `1` par `(x,y)`, et dans l'ordre des grandeurs d'`epsilon`, de façon linéaire, par `(dx,dy)`. Pour expliciter cette dernière dépendance linéaire, on utilise les dérivée partielles, et on préfère représenter certaines coordonnées en vecteurs colonnes :
`f"←"(x,y) df"←"(x,y)`
La valeur `f` est égale à `f(x,y)`. C'est la valeur de `f` au point par défaut `(x,y)`. Et de même `df=df(x,y)`, la valeur de la variation infinitésimale `df` au point par défaut `(x,y)`.
Au point par défaut `(x,y)`, la dépendance linéaire aux variations `dx, dy` se traduit à l'aide des dérivées partielles. La variation `df` est une combinaison linéaire des variations `dx` et `dy` respectivement pondéré par la dérivé partielle de `f` selon `x` notée `delf"/"delx` et par la dérivée partielle de `f` selon `y` notée `delf"/"dely` définies relativement au neurone `f"←"(x,y)` :
`df = (delf)/(delx) dx + (delf)/(delx) dy`
Cela se met sous forme d'un produit matriciel :
`df = [ (delf)/(delx) , (delf)/(delx) ]"×"[(dx),(dy)]`
L'application linéaire ainsi mise en évidence est la dérivée de `f` que l'on note `f'` et qui constitue une matrice :
`f' = [ (delf)/(delx) , (delf)/(delx) ]`
La variation libre `(dx,dy)` va déterminée linéairement `df` selon la dérivée de `f` :
`df =f'"×"[(dx),(dy)]`
La dérivée `f'` est une application linéaire s'appliquant à `(dx,dy)` pour produire `df` d'où sa représentation sous forme matricielle, mais c'est aussi une fonction de `(x,y)` :
`f'"←"(x,y)`
`f' = [ (delf)/(delx) , (delf)/(delx) ]`
Les dérivés partielles ne se comportent pas comme les dérivés exactes. Considérons l'exemple suivant :
`f"←"(x,t)`
`x"←"(t, tau)`
`tau"←"(t)`
Dans cet exemple la variable `f` est déterminée par `(x,t)`, et comme `x` est déterminée par `(t,tau)`, et que `tau` est déterminé par `t`, on en déduit que `f` est déterminée par `t`. La différence entre dérivée partielle et dérivé exacte apparaît alors de façon flagrande :
`(delf)/(delt) ≠ (df)/(dt)`
En effet nous avons par définition du neurone `f"←"(x,t)` :
`df = (delf)/(delx)dx+ (delf)/(delt)dt`
Et donc :
`(delf)/(delt) = (df)/(dt) - (delf)/(delx) (dx)/(dt)`
Dans l'expression `delf"/"delx`, le numérateur et le dénominateur sont liés comme étant relatif à un neurone, et ne peuvent pas à l'instar des différentielles exactes se comporter comme des éléments différentiels globaux traduisant une évolution infinitésimale du système. Les éléments différentiels partiels ne traduisent qu'une évolution hypothétique dans un neurone. C'est pourquoi il est parfois plus prudent d'utiliser l'opérateur de dérivé partielle appliqué à f comme suit :
`df = (del)/(delx)f dx+ (del)/(delt)f dt`
---- 9 novembre 2020 ----
Néanmoins on peut quand même définir des éléments différentiels partiels relatif au neurone à l'aide de l'équation traduisant l'évolution infinitésimale du neurone, et qui porte sur deux ordres de grandeurs :
`del_xf = f(x"+"epsilon,y)-f + o(epsilon)`
`del_yf = f(x,y"+"epsilon)-f + o(epsilon)`
Tout se passe comme si nous avions choisi un élément différentiel propre au neurone `delx` fixé égale à l'étalon `epsilon` et un élément différentiel `dely` fixé également à l'étalon `epsilon`. Dans la pratique cela signifie que l'on ne peut pas simplifier une expression telle que :
`(delf)/(delx) (delx)/(delt) = (del_xf)/epsilon (del_tx)/epsilon`
car le premier `delx` peut être assimilé à `epsilon` mais pas le second. Ce sont des éléments différentielles indépendants défini sur deux neurones distincts ; `f"←"(x,t)` et `x"←"(t)` et donc inégaux.
Le neurone `f"←"(x,t)` entraine également que les dérivées partielles sont des fonctions de `(x,t)` :
`(delf)/(delx)"←"(x,t)`
`(delf)/(delt)"←"(x,t)`
Considérons un autre exemple :
`f"←"(x,y)`
`x"←"(t,tau)`
`y"←"(t,tau)``df = (delf)/(delx) dx + (delf)/(dely) dy`
`dx = (delx)/(delt) dt + (delx)/(del tau) d tau`
`dy = (dely)/(delt) dt + (dely)/(del tau) d tau`
`df = (delf)/(delx) ((delx)/(delt) dt + (delx)/(del tau) d tau) + (delf)/(dely) ((dely)/(delt) dt + (dely)/(del tau) d tau) `
`df = ((delf)/(delx) (delx)/(delt) + (delf)/(dely) (dely)/(delt) ) dt + ((delf)/(delx) (delx)/(del tau) + (delf)/(dely) (dely)/(del tau)) d tau`
`f` étant dépendant de `x` et de `y`, et `x` et `y` étant chacun dépendant de `t` et `tau`, on en conclut que `f` est également dépendant de `t` et `tau`. Cela peut faire l'objet d'un second neurone :
`f"←"(:t,tau:)`
Dés lors, les dérivées partielles de `f` relativement à `t` et à `tau` sont définies, et sont relatives à ce neurone. Nous avons :
`df = (delf)/(delt) dt + (delf)/(del tau) d tau`
En comparant avec le résultat précédent, on en déduit que :
`(delf)/(delt) = (delf)/(delx) (delx)/(delt) + (delf)/(dely) (dely)/(delt)`
`(delf)/(del tau) = (delf)/(delx) (delx)/(del tau) + (delf)/(dely) (dely)/(del tau)`
Si une variable possède plusieurs neurones avec des arguments communs telle que par exemple :
`g"←"(x,y)`
`g"←"(:x,t:)`
Il y a alors deux dérivées partrielles de `g` selon `x`, l'une définie dans le neurone `g"←"(x,y)`, l'autre définie dans le neurone `g"←"(:x,t:)`. La distinction se fait en utilisant les parenthèses d'application du neurone, et à vide si c'est au point par défaut. Ainsi, l'expression suivante :
`(delg)/(delx)(::)`
désigne la dérivée partielle de `g` selon `x` dans le neurone `g"←"(:x,t:)` et appliquée au point par défaut `(x,t)`. Mais généralement les différents neurones d'une même variables ne comprendrons pas d'argument commun et il ne sera pas nécessaire de préciser alors dans quel neurone se calcule la dérivée partielle.
Considérons deux variables vectorielle `vecf,vecx`. Et considérons qu'ils ont 3 composantes chacune :
`vecf = [(f_1),(f_2),(f_3)]`
`vecx = [(x_1),(x_2),(x_3)]`
Considérons le neurone :
`vecf"←"(vecx)`
La dérivée de `vecf`, que l'on note `vecf'`, est une application linéaire selon `vec(dx)` définie par la matrice suivante :
`vecf' = ( ((delf_1)/(delx_1), (delf_1)/(delx_2), (delf_1)/(delx_3)) , ((delf_2)/(delx_1), (delf_2)/(delx_2), (delf_2)/(delx_3)) ,((delf_3)/(delx_1), (delf_3)/(delx_2), (delf_3)/(delx_3)) )`
Et nous avons :
`vec(df)"←"(vecx)`
`vecf'"←"(vecx)`
`vec(df) = f' "×" vec(dx)`
Et nous aurons l'égalité suivante qui porte sur deux ordres :
`vecf (vecx"+"vecdx) = vecf + vec(df) + o(vec epsilon)`
L'opérateur de différentialisation exacte `d` possède une priorité syntaxique plus faible que l'appel de fonction, faisant que `df(u)` signifie `d(f(u))` et non `(df)(u)`. Parcontre il possède une priorité syntaxique plus forte que l'élèvation à la puissance, faisant que `dx^2` signifie `(dx)^2` et non `d(x^2)`. Ainsi nos avons :
`dx^y = (dx)^y`
`dln(x) = d(ln(x))`
`dsin(x) = d(sin(x))`
`dcos(x) = d(cos(x))`
Considérons des variables `x,y,z` et une constante `p`. Nous avons les règles de dérivations suivantes :
`d(xy) = xdy+ydx`
`d(x^p) = p x^(p-1) dx`
`d(x^y) = yx^(y-1)dx + x^y ln(x)dy`
`d(e^x) =e^x dx`
`dln(x) = (dx)/x`
`dsin(x) = cos(x) dx`
`dcos(x) = -sin(x) dx`
Et pour une variable `f` fonction d'une seule variable, nous avons :
`df(y) = f'dy`
Et pour une variable `f` fonction de deux variables, nous avons :
`df(x,y)= (delf)/(delx)dx + (delf)/(dely)dy`
Exemple de calcul de dérivé à partir de ces règles :
`d(x/y) = d(xy^-1)`
` = xd(y^-1)+y^-1dx`
` = x("-"1) y^-2dy+(dx)/y``d(x/y) = (dx)/y - (xdy)/(y^2)`
Autre exemple utilisant le résultat précédent :
`d(sin( x"+"sin(y) )/((xy)^2"+"1)) = (dsin( x"+"sin(y) ))/((xy)^2"+"1) - (sin( x"+"sin(y) ) d((xy)^2"+"1))/(((xy)^2"+"1)^2)`
`= (cos(x"+"sin(y))d(x"+"sin(y)))/((xy)^2"+"1) - (sin(x"+"sin(y))d((xy)^2"+"1))/(((xy)^2"+"1)^2)`
`= (cos(x"+"sin(y))(dx"+"dsin(y)))/((xy)^2"+"1) - (sin(x"+"sin(y))d((xy)^2))/(((xy)^2"+"1)^2)`
`= (cos(x"+"sin(y))(dx"+"cos(y)dy))/((xy)^2"+"1) - (sin(x"+"sin(y))2xyd(xy) )/(((xy)^2"+"1)^2)`
`= (cos(x"+"sin(y))(dx"+"cos(y)dy))/((xy)^2"+"1) - (sin(x"+"sin(y))2xy(xdy+ydx))/(((xy)^2"+"1)^2)`
Etant donné trois variables `f,x,y`. Les éléments différentiels `df, dx, dy`, traduisent une évolution infinitésimale du système constitué par ces trois variables `f,x,y`. Cela se traduit par l'équation suivante, qui porte sur deux ordres de grandeur.
`f(x"+"dx,y"+"dy) = f + df + o(epsilon)`
La série de Taylor formelle porte sur `n"+"1` ordres de grandeur :
`f(x"+"dx,y"+"dy) = f + df + (d^2f)/2 + (d^3f)/(3!) + ... +(d^nf)/(n!) + o(epsilon^n)`
`f(x"+"dx,y"+"dy) = f + sum_(k=1)^n (d^kf)/(k!) + o(epsilon^n)`
où `d^2f` correspond à la différentielle seconde de `f`, c'est à dire à `d(df)`, et de même pour la différentielle troisième `d^3f = d(d(df))`, etc..
`df = (delf)/(delx) dx + (delf)/(dely)dy`
`d^2f = (del df)/(delx) dx + (del df)/(dely)dy`
`= (del ((delf)/(delx) dx + (delf)/(dely)dy))/(delx) dx + (del ((delf)/(delx) dx + (delf)/(dely)dy))/(dely)dy`
`= (del^2f)/(delx^2)dx^2 + (del^2f)/(delxdely)dxdy + (del^2f)/(delxdely)dxdy + (del^2f)/(dely^2)dy^2``= (del^2f)/(delx^2)dx^2 + 2 (del^2f)/(delxdely)dxdy + (del^2f)/(dely^2)dy^2`
`d^3f = (del d^2f)/(delx) dx + (del d^2f)/(dely)dy`
`= (del ((del^2f)/(delx^2)dx^2 + 2 (del^2f)/(delxdely)dxdy + (del^2f)/(dely^2)dy^2))/(delx) dx + (del ((del^2f)/(delx^2)dx^2 + 2 (del^2f)/(delxdely)dxdy + (del^2f)/(dely^2)dy^2))/(dely)dy`
`= (del^3f)/(delx^3)dx^3+2(del^3f)/(delx^2dely)dx^2dy + (del^3f)/(delxdely^2)dxdy^2 + (del^3f)/(delx^2dely)dx^2dy+2(del^3f)/(delxdely^2)dxdy^2 + (del^3f)/(dely^3)dy^3`
`= (del^3f)/(delx^3)dx^3 + 3 (del^3f)/(delx^2dely)dx^2dy + 3 (del^3f)/(delxdely^2)dxdy^2 + (del^3f)/(dely^3)dy^3`
...
`d^nf = sum_(k=0)^n ((n),(k)) (del^nf)/(del^(n"-"k)xdel^ky)`
où les `((n),(k))` sont les coefficients binomiaux `((n),(k))=(n!)/(k!(n-k)!)`
Une variable ne désigne apriori aucune fonction, car apriori elle est supposée libre. Sauf si on pose comme hypothèse un lien de dépendance, et la fonction est alors pré-déclarée dans un neurone tel que par exemple :
`f"←"(x)`
`g"←"(x,y)`
Délors la variable `f` désigne une fonction analytique appliquée par défaut à `x`, et de même la variable `g` désigne une fonction analytique appliquée par défaut à `(x,y)`. Puis, il est possible que la variable `f` est plusieurs lien de dépendance, plusieurs neurones déclarés en utilisant à chaque fois un autre type de parenthèse tel que par exemple :
`f"←"(:y,t:)`
Alors dans ce cas, la variable `f` désigne deux fonctions : L'une, fonction de `x`. L'autre, fonction de `y` et `t`. Et nous avons :
`f = f(x) = f(:y,t:)`
Cela signifit pour `f`, que les coordonnées `(x)` et `(:y,t:)` désignent un même point valué par `f`. Il peut y avoir ainsi plusieurs neurones pour une même variables. Mais des considérations relativement simple nous permettent d'affirmer que l'ensemble des arguments d'un neurone ne peut pas être retrouvé tout ensemble dans un autre neurone de la même variables. Ainsi la liste des arguments, qui préside à la définition des dérivés partielles, adjoint à la variable, permet de détermine le neurone concerné.
La primitive d'une variable `f` relativement au neurone `f"←"(x,y)` est définie comme étant une nouvelle variable `F` liée avec les mêmes arguments, `F"←"(x,y)` et qui lorsqu'on la dérive selon chacun de ses arguments, redonne `f`.
`(del^2 F)/(delxdely) = f`
Cette définition détermine la primitive à une constante près. On note la primitive de `f` à l'aide du symbole d'intégration nu, appliqué à `fdxdy`. Le produit des éléments différentiels des arguments, ici `dxdy`, va déterminer le neurone concerné dans le cas où `f` possède plusieurs neurones :
`F = int fdxdy`
---- 8 novembre 2020 ----
Dans le cas d'une variable `f` avec le neurone`f"←"(x)`. La primitive de `f` est définie comme étant une fonction `F` portant sur les mêmes arguments, autrement dit, on considère donc le neurone `F"←"(x)`, qui lorsqu'on la dérive, redonne `f`, c'est à dire tel que :
Dans le cas d'une variable `g` avec le neurone `g"←"(:x,y:)`. La primitive de `g` est une fonction notée `G` également fonction de `(x,y)`, on considère donc le neurone `G"←"(:x,y:)`, qui lorsqu'on la dérive selon chacune de ses variables, redonne `f`, c'est à dire tel que :`(dF)/(dx) = f`
`(del^2 G)/(delxdely) dxdy = g dxdy`
Si la variable `f` possèdent plusieurs neurones tel que par exemple
`f"←"(:x,y:)`
`f"←"(:t,tau:)`
Alors la primitive de f doit préciser le quel des deux neurones elle est la primitive, cela le fait en indiquant les variables d'intégration. Ainsi l'expression
`int fdxdy`
désigne la primitive du neurone `f"←"(:x,y:)` tandis que l'expression
`int fdt d tau`
désigne la primitive du neurone `f"←"(:t,tau:)`
Les dérivés partielles de `g` par rapport à `x` et `y` sont relatives au neurone `g"←"(x,y)`. Par contre les dérivés exactes, si elles existent, sont absolues, elles décrivent des contraintes globales sur le système de variables.
---- 8 novembre 2020 ----
Dans le cas d'une variable `g` avec le neurone `g"←"(:x,y:)`. On pose `y` constant, délors la variable `g` devient une fonction à un seul argument `x`, et on peut définir comme précédement une primitive `H` qui est également une fonction de `x,y`. On pose le neurone `H"←"(:x,y:)`. Le fait de poser `y` constant et d'imaginer un `x` libre constitue le principe de base de la construction de la dérivée partielle de `H` selon `x`.
`(delH)/(delx) = g`
On pose `x` constant, délors la variable `H` devient une fonction à un seul argument `y`, et on définie comme précédement une primitive `G` qui est également une fonction de `x,y`. On pose le neurone `G"←"(:x,y:)`. Le fait de poser `x` constant et d'imaginer un `y` libre constitue le principe de base de la construction de la dérivée partielle de `G` selon `y`.
`(delG)/(dely) = H`
`(del ((delG)/(dely)))/(del x)= g`
`(del^2 G)/(delxdely)= g`
La primitive de `g` est une fonction notée `G` également fonction de `(x,y)`, on considère donc le neurone `G"←"(:x,y:)`. La dérivée de `G` que l'on note `G'` est une application linéaire de `RR^2->RR`
`G' = [(delG)/(delx), (delG)/(dely)]`
`dG = G'×[(dx),(dy)]`
qui lorsqu'on la dérive, redonne `g`, c'est à dire tel que `G' = f`.
`G' = [(delG)/(delx), (delG)/(dely)] = g`
`G' = [(delG)/(delx), (delG)/(dely)] = g`
`[(delG)/(delx), (delG)/(dely)]×[(dx),(dy)] = f dx`
que l'on notée `F` est définie comme suit, selon le nombre d'arguments :
`f"←"(:x:)`
`int_(x=x_1)^(x=x_2) f(:x:)dx = F(:x_2:) - F(:x_1:)`
`f"←"(:x,y:)`
`int_(x=x_1)^(x=x_2) int_(y=y_1)^(y=y_2) f(:x,y:)dxdy = F(:x_2,y_2:) - F(:x_1,y_1:)`
`f"←"(:x,y,z:)`
`int_(x=x_1)^(x=x_2) int_(y=y_1)^(y=y_2) int_(z=z_1)^(z=z_2) f(:x,y,z:)dxdydz = F(:x_2,y_2,z_2:) - F(:x_1,y_2,z_2:)`
Dans le cas à un seul argument :
`int_(x=x_1)^(x=x_1+dx) f(:x:)dx = f(:x_1:)dx`
`int_(x=x_1)^(x=x_1+dx) f(:x:)dx = F(:x_1"+"dx:) - F(:x_1:) = (dF)(:x_1:)`
Donc `f(:x_1:)dx = F(:x_1+dx:) - F(:x_1:) = (dF)(:x_1:)`
`f(:x_1:) = (F(:x_1+dx:) - F(:x_1:))/(dx) = (dF)/(dx)(:x_1:)`
`f = (dF)/(dx)`
---- 7 novembre 2020 ----
Dans le cas à deux arguments :
`int_(x=x_1)^(x=x_1+dx) int_(y= y_1)^(y=y_1+dy)f(:x,y:)dxdy = f(:x_1,y_1:)dxdy`
`int_(x=x_1)^(x=x_1+dx) int_(y=y_1)^(y=y_1+dy) f(:x,y:)dxdy = F(:x_1+dx,y_1+dy:) - F(:x_1,y_1:)`
Donc `f(:x_1,y_1:)dxdy = F(:x_1+dx,y_1+dy:) - F(:x_1,y_1:) = (dF)(:x_1,y_1:)`
`f(:x_1,y_1:) = (dF)/(dxdy)(:x_1,x_2:)`
`f = (dF)/(dx)`
une fonction `F` tel que `F' = f`.
Voir Formalisation du calcul différentiel.