Estou em um curso sobre computação e complexidade e não consigo entender o que esses termos significam.

Tudo o que sei é que NP é um subconjunto de NP-complete, que é um subconjunto de NP-hard, mas não tenho idéia do que eles realmente significam. A Wikipedia também não ajuda muito, pois as explicações ainda são um pouco alto demais.

Eu acho que os artigos da Wikipedia , e vs. são muito bons. Ainda aqui está o que eu diria: Parte I , Parte II$\mathsf{P}$$\mathsf{NP}$$\mathsf{P}$$\mathsf{NP}$

[Usarei comentários entre colchetes para discutir alguns detalhes técnicos que você pode ignorar se desejar.]

Parte I

Problemas de decisão

Existem vários tipos de problemas computacionais. No entanto, em uma introdução ao curso da teoria da complexidade computacional, é mais fácil focar no problema de decisão , ou seja, problemas em que a resposta é SIM ou NÃO. Existem outros tipos de problemas computacionais, mas na maioria das vezes as perguntas sobre eles podem ser reduzidas a perguntas semelhantes sobre problemas de decisão. Além disso, os problemas de decisão são muito simples. Portanto, em uma introdução ao curso da teoria da complexidade computacional, concentramos nossa atenção no estudo de problemas de decisão.

Podemos identificar um problema de decisão com o subconjunto de entradas que responderam SIM. Isso simplifica a notação e permite escrever no lugar de e no no lugar de .$x\in Q$$Q(x)=YES$$x \notin Q$$Q(x)=NO$

Outra perspectiva é que estamos falando sobre consultas de associação em um conjunto. Aqui está um exemplo:

Problema de decisão:

Entrada: Um número natural , Pergunta: é um número par?$x$x
$x$

Problema de associação:

Entrada: Um número natural , Pergunta: está em ?$x$x E v e n = { 0 , 2 , 4 , 6 , ⋯ }
$x$$Even = \{0,2,4,6,\cdots\}$

Nós nos referimos à resposta SIM em uma entrada como aceitando a entrada e à resposta NÃO em uma entrada como rejeitando a entrada.

Examinaremos os algoritmos em busca de problemas de decisão e discutiremos quão eficientes esses algoritmos são no uso de recursos computáveis . Vou confiar na sua intuição de programar em uma linguagem como C no lugar de definir formalmente o que queremos dizer com algoritmo e recursos computacionais.

[Observações: 1. Se quiséssemos fazer tudo formal e precisamente, precisaríamos consertar um modelo de computação como o modelo de máquina de Turing padrão para definir com precisão o que queremos dizer com algoritmo e seu uso de recursos computacionais. 2. Se quisermos falar sobre computação sobre objetos que o modelo não pode manipular diretamente, precisaríamos codificá-los como objetos que o modelo da máquina possa manipular; por exemplo, se estivermos usando máquinas de Turing, precisaremos codificar objetos como números e gráficos naturais como cadeias binárias.]

$\mathsf{P}$ = Problemas com algoritmos eficientes para encontrar soluções

Suponha que algoritmos eficientes significam algoritmos que usam a quantidade máxima de polinômios de recursos computacionais. O principal recurso com o qual nos preocupamos é o pior tempo de execução dos algoritmos em relação ao tamanho da entrada, ou seja, o número de etapas básicas que um algoritmo executa em uma entrada do tamanho . O tamanho de uma entrada é se forem necessários bits da memória do computador para armazenar ; nesse caso, escrevemos . Portanto, por algoritmos eficientes, entendemos algoritmos com tempo de execução polinomial no pior dos casos .$n$$x$$n$$n$$x$$|x| = n$

A suposição de que algoritmos de tempo polinomial capturam a noção intuitiva de algoritmos eficientes é conhecida como tese de Cobham . Neste momento, não discutirei se é o modelo certo para problemas eficientemente solucionáveis ​​e se captura ou não o que pode ser computado com eficiência na prática e em questões relacionadas. Por enquanto, existem boas razões para fazer essa suposição; portanto, para nosso propósito, assumimos que este é o caso. Se você não aceita a tese de Cobham, ela não torna incorreto o que escrevo abaixo, a única coisa que perderemos é a intuição$\mathsf{P}$$\mathsf{P}$sobre computação eficiente na prática. Eu acho que é uma suposição útil para alguém que está começando a aprender sobre a teoria da complexidade.

$\mathsf{P}$ é a classe de problemas de decisão que podem ser resolvidos com eficiência ,
ou seja, problemas de decisão que possuem algoritmos de tempo polinomial.

Mais formalmente, dizemos que um problema de decisão está em iff$Q$$\mathsf{P}$

existe um algoritmo eficiente tal que para todas as entradas ,$A$x
$x$

• se então , $Q(x)=YES$$A(x)=YES$
• se então .$Q(x)=NO$$A(x)=NO$

Eu posso simplesmente escrever mas escrevo desta maneira para que possamos compará-lo com a definição de .$A(x)=Q(x)$$\mathsf{NP}$

$\mathsf{NP}$ = Problemas com algoritmos eficientes para verificação de provas / certificados / testemunhas

Às vezes, não conhecemos uma maneira eficiente de encontrar a resposta para um problema de decisão; no entanto, se alguém nos diz a resposta e nos dá uma prova , podemos verificar com eficiência se a resposta está correta, verificando a prova para ver se é uma prova válida. . Essa é a idéia por trás da classe de complexidade .$\mathsf{NP}$

Se a prova for muito longa, não é realmente útil, pode levar muito tempo para apenas ler a prova e muito menos verificar se é válida. Queremos que o tempo necessário para a verificação seja razoável no tamanho da entrada original, não no tamanho da prova fornecida! Isso significa que o que realmente queremos não são provas longas arbitrárias, mas provas curtas . Observe que, se o tempo de execução do verificador for polinomial no tamanho da entrada original, ele poderá ler apenas uma parte polinomial da prova. Então, resumidamente, queremos dizer o tamanho polinomial .

