ift-66975 théorème pcp: aperçu et applications à linapproximabilité

IFT-66975

Théorème PCP:Aperçu et applications à

l’inapproximabilité

Vérificateurs faiblesVérificateurs faibles

Dans le chapitre précédent, on est parti des systèmes de preuve qui caractérisent NP et l’on a augmenté la puissance du système de preuve pour définir des classes de complexité potentiellement plus grandes que NP.

Ici, on veut faire le raisonnement inverse. À quel point peut-on affaiblir le vérificateur tel que la classe de complexité capturée demeure exactement NP?

Vérificateurs probabilistes Soit r,q: N N. Un (r(n),q(n))-vérificateur de

preuve probabiliste est un algorithme V de temps polynomial. Pour une entrée x et une preuve P {0,1}*, l’algorithme V reçoit x et un vecteur r {0,1}O(r(|x|)) de bits aléatoires. V calcule alors un total de O(q(|x|)) positions et reçoit les valeurs de P à ces positions précises. Avec cette information, V décide ou non d’accepter le triplet x,r,P. (note: on dénote cette décision V(x,r,P) )

RemarquesRemarques

On peut supposer que r et q sont bornés par des polynômes puisque V s’exécute en temps polynomial.

Il sera pratique de considérer le cas où r = 0 (et donc aucun bit aléatoire n’est utilisé) et le cas où q = 0 (donc la preuve n’est pas consultée du tout).

La surprise de ce modèle est qu’un vérificateur probabiliste ne lit pas nécessairement toute la preuve P!

PCP Un langage L appartient à la classe

PCP(r(n),q(n)) s’il existe un (r(n),q(n))-vérificateur probabiliste V tel que

1. Si x L alors il existe une preuve P(x) telle que

Pr[V(x,r,P(x)) = 1] = 1.2. Si x L alors pour toute preuve P

Pr[V(x,r,P) = 0] ½.

RemarquesRemarques

On dénote PCP(poly,q(n)) l’union de toutes les classe PCP(nk,q(n)) et PCP(r(n),poly) l’union de toutes les classes PCP(r(n),nk).

Notez bien que la preuve est potentiellement exponentiellement longue. Par contre, on peut toujours supposer que la preuve est de longueur au plus O(q(n)2O(r(n))) car pour chacun des 2O(r(n)) vecteurs de bits aléatoires possibles, au plus O(q(n)) bits sont consultés.

Notez aussi que le choix de ½ est plus ou moins arbitraire.

Plusieurs classes usuelles peuvent être définies comme des classes PCP.

ThéorèmeThéorème: P = PCP(0,0) NP = PCP(0,poly) co-RP = PCP(poly,0)

DémonstrationDémonstration: P = PCP(0,0)

Soit L PCP(0,0). Puisque q = 0, la preuve est complètement ignorée.

Par ailleurs, pour tous les x L on aPr[V(x,r,P) = 0] ½

mais puisqu’aucun bit aléatoire n’est utilisé on a Pr[V(x,r,P) = 0] = 1.

Donc L PCP(0,0) si et seulement si L P.

DémonstrationDémonstration: NP = PCP(0,poly)

Soit L PCP(0,poly). Puisque r = 0, les positions que V consulte dans P sont toujours les mêmes. Donc on peut supposer que P est de longueur polynomiale.

Par ailleurs, puisqu’aucun bit aléatoire n’est utilisé on a pour tous les x L et pour toutes les preuves P:

Pr[V(x,r,P) = 0] = 1.

Donc L PCP(0,poly) si et seulement si il existe une preuve de longueur polynomiale qui peut être validée par un algorithme déterministe en temps polynomial. C’est exactement une des définitions de NP.

DémonstrationDémonstration: co-RP = PCP(poly,0)

Soit L PCP(poly,0). Puisque q = 0, la preuve est complètement ignorée. Donc L PCP(poly,0) si et seulement s’il existe un algorithme probabiliste V s’exécutant en temps polynomial et utilisant un nombre de bits aléatoires possiblement polynomial tel que

1. si x L alors Pr[V(x) = 1] = 1.2. Si x L alors Pr[V(x) = 0] ½.

