Code et machine universelle

Un ordinateur peut être programmé pour effectuer différentes tâches, alors qu’il semble à première vue qu’une machine de Turing est spécifique à un problème particulier. Nous allons voir qu’il n’en est rien et qu’il existe une machineuniverselle capable d’exécuter un programme qu’on lui fournit en entrée (selon le vocabulaire informatique, cette ma-chine est donc un interpréteur). L’existence d’une telle mama-chine capable d’exécuter tout

« programme » qu’on lui fournit en entrée n’a rien d’évident a priori, et il s’agit d’une des particularités cruciales des machines de Turing (et de nos ordinateurs bien sûr). Cette notion apparaît déjà dans l’article fondateur de Turing [Tur37].

Une telle machine prend en entrée un « programme » et nous devons donc d’abord voir comment coder ce programme, qui n’est rien d’autre que la description d’une machine de Turing. Nous allons donc définir le code d’une machine de Turing : il s’agit essentiel-lement de coder les alphabets d’entrée et de sortie, l’ensemble des états et la fonction de transition.

1-L Définition (code d’une machine de Turing)

SoitM= (Σ,Γ,B,Q,q₀,q_a,q_r,δ)une machine de Turing àk rubans. Nous supposerons sans perte de généralité queΣ={1, 2, . . . ,|Σ|} ⊂N,Γ ={1, 2, . . . ,|Γ|} ⊂NetB=|Γ|, et queQ={1, 2, . . . ,|Q|} ⊂N,q₀=1, q_a=|Q| −1etq_r =|Q|(ainsi, la seule donnée des tailles deΣ,Γ etQnous permettra de connaîtreΣ,Γ,B,Q,q₀,q_aetq_r).

Pour décrire la machineM, on spécifiera en unaire le nombrek de rubans ainsi que|Σ|,

|Γ|et|Q|, tandis que la fonction de transitionδsera codée par un motu_δdonnant toutes les transitions possibles.

1.2. La machine de Turing 15

Plus précisément, lecodedeM est le mot〈M〉=1^k01^|Σ|01^|Γ|01^|Q|0u_δ sur l’alphabet{0, 1}, oùu_δ est défini comme suit :

– tout d’abord, pour tout élément s = (q,γ₁, . . . ,γ_k−1) ∈ (Q\ {q_a,q_r})×Γ^k−1, si δ(s) = (r,γ₂^′, . . . ,γ_k^′,d₁, . . . ,d_k)alors on code la transition par le mot

u_s=1^q01^γ101^γ2. . . 01^γk−101^r01^γ2′01^γ3′. . . 01^γk′01^d1′01^d2′. . . 01^dk′ oùd_i^′=0sid_i=G,1sid_i=Set2sid_i=D;

– on notes₁, . . . ,s_t les éléments de(Q\{q_a,q_r})×Γ^k−1(disons dans l’ordre lexicogra-phique, mais peu importe) ;

– on définit alorsu_δ=u_s

10u_s

20 . . . 0u_s

t qui encode toutes les transitions possibles.

Nous avons donné une définition précise du code〈M〉d’une machine de TuringMmais il suffit de retenir qu’un tel code est simple et découle directement de la définition deM. Il y aurait bien d’autres codes possibles, notamment faisant intervenir des codages binaires plus compacts — mais cela n’est pas nécessaire. Il faut simplement que le code, en tant que mot sur{0, 1}, soit manipulable aisément sur le ruban d’une machine de Turing.

Afin de préparer la construction d’une machine universelle ci-dessous, nous allons voir que l’on peut réduire la taille de l’alphabet sans trop nuire à l’efficacité de la machine : en effet, on peut construire une machine « équivalente » sur un alphabet restreint. Nous devons d’abord définir la notion de machines équivalentes : nous dirons qu’une machine en simule une autre si elle a le même comportement à un codage près des entrées/sorties.

