IFT-66975

Complexité d’espaceL, NL, PSPACE

P-complétude et NC

Complexité d’espace

Le temps de calcul est la ressource la plus naturelle à considérer pour mesurer la complexité d’un problème.

L’espace (quantité de mémoire) est clairement la seconde ressource dont on se soucie le plus en pratique.

On veut développer pour cette mesure une taxonomie de complexité aussi riche que celle existant pour le temps.

On mesure la mémoire utilisée par une machine de Turing en comptant le nombre de cellules du ruban utilisées lors d’un calcul.

On veut éviter de compter les cellules utilisées pour décrire le mot d’entrée x. Ainsi il est possible de dire d’un calcul qu’il utilise moins de |x| cellules de mémoire.

x1 x2 x3 xn

...

Contrôle finide M

(déterministe ou non)

Machines de Turing à ruban d’entréeMachines de Turing à ruban d’entrée

Ruban d’entrée(lecture seulement)

Ruban de travail(lecture/écriture)

Une transition de la machine de Turing à l’état q, lisant le symbole e sur le ruban d’entrée et le symbole t sur le ruban de travail spécifie:1. Le nouvel état q’ du contrôle fini;2. Un éventuel mouvement (droite, gauche) pour chaque tête de

lecture;3. Un symbole écrit sous la tête du ruban de travail.

Une telle machine de Turing peut être non-déterministe.

La complexité d’espace d’une m.t. est la fonction s: N N telle que s(n) est le plus grand nombre de cases du ruban de travail utilisées sur une entrée de longueur n.

Dans le cas d’une machine non-déterministe, s(n) = plus grand nombre de cases du ruban de travail utilisées sur une entrée de longueur n pour une certaine suite de choix non-déterministes.

Définitions:Pour f: N N, on définit

DTAPE(f) = classe des langages reconnus par une machine déterministe en espace O(f).

NTAPE(f) = classe des langages reconnus par une machine non-déterministe en espace O(f).

Note: la notation DSPACE et NSPACE est parfois utilisée.

Exemples

Les langages réguliers peuvent être reconnus en espace 0.

On peut montrer que DTAPE(1) est exactement la classe des langages réguliers. (pas facile)

En fait, même DSPACE(o(log log n)) ne contient que les langages réguliers. (démonstration ++ difficile)

s-t-connexité est dans NTAPE(log n).

Entrée: graphe dirigé G = (V,E) et s,t V.

Question: existe-t-il un chemin de s à t?

Idée: choisir non-déterministement une suite de sommets et vérifier qu’ils relient s à t. Mais attention: on ne peut pas écrire notre choix sur le ruban!

Algorithme pour s-t-connexité:1. Entrée: graphe G, avec |V| = n et s,t

V;2. Initialiser un compteur c := 0;3. Initialiser point courant p := s;4. Si p = t alors accepter; 5. Si c = n alors rejeter; 6. Choisir non-déterministement un v

V. Si (p,v) E, alors p := v et c := c+1;

7. Répéter 4-6.

Espace utilisé: log n bits pour c, log n bits pour se souvenir du choix de v.

s-t-connexité pour des graphes non-dirigés est dans DTAPE(log n).

Résultat très récent et très subtil.

L’acyclicité d’un graphe non dirigé est également calculable en espace O(log n) (exercice du devoir 3).

Trois nouvelles classes importantes

L = DTAPE(log n).

NL = NTAPE(log n).

PSPACE = c>0 DTAPE(nc).

NPSPACE c>0 NTAPE(nc).

Définition: La fonction s: N N est espace-constructible s’il existe une m.t. déterministe utilisant un espace s(n) qui étant donné x écrit sur son ruban de travail la représentation binaire de s(|x|).

En particulier, si s est espace-constructible on peut en espace s(|x|) délimiter une région de s(|x|) cellules du ruban de travail.

(Note: toute fonction “raisonnable” est espace-constructible.)

Théorème: [Savitch]Si s: N N est espace-constructible et si

s(n) log n, alorsNTAPE(s(n)) DTAPE(s2(n)).

Corollaire:PSPACE = NSPACE

Contraste important avec la complexité de temps où on pense que la simulation d’une machine non-déterministe ne peut se faire qu’à un coût exponentiel (à ce qu’on sache).

