Calcul Cours PDF

Calculabilité
Support de cours et de TD
Eugene Asarin
Grenoble – 2003
Table des matières
0.1 Quelques exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

0.2 Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
0.2.1 Exercices - sans théorie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
0.3 Calculabilité vs Complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1 Modèles de calcul 7
1.1 Fonctions récursives primitives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1.1 Définition de fonctions récursives primitives . . . . . . . . . . . . . . . . . . 7
1.1.2 Exercices – quelques fonctions RP . . . . . . . . . . . . . . . . . . . . . . . 8
1.1.3 Réaliser une fonction RP en un langage “actionnel” . . . . . . . . . . . . . 9
1.1.4 Quelques propriétés de fermeture de la classe RP . . . . . . . . . . . . . . . 9
1.2 Les prédicats RP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.1 Exercices – des fonctions RP plus compliquées . . . . . . . . . . . . . . . . 12
1.3 Les fonctions RP ne suffisent pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.3.1 Fonction d’Ackermann . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.3.2 Interpréteur RP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.4 Fonctions récursives partielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.4.1 Minimisation non-bornée . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.4.2 Fonctions récursives partielles et la thèse de Church . . . . . . . . . . . . . 16
1.4.3 Exercices – fonctions récursives partielles . . . . . . . . . . . . . . . . . . . 17
1.5 Machines de Turing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.6 Thèse de Church-Turing. Équivalence MT – fonctions récursives partielles . . . . . 19
1.6.1 Exercices – MT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.6.2 Vers la preuve de théorème 2 . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.6.3 Exercices – Gödelisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.6.4 Fonction universelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.7 Théorème de la forme normale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.8 Théorème de paramétrisation (s-m-n) . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.8.1 Exercices – s-m-n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2 Décidabilité et indécidabilité 26
2.1 Problèmes décidables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.2 Premiers problèmes indécidables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.2.1 Exercices sur la diagonalisation . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.3 Méthode de réduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.4 Semi-décidabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.5 Ensembles récursivement énumérables (r.e.) . . . . . . . . . . . . . . . . . . . . . . 32
2.6 Semi-décidabilité vs. réduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.7 Exercices – analyse de décidabilité de problèmes . . . . . . . . . . . . . . . . . . . 36
1
3 Applications de la calculabilité dans l’informatique 37
3.1 Problèmes de vérification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.1.1 Machines de Turing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.1.2 Automate fini . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.1.3 Machine à pile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.1.4 Machine à deux piles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.1.5 Exercice – Machine à compteurs . . . . . . . . . . . . . . . . . . . . . . . . 39
3.1.6 Problèmes pratiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.2 Problèmes indécidables dans la théorie de langages . . . . . . . . . . . . . . . . . . 40
3.2.1 Problèmes relatives aux langages hors contexte . . . . . . . . . . . . . . . . 40
3.2.2 Systèmes de réécriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2
Préface
Ce document contient les notes de cours et les exercices de TDs de la Calculabilité, que j’ai
faits en 2000-2003 pour la maı̂trise d’informatique à l’Université Joseph Fourier.
En préparant mon cours de la Calculabilité je me suis basé sur le cours fait à l’UJF par
Christian Boitet jusqu’à 1999, et j’ai profité de ses conseils.
Ce document n’aurait jamais vu le jour sans l’aide de deux jeunes chercheurs, Gerardo Schnei-
der, qui étant chargé d’un groupe de TD en 2001, a assisté à tous les cours et a pris les notes très
détaillées, et Thao Dang, qui a saisi ces notes en LATEX.
Je remercie également les chargés de TDs, qui ont beaucoup influencé le contenu et la forme
de mes cours. Ce sont (dans l’ordre chronologique) Peter Niebert, Gerardo Schneider, Christian
Boitet et Yassine Lakhnech.
Ce document dans sa forme actuelle est encore incomplet et certainement contient quelques
imprécisions. J’espère de le compléter et de l’améliorer dans les mois qui viennent. Je serai re-
connaissant aux lecteurs pour leurs commentaires, remarques et suggestions constructives qu’ils
peuvent m’envoyer à l’adresse asarin@imag.fr
Eugene Asarin
Grenoble, avril 2003
Remarque
Actuellement je n’enseigne pas le cours de la Calculabilité, mais je laisse ce document sur ma
page web pour les étudiants et les enseignants qui peuvent le trouver utile. Je viens de corriger
quelques petites fautes, merci en particulier à Ouri Maler qui m’a signalé une imprécision concer-
nant les formes normales. Je serai toujours reconnaissant aux lecteurs pour leurs commentaires,
qu’ils peuvent m’envoyer à l’adresse asarin@liafa.jussieu.fr
Eugene Asarin
Paris, avril 2006
Notations typographiques
Le texte sur le fond gris représente des raisonnements informels
Les exercices sont données en utilisant cette police
3
Introduction
0.1 Quelques exemples

Les cours d’informatique que vous avez eu peuvent donner une impression que pour chaque
problème on peut trouver un algorithme de solution. Dans le cours de la Calculabilité nous mon-
trerons que ce n’est pas le cas et que pour des nombreux problèmes naturels et intéressants il
n’existe pas d’algorithme. Nous commencerons par quelques exemples illustratifs des problèmes
de décision. Pour le moment nous ne donnons aucune preuve.
Problème de terminaison du programme “3x + 1” Est-ce que le programme ci-dessous

s’arrête sur un x donné ?
while x > 1 do {
if (x mod 2 = 0) then x := x/2;
else x := 3x + 1;
}
Réponse. Pour ce problème, on peut utiliser la procédure suivante : à partir de x donné exécuter
ce programme, et s’il s’arrête retourner “OUI”. Par contre, si pour un certain x le programme
“3x + 1” boucle, cette procédure ne pourra jamais donner la réponse “NON”. Une telle procédure
s’appelle un semi-algorithme.
Il est inconnu s’il existe un algorithme de décision pour ce problème, qui pour chaque x donné
renvoie une réponse correcte “OUI” ou “NON”. Une conjecture dit que ce programme s’arrête
toujours. Si cette conjecture est vraie l’algorithme de décision serait tout simplement de retourner
tout de suite “OUI” pour chaque x.
Problème de terminaison de programme C’est une généralisation du problème précédent.

Étant donné un texte d’une fonction (avec un argument entier) programmé en Pascal et un x ∈ N,
est-ce que cette fonction s’arrête pour l’argument x ?
Pour ce problème il existe un semi-algorithme (trouvez-le), mais il n’existe pas d’algorithme.
Problème de correction de programme Étant donné un texte d’une fonction (avec un ar-
gument entier) programmé en Pascal, est-ce que cette fonction calcule (par exemple) la factorielle.
Pour ce problème il n’existe ni un algorithme, ni même un semi-algorithme. Donc le problème
(très pratique) si un programme donnée satisfait une spécification n’admet pas d’algorithme de
décision.
Problème de logique 1. Est-ce qu’une formule propositionnelle F donnée (telle que F = p ⇒

g ∨ p ∨ ¬p) est valide ?
Réponse. Il existe des algorithmes pour ce problème, par exemple,
– Algorithme 1 : Construire la table de vérité. Si toutes les lignes contiennent seulement ‘1’,
répondre “OUI”. Si dans une ligne il y a ‘0’ répondre “NON”.
– Algorithme 2 : DP (Davis-Putnam), vu en cours de Logique.
4
Problème de logique 2. Est-ce qu’une formule du premier ordre donnée (telle que par exemple
∀xP (x) → ∃yP (y)) est valide ?
Réponse. Il n’existe pas d’algorithme général (c-à-d il n’y a pas d’algorithme qui donne la bonne
réponse pour une formule du premier ordre quelconque). La procédure vue en cours de Logique (à
savoir, skolémiser la négation de la formule, la mettre en forme clausale et appliquer la résolution)
peut ne pas terminer.
Problème de langages 1. Pour une grammaire hors-contexte Γ, est-ce que son langage est
vide, c-à-d L(Γ) = ∅ ?
Réponse. Il existe des algorithmes (vus en cours d’Automates et Langages).
Problème de langages 2. Pour une grammaire hors-contexte Γ et un mot w, est-ce que w ∈

L(Γ) ?
Réponse. Il existe des algorithmes (vus en cours d’Automates et Langages).
Problème de langages 3. Pour deux grammaires hors-contexte Γ1 et Γ2 , est-ce que L(Γ1 ) =

L(Γ2 ) ?
Réponse. Il n’existe pas d’algorithme.
Problème de langages 4. Pour deux mots α et β et les règles de réécriture R (de la forme
v → w), est-il possible de transformer α en β en appliquant plusieurs fois les règles R ?
Réponse. Il n’existe pas d’algorithme.
0.2 Terminologie
Dans ce cours, nous allons considérer des problèmes de décision qui peuvent être formulés
comme suit. Étant donné un ensemble U de toutes les données possibles (un univers) et un ensemble
B de toutes les données dites “bien” (B ⊆ U ), pour chaque élément x ∈ U , répondre “OUI” si
x ∈ B et “NON” si x 6∈ B. Par exemple, pour le problème de logique 2
U = { toutes les formules propositionnelles }

B = { toutes les formules valides }.
Par abus de notation nous écrirons ce problème comme “x ∈ B ?”, ou comme “B(x) ?”
Voici une définition informelle de problèmes décidables, semi-décidables, indécidables.
Définition 1 Pour un problème P = (U, B) donné,
– Le problème P est décidable ⇔ Il existe un algorithme pour P (c’est-à-dire une
procédure qui s’arrête et répond “OUI” si l’entrée x ∈ B et répond “NON” si l’entrée
x 6∈ B).
– Le problème P est indécidable ⇔ Il n’existe pas d’algorithme pour P .
– Le problème P est semi-décidable ⇔ Il existe un semi-algorithme pour P (c’est-à-dire
une procédure telle que si l’entrée x ∈ B elle répond “OUI” ; si l’entrée x 6∈ B dit
“NON” ou ne donne pas de réponse).
Il est clair qu’un problème décidable est aussi semi-décidable. ⋄
Remarque. Pour montrer qu’un problème est décidable, il suffit de trouver un algorithme (un
seul suffit et ceci peut se faire sans utiliser la théorie de la calculabilité). Par contre, pour montrer
qu’un problème est indécidable, il faut considérer tous les algorithmes possibles et montrer qu’aucun
d’eux ne résout le problème, ce qui est plus difficile et impossible sans théorie et sans notion
rigoureuse d’algorithme.
5
0.2.1 Exercices - sans théorie
Pour chacun de problèmes suivants donner explicitement le U et le B. Essayer de trouver
– un algorithme de décision ;
– à défaut, un algorithme de semi-décision (“un semi-algorithme”) ;
– à défaut, une opinion argumentée, si un tel algorithme ou semi-algorithme existe.
1. Étant donné un graphe G et un entier k, y a-t-il une clique1 de taille k dans G ?
2. Étant donnée une équation quadratique ax2 + bx + c = 0 aux coefficients entiers, est-ce qu’elle
a une solution réelle ? une solution entière ?
3. Étant donnée une équation algébrique2 à une ou plusieurs variables et aux coefficients entiers,
est-ce qu’elle a une solution réelle ? une solution entière ?
Réfléchissez d’abord à la façon de résoudre l’équation
x66 − 15x62 − 2002 = 0 ou bien x7 − 17xy + y 5 − 9999 = 0.
4. Étant donnée la valeur initiale de x, est-ce que le programme suivant s’arrête :
while x mod 5 = 6 0 do
if x mod 5 = 4
then x := x2 + 1
else x := x + 2
5. C’est une légère généralisation du problème précédent. Étant données la valeur initiale de x et la
valeur de y, est-ce que le programme suivant s’arrête :
while x mod y 6= 0 do
if x mod y = y − 1
then x := x2 + 1
else x := x + 2
6. Même question que pour 4 et 5
while x 6= 1 do
if x mod 2 = 0
then x := x/2
else x := 3x − 1
0.3 Calculabilité vs Complexité

Nous représentons une brève comparaison entre ces deux disciplines sous la forme d’un tableau
Calculabilité Complexité
Question : Existe-t-il un algorithme ? Existe-t-il un algorithme rapide ?
Hypothèse : Ressources non-bornées Ressources bornées
Technique 1 : Diagonalisation Diagonalisation
Technique 2 : Réduction calculable Réduction polynômiale
Le plan du cours
1. Définitions (rigoureuses) de la notion d’algorithme (modèles de calcul).
2. Propriétés générales des problèmes (décidabilité, indécidabilité, méthode de preuve de l’indécidabilité,
etc.)
3. Applications
1 un sous-ensemble de sommets de G dont chaque deux éléments sont reliés par une arête
2 une équation de la forme un polynôme= 0
6
Chapitre 1
Définitions formelles de la notion

d’algorithme et modèles de calcul
Notre but est de donner une définition formelle de la classe de fonctions calculables. Cette
définition doit être à la fois intuitive et correspondre à la pratique de programmation.
Une définition simple est la suivante : une fonction f est calculable s’il existe un algo-
rithme pour la calculer. Puis, on peut envisager de définir un algorithme par un pro-
gramme PASCAL ou par un programme CAML.
L’inconvénient de cette définition est que la sémantique de ces langages est très compliquée
(et peut varier d’une réalisation à une autre) et, en plus, ces langages sont trop riches pour des
analyses théoriques. Pour cette raison nous définirons les modèles de calculs et de “langages de
programmations” beaucoup plus simples, mais assez puissant pour décrire n’importe quel algo-
rithme.
L’approche, que nous allons utiliser dans ce cours, est dite fonctionnelle. Nous allons restreindre
notre attention aux algorithmes pour calculer les fonctions de la forme f : Nk → N, et nous voulons
aboutir à une définition (formelle) des fonctions calculables f : Nk → N.
Pour voir le lien entre la décidabilité et la calculabilité, considérons un problème de décision
(U, B) où U = Nk . Le problème est donc le suivant : pour x ∈ U décider si x ∈ B. Afin de décider
si une entrée x ∈ B, nous allons utiliser la fonction caractéristique de l’ensemble B (d’entrées
“bien”) χB (x) : U → N, qui est définie comme suit.
Définition 2 (Fonction caractéristique)

1 si x ∈ B,
χB (x) =
0 sinon.
Définition 3 Le problème (U, B) est décidable si et seulement si χB est calculable.

