IFT-66975

1. IFT-66975 Théorème PCP: Aperçu et applications à l’inapproximabilité

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

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

4. Remarques 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!

5. 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 • Si x  L alors il existe une preuve P(x) telle que Pr[V(x,r,P(x)) = 1] = 1. • Si x  L alors pour toute preuve P Pr[V(x,r,P) = 0]  ½.

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

7. Plusieurs classes usuelles peuvent être définies comme des classes PCP. Théorème: • P = PCP(0,0) • NP = PCP(0,poly) • co-RP = PCP(poly,0)

8. Dé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 a Pr[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.

9. Dé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.

10. Dé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 • si x  L alors Pr[V(x) = 1] = 1. • Si x  L alors Pr[V(x) = 0]  ½. C’est précisément la définition de la classe co-RP.

11. Thé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.

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

13. Corollaire: • 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.

14. Thé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é.

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

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

17. Observations 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. • Positif: preuve courte et facilement vérifiable. • 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.

18. Observations préliminaires 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. • Si la preuve fournie est P(a’) telle que (a’) = 0, il faut que le vérificateur puisse conclure que la preuve est invalide. • 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.

19. Observations préliminaires 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. • 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. • 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.

20. Arithmé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 .

21. Arithmétisation des formules Les polynômes p ont des propriétés intéressantes • Petit degré. (3) • Si a  {0,1}n satisfait une clause Cj alors le terme pj correspondant de p est 0. Sinon le terme correspondant est 1. • Si (a) = 1 alors p(a) = 0. • p(a) = 1 si et seulement si le nombre de clauses de  qui ne sont pas satisfaites par a est impair.

22. Vérification à travers l’arithmétisation Supposons que nous avons trouvé une façon pour le vérificateur d’obtenir la valeur p(a). • Si p(a) = 1 alors il sait que a ne satisfait pas . • 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!

23. Un 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] = ½.

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

25. Le 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 L1a, L2a, L3a 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.

26. Le code linéaire Soit q un polynôme de degré au plus 3 sur Z2. On peut développer q et l’écrire comme une somme de • un terme constant cq {0,1} • des termes de la forme xi pour i  Iq1. • des termes de la forme xixj pour (i,j)  Iq2. • 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).

27. Le code linéaire 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 aiajakyi,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  y2) = Lia(y1) + Lia(y2) pour tout y1, y2 {0,1}ni.

28. Utilisation 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, Iq2 et Iq3. Soient cq1, cq2 et cq3 les vecteurs caractéristiques de Iq1, Iq2 et Iq3. Le vérificateur qui veut calculer q(a) va regarder les bits de la preuve donnant L1a(cq1), L2a(cq2) et L3a(cq3) et obtenir q(a) = L1a(cq1) + L2a(cq2) + L3a(cq3).

29. 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 L1a, L2a et L3a il peut choisir aléatoirement un r  {0,1}m et calculer pr(a) en lisant 3 bits de preuve. • Si a satisfait  alors le vérificateur constate que pr(a) = 0 peu importe son choix de r. • 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.

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

31. 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) = Lia(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.

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

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

34. Le 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. • S’il donne des fonctions qui encodent réellement L1a, L2a et L3a, il a perdu car le vérificateur verra probablement que a ne satisfait pas . • S’il donne des fonctions qui ne sont pas quasi-linéaires il a perdu car le vérificateur va probablement s’en apercevoir. • 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.

35. Test 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 L1a, L2a et L3a 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 L3a alors le test de cohérence sera échoué avec une probabilité  < 1.

36. Placer les morceaux ensemble En combinant tous ces éléments, on obtiendra Si  est satisfiable alors toute preuve de la forme (L1a,L2a,L3a) pour (a) = 1 est acceptée avec probabilité 1. Si  est insatisfiable alors une preuve (f1,f2,f3) est accepté seulement si • Les tests de linéarité ne permettent pas de détecter qu’une des fonctions n’est même pas quasi-linéaire. • Le test de cohérence ne réussit pas à détecter que les fonctions l1, l2 et l3 ne sont pas cohérentes. • Tous les pr(a) calculés sont 0. • Une des évaluations de fonction est incorrecte.

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

38. 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(xy) = fi(x) + fi(y) Notez que ce test requiert au plus O(n3) bits aléatoires et la lecture de trois bits de preuve.

39. Test de linéarité (détails) On dit que deux fonctions sont -proches si Probx[f(x)  g(x)] . On va montrer que • Si f est linéaire alors le test de linéarité est toujours un succès. • 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(xy)  f(x)  f(y)] /2 alors il existe une fonction linéaire l qui est -proche de f.