Démonstration:Supposons que L est reconnu par une m.t. à ruban d’entrée non-déterministe M qui utilise un espace s(n). On veut construire une m.t. déterministe M’ qui reconnaît L avec espace s2(n).

Idée maîtresse: analyser le graphe de configurations de M.

Soit Q les états de M et l’alphabet de ruban. Une configuration de M sur une entrée de longueur n est un tuple dans Q {1, ..., n} {1, ..., s(n)} s(n) qui spécifie un état, une position de la tête de lecture sur le ruban d’entrée, une position de la tête de lecture sur le ruban de travail et un contenu des s(n) premières cellules du ruban de travail.

Le graphe de configurations de M sur l’entrée x, est le graphe dirigé GM,x = (V,E) avec

V = Q {1, ..., |x|} {1, ..., s(|x|)} s(|x|)

[(q,i,j,w),(q’,i’,j’,w’)] E si la configuration (q’,i’,j’,w’) peut être atteinte à partir de la configuration (q,i,j,w) lorsque M a reçu x en entrée.

La configuration K0 = (q0, 1, 1, bs(|x|)) est la configuration initiale. La configuration Kacc = (qacc, 1, 1, bs(|x|)) est la configuration acceptante.

On peut supposer que la m.t. M n’atteint l’état acceptant qu’après avoir effacé le contenu de son ruban de travail et ramené les deux têtes de lecture à gauche. Donc, M accepte x si et seulement s’il existe dans GM,x un chemin de la configuration initiale à la configuration acceptante.

La machine déterministe M’ va fonctionner en vérifiant cette condition en utilisant O(s2(n)) cellules de mémoire. Notez qu’une configuration de M peut être décrite avec O(s(n)) symboles car s(n) log n.

Comme s(n) log n, on a |GM,x| |Q| n s(n) ||s(n) = 2O(s(n)).

Que fait M’? 1. Étant donné x, M’ calcule s(|x|) et délimite

s(|x|) cellules de travail.

2. Lorsque deux configurations K1, K2 de M sur x sont décrites sur le ruban de travail de M’ on veut calculer le prédicat Tj(K1,K2) qui est vrai si K2 est atteignable à partir de K1 sur entrée x en au plus 2j étapes. On va montrer que c’est faisable en espace O((j+1) s(n)).

Si j = 0, il suffit de générer à partir de K1= (q,i,j,w) les deux configurations atteignables en 1 étape par M. Plus précisément, M’ lit xi et consulte les fonctions de transition de M pour calculer les deux configurations possibles K1’ et K1’’ qu’il compare avec K2. L’espace utilisé est bien O(s(n)).

2. M’ calcule Tj(K1,K2) = K2 atteignable de K1 en au plus 2j étapes.

Si j 1, M’ procède par récurrence. On aTj(K1,K2) K3: Tj-1(K1,K3) Tj-1(K3,K2)

M’ essaie donc toutes les configurations possibles K3 en ordre lexicographique. Le temps nécessaire est considérable car on a 2O(s(n)) candidats pour K3. Cependant, l’espace nécessaire est O(s(n) + 2j s(n)) tel que promis.

3. M’ accepte x si et seulement si TO(s(n))(K0,Kacc) qui est calculé en espace O(s2(n)). Puisque M accepte x si et seulement si Kacc est atteignable à partir de K0 sans repasser deux fois par une même configuration, on a bien que M accepte le même langage que M.

Relations avec les classes de temps

Pour f: N N, f(n) log n, f espace-constructible et calculable en temps 2f(n):

DTIME(f) DTAPE(f) DTIME(2O(f))

NTIME(f) NTAPE(f) DTIME(2O(f)) DTAPE(f2).

La seule inclusion non-triviale est NTAPE(f) DTIME(2O(f)).

Soit M une m.t. non déterministe avec complexité d’espace f. On peut en temps O(2O(f)) construire entièrement le graphe GM,x et vérifier si Kacc est atteignable à partir de K0 à l’aide d’une fouille en profondeur (par exemple).

On a donc les inclusionsL NL P NP PSPACE = NPSPACE.

Théorème: PH PSPACE.

Démonstration: On montre par récurrence que pout tout k 0 on a k PSPACE et k PSPACE.

Pour k = 0 on a 0 = 0 = P PSPACE.

