Théorèmes de hiérarchie

Oracles et limites de la diagonalisation

La seule technique vue jusqu’à présent pour séparer des classes de complexité (théorèmes de hiérarchie, par exemple) est la diagonalisation. En deux mots, pour montrer qu’une machineM ne peut pas reconnaître le langage Lque l’on souhaite définir, il s’agit de simulerMsur une entréexet de choisir six∈Lde façon à ce queMcommette une erreur (x∈LssiM(x) =0). Si l’on fait cela sur toutes les machinesM fonctionnant en temps O(t(n))par exemple, on aura alors montré queL̸∈DTIME(t(n)). Dans un premier temps, nous revisiterons les preuves des théorèmes de hiérarchie pour montrer qu’elles entrent bien dans ce cadre. Cette nouvelle présentation des preuves permet de mieux comprendre l’essence de la diagonalisation et de montrer plus facilement des variantes de ces résultats.

En réalité on dispose de peu d’autres techniques de preuve de bornes inférieures. Ce-pendant dans ce chapitre nous verrons une limitation à ce que l’on peut montrer par diagonalisation, grâce au conceptd’oracle. En particulier, nous verrons que les principales questions ouvertes (comme «P=NP? ») ne peuvent être résolues au seul moyen d’une diagonalisation « simple » qui simulerait les machines comme des « boîtes noires », c’est-à-dire sans prendre en compte leur fonctionnement intérieur.

Il n’est toutefois pas évident de caractériser ce qu’on entend par « diagonalisation » et ce sera l’objet d’un résultat assez surprenant : pour une certaine définition de cette méthode, toute séparation peut être démontrée par diagonalisation…

Les oracles nous serviront également au chapitre suivant pour définir de nouvelles classes de complexité, à savoir les différents niveaux de la hiérarchie polynomiale.

7.1 Théorèmes de hiérarchie

Avant de pouvoir revisiter les théorèmes des hiérarchie que nous avons vus, il nous faut revenir sur le concept d’énumération de machines de Turing.

170 Chapitre 7. Oracles et limites de la diagonalisation

7.1.1 Énumération des machines

La preuve des théorèmes de hiérarchie que nous avons vus ne fait pas apparaître clairement le processus de diagonalisation. Pour cela, il est utile de travailler avec des énumérations de machines de Turing comme celle de la remarque3-AL.

7-A Définition

Uneénumération de machinespour une classe de complexitéC est une suite(M_i)_i∈N de codes de machines de Turing telle que :

– pour touti∈N, le langage reconnu parM_i appartient àC; – pour toutA∈ C, il existei tel queM_i reconnaîtA.

De la même façon qu’à la remarque3-AL, il existe des énumérations de machines pour DTIME(t(n)),NTIME(t(n))et DSPACE(s(n))si t(n)et s(n)sont constructibles respecti-vement en temps et en espace. Pour cela, il suffit de prendre une énumération(M_i)des machines de Turing et d’y adjoindre un nouveau ruban comptant le nombre d’opérations ou l’espace utilisé : on arrête alors le calcul de la machineM_idès quei t(n)étapes ont été réalisées, oui s(n)cases visitées (on pourrait aussi prendre(logi)t(n)étapes ou f(i)t(n) pour toute fonctionf tendant vers l’infini). On obtient ainsi une nouvelle énumération (M_i^′)pour la classe concernée.

. ^{7-B Exercice}

En supposant que le code deM_iest simplementi écrit en binaire (un code incorrect étant considéré comme la machine rejetant toujours), montrer que calculer le code deM_i^′à partir dei donné en unaire se fait en tempsO(i)et en espaceO(logi). Indication : il s’agit de calculeri en binaire et d’ajouter au code ainsi obtenu le code du ruban comptant les étapes.

7-C Remarque Nous nous intéressons aux énumérationsefficacesoù le code deM_i est calculable facilement à partir dei comme à l’exercice précédent.

Néanmoins, toutes les classes ne possèdent pas d’énumération efficace : par exemple, il n’y a aucune énumération calculable de la classe probabilisteBPP que nous verrons au chapitre suivant, car décider si une machine a un comportement « de typeBPP » est indécidable.

7.1.2 Hiérarchie déterministe

Contrairement aux preuves des théorèmes de hiérarchie données précédemment, la dia-gonalisation peut être complètement explicitée comme nous allons le voir. Nous allons

7.1. Théorèmes de hiérarchie 171 prouver deux variantes du théorème de hiérarchie en temps déterministe : une version

« infiniment souvent » et une autre « presque partout ». La première n’est autre qu’une version plus faible du théorème2-Jpuisque la différence entref etgdoit être plus grande ((logf(n))(logn)au lieu delogf(n))¹.