C’est précisément la définition de la classe co-RP.

ThéorèmeThéorème: Si L PCP(r(n),q(n)) alors L NTIME(2O(r(n)+log n)).

Donc les PCP peuvent peut-être capturer de nombreuses classes de complexité intéressantes mais toutes contenues dans NEXP.

DémonstrationDémonstration: Supposons L PCP(r(n),q(n)).

Pour décider si x L, notre machine non-déterministe va simplement choisir non-déterministement une preuve P et simuler le comportement du vérificateur probabiliste pour les 2O(r(n)) valeurs possibles des bits probabilistes r.

D’après nos remarques précédentes on peut supposer que la preuve est de longueur au plus q(n)2O(r(n)) elle peut donc être choisie dans la borne de temps spécifiée.

Pour chaque valeur de r, la simulation de V se fait en temps p(n) 2O(r(n)) = 2O(r(n) + log n). Notre algorithme non déterministe accepte si pour la preuve choisie, tous les choix de r font que V accepte x.

Si x L alors il existe une preuve telle que tous les choix probabilistes amènent V à accepter.

Si x L alors pour chaque preuve au moins la moitié des r amènent V à rejeter.

CorollaireCorollaire: NP = PCP(log n,poly)

À quel point peut-on diminuer r(n) et q(n) en conservant NP = PCP(r(n),q(n)? En d’autres mots quel est le vérificateur le plus faible qui permet de caractériser NP?

Il existe plusieurs choix optimaux, entre autres parce que NP = PCP(0,poly) mais le théorème PCP est le plus surprenant de ces résultats.

Théorème PCPThéorème PCP: [Arora, Lund, Motwani Sudan, Szegedy]

NP = PCP(log n,1)

Résultat absolument incroyable. On peut se contenter d’un vérificateur qui choisit aléatoirement O(1) bits de la preuve et qui réussit à être convaincu de sa validité.

RemarquesRemarques

Attention, ne pas faire l’erreur du New York Times.

Contrairement aux preuves usuelles pour NP, la preuve utilisée ici doit contenir dans chacun de ses bits une information très délocalisée.

Un des résultats les plus profonds, sinon le plus profond de toute la théorie de la complexité.

Impact considérable sur la théorie de l’inapproximabilité.

Liens étroits avec la théorie des codes correcteurs.

La démonstration continue à être améliorée très régulièrement.

Démonstration du théorème PCP

On va démontrer le résultat plus faible suivant

3-SAT PCP(n3,1).

Tout de même surprenant: il existe pour 3-SAT un vérificateur probabiliste qui consulte une preuve exponentiellement longue mais ne consulte à chaque fois qu’un nombre fixe des bits de preuve.

Observations préliminairesObservations préliminaires

Qu’est-ce qui constitue une preuve que la formule x1, ..., xn) est satisfiable? Le plus simple est de trouver un a {0,1}n tel que (a) = 1.

1. Positif: preuve courte et facilement vérifiable.2. Négatif: seulement vérifiable avec un accès à tous

les bits de preuve. Chaque bit de preuve contient une information excessivement “locale”.

Les PCP représentent également un a {0,1}n qui satisfait la formule. Mais cette information est présenté de façon à ce que chaque bit de preuve contienne un peu d’information à propos de chaque ai. Ainsi la lecture d’un très petit nombre de bits de preuve permet de se convaincre que (a) = 1.


Une PCP pour la formule est l’encodage P(a) d’un a {0,1}n tel que (a) = 1.

Il faut que P(a) soit construit de sorte que la lecture d’un petit nombre de bits suffit à conclure (a) = 1.

Le vrai problème est de s’assurer que si est insatisfiable alors aucune preuve ne réussira à induire en erreur le vérificateur.

1. Si la preuve fournie est P(a’) telle que (a’) = 0, il faut que le vérificateur puisse conclure que la preuve est invalide.

2. Pire encore, si la preuve n’a rien à voir avec un quelconque encodage P(a’) pour un a’ {0,1}n alors il faut aussi que le vérificateur puisse détecter un problème.


