Vous êtes sur la page 1sur 27

Calculabilité

2
Chapitre 1

Administration

15h de cours réparties à parts égales entre Calculabilité et Complexité.


10h de TD de Calculabilité avec Nicolas Ollinger
10h de TD de Complexité avec Anthony Perez
Évaluation en cas de n de semestre en présentiel : Exercices (25%) Oral (37,5%) et CT (37,5%)
Sinon, DM à la place de l'oral.
Oral (n avril) : 30 minutes en groupe de 3 (ou 4 ?) pour écrire un programme de MT et le faire tourner sur le
simulateur vu en TD (10 pts), puis des questions individuelles de Calculabilité ou Complexité tirées au hasard
(10 pts)
Bibliographie sur la page celene.

3
4
Chapitre 2

Introduction, historique

Question : Dénition de l'informatique ? Deux points clés :

1. Notion de procédure eective

2. Les données sont discrètes

Proposition de dénition : Science des procédures eectives applicables à des données discrètes.

On commence par les procédures eectives.


Question : Historiquement, d'où ça sort ?

 Algos babyloniens (3000 av. J.C.) : calculs et résolutions d'équations par l'exemple (exemple : racine de 2).
 Algorithme d'Euclide (300 av. J.C.) : calcul du PGCD.
 crible d'Eratosthène (Fin du 3ème siècle av. J.C.) : énumérer les nombres premiers.
 Pascaline (1645) : machine à calculer de Pascal.
 métiers à tisser Jacquard (1801) : programmation de motifs complexes à l'aide de cartes perforées.
 Ada Lovelace (années 1840) : par exemple programme pour calculer les nombres de Bernoulli sur la machine
de Babbage.
Émergence en tant que concept plus tardive : problèmes de Hilbert au congrès de la Société des Mathématiciens
en 1900. 10ème problème : Trouver une procédure eective pour résoudre les équations diophantiennes.
Par exemple : x2 + 3x + 2 = 0 ou 3x3 y 2 + x4 + 6xy 2 + 1 = 0 (coecients entiers et solutions entières).

Idée de Hilbert (∼1928) : Tout refonder à partir de la logique et de la théorie des modèles. Pour cela, idéale-
ment, la logique doit être :
 cohérente : il n'existe pas d'énoncé démontrable dont la négation est aussi démontrable
 complète : on peut démontrer tout énoncé ou son contraire i.e. Vrai = Démontrable
 décidable : il est possible de savoir si un énoncé est vrai ou faux au moyen d'une procédure eective
Entscheidungsproblem : Entrée : un énoncé, Sortie : Vrai si l'énoncé est universellement vrai et faux sinon.
Problème : Gödel (1929-1931).
 1er théorème d'incomplétude de Gödel : si une théorie logique est assez puissante pour contenir l'arithmétique
de Peano (déf de N) alors il existe un énoncé tel que ni lui ni son contraire ne sont démontrables. La preuve
utilise un énoncé du genre "Je ne suis pas démontrable".
 2nd théorème d'incomplétude de Gödel : soit une théorie logique cohérente contenant l'arithmétique de
Peano, alors la cohérence de cette théorie ne peut être démontrée dans cette même théorie.
Reste l'Entscheidungsproblem. Attention, l'arithmétique de Peano ne peut être décrite dans la logique du
premier ordre avec un nombre ni d'axiomes (à cause du schéma d'induction), ce qui fait que le 1er théorème
d'incomplétude de Gödel ne permet pas de répondre à l'Entscheidungsproblem ! En 1936, Church (λ-calcul) et
Turing (MT) montrent indépendamment qu'il existe des énoncés indécidables. Restriction : on suppose que le λ-
calcul et les MT sont des modèles de calcul universels et que leurs programmes permettent de décrire toutes les
procédures eectives.
Thèse de Church-Turing : Tous les modèles de calcul eectifs (physiquement réalisables) sont :
 soit équivalents aux MT et au λ-calcul
 soit moins puissants, par exemple les automats nis.

5
Autres formulations :
 toute fonction mécaniquement calculable est calculable par MT
 {programmes de MT} = {algorithmes}
Hypothèse communément admise hier, aujourd'hui, demain, même avec l'IA ou l'informatique quantique !
Exemples de modèles de calcul universels : tous les langages de programmation contenant WHILE, automates
à 2 compteurs ou 2 piles, fonctions récursives de Gödel, machines RAM.
Résultat concernant l'existence d'une procédure eective résolvant les équations diophantiennes ? Matijasevic
(1970) : il n'existe pas de telle procédure.

6
Chapitre 3

Les Machines de Turing (MT)

Dans ce cours, les MT parce que :


 description simple et courte du modèle, donc manipulable pour des démonstrations.
 unicité du modèle en calculabilité et complexité.
La contrepartie : ce n'est pas un modèle de programmation très maniable !

3.1 Dénition
Mémoire : Un ruban qui est une bande bi-innie de cases, chaque case pouvant contenir une lettre d'un alphabet
ni xé.
Processeur : Une tête de lecture/calcul qui se déplace sur le ruban et peut changer le ruban en suivant une règle
xée à l'avance. Cette tête est dans un état parmi un ensemble ni.
Chaque étape de calcul consiste en :
 lecture de la case du ruban où se situe la tête
 écriture si nécessaire sur cette même case
 déplacement d'au plus une case dans une direction
La machine dispose d'un état de départ et d'un ensemble d'états terminaux. Le ruban est rempli avec un état
"blanc" B partout où il n'y a pas d'"information utile".

Dénition 3.1. Une machine de Turing est un septuplet (Q, Σ, Γ, δ, q0 , Qf , B) tel que :
 Q est l'ensemble des états, q0 ∈ Q est l'état de départ, Qf ⊆ Q est l'ensemble d'états terminaux
 Γ est l'alphabet de travail, Σ ⊆ Γ est l'alphabet d'entrée, B ∈ Γ \ Σ
 δ : (Q \ Qf ) × Γ → Q × Γ × {←, ↓, →}
Une conguration de la Machine de Turing est un triplet (q ∈ Q, c ∈ Γ , z ∈ Z) décrivant l'état de la machine.
Z

La conguration initiale pour une entrée w ∈ Σ est (q0 , BwB , 0) où w se lit à partir de la position 0 : symbole
Z Z

non B le plus à gauche. Une conguration (q, u, z) est dite terminale lorsque q ∈ Qf .

Z
On utilisera souvent la notation . pour donner la position de la tête, par exemple le ruban contient B.wB Z
dans la conguration initiale. La machine s'arrête lorsque l'état fait partie de Qf .

