Algoritmaların Tam Simülasyonu ve Karmaşıklık Sınıfları Üzerine İlgili Bir İşlem Ne Kadar Zor

Tanıtım

Sorun çok uzun olduğu için burada özünü yakalayan özel bir durum var.

Sorun: A, 3-SAT için bir yönetimsel algoritma olsun. A algoritmasını (sorunun her örneğinde) tamamen simüle etme problemidir. P-Space sert mi?

(Daha doğrusu, bu görevin P-Space zor olduğuna inanmak için nedenler var mı, bu yönde bir şey standart CC varsayımlarından geliyor mu ve bu görevin varsayılan bazı karmaşıklık sınıfı X için X-zor olduğunu kanıtlamayı umuyoruz kesinlikle NP'nin üstünde olmalıdır.)

İlgili sorular : -pspace-complete-problemler-doğası gereği daha az izlenebilir-np-complete-problemleridir ;

DÜZENLENMİŞ GÜNCELLEME : "Tamamen A benzetmesi " için çeşitli yorumlar vardır. Ve yoruma göre farklı ilginç cevaplar olabilir. (Ayrıca Ryan Williams, deterministik olmayan bir algoritmayı simüle etmek için bir yorum önerdi.) Bir karar problemini "Tamamen A benzet" hesaplama göreviyle ilişkilendirmenin belirli bir yolu için, Joe Fitzsimons bu ilişkili karar probleminin hala NP'de olduğu bir algoritma A buldu. . "Tamamen benzetim", belirli bir adımında bilgisayarın tüm kaydını çıkarmayı ifade ediyorsa $i$, Joe'nun algoritması için gerekli olan şey $P^{NP}$ . Bu sürüm için (sanırım, ama emin değilim) Ryan'ın cevabı bir P N P çiziyor$P^{NP}$sertlik argümanı. Joe, (eğer artık bir karar problemi değil) tüm kayıtları tedarik etmeniz gerekiyorsa, adım atmanızın şaşırtıcı olmadığı ve karmaşıklık sınıflarının aynı olmadığını belirtti.

Her neyse, eğer kayıtların durumunu öngörülen bir adımında $i$çıkarmamız gerekiyorsa, o zaman Ruan ve Joe cevapları (ama yine, bundan emin değilim) $NP^+$ nın esasen olduğunu önerir $P^{NP}$. Biz operasyon polinom hiearachy içinde bir adım daha yukarı iter ve bu yorumuyla bu spaculate edebilirsiniz $PH^+ =PH$ .

Her durumda bu yorumlarla teaser sorumun cevabı HAYIR .

Aklımda "A algoritmasını tamamen simüle etmek" için daha sert bir yorum yaptım. (Ama belki Joe ve Ryan'ın yorumu daha ilginçtir.) “A algoritmasını tamamen simüle ederek” yorumum, her adımında kayıtların durumunu kapatmanızdır $i$. Özellikle, algoritma polinom değilse, çıktınız da polinom değildir. Her algoritma A için inanmak gerektiğini merak ettim bu köklü yorumuna göre, $C_A$ sert P-UZAY, ve biz ne kanıtlayabilirim.

Motivasyon:

Bu soru, Paul Goldberg'in ( slaytlar , video , kağıt ) Papadimitriou ve Savani ile bir makaleyi anlatan bir konferansla motive edildi . Lemke-Howson algoritması ile hesaplanan herhangi bir dengeyi bulmak için P-uzayının tamamlandığını gösterdiler. Bir denge noktası bulma problemi sadece PPAD-tamamlandı. Bu boşluk oldukça şaşırtıcı ve benzer sonuçlar zaten Papadimitriu'nun iyi bilinen makalesinde açıklandı: Parite Tartışmasının Karmaşıklığı ve Diğer Verimsiz Varoluş kanıtları (1991) . (PPAD-tamamlanmış problemlerin NP-zor bile olamayacağı bilinmektedir (korkunç şeyler olmadıkça, bu P-uzayına kıyasla karmaşıklık dünyasında çok aşağıdır).

Soru ne hakkında

Sorum daha eski ve daha klasik hesaplama karmaşıklığı problemleri için bile benzer boşluklar hakkında. (Belki bu zaten tanıdıktır.)

Hesaplama problemi göz önüne alındığında, üç konuyu birbirinden ayırabiliriz

a) Problemi algoritmik olarak çözme

b) Belirli bir algoritma A ile aynı çözüme ulaşın

c) Tüm A algoritmasını simüle edin

