Ce rêve m’a marqué. J’en ai gardé un souvenir particulièrement net – ce qui me permit d’en retranscrire le dialogue en intégralité dès mon réveil – alors que cela ne m’arrive pour ainsi dire jamais.

Par ailleurs, je ne fus pas peu surpris de recevoir le lendemain matin un SMS d’un numéro masqué qui disait : « Bonne discussion cette nuit. Nous en reparlerons. Tenez-moi au courant. René D. »

Allez comprendre.

J’ai en tout cas du pain sur la planche, car les trois options proposées par Descartes soulèvent des questions distinctes et toutes passionnantes. Par souci d’honnêteté intellectuelle, il me semble important de commencer par explorer un peu plus la première, celle du dualisme, ne fut-ce que pour me conforter dans mon rejet instinctif de cette hypothèse.

Que m’a dit Descartes ? Que si la conscience s’appuie sur des fonctions non calculables, alors elle ne peut pas s’incarner dans un système purement physique (ou informatique) ; l’existence de l’âme en découle logiquement. Clarifions un peu cela.

Une fonction, c’est une association entre deux ensembles, un ensemble de départ et un ensemble d’arrivée (qui peuvent être différents ou identiques). À tout élément de l’ensemble de départ on associe un unique élément de l’ensemble d’arrivée. Si f est le nom de la fonction et si x est un élément de l’ensemble de départ, on note f(x) l’élément de l’ensemble d’arrivée associé à x. Par exemple, à tout être humain on peut associer son âge en années (un nombre entier) mais aussi sa mère (un être humain).

On peut considérer qu’une conscience, à tout instant, calcule une fonction. L’ensemble de départ est l’ensemble des configurations possibles de la conscience à un instant donné : ce qu’elle perçoit, ce qu’elle pense, ce qu’elle fait. L’ensemble d’arrivée est l’ensemble des configurations possibles à l’instant suivant. Une conscience passe son temps à déterminer dans quel état elle sera à l’instant suivant à partir de son état courant.

Une fonction est dite calculable s’il existe un algorithme permettant de calculer en un temps fini sa valeur pour tout élément de l’ensemble de départ. Si une fonction f est calculable, on peut écrire un programme informatique qui reçoit un élément x de l’ensemble de départ en entrée, et qui calcule l’élément f(x) en un temps fini. Par exemple, il existe un algorithme qui permet de multiplier rapidement n’importe quel nombre entier par 2 ; la fonction qui associe chaque nombre entier à son double est calculable.

On peut montrer qu’il existe des fonctions qui ne sont pas calculables. La démonstration due à Alan Turing (dès 1936 !) est délicieuse et je ne résiste pas au plaisir de vous en présenter une variante.

Considérons l’ensemble des programmes correctement formés qu’il est possible d’écrire sur un ordinateur dans un certain langage de programmation, par exemple Java. Sans perte de généralité on pourra supposer que tout programme reçoit un nombre entier (peut-être immense) en entrée, et retourne un autre nombre entier comme résultat (tous les programmes ne font pas exactement cela, mais on peut toujours se ramener à ce cas par une adaptation simple).

Cet ensemble de programmes est infini. Il est aussi dénombrable, c’est-à-dire qu’on peut associer un nombre entier à tout programme de ce type, de sorte que deux programmes différents soient associés à deux entiers différents. C’est même très facile : un programme, une fois mis en mémoire, c’est une suite de 0 et de 1 ; cette suite peut aussi s’interpréter comme un gigantesque nombre écrit en base 2 (comme le sont tous les nombres dans les ordinateurs).

Maintenant, posons-nous la question : quand on lui soumet un nombre donné, est-ce qu’un programme donné donnera une réponse au bout d’un temps fini, ou est-ce qu’il partira en boucle et ne rendra jamais de résultat ? C’est ce qu’on appelle le problème de l’arrêt.

Il est très facile, dans n’importe quel langage informatique, d’écrire des programmes qui « partent en boucle » et ne s’arrêtent jamais : ils répètent juste une série d’instructions qui ne changent rien à rien, comme un hamster sur sa roue, et ne s’arrêtent pour ainsi dire que quand on coupe le courant. Bien sûr, on ne le fait jamais exprès, mais dans la pratique il peut arriver que, pour certaines valeurs des données qu’on lui soumet, un programme parte en boucle, ce qui est naturellement un bug inacceptable. Il serait donc vraiment utile de pouvoir déterminer si un programme risque de partir en boucle ou non.

Nous avons vu par ailleurs que tout programme peut être identifié par un (très grand) nombre entier, que j’appellerai son code numérique. On peut donc s’amuser à lui soumettre comme valeur d’entrée son propre code numérique, et voir ce qui se passe : soit le programme calculera un résultat en un temps fini, soit il partira en boucle.

Tout programme est nécessairement dans l’un ou l’autre cas : il s’arrête ou non quand on lui soumet son propre code. Il existe donc une fonction de l’ensemble des programmes vers l’ensemble des nombre entiers, que je nommerai ARRET. Elle associe le nombre 0 à un programme qui part en boucle quand on lui soumet son propre code numérique, et le nombre 1 à un programme qui s’arrête. La fonction ARRET est parfaitement définie. Cependant elle n’est pas calculable.