Dénition 3.2. Une étape de calcul de la MT se note (q, u, z) ` (q 0 , v, z + ) où δ(q, uz ) = (q 0 , vz , ) (en identiant
{←, ↓, →} avec {−1, 0, 1}).
∗ 0
On note c ` c une suite d'étapes de calcul lorsqu'il existe (c0 , c1 , . . . , ck ) des congurations telles que c = c0 ,
0
c = ck et ∀i, ci ` ci+1 .
Un calcul ni est une suite d'étapes de calcul c ` ∗ c0 avec c une conguration initiale et c0 une conguration
terminale. Un calcul inni est une suite innie de congurations (c0 , c1 , . . . ) telle que c0 est une conguration
initiale et ∀i, c0 `∗ ci .

3.2 Reconnaissance de langage


On veut utiliser une MT comme reconnaisseur de langage, on a donc besoin de xer Qf = {qa , qr }. Un calcul
commence avec l'état q0 et peut :

7
 terminer dans l'état d'acceptation qa : le mot est accepté (appartient au langage)
 terminer dans l'état de rejet qr : le mot est refusé (n'appartient pas au langage)
 ne pas terminer : le mot est refusé (n'appartient pas au langage)
Le langage de la MT M est alors déni par L(M ) = {w ∈ Σ∗ , M accepte w}. De manière équivalente, on dit
que M reconnaît L(M ).
Retour sur les exemples :
 a∗ b∗

 (ab)

 {w ∈ {a, b} , |w|a mod 2 = 0} (nombre pair de a)
On dit qu'un langage L est récursif lorsqu'il existe une MT qui s'arrête sur toute entrée et qui reconnaît L.
On dit qu'un langage L est récursivement énumérable (r.e.) lorsqu'il existe une MT qui reconnaît L.

On dit qu'un langage L est co-récursivement énumérable (co-r.e.) lorsqu'il existe une MT qui reconnaît L = Σ \ L.

Proposition 3.1. Tout langage récursif est récursivement énumérable.

a∗ b∗ , (ab)∗ et {w ∈ {a, b}∗ , |w|a mod 2 = 0} sont récursifs.

3.3 Calcul de fonction


Cette fois, on veut calculer une fonction f : X → (Γ \ B)∗ avec X ⊆ Σ∗ . Si le calcul s'arrête (état q ∈ Qf ), le
résultat se lit à partir de la tête de la machine et jusqu'au permier état B . Sinon, il n'y a pas de résultat.
Exemples :
 f1 : +1 en binaire
 f2 : remplacer les a c dans un mot.
par des
On dit qu'une fonctionf : Σ∗ → (Γ \ B)∗ est calculable lorsqu'il existe une MT M telle que M s'arrête sur

toute entrée dans w ∈ Σ avec comme résultat f (w).
∗ ∗ ∗
On dit que f : X → (Γ \ B) avec X ⊆ Σ est une fonction partielle calculable lorsque X ⊆ Σ et lorsqu'il existe
une MT M telle que M s'arrête sur toute entrée dans w ∈ X avec comme résultat f (w). Dans ce cas, M peut ne
pas s'arrêter sur d'autres entrées.
f1 et f2 sont des fonctions calculables.

3.4 Entraînement sicilien


Construire une MT qui calcule la fonction f dénie sur N comme suit :
 si n f (n) = n/2
est pair alors
 si n
est impair alors f (n) = 3n + 1
On dénit la suite de Syracuse de n ∈ N par :
 u0 = n
 ∀i ∈ N, ui+1 = f (ui )
On dénit maintenant le langage L = {n ∈ N, ∃i ∈ N, ui = 1}. Enrichir la MT précédente pour qu'elle
reconnaisse L (si n ∈
/ L, la machine ne s'arrête pas).
Question : La machine est-elle un décideur ? Autrement dit : a-t-on L = N ? Et si non, L est-il récursif ?

3.5 Variantes des MT


La plupart des variantes naturelles des machines de Turing dénissent les mêmes ensembles de langages récursifs
et récursivement énumérables. Par exemple on peut montrer (en exercice et en TD) l'équivalence avec les modèles
suivants :
 déplacements à droite et à gauche mais interdiction de rester en place
 ruban semi-inni
 restriction de l'alphabet à {a, b, B} ou à {a, b}
 plusieurs rubans
 règle non déterministe

8
3.6 Des fonctions et des ordinateurs
Certaines fonctions ont une croissance extrêmement rapide et demandent un temps de calcul gigantesque, ce
qui rend la limite entre calcul qui ne termine pas et calcul long dicile à appréhender.
Par exemple, la fonction d'Ackermann est dénie comme suit pour n, m ∈ N :
 
 n+1 si m=0 
A(m, n) = A(m-1,1) si m>0 et n=0
A(m-1,A(m,n-1)) sinon
 

Essayez de calculer A(4, 2) avec un programme sur votre modèle de calcul préféré : MT, python, java,. . .
On dénit un Castor Aairé comme étant une MT eectuant le plus grand nombre de pas de calcul sur une
entrée vide avant de s'arrêter, parmi les MT ayant un nombre d'états et de symboles donnés. On xe par exemple
l'alphabet du ruban : {a, b} où b joue le rôle de l'état blanc. Alors pour un nombre d'états n donné (on autorise
un état terminal supplémentaire), le nombre maximal de pas de calcul d'une machine qui s'arrête est donné dans
la tableau suivant :

n 2 3 4 5 6 ...
nombre de pas 6 21 107 ≥ 47 ∗ 106 ≥ 7.4 ∗ 1036534 ...

3.7 Des questions pour la suite


Existe-t-il des langages non récursifs ? Non r.e. ?
Et le codage dans tout ça ?

3.8 Des gens


 Ada Lovelace
 David Hilbert
 Kurt Gödel
 Alonzo Church
 Alan Turing
 Stephen Cole Kleene
 Emil Leon Post

9
10
Chapitre 4

Problèmes et codage

4.1 Problèmes
Des exemples :
 L'entier naturel n est-il la somme de quatre carrés ?
 L'entier naturel n est-il le produit des entiers p et q ?
 Est-ce que le degré maximal du graphe G est 5?
 Le triangle ABC est-il isocèle ?
On ne s'intéresse ici qu'aux problèmes de décision, ils sont donnés par (une entrée, une question), la réponse
ne pouvant être que oui ou non.
L'entrée doit être décrite dans un langage qui dépend du codage choisi. Exemples :
 unaire/binaire/. . . pour des entiers dans N ou Z
 matrice d'adjacence/liste d'adjacence pour des graphes
 liste des coecients pour les polynômes, intégrale ou par couple avec la position pour les coecients non
nuls
 uplet avec des symboles séparés par des #, des $, ...

Question : Qu'est ce qu'un bon codage ?

Un codage est dit acceptable lorsque les propriétés suivantes sont respectées :
 Il faut pouvoir le calculer pour une entrée donnée.
 Il faut pouvoir détecter ce qui n'est pas un code valide.
 Il faut pouvoir retrouver l'objet étant donné le code.
Exemple : Le problème ((i, j, k), i + j = k?) peut être traité de plusieurs manières, notamment :
 (i, j, k) donné en unaire, avec une MT m1
 (i, j, k) donné en binaire, avec une MT m2
On dénit le langage des instances d'un problème sur un alphabet donné comme étant l'ensemble des codes des
entrées. Ce langage doit être récursif (pour détecter les codes non valides).
On dénit le langage associé à un problème (inclus dans le précédent) comme étant l'ensemble des codes des
entrées pour lesquels la réponse est positive. Intuitivement, c'est l'ensemble des entrées satisfaisant la propriété
recherchée pour ce problème.
On dit qu'un problème est décidable lorsque le langage associé est récursif. Il est semi-décidable lorsque le
langage associé est récursivement énumérable.
Le caractère décidable d'un problème ne dépend pas du codage utilisé tant que celui-ci est acceptable.
Exemples :
 Savoir si un entier est premier est décidable.
 Savoir si un graphe est planaire est décidable.

4.2 Propriété des langages récursifs et r.e.


On peut :

11
 composer des MT : pour des MT dont les ensembles d'états sont disjoints, il sut de fusionner état d'arrêt
de la première machine et état initial de la seconde. Selon l'objectif, on peut se brancher sur certains états
d'arrêt (e.g. qa ) et brancher une autre MT sur d'autres états d'arrêt (e.g. qr ).
 recopier l'entrée après un séparateur hors de Γ pour la garder en mémoire avant de travailler : u devient
u#u.
 travailler sur la copie de l'entrée sans toucher à l'original puis à l'arrêt tout eacer sauf l'entrée originale.
Attention à ne pas écrire sur l'entrée originale : même principe que pour un ruban semi-inni.
 faire 2 calculs de MTs diérentes sur la même entrée, l'un après l'autre, en faisant une copie de l'entrée, en
travaillant dessus avec le programme de la première MT, en eaçant tout puis en travaillant sur l'original
avec le programme de la seconde MT.

Proposition 4.1. L'ensemble des langages récursifs est clos par union, intersection et complémentaire.

Démonstration. Si L1 et L2 sont récursifs, alors il existe des MT M1 et M2 qui s'arrêtent sur toute entrée et qui
les reconnaissent. On construit une MT M qui exécute le programme de M1 sur une copie de l'entrée, retient le
résultat puis exécute le programme de M2 sur l'entrée.
La machine M s'arrête sur toute entrée. Si elle accepte lorsque les 2 machines ont accepté, elle reconnnaît
l'intersection, si elle accepte lorsque l'une des 2 accepte, elle reconnaît l'union.
Pour reconnaître le complémentaire de L1 , on échange les états qa et qr de M1 .

On peut simuler 2 MT en parallèle sur une même entrée. Pour cela :


 on fait une copie de l'entrée après un séparateur #.
 on simule l'exécution des programmes de M1 sur la première version de l'entrée et de M2 sur la seconde.
On exécute les programmes en faisant un pas de calcul de chaque côté alternativement
 On a besoin d'un programme qui gère l'alternance et le déplacement de la tête d'un espace de calcul à
l'autre.
 On a besoin de marqueurs (hors de Γ) pour retenir la position des têtes de calcul.
 On a besoin d'étendre l'espace de calcul si nécessaire : déplacer un mot d'une case vers la droite.

Proposition 4.2. L'ensemble des langages r.e. est clos par union et intersection.

Démonstration. On construit M qui simule en parallèle les machines qui reconnaissent L1 et L2 . Pour l'union :
 Si M1 s'arrête en premier et accepte, M accepte. Si elle rejette, on continue la simulation de M2 .
 Réciproquement si M2 s'arrête en premier.
 Lorsque la seconde machine s'arrête, M accepte ou refuse selon le résultat.
 Si aucune des machines ne s'arrête ou si la seconde ne s'arrête pas, M non plus.
Principe similaire pour l'intersection.

La preuve ne fonctionne pas pour le complémentaire !

Proposition 4.3. Si L est r.e. et co-r.e., alors L est récursif.

Démonstration. Si M1 reconnaît L et M2 reonnaît L, on construit M qui simule les 2 en parallèle. Pour tout mot
u, si u ∈ L, alors M1 s'arrête sur u et M accepte. Sinon u ∈ L et M2 s'arrête, alors M rejette.

4.3 Encodage des MTs


4.3.1 Des programmes et des entrées

Un programme dans un langage quelconque est une chaîne de caractères, donc un objet sur lequel on peut
calculer, et qui peut être lu par un autre programme, voir produit par un autre programme.
Exemple : Un quine est un programme qui ne prend pas d'argument et produit en sortie son propre code en
tant que chaîne de caractère. Il en existe dans tous les langages de programmation.
Ocaml : (fun s -> Printf.printf "%s %S;;" s s) "(fun s -> Printf.printf \"%s %S;;\" s s)";;
Python : a='a=%r;print(a%%a)';print(a%a)
De la même manière, on peut représenter une MT par un code. Il faut un alphabet ni permettant de représenter
toutes les MTs, quels que soient leurs nombres d'états et de symboles.
Voici un exemple, on veut encoder (Q, Σ, Γ, δ, q0 , Qf , B) :

12
 Il n'est pas restrictif de considérer que Q = {0, 1, 2, . . . , |Q| − 1} avec q0 = 0, qa = |Q| − 2 et qr = |Q| − 1.
Donc il sut de donner |Q|.
 De manière similaire Σ = {0, 1, 2, . . . , |Σ| − 1} et Σ ⊆ Γ = {0, 1, 2, . . . , |Γ| − 1} avec B = |Γ| − 1, donc il
sut de donner |Σ| et |Γ|.
0
 Pour δ , on encode la transition δ(q, x) = (q , y, d) où d ∈ {←, ↓, →} par eq |fx : eq 0 |fy |d où eq est l'écriture
binaire de q sur l'alphabet {a, b} et fx est la représentation binaire de x sur l'alphabet {0, 1}.
En notant r0 , r1 , . . . , rN les codes des transitions, on obtient alors le codage de la MT où |Q|, |Σ| et |Γ| sont donnés
en binaire :
hM i = |Q|; |Σ|; |Γ|; r0 @r1 @ . . . @rN
L'alphabet utilisé est bien ni : AM T = {0, 1, a, b, |, :, ; , @, ←, ↓, →}.
Étant donnée une MT, il est facile d'obtenir son code, on peut aussi vérier qu'un code est valide et retrouver
la MT correspondant à un code donné : on a donc bien un encodage acceptable !
Attention : il existe beaucoup de machines et des codes reconnaissant ou décidant un même langage ou calculant
une même fonction.

4.3.2 Énumérer les MT

Avec l'encodage précédent, toute MT M est représentée par un mot hM i sur l'alphabet AM T = {0, 1, a, b, |, :
, ; , @, ←, ↓, →}. À chaque mot sur cet alphabet est associé une place dans l'ordre lexicographique : on obtient une
numérotation des machines de Turing. Par défaut, on considère que tous les mots non-codants encodent la machine
qui rejette toujours
Il existe donc une MT qui prend en entrée un entier n et qui produit le code de la n-ième MT, cette machine
écrit le n-ième mot sur l'alphabet AM , on note (Mi )i cette énumération des MTs.

4.3.3 Machine universelle

Un ordinateur est essentiellement une machine capable de lire un programme et de l'exécuter, on appelle
universalité cette capacité à exécuter un programme quelconque, c'est à dire à appliquer n'importe quelle procédure
eective.
On va construire une machine de Turing universelle, c'est à dire une machine qui prend en entrée un code de
MT hMx i u et qui exécute le programme de Mx sur l'entrée u.
et une entrée associée
On note MU = (QU , ΣU , ΓU , q0 , {qa , qr }, B) cette machine. On utilise ici l'équivalence entre MTs sur ruban
bi-inni et MTs sur ruban semi-inni et on construit MU pour fonctionner sur un ruban semi-inni. L'idée est que
le ruban contienne la règle de la MT simulée puis l'encodage de la conguration et de l'état de la MT simulée.
Pour une machine M de règle r0 @r1 @ . . . @rN , dans l'état q (représenté par eq ) et avec x0 x1 . . . xk BBBBB
sur le ruban, la conguration de la machine universelle sera

r0 @r1 @ . . . @rN #fx0 _fx1 |eq |fx2 _ . . . fxk _BBB . . .

Le codage de l'état est placé sur le ruban à l'endroit où se trouve la tête de la machine simulée.
On aura besoin en plus d'un système de marquage de la conguration : on ajoute un • sur le ruban pour
marquer une position. D'où :
 ΣU = (AM ∪ {_}) × {0} ∪ {B} = ({0, 1, a, b, |, :, ; , @, ←, ↓, →, _} × {0}) ∪ {B} ;
 ΓU = (AM ∪ {_}) × {0, •} ∪ {B} = ({0, 1, a, b, |, :, ; , @, ←, ↓, →, _} × {0, •}) ∪ {B} ;

Calcul de MU hM, ui. Partant de la conguration initiale, MU vérie que hM i est une règle valide,
: L'entrée est
si ce n'est pas le cas on va dans l'état qr . Puis on marque l'emplacement de la tête de la machine simulée sur la
conguration (devant le symbole fu0 ).

1. on part vers la gauche jusqu'à la decription de r0 et on la pointe ;

2. on fait des AR entre les 2 positions pointées pour vérier si la règle s'applique, i.e. si le couple (état,symbole)
est le même ;

3. si ce n'est pas le cas, on essaie avec la règle suivante ;

4. quand on a trouvé la règle qui s'applique, il faut :


 réécrire le symbole ;
 déplacer la tête ;

13
 changer l'état de la tête ;
 enlever les marquages •;
 marquer avec • le nouvel emplacement de la tête ;
 revenir en 1.

5. si aucune règle ne correspond, on va dans l'état qr .


6. lorsqu'on écrit un état nal pour la machine simulée (soit |Q| − 2, soit |Q| − 1), la machine MU va dans
l'état nal correspondant (soit qa , soit qr ).
Théorème 4.1. Il existe une machine MU qui prend en argument hM, ui et qui :
 accepte si et seulement si M accepte u, i.e. M s'arrête dans l'état d'acceptation : u ∈ L(M ).
 rejette si et seulement si M rejette u, i.e. M s'arrête dans l'état de rejet : u ∈
/ L(M ).
 ne s'arrête pas si et seulement si M ne s'arrête pas sur l'entrée u.

On dit que cette machine est universelle et que MU (hM, ui) est une simulation de M sur u.
Remarque : hui et hM i sont tous 2 une partie de l'argument, ils vivent dans le même monde !
Il existe de nombreuses manières de dénir une machine universelle.

14
Chapitre 5

Indécidabilité

Pour le moment, on ne sait pas s'il existe un problème indécidable, tous les langages rencontrés sont récursifs !

5.1 Dénombrement
On a vu qu'il est possible d'associer un numéro à chaque mot et donc à chaque MT en particulier, ce n'est pas
vrai pour d'autres ensembles.

Dénition 5.1. Un ensemble E est dit dénombrable lorsqu'il existe une bijection entre E et un sous-ensemble de
N.

Intuitivement, cela signie que l'on peut associer un numéro entier distinct à chaque élément de E.
Les ensembles dénombrables sont les plus petits parmi les ensembles innis, sont dénombrables :
 ensembles nis
 N, Z, Q, Z2 , . . .
 Σ∗ pour Σ ni
 les MTs donc les langages r.e.
 toute union de deux ensembles dénombrables

Remarque 5.1. Par dénition, tout ensemble inclus dans un ensemble dénombrable l'est aussi.

Il existe des ensembles plus grands ! On montre souvent qu'ils sont indénombrables par diagonalisation.

Proposition 5.1. L'ensemble de réels [0, 1[ est indénombrable.

Démonstration. Un problème peut survenir à cause des nombres réels qui ont 2 écritures binaires, par exemple 0, 5
peut s'écrire 0, 1000 . . . ou 0, 0111 . . . en binaire. On va donc montrer dans un premier temps que l'ensemble des
écritures binaire avec une innité de chires après la virgule X = {0, a0 a1 a2 . . . , ∀i, ai ∈ {0, 1}} est indénombrable.
On suppose que X est dénombrable, alors X = {x0 , x1 , . . .}. Pour tout i, on peut écrire xi = 0, xi,0 xi,1 xi,2 . . .
comme étant la suite des chires après la virgule en binaire. Réciproquement, tout nombre qui s'écrit de cette
manière (0, . . . ) appartient à X.
On construit un nouveau nombre y dont la suite de chires après la virgule est (y0 , y1 , . . . ) en prenant yi =
1 − xi,i . y = 0, y0 y1 y2 · · · ∈ X .
On obtient donc
Comme y ∈ X , il existe j tel que y = xj , mais par dénition de y : yj 6= xj,j donc y 6= xj . C'est une
contradiction, donc l'hypothèse est fausse : X est indénombrable.
Pour revenir aux nombres réels, on s'intéresse maintenant aux nombres réels ayant deux écritures binaires. On
constate que ces nombres s'écrivent indiéremment 0, u0 u1 . . . uk 0111 . . . ou0, u0 u1 . . . uk 1000 . . . , où pour tout
i, ui ∈ {0, 1}. Il y a donc autant de tels nombres que de mots nis sur l'alphabet {0, 1}, ce qui signie que cet
ensemble est dénombrable. On appelle impropre l'écriture de nombres réels nissant par 111 . . . , et on note Impr
l'ensemble des écritures impropres. On a donc montré que Impr est dénombrable.
L'ensemble X est l'union des représentations propres et impropres, donc en identiant un nombre à sa re-
présentation propre, on a X = [0, 1[∪Impr. Si [0, 1[ est dénombrable, comme Impr l'est, alors X aussi, ce qui
contredit le résultat ci-dessus.

15
La méthode s'appelle  diagonalisation  en raison de la représentation graphique que l'on peut en faire :
x0 x1 x2 ...
0 x0,0 x0,1 x0,2 ...
1 x1,0 x1,1 x1,2 ...
2 x2,0 x2,1 x2,2 ...
.
.
.
On prend l'écriture y qui s'obtient en inversant tous les chires de la diagonale. La diagonale est par construction
diérente de chaque colonne, donc y est diérent de chaque xi .
Il y a donc plus de réels que d'entiers.
De manière similaire, on montre que :

Proposition 5.2. L'ensemble des fonctions totales N→N est indénombrable.


L'ensemble des langages sur un alphabet ni Σ est indénombrable.

Démonstration. Dans les 2 cas, on utilise une preuve par diagonalisation. On suppose que l'on peut dénombrer
→ N f: N
les fonctions totales : (fi )i . On construit . Alors si il existe j tel que f = fj , on obtient
7 → fi (i) + 1 i
f (j) = fj (j), ce qui est faux puisque par dénition f (j) = fj (j) + 1.

De même, si l'on peut dénombrer les langages sur l'alphabet ni Σ, on les note (Li )i . On peut parcourir Σ dans

l'ordre lexicographique donc on peut numéroter les mots : Σ = {mi }. On construit le langage L = {mi , mi ∈ / Li }.
Le langage L est bien sur l'alphabet Σ, donc il existe j tel que L = Lj . Alors si mj ∈ Lj , on a mj ∈ / L donc
L 6= Lj . Et inversement si mj ∈ / Lj , alors mj ∈ L donc L 6= Lj . Ce qui contredit notre hypothèse.

5.2 Existence d'un langage non r.e.


Théorème 5.1. Il existe un langage non r.e. (et donc non récursif ).

Démonstration. L'ensemble des MTs est dénombrable donc l'ensemble des langages r.e. est dénombrable. Or
l'ensemble des langages est indénombrable donc il existe un langage non r.e.

Dans la suite, on exhibera de tels langages.

5.3 Le problème de l'arrêt : K


Le problème de l'arrêt, appelé K, est déni par :
 Entrée : Une MT M w.
et un mot
 Question : Est-ce que M s'arrête sur l'entrée w ?
Le langage associé LK = {hM, wi, M s'arrête sur w} est clairement r.e. : on simule la machine M sur l'entrée
w. Si M nit par s'arrêter, la simulation aussi et on accepte.
En revanche, on ne sait pas si M va nir par s'arrêter et il n'est pas possible a priori de rejeter une entrée.

Théorème 5.2. Il n'existe pas de MT MK qui s'arrête sur toute entrée et telle que MK accepte hM, wi si et
seulement si M s'arrête sur l'entrée w.
Autre formulation : le langage LK = {hM, wi, M s'arrête sur w} n'est pas récursif.

Démonstration. La preuve se fait par diagonalisation. Pour chaque MT Mi , on note mi,j = A si Mi s'arrête sur
l'entrée j et mi,j = R sinon.
M 0 M1 M2 . . .
0 A R A ...
1 R R R ...
2 A A R ...
.
.
.
Comme les MT sont dénombrables, il est impossible de construire une MT qui ne soit pas une Mi .
On va supposer l'existence de la MT MK qui s'arrête sur toute entrée et telle que MK accepte hM, wi si et
seulement si M s'arrête sur l'entrée w. On montre maintenant qu'à l'aide de MK , on peut construire une MT D
telle que ∀i ∈ N, D 6= Mi .

16
Pour construire D, D fait l'inverse de Mi sur
on peut chercher à prendre les valeurs inverses de la diagonale :
l'entrée i. Mi s'arrête sur l'entrée i alors D entre dans une boucle innie sur l'entrée i. Il
On va donc dire que si
sut pour cela de simuler Mi sur i et à l'arrêt on bascule vers la boucle. Dans l'autre sens, on veut que si Mi ne
s'arrête pas sur i alors D s'arrête sur i. Problème : Si D simule Mi , il est impossible de choisir quand s'arrêter !
Or, on dispose ici de MK permettant de déterminer l'arrêt de Mi sur i. On dénit donc D comme suit :
 sur l'entrée i, D simule MK sur l'entrée hMi , ii ;
 si MK accepte (cela signie que Mi s'arrête sur i) alors on fait entrer D dans une boucle innie ;
 si MK refuse (cela signie que Mi ne s'arrête pas sur i) alors D va dans un état nal.
Comme MK s'arrête sur toute entrée, ce sont bien les deux seules options.
Par dénition de D , on a bien ∀i ∈ N, D 6= Mi . Ce qui est impossible, donc l'hypothèse est fausse : une telle
MK n'existe pas.
On peut donner une autre preuve utilisant encore la diagonalisation :

Démonstration. On suppose que MK décide LK = {hM, wi, M s'arrête sur w}. On construit la machine D qui,
sur l'entrée w :
 simule MK sur hw, wi (où w est interprété d'abord comme un code de MT puis comme un mot) ;
 si MK accepte, D entre dans une boucle innie ;
 si MK rejette, D s'arrête.
Alors : D(hDi) s'arrête ssi MK rejette hD, Di) ssi D ne s'arrête pas sur hDi. Contradiction.

5.4 Réductions
On va utiliser l'indécidabilité du problème de l'arrêt pour montrer que d'autres problèmes sont indécidables.
Informellement, si on montre qu'un problème est plus dicile à résoudre qu'un problème indécidable, alors le
premier est indécidable aussi.

Dénition 5.2. On dit que le langage A se réduit au langage B (on note A ≤m B ) s'il existe une fonction totale
calculable f : Σ∗ → Σ∗ telle que ∀x ∈ Σ∗ , x ∈ A ⇔ f (x) ∈ B . La fonction f est appelée réduction de A à B .
De manière équivalente, on pourra parler de réduction sur les problèmes directement lorsqu'il existe une
réduction entre les langages associés aux problèmes.
Pour rappel, une fonction totale calculable est une fonction f sur Σ∗ telle qu'il existe une MT qui s'arrête sur

tout w∈Σ avec f (w) sur le ruban.
Exemple 1 : On note K0 le problème de l'arrêt sur entrée vide. L'entrée est une MT et la question est de savoir
si cette machine s'arrête sur l'entrée vide. La fonction f : hM i 7→ hM, i, où  est le mot vide, est une réduction
de K0 à K.
Exemple 2 : On note Lacc = {hM, ui : u ∈ L(M )} le langage des couples (M, u) tels que M accepte le mot
u. On peut montrer que Lacc ≤m LK à l'aide de la réduction f 0 : hM, ui 7→ hM 0 , ui où M 0 est comme M sauf
que l'état qr de M est remplacé par un nouvel état q avec q, _|q, _, ↓. Lorsque M doit s'arrêter dans l'état de
0 ∗
rejet, M entre dans une boucle innie. On peut donc montrer l'équivalence. Soient M une MT et u ∈ Σ , on note
0
(M , u) = f (M, u) :
0
 Si M accepte u, alors M s'arrête sur u.
0
 Si M s'arrête sur u, alors c'est dans l'état qa et donc M accepte u.
Exemple 3 : On peut montrer aussi que LK ≤m Lacc . Laissé en exercice.
Si on sait décider B , il sut donc de composer la réduction avec le programme qui décide B pour obtenir un
programme décidant A.

Proposition 5.3. Si B est récursif et A ≤m B alors A est récursif.

Démonstration. Il existe une MT MB qui décide B . Il existe une MT Mr qui calcule la réduction. On construit

M qui sur une entrée w∈Σ simuleMr et produit f (x), puis simule MB pour décider si f (x) ∈ B . M accepte
ssi MB accepte.

Corollaire 5.1. Si A n'est pas récursif et A ≤m B alors B n'est pas récursif.

Clairement les mêmes arguments permettent de montrer les résultats suivants.

Proposition 5.4. Si B est r.e. et A ≤m B alors A est r.e.

17
Corollaire 5.2. Si A n'est pas r.e. et A ≤m B alors B n'est pas r.e.

Exemple 1 : Retour sur l'exemple de K0 . On a montré que K est plus dicile que K0 , ce qui permet uniquement
de conclure que K0 est r.e., mais on ne peut rien dire pour le moment sur le caractère récursif ou non de K0 . Vous
verrez en TD une réduction dans l'autre sens !
Exemples 2 et 3 : On a montré que Lacc ≤m LK et LK ≤m Lacc . D'autre part, on sait que K est indécidable,
c'est à dire que LK n'est pas récursif. On en déduit que Lacc n'est pas récursif non plus.
Les langages récursifs jouent un rôle particulier vis à vis des réductions : comme les réductions sont des fonctions
totales calculables, la granularité minimale est celle du calcul Turing. Dit autrement, les langages récursifs sont
les langages de complexité minimale vis à vis des réductions (hors langages vide et plein).

Proposition 5.5. 1. Si A 6= Σ∗ alors ∅ ≤m A



2. Si A 6= ∅ alors Σ ≤m A
3. Si A est récursif et / {∅, Σ∗ }
B∈ alors A ≤m B .

Démonstration. 1. Il existe v∈
/ A, on prend la réduction f : w 7→ v .
2. Il existe v ∈ A, on prend la réduction f : w 7→ v .
f : w∈A →
7 v
3. Il existe u ∈
/ B et v ∈ B, on prend la réduction , c'est bien une fonction totale
w∈
/A → 7 u
calculable car A est récursif.

5.5 Théorème de Rice


On a maintenant les armes pour montrer que de nombreux problèmes sont indécidables, il sut de trouver
des réductions du problème de l'arrêt à chacun de ces problèmes. En fait on va donner un résultat générique qui
permet de prouver que beaucoup de langages sont non récursifs.

Dénition 5.3. On dit que P ⊆ {hM i, M est une MT} est une propriété du langage d'une machine de Turing si
c'est un ensemble de codes de MT tel que ∀M1 , M2 , si L(M1 ) = L(M2 ) alors hM1 i ∈ P ⇔ hM2 i ∈ P . C'est à dire
que si 2 MT ont le même langage alors soit elles ont toutes les 2 la propriété, soit aucune.
On dit qu'une propriété P est non triviale s'il existe hM1 i ∈ P et hM2 i ∈
/ P.

Théorème 5.3. Si P est une propriété non triviale de langage de MT, alors P n'est pas récursive.

Démonstration. On montre que le langage LK associé au problème de l'arrêt se réduit à P. Le corollaire 5.1
permettra de conclure que P n'est pas récursif.
Objectif : Pour toute entrée (M, w) du problème K, on construit une entrée T du problème de reconnaissance
de P de telle sorte que :

hM, wi ∈ LK ⇔ hT i ∈ P

Soit M0 une machine qui sur toute entrée entre dans une boucle innie. On suppose que hM0 i ∈
/ P , la preuve
est symmétrique dans le cas où hM0 i ∈ P . Comme P n'est pas triviale, il existe hM1 i ∈ P .
Soit (M, w) une entrée du problème K . La machine T est dénie comme suit : sur l'entrée z , elle simule M
sur l'entrée w et si M s'arrête, elle simule M1 sur l'entrée z .
 Si hM, wi ∈ LK , la machine T simule M sur l'entrée w , s'arrête puis simule M1 sur z . Donc T accepte z si
et seulement si M1 accepte z , i.e. L(T ) = L(M1 ) et donc hT i ∈ P .
 Si hM, wi ∈ / LK , la machine T sur l'entrée z simule M sur w et ne s'arrête pas. Donc en particulier
L(T ) = L(M0 ) ce qui implique que hT i ∈ / P.
On a bien construit T telle que hM, wi ∈ LK ⇔ hT i ∈ P , c'est à dire que LK se réduit à P .

Exemples de propriétés de langage de MT :


 {hM i, L(M ) ni }
 {hM i, L(M ) vide }
 {hM i, abaabb ∈ L(M )}

18
Remarque 5.2. On peut énoncer un théorème de Rice pour les fonctions partielles calculables. dans ce cas, une
propriété des f.p.c. est telle que si 2 fonctions s'arrêtent sur le même ensemble d'entrées et produisent la même
sortie dans chaque cas, alors soit elles ont toutes les 2 la propriété, soit aucune ne l'a.
On peut alors montrer que les propriétés suivantes sont indécidables par exemple :
 {φ f.p.c., φ dénie sur N}
 {φ f.p.c., φ dénie sur N et φ : k 7→ k 2 }
 {φ f.p.c., ∃k ∈ N, φ(k) = 0}

Avec l'universalité de la notion de calcul vient l'universalité de la notion de décidabilité. En particulier, on peut
prendre un autre modèle de calcul équivalent aux MTs (langage de programmation, automates de Minsky,. . .), et
on pourra démontrer un théorème de Rice sur ce modèle.
Par exemple on peut coder des MTs à l'aide de matrices 3×3 à coecients entiers et montrer que partant
d'un ensemble ni de matrices, l'existence d'une suite nie de produit nul est indécidable.

19
20
Chapitre 6

R.e. complétude

On montre ici que ≤m est un préordre sur les langages et on montre l'existence de langages maximaux dans
certaines classes.

Proposition 6.1. La relation ≤m est un préordre.

Démonstration. Un préordre est une relation binaire réexive et transitive. Clairement pour tout langage L,
0
L ≤m L avec la fonction identité comme réduction, donc ≤m est réexive. Si L ≤m L avec la réduction f et
L0 ≤m L00 avec la réduction g , alors L ≤m L00 avec la réduction g ◦ f. Donc ≤m est transitive.

Proposition 6.2. La relation ≤m n'est pas un ordre.

Démonstration. Un ordre est une relation de préordre antisymétrique, c'est à dire telle que ∀L, L0 , si L ≤m L0 et
L0 ≤m L alors L = L0 .
n 0 n
On prend 2 langages récursifs non triviaux L = {a : n%2 = 0} et L = {a : n%2 = 1}, on a clairement
L ≤m L0 et L 0 ≤m L (cf Proposition 5.5) mais L 6= L0 .
Cependant, on peut dénir une relation d'équivalence ∼ entre langages avec L ∼ L0 si et seulement si L ≤m L0
0
et L ≤m L. Dans ce cas, en prenant un représentant de chaque classe d'équivalence, ≤m est un ordre sur l'ensemble
des représentants.
Cette notion d'ordre établie, on montre qu'il existe des langages maximaux dans l'ensemble des langages r.e.

Dénition 6.1. Un langage est dit r.e. complet si tout langage r.e. se réduit à lui.

Théorème 6.1. Le langage LK est r.e. complet.

Démonstration. Soit L un langage r.e., il existe donc une MT M qui le reconnaît. On construit une machine N
qui sur l'entrée w simule M
w puis :
sur
 si M s'arrête et rejette, N entre dans une boucle innie
 si M s'arrête et accepte, N aussi.
Donc w ∈ L ⇔ (M, w) ∈ LK et L ≤m LK .

Corollaire 6.1. Tout langage L r.e. tel que LK ≤m L est r.e. complet.

Exemples : Arrêt sur entrée vide (K0 ), PCP (pas de spoiler !), tout langage r.e. correspondant à une propriété
non triviale des langages de MT (cf Th. de Rice),. . .

21
22
Chapitre 7

Problème de correspondance de Post : un


problème indécidable simple !

Emil Post (1946) : un jeu de dominos

7.1 Dénition
Le problème PCP est déni par :
 Entrée : 2 listes de mots u1 , u2 , . . . , un ∈ Σ∗ et v1 , v2 , . . . , vn ∈ Σ∗
 Question : Existe-t-il une suite i1 , i2 , . . . , ik ∈ {1, 2, . . . , n} telle que ui1 ui2 . . . uik = vi1 vi2 . . . vik ?
L'idée est de se donner un ensemble de  dominos contenant un mot en haut et un mot en bas, tous 2 sur le
même alphabet. Le but est de trouver une suite nie de dominos telle que le mot écrit en haut en concaténant les
dominos est le même qu'en bas.
Exemples :
a ab bba
 , , accepté pour 3231 par exemple (le mot obtenu en haut et en bas est bbaabbbaa).
baa aa bb

aba b a ab
 , , , accepté pour 12321 par exemple
a b ababa b

aaa baa ab b
 , , , accepté avec plus petite solution de taille 302.
aab a abb aa
On va montrer que PCP est indécidable en passant par un intermédiaire et en utilisant 2 réductions consécu-
tives. On utilise un problème plus contraint que PCP.

7.2 PCPM (modié)


On ajoute une contrainte à PCP en xant la première tuile utilisée. L'idée est de faire une réduction de l'arrêt
Turing à PCPM en pratiquant de la même manière que pour la vacuité des Machines de Turing Linéairement
Bornées (n de feuille de TD 3, probablement non traité. . .) : on vérie un historique de calcul Turing.

Dénition 7.1. Le problème PCPM est déni par :


 Entrée : 2 listes de mots u1 , u2 , . . . , un ∈ Σ∗ et v1 , v2 , . . . , vn ∈ Σ∗
 Question : Existe-t-il une suite i2 , . . . , ik ∈ {2, . . . , n} telle que u1 ui2 . . . uik = v1 vi2 . . . vik ?

Théorème 7.1. PCPM est indécidable.

Démonstration. On va montrer que l'on peut réduire le langage LK à LP CP M . Pour cela on va construire un jeu
de dominos capable de simuler du calcul Turing et tel qu'une solution à PCPM correspond à un calcul qui s'arrête.

 Objectif : Pour une machine de Turing


 M et une entrée w, on construit un ensemble de dominos Dom(hM, wi) =
ui
tel que M s'arrête sur w si et seulement si il existe une solution de PCPM pour Dom(hM, wi).
vi i

23
On va construire un jeu de dominos qui écrit la suite des congurations traversées par la
machine M sur l'entrée w (la trace) tout en vériant que chaque conguration est bien
l'image de la précédente. Il faut de plus garantir que la conguration initiale correspond à
w. L'idée est de prendre un premier domino qui écrit la conguration initiale C0 en bas
et rien en haut. Les dominos suivants devront donc écrire C0 en haut, tout en écrivant
son image en bas. Ainsi, on conserve une conguration d'avance en bas et on vérie au
passage que le calcul Turing est correct. On poursuit la vérication jusqu'à obtenir une
conguration terminale.

La preuve. On dénit une fonction Dom qui à chaque instance hM, wi du problème de l'arrêt fait correspondre
un jeu de dominos Dom(hM, wi). Soit M une MT et w ∈ Sigma∗ .
On se donne un premier domino où # est choisi hors de Γ et de Q, et représente le début du
#q0 w0 w1 . . . wn
#
codage d'une conguration Turing. Ensuite, il faut pour marquer le passage à une nouvelle conguration.
#
Puis on propage le calcul en représentant chaque transition Turing :
qx
 (x, q) → (y, q 0 , ↓) est représentée par
q0 y
zqx
 (x, q) → (y, q 0 , ←) est représentée par pour tout z∈Γ
q 0 zy
qx
 (x, q) → (y, q 0 , →) est représentée par
yq 0
On gère les cas particuliers aux bords de la conguration :
#qx
 (x, q) → (y, q 0 , ←) est représentée par
#q 0 By
qx#
 (x, q) → (y, q 0 , →) est représentée par
yq 0 B#
x
Tout le reste de la conguration (lorsque la tête n'est pas visible) est recopié tel quel à l'aide des dominos
x
pour chaque x ∈ Γ.
Enn, lorsque le calcul termine (état terminal atteint), il faut compléter Dom(hM, wi) pour terminer la partie
xqf qf x
de dominos : les états terminaux mangent les lettres avec les dominos et pour chaque x∈Γ et
qf qf
qf #
chaque qf ∈ Qf . On ajoute pour chaque qf ∈ Qf qui servira à clore la partie de dominos.

u
On dira qu'une suite d'indices i1 , i2 , . . . , ik réalise un couple de mots lorsque u = ui1 ui2 . . . uik et v =
v
vi1 vi2 . . . vik . cod(q, u, k) ∈ Σ∗ QΣ∗ le codage de la conguration Turing dans l'état q , avec le mot u
On note sur
le ruban et la tête pointant sur la position k de y , que l'on dénit par m = cod(q, u, k) = m0 m1 . . . m|u| où :
 m0 m1 . . . mk−1 = u0 u1 . . . uk−1
 mk = q où la tête de la MT pointe sur uk
 mk+1 . . . m|u| = uk uk+1 . . . u|u|−1

En particulier le premier domino est .


#cod(q0 , w, 0)
On commence par montrer un premier lemme :

Lemme 7.1. Lemme de simulation : Soit C une conguration pour M. Les 2 propositions suivantes sont équiva-
lentes :
0
1. la règle de M est applicable (∃C , C ` C 0)
cod(C) #cod(C) cod(C)#
2. il existe une suite d'indices qui réalise exactement l'un parmi , et
v #v v#
Dans ce cas, v = cod(C 0 ).

