Le raisonnement exacte est un procédé mécanique c'est à dire dont la production et la vérification peut être faite par une machine, un automate composé de rouages et de pièces mécaniques parfaitement emboîtés sans aucun jeu, et en appliquant la mécanique classique. On formalise cette machine en un ordinateur, ou en un procédé dit effectif. Le raisonnement, pour être incontestable, doit pouvoir s'effectuer par un programme informatique. On résume cette propriété en disant qu'il doit être calculable. Le raisonnement est un calcul. Le raisonnment est un procédé effectif.
Néanmoins, même si nous considérons la nature du raisonnement comme étant mécanique, il existe une partie inexacte qu'est l'intuition et qui est la partie la plus intéressante de la logique. Elle se rapproche davantage d'une culture, d'un corpus idéologique ou d'une âme que d'un procédé mécanique et n'est pas préconstruite puisque c'est à nous de la construire, à l'observateur de s'en faire une, et qui, parceque revendiquant une part de liberté irréductible, constituera une part de lui-même.
La logique est la science du raisonnement. Et on ne peut concevoir de raisonnement sans langage formel. Qu'est-ce qu'un langage formel ? c'est un ensemble de mots composés de caractères, qui est énumérable par une machine. On a donc un alphabet fini `A`, puis un langage mère qui est l'ensemble des listes finies de caractères de `A` appelés mots, noté avec l'étoile de Kleene, `A"*"`, et qui comprend la liste vide correspondant au mot vide noté `epsilon`. Par exemple :
`A = {a,b,c}`
`A"*" = {epsilon, a,b,c,aa,ab,ac,ba,b b,bc,ca,aaa,aab,...}`
`A"*"` joue le rôle de carrière. Les langages formels sont des sous-ensembles de `A"*"` énumérables par une machine.
La hierarchie de Chomsky est une découverte fondamentale démontrée en 1959 par Noam Chomsky, célèbre linguiste américain. Il classifie les langages formels en 4 types inclus l'un dans l'autre, du plus général au plus simple :
Pour établir cela, il part d'un langage mère, `A"*"`, l'ensemble des mots d'un alphabet fini, qui joue le rôle de carrière. C'est le langage le plus simple dans lequel peuvent plonger tous les autres langages.
Nous n'allons pas nous intéresser à la base de cette classification que sont les langages rationnels, mais directement au sommet, que sont les langages énumérables. Et par définition, on appellera langage, les seuls langages énumérables.
On remarque qu'en ordonnant les caracatères, on définit une bijection canonique entre `A"*"` et l'ensemble des entiers naturels `NN`. Chaque mot est associé à un entier écrit en base `n`, où `n` est le nombre de caractères de l'alphabet `A`. On obtient ainsi le langage `NN` qui peut paraître encore plus rudimentaire.
On remarque qu'en faisant apparaitre l'opérateur binaire de concaténation `"∗"` entre chaque caractère d'un mot, on projette un langage terminologique sur le langage `A"*"`. Ainsi, au lieu d'utiliser le langage rationnel `A"*"` comme carrière nous pouvons utiliser un langage terminologique noté `B°` qui est un langage algébrique plus riche qu'un langage rationnel, où `B` est un ensemble d'opérateurs de base qui servent d'opérateurs générateurs. Le langage terminologique est l'ensemble des compositions closes finies d'opérateurs générateurs non-évaluées appelées termes. C'est le domaine de Herbrand. Par exemple :
`B = {a,b,f"(.)",g"(.,.)"}`
`B° = {a,b,f(a),f(b),g(a,a),g(a,f(a)), f(f(b)), g(f(a),f(b)),...}`
Si la carrière est `NN`, alors les langages sont des ensembles énumérables d'entiers naturels.
Si la carrière est `A"*"` , alors les langages sont des ensembles énumérables de mots.
Si la carrière est un langage terminologique `B°`, alors les langages sont des ensembles énumérable de termes.
Puis, rien n'interdit de choisir comme carrière des langages encore plus évolués... Une fois la carrière définie, ce qui définit une sorte de langage formel, on précise le deuxième critère propre au langage : Il doit être énumérable par une machine. Ce dernier point ce décrit à l'aide de machines dont la définition formelle pose une difficultée toujours irrésolue qui est discutée dans la thèse de Church-Turing. Pour résoudre cette difficultée, on explore un large spectre de formes les plus rudimentaires possibles de machines Turing-complètes c'est-à-dire pouvant faire les mêmes calculs qu'une machine de Turing, en tentant d'atteindre une sorte d'exhaustivité.
L'intérêt de partir de la forme la plus générale du raisonnement, du calcul, de ce qu'on appelle un procédé effectif, est de pouvoir étudier toutes les logiques possibles et inimaginables.
La façon de présenter le fonctionnement de ces machines peut se faire sous forme de programme informatique, qui s'avère plus abordable pour les néophites, car utilisant un langage de programmation toujours adaptable au problème, trouvant toujours une codification astucieuse des proccédures effectives, et que nous créerons sur mesure, alors que la définition mathématique de ces machines est particulièrement hermétique et illisible. Puis, on pourra exécuter ces programmes et vérifier expérimentalement quelques-unes de leurs propriétés. On voit ici en quoi la logique prend ses fondements dans l'informatique.
C'est alors que vient l'idée de la conception d'un langage de programmation obtenu en étudiant la machine par le haut, dans le but de circonscrire les différentes formes possibles que peut prendre une machine, les différents formes de processus de calcul qu'il est possible d'imaginer.
Avant la logique, la contradiction n'existe pas, ou plus précisément la négation n'existe pas, cette étonnante symétrie est ignorée, non-atteinte ou non-construite. Néanmoins le raisonnement existe. Il est même nullement altéré dans sa complexité par l'absence de négation. Il est dit prélogique ou sans négation. La proposition n'ayant pas de négation, elle obtient les qualités générales d'un élément c'est pourquoi on l'appelle aussi un élément.
Les propositions n'ont pas de négation. elles sont connues ou inconnues. Lorsqu'elles sont connues c'est qu'elles ont été démontrées, et lorsqu'elles sont inconnues, c'est qu'à l'état actuel où on les évoque, elles n'ont pas encore été démontrées. Les propositions démontrées sont dites tautologiques. Puis en ce plaçant à la fin des temps..., les propositions qui ne sont toujours pas démontrées sont dites indémontrables.
Dans les cas non-triviaux, l'ensembles des propositions indémontrables n'est pas énumérables. C'est à dire qu'il n'existe pas de machine capable d'énumérer cet ensemble. Et on peut démontrer cela assez facilement grâce au paradoxe de Godel-Turing, qu'est l'indécidabilité du problème de l'arrêt.
Au départ, on part d'un langage prélogique noté `L` dont on ne connait presque rien sauf que c'est un ensemble énumérable de propositions, et qui constituera l'ensemble des propositions exprimables. Et donc qu'il existe un processus souche qui énumère cet ensemble, où l'on entend par processus, un procédé effectif c'est-à-dire une machine. Puis, il existe un sous-ensemble énumérable regroupant toutes les tautologies, noté `T`, qui est énuméré par un processus appelé système de démonstration ou machine démonstrative.
Il existe donc deux machines, l'une dite souche qui énumère toutes les propositions, et l'autre dite démonstrative qui énumère toutes les tautologies.
Mais la définition de la prélogique, pour être complète, doit définir en plus une sémantique.
La syntaxe la plus générale étant ainsi décrite en posant deux processus, un processus souche qui énumère les propositions, et un processus démonstratif qui énumère les seules propositions tautologiques, il convient maintenant de définir la signification réelle des propositions. La sémantique d'une proposition se définit comme l'ensemble des mondes où la proposition est réalisée. Mais on n'a pas définit ce qu'était un monde ni comment une proposition se réalise dans un monde.
On va le faire par construction, en ajoutant au langage prélogique un opérateur logique binaire qu'est l'implication `"⇒"`, et en étendant d'une façon librement arbitraire la machine démonstrative, ce qui va de paire avec l'extension du langage prélogique, puis en ajoutant à la machine démonstrative deux règles de production ; la règle du modus ponens, et sa réciproque :
Quelles que soient deux propositions `x`, `y`, si les propositions `x` et `(x"⇒"y)` sont démontrées alors `y` est démontrée.
Quelles que soient deux propositions `x`, `y`, si le fait d'ajouter dans la machine démonstrative la règle qui dit que `x` est une tautologie, permet de démontrer `y`, alors `(x"⇒"y)` est démontrée.
On peut alors définir pour chaque proposition `x`, une machine démonstrative que l'on nomme pareillement `x` et dans laquelle on a ajouté la règle qui dit que la proposition `x` est une tautologie. Ainsi, la machine `x` énumére un ensemble de propositions appelées les conséquences de `x`.
Etant donné deux propositions `x, y`, on note `x |-- y` pour signifier que `y` est une conséquence de `x`, Autrement dit, la machine `x` finira au bout d'un certain temps par produire `y` au cours de son monologue énumératif. Et on dira que `x` implique `y`.
Notez que si `x` énumère `y` alors à l'aide de la seconde règle qu'est la réciproque du modus ponens, `x` énumèrera `(x"⇒"y)`. Réciproquement, si `x` énumère `(x"⇒"y)` comme `x` énumère `x`, en appliquant la première règle qu'est le modus ponens, `x` énumèrera `y`. Ainsi, quelque soit deux propositions `x,y`, la proposition `x` démontre la proposition `y` si et seulement si la proposition `x` démontre la proposition `(x"⇒"y)` :
`x|--y` si et seulement si `x|--(x"⇒"y)`
On peut alors définir une pré-sémantique portant sur les mondes finis.
La pré-sémantique se définit comme suit : Les mondes sont les propositions. Un monde `y` réalise une proposition `x` si et seulement si la proposition `y` implique la proposition `x`. La pré-sémantique d'une proposition `x` est l'ensemble des mondes finis qui satisfont `x`, autrement-dit l'ensembles des propositions qui implique `x`, appelé aussi l'ensemble des inductions de `x`. Le monde est qualifié de fini car il est entièrement défini par une proposition qui est par principe une expression de taille finie.
Ainsi l'élément `x` possède trois rôles ; celui d'une proposition, celui d'une machine qui énumère toutes les conséquences de `x`, et celui d'un monde fini qui satisfait toutes les conséquences de `x`.
Dans les cas non-triviaux, l'ensemble des propositions qui ne sont pas conséquences de `x`, ou autrement-dit qui ne se réalise pas dans le monde fini `x`, forme un ensemble non-énumérable.
On note `x |== y` pour signifier que `x` réalise `y`. Dans cette situation pré-sémantique, quelque soit deux propositions `x,y`, Le monde `x` réalise la proposition `y` si et seulement si `x` implique `y` :
`x |== y` si et seulement si `x |-- y`
Mais le principe d'un monde est qu'il peut réaliser une infinité arbitraire de propositions. On peut définir les mondes comme des ensembles de propositions qu'ils doivent satisfaire. On va définir une telle sémantique encore par construction, en ajoutant au langage prélogique un second opérateur logique binaire qu'est la conjonction `"et"`, et en étendant de façon librement arbitraire la machine démonstrative, ce qui va de paire avec l'extension du langage prélogique, puis en ajoutant à la machine démonstrative deux règles de productions, l'élimination de la conjonction, et l'introduction de la conjonction.
Quelles que soient deux propositions `x`, `y`, si la propositions `(x "et" y)` est démontrée alors `x` est démontrée, et `y` est démontrée
Quelles que soient deux propositions `x`, `y`, si `x` est démontrée, et que `y` est démontrée, alors la propositions `(x "et" y)` est démontrée
Nous verrons comment adjoindre à ces machines une infinité de règles de production sachant que le procédé effectif ne mettra en oeuvre à chaque production nécessairement qu'une partie finie de cet ensemble de règles. On définira pour chaque ensemble de propositions et pour chaque partie finie de cet ensemble, une machine démonstrative `M` en ajoutant une règle pour chaque proposition de la partie finie considérée qui dit que la proposition est une tautologie. `M` énumére un ensemble de propositions appelées les conséquences de `M`. Rappellons que, le processus énumérant les propositions démontrables étant un procédé effectif, il ne peut utiliser à chaque fois qu'une partie finie de l'ensembles des règles rajoutées.
On peut alors définir la sémantique comme suit : Les mondes sont des ensembles de propositions, et chaque sous-ensemble fini forme une machine démonstrative dite appartenant au monde en question. La sémantique d'une proposition `x` est l'ensemble des mondes qui ont au moins une machine démonstrative démontrant `x`.
Pour procéder à cette construction de façon formelle, on va développer un langage informatique adapté à ce problème. Mais on va d'abord développer un environement théorique.
On va d'écrire les langages terminologiques, que nous choisirons comme langage mère. Le langage est la clef de toute chose. Le premier niveau de langage qu'il convient de présenter est celui basé sur la composition d'opérateurs d'arité fixe d'un même type de base, pour former une terminologie monotype tels les domaines de Herbrand, puis utilisant un ensemble de types, pour former une terminologie multitype. Et l'ensemble des types qui l'accompagne peut aussi être infini et construit comme une terminologie appelé typologie. Ces langages permettent de définir une notion de réccurence trés générale sans utiliser les entiers. " Ils sont un premier pas vers la conception des théories, la formalisation des preuves et l'écriture des programmes qui les produisent. "
On définira la notion de structure comme le quotient d'un langage terminologique par une relation d'équivalence. Les structures libres sont les langages terminologiques.
Et on définira le produit libre de structure.
On décrit une méthode rudimentaire de construction de termes qui s'apparente à un jeu de Légos. On pose des opérateurs de base dits générateurs, caractérisés par un nom et une arité. Par exemple `a,b,f"(.)",g"(.,.)"` où le suffixe `"(.,.)"` précise que l'opérateur est binaire, où le suffixe `"(.)"` précise que l'opérateur est unaire, et où l'absence de suffixe précise que l'opérateur est nullaire.
La terminologie, ou le langage terminologique, est l'ensemble des compositions closes finies d'opérateurs générateurs non-évaluées appelées termes. C'est le domaine de Herbrand. La clôture par composition close finie se note en entourant de crochets la liste des opérateurs générateurs :
`"<"a,b,f"(.)",g"(.,.)>" = {a,b,f(a),f(b),g(a,a),g(a,f(a)), f(f(b)), g(f(a),f(b)),...}`
On le note également `{a,b,f"(.)",g"(.,.)}"°"` en utilisant l'opérateur de Kleene généralisé `°`. La structure obtenue est libre et coïncide avec le langage terminologique, à condition de ne pas évaluer les termes, ce que l'on s'assure en définissant les opérateurs sous forme terminologique, faisant que l'évaluation du terme redonne le terme.
`f = (x|->bb(f)(x))`
`g = (x,y|->bb(g)(x,y))`
Les fonctions terminologiques `bb(f)(".")` et `bb(g)(".,.")` retournent le terme produit en remplaçant seulement les variables d'appel par leur valeurs.
La structure se perçoit aussi engendrée récursivement à travers une grammaire. Si la structure est nommé `L` alors on peut remplaçer le symbole point par le symbole `L`, et la grammaire s'écrie en invoquant un procédé récurcif, que l'on écrit sous forme d'une équation récurcive.
Mais pour cela on utilise une notation spécifique, une énumération d'éléments entre crochet `{ }` désignant un ensemble aplati. Dans une telle énumération, un même éléments peut avoir plusieurs occurences sans que cela ne change son statut, et si cet élément est un ensemble alors il est remplacé par son contenu. Ainsi par exemple `{a,{b,c},a,c}` sera égale à `{a,b,c}`. Le symbole `{ }` joue certaine fois le rôle de définition d'ensemble aplati, et certaine fois le rôle de définition d'ensemble. Et on laisse au contexte le soin de discerner si l'on parle d'ensemble aplati ou non.
La grammaire s'écrit son forme d'une équation récurcive d'ensembles aplatis :
`L={a,b,f(L),g(L,L)}`
`f(L)` désigne l'énumération obtenue en appliquant `f` à chaque élément de type `L`, et où `g(L,L)` désigne l'énumération obtenue en appliquant `g` à chaque couple d'éléments de type `L`. La notation `{ }` désigne ici un ensemble aplatit.
Comme la récursion doit traduire un procédé effectif, il est nécessairement fini. Le symbole `L` se comporte comme un symbole non-terminal d'une grammaire, et désigne l'énumération des éléments de type `L` produit par la grammaire.
La terminologie est ici monotype car les éléments arguments des opérateurs ainsi que les éléments résultats des opérateurs sont tous d'un même type `L`, autorisant ainsi toutes les compositions.
Afin que le langage qui constitue une structure libre, désigne autre chose que lui-même, on distingue le signifiant du signifié. On distingue le langage `L` regroupant les termes, et l'ensemble sous-jacent `E` regroupant les éléments désignés par les termes. Deux termes distincts peuvent désigner le même élément. Le terme est le signifiant, l'élément qu'il désigne est le signifié.
Le terme correspond au détail d'un calcul d'un élément dans l'ensemble sous-jacent `E`. Les termes `a` et `b` désignent des éléments de base ou générateurs, tandis que les termes `f(a)` et `g(a,f(a))` désignent des éléments qui, s'ils sont distincts de `a` et de `b`, ne font pas partie de la présentation et sont donc dit non-générateurs. La différence qui existe entre un élément et un terme, tient en ce que deux termes distinctes c'est-à-dire d'expression distincte peuvent désigner un même élément.
Les opérateurs générateurs sont nommés pareillement dans les deux structures que sont le langage `L` et la structure `E`. Ainsi selon le contexte, `a` désigne un terme du langage ou un élément de la structure. Et en tant que termes du langage, `a` et `b` sont différent, bien qu'il puisse désigner le même élément et donc être égaux en tant qu'élément de la strucure `E`.
Chaque terme désigne un élément, et cela traduit une surjection `varphi` du langage sur la structure qui doit respecter chaque opérateur c'est-à-dire qui constitue un morphisme surjectif appelé l'évaluation. Autrement dit, quelques soient des termes `x,y` appartenant à `L` nous avons :
`varphi in (L->E)`
`varphi(a)=a`
`varphi(b)=b`
`varphi(f(x))=f(varphi(x))`
`varphi(g(x,y))=g(varphi(x),varphi(y))``varphi(L)=E`
L'expression `(L->E)` désigne l'ensemble des applications de `L` sur `E`.
L'expression `varphi(x)` retourne l'évaluation du terme `x`, c'est-à-dire l'élément désigné par la variable `x`.
L'expression `varphi(L)` désigne l'ensemble obtenue en appliquant `varphi` à chaque éléments de `L`.
L'inférence de type permet de savoir de quelle structure font référence `a,b,f,g`, qui est soit la structure libre `L` ou soit la structure `E`, et que l'on note en indice pour les expliciter :
`varphi(a_L)=a_E`
`varphi(b_L)=b_E`
`varphi(f_L(x))=f_E(varphi(x))`
`varphi(g_L(x,y))=g_E(varphi(x),varphi(y))`
La cohérence de cette description se conforte en ce qu'elle constitue les prémisses d'une programmation informatique dont l'aboutissement pourra être vérifier par l'exécution des programmes qui constitueront autant d'éléments de preuve.
Le morphisme `varphi` définit une relation d'équivalence dans `L`. Et la structure `E` se définit comme la structure quotient, le quotient de `L` par la relation d'équivalence induite par `varphi` :
`E=L/≈_varphi= L/{AAxAAy,varphi(x)"="varphi(y) => x"="y}`
En résumé, les structures sont les images, par morphisme, des langages terminologiques monotypes.
La terminologie multitype comprend différents types d'éléments générateurs par exemple `a^A, b^B`, où le type est mis en exposant, et comprend des opérateurs générateur de type de la forme `A^n"×"B^m->A` ou `A^n"×"B^m->B` où `n` et `m` doivent être des entiers naturels. Les composition doivent naturellement respecter les types attendus, et non les types réels. Par exemple :
`"<"a^A,b^B,f^(A->B),g^(A"×"B->A)">" = {a,b,f(a),g(a,b),g(a,f(a)),f(g(a,b)),...}`
La structure se perçoit aussi engendrée récursivement à travers une grammaire. Si la structure est nommé `L` alors elle est engendrée par la grammaire suivante :
`L={A,B}`
`A={a,g(A,B)}`
`B={b,f(A)}`
Où `f(A)` désigne l'énumération obtenue en appliquant `f` à chaque élément de type `A`, et où `g(A,B)` désigne l'énumération obtenue en appliquant `g` à chaque couple d'éléments de type `A"×"B`. Les symboles `L, A, B` se comportent comme des symboles non-terminaux d'une grammaire, et désigne l'énumération des éléments de type respectif `L, A, B` produit par la grammaire.
L'ensemble sous-jacent de la structure engendrée est `L=AuuB`. C'est l'ensemble des éléments désignables par les termes qui sont les compositions closes finies d'opérateurs générateurs respectant les déclarations de type, faisant que l'élément `b` qui est déclaré de type `B` ne peut être utilisé comme argument de `f` qui attend un argument de type `A`, et ceci même si par une circonstance inattendue `b` appartient aussi à `A`. C'est l'appartenance déclarée et non celle réelle qui détermine si la composition est autorisée. De tel sorte que tout terme possède un type facile à déterminer, et que le procédé d'engendrement est calculable et est complètement définie par la présentation. Dans la suite de l'exposé on ne traitera que des cas où les ensembles réels coïncident avec les types.
Un opérateur est une application d'un ensemble de départ vers un ensemble d'arrivé. Etant donné des ensembles `A,B,C` qui constituent les types de base, l'ensemble des opérateurs de `A` vers `B` se note `A"→"B` et constitue un nouveau type.
Les types sont des meta-opérateurs, de telle sorte que comme avec les opérateurs on va définir une terminologie des types qui s'appellera une typologie.
Remarquez qu'un terme peut posséder plusieurs types, par exemple il peut être à la fois de type `A` et de type `B` s'il est déclaré appartenir à l'intersection des types `A` et `B`. Mais plus surprenant, il peut être à la fois un élement de type `A` et un élément de type `B"→"C` et un élément de type `A"×"C->B` faisant qu'il appartient à l'intersection des types `A` et `B"→"C` et `A"×"C->B`. Il cumule ainsi plusieurs rôles distincts qu'il parcours librement.
Rappellons-nous qu'une des propriétés paradigmatiques de l'élément consiste en la capacité de pouvoir désigner toute chose, et que deux éléments intialement distincts peuvent toujours être rendus égaux par simple hypothèse, entrainant toute une conséquence d'égalités comme nous le verrons plutard.
Le méta-opérateur binaire `"→(.,.)"` que l'on note avec le suffixe `"(.,.)"` pour rappeller son arité, et qui est de syntaxe centrée `(".→.")` va permettre de construire de nouveaux types à partir d'autres types. On définit un langage typologique permettant de définir les types, autrement dit, on définie une typologie. C'est l'ensemble des compositions closes finies de meta-opérateurs de base, ce qui se note :
`"<"A,B,C,"→(.,.)>"`
La typologie est dite monometatype car les résultats et les arguments des meta-opérateurs, sont tous d'un même type de type, d'un même meta-type de base qui est le meta-type ensemble. Il n'y a qu'un seul type de type.
Noter que cette typologie ne permet pas de désigner l'ensemble des couples `A"×"B`. Mais pour n'importe quel type `E` du langage typologique, elle permet de désigner l'ensemble des applications de `A"×"B"→"E` sous forme curryfiée, par le type `A"→"(B"→"E)`.
Les extensions libre de structure, qui consiste à ajouter un opérateur générateur dans leur langage terminologique, s'inscrivent dans un mecanisme plus général et symétrique appelé union libre de structure.
Commençons par ne considérer que des langages terminologiques monotypes. La présentation d'un langage est par principe finie, c'est-à-dire que la liste de ses opérateurs générateurs est finie. Les structures, qui sont les images par morphisme de tel langage, sont dites de type fini, c'est à dire qu'elles sont engendrées par un nombre fini d'opérateurs.
L'union libre de deux structures est l'union qui propose le moins de contraintes d'égalité. C'est celle qui étend les opérateurs de chaque structure d'une façon qu'il y est le maximum d'éléments distints possibles. Concidérons deux structures `A,B`. L'union libre se note `"<"A,B">"` en spécifiant que les opérateurs sont étendus par leur forme terminologique. Elle forme une structure libre établie à partir des éléments des structures pouvant être non-libres `A` et `B` et des opérateurs générateurs de ces structures, sachant que si un sous-terme se résoud en un élément de l'une des deux structures, il doit être remplacé par cet élément. Par exemple, considérons les deux structures disjointes définies par les grammaires suivantes :
`A={a,f(A),g(A,A)}`
`B={b,h(B),r(B,B)}`
L'union libre `L="<"A,B">"` se définit comme suit :
`L={A,B,U}`
`barA={B,U}`
`barB={A,U}`
`U={f(barA),h(barB),g(barA,A),g(A,barA),g(barA,barA),r(barB,B),r(B,barB),r(barB ,barB)}`
où les opérateurs `f,g,h,r` sont étendus par leur forme terminologique comme suit :
`f"|"_(L-A) = (x|->bb(f)(x))`
`g"|"_(L^2-A^2) = (x,y|->bb(g)(x,y))`
`h"|"_(L-B) = (x|->bb(h)(x))`
`r"|"_(L^2-B^2) = (x,y|->bb(r)(x,y))`
rtemarquez que l'on utilise l'opérateur `-` pour soustraire une partie d'un ensemble, et que l'on spéficie l'ensemble de dépard restreint ou étendu d'un opérateur par une barre verticale indicée par l'ensemble en question. `U` est l'ensemble des éléments de l'union libre `L` qui n'appartiennent ni à `A` ni à `B`. Autrement dit, en utilisant l'opérateur `+` d'union disjointe, nous avons :
`L=A"+"B"+"U`
L'ensemble `barA` est l'ensemble des éléments de l'union libre `L` qui n'appartiennent pas à `A`. L'ensemble `barB` est l'ensemble des éléments de l'union libre `L` qui n'appartiennent pas à `B` :
`L =A"+"barA`
`L=B"+"barB`
Selon le principe métaphysique affirmant qu'un élément peut désigner toute chose, chaque opérateur peut être désigné comme un élément, il possède alors un second rôle d'opérateur nullaire. Cette considération nous amène à concevoir un langage où il n'y a pas de distinction entre élément et opérateur. Le plus simple est le langage alpha unaire dans lequel l'ensemble sous-jacent comprend des opérateurs ayant deux rôles, l'un nullaire et l'autre unaire.
Un opérateur s'applique sur un opérateur pour produire un opérateur, et il n'y a pas de distinction entre opérateur et élément. Tout élément constitue un opérateur unaire. Ce langage alpha permet de définir une loi de composition interne dans un ensemble d'éléments d'une manière trés générale, qui ne nécessite pas de déclarer différent types d'opérateurs. Les éléments sont les opérateurs et n'ont qu'un seul type, celui d'opérateur unaire agissant sur eux-même.
Puis, selon les préceptes élémentariens, dans l'aspect formel des mathématiques, rien n'est immanent ni transcendant, tout doit être construit par un processus de calcul. Les structures sont construites à partir d'éléments dits générateurs. S'il n'y a qu'un seul élément générateur, on verra que celui-ci engendre librement un langage dans lequel tous les autres langages alpha se plongent. Dans la littérature contemporaine cet opérateur unique utilisé comme référence porte un nom. Il s'appelle alpha, `alpha`. Il apparait ici sous forme nullaire mais c'est aussi un opérateur unaire. C'est à dire qu'il peut s'appliquer à tout terme du langage alpha, `"<"α">"`. Et il constitue en-soit un terme du langage alpha, `alpha"∈<"alpha">"`. Regardons comment se construit le langage alpha. Sa présentation est `{α}`. À partir du terme `alpha` on peut construire le terme `α(α)` puis le terme `α(α(α))` ou bien encore le terme `α(α)(α)`, etc.. Autrement dit, le langage `"<"α">"` correspond aux arbres binaires nu.
La loi de composition `"∗"` dans un langage alpha est défini comme suit : Quelque soit `x` et `y` deux termes du langage alpha considéré, le produit de `x` par `y` est égale à l'application de `x` sur `y` :
`x"∗"y = x(y)`
Le langage alpha forme une structure libre de magma. Cela correspond aux arbres binaires ayant comme feuille des éléments générateurs.
---- 20 janvier 2022 ----