Pour coder les entrées/sorties, nous utiliserons un morphisme, c’est-à-dire une application φ:Σ^⋆→Σ^′⋆ telle queφ(uv) =φ(u)φ(v)(en d’autres termes, il s’agit de coder chaque lettre deΣpar un mot surΣ^′, et l’image d’un mot deΣest alors la concaténation des images de ses lettres). Un morphismeφpréserve les longueurssi∀u,v∈Σ,|φ(u)|=|φ(v)|: cette notion est utile pour inverser aisément le morphisme (décoder).

1-M Définition (simulation)

SoitM une machine de Turing d’alphabets d’entréeΣet de travailΓ. Une machineM^′ (d’alphabets d’entrée Σ^′ et de travailΓ^′) simuleM s’il existe un morphisme « d’entrée » φ:Σ^⋆→Σ^′⋆et un morphisme « de sortie »injectif et préservant les longueursψ:Γ^⋆→Γ^′⋆

tels que, pour toute entréex∈Σ^⋆,M(x)s’arrête ssiM^′(φ(x))s’arrête, et dans ce cas : – M(x)accepte ssiM^′(φ(x))accepte (même acceptation),

– et de plusM(x) =ψ⁻¹(M^′(φ(x)))(même résultat de calcul).

Bien que la simulation soit une notion concernant les machines, sixest un mot, on dira par abus de langage que le calcul deM^′ surφ(x)simule le calcul deM sur x (ou plus simplement queM^′(φ(x))simuleM(x)).

16 Chapitre 1. Le modèle de calcul 1-N Remarque Le lemme suivant montre qu’on peut se ramener à des machines sur l’alphabet binaire (le symbole blanc en plus bien sûr). On pourrait se contenter de l’idée de la démonstration esquissée ci-dessous, mais la démonstration relativement for-melle que nous proposons ensuite poursuit deux objectifs : d’abord, montrer que l’on peut manipuler formellement les machines de Turing, puis illustrer par la complexité des détails nécessaires comparativement à la simplicité des idées qu’il est inutile de le faire une fois qu’on a appréhendé les capacités des machines de Turing. Par la suite, nous n’en-trerons plus dans tant de détails lorsqu’il s’agira de manipuler les machines de Turing car ils obscurcissent les idées sous-jacentes.

1-O Lemme (réduction de l’alphabet)

SiM= (Σ,Γ,B,Q,q₀,q_a,q_r,δ)est une machine de Turing, alors il existe une machineM^′ d’alphabet d’entréeΣ^′={0, 1}et d’alphabet de travailΓ^′={0, 1,B}, qui simuleM (avec un morphisme d’entréeφ:Σ^⋆→Σ^′⋆) et telle que :

– siM(x)s’arrête en tempstalorsM^′(φ(x))s’arrête en temps⩽6tlog|Γ|; – siM(x)utilise un espaces, alorsM^′(φ(x))utilise un espace⩽2slog|Γ|.

De plus, les deux machines ont le même nombrek de rubans et il existe une machine de Turing fixée (indépendante deM) qui calcule le code deM^′à partir du code deM. Idée de la démonstration Chaque lettre de l’alphabetΓ sera codée en binaire et

occu-peralog|Γ|cases sur les rubans deM^′(voir la figure1.4). La machineM^′considérera alors ces blocs de cases comme une seule lettre deΓ et pourra effectuer la transition deM qui convient. Les têtes effectuent à la volée les opérations de codage/décodage qui ne nécessitent qu’une mémoire finie puisque le nombre de lettres est fini.

a b c d B

0 0 0 1 1 0 1 1 B B

Figure 1.4 – Changement de l’alphabet{a,b,c,d,B}en{0, 1,B}sur un ruban : chaque lettre est codée sur deux bits.

Démonstration Soitγ⁽⁰⁾, . . . ,γ^(|Γ|−2),B les éléments deΓ etψ:Γ^⋆→Γ^′⋆le morphisme qui àγ⁽ⁱ⁾ associe le code binaire dei surb =⌈log(|Γ| −1)⌉bits (en ajoutant des zéros en tête si nécessaire) et qui àB∈Γ associeB^b ∈Γ^′⋆ : ce sera le morphisme de sortie,