24
Démonstration. On note m = cod(C) = a0 a1−1 . . . al qb0 b1 . . . bp où q ∈ Q, donc le mot sur le ruban dans la
conguration codée est a0 a1−1 . . . al b0 b1 . . . bp . Si la règle de M n'est pas applicable, il n'existe pas de domino
contenant qb0 en haut. Dans le cas contraire, un des cas suivants s'applique :

1. Si m = qb0 b1 . . . bp et la règle de la MT est (q, b0 ) 7→ (q 0 , x, ←) alors il existe une suite d'indices de dominos
#qb0 b1 b #m
réalisant . . . p donc l'équivalent de 0
pour C telle que C ` C .
0
#q 0 Bx b1 bp #cod(C 0 )
2. Si m = a0 . . . al qb0 et la règle de la MT est (q, b0 ) 7→ (q 0 , x, →) alors il existe une suite d'indices de dominos
a0 a qb0 # m#
réalisant ... l donc l'équivalent de
0
pour C telle que C ` C .
0
a0 al xq 0 B# cod(C 0 )#
3. Si m = a0 . . . al qb0 b1 . . . bp et la règle de la MT est (q, b0 ) 7→ (q 0 , x, ←) alors il existe une suite d'indices
a0 a al qb0 b1 b m
de dominos réalisant . . . l−1 . . . p donc l'équivalent de pour C
0
telle que
a0 al−1 q 0 al x b1 bp cod(C 0 )
C ` C 0.
4. Sim = a0 . . . al qb0 b1 . . . bp et la règle de la MT est (q, b0 ) 7→ (q 0 , x, ↓) alors il existe une suite d'indices de
a0 a qb0 b1 b m
dominos réalisant ... l . . . p donc l'équivalent de 0
pour C telle que C ` C 0.
a0 al q 0 x b1 bp cod(C 0 )
5. Sim = a0 . . . al qb0 b1 . . . bp et la règle de la MT est (q, b0 ) 7→ (q 0 , x, →) alors il existe une suite d'indices de
a0 a qb0 b1 b m
dominos réalisant ... l . . . p donc l'équivalent de 0
pour C telle que C ` C 0.
a0 al xq 0 b1 bp cod(C 0 )

⇒nOn suppose ici que M s'arrête sur w. Donc il existe une suite de congurations C0 ` C1 ` · · · ` Ct avec
C0 = (q0 , w, 0) et Ct = (qf , wt , l) une conguration terminale.
 On note mi = cod(Ci ) pour 0 ≤ i ≤ t, en particulier mt = a0 a1 . . . al−1 qf b0 b1 . . . bp : lorsque la MT s'arrête,
