Formules booléennes quantifiées avec alternances logarithmiques

J'étudie un problème difficile pour la classe des formules booléennes quantifiées avec un nombre logarithmique d'alternances des quantificateurs. Un problème dans cette classe ressemblerait à:

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

Où $a_{\log n} = n$ , et $F$ est une formule booléenne des variables $x_1 \ldots x_n$ .

Cette classe contient clairement $PH$ et est contenu dans $AP = PSPACE$ . Y a-t-il un nom pour cette classe? Y a-t-il quelque chose de plus connu à ce sujet?

En s'appuyant sur la réponse de Michael Wehar, il semble que vous pouvez facilement montrer que les calculs peuvent être codés en polysize de tels QBF: vous utilisez des alternances O ( log n ) , chacun de p o l y ( n ) bits, et faire un argument similaire au théorème de Savitch. Toutes les deux alternances diviseront le temps d'exécution du calcul par un p o l y ( $NTISP(n^{\log n},poly(n))$$O(\log n)$$poly(n)$$poly(n)$ facteur.

J'appellerais la classe , en suivant la notation de Fortnow "Time-Space Tradeoffs for Satisfibility" qui pourrait également être citée pour l'argument esquissé dans le paragraphe précédent (mais veuillez consulter le document pour des références antérieures).$\Sigma_{O(\log n)} P$

(1) Ce que nous savons déjà:

Comme vous l'avez déjà dit, QBF avec alternances log ( n ) de quantificateurs est difficile pour chaque niveau de la hiérarchie polynomiale.$\log(n)$

(2) Je pense que nous pouvons également prouver ce qui suit:

Le problème est -hard.$NSPACE(log^2(n))$

(3) Voici ma justification informelle de l'affirmation précédente:

Étant donné un NTM lié à l'espace et une chaîne d'entrée, nous devons déterminer s'il existe un calcul acceptant sur la chaîne d'entrée donnée.$log^2(n)$

Chaque configuration du calcul peut être représentée par essentiellement 2 bits . En d'autres termes, nous pouvons représenter une configuration par un groupe de variables log 2 ( n ) .$\log^2(n)$$\log^2(n)$

L'idée est que nous avons une configuration de départ et une configuration finale et nous devons deviner le calcul qui se produit entre les deux. Nous devinons récursivement les configurations "moyennes" en utilisant des quantificateurs existants et récurrons en vérifiant que la configuration "gauche" va au "milieu" et la configuration "moyenne" va à la "droite" en utilisant pour tous les quantificateurs.

Maintenant, pour que cela fonctionne, au lieu de choisir une configuration "moyenne", nous devons choisir un groupe de configurations "intermédiaires" également espacées entre les configurations "gauche" et "droite". En particulier, on pourrait deviner configurations "intermédiaires" également espacées utilisant des quantificateurs existants avec$\sqrt{n}$variables, puis récapitulez chaque écart entre les configurations en utilisant pour tous les quantificateurs desvariablesà peu prèslog(n).$\sqrt{n} * log^2(n)$$\log(n)$

Il suffit de continuer la récursivité jusqu'à la profondeur pour pouvoir couvrir un calcul de longueur $2 * \log(n)$où chaque configuration a au pluslog2(n)plusieurs bits.$\sqrt{n} ^ {2 * \log(n)} = n^{\log(n)} = 2^{\log^2(n)}$$\log^2(n)$

Puisque la récursivité est de profondeur , nous n'avons que O ( log ( n ) ) groupes de variables c'est-à-dire des alternances. Puisque chaque groupe de quantificateurs a seulement $O(\log(n))$$O(\log(n))$variables, au total nous avonsO($\sqrt{n} * log^2(n)$variables.$O(\sqrt{n} * log^3(n))$

N'hésitez pas à offrir vos commentaires ou corrections. Merci beaucoup et j'espère que cela vous aidera un peu.

(4) Une affirmation plus générale comme le suggère la réponse de Ryan:

Vous devriez pouvoir exécuter la construction précédente de manière plus générale. Considérer ce qui suit:

À chaque étape de la récursivité, divisez en groupes de configurations «intermédiaires» en utilisant c ( n ) bits par configuration. Ensuite, faites la récursivité à la profondeur d ( n ) .$g(n)$$c(n)$$d(n)$

Tant que nous n'avons pas trop de variables et trop d'alternances, cela semble fonctionner correctement. En gros, nous avons besoin des éléments suivants pour être satisfait:

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

Notre approche généralisée sera utilisée pour simuler des machines de Turing non déterministes qui fonctionnent pour étapes en utilisant c ( n ) bits de mémoire.$g(n)^{d(n)}$$c(n)$

En particulier, nous choisissons les éléments suivants:

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

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

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

Les inégalités précédentes sont satisfaites et nous pouvons réaliser la construction pour simuler des machines de Turing non déterministes qui fonctionnent pour environ étapes log 2 ( n ) en utilisant $2^{\log^2(n)}$ bits de mémoire.$\frac{\sqrt{n}}{2 * log^2{n}}$

En d'autres termes, nous avons un meilleur résultat de dureté qu'auparavant. En particulier, le problème est difficile pour .$NTISP(2^{\log^2(n)}, \frac{\sqrt{n}}{2 * log^2{n}})$

(5) Autres généralisations:

Dans la généralisation précédente, nous simulions des machines de Turing non déterministes temporelles et spatiales. Cependant, nous pouvons être en mesure de simuler également des machines de Turing limitées dans le temps et l'espace.

Permettez-moi de vous expliquer un peu. Nous utilisons donc approximativement alternances log ( n ) pour effectuer la récursivité vers log ( n ) en profondeur . Cependant, nous pourrions utiliser certaines des alternances initialement, disons $\log(n)$$\log(n)$ . Ensuite, nous pourrions utiliser le reste$\sqrt{\log(n)}$ alternances pour aller en profondeur$\sqrt{\log(n)}$ .$\sqrt{\log(n)}$

Dans ce cas, nous pourrions simuler des machines de Turing alternées qui ont alternances avec des longueurs de témoin sublinéaires, exécutez pour2 log $\sqrt{\log(n)}$étapes et utilisez$2^{\log^{\frac{3}{2}}(n)}$ bits de mémoire.$\frac{\sqrt{n}}{2 * log^2{n}}$

En d'autres termes, le problème est difficile pour avec des longueurs de témoin sublinéaires. Alternativement, cette classe pourrait être écrite en utilisant lanotationSTAmentionnée dans les commentaires ci-dessus.$AltTimeSpace(\sqrt{\log(n)}, 2^{\log^{\frac{3}{2}}(n)}, \frac{\sqrt{n}}{2 * log^2{n}})$$STA$

Merci pour les commentaires et n'hésitez pas à offrir d'autres corrections ou clarifications. :)

Une réponse plus courte.

Observations initiales:

• Le problème est difficile à tous les niveaux de la hiérarchie polynomiale.
• Le problème est difficile pour les machines de Turing alternées avec des alternances qui fonctionnent pendant un temps polynomial.$\log(n)$

Des informations plus approfondies:

• Suggéré par le commentaire de Kaveh ci-dessus, le problème peut coder les calculs pour les machines Turing.$AltTime(\log(n), n)$
• De plus, comme Ryan l'a souligné, le problème peut coder des calculs pour $NTimeSpace(2^{\log^2(n)}, \sqrt{n})$

• $AltTimeSpace(a(n), t(n), s(n))$avec des longueurs de témoins restreintes. Je ne sais pas exactement quelle est la relation exacte entre $a(n)$, $t(n)$, et $s(n)$ doit être, mais nous savons que:

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

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

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

Voir ma réponse plus longue pour plus de détails sur les compromis entre $a(n)$, $t(n)$, et $s(n)$.

Remarque: Dans ce qui précède, quand je dis encoder des calculs, je veux dire encoder le calcul sans trop exploser la taille de l'instance. Autrement dit, si nous explosons de$n$ taille Turing machine entrée à $poly(n)$formule de taille, alors je pense que bien que l'explosion soit polynomiale, il est bon de porter une attention particulière au degré du polynôme. La raison de la perspective à grain semi-fin est d'essayer de mieux reconnaître comment les différentes mesures de la complexité$a(n)$, $t(n)$, et $s(n)$ dépendent les uns des autres.