Équivalence entre calculabilité et imprimabilité

Dans cette section, une preuve d’équivalence entre les concepts de calculabilité (tel qu’in- troduit par Turing en 1937 [25]) et d’imprimabilité (nommé ainsi par moi-même) est donnée. Le résultat d’équivalence est déjà connu et une preuve a été donnée par A. R. Meyer, dont une version modifiée est présentée par D. W. Loveland [19]. La preuve présentée dans cette section a été élaborée sans connaissance de celle de Meyer (ou Loveland), d’où la pertinence de la présenter en détail ici. L’intérêt est que la nouvelle preuve est conceptuellement plus simple.2

4.3.1. Programme

Soit U une machine de Turing universelle, prenant en entrée hP, xi, où P est la description de la machine de Turing à simuler (une chaîne de bits finie) et x est l’entrée à la machine P .

U (P, x) = P (x) Dans ce qui suit, P est appelée un programme.

4.3.2. Calculabilité et imprimabilité

Soit α = α1α2α3... une chaîne de bits infinie. Définissons α[n] = α1α2...αn comme les n

premiers bits de α.

Définition 4.3.1. Une chaîne de bits infinie α est calculable s’il existe un programme P tel que pour tout n ∈ N :

P (n) = α[n].

La définition d’imprimabilité fait appel à la complexité de Kolmogorov conditionnelle. Définition 4.3.2. Soit c une constante. Une chaîne de bits infinie α est c-imprimable si pour tout n ∈ N :

K(α[n]|n) ≤ c

2. Ce travail est en collaboration avec Xavier Coiteux-Roy, étudiant au doctorat à l’Université de la Suisse italienne, Lugano, Suisse.

Définition 4.3.3. Une chaîne de bits infinie est imprimable s’il existe une constante c telle qu’elle soit c-imprimable.

4.3.3. Calculable =⇒ Imprimable

Soit α une chaîne infinie calculable. Par définition, cela implique qu’il existe un pro- gramme P tel que ∀n, P (n) = α[n]. La description du programme P est une chaîne de bits

de longueur finie. On note cette longueur |P | = c, où c est une constante. Soit U la machine de Turing universelle prenant en entrée la description de P ainsi que n. Ainsi :

U (P, n) = P (n) = α[n].

Par définition de la complexité de Kolmogorov :

K(α[n]|n) ≤ |P | = c

ce qui correspond à la définition d’une chaîne imprimable.

4.3.4. Imprimable =⇒ Calculable

Soit α une chaîne infinie c-imprimable pour un certain c. Définissons Q = {Pi}i comme

la famille contenant tous les programmes de longueur c ou moins. Combien de programmes contient la famille Q ? Comme la longueur des programmes dans Q est bornée supérieurement par c, on obtient : |Q| = c X i=1 2i = 2c+1− 2

Notons la cardinalité de Q par |Q| = M . Ainsi, Q = {Pi}i=Mi=1 .

L’imprimabilité de α implique alors que pour tout n ∈ N, il existe un programme dans la famille Q t.q. :

Pi(n) = α[n]

pour un certain i ∈ {1, 2, ..., M }. L’idée de la preuve est de construire un programme S à partir des programmes dans Q, tel que S(n) = α[n] pour tout n ∈ N.

Définition 4.3.4. Calcul en queue de colombe

Soit P un programme prenant en entrée n ∈ N, c’est-à-dire qu’il existe une infinité d’en- trées possibles au programme P . La je _{étape de calcul du programme P sur entrée n est notée}

(P (n))j. Rouler un programme sur une infinité d’entrées par la méthode en queue de colombe

signifie qu’à chaque temps t > 0, on roule simultanément (P (t))1, (P (t − 1))2, ..., (P (1))t.

t = 1 : (P (1))1

t = 2 : (P (2))1, (P (1))2

t = 3 : (P (3))1, (P (2))2, (P (1))3

...

Remarque. Si le programme P (n) s’est arrêté à l’étape j, alors (P (n))q ne produit rien

∀q > j.

Définition 4.3.5. Soit mn le nombre de sorties distinctes de longueur n obtenues en roulant

les programmes dans Q sur entrée n. On définit k comme la plus grande valeur de mn qui