7-D Théorème (hiérarchie en temps déterministe infiniment souvent)

Soit f :N→Net g :N→N des fonctions constructibles en temps telles que f(n)̸=0 (pour toutn) et

f(n)(logf(n))(logn) =O(g(n)).

AlorsDTIME(f(n))⊊DTIME(g(n)).

Cette version est appelée « infiniment souvent » car le langageA∈DTIME(g(n))construit vérifie : pour toutB∈DTIME(f(n)), pourune infinité den∈N,B⁼ⁿ̸=A⁼ⁿ (l’infinité denvenant de ce que chaque machineM_i a une infinité de machines équivalentes dans l’énumération).

Idée de la démonstration On construit le langageAmot par mot, spécifiquement pour que chaque machine M_i d’une énumération des machines fonctionnant en temps O(f(n))se trompe au moins sur le mot0ⁱ (cf. figure7.1).

Figure 7.1 – Diagonalisation sur le résultat des calculsM_i(0ⁱ).

Démonstration On peut supposer sans perte de généralité que f(n) =Ω(n) : sinon f ⩽αpour une constante α et g(n) =Ω(n)car elles sont constructibles en temps (cf. exercice 2-I). Alors le langage A = 0^⋆ (contenant exactement les mots 0ⁱ pour i∈N) est dansDTIME(g(n))mais pas dansDTIME(f(n)).

Soit(M_i) une énumération des machines fonctionnant en temps(logi)f(n). Nous allons définir un langageA∈DTIME(g(n))sur l’alphabet {0, 1}qui ne soit reconnu par aucune des machinesM_i. Contrairement à d’habitude, nous n’allons pas définirA par une simple expression ensembliste, mais nous allons plutôt indiquer pour chaque mot s’il appartient àAou non.

1. Une autre différence est qu’ici les deux fonctionsf etgsont constructibles en temps, et pas seulement la fonctiong.

172 Chapitre 7. Oracles et limites de la diagonalisation – Aucun motxcontenant le symbole1n’appartient àA(c’est-à-dire queA⊆0^⋆).

– Le mot0ⁱ appartient àAssiM_i(0ⁱ) =0.

Le langageAainsi défini ne contient que des mots de la forme0ⁿ.

Supposons queA∈DTIME(f(n)): il est donc reconnu par une machineM_i de l’énu-mération. Mais alors0ⁱ∈AssiM_i(0ⁱ) =0, une contradiction. DoncA̸∈DTIME(f(n)). Il reste à montrer queA∈DTIME(g(n)). Voici un algorithme pourAsur une entréex de taillen:

– six̸=0ⁿ,rejeter; – accepterssiM_n(0ⁿ) =0.

Il s’agit donc de construire le code deM_n puis de simuler cette machine sur0ⁿ. Or construire le code de M_n prend un temps O(n) comme on l’a vu à l’exercice 7-B (donc un tempsO(g(n))puisque g(n) =Ω(n)) ; la machineM_nfonctionne en temps (logn)f(n)donc la simulation par la machine universelle du théorème1-Sprend un temps majoré par

α(logn)f(n)(log logn+logf(n))⩽2αf(n)(logf(n))(logn) =O(g(n)).

Au total,A∈DTIME(g(n)). ⊓⊔

La version « presque partout » vérifie quant à elle queAetBdiffèrent pourpresque tout ncomme on le voit dans l’énoncé suivant.

7-E Théorème (hiérarchie en temps déterministe presque partout)

Soit f :N→Net g :N→Ndes fonctions constructibles en temps telles que f(n)̸=0 (pour toutn) et

f(n)(logf(n))(logn) =O(g(n)).

Alors il existeA∈DTIME(g(n))tel que pour toutB∈DTIME(f(n)), il existe m∈Ntel que∀n⩾m,B⁼ⁿ̸=A⁼ⁿ.

Idée de la démonstration La démonstration ressemble à celle du théorème précédent mais on utilise davantage de mots (et non seulement0ⁱ) pour diagonaliser sur plus d’une machine par taille.

Démonstration De même qu’à la proposition précédente, on peut supposer que f(n) =Ω(n)(sinon le langageA=0^⋆convient).

Soit(M_i)une énumération des machines fonctionnant en temps(logi)f(n). Nous al-lons définir un langageA∈DTIME(g(n))sur l’alphabet{0, 1}telle que chaque machine M_i se trompe pour presque toute longueur de mot.

Pour une taille d’entrée n fixée, on note x₀ < x₁ <··· < x₂n−1 les mots de {0, 1}ⁿ ordonnés par ordre lexicographique. On définit alorsAcomme suit sur une entréex de taillen: