Quanto è dura la simulazione esatta di algoritmi e un'operazione correlata sulle classi di complessità

Teaser

Poiché il problema è lungo, ecco un caso speciale che cattura la sua essenza.

Problema: Sia A un algoritmo detrministico per 3-SAT. È il problema di simulare completamente l'algoritmo A (su ogni istanza del problema). P-Space difficile?

(Più precisamente, ci sono ragioni per ritenere che questo compito sia difficile da P-Space, fa qualcosa in questa direzione seguito da congetture CC standard, e c'è speranza di provare che questo compito è X-difficile per qualche classe di complessità X che si presume essere rigorosamente al di sopra di NP.)

Domande correlate : sono-pspace-completi-problemi-intrinsecamente-meno trattabili-di-np-completi-problemi ;

AGGIORNAMENTO MODIFICATO : Esistono varie interpretazioni per "Simulare completamente A". E ci possono essere diverse risposte interessanti secondo l'interpretazione. (Anche Ryan Williams ha proposto un'interpretazione per simulare un algoritmo non deterministico.) Per un certo modo di associare un problema decisionale al compito computazionale "Simula completamente A", Joe Fitzsimons ha trovato un algoritmo A per il quale questo problema decisionale associato è ancora in NP . Se "completamente simulare" si riferisce alla possibilità di uscita dell'intero registro del computer in un determinato passo poi per l'algoritmo di Joe sembra che è ciò che è necessario. Per questa versione (penso, ma non sono sicuro) la risposta di Ryan disegna una$i$$P^{NP}$$P^{NP}$-argomentazione. Joe ha osservato che se di voi è richiesto di fornire tutti i registri (che non è più un problema di decisione) non sorprende che sia necessario intensificare e che le classi di complessità non siano le stesse.

In ogni caso, se abbiamo bisogno di uscita lo stato dei registri ad un passo prescritto poi le risposte di Ruan e Joe suggerisce (ma ancora una volta, non sono sicuro su di esso) che è essenzialmente . Possiamo chiarire che con questa interpretazione l'operazione si sposta di un gradino più in alto nella hiearachy polinomiale e che .$i$$NP^+$$P^{NP}$$PH^+ =PH$

In ogni caso con queste interpretazioni la risposta alla mia domanda teaser è NO .

Ho avuto un'interpretazione più drastica per "simulare completamente un algoritmo A" in mente. (Ma forse l'interpretazione di Joe e Ryan è più interessante.) La mia interpretazione "simulando completamente l'algoritmo A" è che si passa allo stato dei registri ad ogni passo . In particolare, se l'algoritmo non è polinomiale, anche l'output non è polinomiale. Sotto questa drastica interpretazione mi chiedevo se dovessimo credere che per ogni algoritmo A, è P-SPACE difficile, e cosa possiamo dimostrare.C $i$$C_A$

Motivazione:

Questa domanda è stata motivata da una conferenza di Paul Goldberg ( scivoli , il video , la carta ) che descrive un documento con Papadimitriou e Savani. Hanno dimostrato che lo spazio P è completo per trovare eventuali equilibri calcolati dall'algoritmo Lemke-Howson. Il problema per trovare un punto di equilibrio è solo PPAD completo. Questo divario è piuttosto sorprendente e risultati simili sono già descritti nel noto articolo di Papadimitriu: The Complexity of the Parity Argument e Other Inefficient proof of Existence (1991) . (È noto che i problemi completi di PPAD non possono nemmeno essere NP-difficili (a meno che non accadano cose terribili, quindi questo è molto più basso nel mondo della complessità rispetto allo spazio P).

Qual è la domanda

La mia domanda riguarda lacune simili per problemi di complessità computazionale ancora più vecchi e più classici. (Forse questo è già familiare.)

Dato un problema computazionale, possiamo distinguere tra tre problemi

a) Risolvi il problema in modo algoritmico

b) Raggiungere la stessa soluzione di un algoritmo specifico A

c) Simulare l'intero algoritmo A

Naturalmente c) è duro almeno quanto b) che è duro almeno quanto a). I risultati sopra menzionati mostrano un divario tra la difficoltà computazionale dei compiti a) eb) per il problema degli equilibri di calcolo. Vorremmo capire la situazione (e principalmente il divario tra a) ec) per altri problemi computazionali.

La domanda:

La forma di base della domanda con un esempio

Iniziamo con un problema computazionale, Problema X

Un esempio può essere

Problema X: risolvi un'istanza di SAT con n variabili

specifichiamo anche

A: un algoritmo che esegue il Problema X

e poniamo un nuovo problema

Problema Y: simula esattamente l'algoritmo A

e siamo interessati alla difficoltà computazionale del Problema Y. Vogliamo capire la classe di tali problemi Y per tutti gli algoritmi A che risolvono il Problema X originale. Soprattutto vogliamo sapere quanto può essere facile il problema Y (o quanto deve essere difficile essere) se ci è permesso di scegliere l'algoritmo A a piacimento.

L'operazione proposta sulle classi di complessità

Inizia con una classe di complessità che è descritta da un compito computazionale. Dato un algoritmo A per eseguire ogni istanza di questo compito computazionale, considerare una nuova classe di complessità che è descritta dal compito computazionale completamente simulare . Quindi possiamo (si spera) definire un "ideale" di classi di complessitàC A$C$$C_A$$A$

$C^+ = \{C_A:$ per tutti gli algoritmi A}.

Se lasciamo che descriva qualunque cosa un computer digitale possa fare in un tempo polinomiale (quindi non voglio limitare l'attenzione, ad esempio ai problemi di decisione), allora è l'ideale attraversato da stesso.P +$P$$P^+$$P$

Infine, le mie domande

Le mie domande sono:

1) La definizione ha senso (nel senso ampio della parola senso). È ben noto o uguale a (o simile a) qualche cosa ben nota. (La mia formulazione era informale e in particolare quando passiamo da problemi specifici come SAT a una classe di complessità come NP, dobbiamo preoccuparci di varie cose che ho trascurato.)

Le prossime due domande presuppongono che la definizione possa avere un senso o recuperata per avere un senso.

2) Supponiamo di dotarci di tutte le congetture standard relative alla completezza computazionale. Possiamo dire cosa dovrebbe essere per alcune classi di complessità familiari. (Ad esempio , = P-spazio, ..)? EDIT: diverse persone hanno sottolineato che . Quindi> possiamo chiedere invece cos'è ? è ?$C^+$$C=NP$$C$$PSPACE^+=PSPACE$$(P^{NP})^+$$PH^+=PH$

Possiamo indovinare quali sono le classi di complicità modo che sia l'ideale attraversato da ?$C$$C^+$$C$

Quindi la domanda su quanto sia facile il compito computazionale di simulare un algoritmo A per 3-SAT (quando possiamo scegliere l'algoritmo per renderlo il più semplice possibile) è un caso speciale interessante.

3) Esiste la speranza di provare qualcosa su questa operazione?

Naturalmente, se si dimostra che tutte le classi di complessità in sono P-space difficili, ciò mostrerà che implica , che (penso) sarebbe un risultato enorme e altamente inaspettato. Ma se mostri che tutte le classi di complessità in sono difficili da dire nel terzo livello del polinomio Hieararchy (es. ) ciò implicherebbe solo cose che già conosciamo, cose che seguono da il fatto che provoca il collasso di PH.$NP^+$$P=NP$$P=PSPACE$$NP^+$$\Delta_3^{\bf P}$$P=NP$

Problema: Sia A un algoritmo deterministico per 3-SAT. Il problema di simulare completamente l'algoritmo A (su ogni istanza del problema) P-Space è difficile?

Non capisco l'affermazione di questo problema. Ma penso che ci sia un modo naturale per formalizzare la tua domanda più generale che potrebbe far luce su di essa. Forse mi manca completamente il tuo punto, ma spero che trovi ancora qualcosa di interessante da leggere qui.

1) La definizione ha senso (nel senso ampio della parola senso). È ben noto o uguale a (o simile a) qualche cosa ben nota. (La mia formulazione era informale e in particolare quando passiamo da problemi specifici come SAT a una classe di complessità come NP, dobbiamo preoccuparci di varie cose che ho trascurato.)

Un modo per dare un senso al compito simulare esattamente l'algoritmo $Y$ è il seguente. Risolviamo il modello come macchine di Turing a nastro singolo per semplicità; ciò che dirò può essere applicato a qualsiasi modello di calcolo tipico.

