IFT-66975
description
Transcript of IFT-66975
![Page 1: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/1.jpg)
IFT-66975
Au delà de NP:hiérarchie polynomiale, EXP,
NEXP
![Page 2: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/2.jpg)
Vers des problèmes plus difficiles
On croit qu’il n’existe pas d’algorithme de temps polynomial pour SAT.
Mais supposons que nous avons accès à un algorithme efficace pour SAT. Quels sont les problèmes qui demeurent difficiles?
![Page 3: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/3.jpg)
Machines à oracle
Une machine de Turing avec oracle L est une m.t. qui peut recevoir en temps unitaire une réponse à toute question “x L?”.
On dénote PL (NPL) la classe des langages qui sont acceptés en temps polynomial (non-déterministe) par une machine avec oracle L. Pour une classe de complexité C, on définit
PC = L C PL
et NPC = L C NPL.
![Page 4: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/4.jpg)
Exemple:
Problème du circuit booléen minimal (MC).
Entrée: un circuit booléen C (avec portes binaires) avec variables booléennes x1, ..., xn et une porte de sortie. Entier k |C|.
Question: existe-t-il un circuit C’ de taille k qui calcule la même fonction que C?
![Page 5: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/5.jpg)
Est-ce que MC P?
Probablement pas.
Appelons SATCIR la variante de SAT où l’on cherche à satisfaire un circuit C plutôt qu’une formule . On a SAT p SATCIR.
On a aussi SATCIR T MCc. En effet, un circuit est insatisfiable ss’il calcule une fonction qui peut être calculé avec une porte qui est la constante 0.
![Page 6: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/6.jpg)
Meilleure borne connue: MC NPNP.
Algorithme: Entrée C; Choisir non déterministement un circuit C’ de
taille k ou moins. Former le circuit C C’. Poser à l’oracle la question “C C’ SATCIR?” Si la réponse est NON alors C et C’ calculent la
même fonction, donc on conclut que C MC et l’algorithme accepte.
Il existe un choix non-déterministe de C’ qui amène l’algo à accepter ssi C, k MC.
![Page 7: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/7.jpg)
Hiérarchie polynomiale
La hiérarchie polynomiale est une suite de classes de complexité définies par récurrence:
0 = 0 = 0 = 1 = P 1 = NP, 1 = co-NP; k = Pk; k = co-k; k+1 = NPk;
PH = k k.
![Page 8: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/8.jpg)
Quelques observations utiles
k = co-k = Pk k+1 k+1
k+1 k+1 k+1.
k = NPk = NPk
k = co-NPk = co-NPk.
k k k = k.
![Page 9: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/9.jpg)
0 = 0 = 0 = 1 = P
1 1 = NP co-NP
2 2
1 = NP 1 = co-NP
1 1 = NP co-NP
2 = PNP
2 2
2 2
3
![Page 10: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/10.jpg)
Définition plus pratique de ces classes grâce à une généralisation des systèmes de preuve utiles pour définir NP.
Théorème: Un langage L est dans k si et seulement s’il existe un langage V P et un polynôme p, tel que
L = {x : y1 y2 y3 ... Qk yk : |yi| p(|x|) et (x,y1, ... ,yk) V}.
(à noter que Qk est si k est impair et si k est pair.)
![Page 11: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/11.jpg)
Exemple de SAT. On sait que SAT 1 = NP.
On peut effectivement voir SAT sous la forme voulue. est satisfiable si et seulement s’il existe des valeurs x1, ..., xn telles que (x1,...,xn) = 1. Étant donné et les valeurs xi on peut vérifier en temps polynomial que (x1,...,xn) = 1.
Point de vue “système de preuve” sur la classe NP. (cf Chapitre 5 de Wegener)
![Page 12: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/12.jpg)
Exemple de MC: On a démontré que MC 2.
C, k MC si et seulement si: il existe un circuit C’ avec |C’| k tel que pour tout choix de valeurs pour les variables booléennes x1, ..., xn on a
C(x1, ..., xn) = C’(x1, ... ,xn).
Étant donné C, C’ et des valeurs xi, on peut en temps polynomial vérifier cette dernière condition.
![Page 13: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/13.jpg)
Démonstration:
Par récurrence sur k. Pour k = 1, on retrouve la caractérisation de NP grâce aux systèmes de preuve.
Supposons que le théorème est vrai pour un certain k-1 et montrons le pour k. Donc montrons qu’il existe un algorithme NPk pour L ssi
L = {x: y1 ... Qk yk |yi| p(|x|) V(x,y1, ...,yk)
![Page 14: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/14.jpg)
Supposons d’abord L NPk. Il existe pour un algo non-déterministe AL avec
temps d’exécution polynomial q utilisant un oracle L’ k. Donc, par récurrence on peut représenter L’ par
L’ = {x: y2 ... Qkyk : V’(x,y2,...,yk)}
avec |yi| p(|x|) et V’ P.
Toutes les questions à l’oracle sont de tailles r(n). Modifions L’ et AL pour que chaque branche non-déterministe pose exactement q(n) questions toutes de longueur r(n).
![Page 15: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/15.jpg)
On a x L ssi AL accepte x. Donc ssi il existe un choix non-déterministe w qui mène à l’acceptation. Sur cette branche, soit b1, ..., bq(n) les questions posées et a1, ..., aq(n) les réponses reçues. On veut donc exprimer qu’un tel w existe avec notre alternation de quantificateurs.
Soit C* l’ensemble des (w,b1, ..., bq(n), a1, ..., aq(n)) tels que
1. la ième question posée est bi lorsque x est l’entrée, w est le choix non-déterministe et les premières questions/réponses sont b1/a1, ..., bi-1/ai-1.
2. x est accepté sur le chemin w.
![Page 16: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/16.jpg)
On a donc que x L ssi il existe c C* tel que les ai sont effectivement les réponses des bi. De plus, C* P car les réponses sont fournies. On a donc
L = {x: c =(w,b1,...,bq,a1, ...,aq): c C* L’(bi) = ai}
On sait que L’(bi) = 1 si
yi2 ... Qkyi
k : V’(bi,yi2,...,yi
k)
et que L’(bi) = 0 si
yi2 ... Qkyi
k: V’(bi, ,yi2,...,yi
k)
![Page 17: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/17.jpg)
On peut combiner ces deux cas. Soit V* le langage qui contient (bi,1, yi
1,...,yik-1) si
(bi,yi1,...,yi
k-1) V’ et (bi,0, yi2,...,yi
k) si (bi,yi
2,...,yik) V’.
On a alorsL’(bi) = ai yi
1 ... Qkyik : V*(bi, ai, yi
1, yi2,...,
yik)
![Page 18: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/18.jpg)
On peut maintenant exprimer L sous la forme désirée.
x LIl existe un c C* avec des
couples questions/réponses valables. (w,b1, ..., bq, a1, ...,aq) L’(bi) = ai
AL(x,w) = 1.
(w,b1, ..., bq, a1, ...,aq,,yi1, ..., yi
k) y1
i ... Qkyk: V*(bi, ai, yi1, yi
2,..., yi
k) AL(x,w) = 1.
![Page 19: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/19.jpg)
Supposons maintenant L = {x: y1 ... Qk yk V(x,y1, ..., yk)}
Soit L’ le langage suivantL’ = {(x,y1): y2 ... Qk(yk) V(x,y1,...,yk)}
Notez que V est calculable en temps polynomial donc par récurrence, L’ k-1.
Reste à montrer que L NPL’.
![Page 20: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/20.jpg)
Algo NPL’ pour L: Entrée x; Choisir non-déterministement y1 tel que |y1|
p(|x|). Poser à l’oracle la question “(x,y1) L’?” Si l’oracle répond non alors accepter x. Si l’oracle répond oui alors rejeter x.
L’algorithme accepte x s’il existe un y1 tel que (x,y1) L’. Donc s’il
y1 ( y2 ... Q’k V (x, y1, ..., yk))
y1 y2 ... Qk yk V(x,y1, ..., yk)Donc si et seulement si x L.
![Page 21: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/21.jpg)
Corollaire: Un langage L est dans k ssi il existe un polynôme p et un langage V P tel que
L = {x : y1 y2 ... Qk yk : |yi| p(|x|) et (x,y1, ... ,yk) V}.
(Ici Q est si k est pair et si k est impair)
![Page 22: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/22.jpg)
Conjecture(s): Pour tout k 1: k k; k k+1; k k k; k k k; k k k+1.
En particulier, on croit P NP co-NP et aussi PNP 2 2.
![Page 23: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/23.jpg)
0 = 0 = 0 = 1 = P
1 1 = NP co-NP
2 2
1 = NP 1 = co-NP
1 1 = NP co-NP
2 = PNP
2 2
2 2
3
![Page 24: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/24.jpg)
Théorème: S’il existe un k tel que k = k alors PH = k.
Démonstration: Il suffit de montrer que si k = k alors
k+1 = k+1 = k.
Prenons un langage L dans k+1. Donc
L = {x: y1 ... Qk+1 yk+1: V(x,y1, ..., yk+1)}
Considérons le langageL’ = {(x,y1): y2 ... Qk+1: V(x,y1, ...,yk+1)}
![Page 25: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/25.jpg)
Puisque L’ k, on a aussi L’ k. Donc il existe V’ P et un polynôme q tel que
L’ = {(x,y1): v2 ... Q’k+1vk+1 : V’(x,y1,v2, ..., vk+1)}
pour des |vi| q(|x,y1|).
Donc L = {x : y1 v2 ... Q’k+1vk+1: V’(x,y1,v2,...,vk+1)}
Les deux premiers quantificateurs peuvent être fondus en un seul!
L = {x : y1,v2) ... Q’k+1vk+1: V’(x,y1,v2,...,vk+1)}
Donc on a L k et donc k+1 k.
![Page 26: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/26.jpg)
Problèmes complets dans PH
On définit le langage SATkCIR pour chaque k
1 ainsi:
Entrée: Circuit booléen C avec k groupes de n variables X1, ..., Xk.
Question: Soit A = {0,1}n. Est-il vrai que X1 A X2 A ... Qk Xk A : C(X) = 1?
![Page 27: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/27.jpg)
Par définition on a SATkCIR k car
l’évaluation du circuit C se fait en temps polynomial. Notez aussi que SAT1
CIR = SATCIR.
Théorème: Pour tout k 1, SATkCIR est k-
complet.
La démonstration est une variante du théorème de Cook. Tout instance d’un problème dans k peut être converti en une instance de SATk
CIR, en faisant correspondre les k quantificateurs de l’algo k avec les k quantificateurs du problème SATk
CIR.
![Page 28: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/28.jpg)
Comparaison de NP et BPP
Théorème: Si NP BPP alors NP RP et donc NP = RP.
Démonstration: (devoir #2)
À noter que ce théorème nous dit que qqch d’improbable implique quelque chose d’encore plus improbable.
![Page 29: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/29.jpg)
Se pourrait-il que BPP NP?
En fait, beaucoup croient que P = BPP (ou presque) et donc que BPP NP.
Comment le démontrer? Il faudrait trouver une preuve succinte qu’une grande majorité des choix probabilistes mènent l’algo BPP à accepter. Aucune façon connue de le faire.
![Page 30: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/30.jpg)
Théorème: BPP 2 2.
Donc BPP ne peut pas être une classe si grande. Il n’existe pas de meilleure borne connue que celle que l’on va montrer ici.
On a BPP = co-BPP. Donc si on montre BPP 2 on a
BPP = co-BPP co-2 = 2
et donc BPP 2 2.
![Page 31: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/31.jpg)
Démonstration:Soit L BPP. Il existe un algo polynomial probabiliste s’exécutant en temps p, avec prob. d’erreur 2-n.
On suppose que toutes les exécutions sur x avec |x| ont une longueur p(n). On a donc 2p(n) exécutions possibles et au plus 2p(n) – n donnent un mauvais résulat.
Soit A(x) {0,1}p(n) l’ensemble des chemins qui acceptent x. Si x L alors A(x) est très grand (au moins 2p(n)-1) mais si x L alors A(x) est très petit (au plus 2p(n) – n). C’est ce que l’on cherche à distinguer.
![Page 32: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/32.jpg)
Idée: si A(x) est très grand dans l’ensemble des chemins C = {0,1}p(n), alors il devrait y avoir moyen de couvrir l’ensemble C avec un petit nombre de copies de A(x). Cela est impossible si A(x) est très petit.
x L A(x) très grand. copies de A(x) qui couvrent C. copies c C; c est couvert.
D’où un algorithme 2.
![Page 33: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/33.jpg)
Pour deux chemins a,b C, soit a b le ou exclusif bit-à-bit de a et b. Notez:
a b = c a c = b (a b) b = a. Pour tout b, la fonction fb : C C définie par
fb(a) = a b est une bijection car fb-1 = fb.
Définissons la translation de A(x) par b comme A(x) b = {a b: a A(x)}. On a |A(x)| = |A(x) b|. L’intuition est que
1. si A(x) est très grand alors l’ensemble C peut être couvert par un petit nombre de translations de A(x).
2. Si A(x) est très petit, un petit nombre de translations de A(x) ne peut couvrir C.
![Page 34: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/34.jpg)
Supposons que x L et choisissons au hasard des translations t1, ..., tp(n). Quelle est alors la probabilité qu’un chemin donné b C n’appartienne à aucun des A(x) ti?
b A(x) ti b ti A(x). Puisque ti est aléatoire, b ti est aussi aléatoire
Pr[b A(x) ti] = Pr [b ti A(x)] 2-n
Valide pour tout ti donc pour chaque b Pr[i b A(x) ti] 2-np(n)
Par la borne de l’union, la probabilité qu’il existe un b C n’appartenant à aucun A(x) ti est donc au plus 2-(n-1)p(n) < 1.
![Page 35: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/35.jpg)
Donc, une immense majorité des choix de ti font en sorte que (A(x) ti) = C. En particulier, il existe des ti qui ont cette propriété.
Supposons maintenant que x L. Alors |A(x)| 2p(n) – n. Donc (A(x) ti) est de taille au plus p(n) 2p(n) – n car il n’y a que p(n) translations ti. Pour n suffisamment grand p(n) 2p(n) – n < 2p(n) donc les translations ne peuvent couvrir C.
![Page 36: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/36.jpg)
On a donc
L = {x: T {0,1}p(n)2 b {0,1}p(n)
il existe j p(n) tel que b A(x) tj}
La dernière ligne peut être évaluée en temps polynomial. En effet le “il existe” est simplement un OU de taille p(n). La vérification que b A(x) tj est équivalente à b tj A(x), ce qui est vérifié en exécutant l’algo BPP avec les bits probabilistes b tj.
![Page 37: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/37.jpg)
En fait, on a montré un résultat plus fort.
La probabilité de choisir des tj qui couvrent C est écrasante si x L mais est nulle si x L.
Donc BPP RPNP et BPP RPNP co-RPNP.BPP ZPPNP.
![Page 38: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/38.jpg)
Problèmes encore plus durs
EXP = c 1 DTIME (2nc).
NEXP c 1 NTIME (2nc).
Ces classes sont certainement hors de portée pour l’algorithmique.
![Page 39: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/39.jpg)
Rappel: on peut démontrer que P EXP.
Considérons le langage L reconnu par l’algorithme suivant. Entrée x; On considère x comme la description
d’un algorithme Mx. Simuler le programme Mx sur l’entrée x
pendant |x|log |x| étapes. Si Mx accepte x alors rejeter x. Sinon accepter x.
Cet algorithme a un temps d’exécution O(nlog n) donc L EXP.
![Page 40: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/40.jpg)
Par contre, on ne peut avoir L P. Supposons que L est reconnu par un algorithme M avec temps de calcul polynomial p. Alors il existe un x tel que M = Mx. Que se passe-t-il lorsqu’on exécute M sur x?
Si M accepte x, alors il le fait en temps p(|x|) < |x|log |x| donc l’algorithme précédent rejette x!
Si M rejette x, alors il le fait en temps p(|x|) < |x|log |x| donc l’algorithme précédent accepte x!
(Note: il se peut que pour |x| petit cette dernière inégalité ne soit pas vérifié. On peut régler le problème comme cela est fait à la fin du chapitre.)
![Page 41: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/41.jpg)
Si un problème est EXP-complet ou NEXP-complet, alors on est certain que ce problème n’admet pas d’algorithme polynomial car il existe des problèmes dans EXP – P.
Contrairement à la NP-complétude, on obtient donc une garantie que le problème est au dessus de nos forces.
![Page 42: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/42.jpg)
Les problèmes complets pour EXP les plus courants sont des variantes “succintes” de problèmes dans P.
Évaluation de circuit succint (SCV).
Entrée: Description succinte d’un circuit booléen sans variables.
Question: Le circuit retourne-t-il 1?
SCV est EXP-complet.
![Page 43: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/43.jpg)
De la même façon, les variantes succintes de problèmes P-complets sont généralement EXP-complètes.
Les problèmes comme HP succint, TSP succint, 3-COL succint etc. sont NEXP-complets.
![Page 44: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/44.jpg)
Relativisation
Lorsqu’on a deux classes de complexité C, et D avec C D, on pourrait s’attendre à ce que pour tout langage L utilisable comme oracle CL DL.
Une démonstration que C D (ou démonstration que C D) est dite relativisable si elle démontre que CL DL (ou que CL DL) pour tout L.
![Page 45: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/45.jpg)
Une machine de Turing déterministe peut être simulée par une m.t. non déterministe ou probabiliste et ce peu importe l’oracle. Donc P NP ou P BPP sont relativisables. De même ZPP = RP co-RP est aussi relativisable
Les preuves de diagonalisation sont également relativisables. On peut démontrer que EXP P de façon relativisable.
La simulation et la diagonalisation sont deux des méthodes les plus utiles en complexité de calcul.
![Page 46: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/46.jpg)
Théorème: Il existe des langages K et L tels que PL = NPL et PK NPK.
!!! Donc toute preuve que P = NP ou P NP doit être non-relativisable.
Démonstration:Pour L, on peut prendre tout problème EXP-complet. On a alors PL = NPL = EXP.
![Page 47: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/47.jpg)
Démonstration (suite):K est plus délicat à trouver. On va montrer que le langage
S = {0n : x K avec |x| = n} est dans NPK – PK. Facile de montrer S NPK.
Il faut construire K pour que S PK. Cela est fait par diagonalisation contre toutes les m.t. avec oracle.
![Page 48: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/48.jpg)
Soit M1?, M2
?, ... une énumération des m.t. avec oracle telle que chaque machine est énumérée infiniment souvent.
On définit K par étapes. À chaque étape i, on a l’ensemble Ki-1 des mots de K avec longueur < i et un ensemble X d’exceptions, c’est à dire de mots de longueur i qu’on ne veut pas mettre dans K.
![Page 49: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/49.jpg)
À l’étape i, on veut définir Ki. On simule MiK(0i)
pendant ilog i étapes. On peut sans problème simuler les réponses de l’oracle si les questions ont une longueur < i. Par contre, si une question plus longue est posée, on répond non et on rajoute cette question à X.
Si MKi rejette 0i en ilog i étapes, alors on choisit Ki = Ki-1 {x: x {0,1}i x X}.
Note importante: {x: x {0,1}i x X} {0,1}i car les étapes 1,2, ..., i, ont créé au plus i
j=1 jlog j < 2i exceptions de longueur i. Donc si Mi rejette 0i en ilog i étapes, Ki est non vide.
Cela force chaque machine qui veut accepter S à accepter 0i! Donc cette machine ne peut être MK
i.
![Page 50: IFT-66975](https://reader036.fdocuments.net/reader036/viewer/2022062723/56813fea550346895daae26d/html5/thumbnails/50.jpg)
Inversement, si MKi accepte 0i en i étapes,
on choisit Ki = Ki-1. Cela veut dire que K ne contient pas de mot de longueur i et donc une machine acceptant S doit rejeter 0i. Ainsi cette machine ne peut être Mi.
Que fait-on si Mi ne termine pas son calcul en ilog i étapes? Alors on choisit Ki = Ki-1. Cela ne permet pas immédiatement de conclure que L(MK
i) S. Mais la machine MK
i apparaît infiniment souvent dans notre énumération alors il existe une description MK
I de cette même machine telle que Ilog I p(I) pour n’importe quel polynôme I.
Donc toute machine avec temps d’exécution borné par un polynôme fini par tomber dans notre piège.