Elbette c) en azından b) kadar serttir, bu en azından a) kadar serttir. Yukarıda zikredilen sonuçlar, a) ve b) görevlerinin hesaplama dengesi sorunu için hesaplama güçlüğü arasındaki boşluğu göstermektedir. Diğer hesaplama problemlerinin durumunu (ve esas olarak a ve c arasındaki boşluğu) anlamak istiyoruz.

Soru:

Bir örnekle sorunun temel formu

Bir hesaplama problemiyle başlıyoruz, Problem X

Bir örnek olabilir

Problem X: n değişkenli SAT örneğini çözme

biz de belirtiyoruz

C: Problem X'i gerçekleştiren bir algoritma

ve yeni bir sorun ortaya koyuyoruz

Problem Y: A algoritmasını tam olarak benzetin

ve Y Sorununun hesaplama zorluğuyla ilgileniyoruz. Orijinal X problemini çözen A algoritmaları için bu tür problemlerin Y sınıfını anlamak istiyoruz. Özellikle Y probleminin ne kadar kolay olabileceğini (veya ne kadar zor olması gerektiğini) bilmek istiyoruz be) İstediğimiz zaman A algoritmasını seçmemize izin verilirse.

Karmaşıklık sınıfları için önerilen operasyon

Bazı hesaplama görevleriyle tanımlanan karmaşıklık sınıfıyla başlayın . Bu hesaplama görevin her örneğini gerçekleştirmek için bir algoritma A göz önüne alındığında, yeni bir karmaşıklık sınıf düşünün Cı Bir tamamen taklit hesaplama görev tarafından açıklanan A . Sonra (umarım) karmaşıklık sınıflarının “ideal” ini tanımlayabiliriz$C$$C_A$$A$

tüm A algoritmaları için}.$C^+ = \{C_A:$

bir dijital bilgisayarın polinom zamanında ne yapabileceğini tanımlamasına izin verirsek (bu yüzden dikkati örneğin karar problemlerine kısıtlamak istemiyorum), P + P'nin kendisinin kapsadığı idealdir .$P$$P^+$$P$

Sonunda, Sorularım

Sorularım:

1) Tanım mantıklı mı (geniş anlamda anlam anlamında). İyi biliniyor mu veya iyi bilinen bir şeyle aynı mı (veya benzer mi). (Formülasyonum gayri resmi idi ve özellikle SAT gibi belirli problemlerden NP gibi bir karmaşıklık sınıfına geçtiğimizde ihmal ettiğim çeşitli şeyler hakkında endişelenmeliyiz.)

Sonraki iki soru, tanımın mantıklı olabileceğini veya mantıklı olabileceğini varsayar.

2) Varsayalım ki kendimizi hesaplama bütünlüğü ile ilgili tüm standart varsayımlar ile donatıyoruz. Bazı bilinen karmaşıklık sınıfları için nın ne olması gerektiğini söyleyebilir miyiz ? (Örneğin C = N P , C = P-alanı, ..)? DÜZENLEME: Birkaç kişi P S P A C E + = P S P A C E olduğuna dikkat çekti . Yani> biz ne yerine sorabilirsiniz ( P N P ) + ? bir p H + = P , H ?$C^+$$C=NP$$C$$PSPACE^+=PSPACE$$(P^{NP})^+$$PH^+=PH$

Biz karmaşıklık ölçmelerde konstrüksiyonlar sınıfları ne olduğunu tahmin edebilir böylece C + idealdir ile geçilir C ?$C$$C^+$$C$

Bu nedenle, 3-SAT için A algoritmasını simüle etme işleminin ne kadar kolay olabileceği sorusu (mümkün olduğunca kolaylaştırmak için algoritmayı seçebildiğimizde) ilginç bir özel durumdur.

3) Bu operasyon hakkında gerçekten bir şey kanıtlama umudu var mı?

Tabii ki, daki tüm karmaşıklık sınıflarının P-alanı zor olduğunu kanıtlarsanız, bu P = N P'nin P = P S P A C E'yi ima ettiğini gösterecektir (ki bence) çok büyük ve beklenmedik bir sonuç olacaktır. . Ancak, N P + ' daki tüm karmaşıklık sınıflarının polinom Hieararchy'nin üçüncü seviyesinde (örneğin Δ P 3 ) söylemesi zor olduğunu gösterirseniz, bu sadece zaten bildiğimiz şeyleri, P = N P , PH'un çökmesine neden olur.$NP^+$$P=NP$$P=PSPACE$$NP^+$$\Delta_3^{\bf P}$$P=NP$