1.2. La machine de Turing 17 tandis que le morphisme d’entréeφ:Σ^⋆→Σ^′⋆est simplement la restriction deψàΣ (rappelons en effet queΣ⊂Γ).

La machineM^′a le même nombrekde rubans queMet chaque ruban aura le même rôle que dans M (c’est-à-dire qu’on fait une simulation ruban par ruban). Chaque ruban deM^′ est divisé mentalement en « blocs » de b cases correspondant chacun au code des lettres se trouvant sur les rubans deM. Pour simuler une transition de M, les têtes de M^′ se trouveront sur la première case des blocs correspondant aux cases lues parM, elles liront ce bloc de la gauche vers la droite en retenant le mot lu au fur et à mesure, puis reviendront en début de bloc en écrivant le nouveau mot (correspondant à la nouvelle lettre deΓ à écrire) de la droite vers la gauche, et enfin se déplaceront éventuellement à gauche ou à droite deb cases pour se positionner en début du nouveau bloc et simuler la transition suivante.

Lors d’un déplacement à droite debcases à la fin de la simulation d’une transition, il faut prêter attention au ruban de sortie en écriture seule. Sur ce ruban comme sur les autres, lorsqu’on les survole on aimerait laisser inchangées les cases du bloc que l’on vient de traiter, mais on ne peut pas les lire et on doit quand même écrire quelque chose à la place (par définition, toute transition doit écrire un symbole dans la case où se trouve la tête). Pour remédier à ce problème, dans les états de déplacement on indiquera ce que la tête de sortie doit écrire.

Une étape deM sera alors simulée par au plus3b−2étapes deM^′. Il nous faudra de nombreux états supplémentaires pour retenir le mot à lire ou à écrire dans le bloc et pour les déplacements. Ainsi, à chaque étatq deM, on associera les états suivants :

– l’état de lecture q_lec^{u1,...,uk−1} (pour tous mots u₁, . . . ,u_k−1 ∈Γ^′⋆ de taille⩽ b−1) signifie que les préfixes des blocs lus jusqu’à présent de gauche à droite sur les k−1premiers rubans (le ruban de sortie est en écriture seule) sontu₁, . . . ,u_k−1; – l’état d’écritureqecr^u2,...,uk pour tous motsu₂, . . . ,u_k∈Γ^′⋆de taille⩽b−1signifie qu’il faut encore écrire, de droite à gauche, les préfixesu₂, . . . ,u_k dans les blocs desk−1derniers rubans (le ruban d’entrée est en lecture seule) ;

– l’état de déplacementq_dep^i1,...,ik;x pour−b ⩽i_j⩽b etx∈Γ^′⋆(|x|⩽b−1) signifie qu’il faut encore se déplacer de|i_j|cases (à gauche sii_j<0et à droite sinon) et que le mot qu’il reste à écrire sur le ruban de sortie dans l’ordre des déplacements estx;

– on ajoute un état d’acceptation noté q_acc et un état de rejet noté q_rej (à ne pas confondre avec les étatsq_aetq_r deM) ;

– enfin, l’état initial est r_lec^ε,...,ε(oùεdésigne le mot vide), pourr=q₀l’état initial deM.

Les transitions deM^′se déduisent alors aisément :

– pour un état de lecture, tant qu’on n’est pas à la fin du bloc (|u_i|<b−1), on lit la case courante qui complète le préfixe et on se déplace à droite :

δ^′(q_lec^{u1,...,uk−1},(a₁, . . . ,a_k−1)) = (q_lec^{u1a1,...,uk−1ak−1},(a₂, . . . ,a_k−1,B),(D, . . . ,D));

18 Chapitre 1. Le modèle de calcul – lorsqu’on arrive en fin de bloc (c’est-à-dire|u_i|=b−1), il faut effectuer le

chan-gement d’état correspondant à la transition deMet commencer à écrire de droite à gauche le nouveau mot sur le bloc.