Forme esse ponto sempre que eu usar a palavra "prova", quero dizer "prova curta".

Aqui está um exemplo de um problema que não sabemos como resolver com eficiência, mas podemos verificar provas com eficiência:

Entrada da Partição : um conjunto finito de números naturais , Pergunta: é possível particionar em dois conjuntos e ( e ) de forma que a soma dos números em é igual à soma do número em ( )?$S$S A B A ∪ B = S A ∩ B = ∅ A B ∑ x ∈ A x = ∑ x ∈ B x
$S$$A$$B$$A \cup B = S$$A \cap B = \emptyset$
$A$$B$$\sum_{x\in A}x=\sum_{x\in B}x$

Se eu lhe der e perguntar se podemos particioná-lo em dois conjuntos, de forma que suas somas sejam iguais, você não conhece nenhum algoritmo eficiente para resolvê-lo. Você provavelmente tentará todas as maneiras possíveis de particionar os números em dois conjuntos até encontrar uma partição em que as somas sejam iguais ou até que você tenha tentado todas as partições possíveis e nenhuma tenha funcionado. Se algum deles funcionasse, você diria SIM, caso contrário, diria NÃO.$S$

Mas existem exponencialmente muitas partições possíveis, portanto isso levará muito tempo. No entanto, se eu dou-lhe dois conjuntos e , você pode facilmente verificar se as somas são iguais e se e é uma partição de . Observe que podemos calcular somas com eficiência.$A$$B$$A$$B$$S$

Aqui o par de e que eu lhe dou é uma prova para uma resposta SIM. Você pode verificar minha reivindicação com eficiência, analisando minha prova e verificando se é uma prova válida . Se a resposta for SIM, existe uma prova válida, e eu posso dar a você e você pode verificar com eficiência. Se a resposta for NÃO, não há prova válida. Portanto, o que quer que eu lhe dê, você pode verificar e ver que não é uma prova válida. Não posso enganá-lo com uma prova inválida de que a resposta é SIM. Lembre-se de que, se a prova for muito grande, levará muito tempo para verificá-la, não queremos que isso aconteça, portanto, nos preocupamos apenas com provas eficientes , ou seja, com tamanho polinomial.$A$$B$

Às vezes, as pessoas usam " certificado " ou " testemunha " no lugar de "prova".

Observe que estou fornecendo informações suficientes sobre a resposta para uma determinada entrada para que você possa encontrar e verificar a resposta com eficiência. Por exemplo, em nosso exemplo de partição, eu não digo a resposta, apenas apresento uma partição e você pode verificar se é válida ou não. Observe que você tem que verificar a resposta você mesmo, não pode confiar em mim sobre o que eu digo. Além disso, você só pode verificar a exatidão da minha prova. Se minha prova for válida, significa que a resposta é SIM. Mas se minha prova for inválida, isso não significa que a resposta seja NÃO. Você viu que uma prova é inválida, não que não haja provas válidas. Estamos falando de provas para SIM. Não estamos falando de provas para NÃO.$x$

Vejamos um exemplo: e é uma prova de que pode ser particionado em dois conjuntos com somas iguais. Nós apenas precisamos de somar os números em e os números em e ver se os resultados são iguais, e verificar se , é partição de .$A=\{2,4\}$$B=\{1,5\}$$S=\{1,2,4,5\}$$A$$B$$A$$B$$S$

Se eu lhe der e , você verificará e verá que minha prova é inválida. Isso não significa que a resposta seja NÃO, apenas significa que essa prova específica é inválida. Sua tarefa aqui não é encontrar a resposta, mas apenas verificar se a prova fornecida é válida.$A=\{2,5\}$$B=\{1,4\}$

É como um aluno resolvendo uma pergunta em um exame e um professor verificando se a resposta está correta. :) (infelizmente, muitas vezes os alunos não fornecem informações suficientes para verificar a exatidão de suas respostas e os professores precisam adivinhar o restante de suas respostas parciais e decidir a nota que devem dar aos alunos por suas respostas parciais, de fato uma tarefa bastante difícil. tarefa).

O surpreendente é que a mesma situação se aplica a muitos outros problemas naturais que queremos resolver: podemos verificar com eficiência se uma determinada prova curta é válida, mas não conhecemos nenhuma maneira eficiente de encontrar a resposta . Essa é a motivação pela qual a classe de complexidade é extremamente interessante (embora essa não tenha sido a motivação original para defini-la). Tudo o que você faz (não apenas em ciências da computação, mas também em matemática, biologia, física, química, economia, administração, sociologia, negócios, ...) você enfrentará problemas computacionais que se enquadram nessa classe. Para ter uma idéia de quantos problemas em confira $\mathsf{NP}$N P N P$\mathsf{NP}$um compêndio de problemas de otimização de NP . De fato, você terá dificuldade em encontrar problemas naturais que não estão no . É simplesmente incrível.$\mathsf{NP}$

$\mathsf{NP}$ é a classe de problemas que possuem verificadores eficientes , ou seja,
existe um algoritmo de tempo polinomial que pode verificar se uma determinada solução está correta.

Mais formalmente, dizemos que um problema de decisão está em iff$Q$$\mathsf{NP}$

existe um algoritmo eficiente chamado verificador, de modo que, para todas as entradas , $V$x
$x$

• se , existe uma prova tal que ,$Q(x)=YES$$y$$V(x,y)=YES$
• se , para todas as provas , .$Q(x)=NO$$y$$V(x,y)=NO$

Dizemos que um verificador é válido se não aceitar nenhuma prova quando a resposta for NÃO. Em outras palavras, um verificador de som não pode ser enganado para aceitar uma prova se a resposta for realmente NÃO. Sem falsos positivos.

Da mesma forma, dizemos que um verificador está completo se aceitar pelo menos uma prova quando a resposta for SIM. Em outras palavras, um verificador completo pode ser convencido de que a resposta é SIM.