Sorun: A, 3-SAT için deterministik bir algoritma olsun. A (problemin her örneğinde) P-Space algoritmasını tamamen simüle etme sorunu zor mu?

Bu sorunun açıklamasını anlamıyorum. Ama daha genel sorunuzu resmileştirmenin doğal bir yolu olduğunu düşünüyorum, bu da ona biraz ışık tutabilir. Belki tam anlamıyla özlüyorum, ama umarım hala burada okumak için ilginç bir şeyler bulursunuz.

1) Tanım mantıklı mı (geniş anlamda anlam anlamında). İyi biliniyor mu veya iyi bilinen bir şeyle aynı mı (veya benzer mi). (Formülasyonum gayri resmi idi ve özellikle SAT gibi belirli problemlerden NP gibi bir karmaşıklık sınıfına geçtiğimizde ihmal ettiğim çeşitli şeyler hakkında endişelenmeliyiz.)

Görev algoritmasını algoritmasını tam olarak simüle$Y$ etmenin bir yolu şudur. Basitlik için modeli tek bantlı Turing makineleri olarak sabitleyelim; söyleyeceğim herhangi bir tipik hesaplama modeli için geçerli olabilir.

For each algorithm $Y$ and input $x$, we can define its computation history $H_Y(x,i,j)$: Given integers $i$ and $j$ which range from $0$ to the running time of $Y$, $H_Y(x,i,j)$ equals the content of the $j$th cell of the tape of Turing machine $Y$ on input $x$ in time step $i$. (And if the tape head is reading the $j$th cell in the $i$th step, include that too along with the machine's state.) Of course, computation histories come up all the time in complexity theory.

Now, one could argue that any algorithm which can decide the language

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

(or simulate the function $H_Y$ on all inputs) is solving the task exactly simulate algorithm $Y$, because it has the ability to print every little part of every possible computation of algorithm $Y$. Certainly, given an oracle for $C_Y$ one could do a step-by-step simulation of $Y$.

2) Suppose we equip ourselves with all the standard conjectures regarding computational complexity. Can we say what C+ is supposed to be for some familiar complexity classes. (E.g. C = NP, C = P-space,..)? Can we guess what are the complexity classes C so that C+ is the ideal spanned by C?

This is still an interesting question, under the above proposal. For deterministic time classes, nothing changes. $P^+$ is just $P$: we can decide $C_Y$ in polytime, for every polytime algorithm. Similarly $EXP^+ = EXP$. Also $PSPACE^+$ is still $PSPACE$. For nondeterministic time complexity classes, the situation becomes more interesting. In that case, an algorithm $Y$ can have multiple computation histories, so $H_Y$ is no longer well-defined. However we still want to print some computation history, so our "exact simulation" would have to isolate a specific nondeterministic computation history and then print its values. For an $NP$ algorithm $Y$, one can say that $C_Y \in P^{NP}$: we can use the $NP$ oracle to binary search for the "first" accepting computation history (in lex order), then once we have obtained it, print the relevant bits. For an $NEXP$ algorithm $Y$, one can say $C_Y \in EXP^{NP}$, for similar reasons.

Can we put $NP^+$ in a smaller class? I don't know. Notice we cannot simply redefine

$C_Y =${$(x,i,j,\sigma)~|~$ there exists a $H_Y$ such that $H_Y(x,i,j)=\sigma$}

to try to put $C_Y$ in $NP$, because we need the history string to be the same for all quadruples involving $x$, in order to "exactly simulate algorithm $Y$".

Anyway, this issue of not being able to "print a witness" to an $NEXP$ computation without going to $EXP^{NP}$ does arise in some situations, such as circuit complexity. If $NEXP$ has polynomial size circuits, then is it also the case that $C_Y \in P/poly$ for every nondeterministic $2^{n^k}$ time $Y$? Impagliazzo, Kabanets, and Wigderson answered this question affirmatively in 2001. Their proof is extremely interesting, invoking tools from derandomization and diagonalization (why would derandomization be necessary for such a result?) and it turns out to be a very useful theorem for proving circuit lower bounds for $NEXP$ functions.

Is there hope to actually prove something about this operation?