Plus précisément, si on noteδ(q,(γ₁, . . . ,γ_k−1)) = (r,(γ₂^′, . . . ,γ_k^′),(d₁, . . . ,d_k)), et ψ(γ_i) =u_ia_i (pour|u_i|=b−1eta_i ∈Γ^′) etψ(γ_i^′) =v_ib_i (pour|v_i|=b−1et b_i∈Γ^′) alors :

δ^′(q_lec^{u1,...,uk−1},(a₁, . . . ,a_k−1)) = (recr^v2,...,vk,(b₂, . . . ,b_k),(G, . . . ,G));

– pour un état d’écriture, tant qu’on n’est pas au début du bloc, on écrit la dernière lettreb_i dans la case courante :

δ^′(recr^{v2b2,...,vkbk},(a₁, . . . ,a_k−1)) = (recr^v2,...,vk,(b₂, . . . ,b_k),(G, . . . ,G));

– lorsqu’on arrive en début de bloc, si r est un état terminal deM alors on passe dans l’étatq_acc ouq_rej selon que r est acceptant ou rejetant : ainsi, si b₂, . . . ,b_k sont des symboles deΓ^′alors

δ^′(recr^b2,...,bk,(a₁, . . . ,a_k−1)) = (q_acc,(b₂, . . . ,b_k),(S, . . . ,S)) sir=q_a(et de manière similaire sir=q_r).

Si en revancher n’est pas terminal, alors on écrit la lettre correspondante et on passe dans un état de déplacement, en effectuant le premier mouvement de ce déplacement.

Ainsi, si comme précédemmentδ(q,(γ₁, . . . ,γ_k−1)) = (r,(γ₂^′, . . . ,γ_k^′),(d₁, . . . ,d_k)), alors on définit :

◦ i_j=−b+1sid_j=G,

◦ i_j=0sid_j=S,

◦ i_j=b−1sid_j=D,

et pour gérer le ruban de sortie, siψ(γ_k^′) =ψ₁. . .ψ_b :

◦ sid_k=Galorsx=B^b−1(on écrira des blancs en allant vers la gauche),

◦ sid_k=Salorsx=ψ₁^b−1(il faut toujours écrireψ₁car on reste sur place),

◦ sid_k=Dalorsx=ψ₂. . .ψ_b (il faut écrireψ(γ_k^′)car on va à droite).

On a alors

δ^′(recr^b2,...,bk,(a₁, . . . ,a_k−1)) = (r_dep^i1,...,ik;x,(b₂, . . . ,b_k),(d₁, . . . ,d_k));

– pour un état de déplacement, il s’agit de se déplacer d’un bloc vers la gauche ou la droite (b cases) ou de rester sur place.

Si toutes les têtes sont arrivées à destination (début du bloc pour la transition suivante), c’est-à-dire sii_j=0pour tout jet x=ε, alors on passe dans l’état de lecture en effectuant le premier déplacement à droite :

δ^′(r_dep^0,...,0;ε,(a₁, . . . ,a_k−1)) = (r_lec^{a1,...,ak−1},(a₂, . . . ,a_k−1,B),(D, . . . ,D)).

1.2. La machine de Turing 19 Si les têtes sont encore en route, on continue leur trajet : on définit

◦ d_j=Geti^′_j=i_j+1sii_j<0,

◦ d_j=Seti^′_j=0sii_j=0,

◦ d_j=D eti_j^′=i_j−1sii_j>0, et alors

δ^′(r_dep^{i1,...,ik;x1...xm},(a₁, . . . ,a_k−1)) = (r_dep^{i1′,...,ik′;x2...xm},(a₂, . . . ,a_k−1,x₁),(d₁, . . . ,d_k)).

Chaque étape deMest ainsi simulée par3b−2étapes deM^′(b−1étapes pour lire le bloc de gauche à droite,b−1pour écrire les nouveaux symboles de droite à gauche etb pour se déplacer d’un bloc vers la gauche ou la droite). Puisque