A terminologia vem de sistemas lógicos e de prova . Não podemos usar um sistema à prova de som para provar quaisquer declarações falsas. Podemos usar um sistema completo de provas para provar todas as afirmações verdadeiras.

O verificador recebe duas entradas,$V$

• $x$ : a entrada original para e$Q$
• $y$ : uma prova sugerida para .$Q(x)=YES$

Note que queremos que seja eficiente no tamanho de . Se é uma grande prova, o verificador poderá ler apenas uma parte polinomial de . É por isso que exigimos que as provas sejam curtas. Se é pequeno, dizer que é eficiente em é o mesmo que dizer que é eficiente em e (porque o tamanho de é limitado por um polinômio fixo no tamanho de ).$V$$x$$y$y y V x V x y y x$y$$y$$V$$x$$V$$x$$y$$y$$x$

Em resumo, para mostrar que um problema de decisão está em , precisamos fornecer um algoritmo verificador eficiente, sólido e completo .$Q$$\mathsf{NP}$

Nota histórica: historicamente, essa não é a definição original de . A definição original usa o que é chamado de máquinas de Turing não determinísticas . Essas máquinas não correspondem a nenhum modelo de máquina real e são difíceis de se acostumar (pelo menos quando você está começando a aprender sobre a teoria da complexidade). Eu li que muitos especialistas acham que teriam usado a definição de verificador como definição principal e até teriam nomeado a classe (para verificação em tempo polinomial) no lugar de$\mathsf{NP}$V P N P N P$\mathsf{VP}$$\mathsf{NP}$ se eles voltarem ao início da teoria da complexidade computacional. A definição do verificador é mais natural, mais fácil de entender conceitualmente e mais fácil de usar para mostrar problemas em .$\mathsf{NP}$

$\mathsf{P}\subseteq \mathsf{NP}$

Portanto, temos = solucionável eficiente e = verificável com eficiência . Portanto, se os problemas que puderem ser verificados com eficiência forem iguais aos problemas que podem ser resolvidos com eficiência.$\mathsf{P}$$\mathsf{NP}$$\mathsf{P}=\mathsf{NP}$

Observe que qualquer problema em também está em , ou seja, se você puder resolver o problema, também poderá verificar se uma determinada prova está correta: o verificador simplesmente ignorará a prova!$\mathsf{P}$$\mathsf{NP}$

Isso ocorre porque não precisamos dela, o verificador pode calcular a resposta por si só, pode decidir se a resposta é SIM ou NÃO sem ajuda. Se a resposta for NÃO, sabemos que não deve haver provas e nosso verificador rejeitará todas as provas sugeridas. Se a resposta for SIM, deve haver uma prova e, de fato, aceitaremos qualquer coisa como prova.

[Poderíamos ter feito nosso verificador aceitar apenas alguns deles, o que também é bom, desde que nosso verificador aceite pelo menos uma prova de que o verificador funciona corretamente para o problema.]

Aqui está um exemplo:

Entrada de soma : uma lista de números naturais e , Pergunta: is ?$n+1$$a_1,\cdots,a_n$$s$Σ n i = 1 a i = s
$\Sigma_{i=1}^n a_i = s$

O problema está em porque podemos resumir os números e compará-los com , retornamos YES se forem iguais e NO se não forem.$\mathsf{P}$$s$

O problema também está em . Considere um verificador que obtém uma prova mais a entrada para Sum. Ele age da mesma maneira que o algoritmo em que descrevemos acima. Este é um verificador eficiente para Sum.$\mathsf{NP}$$V$$\mathsf{P}$

Observe que existem outros verificadores eficientes para Sum, e alguns deles podem usar a prova fornecida. No entanto, o que projetamos não é e também é bom. Como fornecemos um verificador eficiente para Sum, o problema está em . O mesmo truque funciona para todos os outros problemas em então .$\mathsf{NP}$$\mathsf{P}$$\mathsf{P} \subseteq \mathsf{NP}$

Algoritmos de pesquisa de força bruta / exaustiva para e$\mathsf{NP}$$\mathsf{NP}\subseteq \mathsf{ExpTime}$

Os melhores algoritmos que conhecemos para resolver um problema arbitrário em são algoritmos de pesquisa de força bruta / pesquisa exaustiva . Escolha um verificador eficiente para o problema (ele tem um pressuposto de que ele está em ) e verifique todas as provas possíveis uma por uma. Se o verificador aceitar um deles, a resposta é SIM. Caso contrário, a resposta é NÃO.$\mathsf{NP}$$\mathsf{NP}$

No nosso exemplo de partição, tentamos todas as partições possíveis e verificamos se as somas são iguais em alguma delas.

Observe que o algoritmo de força bruta é executado no pior momento exponencial. O tamanho das provas é polinomial no tamanho da entrada. Se o tamanho das provas for , existem provas possíveis. A verificação de cada um deles levará tempo polinomial pelo verificador. Portanto, no total, o algoritmo de força bruta leva tempo exponencial.$m$$2^m$

Isso mostra que qualquer problema pode ser resolvido em tempo exponencial, ou seja, . (Além disso, o algoritmo de força bruta usará apenas uma quantidade polinomial de espaço, por exemplo, mas isso é uma história para outro dia).$\mathsf{NP}$$\mathsf{NP}\subseteq \mathsf{ExpTime}$$\mathsf{NP}\subseteq \mathsf{PSpace}$

Um problema em pode ter algoritmos muito mais rápidos, por exemplo, qualquer problema em possui um algoritmo de tempo polinomial. No entanto, para um problema arbitrário no , não conhecemos algoritmos que podem fazer muito melhor. Em outras palavras, se você me disser que seu problema está em (e nada mais sobre o problema), o algoritmo mais rápido que conhecemos para resolvê-lo leva um tempo exponencial.$\mathsf{NP}$$\mathsf{P}$$\mathsf{NP}$$\mathsf{NP}$