Maybe... that depends on whether you are happy with the above formalization of your question. For a deterministic 3-SAT algorithm $Y$, I think the above exact simulation of $Y$ problem would be $P^{NP(1)}$-hard, where $P^{NP(1)}$ is polynomial time with one query to $NP$. (The annoying syntax of StackExchange requires that I write (1) instead of the alternative. Earlier I said $C_Y$ should be $P^{NP}$-hard, but I am not sure of the details: you may see how to generalize the below.)

We give a polytime many-one reduction from every $L \in P^{NP(1)}$ to $C_Y$. Given such an $L$, let $M$ be a machine recognizing $L$ that does a single $NP$ query. WLOG, that query is a SAT formula. Also WLOG, the SAT query can be "postponed" until the very last step of the computation, in the following sense: there is a polynomial time algorithm $A(x)$ which prints a formula $F$ and bit $b$, such that for all $x$,

$M(x)$ accepts iff $A(x)=(F,b)$ such that ($SAT(F)$ XOR $b$) = 1.

($M$ may reject iff $F$ is satisfiable, or it may accept; the bit $b$ captures this.)

For simplicity, let's say when $Y$ ends its computation, it moves its tape head to cell 1, writes "accept" or "reject" in that cell, and loops forever. Then, asking if $(F,T,1,accept) \in C_Y$ for sufficiently large $T$ will tell us if $F$ is accepted. (In general, we just need that it's efficient to compute the instance $y$ of $C_Y$ which will tell us.) Note this already shows that $C_Y$ is both $NP$-hard and $coNP$-hard; the latter is true because $(F,T,1,reject) \in C_Y$ iff $F$ is not satisfiable.

The final reduction from $L$ to $C_Y$ is: given $x$, run $A(x)$ getting $(F,b)$. If $b=0$ then output $(F,T,1,accept)$, else if $b=1$ output $(F,T,1,reject)$.

For every $x$ we are producing (in polynomial time) a $y$ such that $M(x)$ accepts iff $y \in C_Y$.

(Thanks to Joe for demanding that I be clearer about this part.)

But I don't see (for example) how to get $\Sigma_2 P$-hardness. To reduce $\Sigma_2$-SAT to the problem, it would appear you'd need to write a 3-CNF SAT instance $x$ which simulates your deterministic algorithm $Y$ within it (where $Y$ is solving Tautologies on various subproblems). But as $Y$ has no given time bound, that 3-CNF $x$ could be huge, so you don't necessarily get a polynomial-time reduction. Unless I am missing something.

I initially posted an incorrect answer, so hopefully this is an improvement.

I'm going to start out by considering the 3SAT example. In your comment on Ryan's answer you say

I am interesting how hard it is to simulate a deterministic algorithm Y for 3-SAT. And the question is if no matter what Y is this is P-space hard.

The answer to this is that it is not PSPACE-hard for at least some Y, assuming that NP$\neq$PSPACE, but that there exist other algoriths for which it is PSPACE-hard. Showing the latter is trivial: We simply construct an algorithm which interprets the bit string representing the 3SAT formula instead as a TQBF problem, which it then solves before solving the 3SAT instance. Obviously there is nothing special about TQBF in this case, so the algorithm can be made arbitrarily hard to simulate. So we should only care about lower bounds on simulation of any algorithm for a given problem, rather than a specific algorithm.

With that in mind, we construct the following algorithm to solve 3SAT:

Take a register of $n$ bits (initially all set to 0) to contain a trial solution, together with a register containing the 3SAT instance, a counter register of size $\lceil\log_2 (c + 1)\rceil$ initially set to 1 and and two flag bits (call these the fail flag and the accept flag). Here $c$ is the number of clauses. The algorithm then proceeds as follows:

• If the value of the clause counter $k$ is less than or equal to $c$, and the trial solution is not $111......1$, check whether clause $k$ is satisfied. If not set the fail bit. Increment the counter.
• If the value of the clause counter $k$ is less than or equal to $c$, and the trial solution is $111......1$, check whether clause $k$ is satisfied. If it is not, set the fail flag. Increment the counter.
• If $k$ exceeds $c$, and the trial solution is not $111......1$, check if the fail flag is set. If so then increment the trial solution, reset the counter $k$ to 1, and unset the fail flag. If the fail flag was not set, set the accept flag, set the clause counter $k$ to zero, set the trial solution to zero and halt.
• If $k$ exceeds $c$, and the trial solution is $111......1$, check if the fail flag is set. If the fail flag was not set, set the accept flag. Set the clause counter $k$ to zero, set the trial solution to zero and halt.