la tête pointe la lettre en position l.
 Une fois le mot mt écrit en bas avec les dominos, on  mange les lettres à gauche de la tête une par une,
cela produit les mots mt+j = a0 a1 . . . al−1−j qf b0 b1 . . . bp pour 1 ≤ j ≤ l − 1 et mt+l = qf b0 b1 . . . bp
 Pour nir on  mange les lettres à droite de la tête : on note mt+l+j = qf bj bj+1 . . . bp pour 1 ≤ j ≤ p et
mt+l+p+1 = qf
#
On utilise t fois le lemme de simulation 7.1 et on ajoute des pour montrer qu'il existe une suite d'indices
#
#m0 # . . . #mt−1 #
réalisant . On note en particulier que le cas 2 de la démonstration du lemme ne peut
#m0 # . . . #mt−1 #mt #
se produire directement après le cas 1.
a0 a al−j−1 qf b0 b
Pour 0 ≤ j ≤ l − 1, il existe une suite d'indices réalisant . . . l−j−2 ... p donc
a0 al−j−2 qf b0 bp
mt+j
l'équivalent de .
mt+j+1
q f bj bj+1 b mt+l+j
Pour 0 ≤ j ≤ p, il existe une suite d'indices réalisant ... p donc l'équivalent de .
qf bj+1 bp mt+l+j+1
En juxtaposant toutes ces suites d'indices, on réalise :