No entanto, isso não significa que não existem algoritmos melhores, não sabemos disso . Até onde sabemos, ainda é possível (embora seja quase improvável para quase todos os teóricos da complexidade) que e todos os problemas de possam ser resolvidos em tempo polinomial.$\mathsf{NP}=\mathsf{P}$$\mathsf{NP}$

Além disso, alguns especialistas conjeturam que não podemos fazer muito melhor, ou seja, existem problemas no que não podem ser resolvidos com muito mais eficiência do que algoritmos de busca por força bruta que levam tempo exponencial. Consulte a Hipótese de tempo exponencial para obter mais informações. Mas isso não está provado, é apenas uma conjectura . Apenas mostra a que distância estamos de encontrar algoritmos de tempo polinomial para problemas arbitrários .$\mathsf{NP}$$\mathsf{NP}$

Esta associação com o tempo exponencial confunde algumas pessoas: elas pensam incorretamente que problemas requerem tempo exponencial para resolver (ou pior ainda há nenhum algoritmo para eles em tudo). Afirmar que um problema está em não significa que seja difícil resolvê-lo, apenas significa que é fácil verificar, é um limite superior na dificuldade de resolver o problema e muitos problemas são fáceis de resolver, pois .$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{P}\subseteq\mathsf{NP}$

No entanto, existem problemas que parecem difíceis de resolver. Voltarei a isso quando discutirmos a dureza .$\mathsf{NP}$$\mathsf{NP}$

Limites inferiores parecem difíceis de provar

OK, agora sabemos que existem muitos problemas naturais em e não conhecemos nenhuma maneira eficiente de resolvê-los e suspeitamos que eles realmente exijam tempo exponencial para serem resolvidos. Podemos provar isso?$\mathsf{NP}$

Infelizmente, a tarefa de provar limites inferiores é muito difícil. Não podemos nem provar que esses problemas exigem mais do que tempo linear ! Muito menos exigindo tempo exponencial.

Provar limites inferiores de tempo linear é bastante fácil: afinal, o algoritmo precisa ler a entrada. Provar limites inferiores super-lineares é uma história completamente diferente. Podemos provar limites inferiores super-lineares com mais restrições sobre o tipo de algoritmos que estamos considerando, por exemplo, ordenando algoritmos usando comparação, mas não sabemos limites inferiores sem essas restrições.

Para provar um limite superior para um problema, precisamos apenas projetar um algoritmo suficientemente bom. Muitas vezes, é necessário conhecimento, pensamento criativo e até engenhosidade para criar esse algoritmo.

No entanto, a tarefa é consideravelmente mais simples em comparação com a comprovação de um limite inferior. Temos que mostrar que não existem bons algoritmos . Não que não conheçamos algoritmos bons o suficiente no momento, mas que não existam algoritmos bons , que ninguém jamais venha com um bom algoritmo . Pense nisso por um minuto, se você ainda não o fez, como podemos mostrar um resultado tão impossível ?

Este é outro lugar onde as pessoas ficam confusas. Aqui "impossibilidade" é uma impossibilidade matemática , ou seja, não é uma curta vinda de nossa parte que algum gênio possa corrigir no futuro. Quando dizemos impossível, queremos dizer que é absolutamente impossível, tão impossível quanto . Nenhum avanço científico pode tornar isso possível. É isso que estamos fazendo quando estamos demonstrando limites mais baixos.$1=0$

Provar um limite inferior, isto é, mostrar que um problema requer uma certa quantidade de tempo para ser resolvido, significa que temos que provar que qualqueralgoritmo, mesmo os muito ingênuos que ainda não sabem, não podem resolver o problema mais rapidamente. Existem muitas idéias inteligentes que conhecemos (programação gananciosa, correspondente, dinâmica, programação linear, programação semidefinida, programação de soma de quadrados e muitas outras idéias inteligentes) e muitas outras ainda não sabemos. Descartar um algoritmo ou uma idéia específica de projetar algoritmos não é suficiente, precisamos excluir todos eles, mesmo aqueles que ainda não conhecemos, mesmo que nem todos conheçam! E podemos combinar tudo isso em um algoritmo, por isso precisamos descartar suas combinações também. Houve algum progresso no sentido de mostrar que algumas idéias não podem resolver dificuldades$\mathsf{NP}$problemas, por exemplo, ganancioso e suas extensões não podem funcionar, e há algum trabalho relacionado a algoritmos de programação dinâmica, e há algumas maneiras particulares de usar a programação linear. Mas eles nem sequer estão perto de excluir as idéias inteligentes que conhecemos (procure limites inferiores em modelos restritos de computação, se você estiver interessado).

Barreiras: limites mais baixos são difíceis de provar

Por outro lado, temos resultados matemáticos chamados barreiras que dizem que uma prova de limite inferior não pode ser tal e tal, e tal e tal quase cobre todas as técnicas que usamos para provar limites inferiores! De fato, muitos pesquisadores desistiram de provar limites inferiores após o resultado da barreira de provas naturais de Alexander Razbarov e Steven Rudich . Acontece que a existência de um tipo particular de provas de limite inferior implicaria a insegurança de geradores de números pseudoaleatórios criptográficos e muitas outras ferramentas criptográficas.

Digo quase porque nos últimos anos houve algum progresso principalmente por Ryan Williams que foi capaz de contornar os resultados da barreira de maneira inteligente, ainda os resultados até agora são para modelos de computação muito fracos e muito longe de descartar algoritmos gerais de tempo polinomial .

Mas estou divergindo. O ponto principal que eu queria enfatizar era que provar limites inferiores é difícil e não temos limites inferiores fortes para algoritmos gerais que resolvem problemas de .$\mathsf{NP}$

[Por outro lado, o trabalho de Ryan Williams mostra que existem conexões estreitas entre provar limites inferiores e provar limites superiores. Veja a palestra dele no ICM 2014, se você estiver interessado.]

Reduções: Resolvendo um problema usando outro problema como sub-rotina / Oracle / Black Box

A ideia de uma redução é muito simples: para resolver um problema, use um algoritmo para outro problema.