On va choisir un code-correcteur pour représenter P(a). Si aucun a ne satisfait on va considérer deux types de preuve que l’on pourrait être tenté d’utiliser pour induire le vérificateur en erreur.

1. La preuve est très différente de tous les encodages P(a) d’un a {0,1}n. Alors le vérificateur aura une bonne chance de détecter que la preuve est invalide.

2. Il existe un a tel que la preuve est très semblable à P(a). Alors le vérificateur pourra facilement corriger la preuve pour agir comme si elle était réellement P(a). Il rejettera alors la preuve parce qu’il verra que (a) = 0.

Arithmétisation des formulesArithmétisation des formules

Pour décrire le code et son fonctionnement, il est utile d’associer à chaque formule booléenne en 3CNF avec variables x1, ..., xn un polynôme p sur Z2 avec variables x1, ... ,xn.

(x1 2 x3) (x2 x5 7)

(1-x1)x2(1-x3) + (1-x2)(1-x5)x7

Le devient une multiplication, le devient une addition. xi devient (1-xi) et i devient xi. Cette simple transformation associe un polynôme p à chaque formule .

Arithmétisation des formulesArithmétisation des formules

Les polynômes p ont des propriétés intéressantes

1. Petit degré. (3)2. Si a {0,1}n satisfait une clause Cj alors le

terme pj correspondant de p est 0. Sinon le terme correspondant est 1.

3. Si (a) = 1 alors p(a) = 0.4. p(a) = 1 si et seulement si le nombre de

clauses de qui ne sont pas satisfaites par a est impair.

Vérification à travers l’arithmétisationVérification à travers l’arithmétisation

Supposons que nous avons trouvé une façon pour le vérificateur d’obtenir la valeur p(a).

1. Si p(a) = 1 alors il sait que a ne satisfait pas . 2. Si p(a) = 0, il sait seulement qu’un nombre pair

de clauses sont demeurées insatisfaites mais il voudrait savoir si ce nombre est 0.

Pour régler le problème, on va choisir aléatoirement un sous-ensemble de clauses. Si (a) = 1 alors tous ces sous-ensembles contiennent un nombre pair de clauses insatisfaites. Sinon il y a une chance sur deux pour qu’un sous-ensemble de clauses insatisfaites!

Un test aléatoireUn test aléatoire

Formellement, soit pj le terme de p correspondant à la clause Cj. Pour un r {0,1}m, soit pr le polynôme

pr = rjpj.

Si a satisfait , on a pj(a) = 0 pour tous les j. Donc pr(a) = 0 pour tous les r.

Si a ne satisfait pas et si Ck est insatisfaite alors pk(a) = 1. Quelle est alors la probabilité qu’on choisisse un r tel que pr(a) = 0?

On a pr(a) = (j k rjpj(a)) + rkpk(a). Comme pk(a) = 1, il y a une probabilité ½ que ce dernier terme change la valeur de pr(a). Donc si a ne satisfait pas

Prr[pr(a) = 0] = Prr[pr = 1] = ½.

Et alors?Et alors?

Super. Si le vérificateur reçoit une assignation a qui satisfait , le calcul d’une valeur aléatoire pr(a) lui permet de conclure avec une bonne probabilité que a satisfait effectivement .

Mais la preuve ne peut pas simplement fournir a parce que cela demanderait au vérificateur de lire n bits!

La clé: construire une preuve qui permet au vérificateur de calculer pr(a) sans lire toute la preuve et donc sans savoir précisément la valeur de a.

Le code linéaireLe code linéaire

On peut maintenant décrire un peu mieux la preuve qui sera vérifiée.

La preuve va encoder les valeurs de trois fonctions linéaires L1

a, L2a, L3

a qui dépendent de a.

L1a: {0,1}n {0,1}

L2a: {0,1}n2 {0,1}

L3a: {0,1}n3 {0,1}

On peut écrire entièrement les tables de valeur de ces trois fonctions en utilisant 2n + 2n2 + 2n3 bits.

Si le vérificateur cherche à calculer Lia pour un

point précis il peut le faire en consultant un seul point de cette liste de bits.


Soit q un polynôme de degré au plus 3 sur Z2. On peut développer q et l’écrire comme une somme de