#m0 # . . . #mt−1 # mt # mt+1 mt+l+p # qf #


...
#m0 # . . . #mt−1 #mt # mt+1 # mt+2 mt+l+p+1 #

nOn
⇐ suppose maintenant qu'il existe une solution à l'instance Dom(hM, wi) de PCPM. Il existe donc une
Sol
suite d'indices i1 = 1, i2 , . . . ik qui réalise . On isole les # dans Sol et on a Sol = #m0 #m1 # . . . #ml ou
Sol
Sol = #m0 #m1 # . . . #ml #. Tous les mi sont ici pris dans (Q ∪ Γ)∗ donc ne contiennent pas de #.
On montre successivement plusieurs résultats intermédiaires.
Fait 1 : Il existe e≤l tel que me contient un symbole qf ∈ Qf .
Démo 1 : On utilise le fait que les seuls dominos avec un mot plus long en haut qu'en bas contiennent un symbole

25
qf ∈ Qf . On a |ui1 | < |vi1 | et s'il n'existe pas de tel e, alors pour tout j , |uij | ≤ |vij |, donc la suite (ij )j produit
deux mots de longueurs diérentes, et ne peut pas être une solution.
On note e le plus petit tel indice et on s'intéresse à m0 . . . me . On remarque aussi que, pour chaque domino,
si ui commence par #, alors vi aussi, donc nécessairement vi2 commence par # et m0 = q0 w.
mj
Fait 2 : Il existe un découpage de i2 , . . . iq avec un q ≤ k en des suites d'indices qui réalisent ou
mj+1
mj # #mj
ou pour chaque 0 ≤ j ≤ e − 1.
mj+1 # #mj+1
Démo 2 : Comme mi avec i < e ne contient pas de symbole de Qf , chaque domino utilisé contenant un symbole
# le contient en première ou en dernière position à la fois en haut et en bas. On coupe la séquence d'indices
avant chaque symbole # si possible et après sinon.
#m0 #m1 # . . . #me−1 #m0 #m1 # . . . #me−1 #
On note i1 , i2 , . . . , iq la suite d'indices réalisant ou .
#m0 #m1 # . . . #me #m0 #m1 # . . . #me #
Fait 3 : Chaque mj avec j ≤ e contient exactement un symbole de Q qui n'est pas en dernière position.
Démo 3 : Par récurrence. Pour j = 0, on a m0 = q0 w . Si la propriété est vraie pour j entre 0 et e − 1, on voit que
mj mj #
les dominos conservent tous le nombre de symboles dans Q donc la suite d'indices réalisant ou
mj+1 mj+1 #
#mj
ou aussi (puisque qf ne peut apparaître dans mj ). Par conséquent, la propriété est vraie pour j + 1.
#mj+1
On note mj = cod(Cj ) pour tout 0 ≤ j ≤ e. Le Fait 3 sut à prouver l'existence de la conguration Cj (un
seul symbole d'état).
Des applications répétées du lemme de simulation 7.1 démontrent que pour tout 0 ≤ j ≤ e − 1, la règle de M
est applicable à la conguration Cj et Cj ` Cj+1 .

Ce dernier résultat montre donc que les mj codent des congurations Cj avec :
 C0 la conguration initiale pour M sur l'entrée w
 ∀j ≤ e − 1, Cj ` Cj+1
 Ce une conguration terminale.