Aqui está um exemplo simples: suponha que queremos calcular a soma de uma lista de números naturais e que temos um algoritmo que retorna a soma de dois números fornecidos. Podemos usar para somar os números da lista? Claro!$n$$Sum$$Sum$

Problema:

Entrada: uma lista de números naturais , Saída: return . $n$$x_1,\ldots,x_n$
$\sum_{i=1}^{n} x_i$

Algoritmo de redução:

1. $s = 0$
2. para de a 2.1. $i$$1$$n$
   $s = Sum(s,x_i)$
3. retorno$s$

Aqui estamos usando em nosso algoritmo como uma sub - rotina . Observe que não nos importamos com o modo como o funciona, ele age como uma caixa preta para nós, não nos importamos com o que está acontecendo dentro do . Costumamos nos referir à subrotina como oráculo . É como o oráculo de Delfos na mitologia grega, fazemos perguntas e o oráculo as responde e usamos as respostas.$Sum$$Sum$$Sum$$Sum$

Isso é essencialmente o que é uma redução: assuma que temos um algoritmo para um problema e o use como um oráculo para resolver outro problema. Aqui eficiente significa eficiente assumindo que o oráculo responde em uma unidade de tempo, ou seja, contamos cada execução do oráculo em um único passo.

Se o oráculo retorna uma resposta grande é preciso lê-lo e que pode demorar algum tempo, por isso, devemos contar o tempo que leva -nos a ler a resposta que a Oracle tem dado para nós. Da mesma forma, para escrever / fazer a pergunta do oráculo. Mas o oracle funciona instantaneamente, ou seja, assim que fazemos a pergunta do oracle, o oracle escreve a resposta para nós em uma única unidade de tempo. Todo o trabalho que a Oracle realiza conta um único passo, mas isso exclui o tempo que leva para escrever a pergunta e ler a resposta.

Como não nos importamos com o funcionamento do oracle, mas apenas com as respostas que ele retorna, podemos simplificar e considerar o oracle como o próprio problema no lugar de um algoritmo para ele. Em outras palavras, não nos importamos se o oráculo não é um algoritmo, não nos importamos como o oráculo apresenta suas respostas.

Por exemplo, na pergunta acima é a própria função de adição (não um algoritmo para calcular a adição).$Sum$

Podemos fazer várias perguntas de um oráculo, e as perguntas não precisam ser predeterminadas: podemos fazer uma pergunta e, com base na resposta que o oracle retorna, realizamos alguns cálculos por nós mesmos e depois fazemos outra pergunta com base na resposta que obtivemos para a pergunta anterior.

Outra maneira de encarar isso é pensar nisso como uma computação interativa . A computação interativa por si só é um tópico amplo, por isso não abordarei aqui, mas acho que mencionar essa perspectiva de reduções pode ser útil.

Um algoritmo que usa um oracle / caixa preta normalmente é indicado como .$A$$O$$A^O$

A redução que discutimos acima é a forma mais geral de redução e é conhecida como redução de caixa preta (também conhecida como redução de oráculo , redução de Turing ).

Mais formalmente:

Dizemos que o problema é uma caixa preta redutível ao problema e escrevemos se houver um algoritmo tal que, para todas as entradas , .$Q$$O$$Q \leq_T O$
$A$$x$
$Q(x) = A^O(x)$

Em outras palavras, se existe um algoritmo que utiliza o oráculo como uma sub-rotina e resolve o problema .$A$$O$$Q$

Se o nosso algoritmo de redução é executado em tempo polinomial, chamamos de redução de caixa-preta de tempo polinomial ou simplesmente uma redução Cozinhe (em homenagem a Stephen A. Cook ) e escrever . (O subscrito significa "Turing" em homenagem a Alan Turing ).$A$$Q\leq^\mathsf{P}_T O$$T$

No entanto, podemos querer colocar algumas restrições na maneira como o algoritmo de redução interage com o oráculo. Há várias restrições que são estudadas, mas a restrição mais útil é o chamado muitos e um reduções (aka reduções de mapeamento ).

A idéia aqui é que, em uma dada entrada , realizamos alguma computação em tempo polinomial e geramos um que é uma instância do problema que o oráculo resolve. Depois pedimos ao oráculo e devolvemos a resposta que ele nos retorna. Estamos autorizados a fazer uma única pergunta do oráculo e as respostas do oráculo são o que será retornado.$x$$y$

Mais formalmente,

Dizemos que o problema é muitos redutível ao problema e escrevemos se houver um algoritmo tal que, para todas as entradas , .$Q$$O$$Q \leq_m O$
$A$$x$
$Q(x) = O(A(x))$

Quando o algoritmo de redução é tempo polinomial chamamos isso polinomial-time redução por mapeamento ou simplesmente redução Karp (em homenagem a Richard M. Karp ) e denotam que por .$Q \leq_m^\mathsf{P} O$

A principal razão para o interesse nessa redução não interativa específica é que ela preserva os problemas de : se houver uma redução de muitos polinômios de um problema para um problema , então também está em .$\mathsf{NP}$$A$$\mathsf{NP}$$B$$A$$\mathsf{NP}$

A noção simples de redução é uma das noções mais fundamentais na teoria da complexidade, juntamente com o , e (que discutiremos abaixo).$\mathsf{P}$$\mathsf{NP}$$\mathsf{NP}$

A postagem ficou muito longa e excede o limite de uma resposta (30000 caracteres). Continuarei a resposta na Parte II .

parte II

Continuação da Parte I .

A anterior excedeu o número máximo de letras permitido em uma resposta (30000), por isso estou dividindo em duas.

$\mathsf{NP}$ -completeness: Universal Problemas$\mathsf{NP}$

OK, até agora discutimos a classe de problemas eficientemente solucionáveis ​​( ) e a classe de problemas eficientemente verificáveis ​​( ). Como discutimos acima, ambos são limites superiores . Por enquanto, vamos concentrar nossa atenção nos problemas dentro de pois surpreendentemente muitos problemas naturais acabam dentro de .$\mathsf{P}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$