1. un terme constant cq {0,1}2. des termes de la forme xi pour i Iq1.3. des termes de la forme xixj pour (i,j) Iq2.4. des termes de la forme xixjxk pour (i,j,k)

Iq3.

Puisque l’on travaille sur Z2 tous les coefficients sont 0 (terme n’apparaissant pas dans la somme) ou 1 (terme apparaissant).


On définit maintenant les Lia.

L1a(y1, ..., yn) := 1 i n aiyi

L2a(y1,1, ..., yn,n) := 1 i,j n aiajyi,j

L3a(y1,1,1, ..., yn,n,n) := 1 i,j,k n aiaj

aky

i,j,k.

Notez que chacune de ces trois fonctions ont des valeurs excessivement corrélées. Elles sont linéaires en ce sens que

Lia(y1 y

2) = L

ia(y

1) + L

ia(y

2)

pour tout y1, y2 {0,1}ni.

Utilisation du code pour la vérificationUtilisation du code pour la vérification

Supposons que le vérificateur veut évaluer q(a) pour q de degré 3. Il peut développer q et calculer cq, Iq1, I

q2 et I

q3.

Soient cq1, c

q2 et c

q3 les vecteurs caractéristiques

de Iq1, Iq

2 et Iq

3.

Le vérificateur qui veut calculer q(a) va regarder les bits de la preuve donnant L1

a(cq

1), L2

a(cq

2) et

L3

a(cq

3) et obtenir

q(a) = L1a(c

q1) + L

2a(c

q2) + L

3a(c

q3).

Qu’est-ce que nous offre ce code?Qu’est-ce que nous offre ce code?

On a donc le résultat partiel suivant.

Si le vérificateur reçoit une formule et une preuve encodant les valeurs de L1

a, L2a et L3

a il peut choisir aléatoirement un r {0,1}m et calculer pr(a) en lisant 3 bits de preuve.

1. Si a satisfait alors le vérificateur constate que pr(a) = 0 peu importe son choix de r.

2. Si a ne satisfait pas alors le vérificateur constate pr(a) = 0 avec probabilité ½.

Notez aussi que m = O(n3) et donc ce processus utilise au plus n3 bits aléatoires.

Se protéger des fausses preuvesSe protéger des fausses preuves

Le plus dur reste à faire. On sait ce que devrait être la preuve si est satisfiable mais il faut construire des mécanismes qui permettent de rejeter avec forte probabilité n’importe quelle preuve lorsque est insatisfiable.

On peut supposer que toutes les preuves sont de longueur 2n + 2n2 + 2n3. Notre vérificateur va faire passer une batterie de tests à la preuve potentielle. On veut construire ces tests de façon à ce qu’une réelle preuve de la forme désirée passe tous ces tests avec probabilité 1.

Test de linéaritéTest de linéarité

Les preuves sont censées représenter trois fonctions linéaires. Donc si on choisit au hasard deux points y1, y2 {0,1}ni. On devrait avoir

Lia(y1 y2) = Li

a(y1) + Lia(y2).

Bonne nouvelle: si la preuve représente effectivement des fonctions linéaires tous ces tests seront passés sans problème.

Mauvaise nouvelle: si la preuve contient des fonctions qui sont presque linéaires alors la probabilité de détecter un problème est excessivement faible.

Test de linéaritéTest de linéarité

On va être obligé de “faire avec” des preuves qui représentent des fonctions quasi-linéaires, c’est à dire des fonctions qui diffèrent d’une réelle fonction linéaire sur un tout petit nombre de points.

Les fonctions qui ne sont pas quasi-linéaires vont échouer notre test avec une probabilité suffisamment forte.

Les fonctions quasi-linéaires vont être suffisamment proches d’une fonction linéaire pour que l’on corrige les erreurs!

Évaluateur de fonctionÉvaluateur de fonction

Supposons que le vérificateur a en main une preuve qui est constitué de trois fonctions f1, f2, f3 quasi-linéaires. On va montrer qu’il existe des fonctions linéaires uniques l1, l2 et l3 qui sont très proches des trois fonctions de la preuve.

Lorsque le vérificateur voudra calculer Lia sur

