La première règle de production au stade identitaire, juste avant le stade prélogique méttant en oeuvre le raisonnement hypothético-déductif, est celle de l'identité qui affirme que quelque soit une proposition `x` celle-ci produit elle-même.
`AAx, x"⊩"x`
L'état des connaissances à un moment donné est représenté par l'ensemble `E` qui détermine l'évolution introspective. La règle d'identité ne fait que reproduire `E`. Une fois introduite dans le moteur `ccM`, celui-ci pilotant l'évolution de `E` ne peut qu'accroître `E` et jamais le réduire. À ce stade, la différence avec la logique booléenne tient en ceci : Une proposition connue vrai reste indéfiniment vrai, parcontre une proposition qui n'est pas connue, autrement-dit qui n'est pas encore connue pour être vrai, peut le devenir si on arrive à la produire à l'aide des propositions déjà connues `E` et des règles du moteur `ccM`.
Ce principe d'identité appliqué aux propositions entraine le même principe appliqué aux ensembles de propositions :
`AAX, X"⊩"X`
Le moteur `ccM` est une application d'évolution accumulative `f` appartenant à `ccL_1"→"ccL_1` c-à-d vérifiant :
`AAXAAY, (X"⊆"Y)=>(f(X) "⊆"f(Y))`
`AAX, X "⊆" f(X)`
La situation n'est plus symétrique vis-à-vis du temps. Il y a un sens du temps et de l'évolution qui correspond à l'agrandissement de `E`. Et donc en particulier il y a un début, un état initial appelé axiomatique. Et il faut revenir vraiment à l'état initial qui n'est pas forcement unique, c'est à dire enlever les propositions démontrables à partir des autres pour ne garder qu'une axiomatique au sens propre du terme c'est à dire un ensemble de propositions telle qu'aucune ne peut être produite par les autres avec le système de règles `ccM`.
Du concept d'identité nait celui du sens du temps et nait celui de l'axiomatique.
Cet ensemble `E` joue alors un rôle plus précis que simplement celui d'un état d'un système. Il contient entre autre des axiomes qui lui ont permis grâce au système de règles `ccM` de devenir ce qu'il est. C'est un système dans le quel le sens du temps, le sens de l'évolution est déterminé puisque les vérités une fois connues sont éternelles. Il s'apparente à une conscience, parcequ'il n'oublie pas.
Puis, il est toujours possible de refaire la construction à partir de zéro en prenant une autre axiomatique, un autre ensemble initiale `E`.
On nomme l'axiomatique `bbbA`. Ainsi le raisonnement formel comprend en fait 3 composantes :
Et il comprend un état des connaissances introspectives `E` en cours de développement qui contient `bbbA`, que l'on compare à une conscience, et qui à l'instant initial est égal à `bbbA`. L'axiomatique est un ensemble minimal de propositions appartenants à `ccL`, elle correspond à des vérités posées une fois pour toute, une hypothèse de base que l'on reprend partout. Néanmoins elle n'est nullement indispensable, et on prendra au départ comme axiomatique l'ensemble vide de propositions `bbbA"="{}`. Cela revient à partir d'un ensemble de connaissances introspectives initialement vide, `E"="{}`.
L'axiomatique `bbbA` est par principe en dehors du moteur `ccM`, de telle sorte que la propriété `X"⊢"Y` est distincte de la propriété `(bbbA"∪"X)"⊢"Y`. La propriété `X"⊢"Y` signifit que en supposant seulement `X` et en utilisant les règles `ccM` on peut produire `Y`.
La règle d'identité qui assure la perdurance de ce qui a déjà été produit va nous amener à nous intéresser à la relation de production notée `|--` qui correspond à la cloture transitive de la relation de production en une étape, notée `⊩`. De par sa définition, la relation de production `|--` est transitive et réflexive :
`AAXAAYAAZ, (X"⊢"Y "et" Y"⊢"Z) => X"⊢"Z`
`AAX, X"⊢"X`
On définit également un connecteur unaire de production, de même symbole `"⊢(.)"`. C'est la fonction caractéristique de l'ensemble des propositions produite par `ccM`. Ainsi la propriété `"⊢"a` signifie que la proposition `a` est produite en utilisant uniquement les règles de déduction `ccM`, et la propriété `bbbA"⊢"a` signifie que la proposition `a` est produite en utilisant les axiomes `bbbA` et les règles de déduction `ccM`.
Et nous pouvons distinguer les 6 propriétés suivantes :
La proposition `a` est connue à l'instant `t`. La proposition `a` n'est pas connue à l'instant `t`.
La proposition `a` est produite par `ccM` tout seul. La proposition `a` n'est pas produisable par `ccM` tout seul. La proposition `a` est produite par `ccM` et en utilisant les propositions de `X` comme étant connues. La proposition `a` n'est pas produisible par `ccM` même en utilisant les propositions de `X` comme étant connues.
Les formules du nouveau langage sont appelées des propositions, tandis que les formules de la logique classique sont appelées des propriétés. Comme la négation `¬` n'est pas encore définie dans le nouveau langage on ne peut pas encore écrire la propriété `"⊢"(¬a)` où `a` est une proposition, car `¬a` n'est pas encore une proposition.
On étend les connecteurs unaire et binaire `"⊢"` naturellement aux ensembles de propositions. Nous avons :
`AAA, ("⊢"A) <=> AAa"∈" A, "⊢"a`
`AA A AAB, (A"⊢"B) <=> AAb"∈" B, A"⊢"b`
Les relations `"⊩"` et `"⊢"` sont intemporelles. La propriété `a"∈"E(t)` est temporelle. Elle signifie que la proposition `a` appartient à `E` à l'instant `t` en cours. La propriété `"⊢"a` signifie que la proposition `a` est produite par `ccM`, et ceci est valable quelque soit l'époque. La propriété `X"⊢"a` signifie que la proposition `a` est produite par `ccM` et en utilisant les propositions de `X` comme étant connues, et ceci est valable quelque soit l'époque.
Au stade identitaire, la relation binaire de production constitue un préordre (transitif et réflexif) dans `ccP_"fini"(ccL)` et est appelée relation de production ou de démontrabilité. Elle est noté avec le symbole `"⊢"`.
L'évolution de la connaissance `E(t)` est plus seulement introspective. Mais on peut concevoir une autre sorte d'évolution consistant à adopter des propositions `X` et les considérer comme des axiomes supplémentaires, procédant ainsi à une extension théorique. On verra avec la création du connecteur d'implication comment cette extension théorique correspond au raisonnement hypothético-déductif.
La propriété `A"⊢"b` où `A` est un ensemble de propositions atomiques et où `b` est une proposition atomique, possède une valeur de vérité bien définie. Au stade identitaire, le moteur `ccM` défini par une fonction d'évolution accumulative `f` c-à-d vérifiant :
`AAXAAY, (X"⊆"Y)=>(f(X) "⊆" f(Y))`
`AAX, X "⊆" f(X)`
Et l'ensemble des règles de la forme `X"⊩"y` en plus de la règle d'identité `AAx, x"⊩"x`, définissant `f`, est fini. La propriété `X"⊩"y` équivaut à `y "∈" f(X)`, elle signifie que `y` est produit en une étape à partir de la connaissance des propositions de `X`. La propriété `X"⊢"y` équivaut à `EEn">"0,y "∈" f^n(X)`, elle signifie que `y` est produit en une ou plusieurs étapes à partir de la connaissance des propositions de `X`.
À ce stade identitaire, le moteur est toujours représenté comme un ensemble fini de règles de la forme `X"⊩"y` où `X` est un ensemble minimal de propositions atomiques produisant `y`, et où `y` est une proposition atomique. Et on retire les règles de la forme `x"⊩"x` puisque celles-ci sont assurées par le principe d'identité qui vient en supplément sous la forme de la règle particulière `AAx, x"⊩"x`.
C'est le stade identitaire.
---- 29 juin 2024 ----
Le langage de programmation utilisera les concepts de processus et de canaux de transmission. Tout d'abord, codifions les définitions et appels de procédure. Pour définir une procédure sans la nommer qui prend en argument `x,y,z` et qui retourne un résultat `t`, on utilise un bloc de code à la façon du langage Ruby :
`{x,y,z "|" ...;color(#660000)sf"return" t;...}`
Pour la nommer `P`, on utilise l'égalité :
`P={x,y,z "|" ...;color(#660000)sf"return" t;...}`
Et on peut utiliser aussi un prototype comme cela :
`color(#660000)sf"function" P(x,y,z){ ...;color(#660000)sf"return" t;...}`
Pour l'appliquer, on utilise l'appel à l'anglaise :
`P(a,b,c)`
`{x,y,z "|" ...;color(#660000)sf"return" t;...}(a,b,c)`
Pour que le calcul s'opère dans un nouveau processus en arrière plan on utilise l'esperluète :
`P(a,b,c)&`
`{x,y,z "|" ...;color(#660000)sf"return" t;...}(a,b,c)&`
Notez que le processus et lancé aussitôt qu'il est créé et s'exécute en arrière plan. La création d'un canal `C` se fait avec l'instruction suivante. Notez que `C` est une variable de type pointeur qui désignera le canal :
`C=sf"NewCanal"()`
Le canal sera aussi utilisé comme un sac. L'instruction `x"≫"C` envoit `x` dans le canal `C`. L'instruction `AAx"∈"C` est une boucle "for" sur tout les éléments enoyés dans le canal `C`. Considérons maintenant des processus énumérant des données sur un canal, `P("."),Q("."),R(".")` où l'argument est le canal sur lequel ils émettent. Afin de fusionner ces énumérateurs en un seul énumérateur, on ne peut pas simplement les exécuter les uns à la suite, car ce sont des énumérations sans fin. Les instructions se composent en série à l'aide du point-virgule, et se composent en parallèle à l'aide de l'esperluète. L'énumérateur fusionné émettant sur le canal `C` se programme donc ainsi :
`P(C)&Q(C)&R(C)`
Pour alléger l'écriture, on adopte les accolades blanches ⦃...⦄ pour définir un bloc de code dans lequel chaque ligne correspond à un sous-bloc de code exécuté en parallèle. L'instruction précédente peut s'écrire comme suit :
`⦃`
`P(C)`
`Q(C)`
`R(C)`
`⦄`
Pour créer un sac `E` qui est une copie physique du sac `A` à un moment donné, on utilise l'instruction suivante :
`E=sf"NewCanal"(A)`
C'est un canal qui se crée en dupliquant un canal déjà existant à un instant donné. Pour faire une boucle "for" sur tous les éléments `x` d'un sac `E` et appliquer une procédure `P(x)` nous utiliserons l'instruction suivante :
`AAx"∈"E, P(x)`
La virgule indique que ce qui suit jusqu'à une fin de bloc, fait partie du corps de la boucle, une boucle qui devra se transformer en une énumération unique. Même si la procédure `P(".")` est d'arrêt sûr, cette instruction constituera une énumération sans fin, sachant qu'à chaque instant il se peut que de nouveaux éléments s'ajoutent à `E`, ce qui se passe lorsque des processus émettent sur ce canal `E`. Dans le cas où la procédure `P(".")` peut être sans fin, cette instruction devra lancer en parallèle chaque appel de `P(x)`, de tel sorte que `AAx"∈"E, P(x)` est la même instruction que `AAx"∈"E, P(x)&`. Si on doit emboiter deux boucles voici l'instruction :
`AAx"∈"E, AAy"∈"F, P(x,y) `
Comme les boucles "for" sont sans fin, la composition de boucles "for" ici indiqué par la virgule, devra également se transformer en une énumération unique. Cela est possible si à chaque étape de la première boucle "for" on lance en parallèle la seconde boucle "for", néanmoins cette solution est trop dévoreuse de mémoire, on lui préferera les algorithmes de couverture du plan discret. On utilise pour cela deux indexes, un indexe `i_E` qui désigne un éléments dans le canal `E`, et un indexe `i_F` qui désigne un élément dans le canal `F`. Et on dispose des instruction `sf"next"(".")` et `sf"prev"(".")` qui appliquée à un index retourne l'indexe suivant ou précédent dans le même canal ou null s'il n'y a pas respectivement de suivant ou de précédent, et l'instruction `sf"val"(".")` qui appliquée à un index retourne l'élément qu'il désigne dans le canal.
Au départ l'ensemble `E` est vide, et on ne considère aucun axiome autre que le moteur comprenant les trois règles :
L'algorithme se programme comme suit :
`color(#660000)sf"function" P(E)⦃`
`AAx"∈"E, AA(x"→"y)"∈"E, y"≫"E`
`AAx"∉"E, Q(E,x)`
`⦄`
`color(#660000)sf"function" Q(E,u){`
`F=sf"NewCanal"(E)`
`u"≫"F`
`⦃`
`AAx"∈"F, AA(x"→"y)"∈"F, y"≫"F, (u"→"y)"≫"E` // Modus ponens
`AAx"∈"F, (u"→"x)"≫"E` // Identité
`AAx"∉"F, Q(F,x)` // Hypotético-déduction
`⦃`
`}