Falha na minha prova NP = CoNP?


12

Eu tenho essa "prova" muito simples de NP = CoNP e acho que fiz algo errado em algum lugar, mas não consigo encontrar o que está errado. Alguém pode me ajudar?

Seja A um problema no PN, e M seja o decisor para A. Seja B o complemento, ou seja, B está no CoNP. Como M é um decisor, você também pode usá-lo para decidir B (basta virar a resposta). Isso não significa que resolvemos os problemas de NP e CoNP com o mesmo M?

Para ser mais concreto.

Seja A um problema de NP completo e M decida para A. Considere qualquer problema B no CoNP. Consideramos seu complemento não-B, que está em NP, e obtemos uma redução polinomial para A. Em seguida, executamos nosso decisor M e invertemos nossa resposta. Assim, obtemos uma decisão para B. Isso implica que B também está em NP.

Posso saber o que há de errado com meu raciocínio?


2
Como as respostas abaixo explicam detalhadamente, você não está usando a noção de "decisor" corretamente. Os problemas no coNP não são aqueles com uma "decisão NP invertida". Existe uma assimetria importante nos problemas de PN entre aceitar uma entrada ("existem escolhas não determinísticas que levam à aceitação") e rejeitá-la ("todas as escolhas não determinísticas levam à rejeição"). Seu argumento pressupõe que, para NP, rejeitar uma string significa ("existem escolhas não determinísticas que levam à rejeição"), e essa é a falha. Em outras palavras, você misturou seus quantificadores.
21313 Andrej Bauer

1
Você pode encontrar respostas para esta pergunta esclarecedor.
Raphael

@Raphael Surpreendentemente, essa pergunta não menciona co-NP de todo! (Embora eu concordo que é uma leitura útil para alguém que é inseguro sobre esse tipo de coisa.)
David Richerby

@DavidRicherby Como a resposta é, basicamente, "use a definição de NP em vez de uma intuição imperfeita", espero que sim!
Raphael

1
Regra geral: a construção "flip final states" funciona apenas para modelos determinísticos. Estude como a NFA falha em entender o porquê. Veja também aqui e aqui .
Raphael

Respostas:


16

Existem dois possíveis erros nesta prova:

  1. Quando você diz "decisivo" - você quer dizer uma MT determinística. Neste caso, a melhor tradução (para nosso conhecimento) de uma máquina NP a uma máquina determinista pode produzir uma máquina que executa em tempo exponencial, então depois complementando você terá um decisor para o complemento em tempo exponencial, provando que (ou, após alguma otimização, c o - N P P S P A C E ).coNPEXPcoNPPSPACE

  2. Quando você diz "decisivo", quer dizer uma MT não determinística. Nesse caso, inverter a resposta não complementará necessariamente o idioma. De fato, o idioma da máquina invertida será todas as palavras para as quais existe uma execução rejeitada de em wMw


Não sei por que isso importa. Minha definição de decisor é que aceito se a entrada está em L e rejeito se a entrada não está em L. Esse decisor pode ser determinístico ou não determinístico. No entanto, eu digo que L está em NP e, portanto, se eu estiver usando uma MT não determinística, levarei um tempo polinomial. Além disso, posso saber por que virar o bit não necessariamente complementa o idioma. Para meu conhecimento, CoNP = {L | não L \ in NP}. Portanto, se eu virar, devo obter a resposta?

Vamos . Considere uma TM não determinística que funcione da seguinte maneira - em uma execução, ela sempre gera "rejeitar". Em outras execuções, reconhece L em tempo polinomial (possível desde L N P ). Considere o que acontece se você mudar o bit - a execução de rejeição se torna aceitável para todas as entradas, para que a máquina complementada reconheça Σ - que não é o complemento, a menos que L = . Sugiro que você reveja de perto as definições de não-determinismo para entender isso completamente. LNPLLNPΣL=
Shaull 12/03/2013

Não quero dizer que mudei o bit de cada caminho de computação. O que quero dizer é que, se minha TM aceita, isso significa que existe um caminho de computação que atinge um estado de aceitação. Isso significa que L está em NP, o que significa que o complemento está em coNP. Se minha TM rejeitar, isso significa que todo caminho computacional rejeita. Isso significa que o complemento está no NP, o que significa que o L está no CoNP.

4
@ Simpleton: Você sabe que um NTM não tem acesso a todos os caminhos de uma só vez, apenas um caminho? Você pensa como alguém que analisa deterministicamente o comportamento do MNT do lado de fora.
Frafl 12/03/2013

7
Penso que o PO poderia beneficiar de procurar a definição de NP com mais cuidado.
MCH

15

Aqui está outra maneira de ver o ponto que Shaull faz com relação aos "decisores".

Um problema é em NP se e apenas se existe um algoritmo tal queV:{0,1}n×{0,1}poly(n){0,1}

  • para cada exemplo SIM , existe um certificado p { 0 , 1 } p o l y ( n ) , tais que V ( x , p ) = 1 ; ex{0,1}np{0,1}poly(n)V(x,p)=1

  • para cada exemplo NO , temos V ( x , p ) = 0 para todos os p { 0 , 1 } p o l y ( n ) .x{0,1}nV(x,p)=0p{0,1}poly(n)

Estes são geralmente descritos como a integridade e solidez condições para a NP algoritmo de verificação: a condição de "integridade", diz que cada instância SIM tem um certificado, e a condição "solidez", diz que o algoritmo nunca é enganado por uma instância NO. Para o coNP , é o contrário: existe um algoritmo de verificador que aceita pelo menos um certificado para qualquer instância NO, mas que nunca pode ser enganado por uma instância YES.

Se você deseja mostrar que NPcoNP , deve mostrar que todo problema de NP tem um verificador de tipo coNP , que pode certificar NÃO instâncias em vez de instâncias YES. Você não pode fazer isso com uma máquina de Turing não determinística: não há como saber, por exemplo, mapear com eficiência as instâncias do SAT, de tal maneira que todos fórmulas insatisfatórias sejam mapeadas para satisfatórias e vice-versa. (Negar a saída da fórmula não é suficiente, por exemplo: uma fórmula que seja satisfatória, mas não uma tautologia, seria mapeada para uma fórmula diferente que fosse satisfatória, mas não uma tautologia, quando precisaríamos de uma fórmula insatisfatória.) Simplesmente não existe maneira de "enganar" uma máquina não determinística para detectar algo como todos os seus caminhos sendo caminhos de rejeição.

Você pode perguntar: "A máquina de Turing não determinística não sabe que resultado obtém?" A resposta seria não , não. O funcionamento da máquina não determinística não lhe dá acesso a qualquer informação sobre mais de um caminho computacional de uma só vez: você pode pensar que ele funciona em muitos caminhos em paralelo, mas em cada caminho ele conhece apenas esse caminho. Se você tentar equipá-lo com a capacidade de "perceber" se há ou não soluções, em algum momento, você está descrevendo uma máquina com um oracle NP , que é mais (potencialmente!) Poderoso do que uma simples máquina de Turing não determinística.

  • Por exemplo, se equipar um (determinístico) máquina de Turing com um NP Oracle, em seguida, os problemas que podem ser resolvidos no tempo polinomial em que a máquina é chamado , o que é muitas vezes escrita P N P . O "oráculo" permite que a máquina simplesmente receba respostas para problemas completos de NP em uma única etapa e, portanto, P N P obviamente contém P ; e como você pode negar respostas, obviamente também contém coNP . Mas não sabemos se as contenções reversas se mantêm, exatamente porque não sabemos como enganar as máquinas de Turing não determinísticas para detectar NÃO.Δ2PPNPPNP

  • Além disso, se você der a uma máquina de Turing não determinística a capacidade de chegar a uma conclusão sobre o resultado de um problema no NP , os problemas que essa máquina pode resolver no tempo polinomial são chamados ou N P N P , e isso acredita-se estritamente maior que o da classe P N P . Isso também contém NP e coNP - mas, como NP , não é conhecido por ser fechado com complementos: a máquina oracle não determinística pode saber quando um problema em NPΣ2PNPNPPNPtem uma resposta de NÃO por causa do oráculo, mas ainda assim continuaria operando dentro de um de seus próprios ramos (bastante poderosos) computacionais, de modo que não seria capaz de saber se todos os seus próprios ramos computacionais estavam rejeitando.

Se você continuar fornecendo à máquina oráculos mais poderosos para resolver problemas em , N P N P e assim por diante, acabará definindo as classes da hierarquia polinomial , que são consideradas distintas umas das outras da primeiro nível em diante.NPNPNP

Portanto, não, não existe uma máquina (determinística ou não) que possa simplesmente 'decidir' que um problema é uma instância SIM ou NÃO eficientemente, a menos que usemos oráculos; mas mesmo com esse oráculo, acabamos com uma máquina que (provavelmente) é mais poderosa que NP ou coNP , e não uma que mostre que são iguais.


