Logaritmik değişimli nicelikli Boole Formülleri

Nicelleştiricilerin logaritmik sayıda değişkeni olan nicelenmiş boole formüllerinin sınıfı için zor olan bir problem üzerinde çalışıyorum. Bu sınıftaki bir sorun şöyle görünecektir:

$\forall (x_1, x_2, \ldots x_{a_1}) \exists (x_{{a_1}+1}, \ldots x_{a_2}), \ldots \exists(x_{a_{\log n - 1}}, \ldots x_{a_{\log n}})F$

Burada $a_{\log n} = n$ ve $F$ , değişkenlerinin bir boole formülüdür $x_1 \ldots x_n$.

Bu sınıf, açık bir şekilde içerir $PH$ ve içerdiği $AP = PSPACE$ . Bu sınıf için bir isim var mı? Daha bilinen bir şey var mı?

Michael Wehar'ın cevabına dayanarak, $NTISP(n^{\log n},poly(n))$ hesaplamalarının QBF'ler gibi çok boyutlu olarak kodlanabileceğini kolayca gösterebilirsiniz: $O(\log n)$ alternatiflerini kullanırsınız, $poly(n)$ bitsin her biri ve Savitch teoremine benzer bir argüman yapar. Her iki değişimde, hesaplamanın çalışma süresi bir $poly(n)$ faktörü.

Önceki paragrafta açıklanan argüman için de atıfta bulunulabilen Fortnow'un " Memnuniyet İçin Zaman-Uzay Tradeoffları" ndaki gösterimi takiben sınıfını çağırırdım (ancak daha önceki referanslar için makaleye bakınız).$\Sigma_{O(\log n)} P$

(1) Bildiklerimiz:

Daha önce belirttiğiniz gibi, nicelik değiştiricili QBF , polinom hiyerarşisinin her seviyesi için zordur.$\log(n)$

(2) Aşağıdakileri de kanıtlayabileceğimizi düşünüyorum:

Sorundur -Sert.$NSPACE(log^2(n))$

(3) Önceki iddia için gayri resmi gerekçem:

Verilen Bir yer bağlı LTB ve bir giriş dizisi olarak, verilen giriş dizesi bir kabul hesaplama vardır var olup olmadığını belirlemek gerekir.$log^2(n)$

Hesaplamadaki her yapılandırma esasen bitleri ile temsil edilebilir . Başka bir deyişle, bir grup log 2 ( n ) değişkeniyle bir konfigürasyonu temsil edebiliriz .$\log^2(n)$$\log^2(n)$

Fikir şu ki, bir başlangıç ​​yapılandırması ve bir son yapılandırmamız var ve aralarında gerçekleşen hesaplamayı tahmin etmemiz gerekiyor. Mevcut nicelleştiricileri kullanarak "orta" konfigürasyonları tekrar tekrar tahmin ediyoruz ve "sol" konfigürasyonun "orta" ve "orta" konfigürasyonun tüm nicelleştiriciler için "sağ" a gittiğini doğrulayan tekrarlama tahmin ediyoruz.

Şimdi bu işi yapmak için, bir "orta" konfigürasyon seçmek yerine, "sol" ve "sağ" konfigürasyonlar arasında eşit aralıklı bir "ara" konfigürasyon grubu seçmemiz gerekiyor. Özellikle, eşit ile var nicelik kullanılarak, "ara" yapılandırmaları aralıklı$\sqrt{n}$değişkenleri ve ardından kabacalog(n)değişkenleriolan tüm nicelleştiriciler için konfigürasyonlar arasındaki her boşlukta tekrarlama.$\sqrt{n} * log^2(n)$$\log(n)$

Tekrarlama sadece derinliğe devam ettirmesi gerektiği uzunlukta bir hesaplama kapsayacak edebilmek için $2 * \log(n)$burada her konfigürasyon en fazlalog2(n)bitine sahiptir.$\sqrt{n} ^ {2 * \log(n)} = n^{\log(n)} = 2^{\log^2(n)}$$\log^2(n)$