un point donné y il utilisera un évaluateur de fonction qui lui fournira non pas fi(y) mais plutôt li(y).

Le dilemme de l’adversaireLe dilemme de l’adversaire

Notez le problème auquel fait face un prouveur malicieux qui essaie de convaincre le vérificateur d’accepter une formule insatisfiable.

1. S’il donne des fonctions qui encodent réellement L1

a, L2a et L3

a, il a perdu car le vérificateur verra probablement que a ne satisfait pas .

2. S’il donne des fonctions qui ne sont pas quasi-linéaires il a perdu car le vérificateur va probablement s’en apercevoir.

3. S’il donne des fonctions qui sont quasi-linéaires alors le vérificateur peut contourner le problème en simulant une preuve où les fonctions données sont linéaires.

Test de cohérenceTest de cohérence

Il reste une possibilité de confondre le vérificateur. Si les trois fonctions fournies comme preuve sont linéaires mais ne sont pas des fonctions de la forme L1

a, L2a et L3

a pour un même a alors le vérificateur peut se faire prendre.

Le test de cohérence va précisément s’assurer que les trois fonctions fournies en preuve sont reliées. C’est à dire qu’elles proviennent d’un même a.

Si trois fonctions linéaires ne sont pas de la forme L1a,

L2a et L3

a alors le test de cohérence sera échoué avec une probabilité < 1.

Placer les morceaux ensemblePlacer les morceaux ensemble

En combinant tous ces éléments, on obtiendra

Si est satisfiable alors toute preuve de la forme (L1

a,L2a,L3

a) pour (a) = 1 est acceptée avec probabilité 1.

Si est insatisfiable alors une preuve (f1,f2,f3) est accepté seulement si

1. Les tests de linéarité ne permettent pas de détecter qu’une des fonctions n’est même pas quasi-linéaire.

2. Le test de cohérence ne réussit pas à détecter que les fonctions l1, l2 et l3 ne sont pas cohérentes.

3. Tous les pr(a) calculés sont 0.4. Une des évaluations de fonction est incorrecte.

Les paramètres à atteindreLes paramètres à atteindre

Dans un premier temps, on va s’assurer que la probabilité qu’une fonction qui n’est pas quasi-linéaire passe le test de linéarité est au plus 1/18. Ainsi la probabilité que les trois fonctions passent le test est au plus 1/6 si elles ne sont pas toutes quasi-linéaires.

On pourra ensuite supposer que f1, f2 et f3 sont quasi-linéaires.

De la même façon, on va s’assurer que le test de cohérence laisse passer trois fonctions quasi-linéaires qui sont incohérentes avec probabilité au plus 1/6.

On pourra maintenant supposer que l1, l2 et l3 sont cohérentes.

Le coût de cette générosité: il ne reste plus que 1/6 de jeu pour le reste de la vérification.

Test de linéarité (détails)Test de linéarité (détails)

Pour tester si fi est quasi-linéaire on choisit

aléatoirement x et y {0,1}ni.

fi passe le test de linéarité si et seulement si

fi(xy) = fi(x) + fi(y)

Notez que ce test requiert au plus O(n3) bits aléatoires et la lecture de trois bits de preuve.


On dit que deux fonctions sont -proches si Probx[f(x) g(x)] .

On va montrer que 1. Si f est linéaire alors le test de linéarité est toujours

un succès.2. Si pour un <1/3 on a que fi n’est pas -proche d’une

fonction linéaire li alors la probabilité de passer le test est au plus 1-/2.

La propriété 1 est évidente. Pour montrer la propriété 2, on va établir que si

Probx,y[f(xy) f(x) f(y)] /2alors il existe une fonction linéaire l qui est -proche de

f.


Construisons la fonction l. Comment définir l(x)? Pour chaque y on devra avoir l(x) = l(xy) – l(y).

Regardons plutôt f(xy) – f(y). Cette valeur n’est pas toujours la même si f n’est pas linéaire mais définissons l(x) comme étant la valeur la plus fréquente.

Il faut montrer 1. l est -proche de f. 2. l est linéaire.


Supposons que l n’est pas -proche de f. Prx[f(x) l(x)] >

Par construction de l, on a aussi pour chaque xPry[l(x) = f(xy) – f(y)] ½.

On peut écrire:

Prx,y[f(xy) – f(y) f(x)]

Prx,y[f(xy) – f(y) = l(x) l(x) f(x)]

Analysons cette dernière probabilité.


Prx,y[f(xy) – f(y) = l(x) l(x) f(x)]

= Prx[l(x) f(x)] Pry[f(xy) – f(y) = l(x) l(x) f(x)] + Prx[l(x) f(x)] Pry[f(xy) – f(y) = l(x) l(x) f(x)

l(x) f(x)].

La dernière probabilité est 0. Comme on suppose que l et f ne sont pas proches Prx[l(x) f(x)] > et l’autre terme est ½.

Donc Prx,y[f(x y) – f(y) f(x)] > /2 ce qui est en contradiction avec l’hypothèse.


Il faut aussi montrer que l est linéaire. Considérons la probabilité

p(x) = Pry[l(x) = f(xy) – f(y)]

Notre construction garantit p(x) ½ mais en fait on va montrer que p(x) > 1- grâce au fait que f est quasi-linéaire et donc que

Prx,y[f(xy) f(x) + f(y)] /2


On peut conclure que pour tout xPry,z[f(xy) + f (z) f(x y z)] /2

etPry,z[f(y) + f(xz) f(x y z)] /2

La probabilité que l’un de ces deux évenements se produise est donc au plus . AinsiPry,z[f(xy) + f(z) f(y) + f(xz)]

Au lieu d’écrire f(xy) + f(z) f(y) + f(xz), il est plus pratique d’écire f(xy) - f(z) f(xz) – f(y).

1 - · Pry,z[f(xy) - f(y) f(xz) – f(z)]

= t2 {0,1} Pry,z[f(xy) - f(y) t Æ f(xz) – f(z) = t]

= t2 {0,1} Pry,z[f(xy) - f(y) t] ¢ Pry,z[f(xz) – f(z) = t]

= t2 {0,1} (Pry[f(xy) - f(y) t])2

Prenons maintenant t = l(x). On a alorsPry[f(xy)-f(y) t] = p(x)

et Pry[f(xy)-f(y) 1-t] = 1 - p(x)

Finalement comme p(x) · ½, on a 1 - · p(x)2 + (1 – p(x))2 · p(x)2 + p(x)(1-p(x)) = p(x)


On a donc pour tout x, x’ 1. Pry[l(x) = f(xy) – f(x)] = p(x) 1-.

2. Pry[l(x’) = f(xx’y) – f(xy)] 1-.

3. Pry[l(xx’) = f(xx’y) – f(y)] 1-.

La probabilité que ces trois choses surviennent est au moins 1-3. Et donc avec probabilité 1-3 on a l(x) + l(x’) = l(xx’). Cela est vrai pour tous les x, x’.

De plus si l(x) + l(x’) = l(xx’) avec probabilité > 0 alors en fait cela est vrai et donc l est linéaire.

Évaluateur de fonction (détails)Évaluateur de fonction (détails)

L’évaluateur de fonction reçoit la table de valeurs d’une fonction fi et un certain x. Son but est de retourner en consultant O(1) bits de la table une valeur E(x) de telle façon que pour < 1/3

1. Si fi est linéaire alors E(x) = fi(x).

2. Si fi est -proche d’une fonction linéaire li alors Pr[E(x) = li(x)] 1-2.

Notez bien que E ne cherche pas à évaluer fi(x) mais plutôt li(x)!

Évaluateur de fonction (détails)Évaluateur de fonction (détails)

Algorithme pour l’évaluateur: choisir un y aléatoirement et retourner

E(x) = fi(xy) – fi(y).

Cela requiert la lecture de deux bits de la table de fi. Il est clair aussi que si fi est linéaire alors E(x) = fi(x).

Si fi est proche d’une fonction linéaire li alors

1. Pry[fi(y) = li(y)] 1-2. Pry[fi(xy) = li(xy)] 1-

Donc Pry[fi(xy) = li(xy) fi(y) = li(y)] 1-2Dans ce cas on aura