Si k 1 on sait que L k s’il existe un langage L’ k-1 tel que L = {x | y {0,1}p(|x|): (x,y) L’}.On peut essayer tous les y possibles en utilisant un espace borné par O(p(|x|))! Par récurrence on a que (x,y) L’ peut être vérifié avec complexité d’espace polynomiale. Donc k PSPACE. Par symmétrie k PSPACE.

On a donc les inclusions

L NL P 2 ... PH PSPACE

Par diagonalisation on peut démontrer que L PSPACE. Donc au moins une des inclusions de cette chaîne est stricte. On pense que toutes ces inclusions sont strictes mais aucun résultat n’est démontré.

NP

co-NP

PSPACE-complétude Un problème K de PSPACE est

PSPACE-complet si pour tout L PSPACE on a L p K.

La PSPACE-complétude est une très forte indication qu’un problème n’admet pas d’algorithme efficace. De nombreux problèmes naissant de la théorie des jeux sont PSPACE-complets.

Formule Booléenne quantifiée (QBF)

Entrée: une formule booléenne quantifiée :Q1x1 Q2x2 ... Qnxn: (x1, ..., xn)

où Qi {,} et est une formule booléenne avec variables xi.

Question: La formule est-elle vraie?

À noter que le nombre d’alternations entre les quantificateurs existentiels et universels n’est pas borné, contrairement aux problèmes SATk

cir.

Théorème: QBF est PSPACE-complet.

Démonstration: On veut d’abord montrer QBF PSPACE.

Supposons Q1 = . Alors est vraie si une des deux formulesQ2x2 ... Qnxn: E(1,x2,...,xn) ou

Q2x2 ... Qnxn: E(0,x2,...,xn)est vraie. On peut ainsi bâtir un algorithme récursif. La base de la récursion est l’évaluation d’une formule sans variable, ce qui se fait en temps polynomial. La gestion de la récurrence nécessite que l’on conserve en mémoire au plus n bits.

Soit L PSPACE, reconnu par la machine M utilisant un espace p(n). On veut montrer L p QBF.

Considérons encore le graphe de configurations de M sur l’entrée x. Cette fois M est déterministe donc il existe au plus une arête sortante de chaque configuration.

On a toujours: x L si et seulement s’il existe un chemin de longueur 2O(p(|x|)) de K0 à Kacc dans le graphe de configurations.

On va montrer comment construire en temps polynomial une formule booléenne quantifiée S(x) qui est vraie si et seulement s’il existe un tel chemin.

On réutilise l’idée de Savitch. Pour deux configurations K1, K2 on définit Tj(K1,K2) s’il y a un chemin de longueur 2j entre K1 et K2. On aura alors S(x) = TO(p(|x|))(K0,Kacc).

On a vu que:Tj(K1,K2) K3: Tj-1(K1,K3) Tj-1(K3,K2)

Chaque configuration peut être représentée par une chaîne de O(p(n)) bits et donc on peut voir “K3” comme O(p(n)) quantificateurs existentiels.

En utilisant les idées du théorème de Cook-Levin, on peut écrire une formule AK1,K2

(x) qui est vraie si

et seulement si T0(K1,K2).

Donc, on peut utiliser récursivement Tj(K1,K2) K3: Tj-1(K1,K3) Tj-1(K3,K2)

pour construire une formule quantifiée qui est vraie si et seulement si TO(p(|x|))(K0,Kacc). Cependant, la taille de cette formule est exponentielle ce qui est inacceptable.

Pour éviter cela, on utilise un pour simuler le dans cette formule et profiter de sa symmétrie.

Tj(K1,K2) K3 (K4,K5) {(K1,K3), (K3,K2)}: Tj-1(K4,K5)

Tj(K1,K2) K3 (K4,K5) {(K1,K3), (K3,K2)}: Tj-1(K4,K5)

En utilisant cette équivalence, on voit que si Tj-1 peut être représenté par une formule de taille r, alors Tj peut être représenté par une formule de taille O(r+p(|x|)).

Comme T0 peut être représenté par une formule de taille p(|x|), on peut donc construire une formule quantifiée S(x) de taille O(p2(|x|)) qui est vraie si et seulement si TO(p(n))(K0,Kacc). Cette formule est vraie si et seulement si x L.

Puisque S(x) a été construite en temps polynomial on a bien que L p QBF.

Stratégies de jeux gagnantes De façon abstraite, un jeu entre Alice et

Bob est une compétition se déroulant en n rondes de coups.

Pour chaque ronde, Alice joue un coup et Bob joue un coup (selon des règles spécifiées).