b=⌈log(|Γ| −1)⌉⩽2 log|Γ|,

le temps mis parM^′est⩽6tlog|Γ|. De même, puisque chaque case deMest remplacée parb cases deM^′, l’espace utilisé parM^′est⩽2slog|Γ|.

Nous venons d’écrire explicitement la fonction de transition de M^′ en fonction de celle deM. La machine de Turing, indépendante deM, qui suivrait ces instructions calculerait donc le code deM^′à partir de celui deM. Il serait bien sûr fastidieux mais tout à fait faisable de donner le code d’une telle machine. ⊓⊔

Cette réduction d’alphabet est cruciale pour les machines universelles que nous construi-sons maintenant. En guise d’échauffement, nous propoconstrui-sons l’exercice suivant.

. ^{1-P Exercice}

Montrer qu’une machine de Turing àk>1rubans de travail fonctionnant en temps t peut être simulée par une machine de Turing à un seul ruban de travail fonction-nant en tempsO(t²). D’où vient la perte de temps ?

Indication : cf. figure1.6.

Dans la plupart des cas, nous n’avons pas besoin d’une machine universelle très perfor-mante : c’est pourquoi nous en présentons d’abord une dont le principe est simple et qui est capable de simuler une machine avec une perte quadratique en temps. Nous ne donnerons que l’idée de la preuve car nous verrons ensuite une machine plus efficace : on simulera enO(tlogt)étapes une machine fonctionnant en tempst.

1-Q Proposition (machine universelle simple mais non optimale)

Il existe une machineU à 5 rubans, sur l’alphabet d’entréeΣ_U ={0, 1}et l’alphabet de travailΓ_U={0, 1,B}, telle que pour toute machineM sur les alphabetsΣ_M etΓ_M :

20 Chapitre 1. Le modèle de calcul

– il existe un morphismeφ_M:Σ^⋆_M →Σ^⋆_U tel que pour tout mot x∈Σ^⋆_M, le calcul de la machineU sur le couple(〈M〉,φ_M(x)), notéU(〈M〉,φ_M(x)), simuleM(x); – il existe une constanteα_M telle que pour toutx∈Σ^⋆_M, siM(x)s’arrête en tempst

et utilise un espaces, alorsU(〈M〉,φ_M(x))s’arrête en temps⩽α_M(1+s t)et utilise un espace⩽α_M(1+s).

Idée de la démonstration Le lemme1-Opermet de travailler non surM directement, mais sur la machine équivalente M^′ ayant pour alphabetΓ_U ={0, 1,B} (via un mor-phismeφ_M) : il suffit de calculer dans un premier temps le code de la nouvelle machine.

En outre, par commodité, on peut d’abord construire une machine universelleU^′sur un alphabet plus grand (utilisant, par exemple, des délimiteurs ou des marqueurs), puis se ramener à l’alphabetΓ_U par le lemme1-O.

(ruban de sortie) sortie deM^′

(ruban de travail 3) état des têtes et contenu des cases lues

(ruban de travail 2) contenu des rubans deM^′

(ruban de travail 1)

〈M^′〉

(ruban d’entrée)

〈M〉,φ_M(x)

Figure 1.5 – Machine universelle à 5 rubans simulantM(x).

Voici le principe de notre machine universelleU^′(cf. figure1.5) :

– le ruban d’entrée sert à lire le motxencodé sur l’alphabetΓ_Usous la formeφ_M(x): il se comportera comme le ruban d’entrée deM;

– sur le premier ruban de travail, on a calculé le code de la machineM^′équivalente àMmais travaillant sur l’alphabetΓ_U;

– sur le deuxième ruban de travail, on encode les(k−2)rubans de travail deM^′ en utilisant des blocs consécutifs de(k−2)cases (cf. figure1.6) et on conserve la position de chaque tête par un marqueur spécial (⋆sur la figure, en travaillant donc sur l’alphabetΓ_U∪(Γ_U× {⋆})) : tout se passe comme si l’on disposait de tous les rubans de travail deM^′« en parallèle » sur un unique ruban deU; – à chaque instant,U^′conserve sur son troisième ruban de travail l’état des têtes

deM^′;

– le ruban de sortie se comporte comme celui deM^′;

– pour simuler une étape de calcul deM^′, la machineU^′parcourt son deuxième

1.2. La machine de Turing 21

0 0 1 0 1 1 1

0 0 0 0 0

1 1

1 1 0 1 0 0 1

1 1 0 1 0 0 0 0 1 1 0 0 0 0 1 0 1 1 1 0

⋆ ⋆ ⋆

tête 3 tête 1 tête 2

ruban 2

ruban 1 ruban 3

Figure 1.6 – Encoder 3 rubans sur un seul.

ruban de travail à la recherche des têtes deM^′, recopie sur le troisième ruban de travail le contenu des cases pointées par les têtes deM^′:U^′dispose maintenant de l’état deM^′et du contenu des cases sous les têtes, donc elle va lire dans le code de M^′la transition à effectuer et effectue cette transition en changeant l’état inscrit sur le troisième ruban de travail, en modifiant le contenu des cases concernées et en déplaçant le symbole de repérage des têtes deM^′si nécessaire.

Pour simuler chaque transition de M^′, la machine U^′ fait deux allers-retours sur le ruban codant les rubans de travail deM^′, ce qui coûte un temps linéaire en le nombre maximal de cases utilisées. Puisque M^′ utilise au plus 2slog|Γ_M| cases, on obtient un temps totalO(s tlog|Γ_M|)pour simuler les t étapes. À ce temps de simulation il convient d’ajouter le temps de calcul du code deM^′(une constante dépendant deM), d’où un coûtα_M(s t+1).

De même pour l’espace, siM ak rubans, l’espace utilisé par notre machine est une constante (dépendant de|〈M〉|) sur le premier ruban de travail,O((k−2)slog|Γ_M|)sur le deuxième et une constante (dépendant de|〈M〉|) sur le troisième : on obtient au

total un espaceα_M(s+1). ⊓⊔

1-R Remarque Puisqu’une machine fonctionnant en tempst ne peut pas utiliser un espace supérieur àt, la machine universelle de la proposition précédente fonctionne en temps⩽α_M(1+t²), c’est-à-direO(t²).

Nous allons maintenant décrire une machine universelle dont le principe est plus com-pliqué mais qui est capable de simuler une machine avec une perte en temps seulement logarithmique. Cette construction est due à Hennie et Stearns [HS66].

1-S Théorème (machine universelle avec perte de temps logarithmique)

Il existe une machineU à 6 rubans, sur l’alphabet d’entréeΣ_U ={0, 1}et l’alphabet de travailΓ_U={0, 1,B}, telle que pour toute machineM sur les alphabetsΣ_M etΓ_M :

22 Chapitre 1. Le modèle de calcul

Idée de la démonstration Nous ne pouvons plus nous permettre comme précédem-ment de parcourir tous les rubans à chaque étape pour trouver la position des têtes.

L’idée est d’effectuer les calculs autour de la position0et de ramener à cet emplacement l’information nécessaire contenue sur les rubans : dès qu’on doit lire une nouvelle case, on va chercher le contenu de la case et tout son voisinage pour le rapatrier autour de la case0. L’intérêt de ramener également le voisinage est de limiter le nombre de tels rapatriements (car ceux-ci prennent du temps) : si l’on a ramené un voisinage de taille m, alors on peut ensuite effectuer au moins m/2 transitions sans rapatrier d’autres blocs⁵.

En adaptant la taille du voisinage à chaque transition, on peut simuler une étape deM parlogt étapes deU en moyenne: il s’agit d’un coût amorti sur l’ensemble du calcul, certaines transitions requérant plus de temps pour rapatrier de grands blocs, tandis que d’autres ne nécessitent qu’un temps constant.

Démonstration