En effet, imaginons que je dispose d’un algorithme qui peut calculer ARRET(p) en un temps fini pour n’importe quel programme p. Je crée maintenant le programme PARADOXE qui reçoit en entrée un programme p (ou son code numérique, ce qui revient au même). Il calcule d’abord ARRET(p). Si cette valeur vaut 0 (c’est-à-dire si p part en boucle), PARADOXE s’arrête et rend une valeur quelconque. Si elle vaut 1 (c’est-à-dire si p s’arrête), PARADOXE part délibérément dans une boucle infinie et ne s’arrête jamais. Voici un code source possible de PARADOXE en Java :

int PARADOX(Program p) {
     if (ARRET(p) == 1) 
        while (true);
     return 1;
}

Parfait. Maintenant je peux tester PARADOXE avec différents programmes ; quand il s’arrête tout seul c’est que le programme que je lui ai soumis part en boucle quand on lui soumet son propre code ; s’il part en boucle c’est que le programme que je lui ai soumis s’arrête.

Vous devinez la suite : que se passe-t-il quand je soumets à PARADOXE son propre code ? si PARADOXE s’arrête alors il partira en boucle ; s’il part en boucle, il s’arrêtera. C’est un paradoxe. PARADOXE ne peut pas exister.

Mais PARADOXE est un programme trivial, facile à écrire, et je viens de vous le montrer. S’il ne peut pas exister, c’est parce que ARRET ne peut pas exister.

La fonction qui détermine si un programme s’arrête quand on lui soumet son propre code numérique existe, elle est parfaitement définie, mais aucun algorithme – donc aucun ordinateur – ne peut la calculer.

À ce stade, on peut penser que c’est amusant, certes, mais que ce genre de choses doit être bien rare, une curiosité de cirque ; ce n’est pas une fonction « normale ».

Sauf qu’en vérité, la situation est bien pire que cela : ce sont les fonctions calculables qui forment l’exception. Les fonctions non calculables sont infiniment plus nombreuses que les fonctions calculables !

En visitant l’hôtel Aleph (il y a bien longtemps de ça), nous avions découvert que même avec une infinité de chambres on ne pouvait pas réserver une chambre aux réunions de chaque club possible de résidents de l’hôtel. Il y a une infinité de chambres et de résidents, mais l’infinité des clubs possibles (c’est-à-dire des ensembles de résidents) est plus grande que cette infinité-là, et même infiniment plus grande.

Ici la situation est identique. À tout ensemble de nombres entiers correspond une fonction caractéristique qui associe le nombre 1 à un élément de cet ensemble et le nombre 0 à tous les entiers qui ne sont pas dans cet ensemble. Si deux ensembles sont différents, leurs fonctions caractéristiques sont différentes : il existe donc au moins autant de fonctions que d’ensembles de nombres entiers. Or il existe infiniment plus d’ensembles de nombres entiers que de nombres entiers, et il existe autant de programmes que de nombres entiers. Il existe donc infiniment plus de fonctions que de programmes pouvant les calculer : presque aucune fonction n’est calculable !

Il est tentant d’en conclure que, en toute probabilité et faute d’information supplémentaire, la fonction calculée par une conscience n’est pas calculable. Dans ce cas aucun mécanisme physique, biologique ou informatique ne peut porter la conscience, car même les plus puissants de ces mécanismes (que l’on appelle des calculateurs universels) sont strictement limités aux fonctions calculables. La conscience nécessite autre chose. L’âme pointe le bout de son nez. Damned.

Fort heureusement, un contre-argument vient au secours de l’athée matérialiste en détresse. C’est le fait suivant : toute fonction dont l’ensemble de départ est fini est calculable. Je peux en effet écrire un programme fini qui en énumère toutes les valeurs : « si j’ai l’entrée 1, retourne 2 ; pour l’entrée 2, retourne 5… » et ainsi de suite. Or, rien n’impose que le nombre des états possibles d’une conscience soit infini, bien au contraire. Après tout, pour ce que nous en savons, l’univers observable ne contient qu’un nombre fini de particules élémentaires, sans parler du nombre de neurones dans notre cerveau. Le nombre d’états possible pour une conscience humaine ou animale est sans nul doute astronomique, mais rien n’empêche de le supposer fini ; et dans ce cas toutes les fonctions sont calculables.

Une conscience divine, étant infinie, possèderait certainement, elle, un ensemble infini (et peut-être même non dénombrable) d’états possibles ; l’argument de Descartes prend bien plus de valeur sous cette hypothèse. Mais je n’ai aucun état d’âme (justement) à me contenter d’une conscience supposée finie – ce sera même mon premier axiome. Je ne serais pas choqué d’apprendre que Dieu, si elle existe, doit nécessairement avoir une âme : mais je laisse à d’autres le soin de s’en préoccuper.

(à suivre)