40. Test de linéarité (détails) • Construisons la fonction l. Comment définir l(x)? Pour chaque y on devra avoir l(x) = l(xy) – l(y). • Regardons plutôt f(xy) – 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 • l est -proche de f. • l est linéaire.

41. Test de linéarité (détails) Supposons que l n’est pas -proche de f. Prx[f(x)  l(x)] > . Par construction de l, on a aussi pour chaque x Pry[l(x) = f(xy) – f(y)]  ½. On peut écrire: Prx,y[f(xy) – f(y)  f(x)]  Prx,y[f(xy) – f(y) = l(x)  l(x)  f(x)] Analysons cette dernière probabilité.

42. Test de linéarité (détails) Prx,y[f(xy) – f(y) = l(x)  l(x)  f(x)] = Prx[l(x)  f(x)]  Pry[f(xy) – f(y) = l(x)  l(x)  f(x)] + Prx[l(x) = f(x)]  Pry[f(xy) – 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.

43. Test de linéarité (détails) • Il faut aussi montrer que l est linéaire. Considérons la probabilité p(x) = Pry[l(x) = f(xy) – 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(xy)  f(x) + f(y)] /2

44. Test de linéarité (détails) On peut conclure que pour tout x Pry,z[f(xy) + f(z)  f(x  y  z)] /2 et Pry,z[f(y) + f(xz)  f(x  y  z)] /2 La probabilité que l’un de ces deux évenements se produise est donc au plus . Ainsi Pry,z[f(xy) + f(z) = f(y) + f(xz)]  1-.

45. Au lieu d’écrire f(xy) + f(z) = f(y) + f(xz), il est plus pratique d’écire f(xy) - f(z) = f(xz) – f(y). 1 - · Pry,z[f(xy) - f(y) = f(xz) – f(z)] = t2 {0,1} Pry,z[f(xy) - f(y) = t Æ f(xz) – f(z) = t] = t2 {0,1} Pry,z[f(xy) - f(y) = t] ¢ Pry,z[f(xz) – f(z) = t] = t2 {0,1} (Pry[f(xy) - f(y) = t])2 Prenons maintenant t = l(x). On a alors Pry[f(xy)-f(y) = t] = p(x) et Pry[f(xy)-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)

46. Test de linéarité (détails) On a donc pour tout x, x’ • Pry[l(x) = f(xy) – f(x)] = p(x)  1-. • Pry[l(x’) = f(xx’y) – f(xy)]  1-. • Pry[l(xx’) = f(xx’y) – f(y)]  1-. La probabilité que ces trois choses surviennent est au moins 1-3 > 0. Et donc avec probabilité 1-3 on a l(x) + l(x’) = l(xx’). Cela est vrai pour tous les x, x’. De plus si l(x) + l(x’) = l(xx’) avec probabilité > 0 alors en fait cela est vrai et donc l est linéaire.

47. É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 • Si fi est linéaire alors E(x) = fi(x). • 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)!

48. Évaluateur de fonction (détails) Algorithme pour l’évaluateur: choisir un y aléatoirement et retourner E(x) = fi(xy) – 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 • Pry[fi(y) = li(y)]  1- • Pry[fi(xy) = li(xy)]  1- Donc Pry[fi(xy) = li(xy)  fi(y) = li(y)]  1-2. Dans ce cas on aura E(x) = fi(xy) – fi(y) = li(xy) – li(y) = li(x).

49. 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: • Si f1,f2 et f3 sont du type L1a, L2a et L3a pour un même a  {0,1}n alors le test est passé avec probabilité 1. • S’il n’existe aucun a  {0,1}n tel que l1, l2 et l3 sont du type L1a, L2a et L3a alors le test détecte cela avec une probabilité  > 0.

50. Test de cohérence (détails) Algorithme: • Choisir aléatoirement x, x’ et x’’  {0,1}n et y  {0,1}n2. • 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. • 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). • Accepter si l1(x)l1(x’) = l2(x±x’) et si l1(x’’)l2(y) = l3(x’’±y).