IFT-66975

1. IFT-66975 Au delà de NP: hiérarchie polynomiale, EXP, NEXP

2. 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?

3. 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.

4. 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?

5. 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.

6. 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.

7. 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 = Pk; • k = co-k; • k+1 = NPk; • PH = kk.

8. Quelques observations utiles • k = co-k = Pkk+1k+1 • k+1k+1 k+1. • k = NPk = NPk • k = co-NPk = co-NPk. • kkk = k.

9. 1 = NP 2 1 = co-NP 2 3 22 22 2 = PNP 11 = NP  co-NP 11 = NP  co-NP 0 = 0 = 0 = 1 = P

10. 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.)

11. 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)

12. 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.

13. 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 NPk pour L ssi L = {x:  y1 ... Qk yk |yi|  p(|x|)  V(x,y1, ...,yk)

14. Supposons d’abord L  NPk. 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).

15. 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 • 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. • x est accepté sur le chemin w.

16. 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 ... Qkyik : V’(bi,yi2,...,yik) et que L’(bi) = 0 si yi2 ... Qkyik:  V’(bi, ,yi2,...,yik)

17. On peut combiner ces deux cas. Soit V* le langage qui contient (bi,1, yi1,...,yik-1) si (bi,yi1,...,yik-1)  V’ et (bi,0, yi2,...,yik) si (bi,yi2,...,yik)  V’. On a alors L’(bi) = aiyi1 ... Qkyik : V*(bi, ai, yi1, yi2,..., yik)

18. On peut maintenant exprimer L sous la forme désirée. x  L Il 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, ..., yik)  y1i ... Qkyk: V*(bi, ai, yi1, yi2,..., yik)  AL(x,w) = 1.

19. Supposons maintenant L = {x:  y1 ... Qk yk V(x,y1, ..., yk)} Soit L’ le langage suivant L’ = {(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’.

20. 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.

21. 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)

22. 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.

23. 1 = NP 2 1 = co-NP 2 3 22 22 2 = PNP 11 = NP  co-NP 11 = NP  co-NP 0 = 0 = 0 = 1 = P

24. 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 langage L’ = {(x,y1):  y2 ... Qk+1: V(x,y1, ...,yk+1)}

25. 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.

26. 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?

27. Par définition on a SATkCIRk car l’évaluation du circuit C se fait en temps polynomial. Notez aussi que SAT1CIR = 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 SATkCIR, en faisant correspondre les k quantificateurs de l’algo k avec les k quantificateurs du problème SATkCIR.

28. 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.

29. 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.

30. 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.

31. 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.

32. 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.

33. 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 • si A(x) est très grand alors l’ensemble C peut être couvert par un petit nombre de translations de A(x). • Si A(x) est très petit, un petit nombre de translations de A(x) ne peut couvrir C.

34. 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.

35. 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.

36. 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). Et 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.

37. 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.

38. 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.

39. 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.

40. 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.)

41. 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.

42. 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.

43. 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.

44. 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 que CD) est dite relativisable si elle démontre que CLDL (ou que CLDL) pour tout L.

45. 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. 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.

46. 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.

47. 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.

48. 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.

49. À 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 ij=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 MKi.

50. 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(MKi)  S. Mais la machine MKi apparaît infiniment souvent dans notre énumération alors il existe une description MKI 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.