Description informelle Tous les rubans de travail deM seront regroupés sur un seul ruban de travail deU en les intercalant comme à la figure1.6, de sorte qu’on peut les traiter les uns après les autres. Le contenu de chaque ruban de travail deMse retrouve sur le ruban deU dans le même ordre, mais un symbole particulier□peut venir s’in-tercaler entre les cases (ce qui nous permettra de gérer le rapatriement de blocs). La simulation de toute étape deM s’effectue d’abord en déplaçant un groupe contigu de cases afin d’amener en position0la case du ruban deM qui doit être lue : pour cela, on recopie ces cases autour de la position0et on efface les cases originales grâce au symbole□ (on dira qu’on « rapatrie un bloc »). On est ensuite à même d’effectuer la transition puisqu’on dispose de la bonne case à lire. Pour éviter de perdre trop de temps dans les rapatriements, plus la case à ramener est loin, plus on rapatrie un bloc de grande taille autour d’elle : cela permet d’avoir autour de la position0 l’informa-tion nécessaire pour effectuer un grand nombre de transil’informa-tions sans aller chercher une nouvelle case lointaine.

Le ruban est virtuellement découpé en « zones » de plus en plus grandes qui permettent de savoir quels blocs rapatrier. Lorsqu’on rapatrie un bloc, la construction est telle qu’entre ce bloc et la position0il n’y a que des cases contenant le symbole□, de sorte qu’on n’écrase aucun contenu lors du rapatriement. Les zones sont définies de sorte que les blocs de taille m sont à distance O(m) et donc leur déplacement prend un tempsO(m)en utilisant un ruban de travail auxiliaire : une fois leur rapatriement assuré, on montre qu’il est alors possible de simuler O(m) transitions sans avoir à

5. Attention, il s’agit seulement de l’intuition, ce ne sera pas exactement ce qui se passera dans la démons-tration car à chaque étape on rapatriera des blocs, petits la plupart du temps.

1.2. La machine de Turing 23 rapatrier un nouveau bloc si grand, ce qui permet d’obtenir en analyse amortie la complexité de l’énoncé.

Passons maintenant à la démonstration formelle, dans laquelle la gestion des blocs est assez technique.

Alphabet et rubans Le morphismeφ_M sera simplement celui du lemme1-Ocodant l’alphabetΓ_M surΓ_U ={0, 1,B}; la machine travaillant surΓ_U équivalente àM don-née par ce lemme sera notéeM^′. Par commodité, nous aurons besoin d’un symbole supplémentaire□pour représenter une case laissée volontairement vide : nous décri-rons donc une machine U^′ travaillant sur l’alphabet{0, 1,□,B}. Il conviendra alors d’appliquer le lemme1-Opour se ramener à l’alphabetΓ_U.

Dans un premier temps, notre machineU^′calcule le code deM^′à partir de celui deM et l’écrit sur son premier ruban de travail. Comme à la proposition1-Q, le ruban d’en-trée deU^′contenant(〈M〉,φ_M(x))servira à lire le motφ_M(x)et se comportera comme le ruban d’entrée deM^′; le premier ruban de travail deU^′contiendra le code deM^′; le deuxième ruban de travail contiendra le contenu de tous les rubans de travail deM^′; le troisième ruban de travail contiendra l’état des têtes deM^′ (ainsi que d’éventuels compteurs pour délimiter les zones mentionnées après) ; le quatrième ruban de travail servira de zone de stockage temporaire pour copier les blocs à rapatrier ; enfin, le ruban de sortie se comportera comme celui deM^′. En résumé, le rôle des rubans est comme à la figure1.5sauf un ruban de travail supplémentaire pour recopier temporairement les blocs à rapatrier.

Simulation d’une transition Une transition de M^′ sera simulée comme suit : aller chercher sur le deuxième ruban de travail les cases de M^′ à lire et les ramener à la

Simulation d’une transition Une transition de M^′ sera simulée comme suit : aller chercher sur le deuxième ruban de travail les cases de M^′ à lire et les ramener à la

Dans le document COMPLEXITÉ ALGORITHMIQUE (Page 34-47)