La plus part des modèles en physique se résume en un système d'équations différentielles partielles analytiques, c'est à dire indéfiniment dérivable et développable localement en série de Taylor.
De plus, pour des raisons propres aux fonctions harmoniques, ces modèles n'utiliserons le plus souvent que les deux premiers ordres, les dérivées et les dérivées secondes, tel que par exemple l'équation décrivant la propagation d'onde. Cette continuité, cette dérivabilité première et seconde, s'explique par la nature des modèles physiques. Par exemple, la position d'un astre, en l'état de nos connaissances physiques, évolue continûment et de façon linéaire selon une vitesse. La vitesse évolue continûment et de façon linéaire selon une accélération. Et l'accélération correspond à un champ d'accélération qui évolue continûment et de façon analytique selon la position des astres. Ainsi, la boucle est bouclée, et le système d'équation modélisant la position des astres est analytique.
Le système d'équation comprend deux parties. Le système d'équations locales, et les conditions aux limites. Les équations locales vont décrire le comportement localement. Les conditions aux limites vont décrire les conditions initiales du modèle.
Nous allons formaliser dans la mesure du possible l'écriture de tels systèmes, en perfectionnant notre langage de formule. Et, un apport important va être fait, en introduisant les ordres de grandeurs de façon formelle, c'est à dire en introduisant les hyperréels. La correspondance entre hyperréels et les comparaisons asymptotiques, permet de justifier l'utilisation des hyperréels dans les équations différentielles partielles analytiques. Nous proposons une description pratique et vulgaire des hyperréels dans leur utilisation en analyse, en calcul différentiel, dans les fonctions analytiques, et qui met donc en évidence l'aspect linéaire des différentielles.
Les fonctions analytiques se prolongent analytiquement, faisant que si une fonction analytique est égale à une autre fonction analytique en tout point d'une boule, alors elles sont égales en tout point du domaine obtenu en prolongeant la boule.
Article en lien : Calcul différentiel
On adopte la notation des physiciens. Cela consiste à considèrer un système (la forme analytique du modèle), et à considérer chaque nouvelle variable comme une variable d'état du système. Chaque variable, telle que par exemple `x`, possède un domaine de valeurs réels qu'elle peut parcourir et que l'on note comme un ensemble d'arrivé par analogie aux statistiques, `sf"Arr"(x)`. Par défaut, le domaine des valeurs possibles que peut prendre une variable est l'ensemble des nombres réels, `RR`.
Comme on ne retient que ce qui est analytique, les variables évoluent continument et nécessairement dans un domaine ouvert. Et, dans le cas où le domaine se décompose en plusieurs composantes connexes, chaque composante correspond à un mode du modèle, caractérisé par des conditions initiales différentes. On peut donc séparer chacun de ces cas et en faire des modèles distincts. Ainsi il est toujours possible de ramener le modèle par changement de variable et séparation discrète des cas, à un modèle où les variables ont toutes pour domaine, `RR`.
Le système est un ensemble de neurones. Chaque neurone établit un lien de dépendance complète entre une variable et un ensemble de variables. Etant donné deux variables `x,f`, on déclare que `f` est déterminée par `x` à l'aide du neurone suivant :
`f"←"(x)`
Ce neurone munit la variable `f` d'un système de coordonnée par défaut, `(x)`, spécifié par des parenthèses d'appel qui peuvent être spécifique, `"(), [], <>,"` etc.. Autrement dit, le neurone définie une fonction désignée par le même nom que la variable complété par la forme d'appel `f(".")`, qui possède comme argument par défaut `x`, et qui détermine la variable `f`. Ce qui s'écrit :
`f=f(x)`
Etant donné une autre variable `y`. Il est possible que `f` soit également déterminée par `y`. Cela se note par un second neurone proposant nécessairement une seconde forme d'appel, soit en prenant une autre forme de parenthèse, soit en ayant un autre nombre d'arguments, ou soit en ayant d'autres types d'arguments :
`f"←"[y]`
La variable `f` possède alors deux neurones, deux systèmes de coordonnées par défaut `(x)` et `[u]`. Il existe alors deux fonctions `f(".")` et `f["."]` qui détermine la valeur de `f` en s'appliquant à leur argument par défaut respectif. Ce qui se note :
`f=f(x)=f[y]`
Les deux variables `x` et `y` sont alors liées de façon implicite par l'équation `f(x)"="f[y]`, ce qui constitue une autre forme de dépendance dite implicite et qui correspond à un changement de coordonnée.
Par convention, le dernier neurone évoqué déterminant `f` spécifie qu'elle forme d'appel par défaut est en cours, et qu'elle système de coordonnée par défaut est en cours, pour la variable `f`. Par exemple, le rappel du neurone `f"←"(x)` précisera que dans la suite du texte, la fonction `f` désignera la fonction `f(".")` avec comme système de coordonnées par défaut, `(x)`.
Etant donné une variable `g`, on déclare que `g` est déterminée par `x` et `y`, à l'aide du neurone suivant :
`g"←"(x,y)`
Ce neurone munit la variable `g` d'un système de coordonnées par défaut, `(x,y)`, avec sa forme d'appel spécifique. Elle définie une fonction désignée par le même nom que celui de la variable complété par la forme d'appel, `g(".,.")`, qui possède comme argument par défaut `x,y`, et qui détermine la variable `g`. Ce qui s'écrit :
`g=g(x,y)`
Remarquez que dans l'expression du neurone `g"←"(x,y)`, les symboles `g,x,y` désignent les noms des variables et non leur valeur, tandis que dans l'expression de l'égalité `g=g(x,y)`, le premier `g` et le `x` et le `y` désignent les valeurs des variables, et le deuxième `g` désigne une fonction `g(".,.")` qui est la fonction du neurone `g"←"(x,y)`.
On met en oeuvre un premier aspect intitulé « Absence de variable double » : Un neurone de la forme `f"←"(x,x)` est remplacé par un neurone `f"←"(x)`. Et d'une façon générale, un neurone ayant plusieurs arguments de même nom et réduit en un neurone ne possèdant que des variables de nom différents. Par exemple `f"←"(x,y,x,z,x,y)` est transformé en un neurone `f"←"(x,y,z)`. Et la fonction associée est transformée sans difficultée. Cela ne change pas le modèle. Cela établie seulement une forme de réseau de neurone plus simple.
La programmation et la logique sont soeurs. Le langage de programmation orienté objet s'applique également avec profit aux formules mathématiques.
Le neurone établit un lien de détermination entre un ensemble de variables d'état servant d'arguments d'entrée et une variable d'état servant de sortie. Et ce lien de détermination s'affranchit de l'ordre des arguments car ces arguments ont nécessairement des noms distincts et peuvent donc être énumérés en citant leur nom dans n'importe quel ordre. C'est pourquoi on utilise une deuxième notation d'appel de fonction, en remplaçant la succesion des arguments par un ensemble d'affectations d'appel faisant référence aux noms des variables.
Par exemple considérons le neurone `f"←"(x,y)`. Celui-ci définit une fonction `f` qui appliquée aux arguments `alpha, beta` dans cet ordre s'écrit `f(alpha,beta)`. L'autre forme d'appel est sans ordre, `f(x"="alpha,y"="beta)` `"="` `f(y"="beta,x"="alpha)` mais, prend comme argument, un ensembles d'affectations à des variables locales à la fonction `f`. Les variables d'état sont globales, tandis que les variables d'entrée dans la fonction sont locales à la fonction.
L'affectation d'appel se présente comme une égalité. Le premier terme, celui de gauche, désigne une variable locale. Le second terme désigne une valeur, qu'il faut donc d'abord évaluer, et qui doit être affectée à la variable locale désignée par le premier terme. Cette affectation est parfois notée à l'aide du symbole `:=`. Ainsi par exemple `f(y":="alpha, x":="beta)` `"="` `f(beta,alpha)` car le neurone associé à la fonction est `f"←"(x,y)`.
Dans les cas où les variables d'entrée ne sont pas toutes mentionnées, chaque variable d'entrée manquante possèdera comme valeur par défaut la valeur de la variable globale de même nom.
La fonction `f` s'apparente à un programme qui possède deux variables locales `x` et `y` déclarées dans le neurone, et qui servent d'entrée, sur lesquelles on affecte des valeurs avant de lancer le calcul de `f`. Et les valeurs par défaut sont les valeurs des variables globales de même nom `x` et `y`.
En programmation orienté objet, une variable `x` locale à une fonction `f` se note `f"."x`. Mais lorsqu'elle est évoquée dans le corps de la fonction, la référence à l'objet `f` devient implicite. Le corps de la fonction comprend le programme de calcul de la fonction et comprend également la partie gauche des affectations d'appel. Ainsi `f(x"="alpha,y"="beta)` signifie que la valeur d'`alpha` est affecté à la variable `f"."x` et que la valeur de `beta` est affecté à la variable `f"."y`.
Le neurone correspond à la déclaration de prototype de la fonction, comprenant la déclaration des variables locales à la fonction qui servent de variable d'entrée.
Les valeur par défaut correspondent au valeur des variables globales de même nom figurant dans le neurone. Ainsi, `f "=" f(x"="x,y"="y)`. Ce qui signifie que la valeur de `x` est affectée à la variable `f"."x` et la valeur de `y` est affectée à la variable `f"."y`, avant de lancer le calcul de `f`.
L'appel peut donc être incomplet, et est implicitement complété par un système de coordonnées par défaut. Par exemples `f(y"="gamma)` désignera `f(x, gamma)`, puis `f(x"="lambda)` désignera `f(lambda, y)`, puis `f` désignera`f(x,y)`.
Si la variable `f` possède plusieurs neurones, il faut distinguer autant de fonctions `f` que de neurones à l'aide de formes d'appel différentes. On parlera des fonctions `f(".")`, `f(".,.")`, `f["."]`, `f[".,."]`, `f"<.>"`, `f"<.,.>"`,.... Et la complétion d'appel sera toujours unique selon l'ordre d'évocation des neurones et les variables d'appel évoquées. Considérons par exemple les deux neurones `f"←"(x,u,v)` et `f"←"(x,z)` évoqués dans cet ordre. L'expression `f(x"="a)` désignera `f(a,z)` et non `f(a,u,v)` car le contexte précise le système de coordonnée par défaut en cours, en ce référant au dernier neurone évoqué, des références qui s'emboitent..., faisant que `f(u"="b)` désigne `f(x,b,v)`.
On définit l'union disjointe `"⊎"` comme suit : L'union disjointe `A"⊎"B` retourne l'ensemble union de `A` et de `B`, et affirme que `B` est disjoint de `A`. Le symbole `"⊎"` représente une union qui se comporte comme une addition puisque les ensembles sont disjoints.
On définit la différence incluse `"⨺"` comme suit : La différence incluse `A"⨺"B` retourne l'ensemble des éléments de `A` qui ne sont pas dans `B`, et affirme que `B` est inclus dans `A`. Le symbole `"⨺"` représente une différence symétrique qui se comporte comme une soustraction puisque l'ensemble à retirer est bien inclus.
De telles expressions désignent donc à la fois un ensemble, et une proposition logique. Et dès qu'elles sont présentes dans une proposition, elles complètent celle-ci par conjonction. Ainsi, la proposition `E "=" A"⊎"B` signifie que `E"="A "∪" B` et que `A"∩"B"="Ø`. La proposition `E "=" A"⨺"B` signifie que `E"="A "△" B` et que `B"⊆" A`.
Pour exprimer ces équivalences sous forme d'une formule, on est obligé de s'élever d'un niveau de langage pour pouvoir manipuler les formules comme des arguments d'une formule plus générale. Cela se fait en utilisant le méta-opérateur d'équivalence `color(red)(<=>)` ou en utilisant l'expression littérale « si et seulement si ». Les opérations logiques sont qualifiées de méta dans ce langage de niveau supérieur, et se note en rouge ou en utilisant leur forme d'expression littérale. Elles sont de priorité syntaxique inférieure aux opérations logiques non-méta. Puis par soucis de lisibilité on met les conjonctions de propostions sous forme de vecteur. Ainsi nous avons :
`E "=" A"⊎"B color(red)(<=>) ((E"="A "∪" B),(A"∩"B"="Ø))`
`E "=" A"⨺"B color(red)(<=>) ((E"="A "△" B),(B "⊆" A))`
L'ordre des priorités syntaxiques des opérations est le suivant, du plus prioritaire au moins prioritaire :
`∗` |
`×` |
`+` |
`→` |
`↦` |
`⩽` |
`=` |
`∈` |
` "ou" ` |
` "et" ` |
`=>` |
`<=>` |
Les quantificateurs `AA, EE` interviennent pour déclarer de nouvelles variables. Chaque quantificateur ouvre un bloc dans lequel le langage est augmenté de la variable déclarée par le quantificateur. La portée du quantificateur s'étend jusqu'à une parenthèse englobante ou jusqu'au bout de la formule, et forme un bloc. Si la variable créée existe déjà, alors celle-ci est masquée par la nouvelle variable sur toute la portée du quantificateur c'est à dire dans le bloc correspondant. Et les blocs s'emboitent comme des poupées Russe.
Le quantificateur `EE"!"` signifie « il existe un et un seul élément ». Considérons la proposition logique suivante où `P(".")` est un prédicat unaire quelconque :
`EE"!"x, P(x)`
Cette proposition signifie littéralement : Il existe un unique élément `x` tel que `P(x)`. Cette proposition est équivalente à la proposition suivante :
`EEx, P(x) "et" (AAy, P(y) => y"="x)`
En mettant la conjonction sous forme de vecteur, la proposition se réécrit comme suit :
`EEx"," ((P(x) ),( AAy"," P(y) => y"="x) )`
s'il existe une distinction bien établie entre un type d'élément et un type d'ensemble d'éléments du type en question, alors il est possible d'adopter une convention unifiant les ensembles singleton avec leurs éléments. Autrement dit, on autorise la conversion implicite dans les deux sens, entre élément et singleton contenant l'élément en question. Par exemple si `A` est un ensemble et si `a,b,c` sont des éléments :
`{b}=b`
`A "∪" {b} = A "∪" b`
`{a,b,c}"△"{a,c} = b`
S'il existe une distinction bien établie entre les éléments d'un anneau et les sous-ensembles de l'anneau. Une relation d'ordre entre éléments, que l'on déclare entre un élément et un ensemble signifie que l'élément en question est en relation d'ordre avec tous les éléments de l'ensemble. Et si on déclare cette relation entre un ensemble et un autre ensemble, cela signifie que chaque élément du premier ensemble est en relation d'ordre avec tous les éléments du second ensemble :
`x"⩽"A <=> AAa"∈"A, x"⩽"a`
`A"⩽"B <=> AAa"∈"A, AAb"∈"B, a "⩽"b`
Etant donné un ensemble `A` et une application `f` de domaine couvrant `A`. On note `f(A)` l'ensemble image de `A` par `f`, c'est à dire l'ensemble des éléments images d'au moins un élément de `A` par `f`.
La définition se simplifie :`f(A) = {x "/" EEa "∈" A, x"="f(a)}`
`f(A) ={f(a) "/" a "∈" A}`
Classiquement `f(A)` s'appelle l'image directe de `A` par `f`, mais il n'est pas judicieux d'utiliser ce qualificatif, car il est judicieux de le réserver pour indiquer l'injectivité de `f` restreint à `A`, et qui fait de `f|_A` un membre de la famille des opérations directes.
Lorsque la fonction restreinte à l'ensemble `A` est injective c'est à dire si chaque élément de `f(A)` s'écrit sous forme d'une image d'élément de `A` selon `f` de façon unique, alors on qualifie l'application de `f` sur `A` de directe, l'application restreinte à `A`, notée `f|_A`, est injective et on note l'application sur `A` en mettant le symbole d'injectivité `↪` au dessus de l'application :
`overset(↪)(f)(A)`
Une telle expression désigne donc à la fois un ensemble `overset(↪)(f)(A) "=" f(A)`, et une proposition logique :
`overset(↪)(f)(A) color(red)(<=>) f"|"_A tt"est injective"`
`overset(↪)(f)(A) color(red)(<=>) AAx"∈"f(A),EE"!"a"∈"A,f(a)"="x"`
`overset(↪)(f)(A) color(red)(<=>) AA(x,y)"∈"A^2,f(x)"="f(y) => x"="y`
`E"="f(A) color(red)(<=>) ( (AAa "∈" A"," f(a) "∈" E), (AAx "∈" E"," EEa "∈" A"," x"="f(a) ))``E"="overset(↪)(f)(A) color(red)(<=>) ((AAa "∈" A"," f(a) "∈" E), (AAx "∈" E"," EE"!"a "∈" A"," x"="f(a) ))`
Etant donné deux ensemble `A` et `B` et une application `f` binaire de `A"×"B"→"C`. L'application prend comme arguments d'entrée un élément de `A` puis un élément de `B` dans cet ordre. Mais elle peut être perçue comme une application unaire prenant comme élément d'entrée un couple `(a,b)` appartenant à `A"×"B`. On note cette identité comme suit :
`f("("a,b")") = f(a,b)`
Les fonctions `f(".")` et `f(".,.")` sont similaires, seul change leur mode d'entrée et leur type d'argument. L'une prend un élément d'entrée qui est un couple, l'autre prend deux éléments d'entrée. L'ensemble image de `A"×"B` par `f` est l'ensemble des éléments images d'au moins un couple d'éléments de `A"×"B` par `f`. On le note de deux façons possibles, par `f(A"×"B)` ou bien par `f(A,B)`. De la même façon, on peut désigner `A"×"B` par `(A,B)`, un couple de deux ensembles qui peut être converti en l'ensemble des couples `A"×"B`.
La définition se simplifie :`f(A,B) = {x "/" EE(a,b)"∈" A"×"B, x"="f(a,b)}`
`f(A,B) ={f(a,b) "/" a "∈" A, b"∈" B}`
Notez que grace aux conversions implicites et autorisées :
`(A,B)=A"×"B`
`(A,e)=A"×"e=A"×"{e}`
`(e,B)=e"×"B={e}"×"B`
`(a,b)=a"×"b={a}"×"{b}``f(A,B)=f(A"×"B)`
`f(A, e)=f(A, {e})=f(A"×"{e})=f(A"×"e)`
`f(e,B)=f({e},B)=f({e}"×"B)=f(e"×"B)`
`f(a,b)=f({a},{b})=f({a}"×"{b})=f(a"×"b)`
L'application binaire peut possèder une syntaxe centrée c'est à dire correspondre à une opération tel que `x"+"y=f(x,y)`. Nous avons alors les expressions ensemblistes suivantes :
`A+b = {a"+"b "/" a "∈" A}`
`a+B = {a"+"b "/" b "∈" B}`
`A+B = {a"+"b "/" (a,b) "∈" A"×"B}`
Lorsque la fonction restreinte à l'ensemble `A"×"B` est injective c'est à dire si chaque élément de `f(A"×"B)` s'écrit sous forme d'une image d'élément de `A"×"B` selon `f` de façon unique, alors on qualifie l'application de `f` sur `A"×"B` de directe, l'application restreinte à `A"×"B`, notée `f|_(A"×"B)`, est injective et on note l'application sur `A"×"B` en mettant le symbole d'injectivité `↪` au dessus de l'application :
`overset(↪)(f)(A,B)`
Une telle expression désigne donc à la fois un ensemble `overset(↪)(f)(A,B) = f(A,B)`, et une proposition logique :
`overset(↪)(f)(A,B) color(red)(<=>) f"|"_(A"×"B) tt"est injective"`
`overset(↪)(f)(A,B) color(red)(<=>) AAx"∈"f(A,B),EE"!"(a,b)"∈"A"×"B,f(a,b)"="x"`
`overset(↪)(f)(A,B) color(red)(<=>) AA(a,a’,b,b’)"∈"A^2"×"B^2, f(a,b)"="f(a’,b’) => (a, b)"="(a’,b’)`
`E"="f(A,B) color(red)(<=>) ( (AA(a","b) "∈" A^2"," f(a","b) "∈" E), (AAx "∈" E"," EE(a","b) "∈" A"×"B"," x"="f(a","b)) )`
`E"="overset(↪)(f)(A,B) color(red)(<=>) ( (AA(a","b) "∈" A^2"," f(a","b) "∈" E), (AAx "∈" E"," EE"!"(a","b) "∈" A"×"B"," x"="f(a","b)) )`
Et si l'application binaire possède une syntaxe centrée c'est à dire correspond à une opération tel que `x"+"y=f(x,y)`. La notation de l'injectivité de `+` sur `A"×"B` se note d'une façon plus légère en entourant d'un cercle l'opérateur binaire en question ce qui en fait un opérateur directe :
L'expression `A"⊕"B` constitue à la fois une proposition et un ensemble. Exemple : l'expression `{0,1,2,3}"⊕"{0,4,8}` désigne l'ensemble `{0..11}` (où `n..m` désigne la séquence des entiers compris entre `n` et `m` compris) et affirme que chaque élément de cet ensemble se décompose de façon unique en une somme d'un élément de `{0,1,2,3}` et d'un élément de `{0,4,8}`.`A"⊕"B color(red)(<=>) AAx"∈"A"+"B,EE"!"(a,b)"∈"A"×"B, x"="a"+"b`
L'opération d'addition se définit de façon formelle au sein des entiers naturels en constituant un processus de programmation rudimentaire.
Afin de généraliser le concept d'addition, pour l'appliquer à des domaines beaucoups plus vaste que les seuls entiers, on propose une définition qui n'est plus programmative mais axiomatique. Le mathématicien généralise le concept d'addition en restreignant la compréhension du concept, en ne retenant que quelques propriétés propres à l'addition, pour ainsi la redéfinir de façon plus générale. Et il ne retient comme définition, que le seul fait de pouvoir s'effectuer dans n'importe qu'elle ordre sans que cet ordre n'ai d'influence sur le résultat. Ainsi, la définition politique de l'addition, en fait une opération notée `"+"` s'appliquant à un sac d'arguments que l'on note comme suit :
`+"⟅"a,a,b"⟆" = a"+"a"+"b`
La structure induite par cette opération s'appelle un demi-groupe commutatif. Nous l'appellerons simplement une structure d'addition. Une opération d'addition est donc par définition une opération associative, commutative, et notée par défaut `"+"`. Ces conditions sont nécessaires et suffisantes pour pouvoir ajouter des éléments sans que l'ordre dans lequel s'effectue les opérations n'ait d'importance. La théorie de la structure d'addition comprend 2 axiomes :
`sf"Addition"("+") <=> AAxAAyAAz, ( ( (x"+"y)"+"z = x"+"(y"+"z)),( x"+"y=y"+"x))`
Puis on remarque que quelque soit un demi-groupe commutatif, on peut toujours ajouter un nouvel élément noté `0` et dénommé zéro qui jouera le rôle d'élément neutre de l'addition. On obtient alors une structure de monoïde commutatif contenant la structure de demi-groupe précédente. Comme il est toujours possible d'ajouter un élément neutre sans remettre en cause les principes initiaux, le choix politique d'intégrer le zéro dans la définition de l'addition dans sa conception la plus générale s'est plus ou moins imposé, et cela suscite les mêmes objections que celles engendrées par le choix politique d'inclure le zéro parmi les entiers naturels. Nous ne ferons pas ce choix mais nous garderons cette option comme une propriété intrinsèque.
D'autres propriétés peuvent être envisager telles que :
Mais on s'intéressera en premier à une propriété propre au concept de grandeur, qu'est la relation d'ordre totale respectant l'addition.
De même, l'opération de multiplication est au départ de sa conception un processus de programmation rudimentaire s'appliquant aux entiers naturels. Il existe deux niveaux de généralisation, l'une commutative, l'autre plus générale non-commutative que nous n'évoquerons pas. La multiplication commutative reprend les mêmes axiomes que ceux de l'addition en ajoutant la propriété de distributivité par rapport à une seconde opération qui doit être une opération d'addition. C'est ce principe qui fait d'une addition, une multiplication. L'opération est donc associative, commutative, notée `"∗"` ou par absence de symbole simplement en juxtaposant les arguments, et est distributive par rapport à une seconde opération qui doit être une opération d'addition, notée `"+"`.
Sans autre propriété, il n'y a pas de nom classique pour désigner une telle structure. Nous l'appellerons simplement une structure de multiplication. Elle est composé de deux opérations notées `"+"`, `"∗"` associatives et commutatives, et l'opération `"∗"` doit être distributive par rapport à l'opération `"+"`. La théorie de la structure de multiplication comprend 5 axiomes :
`sf"Multiplication"("+","∗") <=> AAxAAyAAz, ( ( (x"+"y)"+"z = x"+"(y"+"z) ), ( (xy)z = x(yz)) , (x"+"y=y"+"x) ,(xy=yx),( x(y"+"z) = xy"+"xz))`
Puis on remarque que quelque soit une structure de multiplication, on peut toujours ajouter un nouvel élément noté `0` et dénommé zéro qui jouera le rôle d'élément neutre pour l'addition et qui jourera le rôle d'élément absorbant pour la multipication. On obtient alors une structure de pseudo-demi-anneau commutatif contenant la structure précédente. De même que pour l'addition, comme il est toujours possible d'ajouter un tel élément `0` sans remettre en cause les principes initiaux, le choix politique d'intégrer le zéro dans la définition de la multiplication dans sa conception la plus générale s'est plus ou moins imposé, et cela suscite les mêmes objections que celles engendrées par le même choix politique d'inclure le zéro parmi les entiers naturels. Nous ne ferons pas ce choix mais nous garderons cette option comme une propriété intrinsèque.
Par contre, l'ajout d'un élément neutre pour la multiplication, notée `1`, est plus compliqué car cette unité `1` va constituer un élément générateur. On simplifit la construction en ajoutant le zéro. L'ajout de cet unité `1` dans le pseudo-demi-anneau va entrainer la création d'une pléthore de nouveaux éléments pour aboutire à une structure de demi-anneau commutatif contenant la structure de pseudo-demi-anneau précédente dans laquel on pourra retirer le zéro. Ce mécanisme d'agrandissement de structure s'appelle une extension élémentaire.
Nous avons une structure de multiplication `M` quelconque dans laquelle on ajoute le zéro avec son comportement décrite par les deux axiomes `AAx, x"+"0"="x` et `AAx, x"∗"0"="0`, et on obtient un pseudo-demi-anneau commutatif quelconque noté `M[0]` où le choix du symbole `0` correspond à l'ajout implicite des axiomes `AAx, x"∗"0"="0` et `AAx, x"∗"0"="0`.
`M[0]=M"⊎"{0}`
Et on ajoute un nouvel élement noté `1`, qui sera l'élément neutre de la multiplication, c'est à dire que l'on ajoute à la théorie de la structure l'axiome `AAx, x"∗"1"="x`, afin de construire une structure de demi-anneau commutatif. Le nouvel élément noté `1` va engendrer à l'aide des opérateurs et éléments de `M[0]`, une pléthore de nouveaux inconnus susceptibles de constituer de nouveaux éléments dans la structure résultante notée `M[0,1]` où le choix du symbole `1` correspond à l'ajout implicite de l'axiome `AAx, x"∗"1"="x`. Cette opération s'appelle une extension élémentaire. La théorie de la structure de demi-anneau commutatif comprend 8 axiomes :
`sf"Demi-anneau commutatif"("+",0,"∗",1) <=> AAxAAyAAz, ( ( (x"+"y)"+"z = x"+"(y"+"z) ), ( (xy)z = x(yz)) , (x"+"y=y"+"x) ,(xy=yx),( x(y"+"z) = xy"+"xz), (x"+"0=x),(0x=0),(1x = x))`
Par construction `M[0]` est inclus `M[0,1]`. La théorie du demi-anneau va nous permettre de déterminer les formes générales que peuvent prendre un élément de `M[0,1]`. Tout d'abord le demi-anneau engendré par le nouvel élément `1` et les opérations `"+" ,"∗"` se note `"<"1, "+" ,"∗>"` et vaut :
`"<"1, "+" ,"∗>" = "{"1, 1"+"1, 1"+"1"+"1, ..., overset(n sf"fois")(overbrace(1"+"1"+"..."+"1)), ... "}"`
Cela vaut une réplique de l'ensemble des entiers naturels non-nuls. On simplifie le problème en ajoutant le zéro :
`"<"0, 1, "+" ,"∗>" = " {"0, 1, 1"+"1, 1"+"1"+"1, ..., overset(n sf"fois")(overbrace(1"+"1"+"..."+"1)), ..."}"`
Cela vaut une réplique de l'ensemble des entiers naturels.
`"<"0, 1, "+" ,"∗>" = NN`
`M[0]` et `NN` et les opérations `"+" ,"∗"` engendre le demi-anneau `M[0,1]` ce qui se note :
`"<"M[0],NN,"+" ,"∗>" = M[0,1]`
On peut donc par un procédé constructif explorer toutes les formes que peuvent avoir les éléments du demi-anneau `M[0,1]`. À la première étape de construction, un élément de `M[0,1]` peut être un élément de `M[0]` ou un élément de `NN`. Cela constitue 2 formes : `M[0], NN`. Rappelons que l'élément absorbant, `0`, appartient à `M[0]` et aussi à `NN`, que l'élément neutre de la multiplication, `1`, n'appartient qu'à `NN`. À la seconde étape, chacune de ces formes peut être soit additionnée à un élément de `M[0]` ou additionnée à un élément de `NN` ou multipliée par un élément de `M[0]` ou multipliée par un élément de `NN`. Cela aboutie à la seule forme `M[0]+NN`.
`M[0,1] = M[0]+NN`
On veut savoir si la somme en question est directe, c'est à dire si la décomposition est unique, autrement dit si :
`AA(b,b’) "∈" B^2, AA(n,n’) "∈" NN^2, b"+"n"="b’"+"n’ => (b"="b’ "et" n"="n’)`
L'extension élémentaire est choisie la plus libre possible, c'est pourquoi la question se reformule en « Est-ce que l'affirmation de l'unicité entraine une contradiction ? » La réponse étant non, la somme est bien directe :
`M[0,1] = M[0]⊕NN`
Ce qui signifie que les éléments de la structure de demi-anneau se développent de façon unique en la somme d'un élément du pseudo-demi-anneau et d'un entier naturel.
`M[1] = (M[0] ⊕ NN) ⨺ {0}`
L'extension élémentaire du pseudo-demi-anneau commutatif par l'ajout d'un élément neutre `1` de la multiplication correspond à une union libre du pseudo-demi-anneau commutatif `M[0]` et du demi-anneau `NN` en unifiant leur `0`, leur addition `+` leur multiplication `"∗"`, et en quotientant par les théories suivantes : `sf"Multiplication"("+","∗")` et `AAx, 0x"="0` et `AAx, 1x"="x`.
On entend par grandeur, des éléments qui peuvent toujours être comparés entre eux, qui peuvent s'ajouter entre eux dans n'importe quel ordre sans que l'ordre n'ait d'influence sur le résultat, et tel que l'ajout d'une grandeur produise toujours une grandeur plus grande, et qui peuvent ainsi servir d'indicateur et de compte...., sans doute le mal de notre siècle...., de vouloir tout comparer, tout mesurer, tout comptabiliser.
L'ensemble des grandeurs est donc muni d'un ordre totale noté `"⩽"`, d'une opération d'addition notée `"+"` qui est nécessairement associative et commutative afin que la sommation ne dépendent pas de l'ordre dans lequel elle s'effectue. Et l'addition ne doit permettre que l'accroissement stricte des gandeurs, c'est à dire :
`AAxAAy, x<x"+"y`
La structure induite par cette opération s'appellera une structure de grandeur. La théorie de la structure de grandeur comprend 8 axiomes :
`sf"Grandeur"("+","⩽") <=> AAxAAyAAz, ( ((x"+"y)"+"z = x"+"(y"+"z)) , (x"+"y=y"+"x) , (x⩽x"+"y) , (x ≠ x"+"y) , ((x"⩽"y "et" y"⩽"z) => x"⩽"z ) , ((x"⩽"y "et" y"⩽"x) => x"="y ) , (x"⩽"x) , (x"⩽"y "ou" y"⩽"x) )`
Notez que la définition de la grandeur ne donne aucun moyen pour déterminer une unité de grandeur. En économie, c'est une caractéristique d'une monnaie sans étalon.
---- 25 décembre 2021 ----
La relation d'ordre totale respectant l'addition entraine sur la structure d'addditon la propriété de simplification :
`AAxAAyAAz, x"+"z"="y"+"z => x"="y`
Cela se démontre par l'absurde. Supposons qu'il existe un contre exemple, `x"≠"y` et `x"+"z"="y"+"z`. Alors soit `x"<"y` ou `y"<"x`. Et dans les deux cas, la relation d'ordre respectant l'addition, on en déduit que `x"+"z"<"y"+"z` ou `y"+"z"<"x"+"z` ce qui contredit l'hypothèse `x"+"z"="y"+"z`
`sf"Addition croissante "("+","⩽") <=> AAxAAyAAz, ( ((x"+"y)"+"z = x"+"(y"+"z)),(x"+"y=y"+"x),(x"⩽"y => EEg"," x"="y"+"g),((x"⩽"y "et" y"⩽"z) => x"⩽"z),((x"⩽"y "et" y"⩽"x) => x"="y),(x"⩽"x),(x"⩽"y "ou" y"⩽"x) )`
L'ajout du zéro fait aparaitre les notions de valeur positives, de valeur négative, de signe, et de grandeur. Une grandeur et une valeur positive non-nulle. La sous-structure des valeurs positive non-nulles s'appelle la structure des grandeurs, Et celle-ci se définit également axiomatiquement, en remplaçant la définition de l'ordre et le respect de l'ordre par la définition de l'ordre égale au préordre associé à l'addition, et la propriété supplémentaire qui en fait un ordre
`AAxAAy, x"⩽"y => EE z, x"+"z"="y`
Dans un demi-anneau ordonné, sous entendu totalement ordonné, les éléments sont appelés les valeurs. Les éléments non-nuls sont appelés les grandeurs.
S'il existe une distinction bien établie entre les éléments d'un demi-anneau `A` et les sous-ensembles de `A`. Si `x` est un élément du demi-anneau, et `E` est un sous-ensemble de ce demi-anneau. On donne une signification particulière à l'égalité entre un élément et un ensemble. Elle signifie que l'élément en question appartient à l'ensemble en question :
`x"="E <=> x"∈"E`
La proposition `x"="E` peut se réécrire en `x"="0"+"E` et nous dirons que `x` est égale à `0` modulo `E`. Cela signifie que `x` est égale à zéro à l'ajout près d'un élément de `E`. Considérons deux éléments `x` et `y` du demi-anneau, et un sous-ensemble `E` de ce demi-anneau. On dira que `x` est égale à `y` modulo `E` si et seulement si `x` est égale à `y` à l'ajout près d'un élément de `E`
`x"="y"+"E <=> x"∈" {y"+"e "/" e"∈" E}`
`x"="y"+"E <=> EEe"∈"E, x"="y"+"e`
C'est la définition d'une égalité approximative où l'approximation en quetion est encadrée précisément par un ensemble `E`.
Si le demi-anneau est ordonné, sous entendu totalement ordonné, les éléments supérieurs ou égal à zéro sont dits positif, et les éléments inférieurs ou égal à zéro sont dits négatifs. Le zéro est le seul élément à la fois positif et négatif.
On définit une division générale basée sur un ensemble, et qui correspond à la selection d'un élément dans cet ensemble. Le reste de `x` modulo `E` se définit comme étant le plus petit élément positif `r` telle que `x` soit égale à `r` modulo `E`, et se note `x "mod" E`. Tandis que la selection faite par `x` dans l'ensemble `E`, qui se note `x "seuil"E`, se définit comme étant le plus grand élément de `E` inférieur ou égale à `x`.
`x "mod" E ="min"{r "/" r"⩾"0, x"="r"+"E}`
`x "seuil" E = "max"{e "/" e"⩽"x, e"∈"E}`
`(x "seuil" E) + (x "mod" E) = x`
Grâce à la relation d'ordre totale, il n'y a pas besoin de sthasme pour définir la division euclidienne dans le demi-anneau ordonné.
La division de x par y est égale au seuil de x dans yA divisé par y. La division est possible puisqu c'est un multiple de y, et elle est unique à cause de l'ordre.
---- 24 décembre 2021 ----
Pour indiquer que deux entiers `x` et `y` ont même reste de division par `n`, on dit classiquement que `x` est égal à `y` modulo `n`, et il faut entendre que `x` est égal à `y` modulo `nZZ`, ce qui s'écrit :
`x=y+nZZ`
S'il existe une distinction bien établie entre les éléments d'un anneau et les sous-ensembles de l'anneau. Une relation d'ordre entre éléments, que l'on déclare entre un élément et un ensemble signifie que l'élément en question est en relation d'ordre avec tous les éléments de l'ensemble. Et si on déclare cette relation entre un ensemble et un autre ensemble, cela signifie que chaque élément du premier ensemble est en relation d'ordre avec tous les éléments du second ensemble :
`x"⩽"A <=> AAa"∈"A, x"⩽"a`
`A"⩽"B <=> AAa"∈"A, AAb"∈"B, a "⩽"b`
Dans un anneau ordonné (sous entendu totalement ordonné), les éléments sont appelés les valeurs. Les éléments plus grand ou égaux à zéro sont appelés les valeurs positives. Les valeurs positives non nulles sont appelées les grandeurs. Les éléments plus petit ou égaux à zéro sont appelés les laleurs négatives. La seule valeur à la fois positive et négative est zéro. Les valeurs négatives non-nulles sont appelées les grandeurs négatives.
On entend par valeur des éléments qui peuvent être comparés entre eux, et s'ajouter entre eux dans n'importe quel ordre sans que l'ordre n'est d'influence sur le résultat, qui peuvent ainsi servir d'indicateur et de compte...., sans doute le mal de notre siècle...., de vouloir tout comparer, tout mesurer, tout comptabiliser.
L'ensemble des valeurs est donc muni d'un ordre totale noté `⩽`, d'une opération d'addition notée `+` qui est nécessairement associative et commutative afin que la sommation ne dépendent pas de l'ordre dans lequel elle s'effectue, auquel on ajoute un élément neutre noté `0`. Et l'addition doit respecter l'ordre `⩽`. Cela constitue 8 axiomes :
`AAxAAyAAz,`
`(x"+"y)"+"z = x"+"(y"+"z)` Associatif `x"+"y=y"+"x` Commutatif `x"+"0 =x` Neutre `x"⩽"y "et" y"⩽"z => x"⩽"z` Transitif `x"⩽"y "et" y"⩽"x => x"="y` Antisymétrique `x"⩽"x` Réflexif `x"⩽"y "ou" y"⩽"x` Odre total `x"⩽"y => x"+"z "⩽" y"+"z` Respect de l'ordre
Une grandeur et une valeur non-nulle. Notez que la définition de la valeur ne donne aucun moyen pour déterminer une unité de valeur. En économie, c'est une caractéristique de la monnaie sans étalon.
---- 23 décembre 2021 ----
L'approche constructiviste présente la théorie des éléments calculables comme une génèse. Au début, il y a l'unité, notée `1`, que l'on peut additionner librement avec elle-même, grace à une addition notée `"+"` posée par principe commutative et associative, conditions nécessaires pour que l'ordre dans lequel s'effectue les additions n'influe pas sur le résultat. Additionner librement `1` à lui-même signifie que `1`, `1"+"1`, `1"+"1"+"1`, ... constituent des éléments nécessairement distincts dans le mesure où cela est possible. C'est le concept de construction libre, la fonction binaire que constitue l'opérateur `"+"` possède un graphe qui s'étend au grès des nécessités de la façon la plus libre possible, en créant à chaque composition de nouvelle variable. L'inconvénient de cette methode et qu'elle ne garantie pas que la théorie obtenue soit complète.
L'unité `1` munie d'un opérateur constructeur associatif commutatif libre `+`, engendre le semi-groupe monogène libre qui est le nom algébrique des entiers naturels non-nuls.
La notation d'origine de l'ensemble des entiers naturels proposée par Richard Dedekind en 1888 excluait le zéro. Il est judicieux de réintroduire cette notation par le biais d'un nouveau symbole `sfN`, non composé, comme il convient pour désigner un fondement. Ainsi `sfN` désignera le semi-groupe monogène libre des entiers naturels non-nuls tandis que `bbbN` désignera le monoïde monogène libre des entiers naturels.
La construction des entiers `sfN` défini un ordre naturel noté `⩽` qui respecte l'addition. La multiplication notée `∗` se programme à partir de l'addition. Et on démontre que la multiplication est commutative, associative et distributive par rapports à l'addition. Puis on démontre que l'existence d'un ordre totale repsectant l'addition entraine la liberté de la structure évoqué prédédement. On requalifie ainsi la structrue de semi-groupe monogène ordonné qui est le deuxième nom algébrique de `sfN`. La terminologie semi-groupe monogène signifie que la structure est engendré par un élément appelé unité, noté `1`, et par une opération associative et commutatif appelés addition et noté `+`. Et le qualificatif ordonné signifie qu'il y a un ordre totale respectant l'addition. Cette dernière propriété va entrainer que le semi-groupe monogène est libre.
Si on ajoute l'opposé, on obtient l'anneau agène ordonné des entiers relatifs `ZZ`. Si on ajoute l'inverse et le zéro on obtient le demi-corps agène ordonné des rationnels positifs `QQ^"+"`. Et si on ajoute à la fois l'opposé et l'inverse, on obtient le corps agène ordonné des rationnels `QQ`. Ces structures utilisent comme élément générateur l'élément neutre de la multiplication noté `1` qui est déjà déclaré dans la structure. C'est pourquoi elles sont qualifiés d'agène car il n'y a pas d'autre générateur. Et le qualificatif "ordonné" signifie qu'il y existe un ordre totale respectant l'addition :
`AAxAAyAAz,`
`x"⩽"y => x"+"z "⩽" y"+"z`
On en déduit que l'ordre respecte la multipication signée :
`AAxAAyAAz,`
`x"⩽"y "et" z"⩾"0 => x"∗"z "⩽" y"∗"z`
`x"⩽"y "et" z"⩽"0 => x"∗"z "⩾" y"∗"z`
Ainsi l'opposé et l'inverse permettent de construire les rationnel à partir des entiers naturels non-nuls. Par ailleurs, les rationnels admettent une forme normale :
`AAr "∈" QQ, EE!i "∈" ZZ, EE!j "∈" sfN, r "=" i"/"j "et" sf"pgcd"(i,j)"="1`
La structure des rationnels est directement désignable à partir de la structure des entiers naturels non-nuls, c'est pourquoi il est souvent judicieux de choisir `sfN` comme structure en cours par defaut au lieu de `QQ` tout en utilisant les opérations sur `QQ`. Ainsi chaque nouvel élément déclaré sera par défaut élément de `sfN`.
On construit des réels calculables à partir du corps agène ordonné, `QQ`, en utilisant les suites de Cauchy. Ce sont les suites de rationnels intrinsèquement convergentes. Puis comme nous n'utilisons pas l'axiome du choix, on se restreint aux suites calculables de rationnels intrinsèquement convergentes. On remplace ainsi, l'infinité de choix nécessaire pour choisir chaque terme rationnel de la suite, par le choix juste d'une fonction `a` de `sfN"→"QQ` qui doit être programmable, d'arrêt sûr et de taille finie, énumérant les termes rationnels de la suite.
`(a_1,a_2,a_3,...) = (a_i)_(i in sfN)`
On se place dans `sfN` c'est à dire que chaque nouvel élément déclaré sera par défaut élément de `sfN`. La suite est intrinséquement convergente si et seulement si :
`AA n,EEm,AA i"⩾"m,AAj"⩾"m, |a_i-a_j|"<"1/n`
Une telle suite désigne alors un réel calculable que l'on note `ccR(a_i)_(i in sfN)`. Et ces réels peuvent s'additionner, se multiplier, et se comparer :
`ccR(a_i)_(i in sfN) + ccR(b_i)_(i in sfN) = ccR(a_i"+"b_i)_(i in sfN)`
`ccR(a_i)_(i in sfN)ccR(b_i)_(i in sfN) = ccR(a_ib_i)_(i in sfN)`
`ccR(a_i)_(i in sfN) = ccR(b_i)_(i in sfN) <=> AA n, EEm,AA i"⩾"m,AAj"⩾"m, |a_i-b_j|"⩽"1/n`
`ccR(a_i)_(i in sfN) < ccR(b_i)_(i in sfN) <=> EEm,AA i"⩾"m,AAj"⩾"m, a_i"<"b_j`
La structure `RR` ainsi obtenu s'appelle la complétion de `QQ` et constitue le corps agène ordonné complet des réels.
On se place dans le corps des réels. Un ensemble infini de réels, noté `E`, bornée, c'est à dire minoré par un réel et majoré par un réel, admet nécessairement au moins un réel servant de points de fuite. Par définition, un réel qui constitue un point de fuite peut être approché aussi finement que l'on veut en choisissant un réel de `E` distinct du réel en question. L'union de `E` et de l'ensemble de ses points de fuites forme la complétion de `E` notée `barE`, appellée aussi l'adhérence de `E`. L'ensemble des points de fuites est désigné par le symbole `"leak"`.
Cela s'écrit formellement comme suit :
`"leak"(E) = {x "/" AAn, EEy "∈" E, 0"<"|y-x|"⩽" 1/n}`
`bar E = E uu "leak"(E)`
`bar E ={x "/" AAn, EEy "∈" E, |y-x|"⩽" 1/n}`
Si `E` est énuméré, c'est à dire s'il est de la forme suivante :
`E = {e_i}_(i in sfN)`
Alors la fuite de `E` se note comme suit :
`"leak"(E) = underset(i->oo)"leak" e_i`
Sa définition formelle est :
`x "∈" underset(i->oo)"leak" e_i <=> AA n, EEi, |x-e_i|"⩽"1/n`
Remarquez que l'ordre des éléments de la suite `e_0`, `e_1`, `e_2`, ... peut être changé, et que l'on peut enlever n'importe quelle partie finie de `E`, sans que cela ne change la fuite de `E`. Puis si la fuite de `E` est un singleton `{r}`, C'est à dire s'il n'y a qu'un seul point de fuite, alors cela signifie que la suite converge vers le réel `r`, qui est appelé la limite et qui est désigné par :
`lim_(i->oo) e_i`
Remarquez alors, qu'une telle expression désigne donc à la fois un réel et une proposition logique. Et dès qu'elle est présente dans une proposition, elle complète celle-ci par conjonction. Ainsi, nous avons les propriétés suivantes qui servent de définition de la limite :
`x "=" lim_(i->oo) e_i color(red)(<=>) {x} = underset(i->oo)"leak" e_i`
`x "=" lim_(i->oo) e_i color(red)(<=>) AA n, EEm,AAi"⩾"m, |x-e_i|"⩽"1/n`