Per ogni algoritmo e input x , possiamo definirne la cronologia di calcolo H Y ( x , i , j ) : dati interi i e j che vanno da 0 al tempo di esecuzione di Y , H Y ( x , i , j ) è uguale il contenuto della j esima cella del nastro della macchina di Turing Y in ingresso x nel tempo passo i . (E se la testina sta leggendo il $Y$$x$ $H_Y(x,i,j)$$i$$j$$0$$Y$$H_Y(x,i,j)$$j$$Y$$x$$i$$j$nella cella nel passaggio, includi anche questo insieme allo stato della macchina.) Naturalmente, le storie di calcolo emergono continuamente nella teoria della complessità.$i$

Ora, si potrebbe sostenere che qualsiasi algoritmo in grado di decidere la lingua

$C_Y = \{(x,i,j,\sigma)~|~H_Y(x,i,j)=\sigma\}$

(o simulare la funzione su tutti gli ingressi) è soluzione del compito esattamente simulazione algoritmo Y , perché ha la capacità di stampare ogni piccola parte di ogni possibile calcolo dell'algoritmo Y . Certamente, in un oracolo di C Y si può fare una simulazione passo-passo Y .$H_Y$$Y$$Y$$C_Y$$Y$

2) Supponiamo di dotarci di tutte le congetture standard sulla complessità computazionale. Possiamo dire cosa dovrebbe essere C + per alcune classi di complessità familiari. (Ad esempio C = NP, C = P-spazio, ..)? Possiamo indovinare quali sono le classi di complessità C in modo che C + sia l'ideale attraversato da C?

Questa è ancora una domanda interessante, sotto la proposta di cui sopra. Per le classi temporali deterministiche, nulla cambia. è solo P : possiamo decidere C Y in polytime, per ogni algoritmo polytime. Analogamente E X P + = E X P . Anche P S P A C E + è ancora P S P A C E . Per classi di complessità temporale non deterministiche, la situazione diventa più interessante. In tal caso, un algoritmo Y può avere più storie di calcolo, quindi$P^+$$P$$C_Y$$EXP^+ = EXP$$PSPACE^+$$PSPACE$$Y$ non è più ben definito. Tuttavia, vogliamo ancora stampare unpo 'dicronologia di calcolo, quindi la nostra "simulazione esatta" dovrebbe isolare una specifica storia di calcolo non deterministica e quindi stampare i suoi valori. Per unalgoritmo N P Y , si può dire che C Y ∈ P N P : possiamo usare l'oracolo N P per cercare binariamente la "prima" storia di calcolo accettabile (in ordine lex), quindi una volta ottenuta, stampa i bit rilevanti. Per unalgoritmo N E X P Y , si può dire C Y$H_Y$$NP$$Y$$C_Y \in P^{NP}$$NP$$NEXP$$Y$ , per ragioni simili.$C_Y \in EXP^{NP}$

Possiamo mettere in una classe più piccola? Non lo so. Si noti che non possiamo semplicemente ridefinire$NP^+$

{ ( x , i , j , σ ) | esiste una H Y tale che H Y ( x , i , j ) = σ }$C_Y =$$(x,i,j,\sigma)~|~$$H_Y$$H_Y(x,i,j)=\sigma$

per provare a mettere in N P , perché abbiamo bisogno che la stringa di cronologia sia la stessa per tutti i quadrupli che coinvolgono x , al fine di "simulare esattamente l'algoritmo Y ".$C_Y$$NP$$x$$Y$

Comunque, questo problema di non essere in grado di "stampare un testimone" su un calcolo senza passare a E X P N P si presenta in alcune situazioni, come la complessità del circuito. Se N E X P ha circuiti dimensioni polinomiali, allora è anche vero che C Y ∈ P / p o l y per ogni deterministico 2 n k tempo Y ? Impagliazzo, Kabanets e Wigderson$NEXP$$EXP^{NP}$$NEXP$$C_Y \in P/poly$$2^{n^k}$$Y$ha risposto affermativamente a questa domanda nel 2001. La loro dimostrazione è estremamente interessante, invocando strumenti di derandomizzazione e diagonalizzazione (perché la derandomizzazione sarebbe necessaria per un tale risultato?) e risulta essere un teorema molto utile per dimostrare limiti inferiori del circuito per Funzioni $NEXP$

