TD machines de Turing
Exercice 1
Analyse d’une machine de Turing
On donne le tableau suivant :
Etat
q0 , I
q1
q2 , F
0
(q0 , ⊥, →)
–
–
Symbole
1
(q1 , ⊥, →)
(q1 , ⊥, →)
–
⊥
–
(q2 , ⊥, →)
–
1. Représenter la machine de Turing associée. Quel langage reconnaît-elle ?
2. Écrire les représentations instantanées de la machine au cours de son exécution sur l’entrée 001110.
Corrigé
0/⊥, →
start
q0
1/⊥, →
1/⊥, →
q1
⊥/⊥, →
q2
1.
Cette machine reconnaît le langage 0∗ 1+ .
2. q0 001110 ⊢ ⊥q0 01110 ⊢ ⊥⊥q0 1110 ⊢ ⊥⊥⊥q1 110 ⊢ ⊥⊥⊥⊥q1 10 ⊢ ⊥⊥⊥⊥⊥q1 0 ⊢
rejet.
Exercice 2
Écriture d’une machine de Turing
1. Décrire une machine de Turing, étant donné un nombre X, retourne X+1.
Par exemple, pour 26 en entrée, la machine retournera 27.
2. Construire une machine de Turing qui accepte les mots ayant le même
nombre de 0 que de 1.
3. Décrire une machine de Turing qui accepte les palindromes de longueur
paire. Par exemple, 10100101 est un palindrome de longueur paire.
1
Corrigé
Il existe bien sûr de nombreuses solutions pour chaque problème.
1.
q2
0 − 8/1 − 9, →
∗/∗, →
start
q0
⊥/⊥, ←
⊥/1, ←
q1
q3
9/0, ←
On a utilisé quelques abus de notation : */* signifie "pour tout chiffre,
réécrire le chiffre" et 0-8/1-9 signifie "pour tout chiffre entre 0 et 8, écrire
le successeur de ce chiffre".
2.
0/0, →
X/X, →
q1
0/X, →
start
q0
1/X, ←
⊥/⊥, →
q2
1/X, →
X/X, →
0/X, ←
q4
1/1, →
X/X, →
Ici */* signifie "tout ce qui est 0 ou 1"
2
0/0, ←
1/1, ←
X/X, ←
3.
∗/∗, →
q1
X/X, ←
⊥/⊥, ←
q2
0/X, →
0/X, ←
q0
start
q3
X/X, →
∗/∗, ←
1/X, ←
1/X, →
q4
X/X, ←
⊥/⊥, ←
q5
∗/∗, →
Exercice 3
Variante d’une machine de Turing
On appelle machine de Turing avec stationnarité une machine de Turing qui
dispose de trois mouvements de ruban différents : ←, →, ∅. ∅ indique que le
ruban ne bouge pas.
Montrer que l’ensemble des fonctions calculées par les machines de Turing
avec stationnarité est exactement l’ensemble des fonctions calculées par les machines de Turing.
Corrigé
Montrons dans un premier temps que toute machine de Turing peut être simulée
par une machine de Turing avec stationnarité. C’est immédiat, car la machine
de Turing avec stationnarité peut faire toutes les opérations élémentaires d’une
machine de Turing.
Montrons maintenant qu’une machine de Turing avec stationnarité peut être
simulée par une machine de Turing. Pour cela, il est nécessaire de montrer que
toutes les transitions de la machine avec stationnarité peuvent être simulées par
une machine "classique". En particulier, il s’agit de montrer que les transitions
de la forme A/B, ∅ peuvent être simulées.
Considérons une transition de la forme A/B, ∅. Elle peut être simulée par
une machine de Turing, qui effectuerait deux transitions successives, A/B, ←
puis */*, → où * représente n’importe quel caractère : quel que soit le caractère
lu, il est réécrit et on se déplace à droite.
On peut appliquer deux transitions si à chaque fois que l’on veut simuler
une transition stationnaire, on rajoute un état intermédiaire dont le seul rôle
3
q1
est de rajouter une transition. Ainsi,
A/B, ← ′ ∗/∗, →
q1
q2
q1
.
Exercice 4
A/B, ∅
q2
peut être simulé par
Reconnaisseur et décideur
On appelle reconnaisseur d’un langage L une machine de Turing qui accepte
exactement les mots de L. L est alors dit reconnaissable, ou récursivement
énumérable et on note L ∈ RE.
On appelle décideur d’un langage L une machine de Turing qui accepte
exactement les mots de L, et qui rejette les autres. L est alors dit décidable,
et on note L ∈ R.
1. Un reconnaisseur peut-il entrer dans une boucle infinie pour un mot donné
en entrée ? Si oui, le mot est-il accepté ou refusé ? Même question pour
un décideur.
2. Si L est décidable, est-ce que son complémentaire L est décidable ?
3. Montrer que L est décidable ⇔ L et L sont reconnaissables.
4. Si L est reconnaissable, est-ce que L est reconnaissable ?
Corrigé
1. Par définition, un reconnaisseur n’accepte que les mots du langage qu’il
reconnaît, donc il est possible qu’un reconnaisseur entre dans une boucle
infinie pour un mot qui n’est pas du langage reconnu. Un décideur a
un temps d’exécution fini, car il finit soit par accepter, soit par refuser
une entrée. Il ne peut donc pas entrer dans une boucle infinie. On peut
remarquer d’un décideur est un reconaisseur qui s’arrête toujours en un
temps fini.
2. Oui. Soit D un décideur de L. Construisons la machine D qui, pour une
entrée e, simule l’exécution de D sur e. Si D finit par accepter e, alors
D refuse e ; et si D refuse e, alors D accepte e. Il est évident que D se
termine toujours, et reconnaît L, donc D décide L.
3.
⇒ Supposons que L est décidable. Il est immédiat que L est reconnaissable, car un décideur de L est un reconnaisseur de L. De plus
d’après la question 2, L est également décidable donc L est également
reconnaissable.
4
⇐ Supposons que L et L sont reconnaissables. Il existe un reconnaisseur
R de L et un reconnaisseur R de L.
Soit e un mot. Si e ∈ L, alors R(e) s’arrête. Si e ∈
/ L, alors R(e)
s’arrête. On crée donc une machine D qui, sur une entrée e, simule
l’exécution en parallèle de R(e) et R(e). Si R accepte le mot, alors
D accepte le mot, et si R accepte le mot, alors D refuse le mot.
Par définition de R et R, il est nécessaire que D(e) s’arrête en un
temps fini. Par ailleurs, il est immédiat que D reconnaît L, donc D
décide L.
4. D’après la question 3, si L et L sont reconnaissables, alors L est décidable.
Pour répondre à la question, il suffit donc d’exhiber un langage qui soit
reconnaissable mais pas décidable.
Soit L = {(M, e) | M (e) s’arrête}. Une machine de Turing qui déciderait
de L serait en mesure de répondre au problème de l’arrêt, or un tel problème est indécidable, donc L est indécidable.
En revanche, L est reconnaissable. En effet, n’importe quelle machine
universelle permet de reconnaître L, en simulant l’exécution de M (e). Si
l’exécution s’arrête, alors la machine universelle accepte le mot.
Exercice 5
Fermeture des langages
Soient A et B des langages décidables.
1. Montrer que A ∪ B, A ∩ B, A\B, AB, A∗ sont décidables.
2. Existe-t-il un langage fini indécidable ?
3. Soient C, D des langages reconnaissables. Est-ce que C\D est un langage
reconnaissable ?
Corrigé
1. Soit DA un décideur de A, DB un décideur de B. Pour chacune des sousquestions, on va construire un décideur du langage en fonction de DA et
DB .
A ∪ B Pour une entrée e, on simule l’exécution de DA (e). Si c’est accepté,
on accepte. Sinon, on retourne DB (e).
A ∩ B Pour une entrée e, on simule l’exécution de DA (e). Si c’est refusé, on
refuse. Sinon, on retourne DB (e).
A\B Pour une entrée e, on simule l’exécution de DA (e). Si c’est refusé, on
refuse. Sinon, on retourne la négation de DB (e).
5
AB Il faut créer une machine qui va séparer en deux, de façon nondéterministique, le mot e donné en entrée : e = xy (toutes les possibilités pour x et y seront créées, ce qui est faisable en temps fini car
x est de taille finie). On donne ensuite x à un décideur de A et y à
un décideur de B.
A∗ Remarquons que par généralisation de la question précédente, n’importe
quel langage An est décidable, pour tout entier n. Pour décider de
l’appartenance d’un mot à A∗ , on décide si l’entrée appartient à A,
puis si l’entrée appartient à A2 , puis si l’entrée appartient à A3 , etc.
Si l’entrée est de taille n, il n’y a pas besoin d’aller plus loin que
l’appartenance à An , donc le test finit toujours.
2. Non. Étant donné un langage fini, il est immédiat de créer une machine
de Turing qui possède les mots "codés en dur" dans ses états. Une démonstration plus formelle consiste à dire que tout langage Li = {wi } composé
d’un seul mot wi est décidable, et que l’union finie de langages décidable
est décidable.
3. Question très semblable à la question 4.4. Soit C = Σ∗ le langage de
l’ensemble des mots, et soit D l’ensemble des couples (M, e) tels que M (e)
s’arrête. C et D sont reconnaissables (C est reconnaissable par une machine qui accepte tout, D est reconnaissable par toute machine universelle),
or C\D = D n’est pas reconnaissable, car D est indécidable d’après le
théorème de l’arrêt.
Exercice 6
Complexité P et NP
On considère un langage dont toute instance de taille n est décidée en temps
O(f (n)) par une machine de Turing non-déterministe.
Montrer qu’il existe une machine de Turing déterministe qui peut décider de
l’appartenance au langage de tout mot de taille n en temps 2O(f (n)) .
Corrigé
On rappelle comment déterminiser une machine de Turing : on simule, en
parallèle, l’exécution de toutes les branches non-déterministes.
Soit une machine de Turing non-déterministe qui décide du langage. Au
cours d’une transition, le nombre de transitions non-déterministes parallèles est
bornée par un entier M , qui dépend du nombre d’états de la machine et de la
taille de l’alphabet. Notamment, M ne dépend pas de la taille de l’entrée.
On suppose que la machine non-déterministe finit son calcul en O(f (n)),
pour toute entrée de taille n. Alors cette machine non-déterministe effectue
au maximum O(f (n)) opérations, et à chaque étape, choisira parmi au plus M
choix non-déterministes. Ainsi, notre machine déterministe, qui simulera toutes
6
les branches possibles, lancera au maximum M O(f (n)) simulations de machines
de Turing.
Considérons le retour de la machine non-déterministe :
• Soit elle rejette l’entrée (en moins de O(f (n))), ce qui veut dire que toutes
les branches non-déterministes ont rejeté l’entrée en moins de O(f (n))
• Soit elle accepte l’entrée (en moins de O(f (n))), ce qui veut dire qu’une
branche accepte l’entrée en moins de O(f (n)).
Dans les deux cas, dans la machine de Turing déterministe, chaque simulation sera exécutée en moins de O(f (n)) : soit toutes les simulations rejettent,
soit une simulation accepte (et on arrête toutes les autres simulations).
Comme il y a au plus M O(f (n)) simulations et que chaque simulation dure au
plus O(f (n)), notre machine de Turing déterministe s’arrêtera en un temps maximum de O(f (n))×M O(f (n)) = M logM O(f (n)) ×M O(f (n)) = M O(f (n))+logM (O(f (n))) =
M O(f (n)) = 2log2 (M )O(f (n)) = 2O(f (n)) .
Note : il faudrait techniquement montrer que la machine de Turing universelle utilisée pour les calculs ne rajoute pas de complexité supérieure à 2O(f (n)) .
En pratique, on peut construire une machine de Turing universelle dont le temps
d’exécution est un facteur polynomial du temps d’éxécution de la machine donnée en entrée.
Exercice 7
Démonstration du théorème de Rice
On se propose ici de prouver le théorème de Rice. Pour rappel, le théorème
spécifie que toute propriété non triviale sur un langage reconnaissable est indécidable.
On note (wi )i∈N et (Mi )i∈N deux énumérations des mots et des machines de
Turing, et on utilise les deux langages suivants :
K = {w | ∃i ∈ N, w = wi et Mi n’accepte pas wi }
L = {(M, w) | M accepte w}
1. Montrer que K est indécidable.
2. En utilisant la question précédente, montrer que L est indécidable.
On considère à présent une propriété P non triviale. On suppose que le langage
vide ne vérifie pas P . Soit MP une machine de Turing dont le langage vérifie P .
Soit (M, w) un couple (machine,
{ entrée).
MP (x)
si M accepte w
On construit M ′ tel que M ′ (x) =
Refuse x sinon
3. Montrer l’équivalence entre les propositions “le langage reconnu par M ′
vérifie P ” et (M, w) ∈ L.
7
4. Conclure.
5. Comment peut-on conclure si le langage vide vérifie P ?
Corrigé
1. Supposons par l’absurde que K soit décidable. Il existe un décideur DK
qui accepte exactement les mots de K, et refuse les autres. Puisque DK
est une machine de Turing, il existe un entier j tel que DK = Mj .
Regardons si wj appartient à K.
• Si wj ∈ K, alors par définition Mj n’accepte pas wj , ce qui signifie
que DK n’accepte pas wj , donc par définition d’un décideur, que
wj ∈
/ K. Contradiction.
• Si wj ∈
/ K, alors par définition Mj reconnaît wj , donc DK reconnaît
wj , donc par définition wj ∈ K. Contradiction.
On aboutit forcément à une contradiction, donc par l’absurde K n’est pas
décidable.
2. Supposons que L soit décidable. Alors il existe un décideur DL qui décide
en temps fini si M accepte w, pour tous M et w. En particulier, ∀i, DL
décide en temps fini si Mi accepte wi , donc la négation de DL est un
décideur pour K. Or K est indécidable, contradition.
Donc L est indécidable.
3.
⇒ Si (M, w) ∈ L, alors les mots acceptés par M’ sont les mots acceptés
par MP , donc le langage de M ′ vérifie P .
⇐ Si le langage de M ′ vérifie P , alors E = {x | M ′ accepte x} vérifie P .
Or le langage vide ne vérifie pas P , donc E est non vide, donc il existe
au moins un x accepté par M ′ , donc nécessairement M accepte w,
donc (M, w) ∈ L.
4. Comme L est indécidable, le problème “Est-ce que le langage de M ′ vérifie
P ” est indécidable.
5. Il suffit de reprendre le raisonnement avec P , car P est non-trivial. Puisque
P est indécidable, alors P est indécidable (d’après la question 2 de l’exercice
4).
8
Exercice 8
Machine de Turing universelle à un
état
Shannon a prouvé en 1956 qu’il existe des machines de Turing universelles à
deux états, mais aucune machine de Turing universelle à un état. Cet exercice
a pour but de démontrer le second résultat.
On suppose qu’il existe une machine de Turing universelle à un état. Notamment, on peut programmer cette machine
les décimales
√
√ pour qu’elle écrire toutes
d’un nombre calculable, par exemple 2. On rappelle que 2 est un nombre
irrationnel, donc possède une infinité de décimales qui ne se répètent jamais,
mais est néanmoins calculable.
On suppose que la machine dispose d’un ruban semi-infini (équivalent au
ruban infini). On suppose que le ruban possède initialement les données EI sur
le début du ruban. Les cellules suivantes sont initialisées à ⊥ (vide). On appelle
la première cellule vide c1 , la suivante c2 , etc.
Initialement, la tête√de lecture est sur c1 . On suppose que la machine va
écrire les décimales de 2 dans les cellules c1 . . . cn . . . .
Pour notre analyse, on compte le nombre de fois où la tête de lecture passe
la frontière EI/c1 en se déplaçant vers la droite (D1 ) et en se déplaçant vers la
gauche (G1 ). De même, D2 /G2 compte les passages entre c1 /c2 , etc pour toutes
les variables Di , Gi .
On récapitule notre construction dans le schéma ci-dessous.
G1
G2
⊥
EI
D1
...
⊥
c1
c2
D2
1. Montrer que si l’ensemble√des cellules lues par la machine est borné, alors
elle ne peut pas calculer 2.
2. Montrer que G1 ∈ {D1 , D1 + 1}. Montrer que ∀i ≥ 2, Gi ∈ {Di , Di − 1}.
3. Supposons que G1 > D1 . Montrer que la machine n’écrit que sur un
nombre fini de cellules.
4. Supposons que G1 = D1 = ∞.
(a) En supposant que la machine écrit sur une infinité de cellules, montrer
que chaque cellule (sauf une quantité finie) est lue une infinité de fois.
(b) Montrer que dans le cas d’une machine de Turing à un état, la suite
des valeurs contenue dans une cellule réécrite infiniment souvent est
soit stationnaire, soit périodique.
9
(c) En supposant qu’une cellule vide converge vers une valeur stationnaire, montrer que toutes les cellules vides convergent vers la même
valeur
stationnaire. Montrer qu’un tel état final ne peut représenter
√
2.
(d) Montrer qu’une machine dont toutes les cellules sauf une quantité
√
finie sont soit stationnaires soit périodique ne peut pas calculer 2.
√
Conclure que si G1 = D1 = ∞, la machine ne peut pas calculer 2.
5. Supposons que G1 = D1 ̸= ∞.
(a) Supposons que G2 < G1 = D1 . Montrer que la tête de lecture finit
"piégée" dans c1 , c’est-à-dire finit par y rentrer et √
n’en plus sortir.
Conclure que la machine ne peut alors pas calculer 2.
(b) Supposons que G2 = G1 .
i. Montrer que si D2 = 0, la machine ne peut pas calculer
√
2.
Si D2 ̸= 0, on reprend la même étude depuis (1), mais en considérant
c2 comme notre cellule de référence.
On peut se rendre compte qu’on finit systématiquement
par prouver
√
que la machine ne peut pas calculer 2 sauf si ∃N, ∀i, N = Gi =
Di ̸= ∞.
ii. Montrer que l’existence
√ d’un tel N implique que notre machine
ne peut pas calculer 2.
iii. Montrer que si un tel N existe, alors chaque cellule est lue (et
écrite) 2N fois par la tête de lecture.
iv. Montrer qu’alors toutes les cellules ci ont la même valeur finale
et conclure.
10