When the algorithm halts, the state of the accept flag tells you whether or not the 3SAT formula can be satisfied.

Now, if I want to compute the state of the algorithm at time $i$ I have an algorithm to compute this in polynomial time with a single call to an NP oracle as follows:

Note that for any $i$, assuming the accept bit has not yet been set, the state of the registers can be calculated in polynomial time, since the value of $k$ and the trial solution register $t$ are simply functions of $i$. Determining if the fail flag is set can be done in polynomial time, simply by checking whether the current state of the trial solution register satisfies all clauses less than or equal the current value of $k$. If and only if this not the case, the fail flag is set. The accept flag is set to zero.

Similarly, if the accept bit has already been set, the state of the registers can be efficiently computed, since everything is zero except the accept bit, which is set.

So the only hardness comes in determining whether the accept bit is set. This is equivalent to determining whether the given 3SAT instance has a solution less than $t$. If it does, then the accept bit must necessarily be set, and if it does not, then the accept bit must necessarily be zero. Clearly this problem is itself NP-complete.

Thus the state of the system at step $i$ can be determined by in polynomial time with a single query to an NP oracle.

Important update: Initially I had misread Ryan's formulation of exact simulation as a decission problem, and so my claim that the decission version was in NP was incorrect. Given the problem of deciding whether bit $j$ at step $i$ on input $x$ as formulated in Ryans answer, then there are 3 possibilities:

1. This bit is constant in independent of whether $F$ is satisfiable. As there are only two possible states for the system at this time (both of which can be computed in P) determining if this is the case, and if so, whether the value is equal to $\sigma$ is in P.
2. The bit is equal to $\sigma$ if $F\in SAT$, and unequal otherwise. This problem is clearly in NP, as the satisfying assignment of $F$ acts as a witness.
3. The bit is equal to $\sigma$ if $F\in UNSAT$ in which case the problem is then in coNP.

Clearly deciding which one of these three is the case can be done in polynomial time, simply by comparing the value that bit takes if $F\in SAT$ and if $F\in UNSAT$. Thus the exact simulation problem is in NP $\cup$ coNP. Thus, as Ryan's lower bound and my upper bound match, assuming both are correct, I think we have an answer: $C_Y = NP\cup coNP$.

Note that there is nothing special about 3SAT in this case, and the same could be done for any problem in NP. Further, the same trick can be used for any non-deterministic complexity class, not just NP, which seem to be the hard ones to simulate. For deterministic classes you can simply run the best algorithm and halt at step $i$. So with this in mind, full simulation of at least some deterministic algorithm for a problem is only as hard as solving the problem itself.

Very interesting thought! Here's an extended comment that was too long to post as such:

Regarding the definition in (1) as such, that is:

Start with a complexity class $C$ which is described by some computational task. Given an algorithm A to perform every instance of this computational task, consider a new complexity class $C_A$ which is described by the computational task of completly simulating $A$. Then we can (hopefully) define an "ideal" of complexity classes: $C^+ = \{C_A:$ for all algorithms $A\}$.

I believe you're going to quickly run into an issue with undecidability for non-trivial membership in $C^+$. In particular, given the description of two TMs $M$ and $M^{\prime}$, it's well-known that deciding whether they accept the same language (i.e. $L(M) \stackrel{?}{=} L(M^{\prime})$ is undecidable in general by reduction from the Halting Problem.

Further, given the description of a Turing Machine , there is always a trivial simulation: Just construct a new Turing Machine $M^*$ that calls $M$ as a subroutine (using its description), which accepts if $M$ accepts and rejects if $M$ rejects. This only costs a linear overhead. Specifically, if $M$ runs in $t(n)$ computational steps, then $M^*$ runs in $O(t(n))$ (whereby "run," I mean "simulates $M$ exactly").

This suggests to me that if there's any serious traction to be gained here, the precise way you go about making the definition of the ideal of a complexity class is going to be fairly important. In particular, if you intend to show that the ideal of, say, $NP$ is $PSPACE$-hard, you'll have to rule out the notion of a trivial, linear-time simulation of the $NP$ machines in question.

With respect to the homotopy methods described in the talk/paper and GPS's $PSPACE$-completeness result, I believe the "gap" you're witnessing between $PPAD$-completeness and $PSPACE$-hardness is due to the distinction between finding any NE (in the sense of END OF LINE) and finding a unique NE given a specific, initial configuration (in the sense of OTHER END OF LINE).