Agora, às vezes, queremos dizer que um problema é difícil de resolver . Mas, como mencionamos acima, não podemos usar limites inferiores para esse fim: teoricamente, eles são exatamente o que gostaríamos de provar; no entanto, na prática, não tivemos muito sucesso em provar limites inferiores e, em geral, são difíceis de provar, como mencionamos. acima. Ainda existe uma maneira de dizer que um problema é difícil de resolver ?

Aí vem a noção de -completeness. Porém, antes de definir a vamos dar uma nova olhada nas reduções.$\mathsf{NP}$$\mathsf{NP}$

Reduções como dificuldade relativa

Podemos pensar nos limites inferiores como dificuldade absoluta de problemas. Então, podemos pensar em reduções como dificuldade relativa de problemas. Podemos tomar uma redução de para$A$$B$ como dizendo é mais fácil do que . Isso está implícito na noção que usamos para reduções. Formalmente, as reduções dão ordens parciais para os problemas.$A$$B$$\leq$

Se conseguirmos reduzir eficientemente um problema para outro problema então não deve ser mais difícil do que resolver. A intuição é a seguinte:$A$$B$$A$$B$

Deixe- ser uma redução eficiente de a , isto é, é um algoritmo eficiente que utiliza e soluciona . Deixe- ser um algoritmo eficiente que resolve . Nós podemos combinar a redução eficiente e o algoritmo eficiente para se obter que é um algoritmo eficiente que resolve .$M^B$$A$$B$$M$$B$$A$$N$$B$$M^B$$N$$M^N$$A$

Isso ocorre porque podemos usar uma sub-rotina eficiente em um algoritmo eficiente (onde cada chamada de sub-rotina custa uma unidade de tempo) e o resultado é um algoritmo eficiente. Essa é uma propriedade de fechamento muito boa dos algoritmos de tempo polinomial e , não é válida para muitas outras classes de complexidade.$\mathsf{P}$

$\mathsf{NP}$ -completo significa mais difícil problemas$\mathsf{NP}$

Agora que temos uma maneira relativa de comparar a dificuldade dos problemas, podemos perguntar quais problemas são mais difíceis entre os problemas no ? Chamamos esses problemas de completos .$\mathsf{NP}$$\mathsf{NP}$

$\mathsf{NP}$ problemas -Complete são os mais difíceis problemas$\mathsf{NP}$ ,
se podemos resolver uma problema -completo de forma eficiente, podemos resolver todos os problemas de forma eficiente.$\mathsf{NP}$$\mathsf{NP}$

Mais formalmente, dizemos que um problema de decisão é completo se$A$$\mathsf{NP}$

$A$ é em , e para todos problemas , é polinomial de tempo de muitos-ona redutível a ( ).$\mathsf{NP}$
$\mathsf{NP}$$B$$B$$A$$B\leq_m^\mathsf{P} A$

Outra maneira de pensar sobre os é pensar neles como a versão de complexidade das máquinas de Turing universais . Um é universal entre os problemas de em um sentido semelhante: você pode usá-los para resolver qualquer problema de .$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$

Essa é uma das razões pelas quais bons solucionadores de SAT são importantes, principalmente no setor. O SAT é completo (mais sobre isso mais tarde), para que possamos focar no design de algoritmos muito bons (o máximo que pudermos) para resolver o SAT. Para resolver qualquer outro problema no , podemos converter a instância do problema em uma instância SAT e, em seguida, usar um solucionador SAT altamente otimizado de qualidade industrial.$\mathsf{NP}$$\mathsf{NP}$

(Dois outros problemas em que muitas pessoas trabalham para otimizar seus algoritmos para uso prático na indústria são: Programação Inteira e Problema de Satisfação de Restrições . Dependendo do seu problema e das instâncias em que você se preocupa com os algoritmos otimizados para um deles, pode ter um desempenho melhor que o outras.)

Se um problema satisfizer a segunda condição na definição de -completeness (isto é, a condição de universalidade) , chamamos o problema -hard .$\mathsf{NP}$
$\mathsf{NP}$

$\mathsf{NP}$ dureza é uma maneira de dizer que um problema é difícil.

Eu pessoalmente prefiro pensar sobre -hardness como universalidade, então provavelmente -Universal poderia ter sido um nome mais correto, já que não sabemos no momento se eles são realmente difíceis ou é apenas porque não conseguimos encontrar um algoritmo de tempo polinomial para eles).$\mathsf{NP}$$\mathsf{NP}$

O nome -hard também confunde as pessoas a pensarem incorretamente que os problemas -hard são problemas que são absolutamente difíceis de resolver. Nós não sabemos que, no entanto, só sabemos que eles são tão difícil como qualquer problema para resolver. Embora os especialistas pensem que é improvável, ainda é possível que todos os problemas do sejam fáceis e eficientemente solucionáveis. Em outras palavras, ser tão difícil quanto qualquer outro problema não significa realmente difícil. Isso só é verdade se houver um problema que é absolutamente difícil (ou seja, não possui nenhum algoritmo de tempo polinomial).$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$

Agora as perguntas são:

• Existem problemas com o ?$\mathsf{NP}$

• Conhecemos algum deles?

Eu já dei a resposta quando discutimos os solucionadores de SAT. O surpreendente é que muitos problemas naturais de acabam sendo (mais sobre isso mais adiante). Portanto, se escolhermos aleatoriamente problemas naturais em , com uma probabilidade muito alta, é que conhecemos um algoritmo de tempo polinomial para ele ou que sabemos que ele é completo. O número de problemas naturais que também não são conhecidos é muito pequeno (um exemplo importante é fatorar números inteiros; consulte esta lista para obter uma lista de problemas semelhantes).$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$

Antes de passar para exemplos de problemas com , observe que podemos fornecer definições semelhantes para outras classes de complexidade e definir classes de complexidade como . Mas como eu disse, tem um lugar muito especial: diferente de outras classes de complexidade têm poucos problemas completos naturais.$\mathsf{NP}$$\mathsf{ExpTime}$$\mathsf{NP}$$\mathsf{NP}$