Après n rondes, l’un des deux joueurs est déclaré gagnant, selon une règle préétablie. L’identité du gagnant dépend de la suite de coups joués.

On dit qu’Alice a une stratégie gagnante pour le jeu J si elle peut toujours gagner lorsque les deux joueurs jouent de façon optimale.

En d’autres mots, Alice peut jouer un coup à la première ronde tel que peu importe le coup joué par Bob elle peut jouer un second coup tel que peu importe le second coup joué par Bob ... Alice peut jouer un dernier coup tel que peu importe le dernier coup de Bob, Alice est gagnante.

On retrouve des exemples de jeu un peu partout en IA mais aussi en économie, en sociologie, en sciences stratégiques etc.

La question fondamentale à propos de tout jeu est: Alice a-t-elle une stratégie gagnante?

Exemple: le jeu Géographie.

À la ronde 1, Alice choisit un nom de ville du monde qui commence par “A”. Bob doit répondre par un nom de ville du monde qui commence par la dernière lettre de la ville choisie par Alice. On alterne ainsi sans réutiliser la même ville. Le premier qui ne peut nommer une ville a perdu.

Il se peut qu’Alice ait une stratégie gagnante aujourd’hui mais pas demain!

On définit Géographie Généralisée (GG):

Entrée: une liste de villes représentée comme un graphe dirigé G avec un point de départ distingué s V.Question: Existe-t-il une stratégie gagnante pour Alice dans le jeu suivant? On part du point s. Chaque coup à partir du point v correspond au choix d’un point v’ non visité avec (v,v’) E. Le premier joueur qui n’a pas de coup possible a perdu.

GG est PSPACE-complet.

On a tout d’abord GG PSPACE.

On construit un algorithme récursif qui détermine si Alice peut gagner sur le graphe G à partir du point s.

Algorithme A1. Entrée: G,s.2. Si s a degré sortant 0, alors G,s est perdant.3. Sinon, pour chaque si tel que (s,si) E faire

appel récursif A(G’,si) où G’ est G – {s}. Si tous ces appels acceptent alors Bob aura une stratégie gagnante peut importe le coup de Alice donc G,s est perdant. Sinon, G,s est gagnant.

A peut être implémenté en espace O(|G|).

On montre maintenant QBF p GG.

On veut donc transformer en temps polynomial une formule quantifiée en un graphe G avec un point de départ s tel que est vraie si et seulement si Alice gagne le jeu G,s.

Pour se simplifier la tâche, on suppose que est de la forme = x1 x2 x3 x4... Qk xk : (x1,...,xn)où est en 3-CNF.

La plupart des jeux de stratégie (go, échecs, dames, tic-tac-toe, othello) sont des jeux se jouant sur une grille fixe. Donc, selon nos définitions, on peut déterminer si Alice a une stratégie gagnante en temps constant!

La plupart de ces jeux (pas les échecs) se généralisent naturellement à des grilles n n arbitrairement grandes. On peut montrer que des versions généralisées du go, des dames, d’othello, etc. donnent naissance à des problèmes PSPACE-complets.

Problèmes NL-complets

Puisque NL P, tous les problèmes non-triviaux de NL sont NL-complets sous les transformations polynomiales.

On a donc besoin d’utiliser une notion de réduction beaucoup plus restrictive afin d’obtenir une notion intéressante de NL-complétude.

Fonctions calculables en espace log

Une fonction f: * * est calculable en espace logarithmique s’il existe une machine avec un ruban d’entrée (lecture seulement), un ruban de travail (lecture/écriture) et un ruban de sortie (écriture seule) qui en entrée x produit f(x) sur le ruban de sortie et utilise O(log n) cellules du ruban de travail.

Transformations logarithmiques

Un problème A est logarithmiquement réductible au problème B (A log B) s’il existe une fonction f calculable en espace logarithmique qui transforme les instances de A en instances de B tel que

x: x A f(x) B.

Propriétés à noter:

1. Si A log B et B log C alors A log C.

2. Si A log B et B NL alors A NL.

3. Si A log B et B L alors A L.

4. Si A log B alors A p B.

On dit que B est NL-complet si B NL et pour tout A NL, on a A log B.

On dit que B est P-complet si B P et pour tout A P, on a A log B.

Encore une fois ces notions ne sont intéressantes que parce que l’on peut trouver des exemples naturels de problèmes NL-complets et P-complets.