E(x) = fi(xy) – fi(y) = li(xy) – li(y) = li(x).

Test de cohérence (détails)Test de cohérence (détails)

Le test de cohérence reçoit les tables de f1, f2 et f3 qui sont linéaires ou -proches de fonctions linéaires l1, l2 et l3. Le test est effectué en lisant un nombre fixe de positions des tables. Pour < 1/24 ce test a les propriétés:

1. Si f1,f2 et f3 sont du type L1a, L2

a et L3a pour

un même a {0,1}n alors le test est passé avec probabilité 1.

2. S’il n’existe aucun a {0,1}n tel que l1, l2 et l3 sont du type L1

a, L2a et L3

a alors le test détecte cela avec une probabilité > 0.


Algorithme:1. Choisir aléatoirement x, x’ et x’’ {0,1}n et y

{0,1}n2.

2. Définir x±x’ {0,1}n2 par (x±x’)i,j = xix’j et x’’±y

{0,1}n3 par (x’’±y)i,j,k = xi’’yj,k.

3. Utiliser l’évaluateur de fonctions pour calculer avec bonne probabilité l1(x), l1(x’), l1(x’’), l2(x±x’), l2(y) et l3(x’’±y).

4. Accepter si l1(x)l1(x’) = l2(x±x’) et si l1(x’’)l2(y) = l3(x’’±y).


Vérifions d’abord que le test de cohérence est positif lorsque les fonctions sont de la forme L1

a, L2a, L3

a. Dans ce cas on a

L1a(x) L1

a(x’) = (i aixi)(j ajx’j)

= i,j aiajxix’j = L2a(x±x’).

et

L1a(x’’) L2

a(y) = (i aix’’i)(j,k ajakyj,k)

= i,j,k aiajak x’’iyj,k=

L2a(x’’±y)


Que se passe-t-il si f1, f2 et f3 sont -proches de l1, l2 et l3? D’abord comme < 1/24 et comme l’évaluateur de fonction est utilisé six fois, la probabilité que toutes les évaluations soient correctes est au moins ½.

La fonction l1 est linéaire et elle peut donc être écrite comme l1(x) = i aixi.

De même la fonction l2 est linéaire et peut être écrite comme l2(y) = i,j bi,jyi,j.

Ces deux fonctions sont cohérentes si et seulement si bi,j = aiaj pour tout i,j.


Supposons que nous avons bi,j aiaj pour au moins un (i,j). Notre test compare

i,j aiaj xix’j et i,j bi,jxix’j

Considérons les matrices A = (aiaj) et B = (bi,j). Notre test compare xTAx’ et xTBx’.

Si A B à cause de la colonne j alors on a xTA xTB avec probabilité ½. De plus si xTA xTB alors avec probabilité ½ xTAx’ xTBx’.

Donc le test de cohérence échoue avec probabilité au moins ¼.

La preuve du théorème PCPLa preuve du théorème PCP

Le résultat que l’on vient de démontrer est une version simplifié de ce qui est requis pour démontrer le théorème NP = PCP(log n,1).

Pour réduire le nombre de bits aléatoires utilisés et la longueur de la preuve fournie au vérificateur on utilise un meilleur code. La preuve la plus connue utilise des polynômes de petit degré plutôt que des fonctions linéaires.

La partie la plus corsée de la preuve est celle qui établit le test de petit degré qui est l’analogue de notre test de linéarité.

PCP et inapproximabilité

Rappel: il existe pour MAX-3-SAT un algorithme d’approximation avec un ratio 8/7.

On veut maintenant obtenir un résultat d’inapproximabilité pour MAX-3-SAT grâce à la technique du fossé.

Technique du fosséTechnique du fossé

Rappel: s’il existe > 0, un problème NP-complet K et une réduction f de K vers 3-SAT telle que

x K f(x) est une formule satisfiable.

x K au plus (1-)m clauses de f(x) sont satisfiables.

Alors si P NP, MAX-3-SAT n’est pas approximable en temps polynomial avec un ratio meilleur que 1/(1-), car sinon, la combinaison de f et de l’algorithme d’approximation pour MAX-3-SAT forme un algorithme de temps polynomial pour K.

