Un fondement mathématique, pour être incontestable à notre époque, doit reposer sur un mécanisme parfait... au sens de la mécanique classique. Les mathématiques sont un jeu de construction, un jeu de légo, où chaque pièce s'encastre exactement dans un édifice servant de démonstration ou bien construisant un modèle. Rien ne relève du mystère, tout est trivial..., c'est l'aspect exacte de la science mathématique. Le démonstrateur n'est finalement qu'une machine, une machine idéale, composée de rouages parfaitement emboités et sans aucun jeu. Ces machines sont décrites à l'aide d'un langage formel. Le raisonnement, à notre ère, pour être incontestable doit pouvoir s'effectuer mécaniquement, comme un programme informatique ou une machine idéale en mécanique classique.
Tout est langage et on s'inspire de la théorie de l'information pour discourir sur la genèse de la logique. La génèse s'appuit sur la programmation qui est le véritable fondement de la logique. Les mécanismes de typage par inférance que l'on trouve dans les langages informatiques sont formalisés et introduit dans le langage mathématique, et seront intensément utilisés. On construit les structures de la même façon que l'on fait de la programmation informatique.
Le langage ne fait que désigner et transmettre des informations. On opére donc une distinction entre le signifiant et le signifié, entre le symbole et l'objet qu'il désigne, entre la théorie et la propriété constatée dans le modèle, entre la théorie globale et le modèle qu'elle construit.
Nous procédons étape par étape pour que chaque choix puisse découler de source, et on décrit une mathématique qui donne à ces opérateurs, ces prédicats et ces procédures un sens plus profond mais toujours exacte c'est à dire une sémantique formelle. Syntaxe et sémantique constituent alors deux niveaux de langages formels, l'un utilisé pour construire les modèles (la sémantique), l'autre utilisé pour construire les théories et les démonstrations (la syntaxe). La sémantique décrit formellement les modèles. Elle décrit les règles de construction des modèles. Tandis que la syntaxe décrit formellement les théories. Elle décrit les règles de déduction.
Tout modèle possède une théorie globale qui l'engendre mécaniquement par une récursivité qui peut être simple et générale. Et selon les précepts élémentariens, la garanti de cohérence du système est reportée dans le processus constructif auquel nous nous soumettons.
La construction des nombre entiers, nous fait ainsi replonger dans la génèse de la logique et de ses principes fondateurs que sont la liberté des élément et l'égalité ou la relation d'équivalence entre éléments. On se propose de lui adjoindre un autre principe tout aussi fondamental qu'est celui de l'indépendance, et qui va nous faire découvrir la logique respectueuse de l'indépendance.
En privilègiant une approche constructive, on s'écartera du point de vue catégoriel logique, pour un point de vue davantage combinatoire et physique. Les élémentariens rejètent l'axiome du choix, considèrent inexistant le continuum des nombres réels, et le remplace par une représentation dénombrable en ne retenant que les seuls réels calculables.
Pour éviter l'usage intensif des parenthèses, on fixe un ordre de priorité syntaxique des opérateurs, du plus prioritaire au moins prioritaire :
`"¬"` `"∗"` `+` `"∈"`,`"∉"` `"<","⩽",">","⩾"` `"et", "ou"` `"⊢","⊨"` `"⇒", "⇔"` `"=","≠"` `AA, EE`
Ainsi par exemples, pour tout élément `x,y,z`, pour tout ensemble `E`, pour tout prédicat unaire `A"(.)",B"(.)"`, pour toute théorie `T,S`, et pour tout booléen `P,Q,R`, nous avons :
L'expression `x"∗"y "+" z` signifie `(x"∗"y) "+" z` et non `x"∗"(y"+"z)`
L'expression `AA x, A(x) "⇒" B(x)` signifie `AA x, (A(x) "⇒" B(x))` et non `(AAx, A(x)) "⇒" B(x)`
L'expression `P"et"Q "⇒" R` signifie `(P"et"Q) "⇒" R` et non `P"et"(Q "⇒" R)`
L'expression `P "⇒" Q"ou"R` signifie `P "⇒" (Q"ou"R)` et non `(P "⇒" Q)"ou"R`
L'expression `x "+" y "=" z` signifie `(x "+" y) "=" z` et non `x "+" (y "=" z)`
L'expression `T "⊢" P"ou"Q` signifie `T "⊢" (P"ou"Q)` et non `(T "⊢" P)"ou"Q`
L'expression `T "⊢" P"⇒"Q` signifie `(T "⊢" P)"⇒"Q` et non `T "⊢" (P"⇒"Q)`
L'expression `"¬"x"∈"E` signifie `("¬"x)"∈"E` et non `"¬"(x"∈"E)`
Le produit se note aussi par absence de symbole. Par exemple `xyz = x"∗"y"∗"z`.
On utilise les opérations `"+"`, `"∗"`, indifféremment sur des éléments ou des ensembles d'éléments. Ainsi par exemples, pour un élément `a` et des ensembles `U` et `V`, nous avons :
`a"+"U = {a"+"u "/" u "∈" U}`
`aU = {au "/" u "∈" U}`
`U"+"V = {u"+"v "/" u "∈" U, v "∈" V}`
`UV={uv "/" u "∈" U, v "∈" V}`
On identifit les valeurs logiques aux booléens, le vrai est identifié au booléen `1`, le faux est identifié au booléen `0`. Etant donné un prédicat zéro-aire `X`, sa valeur logique est soit `0` ou soit `1`. Mais à cette description nous ajoutons un troisième cas, le cas ou la théorie globale en cours est incomplète pour déterminer `X`, ce qui se note `X"="oo`, l'infini de Turing.
On utilise une conversion implicite de type transformant les booléans en des entiers et réciproquement selon le type attendu. Le booléen `1` correspond à l'entier `1` et le booléen `0` correspond à l'entier `0`. Ainsi par exemple l'expression entière `(a"="b)"+"(a"="c)"+"(b"="c)` vaut `3` si `a` et `b` et `c` désignent le même élément.
Les 3 théories les plus simples sont : la totologie `"⊤"`, l'antilogie `"⊥"`, et la théorie indécidée `"?"`. Nous avons : `"⊤="1`, `"⊥="0`, `"?="oo`.
On adopte les conventions suivantes : Un ensemble de propositions désigne leur conjonction. Et de même, un vecteur de propositions désigne leur conjonction. Par exemple, pour toute variables booléennes `P, Q, R`, nous avons :
L'expression `((P),(Q),(R))` en tant que proposition signifie `P "et" Q "et" R`
De même, l'expression `{P,Q,R}` en tant que proposition signifie `P "et" Q "et" R`
La première structure à la quelle nous nous intéressons est celles des ressources que l'on peut accumuler dans n'importe quel ordre. C'est un ensemble de ressources `D`, et ces ressources appelées éléments peuvent s'ajouter dans n'importe quel ordre. Donc leur somme est associative et commutative. Cela se traduit par le fait que `(D,"+")` est un semi-groupe commutatif. Et nous allons mettre sous forme de fonctions propositionnelles ces différentes propriétés :
`"Associatif"(D,"+")"` `<=>` `AA(a,b,c)"∈"D^3, a"+"(b"+"c) = (a"+"b)"+"c` `"Commutatif"(D,"+")"` `<=>` `AA(a,b)"∈"D^2, a"+"b = b"+"a`
`"Semi-groupe commutatif"(D,"+") <=> (( "Associatif"(D,"+")),("Commutatif"(D,"+")))` `"Semi-groupe commutatif"(D,"+") <=> AA(a,b,c)"∈"D^3 ,((a"+"(b"+"c) = (a"+"b)"+"c),(a"+"b= b"+"a))`
On remarquera qu'il existe un synonyme à la fonction propositionnelle `"Associatif"` qui est la fonction propositionnelle `"Semi-groupe"`.
`"Semi-groupe"(D,"+") <=> "Associatif"(D,"+")`
On remarquera que les fonctions propositionnelles évoquées ci-dessus prennent comme premier argument un ensemble, et comme second argument un opérateur binaire.
L'expression `(D,"+")` désigne une structure composée d'un ensemble `D` et d'un opérateur `"+"` de `D"×"D"→"D`. Si ces deux objets sont connus, alors la structure est déterminée. Cela explique pourquoi il n'y a pas d'autre indication pour désigner la structure. Et la question de l'engendrement ne se pose pas. La structure est supposée innée.
La définition d'un ensemble n'est pas quelque chose de si bien déterminée qu'on pourrait le croire..., elle fait l'objet de plusieurs théories possibles. Et la problèmatique et reporté ailleurs en choississant des fonctions propositonnelles qui ne définissent pas l'ensemble mais qui le prennent comme argument.
Nous verrons que la structure `(D,"+")` constitue un modèle, un objet plus complet qu'une simple théorie du premier ordre, et dans lequel peuvent se réaliser des théories. Et dans notre exemple, ce modèle satisfait la théorie du premier ordre `"Semi-groupe commutatif"(D,"+")`, ce qui se note :
`(D,"+") ⊨"Semi-groupe commutatif"(D,"+")`
Une redondance apparaît néanmoins dans l'expression `(D,"+")`, car l'opérateur `"+"` est suceptible de transporter l'information qu'apporte le symbole `D` dans l'expression.
La forme la plus générale n'est pas forcement celle que l'on croit. Par exemple, une relation de `A` vers `B` peut sembler plus générale qu'une relation de `A` vers `A`. Hors ce n'est pas vrai. Car chacune de ces deux définitions peut contenir l'autre. Aussi, la plus générale est la plus simple des deux. De par le même raisonnement, un opérateur binaire `"+(.,.)"` est défini de façon la plus générale, comme opérant sur un ensemble pour transformer un couple d'élément de cet ensemble en un élément de cet ensemble. On nomme cet ensemble `"Land"("+")`, et l'opérateur `"+"` est alors une fonction de `"Land"("+")^2→"Land"("+")`.
On adopte le standard suivant pour les opérateurs : Un opérateur `n`-aire `f` possède un ensemble où il opère, noté `"Land"(f)`, et constitue une fonction de `"Land"(f)^n"→Land"(f)`. Pourquoi choississons-nous une fonction et non une application ? Parceque selon les préceptes élémentariens, un opérateur, comme toute construction, est soumis à un processus constructif et peut donc produire en calcul, un infini de Turing, correspondant en logique, à une proposition indécidable. Mais nous en reparlerons plus tard. Avec ce standard, pour tout opérateur `"+"`, nos avons l'égalité des structures suivantes :
`("+") = ("Land"("+"),"+")`
Nous nous plaçons maintenant à l'intérieur de la structure et nous limitons notre vision aux seuls éléments de la structure tout en enlevant toute limite à ces éléments. Aucune frontière n'est évoqué pour ces éléments. La théorie `"Semi-groupe commutatif"("+")` s'applique à tous les éléments.
Le regroupement potentiel de tous les éléments ne constitue pas un ensemble mais un objet plus générale appelé la catégorie des éléments. De même, un opérateur opérant sur tous les éléments et non sur seulement un ensemble d'éléments n'est pas un opérateur mais un objet plus générale appelé foncteur. Cette subtile distinction fait que, tant que l'on n'a pas circonscrit la zone d'opération du foncteur à un ensemble, on a à faire à un objet plus générale et plus simple qu'une structure, qui n'est autre qu'une proposition du premier ordre, mais dont le langage logique peut être éventuellement augmenté d'opérateurs et de prédicats supplémentaires qui sont alors dits libres puisque la proposition ne les mentionne pas.
Pour les élémentariens qui rejètent l'axiome du choix et ainsi la puissance du continu, une telle situation n'existe pas. L'ensemble sous-jacent est engendré au plus par une infinité dénombrable d'éléments ajoutés à la structure par extension élémentaire. Telle la seule potentialité que l'Homme a à sa main. Et c'est le théorème de Löwenheim-Skolem dont nous reparlerons plus tard, qui garantit cela. Délors, il n'est plus nécessaire de faire référence à un ensemble sous-jacent supplémentaire car il existe déjà implicitement.
Et nous définissons d'autres fonctions propositionnelles, de même nom, mais ce différenciant par le types de leurs arguments, et que l'on appel en programmation des fontions overloadées (terme anglais francisée).
`"Associatif"("+")"` `<=>` `AAaAAbAAc, a"+"(b"+"c) = (a"+"b)"+"c` `"Commutatif"("+")"` `<=>` `AAaAAb, a"+"b = b"+"a`
Et il existe un synonyme à la fonction propositionnelle `"Associatif"` qui est la fonction propositionnelle `"Semi-groupe"`.
`"Semi-groupe"("+") <=> "Associatif"("+")`
`"Semi-groupe commutatif"("+") <=> (( "Associatif"("+")),("Commutatif"("+")))` `"Semi-groupe commutatif"("+") <=> AAaAAbAAc,((a"+"(b"+"c) = (a"+"b)"+"c),(a"+"b= b"+"a))`
Le type de l'argument est un opérateur binaire libre. Et l'ensemble sous-jacent par défaut est l'ensemble engendré par emboitement de l'opérateur binaire et des éléments ajoutés et numérotés `NN`, que l'on note `"<+",NN">"`. Mais attention, les entiers ainsi évoqués jouent un autre rôle, celui d'élément libre ou si vous préférer celui d'élément inconnue. C'est ainsi que les élémentariens circonscrivent la structure à un ensemble. Ce point de vue affirme que rien n'est inné ni transcendant, que tout doit être engendré, et par un nombre fini de choix arbitraires (ce qui n'exclus pas l'infini potentiel mais qui exige la calculabilité de toutes les fonctions utilisées).
C'est une autre composante de la structure, qui est sa théorie d'engendrement, qui a pour fonction de circonscrire la structure à un ensemble, et qui fait que la structure est plus riche qu'une simple proposition du premier ordre. Dans le cas classique cette théorie d'engendrement consiste en l'apport de l'ensemble sous-jacent et de l'opérateur générateur, ce qui est représenté par les deux symbôles `(D,"+")`. Autrement dit, la structure est innée.
Dans le cas programmatif cette théorie d'engendrement consiste à définir une structure libre du langage qui désigne tous les éléments de la structure. L'ensemble sous-jacent implicite se nomme `"Self"`.
Les structures correspondent aux modèles décrits dans la théorie des modèles. Une structures comprend un langage et comprend trois théories ; sa théorie du premier ordre écrite dans le langage de la structure, sa théorie d'engendrement qui permet à l'aide de la première théorie de déterminer (voir de les construire) son ensemble sous-jacent et ses opérateurs et prédicats opérant sur cet ensemble sous-jacent, et sa théorie globale qui est la conjonction des deux.
La sémantique décrit formellement les modèles et les règles de construction des modèles (et donc des structures). Tandis que la syntaxe décrit formellement les théories et les règles de déduction.
Une structure est juste un modèle particulièrement simple.
Par principe, la théorie globale d'une structure est égale à la structure. Car tout ce qui permet de construire la structure se trouve dans sa théorie globale et il n'y a rien de plus. Exemple :
`"Semi-groupe monogène"("+",1) <=> ((AAaAAbAAc"," a"+"(b"+"c) = (a"+"b)"+"c),("Self=<+,"1">"))`
La théorie du premier ordre de cette structure est `"Semi-groupe "("+")`
La théorie d'engendrement est `"Self=<+",1">"`
La théorie globale est `"Semi-groupe monogène"("+",1)`
Donc nous pouvons écrire :
`"Semi-groupe monogène"("+",1)⊨"Semi-groupe "("+")`
On décrit formellement la syntaxe et la sémantique des langage logiques du `n`-ième ordre sans utiliser l'égalité. Puis on introduit après coup le prédicat spécial d'egalité qui permet de définir des relations d'équivalences et des structures quotients.
4) Langage logique du premier ordre (présentation)
Un langage logique du premier ordre se définit en présentant une liste d'opérateurs entre braquette `"<"...">"` suivie d'une liste de prédicats entre crochet `{...}`, qui sont les seuls opérateurs et prédicats autorisés par le langage. Conventionellement les opérateurs sont notés en minuscule et les prédicats en majuscule et on ajoute parfois un suffixe indiquant l'arité, `"(.)"` pour unaire, `"(.,.)"` pour binaire, `"(.,.,.)"` pour ternaire, etc..
Nous étudions par exemple les structures de groupes ayant au moins deux éléments `a` et `b` et une partie désignée `A`. Le langage que nous utilisons se présente alors comme suit :
`"<"1,"∗(.,.)", frI"(.)", a, b">" {A"(.)"}`
Et il se présente également par `"<"ccL">" {ccM}` où :
`ccL= {1,"∗", frI, a, b}`
`ccM = {A}`Les symboles `a` et `b` désignent deux éléments du groupe. Le symbole `A` désigne le prédicat d'appartenance à la partie `A`. Aussi, l'expression logique `A(x)` signifie `x"∈"A`, et l'expression logique `"¬"A(x)` signifie `x"∉"A`.
L'expression `"<"ccL">"` désigne la clôture par composition close des éléments et opérateurs de `L`. C'est le domaine de Herbrand. C'est aussi le langage d'opérateurs. Et c'est aussi la structure libre du langage qui en constitue son modèle nu.
Le produit `"<"ccL">" {ccM}`, en notation française, désigne les compositions closes des prédicats appartenant à `ccM` avec des éléments appartenant à `"<"ccL">"`. C'est l'ensemble des littéraux affirmatifs. On appelle cet ensemble, la matrice du langage. Ce sont des cases mémoires qui permettent de construire un modèle de la structure libre, ou plus précisément une instanciation de la structure libre. Chaque littéral affirmatif doit posséder une valeur logique `0` ou `1`, ou l'infini de Turing, `oo`, qu'elle mémorise d'une certaine façon pour construire un modèle de la structure libre.
Ainsi le modèle de la structure libre est défini par ses prédicats qui sont des fonctions calculables de `"<"ccL">"^n"→"{0,1}`, et où l'infini de Turing `oo` désigne un comportement particulier où le calcul de la fonction ne s'arrête jamais c'est à dire où la fonction n'est pas définie. (Remarquer qu'avec cette définition, un modèle peut être volontairement incomplet. Et il ne sera pas pour autant dévalorisé. Il aura le status de modèle autant qu'un autre.)
Puis on ajoutera le prédicat d'égalité qui est un prédicat spécial. Dans les modèles de la structure libre, aucun élément du domaine de Herbrand n'est égal à un autre. Tant que la structure reste libre, le prédicat d'égalité qui est une fonction de `"<"ccL">"^2"→"{0,1}` reste constamment nulle.
5) Langage logique propositionnelle
Le langage propositionnelle se présente par une liste d'inconnus booléens (qui sont des prédicats d'arité zéro). Ce langage contient toutes les combinaisons booléennes utilisant les connecteurs booléens `"¬", "et", "ou", "⇒", "⇔"`, qu'il est possible de faire avec ces inconnus booléens.
On étend ce langage en prenant comme inconnus booléens, les littéraux affirmatifs du langage du premier ordre.
Dans un langage propositionnel de présentation `"<"ccL">" {ccM}`, le domaine de Herbrand qui est la structure libre du langage `"<"ccL">"` contiendra tout puisque le langage propositionnel ne permet pas déclarer de nouveaux éléments. Les opérateurs et prédicats opèrent donc exactement sur la structure libre du langage `"<"ccL">"`. Autrement dit ceux-ci ont des domaines de définition toujours circonscrits aux ensembles de la forme `"<"ccL">"^n` où `n` est l'arité de l'opérateur ou du prédicat concerné.
Voici un exemple de proposition d'ordre zéro, `b b"="1 "et" ab"≠"ba`, qui signifie littéralement « `b` est d'ordre `2` et il ne commute pas avec `a` ».
6) Langage logique du premier ordre
Ce langage comprend des opérateurs et prédicats du premier ordre (d'arité quelconque mais fixe) c'est à dire des opérateurs et prédicats opérant sur des éléments.
Le langage du premier ordre introduit la possibilité de déclarer des éléments anonymes potentiellement nouveaux `x` qu'il quantifie soit existentiellement `EEx` ou universellement `AAx`. Ainsi le langage devient contextuel. C'est à dire qu'une sous-proposition possède maintenant un contexte défini en amont qui précise le langage dans laquelle elle doit être écrite. Et ce langage peut-être augmenté de variables qui constitue autant d'éléments potentiellement nouveaux obtenus par extension élémentaire grace à ces déclarartions.
Dans ce langage contextuel, chaque déclaration de variable quantifiée `AAx` ou `EEx` ouvre un bloc possèdant un contexte qui comprend le langage utilisé augmenté de la variable déclarée. Le langage en cours est celui du bloc parent, enrichie du nouvel élément correspondant à la variable déclarée. Et chaque bloc contient une proposition écrite dans le langage du bloc. On remarquera l'analogie avec des langages de programmations informatiques qui sont des langages contextuels et la façon dont ils sont analysés par les compilateurs et interpréteurs.
Puis toutes ces propositions peuvent se combiner à l'aide des connecteurs booléens pour produire le langage du premier ordre.
Prenons un cas simple où `A` est un prédicat unaire :
`AAx, A(x)` La proposition `AAx, A(x)` se trouve dans le langage initial, et la sous-proposition `A(x)` se trouve dans le langage augmenté de la variable `x`. Tout se passe comme si un élément `x` avait été ajouté au langage, par extension élémentaire. Et il n'y a pas de différence entre une variable quantifiée universel ou une variable quantifiée existentiel pour la sous-proposition puisque cette quantification est placée en dehors de la sous-proposition, parcontre la variable `x` est bien ajouté au langage en tant qu'élément mis à disposition de la sous-proposition.
Dans un langage du premier ordre de présentation `"<"ccL">" {ccM}`, le domaine de Herbrand qui est la structure libre du langage `"<"ccL">"` correspond à ce que le langage peut exprimer, c'est à dire à l'ensemble des éléments calculables par le langage. Or, la logique du premier ordre permet l'extension élémentaire, c'est à dire d'ajouter des éléments anonymes potentiellement nouveaux. Et ces éléments sont nouveaux tant que l'on ne démontre pas le contraire. Il peut donc y avoir d'autres éléments, et ces éléments ne seront donc pas calculables par le langage initial. Ainsi dans le cas général, les opérateurs et prédicats n'opèrent pas que sur la structure libre du langage `"<"ccL">"`, Ils opèrent sur toutes les extensions élémentaires possibles, c'est à dire exactement sur `"<"ccL uu {e_1,e_2,e_3,...}">"` où `e_1,e_2,e_3,...` sont une suite infinie énumérable d'éléments anonymes potentiellement nouveaux. Les démonstrations étant par principe de taille finie, Il n'y a qu'un nombre fini d'extensions élémentaires qui peut y être faite, mais non borné. Cela a quand même pour conséquence un point important de cohérence sur la nature des opérateurs et prédicats, c'est qu'ils ont des domaines de définition toujours circonscrits à des ensembles.
Voici deux exemples de proposition du premier ordre :
La proposition `AAx, (EEy,x"="yy)"⇔"(EEy,x"="yyyy)` signifie littéralement « être un carré est équivalent à être une puissance `4` ».
La proposition `AAxEEy,x"="yy "ou" x"="yyy`, signifie littéralement « tous les éléments sont des carrés ou des cubes ».
On peut étendre ce langage du premier ordre en prenant comme opérateurs et prédicats, ceux engendrés en nombre inifini par des opérateurs et prédicats du deuxième ordre préalablement fixés.
7) Langage logique du second ordre
Ce langage comprend des opérateurs et prédicats du second ordre (de type quelconque) c'est à dire des opérateurs et prédicats opérant sur ou produisant des opérateurs et prédicats du premier ordre et éventuellement des éléments.
Le langage du second ordre introduit la possibilité de déclarer de nouveaux opérateurs `f_(G->G)` quantifiées existentiellement `EEf_(G->G)` ou universellement `AAf_(G->G)` ainsi que de nouveaux prédicats `A_(G->{0,1})` quantifiées existentiellement `EEA_(G->{0,1})` ou universellement `AA A_(G->{0,1})`, et cela avec des arités quelconques. Conventionellement les opérateurs sont notés en minuscule et les prédicats en majuscule et on ajoute un suffixe indiquant le type , `"(.)"` ou `""_(G->G)` pour unaire, `"(.,.)"` ou `""_((G,G)->G)` pour binaire, `"(.,.,.)"` ou `""_((G,G,G)->G)` pour ternaire, ou `""_(G->(G->G))` ou `""_(G->((G,G)->G))` etc..
Puis il convient de donner un sens précis à l'égalité de deux opérateurs de mêmes arité, et à l'égalité de deux prédicats de mêmes arité.
| `f"(.)="g"(.)" <=> AAx, f(x)"="g(x)` | `A"(.)="B"(.)" <=> AAx, A(x)"⇔" B(x)` |
| `f"(.,.)="g"(.,.)" <=> AAxAAy, f(x,y)"="g(x,y)` | `A"(.,.)="B"(.,.)" <=> AAxAAy, A(x,y)"⇔" B(x,y)` |
| `f"(.,.,.)="g"(.,.,.)" <=> AAxAAyAAz, f(x,y,z)"="g(x,y,z)` | `A"(.,.,.)="B"(.,.,.)" <=> AAxAAyAAz, A(x,y,z)"⇔" B(x,y,z)` |
| etc.. |
Puis il convient de donner un sens précis à l'égalité de deux opérateurs de mêmes type, et à l'égalité de deux prédicats de mêmes type.
`f_(G->(G->G))"="g_(G->(G->G))<=> AAxAAy, f(x)(y)"="g(x)(y)`
`A_(G->(G->{0,1}))"="B_(G->(G->{0,1})) <=> AAxAAy, A(x)(y)"⇔" B(x)(y)`
Voici un exemple de proposition du second ordre :
La proposition `AA f"(.)", (AAx AAy,f(xy)"="f(x)f(y)) => EEx, f(x)"="x` signifie littéralement « toute fonction qui respecte le produit possède un point fixe ».
On peut étendre ce langage du second ordre en prenant comme opérateurs et prédicats du second ordre (de type quelconque), ceux engendrés en nombre infini par des opérateurs et prédicats du troisième ordre préalablement fixés.
8) Langage logique du `n`-ième ordre
Ce langage comprend des opérateurs et prédicats du `n`-ième ordre c'est à dire des opérateurs et prédicats opérant sur des opérateurs et prédicats du `(n"-"1)`-ième ordre et éventuellement sur des opérateurs ou prédicats d'ordre inférieurs ou sur des éléments.
Et il introduit la possibilité de déclarer de nouveaux opérateurs du `n`-ième ordre, quantifiées existentiellement `EEccf` ou universellement `AAccf` ainsi que de nouveaux prédicats du `n`-ième ordre `ccA` quantifiées existentiellement `EE ccA` ou universellement `AA ccA`, et cela avec des types quelconques.
Puis l'égalité entre deux mêmes type d'opérateurs est définie de façon analogue à celle entre opérateur du premier ordre de même arité.
Voici un exemple de proposition du troisième ordre :
8) Equivalence de Skolem
9) Equivalence de Herbrand
---- 29 octobre 2019 ----
3.1) Forme normale
Les règles syntaxiques de déduction en logique du premier ordre permettent de transformer toutes propositions du premier ordre en une conjonction prénexe de clauses de littéraux, c'est à dire en une proposition composée d'une entête constituée d'une succession de déclarations de variables avec quantificateur `AA` ou `EE`, suivi d'un corps qui est une conjonction de clause de littéraux exprimés dans un langage augmenté des variables déclarés.
Une proposition prénexe du premier ordre est composé d'une entête comprenant une succession de déclarations de variables quantifiée `AA` ou `EE` et d'un corps qui est une proposition d'ordre zero, écrite dans le langage augmenté de ces nouvelles variables.
3.2) Ensemble ou catégorie ?
Le langage logique du premier ordre est un langage contextuel c'est à dire qu'il y a des déclarations de variable dont la portée correspond à un bloc dans la formule délimité par des parenthèses, apportant ainsi au bloc un contexte. Chaque tel bloc constitue une sous-proposition. Et à chaque bloc correspond un contexte qui définit le langage en cours. Et celui-ci reprend celui du bloc parent en l'augmentant par la déclaration de variable du bloc en cours, et la transmet aux éventuels blocs enfants. Et la proposition dans le bloc doit être écrite dans le langage en cours.
La forme prénexe d'une proposition, en regroupant toutes les déclaration de variable dans une entête, dénote une temporalité linéaire dans la création des variables. Tous les blocs sont emboités les uns dans les autres comme des poupées Russes. Les variables suivantes sont dépendantes de toutes les variables précédentes qui sont quantifiées inversement. On place un curseur dans l'entête pour délimiter un sous-bloc c'est à dire une sous-proposition avec un langage. Délors cette sous-proposition se trouve dans une situation où le langage est augmenté des variables préalablement déclarés. Car dans la pratique, leur domaine de définition se ramène toujours à un ensemble minimal désigné par le domaine de Herbrand, complété par extension élémentaire d'autant d'éléments générateurs nouveaux qu'il y a de variables universelles nouvelles.
----------- à revoir --------
Le langage du premier ordre s'enrichit d'éléments générateurs supplémentaires `x,y,z,...` dits variales non quantifiées qui lorsqu'elles sont utilisées dans une expression logique, la transforme en une fonction propositionnelle. Par exemple `EEy, x"="yy` utilise une variable non quantifiée `x` et constitue donc une fonction propositionnelle que l'on nomme `Q(x)` en mettant entre parenthèse les variables libres.
`Q(x) <=> EEy, x"="yy`
Cette fonction propositionelle appliquée à `x` signifie textuellement que `x` est un carré.
Les éléments constants du langage, ici `1`, sont quantifiés existentiellement, ainsi que tous ce qui se trouve dans la présentation du langage.
Pour qu'une fonction propositionnelle deviennent une proposition, il faut que chaque variable non quantifiée soit affectée à une constantes ou bien quantifié existentiellement, ou bien quantifié universellement. Et l'alternance de quantification crée une dépendance fonctionnelle entre variable que l'on retrouve dans la forme skolémisé de la proposition ou bien dans la forme skolémisée de la négation de la proposition.
Par exemple, la proposition `AAxEEy,x"="yy` qui signifie textuellement que tous les éléments du groupe sont des carrés, introduit une variable universelle `x` et une variable existencielle `y` dépendant de `x`. L'élément `x` fait partie du langage en cours dans la sous-proposition `EEy,x"="yy` qui a comme parent `AAx`, et les éléments `x` et `y` font partie du langage en cours dans la sous-proposition `x"="yy` qui a comme parent `EEy`.
La forme skolémisée de la proposition est `EEy"(.)"AAx, x"="y(x)y(x)`. Ce qui permet d'augmenter le langage en introduisant un opérateur unaire `y"(.)"` et de rendre universelle la propriété que tous les éléments sont des carrés.
----------------------------
Analysons le langage logique utilisé. Les axiomes `"Associatif"("+"), "Commutatif"("+")"` sont du premier ordre, c'est à dire qu'ils peuvent s'exprimer en une formule de taille finie, dans un langage contextuel, comprenant qu'un seul type de variables `a,b,c,...`, quantifiées de façon universelle `AA` ou existentielle `EE`, des opérateurs et des prédicats, et le prédicat spécial d'égalité `"="`, puis comprenant les connecteurs logiques habituels `"⊥", "¬", "et", "ou", "⇒", "⇔"`. Où `"⊥"` représente le faux, l'antilogie, et où `"¬"` représente le connecteur logique unaire de négation.
Le langage du premier ordre possède une liste d'opérateurs générateurs et une liste de prédicats générateurs, appelée aussi sa présentation, et qui sont les seuls opérateurs et prédicats autorisés par le language.
On remarque de plus que ce sont des axiomes universels, c'est à dire n'utilisant qu'un seul type de quantificateur, le quantificateur universel `AA`.
Et on remarque de plus que ce sont des axiomes d'égalité, c'est à dire n'utilisant qu'un seul type de prédicats qu'est le prédicat `=`, et n'utilisant que le connecteur logique `"et"`
On précise dans la présentation du langage l'arité de chaque opérateur et prédicat utilisé, en lui adjoignant le suffixe `"(.,.)"` s'il est binaire, le suffixe `"(.)"` s'il est unaire, et en lui adjoignant aucun suffixe s'il est d'arité zéro-aire. Cette précision de l'arité pouvant être répétée de la même façon à d'autres endroits pour le rappeller ou pour lever une ambiguité dans le contexte.
On remarque que le langage de ces axiomes utilise l'opérateur binaire `"+(.,.)"` et le prédicat binaire d'égalité `"=(.,.)"`. Le rôle sémantique d'un langage est de pouvoir définir complètement un modèle. On appel la matrice du langage, les éléments de mémoire qui permettent de déterminer complètement un modèle. La matrice du langage se note sous forme de produit d'un langage d'opérateurs par un ensemble de prédicats `"<...>"{...}`. Les opérateurs générateurs ou ensemble d'opérateurs générateurs sont énumérés entre crochets `"<...>"`. Puis les prédicats générateurs ou d'ensembles de prédicats générateurs sont énumérés entre braquette `{...}`.
Le langage de la théorie `"Semi-groupe commutatif"(D,"+")` a comme matrice de langage `"<+(.,.)>"{"=(.,.)"}`, ou simplement `"<+>"{"="}`.
Les crochets `"<...>"` entourant des opérateurs ou ensembles d'opérateurs désigne l'ensemble des compositions closes qu'il est possible de faire avec ces opérateurs. C'est l'ensemble des termes engendrables. Si les opérateurs sont libres, cela correspond à une structure libre. C'est le langage d'opérateurs, appelé aussi le domaine de Herbrand. Exemple :
`"<"a,f"(.)",g"(.,.)>" ={a,f(a),g(a,a),f(f(a)), g(a,f(a)),g(f(a),f(a)),...}`
Les braquettes `{...}` entourant des prédicats ou ensembles de prédicats indiquent que c'est un ensemble de prédicats mais qu'ils ne se composent pas entre eux. Et le produit avec le langage d'opérateurs, qui est un produit en notation française c'est à dire le produit d'un élément `x` par une fonction `f` se notant `xf=f(x)` appliqué ici à des ensembles, indique qu'ils s'appliquent à des termes quelconques du langage d'opérateurs pour former ce que l'on appelle en logique, un littéral affirmatif. Et de façon plus générale on défini ce qu'est un littéral. Un littéral est soit un littéral affirmatif ou soit la négation d'un littérale affirmatif. Ainsi la matrice du langage est l'ensemble des littéraux affirmatifs.
Chaque littéral affirmatif se doit de posséder une valeur logique `0` ou `1` sauf en cas d'incomplétude théorique auquel cas la valeur n'est pas tranchée et est désignée par l'infini de Turing `oo`, mais nous en reparlerons plus tard. Ils constituent en cela la matrice mémoire qui détermine le modèle. Toutes les valeurs possibles sont autorisées et construisent les modèles selon la mécanique classique. Mais selon le point de vue élémentarien, seuls les modèles ne possédant qu'une quantité finie d'information existes. C'est à dire seuls les modèles calculables par un programme existes. Où on entend par programme, un programme de taille finie et écrit dans un langage impératif fini, tel que exécutable par une machine de Turing.
Ainsi l'infini inné n'existe pas. Tout doit être engendré par un processus réccurcif à partir d'opérateurs énumérables.
Le langage du premier ordre comprend un ensemble `L` d'opérateurs générateurs et un ensemble `M` de prédicats générateurs, et sa matrice qui détermine ses modèles se note `"<"L">"{M}`. Le produit des deux ensembles (en notation française) `"<"L">"{M}` s'interpréte comme produisant l'ensemble de toutes les compositions closes possibles d'un élément de `M` par des éléments de `"<"L">"`. Et donc cette expression `"<"L">"{M}` désigne précisement l'ensemble des littéraux affirmatifs du langage, dont les valeurs logiques déterminent le modèle.
Un modèle `ccM` pour ce langage est défini par une fonction de `"<"L">"{M} -> {0,1}`. Pourquoi choississons-nous une fonction et non une application ? Parceque selon les préceptes élémentariens, un modèle, comme toute construction, est soumis à un processus constructif et peut donc produire en calcul, un infini de Turing, correspondant en logique, à une proposition indécidable. Mais nous en reparlerons plus tard. Les élémentariens ne considère que les fonctions programmables, ne représentant qu'une quantité finie d'information. Lorsque la fonction retourne l'infini de Turing `oo`, ou que simplement n'est pas définie, cela signifie que le modèle ne tranche pas la question. Un modèle n'est pas forcement complet contrairement à la vision classique.
Tous les littéraux affirmatifs peuvent se combiner à l'aide des connecteurs logiques pour produire le langage du premier ordre sans quantificateur qui se note :
`"<" "⊥","<"L">"{M}, "¬(.)", "et(.,.)", "ou(.,.)", "⇒(.,.)", "⇔(.,.)" ">"`
Puis, on joute `n` variables universelles que l'on note `x_1,x_2,x_3,...,x_n.` Le langage est enrichie, tel une extension élémentaire intérieure, par l'apport de nouveaux opérateurs zero-aire dits variables libres car représentant tous les éléments. Ce langage se note :
`"<" "⊥","<"L,x_1,x_2,x_3,...,x_n">"{M}, "¬(.)", "et(.,.)", "ou(.,.)", "⇒(.,.)", "⇔(.,.)" ">"`
Ces variables libres sont des opérateurs zéro-aire du langage, mais ne servent pas à construire les modèles. Seuls les littéraux affirmatifs appartenant à `"<"L">"{M}` déterminent le modèle. Les règles de déducions n'offreront pas le même traitement aux deux sortes de variables pourtant de même type que sont les opérateurs zéro-aire appatenant à `L` et les opérateurs `x_1,x_2,x_3,...,x_n`.
La logique est d'ordre zéro s'il n'y a pas d'opérateurs, c'est à dire s'il n'y a pas d'élément mais seulement `n` prédicats zéro-aire `M = {b_1,b_2,b_3,..., b_n}` c'est à dire des inconnus booléens. Ce langage se note :
`"<" "⊥",M,"¬(.)", "et(.,.)", "ou(.,.)", "⇒(.,.)", "⇔(.,.)" ">"`
Chaque littéral affirmatif, c'est à dire ici chaque prédicats zero-aire `b_1,b_2,b_3,..., b_n`, doit posséder une valeur logique `0` ou `1` ou `oo`, pour déterminer le modèle. Un modèle est une fonction calculable de `M -> {0,1}` où `oo` correspond à l'infini de Turing, c'est à dire à un comportement ou le calcul de la fonction ne s'arrête jamais, c'est à dire où la fonction n'est pas définie.
Ce langage s'appelle aussi le langage propositionnelle. Et cela correspond aux équations booléennes.
On repart du langage logique du premier ordre sans quantificateur qui se note :
`"<" "⊥","<"L">"{M}, "¬(.)", "et(.,.)", "ou(.,.)", "⇒(.,.)", "⇔(.,.)" ">"`
Puis, est mis en oeuvre le principe du langage contextuel. C'est à dire qu'une sous proposition possède un contexte défini en amont qui précise quels sont les variables utilisables.
Ces propositions sans quantificateur peuvent se doter maintenant d'une déclaration de variable, quantifiée `AA` ou `EE`, définissant ainsi un bloc dans lequel le langage est enrichie d'un nouvel opérateur zero-air qui correspond à cette variable, et qui contient une proposition écrite dans ce langage plus riche pouvant utiliser cette variable.
Puis ce procédé est répété autant de fois que l'on veut pour former une proposition prénexe du premier ordre, c'est à dire composé d'une entête comprenant une succession de déclarations de variables quantifiée `AA` ou `EE` et d'un corps qui est une proposition sans quantificateur du premier ordre, écrite dans le langage augmenté de ces nouvelles variables.
Puis toutes ces propositions peuvent se combiner à l'aide des connecteurs logiques pour produire le langage du premier ordre. Mais cette dernière construction s'avèrera inutile car les règles de construction précédantes et les règles de déduction admises permettent d'opérer une telle dernière construction.
Dans ce langage déclaratif, chaque déclaration de variable quantifiée `AA` ou `EE` ouvre un bloc possèdant un contexte qui comprend le langage utilisé. Ce langage est celui du bloc parent, enrichie du nouvel opérateur zero-aire correspondant à la variable déclarée. Et chaque bloc contient une proposition écrite dans le langage du bloc.
C'est ainsi que l'on définie le langage du premier ordre. Les règles syntaxiques de déduction en logique du premier ordre que nous verrons plus loin permettent de transformer toutes propositions du premier ordre en une conjonction prénexe de clauses de littéraux, c'est à dire en une proposition composée d'une entête constituée d'une succession de déclarations de variables avec quantificateur `AA` ou `EE`, suivi d'un corps qui est une conjonction de clause de littéraux exprimés dans un langage augmenté des variables déclarés.
On remarque qu'une sous-proposition est un peu plus qu'une proposition puisqu'elle possède de par le contexte un langage qui peut contenir des variables supplémentaires, les variables déclarés en amont non utilisées dans l'expression de la sous-propostion qui sont alors dites libres.
Trouver une expression formelle de l'ensemble des propositions du premier ordre regroupant toutes les formules du langage déclaratif qu'est le langage logique du premier ordre, nécessite de codifier une procédure que constitue l'extention élémentaire et que nous verrons plus loin.
Dans un langage `ccL_0` du premier ordre sans quantificateur et possédant un ensemble d'opérateurs `L`, l'ensemble sous-jacent est désigné par la structure libre du langage `"<"L">"`. Les opérateurs opèrent que sur la structure libre du langage `"<"L">"`, et de même pour les prédicats. Autrement dit, pour le langage logique du premier ordre sans quantificateur, ses opérateurs et prédicats générateurs désignent implicitement des objets ensemblistes c'est à dire circonscrit à un ensemble qui est en l'occurrence l'ensemble `"<"L">"`.
Par contre pour le langage `ccL_1` du premier ordre avec quantificateur, deux interprétations viennent à l'esprit et qui s'avèrent complémentaires. L'interprétation syntaxique qui part du langage, et l'interprétation sémantique qui part du modèle.
Le langage logique du premier ordre est un langage contextuel c'est à dire qu'il y a des déclarations de variable dont la portée correspond à un bloc dans la formule délimité par des parenthèses, apportant ainsi au bloc un contexte. Chaque tel bloc constitue une sous-proposition. Et à chaque bloc correspond un contexte qui définit le langage en cours. Et celui-ci reprend celui du bloc parent en l'augmentant par la déclaration de variable du bloc en cours, et la transmet aux éventuels blocs enfants. Et la proposition dans le bloc doit être écrite dans le langage en cours.
On remarquera l'analogie avec les compilateurs et interpréteurs de langages informatiques qui sont des langages contextuels.
La forme prénexe d'une proposition, en regroupant toutes les déclaration de variable dans une entête, dénote une temporalité linéaire dans la création des variables. Tous les blocs sont emboités les uns dans les autres comme des poupées Russes. Les variables suivantes sont dépendantes de toutes les variables précédentes qui sont quantifiées inversement. On place un curseur dans l'entête pour délimiter un sous-bloc c'est à dire une sous-proposition avec un langage. Délors cette sous-proposition se trouve dans une situation où le langage est augmenté des variables préalablement déclarés. Prenons un cas simple où `P` est un prédicat unaire :
`AAx, P(x)`
La proposition `AAx, P(x)` se trouve dans le langage ne comprenant que `{P}`, et la sous-proposition `P(x)` se trouve dans le langage comprenant `"<"x">"{P}`. Tout se passe comme si un élément `x` avait été ajouté comme opérateur zéro-aire générateur, c'est à dire par extension élémentaire. Et il n'y a pas de différence entre une variable quantifiée universel ou une variable quantifiée existentiel pour la sous-proposition puisque cette quantification est placée en dehors de la sous-proposition, parcontre la variable `x` est bien ajouté au langage en tant qu'élément mis à disposition de la sous-proposition.
Ainsi, il est facile et naturel de définir la logique par la syntaxe. Et cela se fait s'en rencontrer de problème d'interprétation, car en faite, nous ne procédons à aucune interprétation autre que celle de libérer la puissance d'expression du langage.
L'utilisation d'une variable universelle fait que les symboles d'opérateurs et de prédicats applicables à cette variable désignent des objets qui ne sont plus circonscrits à un ensemble. Les objets désignés opèrent sur la catégorie des éléments et non plus sur un ensemble d'éléments. On distingue alors les deux natures d'objets par des noms différents. On les appelle opérateurs et ensembles lorsqu'il sont circonscrits à un ensemble, et foncteurs et prédicats lorsqu'il ne sont pas circonscrits à un ensemble. Mais ont laisse leur nom d'usage d'opérateur et de prédicat pour désigner les symboles correspondant du langage, car délors il s'applique à un ensemble minimal désigné par le domaine de Herbrand, le langage d'opérateurs, et qui peut être complété par extension élémentaire.
Un opérateur, en tant qu'objet et non en tant que symbole, opère par définition sur un ensemble, Donc, si `"+"` est un opérateur binaire, l'expression `"(+)"` doit suffire pour désigner une structure. Et on considère l'opérateur dans sa plus grande généralité, opérant sur un ensemble noté `"Land"("+")`. Il est donc défini comme une fonction de `"Land"("+")"×Land"("+")"→Land"("+")` où `"Land"("+")` représente un ensemble arbitrairement grand, puisque l'opérateur est définie dans sa plus grande généralité. Mais il faut bien comprendre que cette définition n'est pas anodine. Car la définition d'un ensemble dans l'absolu n'est pas une définition du premier ordre.
On rappelle le standard suivant pour les opérateurs en tant qu'objet et non symbole : Un opérateur `n`-aire `f` possède un ensemble où il opère `"Land"(f)`, et constitue une fonction de `"Land"(f)^n"→Land"(f)`. Pourquoi choississons-nous une fonction et non une application ? Parceque selon les préceptes élémentariens, un opérateur, comme toute construction, est soumis à un processus constructif et peut donc produire en calcul un infini de Turing, correspondant en logique à une proposition indécidable, mais nous en reparlerons plus tard.
Considérons l'égalité de structure suivante où `1` joue ici le rôle d'un opérateur zero-aire libre, autrement dit, d'un élément inconnu.
`S = "<+",1">"`
Et on suppose que l'opérateur `"+"` est libre avant cette déclaration. Cela veut dire qu'on le considère comme nouveau, qu'il n'a pas été utilisé avant. Et s'il y a des homonymies on considère que ces homonomies ne désignent pas le même opérateur.
Après cette déclaration, l'opérateur `"+"` est lié comme suit. L'ensemble où il opère est définie comme suit :
`"+" in (S^2"→"S)`
Et c'est une définiton qui peut être récurcive selon que l'on interprète `"<+",1">"` comme l'ensemble des emboitements clos d'opérateurs, ou comme l'ensemble des compostions close d'opérateurs :
`"+" in ("<+",1">"^2"→<+",1">")`
Une structure et dite universelle si sa théorie est universelle c'est à dire n'utilise qu'un seul type de quantificateur, le quantificateur universelle `AA`. On verra que toutes les structures que nous construisons sont universelles, c'est à dire que tous les opérateurs existentiels qui aurait pu être placé dans la théorie nous sont en fait révélés dans le langage de la structure par un intervenant extérieur, rendant ainsi la structure universelle.
Tout nom de variable ne figurant pas dans le langage d'opérateurs de la structure universelle et apparaissant dans la théorie de la structure en tant qu'élément, est nécessairement une variable quantifiée universel, dite variable universelle. D'autre part, il n'y a pas de dépendance entre variables universelles si toutes les variables sont universelles. Aussi, il est inutile de répéter cette quantification universelle dans l'expression de la théorie. On parlera de quatification universelle implicite :
Les variables qui ne sont pas mentionnées dans les opérateurs passés en argument du patron, sont implicitement quantifiées universel.
Les théories universelles du premier ordre du semi-groupe, du monoïde et du demi-anneau se résume dans ce tableau où les variables qui ne sont pas mentionnées dans les opérateurs passés en argument des patrons, sont implicitement quantifiées universellement :
| `a"+"(b"+"c) = (a"+"b)"+"c` |
Semi-groupe commutatif `("+")` |
Monoïde commutatif `("+",0)` |
Demi-anneau commutatif `("+",0,"⁎",1)` |
| `a"+"b = b"+"a` | |||
| `a"+"0 = a` | Élément neutre `("+",0)` |
||
| `a(bc) "=" (ab)c` | Semi-groupe commutatif `("⁎")` |
Monoïde commutatif `("⁎",1)` |
|
| `ab"=" ba` | |||
| `a1"="a` | Élément neutre `("⁎",1)` |
||
| `a(b"+"c) "=" ab"+"ac` | Distributif `("⁎","+")` |
||
| `0a=0` | Élément absorbant `("⁎",0)` |
||
Les variables ne sont pas seulement introduites pour, d'un point de vue syntaxique, augmenter le langage propositionnel, ou ce qui revient au même, d'un point de vue sémantique, pour procéderà une extension élémentaire. Elles servent aussi à définir des fonctions propositionnelles du premier ordre. Dans ce cas, elles ne sont pas quantifiées mais prédéclarées à l'aide du symbole `"(...)"|->`
Une fonction propositionnelle `n`-aire du premier ordre est une application de `"<"L">"^n -> ccL_1`. Par exemple :
`(a,b)|->{AAc,(a"+"b)"+"c"="a"+"(b"+"c)}`
Les fonctions propositionnelles définissent des prédicats.
Considérons le langage du premier ordre `ccL_1` de matrice `"<"L">"{M}`, où `L` est l'ensemble des opérateurs générateurs et où `M` est l'ensemble des prédicats générateurs. Ce langage permet de construire l'ensemble des éléments engendrables `"<"L">"`, ainsi que l'ensemble des prédicats définissables que l'on note `ccM_1`.
Il est toujours possible d'ajouter un élément neutre à un semi-groupe pour en faire un monoïde sans que cela n'entraine de contrainte tendant à fusionner des éléments du semi-groupe initial.
On procéde pour cela une extension élémentaire. On ajoute un élément `0` au langage d'opérateurs qui devient `"<+",0">"`, où le symbole zéro désigne un ément inconnue. Et on ajoute à la théorie du premier ordre de la structure le fait que c'est un élément neutre :
`"Monoïde commutatif"("+",0) <=> ( ("Semi-groupe commutatif"("+")), ("Elément neutre"("+",0)) )` `"Monoïde commutatif"("+",0) <=> AAaAAbAAc ,((a"+"(b"+"c) = (a"+"b)"+"c),(a"+"b= b"+"a),(a"+"0=a))`
On remarque que la théorie du monoïde est universelles et qu'elle constitue une théorie d'égalité. Par définition, le patron Monoïde commutatif (qui est une fonction propositionnelle) prend deux arguments, le premier argument est l'opérateur du monoïde, le second argument est l'élément neutre du monoïde.
Néanmoins il est possible de définir le monoïde dans un langage ne comprenant pas le `0` mais avec une théorie qui n'est pas universelle. On utilise pour cela un autre patron de structure, qui ne prend en argument que l'opérateur binaire du monoïde. Vue de l'intérieur, nous avons dans le langage `"<+(.,.)>"{"=(.,.)"}`, l'équivalence logique formelle suivante, et qui constitue une définition du premier ordre :
`"Monoïde"("+") <=> EE0AAaAAbAAc,((a"+"(b"+"c)"="(a"+"b)"+"c),(a"+"b"="b"+"a), (a"+"0 "=" a))`
La fonction propositionnelle est overloader. Elle porte le même nom mais comme le nombre d'argument n'est pas le même c'est une autre fonction dont on donne ici la définition.
On remarque que cette définition n'est pas universelle car elle comprend un quantificateur existentiel. Et pour rendre cette définition universelle il faut ajouter l'élément `0` (qui pour l'instant ne joue le rôle que d'une variable indéterminée dans la formule) dans le langage de la structure, et simplifier la formule en enlevant le quantificateur existentiel devenu inutile. Ce procédé s'appelle la skolémisation. Mais cela peut introduire une toute petite différence, à savoir que l'élément `0` devient désignable par le langage de la structure, c'est à dire calculable par la structure, ce qui n'était pas le cas avant. Cette définition avec le quantificateur existentiel précise donc qu'il existe un élément neutre, mais que celui-ci n'est apriori pas désignable par le langage de la structure, c'est à dire apriori pas calculable par la structure.
En effet, il est possible de concevoir des monoïdes où l'élément neutre existe bien mais est incalculable par la structure elle-même. C'est le cas pour les entiers naturels `NN`, si on ne possède comme outils que l'opération d'addition et l'élément `1`, il s'avère impossible de calculer le `0`. C'est toute la difficulté de la découverte du zéro décrite dans l'histoire des sciences.
Des éléments incalculables peuvent avoir des propriétés indécidées par la théorie sans que cela ne porte atteinte de façon excessive à l'espect complet de la théorie.
Avons-nous fait un choix arbitraire d'interprétation dans cette analyse syntaxique ? C'est possible, et cela changera les règles de déduction autorisées (la syntaxe) ainsi que l'interprétation du langage, ses modèles (la sémantique). C'est pourquoi nous gardons sous le coude l'autre option qui ignore cette différence. Nous n'avons fait que libérer la puissance du langage. L'inverse consiste à interpréter ces expressions différentes comme signifiant la même chose.
L'augmentation de la capacité d'expression du langage enrichit la sémantique. Mais cela peut se faire au détriment de la capacité de démonstration du système de démonstration présidé par la syntaxe.
Cette notion de calculabilité des éléments est relative à un langage. Un élément est dit calculable dans le langage `L` si et seulement s'il est exprimable dans le langage `L`, c'est à dire si seulement s'il appartient à `"<"L">"`, c'est à dire si et seulement s'il est égale à une composition close d'opérateurs de `L`.
La notion de calculabilité relative correspond à la notion de dépendance qui prendra tous sont sens dans la logique respectueuse de l'indépendance que nous décrirons plus loin.
Puis, il ne faut pas confondre cette notion de calculablité relative ou de dépendance avec la notion absolue de calculabilité qui est plus vaste, qui comprend l'arithmétique, qui s'appuit sur l'opinion de Church, et qui se formalise pour chaque langage de programmation grâce à la machine de Turing.
Pour couvrire cette notion de calculabilité relative des éléments, on définit deux langages emboitées. Un langage de la structure qui permet de construire tous les éléments de la stucture, et un langage calculable par la structure qui permet de construire tous les éléments calculable par la stucture. Le premier langage est obtenue par skolémisation, le second langage est créé en ne prenant qu'une partie des opérateurs générateurs, ceux connus par la structure.
Les élémentariens considèrent que tout est dénombrable et donc que tout est calculable en quelque sorte s'appuyant sur un ensemble dénombrable de générateurs. Mais si l'on admet que certains opérateurs générateurs ne sont pas à notre porté, ne sont pas mis à notre libre disposition, on définit alors une notion de calculabilité relative, les éléments calculables sont les éléments produit par le calcul à partir des seuls opérateurs générateurs mis à notre disposition. Cela crée deux languages d'opérateurs emboités, l'un calculable mais ne couvrant par forcement tous les éléments, et l'autre exhaustif mais pas forcement calculable.
Ce prinicipe élémentarien est justifié par le théorème de Löwenheim-Skolem qui affirme que, si une théorie du premier ordre écrite dans un langage mathématique dénombrable, admet un modèle infini, alors elle admet un modèle dénombrable. Cela justifie la possibilité de remettre dans le cadre d'une structure libre de type dénombrable, tous les éléments, certes calculables dans l'absolue, mais incalculables par la structures.
L'autre interprétation consiste alors à ignorer ce double langage emboité, et rend donc, de fait, toute structure universelle. C'est à dire que la structure s'accapare toujours tous ses opérateurs existentiels pour les intégrer à son langage. On verra plus loin l'impacte que cela a sur la sémantique c'est à dire comment les modèles en sont modifiés, l'impacte que cela a sur la syntaxe, c'est à dire qu'elles sont les règles syntaxiques de déduction qui ne sont plus permises ou au contraire ajoutées.
Mais avant, nous sommes bien obliger de remonter au base du raisonnement logique, à quelque chose de bien plus simple, au système de déduction naturelle appliqué à des inconnues booléens et à des équations booléennes.
L'intuition nous guide, et va nous permettre de faire les bons choix, de construire les structures pertinentes et de les faire dans un ordre presque déterminé selon une philosophie élémentarienne, batissant un langage d'opérateurs et un ensemble de procédures, comme un jeu de légos, d'une façon la plus libre possible afin d'obtenir une syntaxe simple donnant une large capacité d'expression.
La théorie se comporte alors comme un entonnoir, elle s'applique sur un large spectre de configurations et produit par le calcul ses démonstrations favorites, se comportant ainsi comme un canaliseur.
Nous procédons étape par étape pour que chaque choix puisse découler de source, et on décrit un modèle qui donne à ces opérateurs et ces procédures un sens plus profond, une sémantique qui nous inspire, une intuition qui nous guide.
La construction s'appuit sur la programmation qui est le véritable fondement de la logique. Les mécanismes de typage par inférance que l'on trouve dans plusieurs langages informatiques seront utilisés intensivement dans le langage mathématique. On fera des mathématiques comme on fait de la programmation. Selon les préceptes élémentariens, la garanti de cohérence du système est reportée dans le processus constructif auquel nous nous soumettons.
En privilègiant une approche constructive, on s'écartera du point de vue catégoriel logique, pour un point de vue davantage combinatoire et physique. Les élémentariens rejètent l'axiome du choix, considèrent inexistant le continuum des nombres réels, et le remplace par une représentation dénombrable en ne retenant que les seuls réels calculables. On construit l'espace à partir du seul processus programmatif, énumératif et démonstratif, qu'est la construction de `NN`. On construit le corps qui nous permet la mesure. On l'étend aux infinis, formalisant les ordres de grandeurs. On revisite ainsi les fondements de l'analyse.
Une fois la distance définie, apparait naturellement la notion de continuité et la topologie qui en découle. Et il est pertinent de l'étudier avant même la construction des nombres réels, dans l'étude des infiniments grands entiers, et dans l'étude des infiniments petits rationnels.
Qu'est-ce que la continuité ?. Deux possiblités s'offrent à nous de définir la continuité. Soit d'une manière intuitive. Ou soit d'une manière beaucoup plus libre encore mais dans un espace bimétrique plus riche, contenant deux métriques, l'une pour désigner les passages continues. L'autre pour désigner les passages discontinues "à vole d'oiseaux".
Pour éviter l'usage intensif des parenthèses, on fixe un ordre de priorité syntaxique des opérateurs, du plus prioritaire au moins prioritaire :
`"¬"` `"∗"` `"∈"`,`"∉"` `+` `"<","⩽",">","⩾"` `"et", "ou"` `"⇒", "⇔"` `"=","≠"` `AA, EE`
Ainsi par exemples, pour tout élément `x,y,z`, pour tout ensemble `E`, pour tout prédicat unaire `A"(.)",B"(.)"`, et pour tout booléen `P,Q,R`, nous avons :
L'expression `x"∗"y "+" z` signifie `(x"∗"y) "+" z` et non `x"∗"(y"+"z)`
L'expression `P"et"Q "⇒" R` signifie `(P"et"Q) "⇒" R` et non `P"et"(Q "⇒" R)`
L'expression `P "⇒" Q"ou"R` signifie `P "⇒" (Q"ou"R)` et non `(P "⇒" Q)"ou"R`
L'expression `x "+" y "=" z` signifie `(x "+" y) "=" z` et non `x "+" (y "=" z)`
L'expression `"¬"x"∈"E` signifie `("¬"x)"∈"E` et non `"¬"(x"∈"E)`
L'expression `AA x, A(x) "⇒" B(x)` signifie `AA x, (A(x) "⇒" B(x))` et non `(AAx, A(x)) "⇒" B(x)`
L'expression `P "⇒" AA x, A(x) "⇒" B(x)` signifie `P"⇒"(AAx, A(x) "⇒" B(x))` et non `(P"⇒"(AAx, A(x))) "⇒" B(x)`
Le produit se note parfois par absence de symbole, par exemple `xyz = x"∗"y"∗"z`.
On utilise les opérations `"+"`, `"∗"`, indifféremment sur des éléments ou des ensembles d'éléments. Ainsi par exemples, pour un élément `a` et des ensembles `U` et `V`, nous avons :
`a"+"U = {a"+"u "/" u "∈" U}`
`aU = {au "/" u "∈" U}`
`U"+"V = {u"+"v "/" u "∈" U, v "∈" V}`
`UV={uv "/" u "∈" U, v "∈" V}`
On identifie les valeurs logiques aux booléens, le vrai est identifié au booléen `1`, le faux est identifié au booléen `0`.
Etant donné un prédicat zéro-aire `X`, sa valeur logique est soit `0` ou soit `1`. Mais à cette description nous ajoutons un troisième cas, le cas ou la théorie globale en cours est incomplète pour déterminer `X`, ce qui se note `X"="oo`, l'infini de Turing. Les 3 théories les plus simples sont : la totologie `"⊤"`, l'antilogie `"⊥"`, et la théorie indécidée `"?"`. Nous avons : `"⊤="1`, `"⊥="0`, `"?="oo`.
On adopte les conventions suivantes : Un ensemble de propositions désigne leur conjonction. Et de même, un vecteur de propositions désigne leur conjonction. Par exemple, pour toute variables booléennes `P, Q, R`, nous avons :
L'expression `((P),(Q),(R))` en tant que proposition signifie `P "et" Q "et" R`
L'expression `{P,Q,R}` en tant que proposition signifie `P "et" Q "et" R`
Comment formaliser l'idée intuitive de distance séparant deux points ? On la formalise en une fonction binaire `d"(.,.)"` appelée métrique, de `E^2` vers `D`, où `E` est un ensemble de points et `D` un ensemble de valeurs de distance possible.
L'ensemble des valeurs `D` devra satisfaire un certain nombre d'axiomes. Ces axiomes définiront la structure de l'ensemble des valeurs.
La métrique `d"(.,.)"` est une fonction binaire de `E"×"E"→"D` qui devra satisfaire un certain nombre d'axiomes.
L'ensemble `E`, munie d'une métrique, `(E,d)`, est appelé un espace métrique.
Avant de définir l'espace, on définit ce qu'est une valeur de distance. Par principe, les valeurs de distance, que nous appelons simplement valeurs, se comportent comme une ressource, dont on chercherait à minimiser la consommation. Elles peuvent s'ajouter dans n'importe quel ordre. Donc leur somme est associative et commutative. Cela se traduit par le fait que la structure en notation classique `(D,"+")` est un semi-groupe commutatif.
Vue de l'intérieur, les éléments du semi-groupe commutatif satisfont les deux propiétés :
`"Associatif"("+")"` `<=>` `AAaAAbAAc, a"+"(b"+"c) = (a"+"b)"+"c` `"Commutatif"("+")"` `<=>` `AAaAAbb, a"+"b = b"+"a`
Que l'on regroupe :
`"Semi-groupe commutatif"("+") <=> (( "Associatif"("+")),("Commutatif"("+")))` `"Semi-groupe commutatif"("+") <=> AAaAAbAAc,((a"+"(b"+"c) = (a"+"b)"+"c),(a"+"b= b"+"a))`
On utilise un patron de structure, ici « Semi-groupe commutatif », qui prend en argument une liste précise d'opérateurs, ici `("+")`, et qui affirme que ces opérateurs satisfont la théorie du patron, ici l'associativité de `"+"` et la commutativité de `"+"`. L'expression `("+")` désigne la structure définie par l'opérateur `"+"`. Ainsi la déclaration « `("+")` est un semi-groupe commutatif » se formalise en la proposition patronnée « La structure `("+")` satisfait Semi-groupe commutatif `("+")` », ce qui s'écrit :
`("+") |==` Semi-groupe commutatif `("+")`
Une structure se présente sous la forme d'un n-uplet de prédicats et d'opérateurs, et constitue un modèle. Néanmoins dans l'exemple précédent, le modèle est vide car il n'est mentionné aucun ensemble sous-jacent ni opérateurs générateurs capable de construire un tel ensemble. Et il faut envisager des extensions élémentaires potentielles pour donner corps à la structures. C'est pourquoi on dote souvent la structure d'un ensemble sous-jacent, et on utilise un patron de même nom, comme une fonction overloadée (terme anglais françisé) en programmation, avec des types d'arguments différents, ce qui permet de savoir à quel patron on a à faire. .
`"Semi-groupe commutatif"(D,"+") <=> (( "Assciatif"(D,"+")),("Commutatif"(D,"+")))` `"Semi-groupe commutatif"(D,"+") <=> AA(a,b,c)"∈"D^3 ,((a"+"(b"+"c) = (a"+"b)"+"c),(a"+"b= b"+"a))`
Puis il existe une valeur de distance particulière qu'est la valeur nulle, notée `0`. Dans notre univers, la distance minimale est ainsi zéro, `0"∈"D`. C'est à dire d'une façon imagée, on est pas obligé d'avancer, on peut faire du surplace sans avoir à consommer de la distance. L'élément nul est donc l'élément neutre du monoïde :
`"Élément neutre" ("+",0) <=> ` `AAa, a"+"0 = a`
En faite, il est toujours possible d'ajouter une telle valeur nulle jouant le rôle d'élément neutre à un semi-groupe pour en faire un monoïde sans que cela n'entraine de contrainte tendant à fusionner des éléments du semi-groupe initial.
Ainsi `(D,"+")` devient un monoïde commutatif. On utilisera le terme de valeur pour désigner toutes les valeurs de distance possible, et celui de grandeur pour désigner les seuls valeurs non nulles. Les grandeurs s'ajoutent entre-elles pour produire d'autres grandeurs. L'exposant `""^"⁎"` appliqué à l'ensemble sous-jacent d'un monoïde signifie que l'on retire l'élément nul. Ainsi `D^"⁎"` représente l'ensemble des grandeurs. Tandis que `D` représente l'ensemble des valeurs. À ce stade nous avons :
`(D,"+")` est un monoïde commutatif.
`(D^"⁎","+")` est un semi-groupe commutatif.
Vue de l'intérieur, le langage utilisé par ces axiomes est `"<"0,"+(.,.)>"{"=(..)"}`. Les axiomes `"Associatif"("+")`, `"Commutatif"("+")`, `"Élément neutre"("+",0)` forment la théorie du monoïde commutatif :
`"Monoïde commutatif"("+",0) <=> (("Assciatif"("+")),("Commutatif"("+")),("Élément neutre" ("+",0)))` `"Monoïde commutatif"("+",0) <=> AAaAAbAAc, ((a"+"(b"+"c)"="(a"+"b)"+"c),(a"+"b"="b"+"a), (a"+"0 "=" a),(a"+"0 = a))`
Le patron Monoïde commutatif prend deux arguments, le premier argument est l'opérateur du monoïde, le second argument est l'élément neutre du monoïde.
Les théories universelles du premier ordre du semi-groupe et du monoïde commutatif se résume dans ce tableau où les variables qui ne sont pas mentionnées dans les opérateurs passés en argument des patrons, sont implicitement quantifiées universellement :
`a"+"(b"+"c) = (a"+"b)"+"c` `a"+"b= b"+"a` `a"+"0 = a`
Dans tout monoïde `(D,"+")`, la relation d'inclusion induite par la loi, est une relation de préordre notée `"⩽"`. Vue de l'intérieur, elle est définie comme suit :
`"Inclusion"("+","⩽")` `<=>` `AAaAAb, a"⩽"b <=> EEc, b"="a"+"c`
Un préordre est une relation reflexive et transitive :
`"Réflexif"("⩽")` `<=>` `AAa, a"⩽"a` `"Transitif"("⩽")` `<=>` `AAaAAbAAc, (a"⩽"b "et" b"⩽"c) => a"⩽"c`
`"Préordre"("⩽")` `<=>` `(("Réflexif"("⩽")),("Transitif"("⩽")))` `"Préordre"("⩽")` `<=>` `AAaAAbAAc,((a"⩽"a),((a"⩽"b "et" b"⩽"c) => a"⩽"c))`
La relation d'inclusion induite par la loi du monoïde constitue un préordre :
`"Inclusion"("+","⩽")` `=>` `"Préordre"("⩽")`
C'est la présence de l'élément neutre `0` qui assure la réflexivité, et c'est l'associativité de l'addition `"+"` qui assure la transitivité.
Ce préordre est l'embryon d'une relation d'ordre. Un préordre définie une relation d'équivalence. Et les classes d'équivalences se définissent commme suit : deux éléments `a,b` sont équivalents pour le préordre si et seulement si `a"⩽"b "et" b"⩽"a`. Chaque classe d'équivalence regroupe tous les éléments d'une même valeur d'ordre. Dans un ordre, du fait de la propriété antisymétrique de l'ordre qui affirme que `AAaAAb, (a"⩽"b "et" b"⩽"a) => (a"="b)`, ces classes d'équivalences sont des singletons.
Par commodité, on définit ensuite la relation de préordre opposée `"⩾"` et les relations de préordres strictes `"<"`, `">"` comme suit :
`"Plus grand ou égale"("⩾")` `<=>` `b"⩽"a` `"Strictement plus petit"("<")` `<=>` `(a"⩽"b "et" ¬(b"⩽"a))` `"Strictement plus grand"(">")` `<=>` `(a"⩾"b "et" ¬(b"⩾"a))`
Ce préordre est appelé le préordre canonique du monoïde. Ce n'est pas un axiome, c'est une définition, c'est à dire une construction valable en toutes circonstance, une définition enrichissant le langage. De même pour le préordre symétrique et les préordres strictes.
A partir de la définion du préordre canonique du monoïde `"Inclusion"("+","⩽")` et de la théorie du monoïde `"Monoïde"("+","⩽")`, ont déduit les propriétés `{"Réflexif"("⩽")`,`"Transitif"("⩽")}` comme quoi la relation est bien un préordre, ce qui se note :
`(("Élément neutre" ("+",0)),("Associatif"("+")),("Inclusion"("+","⩽")))` `=>` `(("Transitif"("⩽")),("Réflexif"("⩽")))` `(("Monoïde"("+",0)),("Inclusion"("+","⩽")))` `=>` `"Préordre"("⩽")`
La définition du préordre `"Inclusion"("+","⩽")` n'est pas universelle à cause de la présence d'un quantificateur existentiel :
`"Inclusion"("+","⩽")` `<=>` `AAaAAb, a"⩽"b <=> EEc, b"="a"+"c`
On préfère définir l'ordre à partir d'une notion de préordre compatible avec la structure de monoïde. C'est à dire un préordre invariant par translation et avec zéro comme élément minimal, formant ainsi deux axiomes universelles :
`"Invariant par translation"("+","⩽")` `<=>` `AAaAAbAAc, a"⩽"b => a"+"c "⩽" b"+"c` `"Élément minimal"("⩽",0)` `<=>` `AAa, 0"⩽"a`
Mais ces deux axiomes ne sont pas suffisants pour définir dans notre monoïde la relation `"⩽"` définie par `"Inclusion"("+","⩽")`. On verra plus-tard que si le monoïde est monogène alors cela est suffisant.
Puis la notion de grandeur se définit grace au concept d'étalon servant d'unité de mesure. Selon le point de vu élémentarien, on construit `D` avec le moindre effort, à l'aide du zéro et d'un seul étalon générateur que l'on note `ȷ`. Cela se traduit par le fait que l'ensemble des valeurs `(D,"+")` est un monoïde monogène.
Remarquez que les axiomes exprimant la monogénéité et la liberté du monoïde sont exactement les axiomes décrivant `NN`. On rencontre alors la difficulté de fonder `NN` par une axiomatique sans se servir de `NN`. On peut astucieusement définir un entier naturel comme un schéma de programmation, et donc de démonstration. L'entier naturel correspond à un nombre de répétitions d'un programme. Délors il est possible de définir dans tout monoïde, une opération externe qu'est la multiplication programmative par un entier naturel `n`. Conventionnellement on note dans un tel produit, en premier le nombre entier, et en second l'élément du monoïde qui sert ainsi d'unité physique. Considérons une valeur `a` appartenant à `D`, nous avons :
`0a = 0` `1a = a` `2a = a+a` `3a = a+a+a` `...` `na = ubrace(a+a+...+a)_(n "termes")`
Où l'on note `0,1,2,...` les entiers naturels. On note par le même symbole `0` la valeur de distance nulle, `0"∈"D` et l'entier zéro `0"∈"NN` en laissant au contexte le soin de lever l'ambiguité, sachant que pour garder toute notre liberté on pose `NN` et `D` disjoint. Par contre l'étalon choisi est noté `ȷ"∈"D`, et l'entier générateur, un, est noté `1"∈"NN`. L'opération externe de multiplication programmative `"⁎"`, qui est notée aussi par absence de symbole, est l'application de `NN"×"D->D` définie par le programme informatique suivant :
`n"⁎"x = nx = ubrace(x+x+...+x)_(n "termes")`
On définie également la multiplication à droite comme étant égale à la multiplication à gauche, c'est à dire une application de `D"×"NN->D` définie par `x"⁎"n=n"⁎"x`. On dira que l'opération typé de multiplication de `(NN"×"D + D"×"NN)->D` est commutative, le signe `"+"` désignant ici l'union disjointe.
Puis on utilise le même symbole de multiplication pour le produit d'entiers de `NN"×"NN->NN`. Et nous avons la propriété suivante propre à la composition de programme de multiplication :
`"Associatif"(NN,NN,D,"⁎")` ` <=> ` `AA(n,m)"∈"NN^2, Aa, n(ma)"="(nm)a` `"Associatif"(NN,"⁎")` ` <=> ` `AA(n,m,s)"∈"NN^3, n(ms)"="(nm)s` `"Commutatif"(NN,"⁎")` ` <=> ` `AA(n,m)"∈"NN^2, nm"="mn`
On dira que l'opération typé de multiplication de `(NN"×"NN+NN"×"D+D"×"NN)->(NN+D)` est associative et commutative, faisant qu'un produit d'entiers et d'éventuellement un seul élément de `D` peut être effectuer dans n'importe quel ordre, et que les parenthèses sont inutiles et que l'ordre d'apparition des éléments dans le produit n'a pas d'importance.
L'axiome exprimant la monogénéité du monoïde, de générateur `ȷ`, est :
`AAa, a"="0 "ou" a"="ȷ "ou" a"="2ȷ "ou" a"="3ȷ "ou" ...`
Qui s'écrit :
`AAa, a "∈" {0,ȷ,2ȷ,3ȷ,4ȷ,...}`
Et qui s'écrit encore :
`AAa,EEn"∈"NN, a"="nȷ`
A la différence des axiomes précédent, celui-ci n'est pas du premier ordre. Il utilise soit une formule de taille infinie, ou bien il utilise deux types d'élément, les éléments de `D` et les éléments de `NN`.
On adopte la notation ensembliste qui consiste à distribuer les opérations à tous les éléments des ensembles utilisés comme arguments, tel que par exemple :
`{a,b}{c,d,e}f = {acf,adf,aef,bcf,bdf,bef}`
L'axiome exprimant la monogénéité du monoïde, de générateur `ȷ`, s'écrit vue de l'extérieur :
`NNȷ=D`
Et cette égalité n'est pas du premier ordre car `NN` est un ensemble infini et constitue un élément de type différents de celui des éléments appartenant à `D`.
Une énumération d'opérateurs entourées de braquette `"<"...">"` désigne la clotûre par composition close des opérateurs en question. Nous écrivons la condition de monogénéité du monoïde d'une façon générale par l'égalité suivante :
`"<"ȷ,0,"+>=" D`
Et cette égalité n'est pas du premier ordre car la clôture par composition close correspond à une infinité de termes, tous les termes que l'on peut construire en composant les opérateurs générateurs entre eux. Vue de l'intérieur, on utilise le mot `"Self"` pour désigner l'ensemble sous-jacent implicite qui est construit par les opérateurs générateurs.
`"<"ȷ,0,"+>=Self"`
Cet axiome constitue la théorie d'engendrement qui permet de construire tous les éléments de la structure par un processus récurcif simple et général que constitue la clôture par composition close des opérateurs générateurs. C'est pourquoi la récursivité simple et générale est dite consubstantielle à la notion de structure.
Par contre, dans la description classique, la structure possède un ensemble sous-jacent qui regroupe les éléments d'un modèle satisfaisant la théorie de la structure, et la question de l'engendrement ne se pose pas, la structure est supposée innée, autrment dit `D` est supposé être un ensemble. Ainsi, considérons le langage `"<+(.,.)>", D"(.)"`. Vue de l'exterieur, nous avons l'équivalence logique suivante :
`"Monoïde commutatif"(D,"+") <=> EE0"∈"D,AA(a,b,c)"∈"D^3,((a"+"(b"+"c)"="(a"+"b)"+"c),(a"+"b"="b"+"a),(a"+"0"="a))`
Cette définition est du premier ordre. Le monoïde monogène de manière classique, admet un élément générateur rajouté par quantification existentielle :
`"Monoïde commutatif monogène"(D,"+") <=> EE(0,ȷ)"∈"D^2,AA(a","b","c)"∈"D^3,((a"+"(b"+"c)"="(a"+"b)"+"c),(a"+"b"="b"+"a),(a"+"0"="a),(D"=<"ȷ"," 0"," "+>"))`
Et cette définition n'est pas du premier ordre car la clôture par composition close `"<"ȷ", "0", +>"` correspond à une infinité de termes, tous les termes que l'on peut construire en composant les opérateurs générateurs entre eux. Notez par ailleurs que tout monoïde monogène est commutatif.
Vue de l'intérieur, et en considérant connus par la structure, c'est à dire compris dans son langage, tous ses opérateurs générateurs, nous avons l'équivalence logique suivante :
`"Monoïde commutatif monogène"("+",0,ȷ) <=> AAaAAbAAc,((a"+"(b"+"c)"="(a"+"b)"+"c),(a"+"b"="b"+"a),(a"+"0"="a),("Self=<"ȷ"," 0"," "+>"))`
A ce stade, `(D, "+")` peut être par exemple un groupe cyclique que l'on note selon le nombre d'éléments `(C_1,"+")`, `(C_2,"+")`, `(C_3,"+")`, `(C_4,"+")...`. Dans le cas d'un groupe cyclique à `1` élément `D"=" {0}` et `ȷ"="0`. Dans le cas d'un groupe cyclique à `2` éléments `D"="{0,ȷ}` et `ȷ"+"ȷ"="0`. Dans le cas d'un groupe cyclique à `3` éléments `D"="{0,ȷ,ȷ"+"ȷ}` et `ȷ"+"ȷ"+"ȷ"="0`. Dans le cas d'un groupe cyclique à `4` élément `D"="{0,ȷ,ȷ"+"ȷ,ȷ"+"ȷ"+"ȷ}` et `ȷ"+"ȷ"+"ȷ"+"ȷ "=" 0`, etc..
Tout monoïde comprend un élément neutre et celui-ci avec la loi interne engendre un groupe `(C_1,"+")`. Aussi tout monoïde amet un sous-groupe `(C_1,"+")`.
D'une façon exhaustive, `(D, "+")` peut être, soit un monoïde admettant un sous-groupe cyclique autre que `(C_1,"+")`, ou bien, soit un monoïde ne contenant pas de sous-groupe cyclique autre que `(C_1,"+")`. Du fait de la monogénéité, cette dernière hypothèse correspond au monoïde des entiers naturels `(NN,"+")`.
Il faut donc ajouter une hypothèse supplémentaire qui affirme que `ȷ` engendre librement `(D,"+")`, et qui exclut la présence de sous-groupe cyclique autre que `(C_1,"+")`. C'est l'axiome suivant qui utilise la multiplication programmative par un entier, et qui n'est pas du premier ordre :
`"Libre" ("+",ȷ) <=> ` `AA(n,m)"∈"NN^2, n"≠"m => nȷ"≠"mȷ`
Cet axiome affirme également que l'application de `NN->D` qui associe à chaque entier `n` la valeur `nȷ` est injective et comme nous avons `NNȷ=D` nous savons à présent que cette application est bijective. Et le préordre canonique devient une relation d'orde totale :
`"Antisymétrique"("⩽")` ` <=> ` `AAaAAb, (a"⩽"b "et" b"⩽"a) => a"="b` `"Total"("⩽")` ` <=> ` `AAaAAb, (a"⩽"b" ou "b"⩽"a)`
C'est la liberté du monoïde `(D,"+")` qui assure l'antisymétrie de l'ordre, et c'est la monogénéité du monoïde qui assure l'ordre totale.
Puis on formalise l'isomorphisme de monoïde que nous avons construit précédement :
`AA(n,m)in NN^2`
`((0ȷ = 0),((n"+"m)ȷ =nȷ"+"mȷ))`
par un entier : `NN"×"D->D``n"≠"m=>nȷ"≠"mȷ` `NNȷ"="D`
A ce stade, `(D, "+")` est isomorphe au monoïde des entiers naturels `(NN,"+")`. Ainsi `D` est identifiable à `NN`, et `ȷ` est identifiable à `1`. On conclut qu'il n'existe qu'un seul monoïde commutatif monogène libre à isomorphisme près qui est celui des entiers naturels.
Une fois la notion de valeur créée, on définit la notion de valeur relative, que l'on peut ainsi ajouter ou soustraire. Cela revient à plonger le monoïde qui est l'ensemble des valeurs, dans un groupe qui est un ensemble plus vaste appelé l'ensemble des valeurs relatives.
A ce stade notre monoïde des valeurs est celui des entiers naturels `(NN,"+")`.
On construit habituellement le groupe des entiers relatifs `(ZZ,"+")` à partir du monoïde des entiers naturels `(NN,"+")`, en considérant les couples d'entiers naturels munis de l'addition `"+"` composante par composante, et où la première composante représente un gain et la seconde composante représente une perte, et en considérant la relation d'équivalence suivante :
`(a,b)~~(A,B) <=> a"+"B=b"+"A`
`(ZZ,"+")` est alors défini comme étant l'ensemble des classes d'équivalence, ce qui se note :
`(ZZ,"+") = (NN,"+")^2 "/"~~`
Et cela se note explicitement comme étant le quotient du monoïde `(NN,"+")^2` par une théorie universelle :
`(ZZ,"+") = ((NN,"+")^2)/({(a,b)"="(A,B)<=>a"+"B"="b"+"A})`
Notez que dans la théorie universelle du premier ordre portée au dénominateur, toutes nouvelles variables qui ne figure pas dans le langage de la structure est implicitement quantifié universellement, ici sur `NN` puisque ce sont des composantes d'élément de `NN^2` qui sont invoquées.
Notez que la théorie du premier ordre de la structure ainsi construite `(ZZ,"+")` qui s'avèrera être un groupe, comprend celle du monoïde `(NN,"+")`, la forme des termes désignant les éléments, qui sont des couples d'élément de `NN`, et l'axiome universelle suivant :
`AAaAAbAA A AAB, (a,b)"="(A,B) <=> a"+"B"="b"+"A`
Mais il existe un autre procédé pour construire `(ZZ,"+")` utilisant le mécanisme d'extension élémentaire, et qui a ainsi l'avantage d'en dévoiler les subtilités. L'extension élémentaire étant la clef de voûte dans la construction des structures, c'est cette deuxième méthode qui sera choisi dans l'ordre quasi-canonique de construction évoqué en introduction. Et elle répond à une question plus vaste. Y a-t-il plusieurs possibilités (non isomorphe) d'ajouter au monoïde `(NN,"+")` un nouvel opérateur unaire `-"(.)"` fabriquant les valeurs opposées c'est à dire tel que `AAa, ("-"a)"+"a=0`, et ainsi de plongé `(NN,"+")` dans un groupe par l'adjonction de cet opérateur.
On étend le monoïde commutatif `(NN,"+")` en ajoutant à la structure un opérateur unaire appelé opposé et notée `"-(.)"`. Et on procède précisement à une extension élémentaire libre, c'est à dire que l'on ajoute cet opérateur dans le langage de la structure sans changer sa théorie du premier ordre. On augmente ainsi la puissance expressive de sa théorie d'engendrement, mais on laisse inchangé sa théorie du premier ordre. Cela a comme conséquence la création de nouveaux éléments désignés par les nouveaux termes que l'on peut construire à l'aide de ce nouvel opérateur unaire `"-(.)"` , sauf si la théorie de la structure prouve que ces nouveaux termes sont égaux à des termes déjà existant.
Puis on ajoute à la théorie d'égalité le rôle de l'opérateur `"-"`, à savoir, produire un élément opposé :
`"Opposé"("+",0,"-") <=> ` `AAx, x"+"("-"x) "=" 0`
On note `ZZ^"+"=NN` la structure initiale qui est appelée l'ensemble des valeurs positives. On note `ZZ^"-"="-"NN` l'image de la structure initiale par l'application `"-(.)"` et qui est appelée l'ensemble des valeurs négatives. Et nous démontrons qu'il n'existe pas de valeur engendrée en dehors de `ZZ^"+"uuZZ^"-"` c'est à dire que :
`"<"0,1,"+","-"">" = ZZ^"+"uuZZ^"-"`
Pour démontrer cela de façon formelle, on démontre simplement que tous les opérateurs générateurs `{0,1,"+","-"}` appliqués à des éléments de `ZZ^"+"uuZZ^"-"` produisent des éléments de `ZZ^"+"uuZZ^"-"`.
Le seul cas non trivial qu'il convient d'analyser est la somme d'un élément `x "∈" ZZ^"+"` et d'un élément `y "∈" ZZ^"-"`. Nous avons `(x,"-"y) "∈" NN^2`.
Dans un monoïde monogène libre, il existe un ordre canonique `"⩽"`. C'est le préordre canonique du monoïde, et qui s'avère être antisymétrique et donc constituer un ordre grace à la monogénéité du monoïde, et qui s'avère être total et donc constituer un ordre total grace à la liberté du monoïde.
Comme `(x,"-"y) "∈" NN^2`, deux cas peuvent se produisent. Soit `x ⩽ "-"y` ou bien `"-"y⩽x`. Dans le premier cas, `x ⩽ "-"y` entraine qu'il existe `z "∈" NN` tel que `x"+"z="-"y`, donc `y"+"x"+"z=y"+"("-"y)`, donc `y"+"x"+"z = 0`, donc `y"+"x"+"z"+"("-"z) = 0 "+" ("-"z)`, donc `y"+"x="-"z`. Dans le second cas, `"-"y⩽x` entraine qu'il existe `z "∈" NN` tel que `("-"y)"+"z=x`, donc `y"+"("-"y)"+"z=y"+"x`, donc `z=y"+"x`.
A ce stade, nous dirons que `(ZZ,"+")` est un groupe abelien monogène libre, abelien signifiant commutatif et rendant homage aux travaux de Niels Abel sur les groupes commutatifs. Et en notation programmative et en utilisant comme langage d'opérateurs `{0,1,"-(.)","+(.,.)"}` nous avons :
`ZZ =` Groupe abelien monogène `("+",0,"-",1)`
Le 1er argument `"+"` désigne l'opérateur binaire du groupe. Le 2nd argument `0` désigne l'élément servant d'élément neutre. Le 3ième argument `-` désigne l'opérateur unaire donnant l'opposé. Le 4 ième argument `1` désigne l'élément générateur.
Cette structure possède une théorie universelle d'égalité du premier ordre et une théorie d'engendrement exprimées par les axiomes suivants utilisant le langage d'opérateurs transmis en argument :
`"Associatif"("+")"` `AAaAAbAAc, a"+"(b"+"c) = (a"+"b)"+"c` `"Commutatiité"("+")"` `AAaAAb, a"+"b= b"+"a` `"Élément neutre"("+",0)` `AAa, a"+"0 = a` `"Opposé"("+",0,"-")` `AAa, a"+"("-"a) "=" 0` `"Engendrement"(0,1,"+","-")` `"Self" = "<"1,0,"-","+>"`
Le symbole `"Self"` désigne l'ensemble sous-jacent énuméré par l'axiome d'engendrement
Les théories universelles du premier ordre du semi-groupe, du monoïde et du groupe commutatif se résume dans ce tableau où les variables qui ne sont pas mentionnées dans les opérateurs passés en argument des patrons, sont implicitement quantifiées universellement :
`a"+"(b"+"c) = (a"+"b)"+"c`
commutatif `("+")`
commutatif `("+",0)`
abelien `("+",0,"-")``a"+"b = b"+"a` `a"+"0 = a` `a"+"("-"a) "=" 0`
Puis, il apparaît une difficulté pour définir au premier ordre la relation d'ordre `"⩽"` dans `ZZ`. Car on ne sait pas définir `ZZ^+` au premier ordre. Mais cette difficulté n'existera plus lorsque la multiplication sera définie :
`"Préordre dans"(ZZ,"+","⩽")` `<=>` `AAaAAb, a"⩽"b <=> EEc"∈"ZZ^+, b"="a"+"c`
`ZZ^+ = NN = "<"0,1,"+>"`
--- 22 août 2019 ---
Ainsi un monoïde commutatif monogène `"Monoïde commutatif"("+",0,1)`, ce qui veut dire `NN`, se plonge de façon unique (à isomorphisme près) dans un groupe, par extension élémentaire d'une fonction unaire `-"(.)"` sur laquelle on force la règle d'égalité `AAa, a"+"("-"a) "=" 0`. Peut-on en dire de même pour la structure de demi-anneau commutatif sans autre générateurs que les éléments neutres de l'addition et de la multiplication ? C'est un problème plus compliqué car pour le demi-anneau on procède par l'extension élémentaire d'un opérateur binaire `"⁎(.,.)"`, qui est donc sucesptible de créer beaucoups plus de nouveaux éléments, et qui enrichie le langage de la structure et permet d'engendrer des termes de grande complexité.
Dans la littérature, l'anneau est implicitement unitaire, c'est à dire qu'il possède un élément neutre pour la multiplication. Et lorsqu'il n'en possède pas il est appelé un pseudo-anneau. De même pour le demi-anneau, un demi-anneau sans unité est appelé un hémi-anneau. Un demi-anneau est donc une structure possédant deux opérations binaires : La première est appelé l'addition et forme un monoïde. La seconde est appelé la multiplication et forme un monoïde. Et la seconde est distributive par rapport à la première.
Les théories universelles du premier ordre du semi-groupe, du monoïde et du demi-anneau se résume dans ce tableau où les variables qui ne sont pas mentionnées dans les opérateurs passés en argument des patrons, sont implicitement quantifiées universellement :
| `a"+"(b"+"c) = (a"+"b)"+"c` |
Semi-groupe commutatif `("+")` |
Monoïde commutatif `("+",0)` |
Demi-anneau commutatif `("+",0,"⁎",1)` |
| `a"+"b = b"+"a` | |||
| `a"+"0 = a` | |||
| `a(bc) "=" (ab)c` | Semi-groupe commutatif `("⁎")` |
Monoïde commutatif `("⁎",1)` |
|
| `ab"=" ba` | |||
| `a1"="a` | |||
| `a(b"+"c) "=" ab"+"ac` | |||
La théorie universelle du premier ordre du demi-anneau commutatif est donc consituée de ces 7 axiomes universelles d'égalité.
Si on ne considère aucun autre opérateur générateur que ceux mentionnés dans le langage du demi-anneau, c'est à dire apparaissant dans l'expression de sa théorie du premier ordre, on dira que la structure est agène, parcequ'on ne lui adjoint pas d'élément générateur supplémentaire. On ne peut pas faire moins ce qui n'exclut pas les cas dégénérés où `0"="1`. La théorie d'engendrement du demi-anneau commutatif agène est :
`"Self" = "<"0,1,"+(.,.)","⁎(.,.)>"`
Puis on explore tous les termes que l'on peut construire. On constate que le zéro `0` possède un comportement spécial. Il est possible d'ajouter à la théorie que l'élément neutre de l'addition doit être un élément absorbant pour la multiplication, mais cela fait perdre une symétrie qu'il peut être utile de conserver. Il faudra donc prévoir d'étudier les nouveaux éléments qu'engendre la présence d'un zéro non astreint au rôle d'élément absorbant. Mais dans notre première approche des espaces métriques, nous choisirons la solution simple consistant à rajouter cet axiome :
`"Absorbant"("⁎",0)"` `AAa, a"⁎"0"="0`
Deux opérations binaires peuvent engendrer des termes d'une trés grande complexité. Et c'est la théorie du premier ordre de la structure qui va permettre de définir une forme normale des éléments, de complexité raisonnable. La distributivité du produit sur l'addition, et le fait que les deux opérations sont associatives et commutatives, permet de développer tout terme en une somme de `1`. Autrement dit le demi-anneau commutatif agène est le demi-anneau `(NN,"+","⁎")`.
Dans un monoïde monogène, chaque générateur permet de définir une multiplication à l'intérieur du monoïde, c'est à dire sans avoir besoin d'ajouter des éléments à la structure. Le choix d'une grandeur servant d'étalon, noté `ȷ`, correspond au choix d'une unité de mesure, et correspond au choix d'un élément générateur. Une fois ce choix établi, on peut définir la mutliplication en posant cet étalon comme élément neutre, `AAx, ȷx"="x`. Une fois ce choix fait, du fait que la multiplication doit être associative, commutative et distributive par rapport à `"+"` et admettre `ȷ` comme élément neutre, et l'élément neutre de l'addition comme élément absorbant, celle-ci ne peut être définie que d'une seule façon, et c'est la distributivité qui va établire la table de multiplication comme dans l'exemple suivant :
`2ȷ"⁎"3ȷ= 2ȷ3ȷ = (ȷ"+"ȷ)(ȷ"+"ȷ"+"ȷ) = ȷȷ"+"ȷȷ"+"ȷȷ"+"ȷȷ"+"ȷȷ"+"ȷȷ = 6ȷȷ = 6ȷ`
Ainsi nous définissons la multiplication des valeurs entre-elles grace au produit programmatif comme suit, et qui ne fait que transporter par le biais de l'isomorphisme de monoïde l'opération de multiplication programmative :
`"Multiplication"("+","⁎") <=> ` `AAaAAb, AA(A,B)"∈"NN^2, (a"="Aȷ "et" b"="Bȷ) => ab"="ABȷ`
La définition de la multiplication n'est pas du premier ordre, mais est placé dans la théorie d'engendrement de la structure, et sert à construire le modèle satisfaisant la théorie globale de la structure. La formulation n'est pas du premier ordre, mais celle-ci peut quand-même être ramené à une formulation du premier ordre grace à l'équivalence que nous venons de dévoiler :
`(("Monoïde commutatif"("+",0)),("Monoïde commmutatif"("⁎",1)),("Distributivité"("⁎","+")),("Monogénéité"("+",0,ȷ))) <=> (("Monoïde commutatif"("+",0)),("Multiplication"("+","⁎")),("Monogénéité"("+",0,ȷ)))`
On dira qu'en présence d'un monoïde monogène `Monoïde monogène ("+",0,ȷ)`, les propriétés du premier ordre d'associativité de commutativité d'élément neutre de la multiplication et de la distributivité de la multipliation par rapport à l'addition, sont équivalente à la définition de la multiplication programmative, ce qui se note :
`(("Monoïde commmutatif"("⁎",1)),("Distributivité"("⁎","+"))) <=>_((("Monoïde commutatif"("+",0)),("Monogénéité"("+",0,ȷ))) ) "Multiplication"("+","⁎")`
A ce stade, la structure `(D, "+", "⁎")` est un demi-anneau qui est engendré par `"<"ȷ,"+>"` et tel que `AA(n,m)"∈"NN^2, n"≠"m => n×ȷ"≠"m×ȷ` où le symbôle `×` représente la multiplication programmative, `n` et `m` représentent des entiers comme programme de multiplication, et `ȷ` représente l'élément générateur sur lequel s'applique les programmes de multiplication.
On présente la structure en notation programmative comme suit, en utilisant le langage d'opérateurs `{0,1,"+(.,.)","⁎(.,.)"}`. Cela a l'avantage d'expliciter chaque opérateur générateur, et d'exprimer les propriétés de monogénéités plus simplement :
`D="Demi-anneau commutatif agène"("+",0,"⁎", ȷ)`
Le demi-anneau est dit agène, car il n'est ajouté aucun élément générateur supplémentaire en dehors des éléments singuliers déjà existants, qui peuvent par ailleurs être égaux entre eux mais que le principe de liberté élémentarienne distingue par défaut sans formellement les différencier.
Le patron « Demi-anneau commutatif agène » donne un rôle à chacun de ses arguments dans un ordre précis : Le 1er argument `"+"` désigne l'opérateur binaire servant pour l'addition. Le 2nd argument `0` désigne l'élément servant d'élément neutre de l'addition. Le 3ième argument `"⁎"` désigne l'opérateur binaire servant pour la multiplication. Le 4ième argument `ȷ` désigne l'élément servant d'élément neutre de la multiplication et qui correspond à l'étalon.
Tous les éléments sont obtenus par composition close de ces opérateurs, ce qui se note :
`D = "<"0,ȷ,"+","⁎"">"`
La théorie d'engendrement portée par le patron et utilisant le langage d'opérateurs transmis en argument est `D = "<"0,ȷ,"+","⁎"">"`. Et lorsque aucune règles d'égalité n'est ajouté, la structure est dite libre. Mais contrairement à l'interpretation classique, la structure peut être incomplète c'est à dire de théorie incomplète.
La théorie d'égalité portée par le patron et utilisant le langage d'opérateurs transmis en argument est :
`(("Monoïde commutatif"("+",0)), ("Monoïde commutatif"("⁎",1)), ("Distributivité"("⁎","+")), ("Absorbant" ("⁎",0)))`
C'est à dire, associativité, commutativité et élément neutre pour l'opération `"+"`, et associativité, commutativité, et élément neutre pour l'opération `"⁎"`, distributivité de `"⁎"` par rapport à `"+"`, et élélment absorbant `0` pour l'opération `"⁎"`.
Comme il n'y a pas d'autre élément générateur, l'axiome `"Monogénéité"("+",0,ȷ)` est vérifiés, ce qui a pour conséquence que les opérateurs d'addition et de multiplication y sont compètement déterminé, l'opérateur de multiplication correspond obligatoirement à la définition canonique `"Multiplication"("+","⁎")` .
Et c'est par définition, la théorie d'engendrement portée par le patron et utilisant le langage d'opérateurs transmis en argument. Mais la multiplication étant définie comme une application de `"<"0,ȷ,"+"">"^2->"<"0,ȷ,"+"">"`, la théorie d'engendrement se simplifie en `D = "<"0,ȷ,"+">"` c'est à dire `"Monogénéité"("+",0,ȷ)`, auquel on ajoute la définition canonique de la multiplication `"Multiplication"("+","⁎")`.
Mais on préfère remplacer ce dernier axiome qui définie constructivement la multiplication mais qui n'est pas du premier ordre, par la théorie équivalente en présence de `"Monoïde commutatif monogène"("+",0,ȷ)` :
`( ("Monoïde commutatif"("⁎",1)), ("Distributivité"("⁎","+")), ("Absorbant" ("⁎",0)))`
La théorie d'engendrement portée par le patron et utilisant le langage d'opérateurs transmis en argument est `"Monogénéité"("+",0,ȷ)`. Et lorsque aucune règles d'égalité n'est ajouté, la structure est dite libre, et donc satisfait `"Libre" ("+",ȷ), ce qui a pour conséquence que le préordre définie canoniquement par `"Inclusion"("+","⩽")` est compétement déterminé et est un ordre total c'est à dire satisfaisant :
`(("Réflexif"("⩽")),("Transitif"("⩽")),("Antisymétrique"("⩽")))`
Ainsi, la théorie d'égalité portée par le patron et utilisant le langage d'opérateurs transmis en argument est `"Demi-anneau commutatif"("+",0,"⁎",1)`, c'est à dire, associativité, commutativité et élément neutre pour l'opération `"+"`, et associativité, commutativité, et élément neutre pour l'opération `"⁎"`, et distributivité de `"⁎"` par rapport à `"+"`. Dans le cas où il n'y a pas d'autre élément générateur, c'est à dire lorsque `"Monogénéité"("+",0,ȷ)` est vérifiés, ce qui a pour conséquence que les opérateurs d'addition et de multiplication y sont compètement déterminé, l'opérateur de multiplication correspond obligatoirement à la définition canonique `"Multiplication"("+","⁎")` .
On remarque qu'une valeur non nulle peut toujours être rendue plus grande qu'une autre valeur en la multipliant par `n`, où `n` est un entier positif suffisament grand. C'est la notion archimedienne de la grandeur. Le monoïde `(D,"+")` est archimedien. L'énoncé de l'axiome d'Archimède est le suivant : « Pour deux grandeurs inégales, il existe toujours un multiple entier de la plus petite, supérieur à la plus grande ». Autrement dit, il n'existe pas de grandeur infiniment grande par rapport à l'étalon `ȷ`.
Le monoïde `(D,"+")` est archimedien : `AA(a,b)"∈"{:D^"⁎":}^2,EEn"∈"NN, na">"b`
Voyons comment il est possible d'exprimer cette propriété en logique du premier ordre.
Dans une structure de demi-anneau totalement ordonné, la propriété d'être archimedien s'exprime au premier ordre comme suit :
`(D,"+","⁎")` Archimedien : `AAaAAbEEc, ("¬"a"="0 "et" "¬"b"="0)=>ca">"b`
On remarquera que `AaAAb,AAn "∈" NN, n(ab)=(na)b`. Grace aux propriétés `"Associatif"(NN,NN,D,"⁎")` et `"Associatif"(NN,"⁎")`, on dira que l'opération typé de multiplication appartenant à :
`(NN"×"NN+NN"×"D+D"×"NN+D×D)->NN+D`
on dira que cette opération est associative et commutative, faisant qu'un produit d'entiers et d'éléments de `D` en nombre quelconque peut être effectuer dans n'importe quel ordre, et que les parenthèses sont inutiles et que l'ordre d'apparition des éléments dans le produit n'a pas d'importance. Ainsi l'ensemble `NN+D` où le signe `"+"` désigne ici l'union disjointe, munie du produit typé, se comportent comme un ensemble de ressource que l'on accumule en les liant par produit.
Pour résumer nous dirons qu'en toute connaissance de cause, on peut identifier `D` à `NN`. A ce stade, nous avons en notation classique :
`(NN,"+")` est un monoïde commutatif monogène libre.
Et en notation programmative, en utilisant comme langage d'opétrateurs `{0,1,"-(.)","+(.,.)"}` :
`NN =` Monoïde commutatif monogène `("+",0,1)`
Le Monoïde commutatif monogène `("+",0,1)` possède une théorie d'égalité et une théorie d'engendrement exprimées par les axiomes suivants utilisant le langage d'opérateurs transmis en argument :
(D1) Associativité : `AAaAAbAAc, a"+"(b"+"c) = (a"+"b)"+"c` (D2) Commutativité : `AAaAAb, a"+"b= b"+"a` (D3) Élement neutre : `AAa, a"+"0 = a` Engendrement : `"Self" = "<"1,0,"+>"`
Le symbole `"Self"` désigne l'ensemble sous-jacent.
Et il existe un ordre canonique `"⩽","⩾","<",">"` et une multiplication canonique `"⁎"`, notée aussi par absence de symbole, définie comme suit :
(L1) `"⩽"` Plus petit ou égale : `AAaAAb, a"⩽"b <=> EEc, b"="a"+"c` (L2) `"⩾"` Plus grand ou égale : `AAaAAb, a"⩾"b <=> b"⩽"a` (L3) `"<"` Strictement plus petit : `AAaAAb, a"<"b <=> a"⩽"b "et" ¬(b"⩽"a))` (L4) `">"` Strictement plus grand : `AAaAAb, a">"b <=> (a"⩾"b "et" ¬(b"⩾"a))` (L5) Multiplication : `AAaAAb, AA(A,B)"∈"NN^2, (a"="A×1 "et" b"="B×1) => ab"="A×B×1`
Où `×` est la multiplication définie programmativement.
C'est la définition de la multiplication qui n'est pas du premier ordre, mais qui est constructive, et qui relève bien du procédé récurcif simple et général consubstantiel à la notion de structure, et qui est naturellement placé dans la théorie d'engendrement de la structure, et qui s'avère être, dans un monoïde commutatif additif monogène où l'élément neutre de notre multiplication est choisi parmis les éléments générateurs, l'unique multiplication possible possédant cet élément neutre, faisant qu'il n'est pas nécessaire de faire référence à la définition de la multiplication qui n'est pas du premier ordre mais seulement à ces 4 axiomes Demi-anneau commutatif `("+",0,"⁎",1)` qui eux sont du premier ordre.
Et on remplace {L5} qui n'est pas du premier ordre par les 4 axiomes suivants :
Associativité : `AAaAAbAAc, a(bc) "=" (ab)c` Commutativité : `AAaAAb, ab"=" ba` Élément neutre : `AAa, a1"="a` Distributivité : `AAaAAbAAc, a(b"+"c) "=" (ab)"+"(ac)`
Car nous avons : {P1,P2,P3,P4} équivalent à {L5} en présence de {D1,D2,D3,E1}, ce qui se note :
{L5} `<=>_("{D1,D2,D3,E1}")`{P1,P2,P3,P4}
L'ajout de l'opérateur de multiplication `"⁎"` transforme la structure en un demi-anneau. A ce stade, nous avons en notation classique :
`(NN,"+","⁎")` est un demi-anneau, qui est engendré par `"<"1,"+>"` et tel que `AA(n,m)"∈"NN^2, n"≠"m => n×1"≠"m×1` où le symbôle `×` représente la multiplication programmative, `n` et `m` représentent des programmes de multiplication, et `1` représente l'élément générateur sur lequel s'applique les programmes de multiplication.
Et en notation programmative, en utilisant comme langage d'opérateurs `{0,1,"+(.,.)","⁎(.,.)"}`, cela s'exprime plus simplement :
`NN =` Demi-anneau commutatif agène `("+",0,"⁎",1)`
Le demi-anneau est dit agène, car il n'est ajouté aucun élément générateur supplémentaire en dehors des éléments singuliers déjà existants, qui peuvent par ailleurs être égaux entre eux mais que le principe de liberté différencie par défaut au départ dans une structure libre.
Le Demi-anneau commutatif agène `("+",0,"⁎",1)` possède une théorie d'égalité et une théorie d'engendrement exprimées par les axiomes suivants utilisant le langage d'opérateurs transmis en argument, la multiplication "⁎" étant notée par absence de symbole :
(D1) Associativité de `"+"` : `AAaAAbAAc, a"+"(b"+"c) = (a"+"b)"+"c` (D2) Commutativité de `"+"` : `AAaAAb, a"+"b= b"+"a` (D3) Élement neutre de `"+"` : `AAa, a"+"0 = a` Associativité de `"⁎"` : `AAaAAbAAc, a(bc) "=" (ab)c` Commutativité de `"⁎"` : `AAaAAb, ab"=" ba` Élément neutre de `"⁎"` : `AAa, a1"="a` Distributivité de `"⁎"` : `AAaAAbAAc, a(b"+"c) "=" (ab)"+"(ac)` Engendrement : `"Self" = "<"1,0,"+","⁎>"`
Et l'addition et la multiplication y sont complètement déterminés. Il n'y a donc qu'un seul demi-anneau commutatif agène libre à isomorphisme près, noté `ZZ`. Et l'ordre total canonique est défini par les axiomes du premier ordres {L1,L2,L3,L4}. Notez que {L1,L2} sont des théories d'égalité du premier ordre tandis que {L3,L4} ne sont pas des théorie d'égalité du premier ordre mais seulement des théories du premier ordre. Notez que `"Self" = "<"1,0,"+","⁎>" = "<"1,0,"+">"`, la multiplication n'apportant aucun nouvel élément que l'addition n'apporte pas déjà.
Et il existe un ordre canonique `"⩽","⩾","<",">"` et une multiplication `"⁎"` canonique définie comme suit :
(L1) `"⩽"` Plus petit ou égale : `AAaAAb, a"⩽"b <=> EEc in , b"="a"+"c` (L2) `"⩾"` Plus grand ou égale : `AAaAAb, a"⩾"b <=> b"⩽"a` (L3) `"<"` Strictement plus petit : `AAaAAb, a"<"b <=> a"⩽"b "et" ¬(b"⩽"a))` (L4) `">"` Strictement plus grand : `AAaAAb, a">"b <=> (a"⩾"b "et" ¬(b"⩾"a))` (L5) Multiplication : `AAaAAb, AA(A,B)"∈"NN^2, (a"="A×1 "et" b"="B×1) => a⁎b"="A×B×1`
On note `ZZ^"+⁎"=NN^"⁎"` qui est appelée l'ensemble des valeurs strictement positives. On note `ZZ^"-⁎"="-"NN^"⁎"` qui est appelée l'ensemble des valeurs strictement négatives. Dans le groupe monogène `(ZZ,+)`, il est définie canoniquement un ordre "⩽", une norme `|"."|`, et le signe `"sign(.)"` comme suit :
`ZZ = ZZ^"-⁎"+{0}+ZZ^"+⁎"`
`ZZ = ZZ^"-⁎"+{0}+ZZ^"+⁎"`
`AAaAAb, a"⩽"b <=> EEc, b"="a"+"c`
ensembliste
d'ordreSi `x "∈" ZZ^"+⁎"` Si `x "⩾" 0` Si `x"∈"(ZZ^"+" nn ZZ^"-")` Si `x "=" 0` Si `x "∈" ZZ^"-⁎"` Si `x "⩽" 0`
A ce stade, `(D, "+", "⁎" )` est l'anneau commutatif agène libre. Ainsi `D` est identifiable à `ZZ`. C'est l'ensemble des valeurs possibles de distance relative entière. Et c'est l'ensemble des valeurs possibles d'une coordonnée entière. Puis on présente la structure en notation programmative comme suit :
`D=` Anneau commutatif agène libre `("+",0,"-","⁎", 1)`
Le patron « Anneau commutatif agène » donne un rôle à chacun de ses arguments dans un ordre précis :
Le 1er argument désigne l'opérateur binaire servant pour l'addition.
Le 2nd argument désigne l'élément servant d'élément neutre de l'addition.
Le 3ième argument désigne l'opérateur unaire opposé.
Le 4ième argument désigne l'opérateur binaire servant pour la multiplication.
Le 5 ième argument désigne l'élément servant d'élément neutre de la multiplication.
La définition de la relation d'ordre devient :
(L1bis) `"⩽"` Ordre canonique : `AAaAAb, a"⩽"b <=> EEc "∈" D^"+", b"="a"+"c`
Mais on préfère redéfinir l'ordre à partir d'une notion d'ordre total compatible avec la structure d'anneau. C'est à dire un ordre total invariant par translation et respectant le produit des signes :
(O1) `"⩽"` Invariant par translation : `AAaAAbAAc, a"⩽"b => a"+"c"⩽"b"+"c` (O2) `"⩽"` Respecte le produit des signes : `AAaAAb, (a"⩾"0 "et" b"⩾"0) => ab"⩾"0` (O3) `"⩽"` Total : `AAaAAb, (a"⩽"b" ou "b"⩽"a)`
Dans un anneau commutatif agène libre, il n'existe qu'un seul ordre total compatible avec la structure d'anneau. Les trois axiomes {O1,O2,O3} remplace la définition {L1bis}.
La définition de la multiplication s'obtient en posant l'étalon `ȷ` comme élément neutre, `AAx, ȷx=x`.
L5bis Multiplication : `AAaAAb, AA(A,B)"∈"ZZ^2, (a"="Aȷ "et" b"="Bȷ) => ab"="ABȷ`
La théorie portée par le patron et utilisant le langage d'opérateurs transmis en argument est {D1,D2,D3,L5bis}.
------------2019----------