apparaît infiniment souvent. Donnons-en une définition mathématique. On définit d’abord l’ensemble K, contenant toutes les valeurs de mn qui reviennent infiniment souvent.

K = {˜k |∞∃ n t.q. mn = ˜k}

Ensuite, k est défini comme la plus grande valeur de cet ensemble. k = max

˜ k

˜ k ∈ K

Définition 4.3.6. On définit ˜n comme le plus petit entier tel que : ∀n ≥ ˜n : mn ≤ k

Définition 4.3.7. Définissons une famille d’entrées {ci}i telle que :

n ∈ {ci}i ⇐⇒      n ≥ ˜n mn = k

Les éléments de {ci}i sont appelés entrées complètes. On définit l’élément ci comme la ie

entrée complète à être trouvée par le calcul en queue de colombe.

n 1 ... 10 ... n˜ ... cj ...

Définition 4.3.8. Définissons une liste d’ imposteurs, notés β1, ..., βb. Un imposteur est c-

imprimable et différent de α. À chaque imposteur est assignée une étiquette indiquant la position et la valeur du premier bit différant avec la chaîne α.

Figure 4.1. Exemple d’une étiquette pour l’imposteur β1.

Lemme 4.3.1. Il existe au plus M = 2c+1− 2 chaînes infinies distinctes c-imprimables.

Preuve. Rappelons nous d’abord qu’il y a M = 2c+1− 2 programmes différents de longueur au plus c. Supposons qu’il existe M +1 chaînes infinies distinctes c-imprimables. Ceci implique qu’il existe une valeur d’entrée n∗ telle que ∀ n ≥ n∗, la famille {Pi(n)}i contient M + 1

éléments distincts. Mais comme le nombre de programmes est borné par M , il est impossible que {Pi(n)}i contienne plus de M éléments distincts, peu importe la valeur de n. Ainsi,

il existe au plus M chaînes infinies distinctes c-imprimables, c’est-à-dire au plus M − 1

imposteurs. _

Construction du programme S

Considérons maintenant le programme S prenant en entrée n ∈ N :

(1) Énumération des programmes dans Q.

(2) Description de ˜n, k et la liste des étiquettes des imposteurs.

(3) Rouler tous les programmes dans Q en parallèle en queue de colombe (on roule M queues de colombe en parallèle), à partir de l’entrée ˆn = max(n, ˜n). Ainsi, au temps t = 1, on roule (Pi(ˆn))1pour i ∈ [1, M ], au temps t = 2, on roule (Pi(ˆn + 1))1, (Pi(ˆn))2

pour i ∈ [1, M ], etc.

(4) Trouver c1. Les k sorties distinctes de longueur c1 obtenues sur entrée c1 sont les

candidats pour α[c1].

(5) Élimination des imposteurs : en se référant à la liste des étiquettes, éliminer de la liste de candidats les imposteurs dont la position du premier bit différant avec α est plus petite ou égale à c1. (Les autres imposteurs respectent βi[c1] = α[c1].)

(6) Filtrage : même si les imposteurs indésirables ont été éliminés à l’étape précédente, il y a encore (potentiellement) de mauvais candidats à éliminer. Notons ceux-ci par {γi}i. Les γi sont les chaînes qui respectent K(γi[n]|n) ≤ c pour certaines valeurs de n

(et non pour tout n). Pour les éliminer, trouver c2. Comparer les k sorties distinctes

de longueur c2 obtenues sur entrée c2 avec les candidats restants.

— Si c2 > c1, éliminer tous les candidats qui ne sont pas préfixes d’au moins une

sortie obtenue sur entrée c2. À l’aide de la liste des étiquettes, éliminer de la liste

de candidats les imposteurs dont la position du premier bit différant avec α est entre c1 et c2, inclusivement.

— Si c2 < c1, garder seulement les sorties obtenues sur entrée c2 qui sont préfixes

d’au moins un candidat. Ces sorties forment la nouvelle liste de candidats.

(7) Répéter l’étape précédente pour ci avec i > 2 jusqu’à ce qu’il reste seulement un

candidat.

(8) Produire en sortie α[n], c’est-à-dire les n premiers bits du candidat final.

Nous avons construit un programme S tel que, ∀n, S(n) = α[n]. Ceci correspond à la

définition de calculabilité.