Ce qui signie que M s'arrête sur l'entrée w .

Conclusion : La fonction Dom est totale calculable et de plus

∀hM, wi : (hM, wi ∈ LK ⇔ Dom(hM, wi) ∈ LP CP M )


C'est à dire LK ≤m LP CP M . Comme LK n'est pas récursif, d'après le corollaire 5.1, LP CP M non plus.

7.3 Indécidabilité de PCP


Pour conclure, on fait une réduction de PCPM à PCP.

Théorème 7.2. PCP est indécidable

Démonstration. On montre que LP CP M ≤m LP CP . Pour cela on construit une fonction f totale calculable qui à
tout jeu de dominos A B tel que (A ∈ LP CP M ⇔ B ∈ LP CP ).
associe un jeu de dominos
On se donne un symbole # ∈ / Σ. Pour tout mot w = w0 w1 . . . wk ∈ Σ∗ , on note :
 g(w) = #w0 #w1 # . . . #wk et g() = 
 d(w) = w0 #w1 # . . . #wk # et d() = 
w0 .clean(w1 . . . wn ) si w0 ∈ Σ

 clean(w0 w1 . . . wn ) =
clean(w1 . . . wn ) si w0 = #
Les fonctions g et d intercalent des # une lettre sur 2 en commençant avant ou après la première lettre de w . Et
clean enlève les #.  
ui
Soit A un jeu de dominos . On construit un jeu de dominos B contenant :
vi i