Olá, obrigado a você e Shauli pelos comentários. Você está dizendo que um NTM pode reconhecer uma linguagem NP no polytime, mas não pode decidir uma linguagem NP no polytime? Eu acho que é isso que estou assumindo quando digo que tenho uma decisão por problemas de PN.
simpleton 12/03

2
Acho que entendi o que você quer dizer. Você está dizendo que estou usando a redução de oráculo, e isso realmente mostra que o problema está em (o que é verdade porque N P P N P e C o N P P N P )? A redução do oracle mostra que UNSAT é NP-difícil, mas ainda preciso mostrar que U N S A T N P , e não posso mostrar isso? PNPNPPNPCoNPPNPUNSATNP
simpleton

5
A dureza NP é definida com muitas reduções de um, não reduções de oráculo.
Yuval Filmus

6

Seu raciocínio implica que RE = coRE, mas isso é comprovadamente falso. Você pode tentar descobrir uma prova disso e ver onde sua redução falha.

Recall that RE is the complexity class of recursively enumerable languages, which are languages of the form {x:P halts on input x}. You can also think of it in non-deterministic terms: RE is the class of languages of the form {x:(x,w)L for some w}, where L is recursive (computable).

Here is a proof that both definitions match. Suppose first L={x:p halts on input x}. Let L={(x,w):p halts on input x in w steps}. The language L is recursive and L={x:(x,w)L for some w}.

For the other direction, let L={x:(x,w)L for some w}, where L is recursive, say computed by the program P(x,w). We construct a new program Q(x) which enumerates all possible w and runs P(x,w) on all w, in order. If P(x,w) ever accepts for some w, then Q halts. It's not hard to check that L={x:Q halts on input x}.

For your convenience, here are outlines for a proof that RE is different from coRE. The language L={(P,x):P halts on input x} is clearly recursively enumerable: a program for it simply runs P on x. Suppose there was a program H such that H(P,x) halts if and only if (P,x)L. We define a new program G by G(x)=H(x,x). Is (G,G)L? If so, then G halts on G, so H halts on (G,G), so (G,G)L. If (G,G)L, then G doesn't halt on G, so H doesn't halt on (G,G), so (G,G)L. This contradiction shows that H cannot exist.

Now try to run your proof in this case and see what goes wrong. In more detail, try to construct the program H using your recipe, and follow the proof - at some point something wouldn't be quite right.


2

Here's a TL;DR version; I've also posted a longer answer to a similar question.

Suppose we have a language A that's decided in polynomial time by nondeterministic Turing machine M. The point is that xA iff there M has some accepting path on input x. However, since M is nondeterministic, there may also be rejecting paths when it runs on x. If you just reverse the accepting and rejecting states, you'll go from a machine that had some accepting paths and some rejecting ones to a machine that has some rejecting paths and some accepting ones. In other words, it still has accepting paths, so it still accepts. Flipping the accept and reject states of a nondeterministic machine does not, in general, cause you to accept the complement language.

It is this asymmetry of definition (accept if any path accepts; reject only if all paths reject) that makes the NP vs co-NP problem difficult.


-2

I actually agree that your nondeterministic machine M can decide whether a given input string is in B. However, it "decides" slightly differently than the way it decides if a given input is in A. In the latter case, it does so by (nondeterministically) finding an accepting state. In the former case, it does so by failing to find any accepting states. Why does this difference matter? Let's see:

When asking M "Is the string in the language A?"

M reaches an accept state. This, you can prove (see, for example, the Sipser book theorem 7.20) implies that there is a deterministic machine that verifies the string is in A in polynomial time

When asking M "Is the string in the language B?"

M reaches reject states on all branches of its nondeterministic computation. If you think about how the verifier proof above works, you will see that it cannot be accomplished in this situation. This is roughly because the verifier uses the path that M takes through its state space as "proof". In this case, there is no one such path.

Conclusion:

If you consider the existence of a polynomial time deterministic verifier for a language to be the definition of an NP language (which you should), the existence of M does not prove that B is in NP.


1
The existence of M doesn't prove that B is in NP precisely because you have to use this "weird" acceptance criterion to make it "accept" B. NP is defined via the conventional nondeterministic acceptance criterion. (The acceptance criterion is slightly weird partly because the question talks about flipping accepting and rejecting states in M but you don't seem to have done that.)
David Richerby
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.