Théorème: s-t-conn est NL-complet.

Démonstration:On a déja montré s-t-conn NL.

Soit A NL et M une m.t. non-déterministe avec complexité de mémoire O(log n) qui accepte A. Pour tout x, on veut construire un graphe G(x) avec deux points s,t tels qu’il y a un chemin de s à t si et seulement si M accepte x.Ce graphe est tout simplement le graphe des configurations GM,x avec s = K0 et t = Kacc. Il est facile de voir qu’une représentation de ce graphe est calculable en espace logarithmique.

Note: si L NL alors s-t-conn n’est pas dans L. (C’est bien sûr le but des résultats de complétude)

Il existe plusieurs autres problèmes intéressants qui sont NL complets, notamment 2SAT.

NL vs co-NL On pense que NP co-NP. Plus

précisément, il semble que la complexité de temps non déterministe d’un langage K peut être radicalement différente que la complexité de temps non déterministe du complément de K.

Soupçonne-t-on la même chose pour la complexité d’espace?

Non car co-NPSPACE = PSPACE = NPSPACE!

Qu’en est-il pour NL et co-NL?

Théorème: [Immerman-Szelepcsényi]NL = co-NL

Théorème très surprenant au moment de sa découverte.Pour le montrer, il suffit de montrer que le complément de s-t-conn fait partie de NL. Appelons ce problème s-t-unconn.

Comment montrer s-t-unconn NL?

Supposons d’abord qu’en plus de G, s, t, on reçoit en entrée le nombre c de points de G qui sont atteignables à partir de s. Soit A(s) l’ensemble de ces points.

Notre algorithme fonctionne comme suit: pour chaque point u V – {t}, choisir non-déterministement si u A(s) ou non. Lorsque l’on choisit u A(s), on vérifie ce choix en trouvant non-déterministement un chemin de s vers u. Si on a choisi c points dans A(s) et validé ce choix pour chacun alors on accepte.

Reste à calculer c. Soit Ai les points atteignables en au

plus i étapes à partir de s. On a donc A0 = {s} et Ai Ai+1 et A|G| = A(s). Soit ci = |Ai|.

On va montrer comment calculer ci+1 à partir de ci grâce à notre machine non-déterministe.(Idée similaire à la précédente)

Algorithme C calculant ci+1 à partir de ci. On veut faire en sorte que pour chaque choix non-déterministe, C rejette ou calcule ci+1.

1. Entrée: G, s, ci.

2. ci+1 := 0;

3. Pour chaque v V faire 1. intialiser compteur d:=0;2. Pour chaque u V

1. choisir non-déterministement si u Ai.

2. Si on choisit u V alors choisir non-déterministement et vérifier un chemin de longueur i de s à u. Si échec rejeter.

3. Si réussite d:= d+1;4. Si (u,v) E alors flag:= 1;

3. Si d ci rejeter.

4. Si flag = 1, alors v Ai+1 alors ci+1 = ci+1 +1.

4. Retourner ci+1.

Remarques:Il faut un vrai miracle pour que C ne fasse pas des choix non-déterministes qui l’amènent à rejeter.

La seule possibilité pour que C ne rejette pas est que

1. Pour chaque v V, la boucle traitant v fait toujours la bonne hypothèse en choisissant u Ai ou u Ai.

(Si u Ai est incorrect, alors impossible de trouver un chemin de s à u. Si u Ai est incorrect on aura d < ci.)

2. Pour chaque u Ai, un chemin de longueur i de s vers u est correctement choisi.

Lorsque ces miracles ont lieu simultanément C ne rejette pas et calcule ci+1 correctement. À noter aussi que la complexité d’espace de C est O(log n) car on n’a jamais besoin d’inscrire plus que trois points du graphe et deux compteurs en mémoire.

Algorithme NL pour s-t-unconn

1. Entrée: graphe G, source s, cible t;2. c0 := 1. Calculer c1 puis c2 et ainsi de suite

jusqu’à c = c|G|. (Forte probabilité d’échec mais le calcul de c|G| est correctement effectué sur au moins un choix non-déterministe.)

3. initialiser compteur d:=0;4. Pour chaque u V-{t} choisir non-

déterministement u A(s) ou u A(s).1. Si u A(s), choisir et vérifier un chemin de s

vers u. Si échec rejeter, sinon d := d+1;