(Por um problema natural, quero dizer um problema que as pessoas realmente se importam em resolver, não problemas que são definidos artificialmente por pessoas para demonstrar algum ponto. Podemos modificar qualquer problema de uma maneira que permaneça essencialmente o mesmo problema, por exemplo, podemos alterar o responda para a entrada no SAT como NO. Podemos definir infinitamente muitos problemas distintos de maneira semelhante sem essencialmente mudar o problema. Mas quem realmente se importaria com esse problema artificial sozinho?)$p \lor \lnot p$

$\mathsf{NP}$Problemas : existem problemas universais em$\mathsf{NP}$

Primeiro, observe que se é -hard e -polinômio-muitos-um se reduz a então também é -hard. Podemos resolver qualquer problema usando e podemos resolver si usando , para que possamos resolver qualquer problema usando !$A$$\mathsf{NP}$$A$$B$$B$$\mathsf{NP}$$\mathsf{NP}$$A$$A$$B$$\mathsf{NP}$$B$

Este é um lema muito útil. Se queremos mostrar que um problema é -hard, temos que mostrar que podemos reduzir todos os problemas , isso não é fácil, porque não sabemos nada sobre esses problemas além de que eles são em .$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$

Pense nisso por um segundo. É incrível a primeira vez que vemos isso. Podemos provar que todos os problemas do são redutíveis ao SAT e sem saber nada sobre esses problemas além do fato de estarem no !$\mathsf{NP}$$\mathsf{NP}$

Felizmente, não precisamos realizar isso mais de uma vez. Depois que mostramos um problema como é -hard para outros problemas, precisamos apenas reduzir o para eles. Por exemplo, para mostrar que é -hard, precisamos apenas reduzir o para o .$SAT$$\mathsf{NP}$$SAT$$SubsetSum$$\mathsf{NP}$$SAT$$SubsetSum$

OK, vamos mostrar que há um .$\mathsf{NP}$

O Verificador Universal está completo$\mathsf{NP}$

Nota: a parte a seguir pode ser um pouco técnica na primeira leitura.

O primeiro exemplo é um pouco artificial, mas acho que é mais simples e útil para a intuição. Lembre-se da definição do verificador de . Queremos definir um problema que possa ser usado para resolver todos eles. Então, por que não apenas definir o problema?$\mathsf{NP}$

Time-Bounded Universal Verificador
de entrada: o código de um algoritmo que recebe uma entrada e uma prova, uma entrada , e dois números e . Saída: se houver uma prova de tamanho no máximo st, é aceita por para a entrada em etapas , se não houver tais provas.$V$$x$$t$$k$
$YES$$k$$V$$x$$t$$NO$

Não é difícil mostrar esse problema que chamarei de como -hard:$UniVer$$\mathsf{NP}$

Pegue um verificador para encontrar um problema em . Para verificar se há provas para a entrada , passamos o código de e para o . ( e são limites superiores no tempo de execução de e no tamanho das provas que procuramos . precisamos que eles limitem o tempo de execução de e o tamanho das provas de polinômios no tamanho de ).$V$$\mathsf{NP}$$x$$V$$x$$UniVer$
$t$$k$$V$$x$$V$$x$

(Detalhes técnicos: o tempo de execução será polinomial em e gostaríamos que o tamanho da entrada fosse pelo menos portanto, damos em notação unária e não binária. semelhante é dado em unária.)$t$$t$$t$$k$

Ainda precisamos mostrar que o problema está em . Para mostrar que o está em , consideramos o seguinte problema:$\mathsf{NP}$$UniVer$$\mathsf{NP}$

Entrada de intérprete com limite de tempo : o código de um algoritmo , uma entrada para e um número . Saída: se o algoritmo dado a entrada retornar em etapas, se não retornar em etapas.$M$$x$$M$$t$
$YES$$M$$x$$YES$$t$$NO$$YES$$t$

Você pode pensar em um algoritmo aproximadamente como o código de um programaNão é difícil ver esse problema em . É essencialmente escrever um intérprete, contar o número de etapas e parar após etapas.$C$$\mathsf{P}$$t$

Usarei a abreviação para esse problema.$Interpreter$

Agora não é difícil ver que está em : dada entrada , , , e ; e uma prova sugerida ; verificar se tem tamanho no máximo e, em seguida, usar o para ver se retorna em e em passos.$UniVer$$\mathsf{NP}$$M$$x$$t$$k$$c$$c$$k$$Interpreter$$M$$YES$$x$$c$$t$

N $SAT$ é completo$\mathsf{NP}$

O verificador universal é um pouco artificial. Não é muito útil mostrar que outros problemas são -hard. Fazer uma redução no não é muito mais fácil do que reduzir um problema arbitrário . Precisamos de problemas mais simples.N P U n i V e r N $UniVer$$\mathsf{NP}$$UniVer$$\mathsf{NP}$

Historicamente, o primeiro problema natural que se mostrou como foi .S A T$\mathsf{NP}$$SAT$

Lembre-se de que é o problema em que recebemos uma fórmula proposicional e queremos ver se ela é satisfatória , isto é , se podemos atribuir verdadeiro / falso às variáveis ​​proposicionais para fazê-lo avaliar como verdadeiro.$SAT$

Entrada SAT : uma fórmula proposicional . Saída: se for satisfatório, se não for.Y E S φ N $\varphi$
$YES$$\varphi$$NO$

Não é difícil ver que o está em . Podemos avaliar uma dada fórmula proposicional em uma determinada atribuição de verdade em tempo polinomial. O verificador receberá uma atribuição de verdade e avaliará a fórmula nessa atribuição de verdade.N $SAT$$\mathsf{NP}$

Para ser escrito ...

SAT é -hard$\mathsf{NP}$

O que significa -completeness para a prática?$\mathsf{NP}$