Comment choisir un problème NP-complet A et une réduction f vers 3-SAT avec ces belles propriétés?

Le théorème de Cook-Levin nous donne une réduction de n’importe quel problème NP-complet vers 3-SAT. Malheureusement, si w K, alors on peut quand même satisfaire toutes les clauses de f(w) sauf une!

C’est la construction de réductions créant des plus grand fossés qui ont originellement motivé les recherches qui ont amené au théorème PCP.

LemmeLemme: Pour un certain > 0, il existe une réduction f de 3-SAT vers 3-SAT telle que

1. Si est une formule satisfiable alors f() est aussi satisfiable.

2. Si est insatisfiable alors une fraction au plus (1-) des clauses de sont satisfiables simultanément.

Donc f aggrandit le fossé entre satisfiable et insatisfiable. Même si on peut simultanément satisfaire presque toutes les clauses de , cela sera impossible pour f().

DémonstrationDémonstration:Le théorème PCP est la clé. Puisque 3-SAT est dans NP, on sait que pour des constantes c,k N il existe un vérificateur probabiliste pour 3-SAT qui utilise au plus c log n bits probabilistes et consulte au plus k bits de la preuve.

Soit N = 2c log n nc. Il existe au plus N choix de bits probabilistes et chacun d’entre eux mène à la consultation de k bits de la preuve. On peut donc supposer que la preuve est de longueur kN et que {0,1}kN est l’ensemble des preuves possibles.

Soit C l’ensemble des 3-clauses de et n le nombre de variables booléennes. Pour chaque 0 r N-1, on construit la fonction

fr: {0,1}kN {0,1}

telle que 1. fr(p) = 1 si la preuve p est acceptée par le

vérificateur lorsque r est le choix de ses bits probabilistes et

2. fr(p) = 0 si la preuve p est rejetée par le vérificateur lorsque r est le choix de ses bits probabilistes.

À noter que pour un r fixé, la fonction fr ne dépend que de k bits de son entrée! Nous dénoterons ces positions jr(1) < jr(2) < ... < jr(k).

Par définition des PCP, on a que

1. Si est satisfiable, alors il existe une preuve {0,1}kN telle que fr() = 1 pour tous les r.

2. Si est insatisfiable, alors pour toutes les {0,1}kN on a que fr() = 1 pour au plus la moitié des r.

Chaque fonction fr ne dépend que de k bits d’entrée. On peut donc écrire une formule en forme normale conjonctive de taille au plus k2k décrivant fr. Les variables booléennes utilisées ici sont jr(1), ... ,jrk

).

De plus on a vu comment transformer une clauses de longueur k en k* clauses de longueur 3 pour k* = max{1,k-2}. Ici de nouvelles variables booléennes sont introduites.

Donc on peut pour chaque fr construire k*2k clauses de trois litéraux telles que

1. si fr() = 1 alors toutes ces clauses sont simultanément satisfiables.

2. Si fr() = 0, alors au moins une clause est insatisfaite.

En construisant ces clauses pour chaque fr, on obtient un ensemble d’au plus k*2kN clauses de longueur 3 telles que:

1. Si est satisfiable alors toutes ces clauses sont satisfiables.

2. Si est insatisfiable alors au moins N/2 de ces nouvelles clauses sont insatifiables pour toute assignation (au moins une pour au moins la moitié des fr.)

Choisissons = 1/(k*2k+1). Si est insatisfiable la proportion de nos nouvelles clauses qui sont simultanément satisfiables est 1 – (N/2)/(Nk*2k) = 1-.

CorollaireCorollaire: MAX-3-SAT APX – PTAS.

À noter que si on a un PCP pour 3-SAT avec k = 3 alors on peut montrer que MAX-3-SAT n’est pas approximable avec un ratio meilleur que le 8/7 que nous avons montré.

Les mêmes techniques ont permis de montrer des résultats d’approximation souvent très forts. En particulier si P NP alors MAX-CLIQUE n’est même pas approximable avec un ratio n1/2- et MIN-GC n’est pas approximable avec un ratio meilleur que n1/7-.

ift-66975 théorème pcp: aperçu et applications à linapproximabilité

Documents