Perché le uguaglianze tra le classi di complessità si traducono verso l'alto e non verso il basso?

25

Hey ragazzi, ho capito che il trucco imbottitura ci permette di tradurre classi di complessità verso l'alto - per esempio . Il padding funziona "gonfiando" l'input, eseguendo la conversione (diciamo ad esempio da a ), che produce un algoritmo "magico" che puoi eseguire sull'input imbottito. Anche se questo ha un senso tecnico, non riesco a capire bene come funziona. Cosa sta succedendo esattamente qui? Esiste una semplice analogia per quanto riguarda l'imbottitura? $P=NP \rightarrow EXP=NEXP$ $NP$ $P$

Può fornire una ragione di buon senso perché questo è il caso?

cc.complexity-theory complexity-classes padding

— gabgoh
fonte

11

Vorrei sottolineare che non tutti i risultati della classe di complessità vanno verso l'alto. Ad esempio, se hai dimostrato

, allora ciò implicherebbe

. In generale, i crolli aumentano, mentre le separazioni diminuiscono.

E X P \neq N E X P

$EXP \neq NEXP$

P \neq N P

$P \neq NP$

— Robin Kothari,

infatti. In effetti, questo sembra un buon modo di pensarci, poiché le separazioni sono più intuitive dei collassi.

— gabgoh,

2

@Robin, @gabgoh: anche alcuni crolli vanno verso il basso, ma non per riempire gli argomenti. Vedi ad esempio arxiv.org/abs/cs/9910008 .

— Joshua Grochow,

30

Penso che il modo migliore per ottenere l'intuizione di questo problema sia quello di pensare a quali siano i problemi completi per le classi temporali esponenziali. Ad esempio, i problemi completi per NE sono i problemi standard NP completi su ingressi descrittivamente succinti, ad esempio, dato un circuito che descrive la matrice di adiacenza di un grafico, il grafico è 3-colorabile? Quindi il problema se E = NE diventa equivalente a se i problemi NP sono risolvibili in tempo polinomiale sugli input descrittivamente succinti, ad esempio quelli con una piccola complessità efficace di Kolmogorov. Questo ovviamente non è più forte del fatto che siano risolvibili su tutti gli input. Maggiore è il limite di tempo, minore è la complessità di Kolmogorov degli input rilevanti, quindi i crolli per limiti di tempo più grandi sono in effetti algoritmi che funzionano su sottoinsiemi di input più piccoli.

Russell Impagliazzo

— Russell Impagliazzo
fonte

14

OK, quindi il tuo obiettivo è mostrare che basandosi su $CLASS_1[g(f(n))] = CLASS_2[h(f(n))]$ $CLASS_1[g(n)] = CLASS_2[h(n)]$ (non specifichiamo esattamente cosa siano queste classi, sappiamo solo che sono in qualche modo parametrizzate con la dimensione dell'input). Abbiamo un linguaggio , ha deciso da qualche algoritmo . Ora creiamo una lingua riempiendo ogni parola in , in modo che la sua lunghezza sia ora , e vediamo che è contenuta in $L \in CLASS_1[g(f(n))]$ $A$ $L'$ $x \in L$ $f(n)$ (il nostro nuovo algoritmo fondamentalmente ignora solo gli zeri aggiunti ed esegue sull'ingresso reale, corto). $CLASS_1[g(n)]$ $A'$ $A$

Quello che facciamo è: prendiamo un linguaggio dalla classe più grande e lo riempiamo, in modo che possa essere risolto da un algoritmo più debole che ci fornisce contenimento nella classe più piccola - l'algoritmo più debole può farlo, perché ha la stessa quantità di 'lavoro reale' da fare come prima, ma ha le sue restrizioni (essendo una funzione della lunghezza dell'input) estese estendendo l'input.

Ora sappiamo che e quindi (deciso da un algoritmo ). Vorremmo andare da qui a $L' \in CLASS_1[g(n)]$ $L' \in CLASS_2[h(n)]$ $B'$ $L \in CLASS_2[h(f(n))]$ . Ma questo è semplice: l'algoritmo decide pad sull'input di conseguenza ed esegue sull'input imbottito. $B$ $L$ $B'$

Questo passaggio può essere riassunto come segue: vogliamo decidere nella classe più grande e più intraprendente. Usando le nostre risorse extra, inseriamo l'input ed eseguiamo l'algoritmo decidendo il linguaggio imbottito $L$ .

Naturalmente ci sono alcuni dettagli tecnici coinvolti qui (ad esempio, dobbiamo assicurarci che l'imbottitura possa essere implementata nelle classi che consideriamo), ma li ignoro solo per dare l'intuizione generale.

— Karolina Sołtys
fonte

13

Vedo gli argomenti di riempimento in termini di compattezza della rappresentazione. Pensa a due macchine di Turing traduttore: fa esplodere le istanze e comprime di nuovo. $B$ $C$

L'argomento padding funziona con , componendo con la versione deterministica della TM per il linguaggio nella classe non deterministica inferiore. I risultati di formano collettivamente un linguaggio che non è rappresentato in modo compatto, quindi diventa "più facile". $B$ $B$ $B$

Non è possibile applicare l'idea nell'altro modo, usando , perché solo alcune delle lingue nella classe facile vengono generate facendo saltare le lingue nella classe difficile. $C$

— András Salamon
fonte

5

Per renderlo più intuitivo, guardiamo cosa sta succedendo in modo più astratto!

$pad$

Queste due trasformazioni hanno la seguente proprietà:

$A\subseteq \Sigma^{ * }$ $x\in\Sigma^{ * }$

$pad(x) \in pad(A)$ $x \in A$

$A$ $EXP$ $NEXP$ $pad(A)$ $P$ $NP$

$EXP$

È chiaro che le trasformazioni per l'imbottitura hanno queste proprietà.

$EXP$ $P$ $NEXP$ $NP$

Non ho una discussione formale sul perché al momento non ci siano trasformazioni del genere, ma intuitivamente ciò che András Salamon ha detto è corretto. È facile aumentare le dimensioni degli input, ma non è chiaro come possano essere compressi?

$P=NP$ $NEXP=NTime(2^{n^{O(1)}})$ $x$ $n$ $N=2^{n^{O(1)}}$

$NEXP(n) = NTime(2^{n^{O(1)}}) = NTime(N) \subseteq NP(N) \subseteq P(N) = Time(N^{O(1)}) = Time(2^{n^{O(1)}}) = EXP(n)$

— Kaveh
fonte

1

N = l o g (n)

$N=log(n)$

1

Un terzo modo di pensarci, in realtà, è guardare il contrario. Non ho seguito questo approccio fino alla fine, ma se arriva una grande intuizione, lo pubblicherò come risposta a me stesso.

— gabgoh

1

N = 2^{n^{O (1)}}

$N=2^{n^{O(1)}}$

n \leq N

$n\leq N$

N

$N$

n

$n$

N = \log (n)

$N=\log(n)$

— Kaveh,

1

n

$n$

N = ⌈ \log (n) ⌉

$N = \lceil \log(n) \rceil$

P

$P$

N P

$NP$

E X P

$EXP$

N E X P

$NEXP$

1

N = l o g (n)

$N=log(n)$