O que fazer se você precisar resolver um problema ?$\mathsf{NP}$

N $\mathsf{P}$ vs.$\mathsf{NP}$

Qual é o próximo? Para onde ir a partir daqui?

Mais do que útil respostas mencionadas, eu recomendo que você altamente para assistir " além da computação: A P vs NP Problema ", de Michael Sipser . Acho que este vídeo deve ser arquivado como um dos principais vídeos de ensino em ciência da computação.!

Desfrutar!

Copiando minha resposta para uma pergunta semelhante no Stack Overflow:

A maneira mais fácil de explicar P v. NP e outras coisas sem entrar em detalhes técnicos é comparar "problemas de palavras" com "problemas de múltipla escolha".

Quando você está tentando resolver um "problema de palavras", precisa encontrar a solução do zero. Quando você está tentando resolver um "problema de múltipla escolha", tem uma opção: resolva-o como faria com um "problema de palavras" ou tente inserir cada uma das respostas que lhe foram dadas e escolha a resposta que melhor se encaixa.

Muitas vezes acontece que um "problema de múltipla escolha" é muito mais fácil do que o correspondente "problema de palavras": substituir as respostas do candidato e verificar se elas se encaixam podem exigir um esforço significativamente menor do que encontrar a resposta certa do zero.

Agora, se concordarmos com o esforço que leva tempo polinomial "fácil", a classe P consistiria em "problemas fáceis de palavras" e a classe NP consistiria em "problemas fáceis de múltipla escolha".

A essência de P v. NP é a pergunta: "Existem problemas fáceis de múltipla escolha que não são fáceis como problemas de palavras"? Ou seja, existem problemas para os quais é fácil verificar a validade de uma resposta dada, mas é difícil encontrá-la do zero?

Agora que entendemos intuitivamente o que é NP, precisamos desafiar nossa intuição. Acontece que existem "problemas de múltipla escolha" que, em certo sentido, são os mais difíceis de todos: se alguém encontrasse uma solução para um desses problemas "mais difíceis de todos", seria capaz de encontrar uma solução para TODOS. Problemas de NP! Quando Cook descobriu isso há 40 anos, foi uma surpresa completa. Esses problemas "mais difíceis de todos" são conhecidos como NP-hard. Se você encontrar uma "solução de problemas de palavras" para um deles, encontrará automaticamente uma "solução de problemas de palavras" para cada um dos "problemas fáceis de múltipla escolha"!

Finalmente, problemas NP-completos são aqueles que são simultaneamente NP e NP-difíceis. Seguindo nossa analogia, eles são simultaneamente "fáceis como problemas de múltipla escolha" e "os mais difíceis de todos como problemas de palavras".

O mais simples deles é P, os problemas solucionáveis ​​no tempo polinomial pertencem aqui.

Então vem NP. Problemas solucionáveis ​​em tempo polinomial em uma máquina de Turing não determinística pertencem aqui.

A dureza e a integridade têm a ver com reduções. Um problema A é difícil para uma classe C se todos os problemas em C forem reduzidos a A. Se o problema A for difícil para NP , ou NP-difícil, se todos os problemas em NP forem reduzidos a A.

Finalmente, um problema está completo para uma classe C se estiver em C e difícil para C. No seu caso, o problema A está completo para NP ou NP-completo, se todo problema em NP se reduzir a A e A estiver em NP .

Para adicionar à explicação do NP, um problema está no NP se e somente se uma solução puder ser verificada no tempo polinomial (determinístico). Considere qualquer problema de NP completo, SAT, CLIQUE, SUBSET SUM, VERTEX COVER, etc. Se você "obtiver a solução", poderá verificar sua correção em tempo polinomial. São, respectivamente, atribuições de verdade para variáveis, subgráfico completo, subconjunto de números e conjunto de vértices que dominam todas as arestas.

Para o básico, o vídeo P vs. NP e o Zoológico da Complexidade Computacional parece muito mais simples de entender.

Para um computador com uma versão realmente grande de um problema :

Problemas de P

fácil de resolver (cubo de rubix)

Problemas NP

difícil - mas verificar as respostas é fácil (sudoku)

Talvez todos esses sejam realmente problemas de P, mas não sabemos ... P vs. NP .

Muitos problemas de NP se resumem ao mesmo (o sudoku é um recém-chegado à lista).

Problemas de EXP

muito difícil (melhor jogada seguinte no xadrez)

Problemas NP-difíceis

Edit: NP-hard não é bem explicado no vídeo (são todos os bits cor-de-rosa), o diagrama de Euler NP-hard da Wikipedia é mais claro nisso.

Resumo do vídeo

Diagrama de Euler NP-rígido da Wikipedia

P , NP , NP completo e NP rígido são classes de complexidade, classificando os problemas de acordo com a complexidade algorítmica para resolvê-los. Em resumo, eles são baseados em três propriedades:

Resolvível em tempo polinomial: define os problemas de decisão que podem ser resolvidos por uma máquina de Turing determinística (DTM) usando uma quantidade polinomial de tempo de computação, ou seja, seu tempo de execução é superior ao limite de uma expressão polinomial no tamanho da entrada do algoritmo. Usando a notação Big-O, essa complexidade de tempo é definida como O(n ^ k), onde n é o tamanho da entrada e o coeficiente ka constante.

Solução verificável em tempo polinomial: define os problemas de decisão para os quais uma determinada solução pode ser verificada por um DTM usando uma quantidade polinomial de tempo de computação, mesmo que a obtenção da solução correta exija maior quantidade de tempo.

Reduz qualquer problema de NP em tempo polinomial : define problemas de decisão cujos algoritmos para resolvê-los podem ser usados ​​para resolver qualquer problema de NP após uma etapa de conversão de tempo polinomial.

Escrevi recentemente um artigo sobre esse assunto, fornecendo mais detalhes, incluindo uma demonstração de código para reduzir um problema NP em um problema NP-difícil: Classes de complexidade de problemas