Un oracle pour séparer NP de coNP

Comment prouver que ? Je cherche juste un tel oracle TM et un langage récursif pour lequel cela vaut. ML(M)=$\mathsf{NP}^A \neq \mathsf{coNP}^A$$M$$L(M) = L$

Je connais la preuve où vous montrez qu'il y a un oracle tel que et un oracle tel que . J'ai un indice que je devrais trouver un tel oracle en étendant la preuve de mais partout où je recherche et lis, c'est "évident" ou "simple" partout mais Je ne vois tout simplement pas comment le prouver.P A ≠ N P A A P A = N P A A P A ≠ N P$A$$\mathsf{P}^A \neq \mathsf{NP}^A$$A$$\mathsf{P}^A = \mathsf{NP}^A$$A$$\mathsf{P}^A \neq \mathsf{NP}^A$

Comme Max a dit que la modification n'est pas difficile, je vous suggère de ne pas lire le reste de cette réponse et de réfléchir un peu plus au problème, il n'y a qu'une partie qui doit être modifiée et se souvenir de la définition du moment où un machine accepte vous aidera à réparer cette partie.$\mathsf{coNP}$

J'expliquerai la modification requise ci-dessous, mais commençons par avoir un bref aperçu de la preuve d'origine.

Dans la preuve d'origine est construit en étapes où à l'étape avec assurez-vous que la machine dans , , ne décide pas de la langue correctement. Notez que le jeu est dans . i i P M i { x ∣ ∃ y ∈ A | x | = | y | $A=\bigcup_n A_n$$i$$i$$\mathsf{P}$$M_i$$\{x \mid \exists y\in A \ |x|=|y| \}$$\mathsf{NP}^A$

Nous y parvenons en simulant utilisant la partie de nous avons construite sur un où est assez grand (la chaîne est plus longue que les chaînes considérées dans les étapes précédentes). accepte, nous n'ajoutons rien, s'il rejette, nous ajoutons une chaîne de longueur que ne fait pas de requête à l'ensemble (Une telle chaîne existe car il existe de façon exponentielle de nombreuses chaînes de longueur mais ne peut pas demander tous en temps polynomial). Nous ne modifierons pas cette partie de dans les prochaines étapes (c'est-à-dire que les chaînes de longueur ou moins resteront les mêmes). Cela garantit que A 0 m m M i m M i m M i A m M A $M_i$$A$$0^m$$m$$M_i$$m$$M_i$$m$$M_i$$A$$m$$M_i^A$ ne décidera pas la langue correctement et complétera la preuve.

Supposons maintenant que les machines étaient dans à la place de . Nous devons modifier la preuve pour vous assurer que ne reconnaîtra pas . S'il accepte, nous conservons comme avant et tout fonctionne bien comme dans la preuve d'origine. S'il rejette, nous devons ajouter une chaîne à l'ensemble pour nous assurer qu'il ne répond pas correctement. Nous pouvons toujours simuler avec la partie de nous avons, le problème est que peut interroger toutes les chaînes de longueur . Ici, le fonctionnement d'une machine devient important. Il accepte si et seulement si tousc o N P P M A i L A M i A M i n c o N P m $M_i$$\mathsf{coNP}$$\mathsf{P}$$M_i^A$$L$$A$$M_i$$A$$M_i$$n$$\mathsf{coNP}$les chemins de calcul acceptent. Puisqu'il rejette dans ce cas, il y a un chemin de calcul qui rejette. Tant que nous garderons ce chemin intact, tout fonctionnera, nous n'avons donc besoin que de garder les réponses aux requêtes de ce chemin. Le nombre de requêtes dans ce chemin est polynomial (puisque la machine fonctionne en temps polynomial), donc il y a des chaînes de longueur que le chemin ne demande pas, ajoutez simplement l'une d'elles à et le reste de la preuve fonctionne comme avant.$m$$A$

Les étapes sont algorithmiques, donc l'ensemble est récursif (l'essentiel de la construction est de pouvoir simuler des machines qui peuvent être faites dans say ).D S p a c e ( n ω ( 1 )$A$$\mathsf{DSpace}(n^{\omega(1)})$

Vous pouvez également consulter le texte Complexité informatique de Christos Papadimitriou. Plus précisément le chapitre 14, section 3 qui plonge dans les oracles. Les preuves pour et pour certains oracles et par exemple sont fournies en détail et peuvent être utiles pour votre problème principal. J'espère que cela pourra aider.P B ≠ N P $P^A = NP^A$$P^B \not= NP^B$$A$$B$