g(u1 ) # g(ui )
, et pour chaque i
#d(v1 ) d(vi )

26
On montre successivement les points suivants :

1. Si A ∈ LP CP M , alors B ∈ LP CP
u1 ui2 u g(u1 ) g(ui2 ) g(uin ) #
Soit . . . in une solution pour A. Clairement ... est une solu-
v1 vi 2 vi n #d(v1 ) d(vi2 ) d(vin )
tion pour B .

g(u1 )
2. Toute solution pour B commence par .
#d(v1 )
g(ui )
Tous les dominos commencent par des lettres diérentes (# et une lettre de Σ). Si une solution
d(vi )
#
commence par un nombre n≥1 de dominos , il faut poursuivre avec un autre domino dont le mot du

bas commence par # et pas celui du haut, ce qui n'existe pas.

#
3. Toute solution pour B termine par

Tous les autres dominos ont des lettres terminales diérentes en haut et en bas (une lettre de Σ et #).
4. Pour tous mots w1 , w2 , . . . , wk dans Σ∗ , on a g(w1 )g(w2 ) . . . g(wk ) = g(w1 w2 . . . wk ) et d(w1 )d(w2 ) . . . d(wk ) =
d(w1 w2 . . . wk ).
#
5. S'il existe une solution pour B, alors il en existe une qui ne contient qu'une seule fois le domino

On se donne une solution pour B. Tous les mots g(ui ) et # commencent par # donc si une occur-
#
rence du domino n'est pas en dernière position, le mot construit contient ## or ce mot ne peut

g(u1 )
apparaître en bas qu'en réutilisant . Dans ce cas la suite de dominos solution commence par
#d(v1 )
g(u1 )g(ui2 ) . . . g(uin )#g(u1 ) . . .
. En particulier, comme les mots haut et bas coïncident, les préxes ob-
#d(v1 )d(vi2 ) . . . d(vin )#d(v1 ) . . .
tenus avant la première apparition du motif ## doivent coïncider aussi, donc g(u1 )g(ui2 ) . . . g(uin )# =
#
#d(v1 )d(vi2 ) . . . d(vin ). C'est bien une solution pour B ne contenant qu'une fois (en dernière position).

6. Si g(u)# = #d(v) alors u = v.


7. S'il existe une solution pour B, alors il existe une solution pour A
Par les points précédents, s'il existe une solution pour B, on peut en trouver une qui s'écrit
g(u1 ) g(ui2 ) g(uin ) #
... .
#d(v1 ) d(vi2 ) d(vin )
u1 ui1 u
Donc g(u1 ui2 . . . uin )# = #d(v1 vi2 . . . vin ), par conséquent . . . in est une solution pour A.
v1 vi 1 vi n
On a donc construit le jeu de dominos B tel que

A ∈ LP CP M ⇔ B ∈ LP CP

C'est à dire LP CP M ≤m LP CP .

27

Vous aimerez peut-être aussi