Công thức Boolean được định lượng với các phép xen kẽ logarit

Tôi đang nghiên cứu một vấn đề khó đối với lớp các công thức boolean được định lượng với số lượng xen kẽ logarit của các bộ lượng hóa. Một vấn đề trong lớp này sẽ giống như:

$\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$

Trong trường hợp $a_{\log n} = n$ , và $F$ là một công thức boolean của các biến $x_1 \ldots x_n$ .

Lớp này chứa rõ ràng và được chứa trong A P = P S P Một C E . Có một tên cho lớp học này? Có bất cứ điều gì được biết nhiều hơn về nó?$PH$$AP = PSPACE$

Dựa trên câu trả lời của Michael Wehar, dường như bạn có thể dễ dàng hiển thị rằng các phép tính có thể được mã hóa trong các polBize như vậy: bạn sử dụng xen kẽ O ( log n ) , mỗi bit p o l y ( n ) và thực hiện một đối số tương tự như định lý của Savitch. Cứ hai lần thay thế sẽ chia thời gian chạy của phép tính cho một p o l y ( $NTISP(n^{\log n},poly(n))$$O(\log n)$$poly(n)$ yếu tố.$poly(n)$

Tôi sẽ gọi lớp , theo ký hiệu trong "Sự đánh đổi không gian thời gian" của Fortnow cũng có thể được trích dẫn cho đối số được phác thảo trong đoạn trước (nhưng vui lòng xem bài viết để tham khảo trước).$\Sigma_{O(\log n)} P$

(1) Những gì chúng ta đã biết:

Như bạn đã nói, QBF với các phép thay đổi lượng tử rất khó cho mọi cấp của hệ thống phân cấp đa thức.$\log(n)$

(2) Tôi nghĩ rằng chúng ta cũng có thể chứng minh những điều sau:

Vấn đề là -hard.$NSPACE(log^2(n))$

(3) Đây là lời biện minh không chính thức của tôi cho khẳng định trước:

Cho một không gian ràng buộc NTM và một chuỗi đầu vào, chúng ta cần phải xác định xem có tồn tại một tính toán chấp nhận trên chuỗi đầu vào nhất định.$log^2(n)$

Mỗi cấu hình trong tính toán có thể được biểu diễn bằng các bit . Nói cách khác, chúng ta có thể biểu diễn một cấu hình bằng một nhóm các biến log 2 ( n ) .$\log^2(n)$$\log^2(n)$

Ý tưởng là chúng ta có một cấu hình bắt đầu và một cấu hình cuối cùng và chúng ta cần đoán tính toán xảy ra ở giữa. Chúng tôi đoán đệ quy các cấu hình "giữa" bằng cách sử dụng các bộ lượng tử tồn tại và xác nhận lại rằng cấu hình "bên trái" sẽ chuyển sang "giữa" và cấu hình "giữa" đi đến "bên phải" sử dụng cho tất cả các bộ lượng hóa.

Bây giờ để thực hiện công việc này, thay vì chọn một cấu hình "giữa", chúng ta cần chọn một nhóm các cấu hình "trung gian" cách đều nhau giữa các cấu hình "trái" và "phải". Đặc biệt, chúng ta có thể đoán cách đều nhau cấu hình "trung gian" sử dụng quantifiers tồn tại với$\sqrt{n}$biến và sau đó lặp lại trên mọi khoảng cách giữa các cấu hình sử dụng cho tất cả các bộ lượng hóa vớicác biếnlog(n)thô.$\sqrt{n} * log^2(n)$$\log(n)$

Các đệ quy chỉ cần tiếp tục vào sâu để có thể bao gồm một tính toán chiều dài $2 * \log(n)$trong đó mỗi cấu hình có ít nhấtlog2(n)nhiêu bit.$\sqrt{n} ^ {2 * \log(n)} = n^{\log(n)} = 2^{\log^2(n)}$$\log^2(n)$

Vì đệ quy có độ sâu , nên chúng ta chỉ có các nhóm biến O ( log ( n ) ) tức là xen kẽ. Vì mỗi nhóm định lượng chỉ có $O(\log(n))$$O(\log(n))$biến, tổng cộng chúng ta cóO($\sqrt{n} * log^2(n)$biến.$O(\sqrt{n} * log^3(n))$

Hãy cung cấp bất kỳ thông tin phản hồi hoặc sửa chữa. Cảm ơn bạn rất nhiều và tôi hy vọng điều này sẽ giúp một chút.

(4) Một khẳng định tổng quát hơn theo đề xuất của câu trả lời của Ryan:

Bạn sẽ có thể thực hiện việc xây dựng trước một cách tổng quát hơn. Hãy xem xét những điều sau đây:

Ở mỗi bước của đệ quy, chia thành các nhóm cấu hình "trung gian" bằng cách sử dụng bit c ( n ) trên mỗi cấu hình. Sau đó, thực hiện đệ quy đến độ sâu d ( n ) .$g(n)$$c(n)$$d(n)$

Miễn là chúng ta không có quá nhiều biến số và quá nhiều lựa chọn thay thế, điều này dường như hoạt động tốt. Một cách thô bạo, chúng ta cần những điều sau đây để được thỏa mãn:

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

Cách tiếp cận tổng quát của chúng tôi sẽ được sử dụng để mô phỏng các máy Turing không xác định chạy cho các bước sử dụng các bit c ( n ) của bộ nhớ.$g(n)^{d(n)}$$c(n)$

Cụ thể, chúng tôi chọn như sau:

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

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

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

Các bất đẳng thức trên được thỏa mãn và chúng tôi có thể thực hiện việc xây dựng để mô phỏng máy Turing không xác định mà chạy cho khoảng bước sử dụng $2^{\log^2(n)}$ bit bộ nhớ.$\frac{\sqrt{n}}{2 * log^2{n}}$

Nói cách khác, chúng ta có kết quả độ cứng tốt hơn trước. Đặc biệt, vấn đề là khó khăn cho .$NTISP(2^{\log^2(n)}, \frac{\sqrt{n}}{2 * log^2{n}})$

(5) Khái quát hơn nữa:

Trong phần khái quát trước, chúng tôi đã mô phỏng các máy Turing không giới hạn thời gian và không xác định. Tuy nhiên, chúng tôi cũng có thể mô phỏng các máy Turing giới hạn thời gian và không gian xen kẽ.

Hãy để tôi giải thích một chút. Vì vậy, chúng tôi sử dụng xen kẽ để thực hiện đệ quy đến log sâu ( n ) . Tuy nhiên, chúng ta có thể sử dụng một số alternations ban đầu, chúng ta hãy nói $\log(n)$$\log(n)$ . Sau đó, chúng ta có thể sử dụng còn lại$\sqrt{\log(n)}$ alternations đi đến sâu$\sqrt{\log(n)}$ .$\sqrt{\log(n)}$

$\sqrt{\log(n)}$$2^{\log^{\frac{3}{2}}(n)}$$\frac{\sqrt{n}}{2 * log^2{n}}$

$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.