Transcript Diapositive 1

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?
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 (nondé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.


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?

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.

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







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.
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.
3
2   2
2
2
2   2
2 = PNP
1  1 = NP  co-NP
1 = NP
1 = co-NP
1  1 = NP  co-NP
0 = 0 = 0 = 1 = P


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.)
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)

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.


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)
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).
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.
2.
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.
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)
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)
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.


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’.

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.


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)
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.
3
2   2
2
2
2   2
2 = PNP
1  1 = NP  co-NP
1 = NP
1 = co-NP
1  1 = NP  co-NP
0 = 0 = 0 = 1 = P

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)}

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

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?



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 kcomplet.
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
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.



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.

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.

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.
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.
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.
2.
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.




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
-np(n)
Pr[i b  A(x)  ti]  2
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.


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.
On a donc
2
p(n)
L = {x: T  {0,1}
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.



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


c
n
(2 ).
EXP = c 1 DTIME
c
n
NEXP c 1 NTIME (2 ).
Ces classes sont certainement hors de
portée pour l’algorithmique.
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.



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.)


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.


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.
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 NEXPcomplets.
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.



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  coRP 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.
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 EXPcomplet. On a alors PL = NPL = EXP.
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.


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.




À 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.



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.