Une fois que nous aurons une notion précise de fonction calculable, la définition précédente
deviendra aussi rigoureuse.
1.1 Fonctions récursives primitives

Dans cette section nous faisons la première tentative de définir la classe des fonctions cal-
culables. On obtiendra une classe assez large, contenant presque tous les algorithmes que vous
connaissez, mais, néanmoins insuffisante. Dans les sections suivantes nous l’élargirons encore.
1.1.1 Définition de fonctions récursives primitives

Définition 4 (RP) La classe des fonction récursives primitives (RP) est la classe de fonctions
f : Nk → N définie inductivement en utilisant 3 fonctions de base et 2 constructeurs suivants.
7
– Fonctions de base
– Zéro O : N0 → N telle que O() = 0.
– Successeur σ : N → N telle que σ(x) = x + 1.
– Projecteur πik : Nk → N telle que πik (x1 , x2 , . . . , xk ) = xi .
– Constructeurs
– Composition Comp(f, g1 , . . . , gk ) = h t.q. h(x̄) = f (g1 (x̄, . . . , gk (¯(x)).
– Rec P ri(f, g) = u t.q. (
u(x̄, 0) = f (x̄)
u(x̄, n + 1) = g(x̄, n, u(x̄, n))
Autrement dit, la classe RP est la plus petite classe qui contient les fonctions de base O, σ, πik et
est fermée par les constructeurs Comp et Rec P ri.
Exemple 1. Nous allons définir la fonction P lus(x, y) = x + y. D’abord,

(
P lus(x, 0) = x
P lus(x, n + 1) = P lus(x, n) + 1
Il suffit maintenant de récrire les équations ci-dessus sous forme Rec P ri(f, g). Nous avons
(
P lus(x, 0) = π11 (x) = f (x)
P lus(x, n + 1) = σ(π33 (x, n, P lus(x, n))) = g(x, n, P lus(x, n))
Donc, P lus = Rec P ri(π11 , Comp(σ, π33 )). ⋄
Exemple 2. zero : λx.0 (avec un argument).

(
zero(0) = 0 = O() = f ()
zero(n + 1) = zero(n) = π22 (n, zero(n)) = g(n, zero(n))
Donc, zero = Rec P ri(O, π22 ). ⋄

Dans les deux séries d’exercices 1.1.2 et 1.2.1 nous établirons la récursivité primitive de nom-
breuses fonctions utiles.
1.1.2 Exercices – quelques fonctions RP

Montrer que les fonctions suivantes sont récursives primitives (RP) en les construisant à partir de
fonctions de base 0, σ, π avec les constructeurs Comp et Rec Pri :
1. 7 (d’arité 0, c-à-d λ.0 et d’arité 1, c-à-d λx.7) ;
2. Mult=λxy.x × y ;
3. ↑= λxy.x ↑ y (cela signifie xy ) ;
4. λxy.x ↑↑ y (cela signifie x ↑ (x ↑ . . . ↑ x)) ;
| {z }
y fois
5. λx.sg(x) (signe : 0 quand x est nul, 1 quand x est positif) ;

6. λxy.x−̇y (différence tronquée ou monus : x − y si x ≥ y ; 0 sinon) ;
7. λxy.|x − y| ;
8. Montrer que la fonction g = λx, y.2x + y est récursive primitive en la construisant à partir de
fonctions de base avec les constructeurs Comp et Rec Pri.
8
Solution: Soit plus = λxy.x + y et exp2 = λz.2z
(a) plus est RP :
π11 (x)

plus(x, 0) = x =
plus(x, n + 1) = plus(x, n) + 1 = σ(plus(x, n)) = h(x, n, plus(x, n))
Donc h = Comp(σ, π33 ) et plus = Rec Pri(π11 , Comp(σ, π33 ))

(b) exp2 est RP :

exp2(0) = 1 = σ(0)
exp2(n + 1) = 2n+1 = exp2(n) + exp2(n) = h(n, exp2(n))
Donc h = Comp(plus, π22 , π22 )

et exp2 = Rec Pri(Comp(σ, 0), Comp(plus, π22 , π22 ))
(c) Finalement, g = Comp(plus, Comp(exp2, π12 ), π22 )
1.1.3 Réaliser une fonction RP en un langage “actionnel”

Programmer les fonctions de base en un langage de programmation comme Pascal est
trivial. En ce qui concerne la fonction Comp, si l’on sait programmer h(x1 , . . . , xk ) et
g1 (x̄), . . . , gk (x̄), on peut alors programmer h(x̄) = f (g1 (x̄), . . . , gk (x̄)). Pour la fonction
Rec, un programme pour la calculer est le suivant.
fonction u(x, y)
r ← f (x)
for i = 0 to y − 1 {
r ← g(x̄, i, r)
}
return r
On peut donc voir qu’une fonction RP est programmable en utilisant seulement des
boucles for imbriqués et les appels des fonctions non-récursifs. Or, le langage RP est
équivalent à une partie du langage Pascal seulement avec la boucle for et sans appels
récursifs. ⋄
1.1.4 Quelques propriétés de fermeture de la classe RP

Décrire les fonctions RP par des termes ne contenant que des fonctions de base et constructeurs
Comp et Rec P ri est une tâche fastidieuse. Nous établirons plusieurs propriétés de fermeture de
la classe RP qui nous permettront d’établir la récursivité partielle plus rapidement.
Pn
Exemple. Considérons f (n) = i=0 i!. Afin de montrer que cette fonction est RP, notons
d’abord que i! est RP puisqu’on peut l’exprimer comme

0! = 1
(i + 1)! = i! (i + 1)
Ensuite, f peut être écrite comme

f (0) = 1
f (n + 1) = f (n) + (n + 1)!
La fonction f est donc RP. ⋄

Pn Qn
Proposition 1 Si g(x̄, i) est RP, alors f (x̄, n) = i=0 g(x̄, i) et h(x̄, n) = i=0 g(x̄, i) sont aussi
RP.
9
P Q
Autrement dit, la classe de fonctions
P RP est fermée par rapport à Qet .
Démonstration. Pour la somme c’est un exercice. Pour le produit , on peut écrire la fonction
h comme suit.
h(x̄, 0) = g(x̄, 0)
h(x̄, n + 1) = h(x̄, n) · g(x̄, n + 1)
Puisque g et la multiplication · sont RP, la construction ci-dessus montre que h est aussi RP.
1.2 Les prédicats RP

Un prédicat sur Nk décrit une propriété d’un k-uplet (x1 , . . . , xk ). Il peut être défini par une
fonction Nk → {vrai, f aux} ou bien par un sous-ensemble de Nk .
Exemple 1. Le prédicat P air sur N. Nous avons P air(5) = f aux et P air(6) = vrai. Le prédicat
P air correspond à l’ensemble {0, 2, 4, 6, 8 . . .}.
Exemple 2. Le prédicat P lusGrand sur N2 est défini comme suit.

vrai si x > y,
P lusGrand(x, y) =
f aux sinon.
Il correspond à un ensemble {(1, 0), (2, 0), . . . , (2, 1), (3, 1), . . .}.
Dans le cadre défini dans l’introduction un prédicat P sur Nk correspond au problème (U, B)
avec U = Nk et B = {x̄|P (x̄)}.
Définition 5 (Fonction caractéristique) Soit P un prédicat sur Nk . Sa fonction caractéristique

est χP : Nk → N telle que
1 si P (x̄),
χP (x̄) =
0 si ¬P (x̄).
La fonction caractéristique du prédicat P air est donc

χP air (2n) = 1,
χP air (2n + 1) = 0.
Et celle du prédicat P lusGrand

1 si x > y,
χP lusGrand (x, y) =
0 sinon.
Définition 6 (Prédicat RP) Un prédicat P sur Nk est RP ssi χP est RP.
Exemple 1. La fonction caractéristique d’un prédicat P tel que P (x) ⇔ x 6= 0 est :

1 si x > 0,
χP (x) =
0 si x = 0.
On peut voir que χP (x) = sg(x) et χP est donc RP. Par conséquent, le prédicat P est RP. ⋄
Proposition 2 Soient P et Q deux prédicats RP, alors P ∧ Q, P ∨ Q, ¬P et P ⇒ Q sont aussi

RP.
Autrement dit, la classe de prédicats RP est fermée par les opérations booléennes.
Démonstration. Nous prouvons d’abord que P ∧ Q est RP. Comme (P ∧ Q)(x̄) ≡ P (x̄) ∧ Q(x̄),
alors,
1 si χP (x̄) = 1 et χQ (x̄) = 1,
χP ∧Q (x̄) =
0 sinon.
10
On peut en déduire que χP ∧Q (x̄) = χP (x̄).χQ (x̄). Or χP et χQ sont RP par hypothèse et, de plus,
on sait que la multiplication est RP. Par conséquent, χP ∧Q est RP et P ∧ Q l’est aussi.
Nous allons maintenant prouver que ¬P est RP.

1 si χP (x̄) = 0,
χ¬P (x̄) =
0 si χP (x̄) = 1.
.
Il est facile de voir que χ¬P (x) = 1 − χP (x̄). Alors, χ¬P est RP et ¬P est donc RP.
Pour “∨” et “⇒”, on peut les exprimer en utilisant “∧” et “¬” comme suit : (P ∨ Q) ≡
(¬(¬P ∧ ¬Q)) et (P ⇒ Q) ≡ (¬(P ∧ ¬Q)).
Par la suite, nous présentons les propriétés de la RP.
Proposition 3 (Quantification bornée) Soit P (x̄, y) un prédicat RP. Alors, ∀x ≤ n P (x̄, y)

et ∃y ≤ n P (x̄, y) sont RP.
Il est important de noter que cette propriété n’est pas vraie pour une quantification arbitraire,
par exemple ∀xP (x̄, y) ou bien ∃yP (x̄, y).
△
Démonstration. Pour ∀≤ , notons Q(x̄, n) = ∀x ≤ n : P (x̄, y). Donc,
( n
1 si ∀y ≤ n : χP (x̄, y) = 1, Y
χQ (x̄, n) = = χP (x̄, y)
0 sinon.
y=0
Qn
On sait que χP est RP, par hypothèse. En plus, selon la Proposition 1, le produit y=0 préserve
la récursivité primitive. Ainsi, RP est fermé par ∀≤ .
Pour ∃≤ , il suffit d’utiliser la propriété que ∃x ≤ n P (x̄, y) peut être exprimé comme ∃x ≤
n P (x̄, y) ≡ ¬(∀x ≤ n : ¬P (x̄, y)).
Proposition 4 (Définition par cas) Si les fonctions gi et les prédicats Pi sont RP (pour i ∈
{1, . . . , n}, alors la fonction 
 g1 (x̄) si P1 (x̄),

f (x̄) = ..
 .

gn (x̄) si Pn (x̄).
est aussi RP.
Pour prouver la proposition, notons que la fonction f peut être écrite comme f = g1 .χP1 + . . . +
gn .χPn . Alors, f est RP puisqu’elle est obtenue à partir des fonctions RP en utilisant l’addition
et la multiplication.
Définition 7 (Opérateur de minimisation bornée) Soit P (n̄, m) un prédicat. Alors,

△ le plus petit i t.q. P (n̄, i) s’il existe,
f (n̄, m) = µi≤m P (n̄, i) =
0 si un tel i n’existe pas.
On dit que f est obtenue de P par la minimisation bornée.
Proposition 5 (Fermeture de RP par minimisation bornée) Si P est RP, et f est obtenue

de P par la minimisation bornée, alors f est aussi RP
Démonstration. Soit f (n̄, m) = µi≤m P (n̄, i).

On peut définir la fonction f par cas :

0 si P (n̄, 0)
f (n̄, m) =
f1 (n̄, m) sinon.
11
La fonction f1 (qui correspond au cas non-trivial de la minimisation quand P (n̄, 0) est faux) peut
être définie par récurrence primitive :


 f1 (n̄, 0) = 0


 f1 (n̄, m) si f1 (n̄, m) > 0
 f (n̄, m + 1) = m+1 si f1 (n̄, m) > 0 ∧ P (n̄, m + 1)
 1
 
0 sinon
La première ligne du cas récursif correspond au cas où le plus petit i satisfaisant la propriété est
≤ m (et donc nous l’avons déjà trouvé), la deuxième correspond au cas où le plus petit i est m + 1
(et donc nous ne l’avions pas encore trouvé aux étapes précédentes, mais P (n̄, m + 1) est vrai), la
dernière est pour le cas où nous ne trouvons pas le bon i ni avant, ni à l’étape m + 1.
Toutes les fonctions et prédicats qui interviennent dans la définition de f1 sont RP, et, par
conséquent, f1 l’est aussi. Donc f est aussi RP.
1.2.1 Exercices – des fonctions RP plus compliquées

1. Montrer que les prédicats x | y, EstP remier(x) et x mod y = z sont RP.
2. Nombres parfaits. Le nombre x est parfait s’il est égal à la somme de tous ses diviseurs (différents
de x). Par exemple : 6 = 1 + 2 + 3, 28 = 1 + 2 + 4 + 7 + 14.
Montrer que le prédicat EstParfait est récursif primitif.
Solution: Le prédicat est parfait(x) est récursif primitif :
" x−1
#
X
est parfait(x) = x = i · χ| (i, x)
i=1
où χ| est la fonction caractéristique du prédicat “divise”.

3. Montrer que les fonctions suivantes sont récursives primitives en utilisant les propriétés de fer-
meture :
(a) x mod y ;
(b) x div y ;
(c) ex2(x) : l’exposant de 2 dans la décomposition de x en facteurs premiers ;
(d) px : le x-ème nombre premier ;
Solution: On définit la fonction pn par récursion primitive

p0 = 2
pn+1 = µx < (n + 2)2 .x > pn ∧ ∀y < x(y = 1 ∨ ¬y|x)
Donc pn est récursive primitivea

a On a utilisé l’inégalité pn < (n + 1)2 .
(e) ex(x, y) : l’exposant de px dans la décomposition de y en facteurs premiers.

(f) Cxy : le nombre de combinaisons de x éléments y à y ;
√ √
(g) ⌊ x⌋ : la partie entière de x ;
(h) ⌊logx y⌋ : la partie entière de logx y ;
4. Les nombres de Fibonacci sont définis par la récurrence :

 F ib(0) = 1
F ib(1) = 1

F ib(n + 2) = F ib(n) + F ib(n + 1)
Montrer que la fonction F ib est RP.
12
1.3 Les fonctions RP ne suffisent pas
Nous avons vu dans que la classe de fonctions RP est assez riche pour définir une grande majo-
rité des algorithmes que vous connaissez. En choisissant une bonne représentation de structures de
données par des entiers (les détails d’une telle arithmétisation sont pareils que dans 1.6.2 ci-dessus)
il est possible de représenter comme des fonctions RP les solutions de quasiment tous les problèmes
vus en cours de Langages et Programmation. Néanmoins, les deux exemples suivants montrent
qu’il existe des fonctions calculables dans le sens informel (par exemple on peut les programmer
en Pascal, CAML ou ADA), mais qui ne sont pas récursives primitives. Ceci montre, que malgré
tout l’intérêt de la notion de fonctions RP, cette notion n’est pas une formalisation adéquate de la
notion d’algorithme.
1.3.1 Fonction d’Ackermann

On considère une famille de fonctions définie comme suit.

n·0=0
n ↑0 m = n · m = (1.1)
n · (m + 1) = n + n · m

n↑0=1
n ↑1 m = (1.2)
n ↑ (m + 1) = n · (n ↑ m)

n ↑↑ 0 = 1
n ↑2 m = (1.3)
n ↑↑ (m + 1) = n ↑ (n ↑↑ m)

n ↑k+1 0 = 1
n ↑k+1 m = (1.4)
n ↑k+1 (m + 1) = n ↑k (n ↑k+1 m)
Pour calculer n ↑0 m il faut 2 boucles for ; 3 boucles for pour n ↑1 m ; 4 boucles for pour n ↑2 m,
. . ., (k + 2) boucles for pour n ↑k m.
La fonction d’Ackermann peut être définie comme Ack(n, k, m) = n ↑k m.
Pour chaque k fixé, la fonction ↑k , c’est-à-dire λnm.n ↑k m est RP. Pourtant, on peut montrer
que la fonction Ack = λnkm.n ↑k m, k étant une variable, n’est pas RP. Nous omettrons la preuve
basée sur le fait que la fonction Ack croı̂t plus vite que toutes les fonctions récursives primitives.
Par contre, on peut facilement écrire un programme récursif qui termine toujours et qui calcule
Ack (il faut juste programmer les équations de récurrence 1.1- 1.4).
Nous venons donc de trouver une fonction calculable (dans le sens informel) qui n’est pas RP.
1.3.2 Interpréteur RP
Un autre exemple important d’une fonction calculable non RP est l’interpréteur des termes RP
(ou la fonction universelle). Pour démontrer que cet interpréteur n’est pas RP nous utilisons (pour
la première fois dans ce cours) la méthode de “diagonalisation”, qui jouera un rôle important dans
la suite.
Énumération La première idée est d’énumérer toutes les fonctions RP de forme N → N :

f0 (x), f1 (x), . . . , fi (x) . . . (1.5)
Pour obtenir une telle énumération nous pouvons remarquer, que chaque fonction RP f peut
être définie par un terme contenant les fonctions de base et les constructeurs de la classe RP. Par
exemple, la fonction doubler = λx.2x est définie par
△
doubler = Rec P ri(0, Comp(σ, Comp(σ, π22 )),
c’est-à-dire par une chaı̂ne de caractères ASCII. On peut énumérer toutes les chaı̂nes en ordre
lexicographique. La liste (1.5) contient toutes les fonctions RP et seulement les fonctions RP.
Nous allons noter la chaı̂ne numéro i par si .
13
Nous définissons ensuite un interpréteur RP (une fonction universelle Int(i, x) où i est le
numéro du programme et x est l’entrée) comme suit :

g(x) si si est la déf. d’une fonction RP g : N → N,
Int(i, x) =
0 si si n’est pas une telle définition.
Nous pouvons remarquer que Int est calculable (dans le sens usuel). Un programme pour calculer
Int(i, x) devrait générer d’abord la chaı̂ne si , effectuer son analyse syntaxique. Si si n’est pas un
terme RP pour une fonction scalaire, Int renvoie 0, sinon Int utilise l’arbre syntaxique obtenu et
les définitions des opérations Comp et rec pri pour calculer la valeur de fi (x)
Finalement on obtient la liste de toutes les fonctions RP en posant fi (x) = Int(i, x). Par
construction chaque fonction fi est soit nulle, soit représentée par un terme récursif primitif, et
donc, dans les deux cas elle est RP. Réciproquement, chaque fonction RP f admet un terme t qui
se représente par une chaı̂ne s qui a un numéro lexicographique i, donc f est présente dans la liste
sous ce numéro i.
Diagonalisation
Proposition 6 La fonction Int n’est pas RP.

△
Démonstration (par contradiction). Supposons que Int est RP. Définissons h(x) = fx (x) + 1 =
Int(x, x) + 1. Cette fonction doit aussi être RP (comme Int l’est). Donc h est dans la liste 1.5,
c’est-à-dire h = fi pour un certain i. Comme ∀xh(x) = fi (x), et avec x = i nous avons h(i) = fi (i).
Or, par définition, h(i) = fi (i) + 1. On obtient donc fi (i) = fi (i) + 1 – contradiction !
Nous en déduisons que notre hypothèse de départ était fausse et Int est RP (h non plus).
On peut re-formuler la même preuve en terme suivants. Nous définissons h comme suit :
h(1) = f1 (1) + 1
h(2) = f2 (2) + 1
..
.
h(k) = fk (k) + 1
Il est clair que pour chaque x = k, h(k) 6= fk (k), ce qui implique que h 6= fk pour tout k. Donc h
n’est pas dans la liste de toutes les fonctions RP, et donc h n’est pas RP.
1.4 Fonctions récursives partielles

Nous avons vu que la classe de fonctions RP est en fait une sous-classe de fonctions calculables.
La question qui se pose ensuite est comment construire la vraie classe de fonctions calculables.
Même si l’on élargit la classe de fonctions de base et les opérations, un contre-exemple similaire
à la fonction “diagonale” h ci-dessus est toujours valide. En effet, soit f0 (x), f1 (x), . . . , fi (x) . . .
la liste complète de fonctions calculables telle que fi (x) = Int(i, x). Alors, h(x) = fx (x) + 1 est
une fonction calculable qui n’est pas dans la liste. La solution à ce problème est de considérer les
fonctions partielles.
Définition 8 (Fonction partielle) Une fonction partielle f : Nk · · · → N est une fonction d’un
sous-ensemble de Nk vers N. Le domaine de f est Dom(f ) = {x̄ | f (x̄) est définie}. Si en x̄
la fonction f est définie, on écrit f (x̄) ↓ (on lit : f converge sur x̄), sinon on écrit f (x̄) ↑ ou
f (x̄) = ⊥ (f diverge). Si Dom(f ) = Nk on dit que f est totale1
Par convention, quand on applique des opérations arithmétiques (ou d’autres fonctions) à une
valeur indéfinie ⊥, le résultat diverge également.
1 Des fonctions totales forment une sous-classe des fonctions partielles.
14
Exemple 1.
x/2 si x est pair,
f (x) =
↑ sinon.
Alors, f (5) + 1 ↑, f (6) + 1 = 3 + 1 = 4, et 0 · f (7) + 2 ↑. En général, si f est une fonction
partielle, nous avons
0 si f (x) ↓
0 · f (x) =
↑ si f (x) ↑
1.4.1 Minimisation non-bornée

Afin de définir des fonctions récursives partielles, nous allons introduire la définition de la
minimisation non-bornée. Cette opération ressemble à la minimisation bornée, voir définition 7.
Définition 9 (provisoire) Si f (x̄, y) est totale, on peut définir la minimisation non-bornée comme
suit.
le plus petit y tel que f (x̄, y) = 1,
g(x̄) = µy.(f (x̄, y) = 1) = (1.6)
↑ s’il n’y a pas de tel y.
Exemples √
µy.((y + 1)2 > x) = ⌊ x⌋
√
x si x est un carré parfait,
µy.(y 2 = x) =
↑ sinon.

x/2 si x est pair,
µk.(2k = x) =
↑ sinon.
On voit que la minimisation bornée fait sortir de la classe des fonctions totales.
Au niveau toujours informel on peut se convaincre que le résultat de la minimisation est
calculable
Proposition 7 Si f est calculable totale, alors la minimisation non-bornée g définie
en (1.6) est aussi calculable.
Démonstration. Afin de prouver la proposition, nous montrons le programme suivant qui

calcule g. Notons que pour programmer la minimisation non-bornée, il faut utiliser des
boucles while.
fonction g(x̄)
y←0
while (f (x̄, y) 6= 1) {
y ←y+1
}
return y
Maintenant nous allons considérer le cas où f est partielle. On peut voir que la définition (1.6)
n’est plus adéquate puisque le programme qui calcule µy.f (x̄, y) boucle si f (x̄, y) n’est pas définie
pour certain y. Ainsi, nous allons donner ensuite une définition plus rigoureuse.
Définition 10 Soit f (x̄, y) est fonction (peut-être partielle), la minimisation non-bornée est définie
comme suit.
g(x̄) =
µy.(f (x̄, y) = 1)
le y tel que f (x̄, y) = 1 ∧ ∀i < y(f (x̄, i) ↓ ∧ f (x̄, i) 6= 1)
=
↑ s’il n’y a pas de tel y.
15
On voit donc, que µy.(f (x̄, y) = 1) est le plus petit y convenable, à condition que pour toutes les
valeurs plus petites la fonction est quand même définie.
Remarque. Il est très facile de se tromper en appliquant µ à des fonctions qui ne sont
pas totales. C’est une pratique déconseillée (et inutile, comme nous démontrerons dans
la suite).
1.4.2 Fonctions récursives partielles et la thèse de Church

Définition 11 (Fonctions récursives partielles) La classe de fonctions récursives partielles
est la plus petite classe de fonctions partielles qui contient les fonctions de base 0, π, σ, et qui est
fermée par les constructeurs Comp, Rec P ri et µ.
La seule différence par rapport à la définition de la classe RP est le nouveau constructeur µ.

C’est trivial que toutes les fonctions récursives primitives RP sont aussi récursives partielles.
Un lecteur attentif peut remarquer ici, que pour donner un sens précis à cette définition, il faut
étendre les opérations Comp, Rec P ri aux fonctions partielles. C’est un exercice pour ce lecteur.
Thèse 1 (Thèse de Church) La classe de fonctions récursives partielles est égale à la classe
de fonctions calculables par un algorithme quelconque.
Notons que ceci est une thèse (et pas un théorème) puisque la classe de fonctions récursives
partielles est formellement définie tandis que “la classe de fonctions calculables” est une notion
intuitive et informelle.
La thèse de Church contient deux parts :
1. Chaque fonction récursive partielle est calculable.
2. Chaque fonction calculable est récursive partielle.
Le raisonnement suivant permet de se convaincre de la première partie de la thèse de Church
“Démonstration.” Afin de prouver la première part, nous allons montrer que les fonctions
de base sont calculables, aussi bien que les constructeurs (qui sont utilisés pour définir
les fonctions récursives partielles) préservent la calculabilité, et il suffit de montrer les
programmes qui calculent ces fonctions. Pour les fonctions de base, c’est trivial de mon-
trer les programmes qui les calculent. En ce qui concerne les constructeurs, supposons
que nous avons les algorithmes pour calculer f et g, les programmes pour calculer les
résultats d’application des constructeurs sont montrés ci-dessous.
fonction Comp(f, g)(x̄)
return f (g(x̄))
fonction Rec P ri(f, g)(x̄, y)

r ← f (x̄)
for i = 1 to y {
r ← g(x̄, i, r)
}
return r
fonction µf = 1(x̄)
k←0
while f (x̄, k) 6= 1 {
k ←k+1
}
return k
Il existent aussi des arguments en faveur de la réciproque. En particulier toutes les fonctions
calculable par des algorithmes qu’on peut représenter en langages de programmations qui existent
16
actuellement sont récursives partielles. Des nombreuses définitions théoriques des fonctions cal-
culables sont équivalentes à la récursivité partielle. Donc si la thèse de Church est fausse et s’il
existe un algorithme qui n’est pas récursif partiel, cet algorithme doit être basé sur des principes
actuellement inconnus. Ceci me semble très peu probable.
Nous avons finalement réussi à trouver une notion formelle de fonction
calculable : c’est la notion de fonction récursive partielle.
1.4.3 Exercices – fonctions récursives partielles

1. Montrer que les fonctions suivantes sont récursives partielles (en utilisant l’opérateur de mini-
misation) : x − y ; xy ; logx y (elles sont définies seulement sur x et y tels que le résultat est
naturel).
2. Montrer que les fonctions suivantes sont récursives partielles :
(a)
2 une solution de l’équation y 3 − 5y 2 = 3 si elle existe
f (x) =
↑ s’il n’y a pas de solution
(b)
1 si x peut être représenté comme y 2 + z 2
f (x) =
↑ sinon
(c)
3 1 si ∃x, y, z · xn + y n = z n
f (n) =
↑ sinon
3. Montrer que le programme suivant calcule une fonction récursive partielle (problème de Collatz) :
function f (x)
n := 0 ;
while x > 1
n := n + 1
if pair(x)
then x := x div 2
else x := 3x + 1
return n
1.5 Machines de Turing

Nous allons maintenant étudier un autre modèle de calcul qui est la machine de Turing. Ce
modèle est très différent du modèle fonctionnel des fonctions récursives partielle. Il ressemble plus
aux modèles de calcul de type “machine”, tels que des automates ou des machines à pile (et aux
ordinateurs réels). La raison pour laquelle nous concentrons sur les machines de Turing est qu’elles
sont des machines abstraites très simples mais capables de réaliser tous les algorithmes.
Pour mieux placer les machines de Turing dans le contexte nous pouvons considérer d’abord
des modèles plus simples. Un automate fini, n’ayant pas de “mémoire externe”, a une capacité de
calcul assez limitée. Une machine à pile est un automate avec une pile, qui représente une mémoire
externe non-bornée, mais avec l’accès très restreint (seulement par le sommet). Une machine de
Turing peut être vue comme un automate avec un ruban de longueur infinie (qui est une mémoire
avec des règles d’accès assez libérales). Plus précisément, chaque case du ruban contient un symbole
(on suppose que seulement un nombre fini de cases contiennent un symbole non-nul), la machine
possède une tête qui peut se déplacer sur le ruban, lire le symbole à sa position, et réécrire ce
symbole. La définition formelle suit.
2 cas particulier du 10-ème problème de Hilbert.
3 Problème de Fermat.
17
Définition 12 (Machine de Turing) Une machine de Turing (une MT) est un quadruplet M T =
(Q, Σ, q0 , δ) tel que
– Q : un ensemble fini appelé l’ensemble d’états,
– Σ : un alphabet fini appelé l’alphabet du ruban (on suppose que cet alphabet contient 0 et 1),
– q0 : un élément de Q appelé l’état initial,
– δ : le programme qui est un ensemble d’instructions.
Les instructions ont la forme suivante :(état, symbole lu) → (état, symbole écrit, déplacement) où
les deux états appartiennent à Q, le deux symboles à Σ, et le déplacement à {G, D, −}. Il y a donc
trois types d’instructions :
– (q, a) → (p, b, G) (en observant a en état q passer à l’état p, écrire b, déplacer la tête à
gauche),
– (q, a) → (p, b, D) (déplacer à droite),
– (q, a) → (p, b, −) (aucun déplacement).
Définition 13 Configurations et calculs d’une machine de Turing

– Une configuration d’une M T est (wG , q, wD ) où wG est le mot à gauche de la tête de lecture
(jusqu’au premier symbole non-nul), q est l’état actuel, wD est le mot à droite de la tête de
lecture (y compris la case où la tête se trouve, et jusqu’au dernier symbole non-nul).
– Un calcul de la machine sur une entrée (x1 , . . . , xk ) ∈ Nk est une séquence de configurations
c1 , c2 , . . . , cn telle que
1. Chaque configuration ci+1 est obtenue à partir de la configuration ci en appliquant une
instruction de la machine4 .
2. c1 = ε, q0 , 01x1 01x1 . . . 01xk .
3. Dans la configuration cn il n’y a pas d’instructions applicables.
Dorénavant, nous considérons seulement les machines de Turing déterministes, c’est-à-dire les
machines ayant au plus une instruction commençant par le même (q, a).
Exemple. Supposons que la machine M a seulement 2 instructions :
I1 : (q0 , 0) → (q1 , 1, D)
I2 : (q1 , 0) → (q1 , 3, G)
et qu’initialement le ruban de la machine M ne contient que des 0’ :
... | 0 | 0 | 0 | 0 | 0 | 0 |...
△ .
Alors, après avoir exécuté le programme, la machine est dans la configuration suivante :
... | 0 | 0 | 1 | 3 | 0 | 0 |...
△
q0
Le calcul de la machine est donc (ε, q0 , ε) → (1, q1 , ε) → (ε, q0 , 13). ⋄
Définition 14 (Fonctions calculées par les machines de Turing) Le résultat de calcul de

la machine M est le nombre de “1” sur le ruban quand la machine est dans la configuration cn . La
(k)
fonction(partielle) fM de k arguments calculée par la machine M est donc définie comme suit :
– Si sur l’entrée (x1 , . . . , xk ) la machine M s’arrête dans une configuration cn alors f (x1 , . . . , xk ) =
nombre de “1” dans cn .
– si elle ne s’arrête pas, alors f (x1 , . . . , xk ) ↑
4 pour être rigoureux il faudrait formaliser cela.
18
Exemples. Voir exercices 1-2, section 1.6.1.
1.6 Thèse de Church-Turing. Équivalence MT – fonctions

récursives partielles
Nous présentons maintenant les résultats importants qui montrent le lien entre les fonctions
calculées par les machines de Turing et les fonctions récursives partielles.
Théorème 1 Chaque fonction récursive partielle peut être calculée par une machine de Turing.
Théorème 2 Chaque fonction calculée par une machine de Turing est récursive partielle.
D’où la forme équivalente de la thèse de Church
Thèse 2 (Thèse de Church-Turing.) La classe de fonctions calculables par machines de Tu-

ring est égale à la classe de fonctions calculables par un algorithme quelconque.
Pour prouver les deux théorèmes ci-dessus, nous construirons deux compilateurs : l’un qui
compile une fonction récursive partielle vers une machine de Turing, et l’autre qui compile une
machine de Turing vers une fonction récursive partielle. Nous présenterons dans la suite ces preuves
avec plus de détails.
Preuve du théorème 1
Nous allons montrer d’abord quelques résultats préliminaires qui seront utilisés pour la preuve.
En outre, pour des raisons techniques, nous aurons besoin de calculs réguliers. Une machine M
calcule f régulièrement si elle satisfait les deux conditions suivantes :
1. Quand la machine M s’arrête, elle le fait toujours dans une configuration de la forme
... | 0 | 0 | 1f (x̄) | 0 | ...

△
q1
2. Elle ne va jamais à gauche de sa position initiale.

Nous prouverons par induction que pour chaque fonction récursive partielle il existe une MT
qui la calcule régulièrement.
Le cas de base est laissé comme exercice (voir section 1.6.1) :
Lemme 1 Il existe des machines de Turing qui calculent régulièrement les fonctions 0(), σ(x) et
πik (x1 , . . . , xk ).
Pour le cas inductif il faut considérer les trois constructeurs. Nous donnerons une preuve pour
Comp et nous donnerons des exercices pour illustrer les deux autres preuves.
Lemme 2 Si f et g1 , . . . , gk sont calculables par une MT, alors Comp(f, g1 , . . . , gk ) est calculable
par une MT.
Démonstration. Nous considérons uniquement le cas de deux fonctions scalaires. Soient f et g

(1) (1)
deux fonctions MT-calculables : f = fR (calculable par la machine R), g = fS (calculable par
la machine S). Nous voulons alors calculer f (g(x)).
Soient r0 , r1 , . . . , rn les états de R, et s0 , s1, . . . , sm les états de S (nous supposons ces deux
ensembles disjoints).
Nous allons construire une machine de Turing M pour calculer f (g(x)). Les états de M sont
q0 , q1 , r0 , r1 , . . . , rn , s0 , s1, . . . , sm
19
et ses instructions sont
I1 : q0 0 → s0 0 (lancer S),
δS (instructions de S),
I2 : s1 0 → r0 0 (lancer R),
δR (instructions de R),
I3 : r1 0 → q1 0 (stop).
Les étapes de calcul de M sont

I S I R I
(ε, q0 , 01x ) →
1
(ε, s0 , 01x ) → (ε, s1 , 01g(x) ) →
2
(ε, r0 , 01g(x) ) → (ε, r1 , 01f (g(x)) ) →
3
(ε, q1 , 01f (g(x)) ),
ce qui conclut la preuve.
Lemme 3 Si f et g sont calculables par une MT, alors Rec P ri(f, g) est calculable par une MT.
Voir exercice 5a ci-dessous pour une idée de preuve.
Lemme 4 Si f est calculable par une MT, alors µy.f (x̄, y) = 1 est calculable par une MT.
Voir exercice 5b ci-dessous pour une idée de preuve.

Le théorème 1 est une conséquence immédiate des lemmes ci-dessus et de la définition des
fonctions récursives partielles. Nous venons de montrer que “récursive partielle ⇒ MT-calculable
régulièrement”. Cette démonstration est constructive et peut être vue comme une description d’un
compilateur des fonctions récursives partielles vers des MT (régulières) ⋄
1.6.1 Exercices – MT
1. Quelle fonction f (x) (d’un seul argument) est calculée par cette Machine de Turing ?
q0 0 −→ q2 0D
q0 1 −→ q1 1
q2 0 −→ q1 1
q2 1 −→ q2 1D
2. Quelles fonctions sont calculées par cette Machine de Turing (donner toutes les fonctions de 0,
1, 2 et plus arguments) ?
q0 0 −→ q1 0
3. Écrire les machines de Turing qui calculent (régulièrement) les fonctions suivantes :
(a) 0() ;
(b) σ(x) ;
(c) π23 (x, y, z).
4. Écrire les machine de Turing qui font les transformations suivantes :
(ε, q0 , 01x ) −→ (ε, q1 , 01x 01x ) (1.7)
(1x , q0 , 01y ) −→ (1y , q1 , 01x ). (1.8)

5. Définir les machines de Turing qui calculent (régulièrement) :
(a) x · y ;
√
(b) x.
20
1.6.2 Vers la preuve de théorème 2
En ce qui concerne le théorème 2, la difficulté de sa preuve est que les machines de Turing
fonctionnent sur Σ∗ tandis que les fonctions récursives partielles sont définies sur les entiers. Il
faut donc représenter les mots ainsi que les séquences de mots par les entiers. Pour ce but, nous
allons utiliser l’arithmérisation ou Gödelisation.
Gödelisation
L’idée est de donner un numéro entier naturel à chaque objet utilisé (mot, instruction, ma-
chine de Turing...) et de remplacer des manipulation de ces objets par des opérations de nature
arithmétique sur leurs numéros
Nous commençons par les séquences d’entiers. Le numéro de Gödel d’un n-uplet d’entiers
naturels (x1 , . . . , xn ), dénoté par hx1 , . . . xn i, est défini comme suit :
n
Y
A = hx1 , . . . xn i = 2n · 3x1 · 5x2 · · · pxnn = 2n pxi i .
i=1
(nous utilisons la notation pi comme notation pour le n-ème nombre premier avec p0 = 2 et p1 = 3)
Par exemple, h10, 11i = 22 · 310 · 511 = 11533007812500. Nous mentionnons ensuite quelques
opérations usuelles sur les numéros de Gödel :
– est un no(A) : ce prédicat est vrai ssi A est le numéro d’un uplet
– long(A) : longueur de l’uplet (par exemple n pour A = hx1 , . . . xn i). Pour complétude on
pose la valeur de cette fonction à 0 si A n’est pas un numéro.
– el(A, i) : élément xi (ou 0 si A n’est pas un numéro, ou si la séquence ne contient pas assez
d’éléments)
– remplacer(A, i, m) : remplacer xi par m, c-à-d pour A = hx1 , . . . , xi , . . . , xn i, le résultat est
remplacer(A, i, m) = hx1 , . . . , m, . . . , xn i.
Propriétés des numéros de Gödel

– Le numéro de Gödel d’un n-uplet est une opération injective (c-à-d des n-uplets différents
ont des numéros différents).
– Les opérations énumérées ci-dessus sur les numéros de Gödel (et autres opérations naturelles)
sont récursives primitives.
Démonstration. Le numéro de Gödel d’un n-uplet est injective puisque la décomposition en
facteurs premiers est unique. La preuve que les opérations sont récursives primitives fait l’objet
de l’exercice 1 (section 1.6.3).
Arithmétisation de MT
Supposons que l’alphabet d’une machine de Turing M est Σ = {a0 , a1 , . . . , an } (avec a0 = 0 et
a1 = 1) et que ses états sont Q = {q0 , . . . , qm }.
Numéro d’un mot. Soit w ∈ Σ∗ tel que w = ai1 ai2 . . . ail . Le numéro de w est hwi =
hi1 , i2 , . . . il i. Par exemple, ha3 a7 a1 i = h3, 7, 1i = 23 .33 .57 .71 .
Numéro d’une instruction. Étant donné une instruction

 
 − 
I : qi aj → qk al G
 
D
 
 0 
hIi = hi, j, k, l 1 i
 
2
21
Numéro d’une machine de Turing. Soient I1 , . . . , In les instructions de la machine M . Alors,
hM i = hhI1 i, . . . , hIn ii
Numéro d’une configuration. Soit c = (wG , qi , wD ) une configuration.
hci = hhwG i, hii, hwD ii
Démonstration de théorème 2
Nous allons le prouver uniquement pour le cas scalaire. Pour établir la preuve, nous définissons
les fonctions suivantes :
– init(x) donne le numéro de la configuration initiale pour l’entrée x. La fonction init(x) est
récursive primitive (voir TD).
– suivant(m, c) donne le numéro de la configuration de la machine numéro m après une
transition à partir de la configuration numéro c. La fonction suivant(m, c) est récursive
primitive (exercice).
– conf(m, x, t) donne le numéro de la configuration de la machine numéro m après t transitions
à partir de l’entrée x. On peut prouver que conf(m, x, t) est récursive primitive :

conf(m, x, 0) = init(x)
conf(m, x, t + 1) = suivant(m, conf(m, x, t))
– stop(m, c) donne V rai si la configuration numéro c est une configuration de l’arrêt de la

machine numéro m (exercice).
– temps de calcul(m, x) = µt . stop(m, conf(m, x, t)). Cette fonction est aussi récursive par-
tielle.
– sortie(c) donne le nombre de “1” sur le ruban dans la configuration numéro c. sortie(c) est
récursive primitive (voir TD).
Ensuite, en utilisant les fonctions ci-dessus nous pouvons définir la fonction
la fonction(m, x) = sortie(conf(m, x, temps de calcul(m, x)))
qui donne en fait le résultat du calcul de la machine numéro m sur l’entrée x.

Résumons ce que nous avons établi. Soit f (x) une fonction Turing-calculable, c’est-à-dire il
existe une machine de Turing M telle que f (x) = fM (x). Soit m0 le numéro de M . Alors f (x) =
la fonction(m0 , x), indiquant que f est récursive partielle. Nous venons de prouver que “MT-
calculable” ⇒ “récursive partielle” (pour le cas de fonctions d’un seul argument). L’extension au
cas général est presque triviale.
Notons que le but initial étant de chercher un compilateur d’une machine de Turing vers une
fonction récursive partielle, nous avons trouvé en fait un interpréteur (c-à-d la fonction(m, x))
– une fonction récursive partielle capable de trouver le résultat de chaque machine de Turing sur
chaque entrée. Comme ces résultats ont été établis avant l’invention de la programmation (et des
interpréteurs), cette fonction a été appelée la fonction universelle. Dans la suite, nous étudions les
propriétés de cette fonction.
1.6.3 Exercices – Gödelisation

Cette série d’exercices permet de compléter la preuve ci-dessus
1. Montrez que le prédicat

vrai s’il existe une représentation M = hx0 x1 . . . xn−1 i
EstU nN umero(M ) =
faux sinon
22
et les fonctions

n s’il existe une représentation M = hx1 x2 . . . xn i
longueur(M ) =
0 sinon

xi s’il existe une représentation M = hx1 x1 . . . xn i, n≥i>0
element(M, i) =
0 sinon
sont récursives (primitives).
2. Trouvez la forme explicite de la fonction suivante et déduisez sa récursivité primitive :
init(x) = numéro de Gödel de la configuration initiale de la MT pour l’entrée x.
3. Prouvez que la fonction suivante est récursive primitive :

sortie(x) = le nombre de 1s sur le ruban dans la configuration de numéro de Gödel c.
1.6.4 Fonction universelle

Nous dénotons la fonction universelle par U , c-à-d U = la fonction.
Théorème 3 (Théorème d’énumération)
1. U (m, x) est récursive partielle (Turing-calculable)

2. Pour chaque fonction f (x) récursive partielle (ou Turing-calculable) avec un seul argument,
il existe m0 tel que f (x) = U (m0 , x) pour tout x.
Démonstration. Pour (1), nous avons déjà montré que U (m, x) est récursive partielle dans la
preuve du théorème 2. Pour (2), comme f (x) est Turing-calculable, par le théorème 1, il existe
une machine de Turing M telle que f (x) = fM (x). Soit m0 le numéro de la machine M . En
conséquence, f (x) = U (m0 , x).
Nous avons présenté le théorème 3 pour le cas scalaire, mais il peut être facilement étendu au
cas vectoriel. Pour ce cas-là où x̄ = (x1 , . . . , xk ), la fonction universelle a la forme U (k) (m, x̄). Nous
(k) △ (k)
définissons la fonction λm, x̄ . ϕm (x̄) = U (k) (m, x̄), c-à-d ϕm (x̄) est une fonction récursive par-
(k)
tielle de k arguments calculée par la machine numéro m et ϕm (x̄) est appelée la fonction récursive
partielle numéro m de k arguments. Nous avons alors énuméré toutes les fonctions calculables :
Théorème 4 (Théorème d’énumération - forme 2)
1. La liste
(k) (k) (k)
ϕ0 , ϕ1 , ϕ2 , . . .
est une énumération de toutes les fonctions récursives partielles de k arguments.
(k)
2. Cette énumération est “effective” (calculable) dans le sens que la fonction λm, x̄ . ϕm (x̄) est
récursive partielle.
(k)
Dans la suite nous utiliserons systématiquement la notation ϕm en omettant parfois l’indice d’arité
(k).
1.7 Théorème de la forme normale

Une autre conséquence importante de la preuve du théorème 2 est la suivante. Rappelons que
U (m, x) = sortie(conf(m, x, temps de calcul(m, x))).
D’ailleurs, temps de calcul(m, x) = µt . stop(m, conf(m, x, t)). La fonction fM (x) peut être
donc écrite sous forme fM (x) = g(x, µt . P (x, t)), ce qui montre que pour exprimer fM (x), seule
l’opérateur de minimisation µ suffit. Nous avons établi le résultat suivant :
23
Théorème 5 (Théorème de la forme normale) Chaque fonction récursive partielle peut être
représentée comme
fM (x) = g(x, µt . P (x, t))
où g est une fonction récursive primitive et P est un prédicat récursif primitif.
Nous laissons comme exercice le résultat suivant qui donne une forme normale un peu plus simple :
Théorème 6 (Théorème de la forme normale 2) Chaque fonction récursive partielle peut

être représentée en utilisant seulement l’opérateur de minimisation µ :
fM (x) = h(µy . Q(x, y))
où h est une fonction récursive primitive et Q est un prédicat récursif primitif.
Remarque. Une conséquence du théorème 5 est que tout algorithme peut être programmé avec
une seule boucle while et plusieurs boucles for.
1.8 Théorème de paramétrisation (s-m-n)

Maintenant nous allons considérer le problème suivant. Étant donné une fonction f (x, y) de
2 arguments, nous voulons traiter x comme paramètre afin d’obtenir une famille de fonctions
calculables d’un argument, par exemple,
f (0, y)
f (1, y)
..
.
f (2003, y)
En d’autres termes, le problème que nous voulons résoudre est formulé comme suit. Supposons
(2)
que f (x, y) est calculable par une machine de Turing numéro i, c’est-à-dire f (x, y) = ϕi (x, y),
on veut trouver les programmes qui calculent les fonctions suivantes :
f (0, y) = ϕC0 (y)

f (1, y) = ϕC1 (y)
..
.
f (2003, y) = ϕC2003 (y)
où Ca est le programme numéro i avec l’entrée x fixée à a : x = a. Le théorème de paramétrisation

dit que l’on peut calculer ces fonctions ϕCa (y) par une transformation de programme :
Ca = s(i, a)
où Ca est le programme pour calculer λy . ϕCa (y) et a est le premier argument de la fonction
f (x, y) que l’on veut considérer comme paramètre, et la fonction s est récursive primitive.
programme i s programme Ca
pour λx, y.φi (x, y) pour λy.φCa (y)
Fig. 1.1 – Illustration du théorème de paramétrisation.
24
Théorème 7 (s-m-n : cas scalaire) Il existe une fonction s récursive primitive telle que pour
tout x, y
(2) (1)
ϕi (x, y) = ϕs(i,x) (y) (1.9)
La preuve du théorème (omise) peut être faite par une manipulation de machines de Turing.
Exemple. Soit ga une fonction définie comme suit : ga = λy . a + y 2 , nous voulons trouver le
numéro de MT qui calcule ga . Pour ceci, nous considérons a et y comme arguments, et la fonction
h(a, y) = a + y 2 est calculable. Soit k le numéro de la machine de Turing qui calcule h. En utilisant
le théorème s-m-n nous obtenons
(2) (1)
h(a, y) = ϕk (a, y) = ϕs(k,a) (y) = a + y 2 .
Théorème 8 (s-m-n : cas général) Pour tout m et n il existe une fonction sm

n : N
m+1
→N
m n
récursive primitive telle que pour tout x̄ ∈ N et ȳ ∈ N
(m+n) (n)
ϕi (x̄, ȳ) = ϕsm (i,x̄) (ȳ) (1.10)
n
1.8.1 Exercices – s-m-n

1. Trouver une fonction h récursive primitive qui transforme un programme pour toute fonction
récursive partielle f (y) vers un programme pour la fonction 7f (y). C’est-à-dire ϕh(x) (y) =
7ϕx (y).
2. Trouver une fonction g qui “compose” deux machines de Turing. C’est-à-dire g est telle que
ϕg(p,q) (x) = ϕp (ϕq (x)).
25
Chapitre 2
Décidabilité et indécidabilité
2.1 Problèmes décidables

Comme nous avons déjà mentionné, les problèmes de décision que nous considérons sont posés
sous la forme : “Étant donné x, est-ce que le prédicat P (x) est vrai ?”, ou bien sous la forme :
“Est-ce que x ∈ P ?” où P est un ensemble.
Nous somme maintenant capables de donner la définition centrale de ce cours : celle de la
décidabilité :
Définition 15 Un prédicat P est décidable (récursif ) si χP est récursive totale. Au cas contraire
on dit que P est indécidable.
Une forme équivalente de cette définition est la suivante :
Définition 16 P est récursif (décidable) s’il existe une fonction g récursive totale telle que :

1 si P (x),
∀x : g(x) =
0 si ¬P (x).
Intuitivement, P est décidable s’il existe un algorithme qui pour chaque x dit “OUI” ou “NON”
à la question : “Est-ce que P (x) est vrai ?”.
Remarque. Par définition, la fonction caractéristique est définie partout, et si elle est calculable,
alors elle est obligée d’être récursive totale.
Propriétés des prédicats décidables. Fermeture booléenne : Si A et B sont décidables, alors

Ā, A ∨ B, A ∧ B sont décidables. Pour prouver ce résultat, notons que
.
χĀ (x) = 1 − χa (x)
χA ∨ B (x) = sg(χA (x) + χB (x))
χA ∧ B (x) = sg(χĀ (x) + χB̄ (x)) (puisque A ∧ B = Ā ∨ B̄)
2.2 Premiers problèmes indécidables

Dans la suite nous examinons deux prédicats représentants deux problèmes de décision impor-
tants. Nous avons maintenant tous les outils pour prouver leur indécidabilité.
1
1. Problème de l’arrêt :
△ △
Arret(x, y) = ϕx (y) ↓ = la machine de Turing x s’arrête sur l’entrée y
1 “Halting problem” en anglais.
26
En langage courant ce problème est posé comme suit : est-ce que le programme x donne un
résultat sur l’entrée y ?
2. Problème K : l’ensemble K est défini comme K = {x | ϕx (x) ↓}
△ △
K(x) = ϕx (x) ↓ = le programme x s’arrête sur l’entrée x.
Le problème K est un sous-problème de l’arrêt (en fait K(X) ⇔ Arret(x, x)). Si l’on savait
décider le problème de l’arrêt, on saurait aussi décider K.
Théorème 9 K est indécidable.
Démonstration :
Une fonction auxiliaire D’abord, observons que

1 si x = 0,
v(x) =
↑ si x > 0.
est récursive partielle puisque v(x) = 1 + µy . (x + y = 0).
Construction diagonale Nous allons prouver le théorème par contradiction. Supposons que K
est décidable. Alors, il existe une fonction g récursive telle que :

1 si K(x), 1 si ϕx (x) ↓,
g(x) = =
0 si ¬K(x) 0 si ϕx (x) ↑.
Nous pouvons maintenant construire une nouvelle fonction :

1 si ϕx (x) ↑,
d(x) = v(g(x)) =
↑ si ϕx (x) ↓.
La fonction d est récursive puisqu’elle est obtenue par la composition de v et de g qui sont
récursives. Donc,
d(x) ↓ si ϕx (x) ↑,
d(x) ↑ si ϕx (x) ↓.
ou, plus court, pour tout x nous avons
d(x) ↓ ⇔ ϕx (x) ↑
Cette propriété nous permettra d’obtenir une contradiction.
Raisonnement “diagonale” Pour chaque a le fait que d(a) ↓ ⇔ ϕa (a) ↑ implique que d 6= ϕa
(ces deux fonctions se comportent différemment sur a). Alors, d n’est pas dans la liste ϕ0 , ϕ1 , . . . , ϕa , . . ..
Pourtant, cette liste est l’énumération de toutes les fonctions récursives partielles. Donc, d n’est
pas récursive partielle, ce qui est une contradiction puisque nous avons montré précédemment que
d est récursive partielle. On conclut que K est indécidable.
Vu l’importance du raisonnement ci-dessus nous le présentons encore une fois sous une forme
différente.
Raisonnement “diagonale” - forme succincte De même, nous utilisons la fonction d définie

dans la première preuve, qui est récursive partielle. Soit c son numéro. Alors, d = ϕc . Comme
d(x) ↓ ⇔ ϕx (x) ↑, nous avons
∀x ϕc (x) ↓ ⇔ ϕx (x) ↑ .
En particulier, pour x = c nous avons ϕc (c) ↓ ⇔ ϕc (c) ↑, ce qui est une contradiction. Alors, K
est indécidable.
27
Corollaire 1 Le problème de l’arrêt est indécidable.
Démonstration. Supposons que le problème de l’arrêt est décidable. Alors, il existe f (x, y) récursive
telle que
1 ↓ si Arret(x, y), 1 ↓ si ϕx (y) ↓,
f (x, y) = =
0 ↑ sinon 0 ↑ si ϕx (y) ↑.
Puis, la fonction u(x) = f (x, x) est aussi récursive. En plus,

1 ↓ si ϕx (x) ↓,
u(x) = = χK
0 ↑ si ϕx (x) ↑
Ceci veut dire que K est décidable. Mais, selon le théorème 9, K est indécidable, d’où une contra-
diction. Alors, le problème de l’arrêt est indécidable.
2.2.1 Exercices sur la diagonalisation

Cette série d’exercices sert à mieux comprendre la méthode de diagonalisation qui joue un rôle
principal dans les preuves d’indécidabilité
1. Le barbier du village rase tous les habitants qui ne se rasent pas et seulement ceux-là. Est-ce
qu’il se rase ? Formaliser en utilisant le prédicat R(x,y). Comparer avec la preuve de l’indécidabilité
du problème K. Réfléchir est-ce qu’il se rase vraiment.
2. Une fonction partielle qu’on ne peut pas compléter. On considère la fonction suivante :
f (x) = ϕx (x) + 1
Montrer que :
(a) f est récursive partielle.
(b) il n’existe pas de fonction récursive totale g qui prolonge f , c’est-à-dire telle que

f (x) si f (x) ↓
g(x) =
valeur arbitraire si f (x) ↑
Indication : supposer le contraire et considérer le numéro de g

3. Montrer qu’il n’existe pas d’énumération effective de fonctions récursives totales, c’est à dire
d’une liste h1 (x), h2 (x), . . . telle que :
(a) chaque fonction h(x) est récursive totale ;
(b) chaque fonction récursive totale est dans la liste ;
(c) la fonction V (i, x) = hi (x) est calculable.
Pourquoi une telle énumération est quand même possible pour les fonctions récursives partielles ?
2.3 Méthode de réduction

Nous venons d’établir l’indécidabilité du problème de l’arrêt (corollaire 1) par le raisonnement
suivant : le problème K se réduit au problème de l’arrêt, K est indécidable, donc Arret est
indécidable. Dans l’étude de complexité, il y a un raisonnement similaire : SAT ∝ Clique, SAT est
NP-complet, alors Clique est NP-complet.
La réduction est une méthode très utile pour prouver l’indécidabilité de problèmes divers. Nous
étudierons cette méthode de raisonnement plus profondément.
Définition 17 (m-réduction ) Soient A et B deux prédicats. A ≤m B s’il existe une fonction

h récursive totale telle que ∀x A(x) ⇔ B(h(x)). Dans ce cas on dit que A se réduit à B par h2 .
2 Il existe d’autres notions de réduction utiles : 1-réduction, Turing-réduction, réduction polynômiale vue en AC,
mais dans ces notes nous nous intéressons uniquement à la m-réduction.
28
Le diagramme suivant peut illustrer cette définition.
B
h(x) −→ B(h(x)) oui/non
↑ ↓ Id
A?
x −→ A(x) oui/non
Proposition 8 (Propriétés de ≤m )
– A ≤m A (réflexivité)
– A ≤m B ∧ B ≤m C ∧ A ≤m C (transitivité)
– Si R est récursive et A est tel que A 6= ∅ et Ā 6= ∅, alors R ≤m A (un problème décidable ce
réduit à tous les problèmes)
Le résultat suivant est presque évident : si A se réduit à B, et si l’on sait résoudre B, alors on
peut résoudre A.
Lemme 5 Si A ≤m B et B est décidable, alors A est décidable.
Démonstration. Par définition de ≤m , il existe une fonction h récursive totale telle que ∀xA(x) ⇔
B(h(x)). D’autre part, par définition de décidabilité, χB est récursive totale. Soit χA la fonction
caractéristique de A. Donc,

1 si A(x) 1 si B(h(x))
χA (x) = = = χB (h(x)).
0 si ¬A(x) 0 si ¬B(h(x))
On peut voir que χA est récursive totale puisque elle est obtenue par la composition de χB et h
qui sont récursives totales. Alors A est décidable.
Corollaire 2 Si A ≤m B et A est indécidable, alors B est indécidable.
Les résultats ci-dessus suggèrent une méthode pour prouver l’indécidabilité. Comme on sait que
K est indécidable, afin de prouver que B est indécidable, il suffit de montrer que K se réduit à B
(c-à-d K ≤m B).
Cette méthode permet d’établir l’indécidabilité de nombreux problèmes. Nous donnerons un
exemple simple et concret, et ensuite un résultat général.
Exemple. Nous considérons le problème de décision définie par B(x) ≡ ϕx (3) = 10. Il faut donc
pour un x donné décider si la machine de Turing de numéro de Gödel x sur l’entrée 3 s’arrête et
produit le résultat 10.
Nous montrons que B n’est pas récursif en utilisant une réduction de l’ensemble K à B. Soit
g la fonction partielle définie comme suit

10 si ϕx (x) ↓
g(x, y) =
↑ si ϕx (x) ↑
g est récursive partielle, comme g(x, y) = U (x, x) · 0 + 10, où U dénote la fonction universelle
(et cette fonction U est bien récursive partielle). Donc il existe un numéro n avec g = ϕn et le
théorème de “s-n-m” garantie que g(x, y) = ϕs(n,x) (y). On a donc obtenu une fonction récursive
totale h(x) = s(n, x) telle que g(x, y) = ϕh(x) (y).
Maintenant, pour montrer que K(x) ⇔ B(h(x)) nous considérons les deux cas possibles :
– Si K(x), alors ϕx (x) ↓ et alors ϕh(x) (y) = g(x, y) = 10 pour tout y, et en particulier pour
y = 3. Donc ϕh(x) (3) = 10 ce qui implique que B(h(x)).
– Si ¬K(x), alors la fonction ϕh(x) est définie nulle part et ϕh(x) (3) ↑. Donc ¬B(h(x)).
Nous venons de prouver que K ≤m B par h, d’où suit l’indécidabilité de B.
La même méthode permet d’établir un résultat d’indécidabilité très général
29
Théorème 10 (Théorème de Rice) Soit C une classe non-triviale de fonctions récursives par-
△
tielles. Alors, le prédicat BC (x) = ϕx ∈ C est indécidable.
“C non-trivial” veut dire que C = 6 ∅ et C = 6 ∅. Par exemple, pour C = {f | f (3) = 10}, nous avons
BC (x) ⇔ ϕx (3) = 10}.
Démonstration. Soit ⊥ une fonction telle que ⊥(x) ↑ pour tout x.
– Premier cas : ⊥ ∈ C. Soit v une fonction récursive partielle telle que v 6∈ C (par l’hypothèse
de non-trivialité elle existe), définissons :

v(y) si ϕx (x) ↓,
g(x, y) =
↑ si ϕx (x) ↑,
△
La fonction g peut être écrite comme g(x, y) = ϕ(x, x)·0+v(y) et est donc récursive partielle,
soit b son numéro. Par le théorème de paramétrisation s − m − n, ϕb (x, y) = ϕs(b,x) (y). Soit
h(x) = s(b, x), qui est récursive totale.
Soit x une valeur arbitraire, alors soit x ∈ K soit x 6∈ K. Pour le cas où x ∈ K, nous avons :
ϕh(x) (y) = v(y). En conséquence, ϕh(x) = v. En plus, par hypothèse, v 6∈ C, donc ϕh(x) 6∈ C.
Nous en déduisons que h(x) 6∈ BC . Pour le cas où x 6∈ K, nous avons que
ϕh(x) (y) ↑ ⇒ ϕh(x) (y) = ⊥ ⇒ ϕh(x) ∈ C.
Donc h(x) ∈ BC . Ceci montre que K ≤m BC . Puisque K est indécidable, alors BC est
indécidable et, par la fermeture booléenne, BC l’est aussi. ⋄
– Deuxième cas : ⊥ 6∈ C. La preuve est similaire à celle du premier cas. Soit w ∈ C (elle existe
par l’hypothèse de non-trivialité), définissons :

w(y) si ϕx (x) ↓,
g(x, y) =
↑ si ϕx (x) ↑,
△
Nous avons donc que la fonction g(x, y) = ϕ(x, x).0 + w(y) est récursive partielle, et soit a
son numéro. Par le théorème s − m − n, nous avons ϕb (x, y) = ϕs(a,x) (y). Soit h(x) = s(a, x),
qui est récursive totale.
Si x ∈ K nous avons :
ϕx (x) ↓⇒ g(x, y) = w(y) ⇒ ϕh(x) (y) = w(y).
Donc ϕh(x) = w et ϕh(x) ∈ C. Nous avons donc h(x) ∈ BC . Pour le cas où x 6∈ K nous avons :
ϕx (y) ↑⇒ ϕh(x) (y) ↑⇒ ϕh(x) = ⊥ ⇒ ϕh(x) 6∈ C.
Donc, K ≤m BC et BC est indécidable.
Remarque. En termes usuels le théorème de Rice signifie que toutes les propriétés de fonctions
calculables par MT sont indécidables.
Par exemple toutes les propriétés ci-dessous le sont
1. {x | Dom(ϕx ) est infini}
2. {x | ϕx est totale}
3. {x | ϕx (20) ↓}
4. {x | ∀y : ϕx (y) = 3y 2 + 5y + 2}
5. {x | 3 ∈ Im(ϕx )} = {x | ∃y ϕx (y) = 3}
Les propriétés décidables des MT font toujours référence à la structure ou au fonctionnement
des MT, et pas uniquement aux aspects fonctionnels, par exemple :
1. {x | ϕx (3) s’arrête avant 1000 pas}
2. {x | la machine de Turing numéro x a un nombre pair d’instructions}
30
2.4 Semi-décidabilité
Dans l’introduction nous avons discuté informellement les notions de semi-algorithme et d’un
problème semi-décidable. Dans cette partie nous ferons une étude technique de ces concepts. Nous
examinons d’abords quelques exemples.
Exemples
△
– Arret(x, y) = ϕx (y) ↓. Nous avons prouvé que Arret(x, y) est indécidable, mais il existe
un semi-algorithme suivant : lancer la machine x sur l’entrée y, et si la machine s’arrête,
renvoyer “OUI”.
△
– K(x) = ϕx (x) ↓. Pour ce problème indécidable il existe un semi-algorithme suivant : lancer
la machine x sur l’entrée x, et si la machine s’arrête, renvoyer “OUI”.
△
– P (x) = ϕx (3) = 10. De même, nous avons prouvé que P (x) est indécidable, et un semi-
algorithme pour décider P (x) est : lancer la machine x sur l’entrée 3 ; si la machine s’arrête
et le résultat est 10, répondre “OUI”.
△
– Q(x) = (Dom(ϕx ) est infini). Il n’y a pas de semi-algorithme 3 et la raison intuitive est que
l’on ne peut pas tester si une machine s’arrête sur un nombre infini d’entrées.
Définition 18 L’ensemble P (comme avant P ⊆ Nk ) est semi-décidable s’il existe une fonction
récursive partielle g telle que P = Dom(g), c’est-à-dire x ∈ P ⇔ g(x) ↓. Autrement dit, g
“s’arrête” sur tous les x dans P et “boucle” sur tous les x 6∈ P .
Définition 19 La fonction semi-caractéristique de P est :

1 si x ∈ P ,
ψP (x) =
↑ si x 6∈ P .
Proposition 9 Un prédicat P est semi-décidable si et seulement si sa fonction semi-caractéristique

est récursive partielle.
Démonstration. Pour ⇐, supposons que ψP est récursive partielle. Alors, P = Dom(ψP ) et P est
le domaine d’une fonction récursive partielle. Par définition, P est semi-décidable.
Pour ⇒, supposons que P est semi-décidable. Donc, P = Dom(g) où g est récursive partielle.
Nous avons :
g(x) ↓ ⇔ x ∈ P.
Soit
1 si x ∈ P ,
ψP (x) =
↑ si x 6∈ P .

1 si g(x) ↓,
ψP (x) =
↑ si g(x) ↑.
Nous montrons que ψP est récursive partielle en écrivant ψP (x) = g(x) · 0 + 1
Proposition 10 Si un prédicat P est décidable, alors il est semi-décidable.
Un algorithme pour semi-décider P peut être comme suit : si x ∈ P retourner “OUI”,

sinon boucler.
La démonstration ci-dessous formalise se raisonnement
Démonstration. Puisque P est décidable, alors sa fonction caractéristique

1 si x ∈ P
χP (x) =
0 si x 6∈ P
3 Prouver ceci est un exercice !
31
est récursive totale. La fonction semi-caractéristique de P est :

1 si χP (x) = 1,
ψP (x) =
↑ si χP (x) = 0.
Nous allons maintenant prouver que ψP est récursive partielle. En fait, on peut écrire ψP sous
forme : ψP (x) = w(χ(x)) où la fonction

1 si y = 1,
w(y) =
↑ si y = 0.
peut être exprimée comme : w(y) = µz.(z · y = 1). Alors, v est récursive partielle, et en plus χP
est récursive totale, nous en déduisons que ψP l’est aussi.
Forme normale
Proposition 11 Chaque ensemble semi-décidable P peut-être représenté comme suit :
P (x) ⇔ ∃t R(x, t)
où R est un prédicat récursif primitif.
L’idée derrière cette proposition est que R(t, x) vérifie est-ce que le semi-algorithme pour P sur
l’entrée x s’arrête après t pas avec le résultat “OUI”.
Démonstration. D’après le théorème de la forme normale pour les fonctions récursives partielles,
la fonction g(x) telle que P = Dom(g) peut être représentée comme g(x) = h(x, µ t.R(x, t)) où h
et R sont récursives primitives. Alors,
x ∈ P ⇔ g(x) ↓ ⇔ h(x, µ t.R(x, t)) ↓ ⇔ µt.R(x, t) ↓ ⇔ ∃t R(x, t).
En effet, nous venons de montrer que x ∈ P ⇔ ∃t R(x, t).
2.5 Ensembles récursivement énumérables (r.e.)

Dans cette section nous donnons une caractérisation complètement différente de la semi-
décidabilité.
Définition 20 P est récursivement énumérable si et seulement s’il existe une fonction récursive
totale h telle que P = Im(h) ou bien si P = ∅, c’est-à-dire, P = {h(0), h(1), . . . , h(i), . . .} (ou P
est vide). On dit que h énumère P .
Intuitivement, P est récursivement énumérable si et seulement s’il y a un algorithme qui imprime
la liste de tous les éléments de l’ensemble.
Interprétation
– Semi-décidabilité = acceptation par une MT.
– Récursivement énumérable = génération par une MT.
Dans d’autres cours vous avez vu plusieurs résultats qui relient l’acceptation avec la génération,
par exemple
Acceptation par machine à pile ⇔ Génération par grammaire hors contexte
Nous allons prouver un résultat important du même type pour les MT.
Théorème 11 Semi-décidable ⇔ récursivement énumérable.
32
Démonstration. (⇐) Soit P un prédicat récursivement énumérable. On veut montrer que P est
semi-décidable.
Voici un semi-algorithme pour semi-décider si x ∈ P .
i=0
while (h(i) 6= x) {
i++
}
return “OUI”
Il faut noter que h est totale, c-à-d elle est définie partout. Donc, le test h(i) 6= x donne
toujours un résultat.
Formellement, si P = ∅, il est clair qu’il est semi-décidable. Si P 6= ∅, alors P = Im(h) =
△
{h(0), h(1), . . . , h(i), . . .} où h est récursive totale. Puis, nous définissons une fonction f (x) =
µi.h(i) = x. Nous avons
x ∈ P ⇔ ∃i h(i) = x ⇔ µ i.h(i) = x ↓⇔ f (x) ↓ .
Donc, P = Dom(f ). Comme f est récursive partielle, P est semi-décidable.

(⇒)Maintenant, supposons que P est semi-décidable, alors P = Dom(g) où g est récursive
partielle. On suppose que P est non-vide (l’autre cas est trivial) et on cherche à énumérer P . Par
le théorème de la forme normale,
P = {x | ∃tR(x, t)}
où R est récursive primitive. Essentiellement, nous allons générer P pour chaque (x, t) comme
suit : si R(x, t) alors on peut générer x, sinon on génère a où a est un élément fixe de P . Plus
concrètement, soit A = 2x · 3t , définissons une fonction h pour énumérer P comme suit :

ex2(A) si R(ex2(A), ex3(A)),
h(A) =
a sinon.
Un programme pour calculer h(A) est le suivant.

fonction h(A)
x ← ex2(A)
t ← ex3(A)
if (h(x) converge en t pas) then return x
else return a
Il suffit ensuite de prouver que P = Im(h) (notons que h est récursive totale). Pour cela, nous
allons prouver que x ∈ P ⇔ x ∈ Im(h).
Effectivement, soit x ∈ P . Alors ∃t R(x, t). Puis, pour A = 2x · 3t nous avons h(A) = x, et
donc x ∈ Im(h).
Soit maintenant x un élément de Im(h). Alors x = h(A) pour un certain A. Nous avons ensuite
deux cas : x = a et x 6= a. Si x = a, il est clair que x ∈ P . Si x 6= a, alors pour t = ex3(A), nous
avons que R(x, t) est vrai. Autrement dit, ∃t R(x, t), ce qui implique que x ∈ P .
Le résultat suivant relie la décidabilité avec la semi-décidabilité (et explique le dernier terme).
Théorème 12 (Théorème de Post) Un prédicat P est décidable ssi P est semi-décidable et P

est semi-décidable.
L’intuition derrière ce théorème est que si l’on sait dire “OUI” quand x est dans P aussi bien que
dire “NON” quand x n’est pas dans P , alors on sait décider si x ∈ P .
Démonstration. Supposons que P est décidable. Nous allons prouver que P et P sont semi-
décidables. Le fait que P est décidable implique (en vigueur de la Proposition 10) que P est
semi-décidable. D’autre part, si P est décidable, alors P est décidable (par fermeture) et donc P
est semi-décidable.
33
Inversement, étant donné que P est semi-décidable et P est semi-décidable, il faut prouver
que P est décidable. Comme P et P sont récursivement énumérables, nous avons P = Im(f ) et
P = Im(h) avec f et h récursives totales, c’est-à-dire,
P = {f (0), f (1), . . .}
P = {h(0), h(1), . . .}
Pour décider si x ∈ P , on peut utiliser l’algorithme suivant (qui converge toujours) :

repeat {
i←0
if f (i) = x then return “OUI”
if h(i) = x then return “NON”
i++
}
Plus formellement, nous définissons
△
u(x) = µi.(f (i) = x ∨ h(i) = x)
Il est clair que u est récursive totale puisque soit x ∈ P = Im(f ) soit x ∈ P = Im(g). La fonction

1 si f (u(x)) = x,
χP (x) =
0 sinon.
est récursive totale, et P est donc décidable.
Théorème 13 Propriétés de fermeture des ensembles récursivement énumérables

1. Si les prédicats P et Q sont récursivement énumérables, alors les prédicats P ∧ Q et P ∨ Q
sont récursivement énumérables.
2. Pour certains prédicats récursivement énumérable P leur négation ¬P n’est pas récursivement
énumérable.
3. Si P (x, y) est r.e., alors le prédicat (avec quantification existentielle non-bornée) ∃y P (x, y)
est aussi récursivement énumérable.
Démonstration.
1. (∧) Supposons que P et Q sont récursivement énumérables. Donc ils sont semi-décidables,
et il existe deux fonctions récursives partielles f et g telles que P (x) ⇔ f (x) ↓ et
Q(x) ⇔ g(x) ↓, d’où nous déduisons que P (x) ∧ Q(x) ⇔ (f (x) + g(x)) ↓. Nous avons
établi que P ∧ Q est le domaine d’une fonction récursive partielle f + g, donc il est
semi-décidable. ⋄
(∨) Supposons que P et Q sont récursivement énumérables et non-vides. Donc P = Im(v)
et Q = Im(w) pour deux fonctions récursives totales v et w. La façon la plus simple
pour énumérer P ∨ Q est la suivante :
v(0), w(0), v(1), w(1), v(2), w(2), . . .
Formellement, P ∨ Q = Im(h) avec

v(n div 2) si n est pair
h(n) =
w(n div 2) si n est impair
⋄
2. Le prédicat K est semi-décidable parce que K(x) ⇔ ϕx (x) ↓⇔ U (x, x) ↓ et donc K =
Dom(f ) avec f (x) = U (x, x) - une fonction récursive partielle. Si son complément K était
aussi semi-décidable, alors K serait décidable par théorème de Post. Or, c’est impossible.
Donc K est semi-décidable, et son complément non. ⋄
34
3. Supposons que P (x, y) est semi-décidable et que Q(x) ≡ ∃y P (x, y). Par théorème de forme
normale P (x, y) ⇔ ∃t R(x, y, t) (avec R récursif primitif), d’où
Q(x) ⇔ ∃y∃t R(x, y, t) ⇔ ∃A R(x, ex2(A), ex3(A)) ⇔ (µA.R(x, ex2(A), ex3(A))) ↓⇔ f (x) ↓
avec f (x) = µA.R(x, ex2(A), ex3(A)) récursive partielle. Nous avons représenté Q comme
domaine d’une fonction récursive partielle f , par conséquent Q est semi-décidable.
Dans la pratique la preuve de semi-décidabilité peut se faire en utilisant les propriétés de
fermeture ci-dessus et la semi-décidabilité de certains prédicats.
Proposition 12 (Quelques prédicats r.e. utiles) Les prédicats suivants sont r.e. :
– tous les prédicats décidables ;
– le prédicat Resultat défini comme suit :
Resultat(x, y, z) ⇔ (ϕx (y) = z)
– Arret ;
Démonstration : Tous les prédicats décidables sont r.e. selon la proposition 10.
La fonction semi-caractéristique de Resultat peut s’écrire comme
ψResultat (x, y, z) = ψ= (U (x, y), z),
donc elle est récursive partielle, d’où suit la semi-décidabilité de Resultat.

Finalement Arret(x, y) ⇔ U (x, y) ↓, donc Arret = Dom(U ) est aussi semi-décidable.
Exemple Nous utiliserons les deux dernières propositions pour prouver la semi-décidabilité du
prédicat suivant
S(x) ≡ Dom(ϕx ) contient au moins deux nombre premiers
Effectivement, s admet la représentation suivante :

S(x) ≡ ∃y1 ∃y2 EstP remier(y1 ) ∧ EstP remier(y2 ) ∧ y1 6= y2 ∧ Arret(x, y1 ) ∧ Arret(y2 )
qui utilise uniquement des prédicats semi-décidables et des opérations préservant la semi-décidabilité.
⋄
2.6 Semi-décidabilité vs. réduction

Cette section n’a pas été présentée dans les cours de cette année 2003.
Proposition 13 Si A ≤m B et B est semi-décidable (r.e.), alors A est semi-décidable.
Démonstration. Supposons que A ≤m B pour h récursive totale, c’est-à-dire
x ∈ A ⇔ h(x) ∈ B. (2.1)
D’autre part, comme B est semi-décidable, B = Dom(f ) où f est récursive partielle. Alors, en
combinant avec (2.1), nous avons
x ∈ A ⇔ h(x) ∈ B ⇔ h(x) ∈ Dom(f ) ⇔ f (h(x)) ↓
En conséquence, A = Dom(f ◦ h) et A est alors semi-décidable.
Corollaire 3 Si A ≤m B et B est non-semi-décidable, alors A est non-semi-décidable.
35
Théorème 14 Soit T = {x | ϕx est totale} 4 . Alors,
1. T n’est pas récursivement énumérable.
2. T n’est pas co-récursivement énumérable (c’est-à-dire T n’est pas r.e.)
Démonstration. Nous allons d’abord prouver (1) par contradiction. Supposons que T est récursivement
énumérable. Alors,
T = g(0), g(1), g(2), . . .
où g est récursive totale. Puis,
ϕg(0) , ϕg(1) , ϕg(2) , . . . (2.2)
est la liste de toutes les fonctions récursives totales. Soit
d(x) = ϕg(x) (x) + 1 (2.3)

= U (g(x), x) + 1.
Notons que d(x) est récursive partielle. Puisque ϕg(x) est totale, alors ∀x ϕg(x) ↓ et nous avons
donc ∀x d(x) ↓. Autrement dit, d(x) est en effet récursive totale et W est dans la liste (2.2), c-à-d
∃c d = ϕg(c) . D’où, d(c) = ϕg(c) (c). D’autre part, par définition (2.3), d(c) = ϕg(c) (c) + 1. Alors,
d(c) = d(c) + 1, une contradiction. Par conséquent, T n’est pas récursivement énumérable.
Pour prouver (2), c’est-à-dire T n’est pas récursivement énumérable, il suffit de faire la réduction
K ≤m T (voir les exercices ci-dessous).
2.7 Exercices – analyse de décidabilité de problèmes

Faire l’analyse de décidabilité des prédicats P suivants :
1. P (x) ≡ ∀y.ϕx (y) = y 2 ; déduire qu’il y a une infinité de MT qui calculent la fonction y 2
2. P (x) ≡ 10 ∈ Im(ϕx ) ;
3. P (x) ≡ Dom(ϕx ) est infinie ;
4. P (x) ≡ ϕx est totale ;
5. P (x) ≡ ϕx (3) ↓ ;
6. P (x) ≡ ϕx (x) = x (Examen 2000) ;
7. P (x) ≡ K(x) ≡ ϕx (x) ↑ ;
Plan de l’analyse :
1. Définir P en français.
2. Est-ce que P est récursivement énumérable (r.e.) ?
3. Est-ce que P est décidable (récursif) ?
4. (Question subsidiaire) est-ce que P est r.e. ?
4T correspond à l’ensemble de tous les programmes qui ne bouclent pas.
36
Chapitre 3
Applications de la calculabilité
dans l’informatique
3.1 Problèmes de vérification

Nous nous intéressons au problème très pratique de vérification de programmes, qui a souvent
la forme suivant : étant donné un programme P (avec un modèle de calcul M C) et une propriété
Q (spécification), est-ce que P satisfait Q ?
Nous allons dans la suite étudier la décidabilité et l’indécidabilité de quelques problèmes de ce
type. Il est important de noter que l’on peut parler de la décidabilité ou l’indécidabilité d’une classe
de problèmes et pas seulement d’une instance de problème. Nous allons considérer de différents
modèles de calculs (avec mémoire finie et infinie, sans ou avec entrées).
3.1.1 Machines de Turing

Les machines de Turing sont un modèle de calcul avec mémoire infinie. Soit M la machine de
Turing (qu’on peut représenter par son numéro de Gödel x) que l’on veut vérifier. Nous mention-
nons dans la suite quelques problèmes décidables et indécidables (certains résultats ci-dessous sont
triviaux, certains ont été établis dans le Chapitre 2, les autres peuvent être établis facilement en
utilisant les mêmes techniques).
– Problèmes décidables (et même récursifs primitifs) :
– Si Q est une propriété syntaxique (par exemple, “est-ce que la machine M a plus que 2002
états”, ou moins que 2003 instructions, ou aucune instruction du type “aller à gauche ?”,
etc.)
– Si Q est une propriété de complexité bornée (par exemple, “est-ce que la machine M
s’arrête sur l’entrée y avant t pas avec le résultat z ?”).
– Problèmes indécidables :
– Est-ce que la machine M s’arrête sur y ? (ce problème est r.e.).
– Est-ce que la machine M s’arrête au moins sur une entrée ? (r.e.).
– Est-ce que la machine M s’arrête sur chaque entrée ? (ce problème n’est pas r.e.).
– Est-ce que la machine M calcule la fonction f (y) = y ? (ce problème n’est pas r.e. non
plus).
– ...
3.1.2 Automate fini

Un automate fini est un modèle de calcul avec mémoire finie, qui peut être vu comme un
programme sans variables. Grosso modo tous les problèmes concernant les automates finis sont
décidables, par exemple :
37
– L’automate A a 156 états.
– A accepte y (y appartient au langage régulier accepté par A).
– L(A) 6= ∅ (A accepte au moins une entrée).
– L(A) = Σ∗ (A accepte toutes les entrées).
– L(A) = (a + b)∗ bba.
– L(A) = L(B).
Les algorithme de décision pour ces problèmes ont été vus dans le cours d’Automates et Langages.
3.1.3 Machine à pile

Machine à pile est un modèle de calcul avec mémoire infinie et une entrée. Rappelons qu’elle
est composée d’un automate fini et une pile. Les opérations sur une telle machine sont : empiler,
dépiler, sommet de la pile, etc. Un programme sur une machine à pile peut avoir des instructions
de la forme “if .. then .. else ”, par exemple :
q0 : empiler(0) ; goto q1
q1 : empiler(1) ; goto q2
q2 : dépiler ; goto q3
q3 : if (sommet=1) goto q4 else goto q0
q4 : lire(a) ; if (a = 1) goto q4 else goto q0
Exemples des problèmes décidables et indécidables concernant les machines à pile sont :
– Problèmes décidables (algorithmes vus en cours d’Analyse Syntaxique) :
– Machine à pile A a 156 états.
– A accepte y (y est dans le langage hors-contexte).
– L(A) 6= ∅.
– Problèmes indécidables (indécidabilité admise sans preuve) :
– L(A) = Σ∗ .
– L(A) ∩ L(B) 6= ∅.
3.1.4 Machine à deux piles

Dans cette sections nous démontrons l’indécidabilité du problème d’arrêt pour les machines à
2 piles sans entrée. Ce résultat lui-même n’est pas très intéressant mais il permet d’illustrer une
technique de preuve d’indécidabilité extrêmement utile : celle de la réduction par simulation. Pour
simplifier la simulation nous supposons que le sommet de la pile vide est 0, et qu’on peut dépiler
de la pile vide (elle reste vide).
Théorème 15 Le problème de l’arrêt est indécidable pour les machines à 2 piles.
Démonstration. L’idée essentielle est de construire pour chaque machine de Turing T une machine
à 2 piles B = B(T ) qui simule T , c’est-à-dire B a le même comportement que T . En conséquence,
T s’arrête si et seulement si B(T ) s’arrête. Nous allons prouver que Arret (pour la machine de
Turing) ≤m Arret (pour la machine à 2 piles) et donc le problème de l’arrêt pour les machines à
2 piles est indécidable.
La méthode de réduction par simulation a 3 étapes :
Représenter chaque configuration de T par une configuration de B : la configuration sui-
vante de T
. . . | a−2 | a−1 | a0 | a1 | a2 | . . .
△
q
38
est représentée par l’état q de la machine B et par les piles suivantes :
| a−1 | | a0 |
| −−− | | −−− |
| a−2 | | a1 |
| −−− | | −−− |
| a−3 | | a2 |
| −−− | | −−− |
| ... | | ... |
Pile 1 Pile 2
Programmer (sur la machine B) chaque instruction de T :

Instructions de T Instructions de B
qc → qc′ q : if sommet(P2 ) = c goto q1
q1 : dépiler(P2 ) ; goto q2
q2 : empiler(P2 , c′ ) ; goto q ′
′ ′
qc → q c D q : if sommet(P2 ) = c goto q1
q1 : dépiler(P2 ) ; goto q2
q2 : empiler(P1 , c′ ) ; goto q ′
′ ′
qc → q c G Exercice
En appliquant cette traduction à chaque instruction de la machine de Turing T on obtient
un programme B(T ) pour une machine à 2 piles. Ce programme fait la même chose que T
en utilisant une autre structure de données (2 piles au lieu d’un ruban)
Analyser l’initialisation/arrêt : On voit facilement que la machine de Turing T s’arrête sur
l’entrée x si et seulement si la machine à 2 piles s’arrête en démarrant de P1 = ǫ et P2 = 01x .
On a donc réduit le problème de l’arrêt pour les MT au problème de l’arrêt pour les machines
à 2 piles. Comme le premier problème est indécidable, le second l’est également.
Une conséquence intéressante de cette démonstration est que les machines à 2 piles peuvent
calculer toutes les fonctions récursives partielles.
3.1.5 Exercice – Machine à compteurs

Nous représentons l’étude de ce modèle de calcul sous la forme d’une série d’exercices
Définition informelle. Une machine à n compteurs (MàCn) a plusieurs registres x1 , x2 ,. . ., xn
chacun capable de stocker un nombre naturel.
un programme - c’est un ensemble d’instructions de types suivants :
1. q : x + + ; goto p
2. q : x − − ; goto p
3. q :if x = 0 then goto p else goto r
4. q : stop
La tentative de calculer 0 − − produit une erreur. La configuration de la MàCn est le n + 1-
uplet (q, x1 , x2 , . . . , xn ) qui représente l’étiquette de l’instruction courante et le contenu de tous les
compteurs. On suppose que pour l’entrée x la machine démarre dans la configuration (init, x, 0, . . . , 0)
où “init” est une instruction particulière, et qu’elle calcule jusqu’à un stop . Le résultat de ce calcul
est le contenu du registre x1 après l’arrêt.
Le but de ce TD consiste à prouver l’indécidabilité du problème d’arrêt pour les machines à 4

compteurs (et équivalence des MàC4 aux MT)
1. Programmer une machine à 2 compteurs (MàC2) qui calcule f (x) = x mod 2.
2. Simuler une pile (pour simplicité sur {0, 1} ) par 2 compteurs :
– Comment représenter le contenu de pile a0 a1 a2 . . . par des valeurs de x1 et x2 ?
39
– Quelle transformation de x1 , x2 correspond a l’opération Empiler(0) ? Programmer cette trans-
formation sur la MàC.
– Même question pour Empiler(1)
– Même question pour Dépiler ;
– Même question pour if Sommet=0 then goto p else goto r
3. Simuler 2 piles sur 4 compteurs
4. Prouver qu’une MàC4 peut calculer chaque fonction récursive partielle
5. Prouver que le problème d’arrêt est indécidable pour les MàC4
6. Prouver que le problème d’arrêt est indécidable pour les MàC2
7. Prouver que le problème d’arrêt est décidable pour les MàC1
Nous retenons le résultat principal
Théorème 16 Les machines à 2 compteurs peuvent simuler les machines de Turing. Alors, le
problème de l’arrêt est indécidable pour les machines à 2 compteurs.
3.1.6 Problèmes pratiques

En pratique, on s’intéresse à vérifier des programmes C (ou Pascal, ou Lustre). Par exemple
nous voulons savoir si un programme s’arrête sur une entrée x, ou s’il s’arrête toujours, ou s’il
calcule f (x) = x!. La décidabilité dépend en général du modèle de calcul.
– (a) Pour le cas d’un ordinateur avec mémoire finie (bornée), on peut le considérer comme un
automate fini (dont le nombre d’états est souvent très grand) et en théorie tous les problèmes
de vérification d’automates finis sont décidables. Pourtant la taille de l’automate peut rendre
l’application des méthodes pour les automates finis aux programmes infaisable en pratique.
– (b) Si l’on permet des variables non-bornées, alors le modèle de l’ordinateur peut simuler une
machine à compteurs, et tous les problèmes qui sont décidables pour le cas (a) deviennent
indécidables.
– (c) Si le modèle de calcul a un nombre non-borné de variables (registres, cellules de mémoire),
alors tous les problèmes précédents sont aussi indécidables.
En général, la plupart de problèmes de vérification de programmes sont indécidables. Parmi les
directions de recherche actuellement poursuivies mentionnons :
– Chercher de bonnes classes de programmes pour lesquels le problème de vérification est
décidable.
– Trouver de méthodes de “Bonne programmation”, qui consiste à accompagner chaque pro-
gramme par une preuve de correction.
– Utiliser des semi-algorithmes.
3.2 Problèmes indécidables dans la théorie de langages

3.2.1 Problèmes relatives aux langages hors contexte
Ici on énumère sans preuve quelques résultats concernant les grammaires hors contexte. Ce
n’est pas par hasard que ces résultats ressemblent à ceux de la section 3.1.3.
On utilise les notations G et H pour des grammaires hors contexte(sur un alphabet Σ), L(G)
et L(H) pour leurs langages engendrés, w pour un mot sur Σ.
– Problèmes décidables :
– Problème de mot : est-ce que w ∈ L(G) ?
– Problème de langage vide : est-ce que L(G) = ∅ ?
– Problèmes indécidables (indécidabilité admise sans preuve) :
– Problème de langage universel : est-ce que L(G) = Σ∗ ?
– L(G) ∩ L(H) = ∅ ?
– Problème d’équivalence : est-ce que L(G) = L(H) ?
40
3.2.2 Systèmes de réécriture
Dans cette section nous étudions un type de grammaires très général.
Soit Σ un alphabet fini. Un système de réécriture sur l’alphabet Σ est un ensemble fini Π de
règles de la forme v → w (où v et w sont des mots sur l’alphabet Σ). On dit qu’un mot B est
dérivable de A s’il peut être obtenu en appliquant plusieurs fois les règles de Π à des sous-mots
∗
(notation : A → B).
Le but de cette section consiste à étudier la décidabilité du problème Dérivable(Π, A, B) :
∗
“Est-ce que A → B dans Π” .
Par exemple A et B sont des génomes de deux cellules, les règles v → w représentent
des mutations possibles, et on veut décider si B peut être un descendant de A
Exemple : deux instances du problème. Soit R1 = ab → ba et R2 = a → aa.

∗ R1 R2 R2
– Est-ce que aab → aaaba ? La dérivation aab → aba → aaba → aaaba montre que aaaba
est dérivable de aab.
∗
– Est-ce que aba → ababa ? On peut remarquer, que l’application de règles R1 et R2 préserve
le nombre de b dans le mot. Comme aba contient un seul b, tandis que ababa en contient
deux, la dérivation est impossible.
Simulation. On veut prouver l’indécidabilité du problème Dérivable(Π, A, B) en y réduisant le

problème de l’arrêt pour les machines à 2 compteurs.
Pour une Mà2C M on construira un système de réécriture Π(M ) qui simule cette machine. On
représentera la configuration c = (q, x, y) par le mot b c = $1x q1y $.
On représentera dans une table tous les types d’instructions de la Mà2C, comment ces instruc-
tions modifient la configuration c, comment doit ce transformer le mot b c et quelles sont les règles
qui assurent une telle transformation
in c → c′ c → cb′
b b
in
x y x+1 y
q : x + + ; goto p (q, x, y) → (p, x + 1, y) $1 q1 $ → $1 p1 $ q → 1p
q : x − − ; goto p (q, x, y) → (p, x − 1, y) $1x q1y $ → $1x−1 p1y $ 1q → p
q :if x = 0 then p (q, 0, y) → (p, 0, y) $q1y $ → $p1y $ $q → $p
else r (q, x + 1, y) → (r, x + 1, y) $1x+1 q1y $ → $1x+1 r1y $ 1q → 1r
∗
q : stop (q, x, y) → $1x q1y $ → ε 1q → q, q1 → q,
$q$ → ε
(les règles concernant y sont symétriques à celles pour x et on s’est permis de les omettre).
L’algorithme de construction du système de réécriture Π(M ) est donc le suivant : pour chaque
instruction in de la machine M prendre la règle (ou les règles) de in b (quatrième colonne), et les
mettre tous ensemble. Ça donne un ensemble fini de règles de réécriture.
On va maintenant prouver que le système de réécriture Π(M ) simule la machine M .
Soit c = (q, x, y) une configuration de M et b c = $1x q1y $ le mot qui la représente. Soit in
l’instruction étiquetée par q dans M.
Lemme 6 (simulation d’un pas de calcul) Si c n’est pas une configuration de l’arrêt, alors
in b
in
c → cb′ dans Π(M ).
c → c′ dans M si et seulement si b
Démonstration :
On voit tout de suite de la table ci-dessus, que si in 6= stop , alors une seule règle de Π(M )
s’applique à b b Si in = if - c’est la “bonne” règle des deux
c : si in = ++, c’est la seule règle de in.
b
de in. Dans tous les cas on voit que cette règle fait la même transformation que in. 2
∗
c → ε dans Π(M ).
Lemme 7 (simulation de stop) Si c est une configuration de l’arrêt , alors b
Démonstration : Si c est une configuration de l’arrêt, c-à-d in = stop , alors on peut appliquer
b pour supprimer d’abord tous les 1, et à la fin supprimer le $q$.
les règles de in 2
41
Lemme 8 (correction) M possède un calcul qui mène à l’arrêt à partir d’une configuration c si
∗
c → ε dans Π(M )
et seulement si b
Démonstration : Supposons que M s’arrête à partir de la configuration c. Soit c′ la dernière

configuration de ce calcul (c’est forcément une configuration de l’arrêt). Alors en appliquant le
∗
lemme 7 pour chaque pas de calcul on obtient une dérivation b c → cb′ dans Π(M ). En appliquant
∗
la propriété B pour la configuration de l’arrêt c′ , on obtient que cb′ → ε. En concaténant ces deux
∗
dérivations ensemble on obtient que b c → ε.
Supposons maintenant que M ne s’arrête pas à partir de la configuration c. Dans ce cas-là le
calcul de M est soit infini, soit mène à une erreur (0 − −), mais jamais dans un état de l’arrêt. La
propriété A nous garantit que les réécritures de Π(M ) à partir du mot b c ne mènent jamais à un
mot qui contient l’étiquette q ′ d’une instruction stop . Donc on ne pourra jamais utiliser la règle
∗
$q ′ $ → ε - la seule qui permet d’obtenir le mot vide. On a prouvé donc que b c 6→ ε. 2
∗
En particulier, Arrêt2C(M,x) si et seulement si $1x init$ → ε, c’est à dire, si et seulement si
Dérivable(Π(M ), $1x init$, ε). Donc on a réduit Arrêt2C à Dérivable (on a montré que Arrêt2C≤m
Dérivable ). Comme Arrêt2C est indécidable, Dérivable est aussi indécidable.
42
Bibliographie
[1] Pierre Wolper. Introduction à la calculabilité : Cours et exercices corrigés, 2e édition, Dunod,
2001,
[2] H. Rogers. Theory of Recursive Functions and Effective Computability, MIT Press, 1987.
[3] Ch. Boitet. Récursivité, calculabilité, application à la théorie des langages : notes de cours -
Grenoble : Université scientifique et médicale, 1983,1987...
43

Calcul Cours PDF

Transféré par

Droits d'auteur :

Formats disponibles

Calcul Cours PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Calcul Cours PDF

Transféré par

Droits d'auteur :

Formats disponibles

Calculabilité

0.1 Quelques exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

0.1 Quelques exemples

Problème de terminaison du programme “3x + 1” Est-ce que le programme ci-dessous

Problème de terminaison de programme C’est une généralisation du problème précédent.

Problème de logique 1. Est-ce qu’une formule propositionnelle F donnée (telle que F = p ⇒

Problème de langages 2. Pour une grammaire hors-contexte Γ et un mot w, est-ce que w ∈

Problème de langages 3. Pour deux grammaires hors-contexte Γ1 et Γ2 , est-ce que L(Γ1 ) =

U = { toutes les formules propositionnelles }

Il est clair qu’un problème décidable est aussi semi-décidable. ⋄

0.3 Calculabilité vs Complexité

Définitions formelles de la notion

Définition 3 Le problème (U, B) est décidable si et seulement si χB est calculable.

1.1 Fonctions récursives primitives

1.1.1 Définition de fonctions récursives primitives

Exemple 1. Nous allons définir la fonction P lus(x, y) = x + y. D’abord,

Donc, P lus = Rec P ri(π11 , Comp(σ, π33 )). ⋄

Exemple 2. zero : λx.0 (avec un argument).

Donc, zero = Rec P ri(O, π22 ). ⋄

1.1.2 Exercices – quelques fonctions RP

5. λx.sg(x) (signe : 0 quand x est nul, 1 quand x est positif) ;

Donc h = Comp(σ, π33 ) et plus = Rec Pri(π11 , Comp(σ, π33 ))

Donc h = Comp(plus, π22 , π22 )

1.1.3 Réaliser une fonction RP en un langage “actionnel”

1.1.4 Quelques propriétés de fermeture de la classe RP

Ensuite, f peut être écrite comme

La fonction f est donc RP. ⋄

1.2 Les prédicats RP

Exemple 2. Le prédicat P lusGrand sur N2 est défini comme suit.

Définition 5 (Fonction caractéristique) Soit P un prédicat sur Nk . Sa fonction caractéristique

La fonction caractéristique du prédicat P air est donc

Et celle du prédicat P lusGrand

Définition 6 (Prédicat RP) Un prédicat P sur Nk est RP ssi χP est RP.

Exemple 1. La fonction caractéristique d’un prédicat P tel que P (x) ⇔ x 6= 0 est :

Proposition 2 Soient P et Q deux prédicats RP, alors P ∧ Q, P ∨ Q, ¬P et P ⇒ Q sont aussi

Par la suite, nous présentons les propriétés de la RP.

Proposition 3 (Quantification bornée) Soit P (x̄, y) un prédicat RP. Alors, ∀x ≤ n P (x̄, y)

Définition 7 (Opérateur de minimisation bornée) Soit P (n̄, m) un prédicat. Alors,

On dit que f est obtenue de P par la minimisation bornée.

Proposition 5 (Fermeture de RP par minimisation bornée) Si P est RP, et f est obtenue

Démonstration. Soit f (n̄, m) = µi≤m P (n̄, i).

1.2.1 Exercices – des fonctions RP plus compliquées

où χ| est la fonction caractéristique du prédicat “divise”.

Donc pn est récursive primitivea

(e) ex(x, y) : l’exposant de px dans la décomposition de y en facteurs premiers.

Montrer que la fonction F ib est RP.

1.3.1 Fonction d’Ackermann

Énumération La première idée est d’énumérer toutes les fonctions RP de forme N → N :

Proposition 6 La fonction Int n’est pas RP.

1.4 Fonctions récursives partielles

1.4.1 Minimisation non-bornée

Démonstration. Afin de prouver la proposition, nous montrons le programme suivant qui

1.4.2 Fonctions récursives partielles et la thèse de Church

La seule différence par rapport à la définition de la classe RP est le nouveau constructeur µ.

fonction Rec P ri(f, g)(x̄, y)

1.4.3 Exercices – fonctions récursives partielles

1.5 Machines de Turing

Définition 13 Configurations et calculs d’une machine de Turing

Exemple. Supposons que la machine M a seulement 2 instructions :