Özyineleme derinliği olduğundan, yalnızca O ( log ( n ) ) değişken gruplarımız vardır, yani alternatifler. Her nicelik grubu sadece $O(\log(n))$$O(\log(n))$değişken, toplamdaO($\sqrt{n} * log^2(n)$değişkenleri.$O(\sqrt{n} * log^3(n))$

Herhangi bir geri bildirim veya düzeltme yapmaktan çekinmeyin. Çok teşekkür ederim ve umarım bu biraz yardımcı olur.

(4) Ryan'ın cevabının önerdiği daha genel bir iddia:

Önceki inşaatı daha genel bir şekilde yapabilmelisiniz. Aşağıdakileri göz önünde bulundur:

At each step of the recursion, break up into $g(n)$ groups of "intermediate" configurations using $c(n)$ bits per configuration. Then, do the recursion to depth $d(n)$.

As long as we don't have too many variables and too many alternations, this seems to work fine. Roughly, we need the following to be satisfied:

• $g(n) * c(n) * d(n) \leq n$
• $d(n) \leq \log(n)$

Our generalized approach will be used to simulate non-deterministic Turing machines that run for $g(n)^{d(n)}$ steps using $c(n)$ bits of memory.

In particular, we pick the following:

• $g(n) = \sqrt{n}$

• $c(n) = \frac{\sqrt{n}}{2 * log^2{n}}$

• $d(n) = 2 * \log^2(n)$

The preceding inequalities are satisfied and we can carry out the construction to simulate non-deterministic Turing machines that run for roughly $2^{\log^2(n)}$ steps using $\frac{\sqrt{n}}{2 * log^2{n}}$ bits of memory.

In other words, we have a better hardness result than before. In particular, the problem is hard for $NTISP(2^{\log^2(n)}, \frac{\sqrt{n}}{2 * log^2{n}})$.

(5) Further generalizations:

Önceki genellemede, deterministik olmayan zaman ve uzay sınırlı Turing makinelerini simüle ediyorduk. Bununla birlikte, alternatif zaman ve mekan sınırlı Turing makinelerini de simüle edebiliriz.

$\log(n)$$\log(n)$$\sqrt{\log(n)}$$\sqrt{\log(n)}$ alternations to go to depth $\sqrt{\log(n)}$.

In this case, we could simulate alternating Turing machines that have $\sqrt{\log(n)}$ alternations with sublinear witness lengths, run for $2^{\log^{\frac{3}{2}}(n)}$ steps, and use $\frac{\sqrt{n}}{2 * log^2{n}}$ bits of memory.

In other words, the problem is hard for $AltTimeSpace(\sqrt{\log(n)}, 2^{\log^{\frac{3}{2}}(n)}, \frac{\sqrt{n}}{2 * log^2{n}})$ with sublinear witness lengths. Alternatively, this class could be written using the $STA$ notation mentioned in the comments above.

Thank you for the comments and feel free to offer any further corrections or clarifications. :)

A shorter answer.

Initial observations:

• The problem is hard for every level of the polynomial hierarchy.
• The problem is hard for alternating Turing machines with $\log(n)$ alternations that run for polynomial time.

Deeper Insights:

• Suggested by Kaveh's comment above, the problem can encode computations for $AltTime(\log(n), n)$ Turing machines.
• Also, as Ryan pointed out, the problem can encode computations for $NTimeSpace(2^{\log^2(n)}, \sqrt{n})$ Turing machines.

• More generally, the problem can encode computations for machines corresponding to various classes of the form $AltTimeSpace(a(n), t(n), s(n))$ with restricted witness lengths. I'm not quite sure what the exact relationship between $a(n)$, $t(n)$, and $s(n)$ has to be, but we know that:

  1. $\; \; a(n) \leq \log(n)$

  2. $\; \; t(n) \leq 2^{\log^2(n)}$

  3. $\; \; s(n) \leq n$

See my longer answer for more details on the trade-offs between $a(n)$, $t(n)$, and $s(n)$.

Note: In the above, when I say encode computations, I mean encode the computation without blowing up the instance size too much. That is, if we blow-up from $n$ size Turing machine input to $poly(n)$ size formula, then I think that although the blow-up is polynomial, it is good to pay close attention to the degree of the polynomial. The reason for the semi-fine-grained perspective is to try and slightly better recognize how the different complexity measures $a(n)$, $t(n)$, and $s(n)$ depend on each other.