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

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 = Pk; k = co-k; k+1 = NPk;

PH = k k.

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.

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

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 NPk pour L ssi

L = {x: y1 ... Qk yk |yi| p(|x|) V(x,y1, ...,yk)

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

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.

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)

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)

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.

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

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.

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

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

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

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

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.

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

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.

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

EXP = c 1 DTIME (2nc).

NEXP c 1 NTIME (2nc).

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 NEXP-complets.

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.

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.

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.

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

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.