C'è speranza di provare qualcosa su questa operazione?

Forse ... dipende dal fatto che tu sia felice con la formalizzazione di cui sopra della tua domanda. Per un deterministico 3-SAT algoritmo , Credo sopra simulazione esatta di Y problema sarebbe P N P ( 1 ) -duro, dove P N P ( 1 ) è un tempo polinomiale con una query N P . (La fastidiosa sintassi di StackExchange richiede che io scriva (1) invece dell'alternativa. Prima ho detto che C Y dovrebbe essere P N P -hard, ma non sono sicuro dei dettagli: potresti vedere come generalizzare il seguito.)$Y$$Y$$P^{NP(1)}$$P^{NP(1)}$$NP$$C_Y$$P^{NP}$

Diamo una riduzione polytime molti-uno da ogni a C Y . Dato tale L , sia M una macchina che riconosce L che esegue una singola query N P. WLOG, quella query è una formula SAT. Anche WLOG, la query SAT può essere "rimandata" fino all'ultima fase del calcolo, nel senso seguente: esiste un algoritmo di tempo polinomiale A ( x ) che stampa una formula F e il bit b , tale che per tutte le x ,$L \in P^{NP(1)}$$C_Y$$L$$M$$L$$NP$$A(x)$$F$$b$$x$

accetta iff A ( x ) = ( F , b ) tale che ( S A T ( F ) XOR b ) = 1.$M(x)$$A(x)=(F,b)$$SAT(F)$$b$

( può rifiutare se F è soddisfacente, oppure può accettare; il bit b lo cattura.)$M$$F$$b$

Per semplicità, diciamo che quando termina il suo calcolo, sposta la testina del nastro sulla cella 1, scrive "accetta" o "rifiuta" in quella cella e esegue un ciclo per sempre. Quindi, chiedendo se ( F , T , 1 , a c c e p t ) ∈ C Y per T sufficientemente grande ci dirà se F è accettata. (In generale, abbiamo solo bisogno che sia efficiente calcolare l'istanza y di C Y che ci dirà.) Nota che questo dimostra già che C Y è sia N P -hard che$Y$$(F,T,1,accept) \in C_Y$$T$$F$$y$$C_Y$$C_Y$$NP$ -hard; il secondo è vero perché ( F , T , 1 , r e j e c t ) ∈ C Y iff F nonèsoddisfacente.$coNP$$(F,T,1,reject) \in C_Y$$F$

La riduzione finale da a C Y è: dato x , esegui A ( x ) ottenendo ( F , b ) . Se b = 0 quindi uscita ( F , T , 1 , a c c e p t ) , altrimenti se b = 1 uscita ( F , T , 1 , r e j e c $L$$C_Y$$x$$A(x)$$(F,b)$$b=0$$(F,T,1,accept)$$b=1$ .$(F,T,1,reject)$

Per ogni stiamo producendo (in tempo polinomiale) un y tale che M ( x ) accetta sse y ∈ C Y .$x$$y$$M(x)$$y \in C_Y$

(Grazie a Joe per avermi chiesto di essere più chiaro su questa parte.)

Ma non vedo (per esempio) come ottenere -hardness. Per ridurre Σ 2 -SAT al problema, sembrerebbe che dovresti scrivere un'istanza SAT 3-CNF x che simuli l'algoritmo deterministico Y al suo interno (dove Y sta risolvendo le tautologie su vari sottoproblemi). Ma poiché Y non ha un limite di tempo, quel 3-CNF x potrebbe essere enorme, quindi non si ottiene necessariamente una riduzione del tempo polinomiale. A meno che non mi manchi qualcosa.$\Sigma_2 P$$\Sigma_2$$x$$Y$$Y$$Y$$x$

Inizialmente ho pubblicato una risposta errata, quindi spero che questo sia un miglioramento.

Inizierò considerando l'esempio 3SAT. Nel tuo commento sulla risposta di Ryan dici

Sono interessante quanto sia difficile simulare un algoritmo deterministico Y per 3-SAT. E la domanda è se non importa cosa sia Y questo è P-spazio difficile.

La risposta a questa domanda è che non è difficile per PSPACE almeno per alcuni Y, supponendo che NP PSPACE, ma che esistano altri algoritmi per i quali è difficile per PSPACE. Mostrare quest'ultimo è banale: costruiamo semplicemente un algoritmo che interpreta la stringa di bit che rappresenta la formula 3SAT invece come un problema TQBF, che risolve quindi prima di risolvere l'istanza 3SAT. Ovviamente non c'è nulla di speciale in TQBF in questo caso, quindi l'algoritmo può essere reso arbitrariamente difficile da simulare. Quindi dovremmo preoccuparci solo di limiti inferiori nella simulazione di qualsiasi algoritmo per un dato problema, piuttosto che di un algoritmo specifico.$\neq$

Con questo in mente, costruiamo il seguente algoritmo per risolvere 3SAT:

Prendi un registro di bit (inizialmente tutti impostati su 0) per contenere una soluzione di prova, insieme a un registro contenente l'istanza 3SAT, un registro contatore di dimensioni ⌈ log 2 ( c + 1 ) ⌉ inizialmente impostato su 1 e e due flag bit (chiamare questi il ​​flag fail e il flag accetta). Qui c è il numero di clausole. L'algoritmo procede quindi come segue:$n$$\lceil\log_2 (c + 1)\rceil$$c$

• Se il valore del contatore della clausola è inferiore o uguale a c e la soluzione di prova non è 111 ...... 1 , verificare se la clausola k è soddisfatta. In caso contrario, impostare il bit di errore. Incrementa il contatore.$k$$c$$111......1$$k$
• Se il valore del contatore della clausola è inferiore o uguale a c e la soluzione di prova è 111 ...... 1 , verificare se la clausola k è soddisfatta. In caso contrario, impostare il flag di errore. Incrementa il contatore.$k$$c$$111......1$$k$
• Se supera c e la soluzione di prova non è 111 ...... 1 , verificare se il flag di errore è impostato. In tal caso, incrementare la soluzione di prova, reimpostare il contatore k su 1 e deselezionare il flag di errore. Se il flag di errore non è stato impostato, impostare il flag di accettazione, impostare il contatore della clausola k su zero, impostare la soluzione di prova su zero e arrestare.$k$$c$$111......1$$k$$k$
• Se supera c e la soluzione di prova è 111 ...... 1 , verificare se il flag di errore è impostato. Se il flag di errore non è stato impostato, impostare il flag di accettazione. Impostare il contatore di clausole k su zero, impostare la soluzione di prova su zero e arrestare.$k$$c$$111......1$$k$

Quando l'algoritmo si interrompe, lo stato del flag accetta indica se la formula 3SAT può essere soddisfatta o meno.

Ora, se voglio calcolare lo stato dell'algoritmo al momento, un algoritmo per calcolare questo in tempo polinomiale con una singola chiamata a un oracolo NP come segue:$i$

Si noti che per qualsiasi , supponendo che il bit di accettazione non sia stato ancora impostato, lo stato dei registri può essere calcolato in tempo polinomiale, poiché il valore di k e il registro della soluzione di prova t sono semplicemente funzioni di i . Determinare se il flag di errore è impostato può essere eseguito in un tempo polinomiale, semplicemente controllando se lo stato corrente del registro della soluzione di prova soddisfa tutte le clausole inferiori o uguali al valore corrente di k . Se e solo in caso contrario, viene impostato il flag di errore. Il flag accetta è impostato su zero.$i$$k$$t$$i$$k$

Allo stesso modo, se il bit di accettazione è già stato impostato, lo stato dei registri può essere calcolato in modo efficiente, poiché tutto è zero tranne il bit di accettazione, che è impostato.

Quindi l'unica durezza viene nel determinare se il bit di accettazione è impostato. Ciò equivale a determinare se l'istanza 3SAT fornita ha una soluzione inferiore a . In tal caso, il bit di accettazione deve essere necessariamente impostato e, in caso contrario, il bit di accettazione deve essere necessariamente zero. Chiaramente questo problema è esso stesso NP completo.$t$

Pertanto, lo stato del sistema nella fase può essere determinato in tempo polinomiale con una singola query in un oracolo NP.$i$

Aggiornamento importante: inizialmente avevo frainteso la formulazione della simulazione esatta di Ryan come un problema di decisione, quindi la mia affermazione che la versione di decisione era in NP era errata. Dato il problema di decidere se il bit al punto i sull'ingresso x come formulato nella risposta di Ryans, ci sono 3 possibilità:$j$$i$$x$

1. Questo bit è costante indipendentemente dal fatto che sia soddisfacente. Poiché in questo momento ci sono solo due stati possibili per il sistema (entrambi i quali possono essere calcolati in P) che determinano se questo è il caso e, in tal caso, se il valore è uguale a σ è in P.$F$$\sigma$
2. Il bit è uguale a se F ∈ S A T , e diversamente diverso. Questo problema è chiaramente in NP, poiché l'assegnazione soddisfacente di F funge da testimone.$\sigma$$F\in SAT$$F$
3. Il bit è uguale a se F ∈ U N S A T nel qual caso il problema è quindi in coNP.$\sigma$$F\in UNSAT$

Chiaramente decidendo quale di questi tre è il caso può essere fatto in tempo polinomiale, semplicemente confrontando il valore che assume bit se e se F ∈ U N S A T . Così l'esatto problema di simulazione è in NP ∪ CONP. Così, come Ryan di limite inferiore e la mia partita limite superiore, assumendo entrambi sono corretti, penso che abbiamo una risposta: C Y = N P ∪ c o N P .$F\in SAT$$F\in UNSAT$$\cup$$C_Y = NP\cup coNP$

Si noti che in questo caso non c'è nulla di speciale in 3SAT e lo stesso potrebbe essere fatto per qualsiasi problema in NP. Inoltre, lo stesso trucco può essere utilizzato per qualsiasi classe di complessità non deterministica, non solo NP, che sembrano essere difficili da simulare. Per le classi deterministiche puoi semplicemente eseguire il miglior algoritmo e fermarti al punto . Quindi, tenendo presente questo, la simulazione completa di almeno un algoritmo deterministico per un problema è difficile quanto risolvere il problema stesso.$i$

Pensiero molto interessante! Ecco un commento esteso che era troppo lungo per essere pubblicato come tale:

Per quanto riguarda la definizione in (1) in quanto tale , vale a dire:

Inizia con una classe di complessità che è descritta da un compito computazionale. Dato un algoritmo A per eseguire ogni istanza di questo compito computazionale, considerare una nuova classe di complessità C A che è descritta dal compito computazionale completamente simulare A . Quindi possiamo (si spera) definire un "ideale" di classi di complessità: C + = { C A : per tutti gli algoritmi A } .$C$$C_A$$A$$C^+ = \{C_A:$$A\}$

Credo che incontrerai rapidamente un problema di indecidibilità per l' appartenenza non banale a . In particolare, data la descrizione di due TM M e M ′ , è risaputo che decidere se accettano la stessa lingua (cioè L ( M ) ? = L ( M ′ ) è indecidibile in generale dalla riduzione del problema di Halting.$C^+$$M$$M^{\prime}$$L(M) \stackrel{?}{=} L(M^{\prime})$

Inoltre, data la descrizione di una Turing Machine , c'è sempre una banale simulazione: basta costruire una nuova Turing Machine che chiama M come subroutine (usando la sua descrizione), che accetta se M accetta e rifiuta se M rifiuta. Questo costa solo un sovraccarico lineare. In particolare, se M viene eseguito in passi computazionali t ( n ) , allora M ∗ viene eseguito in O ( t ( n ) ) (per cui "corri" intendo "simula M esattamente").$M^*$$M$$M$$M$$M$$t(n)$$M^*$$O(t(n))$$M$

Questo mi suggerisce che se c'è una seria trazione da guadagnare qui, il modo preciso in cui si procede nel definire l'ideale di una classe di complessità sarà abbastanza importante. In particolare, se si intende dimostrare che l'ideale, per esempio, è P S P A C E -hard, si dovrà escludere la nozione di una banale simulazione a tempo lineare delle macchine N P in domanda.$NP$$PSPACE$$NP$

Rispetto ai metodi di omotopia descritti nel talk / paper e nel risultato di completezza E , credo che il "gap" a cui stai assistendo tra P P A D- completezza e P S P A C E -hardness è dovuto alla distinzione tra trovare un NE (nel senso di END OF LINE) e trovare un NE unico dato una specifica configurazione iniziale (nel senso di OTHER END OF LINE).$PSPACE$$PPAD$$PSPACE$