5. Si d = c alors accepter, sinon rejeter.

Autres classes d’espace logarithmique

On peut également définir des classes probabilistes telles que RL, BPL, PL.

On a presque réussi à démontrer que RL = L.

De façon générale, on croit que ces classes ne sont pas beaucoup plus grandes que L.

Algorithmes parallèles Le problème s-t-conn peut-être calculé

rapidement par un algorithme massivement parallèle.

Supposons |G| = n et utilisons n2 log n processeurs.

On peut imaginer les n2 premiers processeurs sont responsables chacun de calculer T0(u,v) pour une paire (u,v).

Les n2 suivants calculent chacun un T1(u,v) grâce à la relation T1(u,v) m: T0(u,m) T0(m,v).

Avec log n niveaux on peut donc calculer Tlog n(s,t). Le temps à chaque niveau est linéaire donc le gain n’est pas appréciable.

Pourquoi s’arrêter en si bon chemin?

Considèrons le processeur qui calcule Tj(u,v) m: Tj-1(u,m) Tj-1(m,v).

Remplaçons le par n processeurs, chacun calculant Tj-1(u,m) Tj-1(m,v) pour un m! Ces réponses sont ensuite combinées par un OU d’arité n. (ce qui demande à nouveau n processeurs).

Il existe donc un algorithme massivement parallèle qui calcule s-t-conn en temps O(log2 n).

La classe NC

Grossièrement la classe de complexité NC est l’ensemble des langages calculables par O(nc) processeurs en temps O(logd n).

Puisque le nombre de processeurs est polynomial, on a NC P. Là encore, on croit que l’inclusion est stricte.

Modèle plus précis de calcul parallèle: les PRAM (parallel random-access machines).

Informellement, NC correspond aux problèmes ayant un algorithme parallèle très efficace. Mais l’implémentation d’algorithmes massivement parallèles est souvent trop délicate pour que cette correspondance soit réaliste.

Par contre, il est raisonnable de postuler qu’un problème en dehors de NC n’admet pas d’algorithme parallèle très efficace.

Exemples de problèmes dans NC:

st-conn Tous les problèmes de NL! Multiplication de matrices Calcul de déterminant de matrice Calcul d’inverse de matrice Évaluation de formule Booléenne etc.

P-complétude

Si A log B et B NC, alors A NC.

Ainsi si NC P alors si K est P-complet on a K NC.

Les problèmes P-complets sont intrinsèquement séquentiels.

Soit CVP le problème suivant:

Entrée: circuit booléen C sans variables.

Question: Quel est la valeur de sortie du circuit?

Théorème: CVP est P-complet.

Clairement, on a CVP P: on peut calculer la valeur de chaque porte du circuit niveau par niveau.

Soit maintenant A un problème de P et M la m.t. déterministe qui reconnaît A en temps polynomial.

Pour chaque x, on peut réutiliser notre construction pour Cook-Levin pour obtenir en espace logarithmique un circuit C(x) dont la valeur de sortie est 1 si et seulement si M accepte x.

b ... b b

#

#

#

#

#

#

#

#

q0 x1 x2 ... xn

nk

nk

configinitiale

2ème config

config finale

Tableau du calcul de M

Chaque cellule [i,j] contient un symbole de l’alphabet ou un état q Q. On veut construire à partir d’une entrée x à M un circuit C qui évalue à 1 si et seulement si M accepte x, donc si et seulement si le tableau aboutit dans une configuration acceptante.

Chaque cellule va être transformée en un ensemble || + |Q| portes dans le circuit. La structure du circuit est donc très régulière, ce qui facilite sa construction en espace logarithmique.

Le reste n’est qu’une question de détails. (!) (voir 14.2 de Wegener)

Il existe de très nombreux exemples de problèmes P-complets:

Horn-SAT programmation linéaire ordre DFS Max-flow etc.

Notre vue sur le monde

Pour les problèmes de décision, on a vu

L NL NC P NP ... PH PSPACE EXP NEXP

Pour un problème de décision donné K, on voudrait idéalement être capable de montrer que K est C-complet pour une classe C car cela indique que l’on comprend la complexité de K aussi bien que le domaine le permet actuellement.

Seul problème: il existe beaucoup de classes de complexité, dont plusieurs qui sont probablement égales et plusieurs qui ne contiennent que très peu de problèmes dignes d’intérêt.

cf Complexity Zoo