corrige exercices

TD machines de Turing
Exercice 1 Analyse d’une machine de Turing
On donne le tableau suivant :
Symbole
Etat 0 1 ⊥
q0, I (q0,⊥,→) (q1,⊥,→)–
q1–(q1,⊥,→) (q2,⊥,→)
q2, F – – –
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é
1.
q0
start q1q2
1/⊥,→
0/⊥,→
⊥/⊥,→
1/⊥,→
Cette machine reconnaît le langage 0∗1+.
2. q0001110 ⊢ ⊥q001110 ⊢ ⊥⊥q01110 ⊢ ⊥⊥⊥q1110 ⊢ ⊥⊥⊥⊥q110 ⊢ ⊥⊥⊥⊥⊥q10⊢
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.
q0
start q1
q2
q3
∗/∗,→
⊥/⊥,←
9/0,←
0−8/1−9,→
⊥/1,←
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.
q0
start
q1
q4
q2
0/X, →
X/X, →
0/0,→
X/X, →
1/X, ←
1/X, →
1/1,→
X/X, →
0/X, ←
0/0,←
1/1,←
X/X, ←
⊥/⊥,→
Ici */* signifie "tout ce qui est 0 ou 1"
2

3.
q0
start
q1q2
q3
q4q5
0/X, →
∗/∗,→X/X, ←
⊥/⊥,←
0/X, ←
∗/∗,←
X/X, →
1/X, →
∗/∗,→
X/X, ←
⊥/⊥,←
1/X, ←
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 ma-
chines 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

est de rajouter une transition. Ainsi, q1q2
A/B, ∅
peut être simulé par
q1q′
1q2
A/B, ← ∗/∗,→
.
Exercice 4 Reconnaisseur et décideur
On appelle reconnaisseur d’un langage Lune machine de Turing qui accepte
exactement les mots de L.Lest alors dit reconnaissable, ou récursivement
énumérable et on note L ∈ RE.
On appelle décideur d’un langage Lune machine de Turing qui accepte
exactement les mots de L, et qui rejette les autres. Lest 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 Lest décidable, est-ce que son complémentaire Lest décidable ?
3. Montrer que Lest décidable ⇔ L et Lsont reconnaissables.
4. Si Lest reconnaissable, est-ce que Lest 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 Dun décideur de L. Construisons la machine Dqui, pour une
entrée e, simule l’exécution de Dsur e. Si Dfinit par accepter e, alors
Drefuse e; et si Drefuse e, alors Daccepte e. Il est évident que Dse
termine toujours, et reconnaît L, donc Ddécide L.
3. ⇒Supposons que Lest décidable. Il est immédiat que Lest recon-
naissable, car un décideur de Lest un reconnaisseur de L. De plus
d’après la question 2, Lest également décidable donc Lest également
reconnaissable.
4

⇐Supposons que Let Lsont reconnaissables. Il existe un reconnaisseur
Rde Let un reconnaisseur Rde L.
Soit eun 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 Dqui, sur une entrée e, simule
l’exécution en parallèle de R(e)et R(e). Si Raccepte le mot, alors
Daccepte le mot, et si Raccepte le mot, alors Drefuse le mot.
Par définition de Ret R, il est nécessaire que D(e)s’arrête en un
temps fini. Par ailleurs, il est immédiat que Dreconnaît L, donc D
décide L.
4. D’après la question 3, si Let Lsont reconnaissables, alors Lest 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 Lserait en mesure de répondre au problème de l’arrêt, or un tel prob-
lème est indécidable, donc Lest indécidable.
En revanche, Lest 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 Aet Bdes 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\Dest un langage
reconnaissable ?
Corrigé
1. Soit DAun décideur de A,DBun décideur de B. Pour chacune des sous-
questions, on va construire un décideur du langage en fonction de DAet
DB.
A∪BPour une entrée e, on simule l’exécution de DA(e). Si c’est accepté,
on accepte. Sinon, on retourne DB(e).
A∩BPour une entrée e, on simule l’exécution de DA(e). Si c’est refusé, on
refuse. Sinon, on retourne DB(e).
A\BPour 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