Ift 66975
This presentation is the property of its rightful owner.
Sponsored Links
1 / 50

IFT-66975 PowerPoint PPT Presentation


  • 81 Views
  • Uploaded on
  • Presentation posted in: General

IFT-66975. Au delà de NP: hiérarchie polynomiale, EXP, NEXP. 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?.

Download Presentation

IFT-66975

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Ift 66975

IFT-66975

Au delà de NP:

hiérarchie polynomiale, EXP, NEXP


Vers des probl mes plus difficiles

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?


Machines oracle

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.


Ift 66975

  • 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?


Ift 66975

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


Ift 66975

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


Hi rarchie polynomiale

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.


Ift 66975

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.


Ift 66975

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


Ift 66975

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


Ift 66975

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)


Ift 66975

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


Ift 66975

  • 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)


Ift 66975

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


Ift 66975

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.


Ift 66975

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)


Ift 66975

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)


Ift 66975

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.


Ift 66975

  • 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’.


Ift 66975

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


Ift 66975

  • 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)


Ift 66975

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.


Ift 66975

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


Ift 66975

  • 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)}


Ift 66975

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.


Probl mes complets dans ph

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?


Ift 66975

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


Comparaison de np et bpp

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.


Ift 66975

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


Ift 66975

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


Ift 66975

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


Ift 66975

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.


Ift 66975

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


Ift 66975

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


Ift 66975

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


Ift 66975

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


Ift 66975

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


Probl mes encore plus durs

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.


Ift 66975

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.


Ift 66975

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


Ift 66975

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


Ift 66975

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


Ift 66975

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.


Relativisation

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.


Ift 66975

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


Ift 66975

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.


Ift 66975

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.


Ift 66975

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


Ift 66975

  • À 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.


Ift 66975

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


  • Login