Estoy en un curso sobre computación y complejidad , y no puedo entender lo que significan estos términos.

Todo lo que sé es que NP es un subconjunto de NP-completo, que es un subconjunto de NP-hard, pero no tengo idea de lo que realmente significan. Wikipedia tampoco es de gran ayuda, ya que las explicaciones son todavía un nivel demasiado alto.

Creo que los artículos de Wikipedia $\mathsf{P}$ , $\mathsf{NP}$ y $\mathsf{P}$ vs. $\mathsf{NP}$ son bastante buenos. Todavía aquí está lo que diría: Parte I , Parte II

[Usaré comentarios entre paréntesis para analizar algunos detalles técnicos que puede omitir si lo desea].

Parte 1

Problemas de decisión

Hay varios tipos de problemas computacionales. Sin embargo, en una introducción al curso de teoría de la complejidad computacional, es más fácil enfocarse en el problema de decisión , es decir, problemas en los que la respuesta es SÍ o NO. Existen otros tipos de problemas computacionales, pero la mayoría de las veces las preguntas sobre ellos pueden reducirse a preguntas similares sobre problemas de decisión. Además, los problemas de decisión son muy simples. Por lo tanto, en una introducción al curso de teoría de la complejidad computacional centramos nuestra atención en el estudio de los problemas de decisión.

Podemos identificar un problema de decisión con el subconjunto de entradas que tienen respuesta SÍ. Esto simplifica la notación y nos permite escribir $x\in Q$ en lugar de $Q(x)=YES$ y $x \notin Q$ en lugar de $Q(x)=NO$ .

Otra perspectiva es que estamos hablando de consultas de membresía en un conjunto. Aquí hay un ejemplo:

Problema de decisión:

Entrada: Un número natural $x$ ,
Pregunta: ¿Es $x$ un número par?

Problema de membresía:

Entrada: Un número natural $x$ ,
Pregunta: ¿Es $x$ en $Even = \{0,2,4,6,\cdots\}$ ?

Nos referimos a la respuesta SÍ en una entrada como aceptar la entrada y a la respuesta NO en una entrada como rechazar la entrada.

Analizaremos los algoritmos para problemas de decisión y discutiremos qué tan eficientes son esos algoritmos en el uso de recursos computables . Confiaré en su intuición desde la programación en un lenguaje como C en lugar de definir formalmente lo que queremos decir con un algoritmo y recursos computacionales.

[Observaciones: 1. Si quisiéramos hacer todo de manera formal y precisa, necesitaríamos arreglar un modelo de cómputo como el modelo estándar de máquina de Turing para definir con precisión lo que queremos decir con un algoritmo y su uso de recursos computacionales. 2. Si queremos hablar sobre el cálculo sobre objetos que el modelo no puede manejar directamente, necesitaríamos codificarlos como objetos que el modelo de máquina puede manejar, por ejemplo, si estamos usando máquinas de Turing, necesitamos codificar objetos como números naturales y gráficos como cadenas binarias.]

$\mathsf{P}$ = Problemas con algoritmos eficientes paraencontrarsoluciones

Suponga que algoritmos eficientes significa algoritmos que utilizan como máximo una cantidad polinómica de recursos computacionales. El principal recurso que nos interesa es el peor tiempo de ejecución de los algoritmos con respecto al tamaño de entrada, es decir, el número de pasos básicos que un algoritmo realiza en una entrada de tamaño $n$ . El tamaño de una entrada $x$ es $n$ si se necesitan $n$ bits de memoria de la computadora para almacenar $x$ , en cuyo caso escribimos $|x| = n$ . Entonces, por algoritmos eficientes, nos referimos a algoritmos que tienen un tiempo de ejecución polinómico en el peor de los casos .

La suposición de que los algoritmos de tiempo polinómico capturan la noción intuitiva de algoritmos eficientes se conoce como tesis de Cobham . No discutiré en este punto si $\mathsf{P}$ es el modelo correcto para problemas que se pueden resolver de manera eficiente y si $\mathsf{P}$ captura o no lo que se puede calcular de manera eficiente en la práctica y cuestiones relacionadas. Por ahora hay buenas razones para hacer esta suposición, por lo que para nuestro propósito asumimos que este es el caso. Si no acepta la tesis de Cobham, no hace incorrecto lo que escribo a continuación, lo único que perderemos es la intuición sobre la computación eficiente en la práctica. Creo que es una suposición útil para alguien que está comenzando a aprender sobre la teoría de la complejidad.

$\mathsf{P}$ es la clase de problemas de decisión que se pueden resolver de manera eficiente,
es decir, problemas de decisión que tienen algoritmos de tiempo polinómico.

Más formalmente, decimos que un problema de decisión $Q$ está en $\mathsf{P}$ iff

hay un algoritmo eficiente $A$ tal que
para todas las entradas $x$ ,

• si $Q(x)=YES$ entonces $A(x)=YES$ ,
• si $Q(x)=NO$ entonces $A(x)=NO$ .

Simplemente puedo escribir $A(x)=Q(x)$ , pero lo escribo de esta manera para que podamos compararla con la definición de $\mathsf{NP}$ .

$\mathsf{NP}$ = Problemas con algoritmos eficientes paraverificarpruebas / certificados / testigos

A veces no conocemos ninguna forma eficiente de encontrar la respuesta a un problema de decisión, sin embargo, si alguien nos dice la respuesta y nos da una prueba , podemos verificar de manera eficiente que la respuesta es correcta al verificar la prueba para ver si es una prueba válida. . Esta es la idea detrás de la clase de complejidad $\mathsf{NP}$ .

Si la prueba es demasiado larga, no es realmente útil, puede tomar demasiado tiempo leer la prueba y mucho menos verificar si es válida. ¡Queremos que el tiempo requerido para la verificación sea razonable en el tamaño de la entrada original, no en el tamaño de la prueba dada! Esto significa que lo que realmente queremos no son pruebas largas arbitrarias sino pruebas cortas . Tenga en cuenta que si el tiempo de ejecución del verificador es polinómico en el tamaño de la entrada original, solo puede leer una parte polinómica de la prueba. Entonces, por corto, nos referimos al tamaño polinómico .

Formule este punto cuando use la palabra "prueba", quiero decir "prueba corta".

Aquí hay un ejemplo de un problema que no sabemos cómo resolver de manera eficiente, pero podemos verificar las pruebas de manera eficiente:

Partición de
entrada: un conjunto finito de números naturales $S$ ,
Pregunta: ¿ es posible dividir $S$ en dos conjuntos $A$ y $B$ ( $A \cup B = S$ y $A \cap B = \emptyset$ ) de
modo que la suma de los números en $A$ sea ​​igual a la suma del número en $B$ ( $\sum_{x\in A}x=\sum_{x\in B}x$ )?

Si le doy $S$ y le pregunto si podemos dividirlo en dos conjuntos para que sus sumas sean iguales, no conoce ningún algoritmo eficiente para resolverlo. Probablemente intente todas las formas posibles de dividir los números en dos conjuntos hasta que encuentre una partición donde las sumas sean iguales o hasta que haya probado todas las particiones posibles y ninguna haya funcionado. Si alguno de ellos funcionara, diría SÍ, de lo contrario, diría NO.

Pero hay exponencialmente muchas particiones posibles, por lo que tomará mucho tiempo. Sin embargo, si te doy dos conjuntos $A$ y $B$ , se puede comprobar fácilmente si las sumas son iguales y si $A$ y $B$ es una partición de $S$ . Tenga en cuenta que podemos calcular sumas de manera eficiente.

Aquí el par de $A$ y $B$ que le doy es una prueba de una respuesta SÍ. Puede verificar eficientemente mi reclamo mirando mi comprobante y verificando si es un comprobante válido . Si la respuesta es SÍ, entonces hay una prueba válida, y puedo dársela y usted puede verificarla de manera eficiente. Si la respuesta es NO, entonces no hay prueba válida. Entonces, lo que sea que le dé, puede verificarlo y ver que no es una prueba válida. No puedo engañarte con una prueba no válida de que la respuesta es SÍ. Recuerde que si la prueba es demasiado grande, llevará mucho tiempo verificarla, no queremos que esto suceda, por lo que solo nos preocupamos por las pruebas eficientes , es decir, las pruebas que tienen un tamaño polinómico.

A veces las personas usan " certificado " o " testigo " en lugar de "prueba".

Tenga en cuenta que le estoy dando suficiente información sobre la respuesta para una entrada dada $x$ para que pueda encontrar y verificar la respuesta de manera eficiente. Por ejemplo, en nuestro ejemplo de partición, no le digo la respuesta, solo le doy una partición y puede verificar si es válida o no. Tenga en cuenta que debe verificar la respuesta usted mismo, no puede confiar en mí acerca de lo que digo. Además, solo puede verificar la exactitud de mi prueba. Si mi prueba es válida, significa que la respuesta es SÍ. Pero si mi prueba no es válida, no significa que la respuesta sea NO. Ha visto que una prueba no era válida, no que no haya pruebas válidas. Estamos hablando de pruebas de SÍ. No estamos hablando de pruebas de NO.

Veamos un ejemplo: $A=\{2,4\}$ y $B=\{1,5\}$ es una prueba de que $S=\{1,2,4,5\}$ se puede dividir en dos conjuntos con sumas iguales. Sólo tenemos que resumir los números en $A$ y los números en $B$ y ver si los resultados son iguales, y comprobar si $A$ , $B$ es la partición de $S$ .

Si le di $A=\{2,5\}$ y $B=\{1,4\}$ , verificará y verá que mi prueba no es válida. No significa que la respuesta sea NO, solo significa que esta prueba en particular no era válida. Su tarea aquí no es encontrar la respuesta, sino solo verificar si la prueba que se le da es válida.

Es como un estudiante resolviendo una pregunta en un examen y un profesor verificando si la respuesta es correcta. :) (desafortunadamente a menudo los estudiantes no dan suficiente información para verificar la exactitud de su respuesta y los profesores tienen que adivinar el resto de su respuesta parcial y decidir cuánta calificación deberían dar a los estudiantes por sus respuestas parciales, de hecho, es bastante difícil tarea).

Lo sorprendente es que la misma situación se aplica a muchos otros problemas naturales que queremos resolver: podemos verificar eficientemente si una prueba corta es válida, pero no conocemos ninguna forma eficiente de encontrar la respuesta . Esta es la motivación por la cual la clase de complejidad $\mathsf{NP}$ es extremadamente interesante (aunque esta no fue la motivación original para definirla). Independientemente de lo que haga (no solo en CS, sino también en matemáticas, biología, física, química, economía, administración, sociología, negocios, ...) enfrentará problemas de computación que se incluyen en esta clase. Para tener una idea de cuántos problemas resultan en $\mathsf{NP}$ consulte Un compendio de problemas de optimización de NP . En efecto tendrá dificultades para encontrar problemas naturales que no están en $\mathsf{NP}$ . Es simplemente asombroso.

$\mathsf{NP}$ es la clase de problemas que tienen verificadores eficientes, es decir,
hay un algoritmo de tiempo polinómico que puede verificar si una solución dada es correcta.

Más formalmente, decimos que un problema de decisión $Q$ está en $\mathsf{NP}$ iff

hay un algoritmo eficiente $V$ llamado verificador de modo que
para todas las entradas $x$ ,

• si $Q(x)=YES$ entonces hay una prueba $y$ tal que $V(x,y)=YES$ ,
• si $Q(x)=NO$ entonces para todas las pruebas $y$ , $V(x,y)=NO$ .

Decimos que un verificador es el sonido si no se hace la prueba cuando la respuesta es NO. En otras palabras, un verificador de sonido no puede ser engañado para aceptar una prueba si la respuesta es realmente NO. No hay falsos positivos.

Del mismo modo, decimos que un verificador está completo si acepta al menos una prueba cuando la respuesta es SÍ. En otras palabras, un verificador completo puede estar convencido de que la respuesta es SÍ.

La terminología proviene de la lógica y los sistemas de prueba . No podemos usar un sistema de prueba de sonido para probar declaraciones falsas. Podemos usar un sistema de prueba completo para probar todas las declaraciones verdaderas.

El verificador $V$ obtiene dos entradas,

• $x$ : la entrada original para$Q$ , y
• $y$ : a prueba sugerido para$Q(x)=YES$ .

Tenga en cuenta que queremos que $V$ sea ​​eficiente en el tamaño de $x$ . Si $y$ es una gran prueba, el verificador podrá leer solo una parte polinómica de $y$ . Es por eso que exigimos que las pruebas sean cortas. Si $y$ es corto, decir que $V$ es eficiente en $x$ es lo mismo que decir que $V$ es eficiente en $x$ e $y$ (porque el tamaño de $y$ está limitado por un polinomio fijo en el tamaño de $x$ ).

En resumen, para mostrar que un problema de decisión $Q$ está en $\mathsf{NP}$ , tenemos que dar un algoritmo verificador eficiente que sea sólido y completo .

Nota histórica: históricamente, esta no es la definición original de $\mathsf{NP}$ . La definición original utiliza lo que se llama máquinas de Turing no deterministas . Estas máquinas no corresponden a ningún modelo de máquina real y es difícil acostumbrarse a ellas (al menos cuando comienza a aprender sobre la teoría de la complejidad). He leído que muchos expertos piensan que habrían usado la definición del verificador como la definición principal e incluso habrían nombrado la clase $\mathsf{VP}$ (verificable en tiempo polinómico) en lugar de $\mathsf{NP}$ si se remontan a los albores de la teoría de la complejidad computacional. La definición verificador es más natural, más fácil de entender conceptualmente, y más fácil de usar para mostrar problemas son en $\mathsf{NP}$ .

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

Por lo tanto, tenemos $\mathsf{P}$ = eficiente solucionable y $\mathsf{NP}$ = eficientemente verificable . Entonces $\mathsf{P}=\mathsf{NP}$ si los problemas que pueden verificarse eficientemente son los mismos que los problemas que pueden resolverse eficientemente.

Tenga en cuenta que cualquier problema en $\mathsf{P}$ también está en $\mathsf{NP}$ , es decir, si puede resolver el problema, también puede verificar si una prueba dada es correcta: ¡el verificador simplemente ignorará la prueba!

Eso es porque no lo necesitamos, el verificador puede calcular la respuesta por sí mismo, puede decidir si la respuesta es SÍ o NO sin ninguna ayuda. Si la respuesta es NO, sabemos que no debería haber pruebas y nuestro verificador simplemente rechazará todas las pruebas sugeridas. Si la respuesta es SÍ, debería haber una prueba y, de hecho, aceptaremos cualquier cosa como prueba.

[Podríamos haber hecho que nuestro verificador acepte solo algunos de ellos, eso también está bien, siempre que nuestro verificador acepte al menos una prueba de que el verificador funciona correctamente para el problema.]

Aquí hay un ejemplo:

$n+1$$a_1,\cdots,a_n$$s$
$\Sigma_{i=1}^n a_i = s$

$\mathsf{P}$$s$

$\mathsf{NP}$$V$$\mathsf{P}$

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

$\mathsf{NP}$$\mathsf{NP}\subseteq \mathsf{ExpTime}$

$\mathsf{NP}$$\mathsf{NP}$

En nuestro ejemplo de partición, probamos todas las particiones posibles y verificamos si las sumas son iguales en alguna de ellas.

$m$$2^m$

$\mathsf{NP}$$\mathsf{NP}\subseteq \mathsf{ExpTime}$$\mathsf{NP}\subseteq \mathsf{PSpace}$

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

$\mathsf{NP}=\mathsf{P}$$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$

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

$\mathsf{NP}$$\mathsf{NP}$

Los límites inferiores parecen difíciles de demostrar

$\mathsf{NP}$

Lamentablemente, la tarea de probar los límites inferiores es muy difícil. ¡ Ni siquiera podemos probar que estos problemas requieran más que tiempo lineal ! Sin mencionar que requiere tiempo exponencial.

Probar límites inferiores de tiempo lineal es bastante fácil: el algoritmo necesita leer la entrada después de todo. Probar límites inferiores superlineales es una historia completamente diferente. Podemos probar límites inferiores superlineales con más restricciones sobre el tipo de algoritmos que estamos considerando, por ejemplo, ordenar algoritmos mediante comparación, pero no conocemos límites inferiores sin esas restricciones.

Para demostrar un límite superior para un problema, solo necesitamos diseñar un algoritmo suficientemente bueno. A menudo se necesita conocimiento, pensamiento creativo e incluso ingenio para crear dicho algoritmo.

Sin embargo, la tarea es considerablemente más simple en comparación con probar un límite inferior. Tenemos que demostrar que no hay buenos algoritmos . No es que no conozcamos ningún algoritmo lo suficientemente bueno en este momento, sino que no existe ningún algoritmo bueno , que a nadie se le ocurra un buen algoritmo . Piénselo por un minuto si no lo ha hecho antes, ¿cómo podemos mostrar un resultado tan imposible ?

$1=0$

Para demostrar un límite inferior, es decir, para demostrar que un problema requiere una cierta cantidad de tiempo para resolver, significa que tenemos para demostrar que cualquier$\mathsf{NP}$problemas, por ejemplo, codiciosos y sus extensiones no pueden funcionar, y hay algunos trabajos relacionados con algoritmos de programación dinámica, y hay algunos trabajos sobre formas particulares de usar la programación lineal. Pero estos ni siquiera están cerca de descartar las ideas inteligentes que conocemos (si está interesado, busque límites más bajos en modelos restringidos de cómputo).

Barreras: los límites más bajos son difíciles de probar

Por otro lado, tenemos resultados matemáticos llamados barreras que dicen que una prueba de límite inferior no puede ser tal y tal, ¡y tal y tal cubre casi todas las técnicas que hemos utilizado para probar los límites inferiores! De hecho, muchos investigadores dejaron de trabajar para probar los límites inferiores después del resultado de la barrera de pruebas naturales de Alexander Razbarov y Steven Rudich . Resulta que la existencia de un tipo particular de pruebas de límite inferior implicaría la inseguridad de los generadores de números pseudoaleatorios criptográficos y muchas otras herramientas criptográficas.

Digo casi porque en los últimos años ha habido algunos avances, principalmente por parte de Ryan Williams, que ha sido capaz de sortear de manera inteligente los resultados de la barrera, aún así los resultados hasta ahora son para modelos de computación muy débiles y bastante lejos de descartar algoritmos generales de tiempo polinómico .

$\mathsf{NP}$

[Por otro lado, el trabajo de Ryan Williams muestra que hay conexiones cercanas entre probar los límites inferiores y probar los límites superiores. Vea su charla en ICM 2014 si está interesado.]

Reducciones: Resolver un problema utilizando otro problema como subrutina / Oracle / Black Box

La idea de una reducción es muy simple: para resolver un problema, use un algoritmo para otro problema.

$n$$Sum$$Sum$

Problema:

$n$$x_1,\ldots,x_n$
$\sum_{i=1}^{n} x_i$

Algoritmo de reducción:

1. $s = 0$
2. $i$$1$$n$
   $s = Sum(s,x_i)$
3. $s$

$Sum$$Sum$$Sum$$Sum$

Esto es esencialmente lo que es una reducción: suponga que tenemos un algoritmo para un problema y úselo como un oráculo para resolver otro problema. Aquí eficiente significa eficiente asumiendo que el oráculo responde en una unidad de tiempo, es decir, contamos cada ejecución del oráculo en un solo paso.

Si el oráculo devuelve una respuesta grande, debemos leerla y eso puede llevar algún tiempo, por lo que debemos contar el tiempo que nos lleva leer la respuesta que nos ha dado el oráculo. Del mismo modo para escribir / hacer la pregunta del oráculo. Pero el oráculo funciona instantáneamente, es decir, tan pronto como hacemos la pregunta del oráculo, el oráculo escribe la respuesta para nosotros en una sola unidad de tiempo. Todo el trabajo que realiza Oracle cuenta un solo paso, pero esto excluye el tiempo que nos lleva escribir la pregunta y leer la respuesta.

Debido a que no nos importa cómo funciona Oracle, sino solo por las respuestas que devuelve, podemos hacer una simplificación y considerar que el Oracle es el problema en lugar de un algoritmo para ello. En otras palabras, no nos importa si el oráculo no es un algoritmo, no nos importa cómo surgen los oráculos con sus respuestas.

$Sum$

Podemos hacer múltiples preguntas desde un oráculo, y las preguntas no necesitan ser predeterminadas: podemos hacer una pregunta y, en base a la respuesta que devuelve el oráculo, realizamos algunos cálculos por nosotros mismos y luego hacemos otra pregunta basada en la respuesta que obtuvimos. La pregunta anterior.

Otra forma de ver esto es pensarlo como un cálculo interactivo . El cálculo interactivo en sí mismo es un gran tema, por lo que no voy a entrar aquí, pero creo que mencionar esta perspectiva de reducciones puede ser útil.

$A$$O$$A^O$

La reducción que discutimos anteriormente es la forma más general de reducción y se conoce como reducción de caja negra (también conocida como reducción de oráculo , reducción de Turing ).

Más formalmente:

$Q$$O$$Q \leq_T O$
$A$$x$
$Q(x) = A^O(x)$

$A$$O$$Q$

$A$$Q\leq^\mathsf{P}_T O$$T$

Sin embargo, es posible que deseemos poner algunas restricciones en la forma en que el algoritmo de reducción interactúa con el oráculo. Hay varias restricciones que se estudian, pero la restricción más útil es la llamada reducciones de muchos (también conocida como reducciones de mapeo ).

$x$$y$

Más formalmente,

$Q$$O$$Q \leq_m O$
$A$$x$
$Q(x) = O(A(x))$

$Q \leq_m^\mathsf{P} O$

$\mathsf{NP}$$A$$\mathsf{NP}$$B$$A$$\mathsf{NP}$

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

La publicación se ha vuelto demasiado larga y supera el límite de una respuesta (30000 caracteres). Continuaré la respuesta en la Parte II .

Parte II

Continuación de la primera parte .

La anterior excedió el número máximo de letras permitidas en una respuesta (30000), así que la estoy dividiendo en dos.

$\mathsf{NP}$ $\mathsf{NP}$

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

Ahora a veces queremos decir que un problema es difícil de resolver . Pero como mencionamos anteriormente, no podemos usar límites inferiores para este propósito: en teoría son exactamente lo que nos gustaría probar, sin embargo, en la práctica no hemos tenido mucho éxito en probar límites inferiores y, en general, son difíciles de probar como mencionamos encima. ¿Todavía hay una manera de decir que un problema es difícil de resolver ?

$\mathsf{NP}$$\mathsf{NP}$

Reducciones como dificultad relativa

$A$$B$$A$$B$$\leq$

$A$$B$$A$$B$

$M^B$$A$$B$$M$$B$$A$$N$$B$$M^B$$N$$M^N$$A$

$\mathsf{P}$

$\mathsf{NP}$$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$
$\mathsf{NP}$$\mathsf{NP}$

$A$$\mathsf{NP}$

$A$$\mathsf{NP}$
$\mathsf{NP}$$B$$B$$A$$B\leq_m^\mathsf{P} A$

$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$

(Otros dos problemas en los que mucha gente trabaja para optimizar sus algoritmos para su uso práctico en la industria son la programación de enteros y el problema de satisfacción de restricciones . Dependiendo de su problema y las instancias que le interesan, los algoritmos optimizados para uno de estos podrían funcionar mejor que el otros.)

$\mathsf{NP}$
$\mathsf{NP}$

$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$ duro (es decir, no tiene ningún algoritmo de tiempo polinómico).

Ahora las preguntas son:

• $\mathsf{NP}$

• ¿Conocemos alguno de ellos?

$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{ExpTime}$$\mathsf{NP}$$\mathsf{NP}$

$p \lor \lnot p$

$\mathsf{NP}$$\mathsf{NP}$

$A$$\mathsf{NP}$$A$$B$$B$$\mathsf{NP}$$\mathsf{NP}$$A$$A$$B$$\mathsf{NP}$$B$

$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$

$SAT$$\mathsf{NP}$$SAT$$SubsetSum$$\mathsf{NP}$$SAT$$SubsetSum$

$\mathsf{NP}$

$\mathsf{NP}$

Nota: la siguiente parte puede ser un poco técnica en la primera lectura.

$\mathsf{NP}$

$V$$x$$t$$k$
$YES$$k$$V$$x$$t$$NO$

$UniVer$$\mathsf{NP}$

$V$$\mathsf{NP}$$x$$V$$x$$UniVer$
$t$$k$$V$$x$$V$$x$

$t$$t$$t$$k$

$\mathsf{NP}$$UniVer$$\mathsf{NP}$

$M$$x$$M$$t$
$YES$$M$$x$$YES$$t$$NO$$YES$$t$

$C$$\mathsf{P}$$t$

$Interpreter$

$UniVer$$\mathsf{NP}$$M$$x$$t$$k$$c$$c$$k$$Interpreter$$M$$YES$$x$$c$$t$

$SAT$$\mathsf{NP}$

$UniVer$$\mathsf{NP}$$UniVer$$\mathsf{NP}$

$\mathsf{NP}$$SAT$

$SAT$

$\varphi$
$YES$$\varphi$$NO$

$SAT$$\mathsf{NP}$

Para ser escrito...

$\mathsf{NP}$

$\mathsf{NP}$

$\mathsf{NP}$

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

¿Que sigue? ¿A dónde ir desde aquí?

Más que útil respuestas mencionadas, le recomiendo altamente para ver " Más allá de Cálculo: El P vs NP Problema " de Michael Sipser . Creo que este video debería ser archivado como uno de los videos de enseñanza líderes en informática.

¡Disfrutar!

Copiando mi respuesta a una pregunta similar sobre Stack Overflow:

La forma más fácil de explicar P v. NP y tal sin entrar en tecnicismos es comparar "problemas de palabras" con "problemas de opción múltiple".

Cuando intenta resolver un "problema de palabras", tiene que encontrar la solución desde cero. Cuando intenta resolver un "problema de opción múltiple" tiene una opción: resolverlo como lo haría con un "problema de palabras", o tratar de conectar cada una de las respuestas que se le dieron y elegir la respuesta candidata que se ajuste.

A menudo sucede que un "problema de opción múltiple" es mucho más fácil que el "problema de palabras" correspondiente: sustituir las respuestas del candidato y verificar si encajan puede requerir un esfuerzo significativamente menor que encontrar la respuesta correcta desde cero.

Ahora, si estuviéramos de acuerdo en que el esfuerzo que lleva el tiempo polinómico es "fácil", entonces la clase P consistiría en "problemas de palabras fáciles", y la clase NP consistiría en "problemas fáciles de opción múltiple".

La esencia de P v. NP es la pregunta: "¿Hay algún problema fácil de opción múltiple que no sea tan fácil como un problema de palabras"? Es decir, ¿hay problemas para los cuales es fácil verificar la validez de una respuesta dada pero es difícil encontrar esa respuesta desde cero?

Ahora que entendemos intuitivamente qué es NP, tenemos que desafiar nuestra intuición. Resulta que hay "problemas de opción múltiple" que, en cierto sentido, son los más difíciles de todos: si uno encontrara una solución a uno de esos problemas "más difíciles de todos", sería capaz de encontrar una solución para TODOS NP problemas! Cuando Cook descubrió esto hace 40 años, fue una completa sorpresa. Estos problemas "más difíciles de todos" se conocen como NP-hard. Si encuentra una "solución de problemas de palabras" para uno de ellos, ¡encontrará automáticamente una "solución de problemas de palabras" para cada "problema de opción múltiple fácil"!

Finalmente, los problemas NP-completos son aquellos que son NP y NP-hard simultáneamente. Siguiendo nuestra analogía, son simultáneamente "fáciles como problemas de opción múltiple" y "los más difíciles de todos como problemas verbales".

El más simple de ellos es P, los problemas que se pueden resolver en el tiempo polinómico pertenecen aquí.

Luego viene NP. Los problemas que se pueden resolver en tiempo polinómico en una máquina de Turing no determinista pertenecen aquí.

La dureza e integridad tiene que ver con las reducciones. Un problema A es difícil para una clase C si cada problema en C se reduce a A. Si el problema A es difícil para NP , o NP-difícil, si cada problema en NP se reduce a A.

Finalmente, un problema está completo para una clase C si está en C y difícil para C. En su caso, el problema A está completo para NP , o NP-completo, si cada problema en NP se reduce a A, y A está en NP .

Para agregar a la explicación de NP, un problema está en NP si y solo si una solución puede ser verificada en tiempo polinómico (determinista). Considere cualquier problema de NP completo que conozca, SAT, CLIQUE, SUBSET SUM, VERTEX COVER, etc. Si "obtiene la solución", puede verificar su corrección en el tiempo polinómico. Son, respectivamente, asignaciones de verdad para variables, subgrafo completo, subconjunto de números y conjunto de vértices que domina todos los bordes.

Del video P vs. NP y el video Computational Complexity Zoo .

Para una computadora con una versión realmente grande de un problema ...

Problemas P

fácil de resolver (cubo de rubix)

Problemas de NP

difícil de resolver, pero verificar las respuestas es fácil (sudoku)

Quizás todos estos son realmente problemas de P pero no lo sabemos ... P vs. NP .

Muchos problemas de NP se reducen al mismo (sudoku es un recién llegado a la lista).

Problemas de EXP

realmente difícil de resolver (por ejemplo, el mejor próximo movimiento en ajedrez)

Problemas NP-difíciles

NP-hard no se explica bien en el video (son todos los bits rosados ​​en el siguiente diagrama). El diagrama de Euler NP-hard de Wikipedia es más claro al respecto.

Diagrama

Como se muestra cerca del final del video.

P , NP , NP-complete y NP-hard son clases de complejidad, que clasifican los problemas de acuerdo con la complejidad algorítmica para resolverlos. En resumen, se basan en tres propiedades:

Soluble en tiempo polinómico: define los problemas de decisión que puede resolver una máquina de Turing determinista (DTM) utilizando una cantidad polinómica de tiempo de cálculo, es decir, su tiempo de ejecución está limitado por una expresión polinómica en el tamaño de la entrada para el algoritmo. Usando la notación Big-O, esta complejidad temporal se define como O(n ^ k), donde n es el tamaño de la entrada y el coeficiente constante de ka.

Solución verificable en tiempo polinómico: define los problemas de decisión para los cuales una solución determinada puede ser verificada por un DTM utilizando una cantidad polinómica de tiempo de cálculo, aunque obtener la solución correcta puede requerir mayores cantidades de tiempo.

Reduce cualquier problema de NP en tiempo polinómico : define problemas de decisión cuyos algoritmos para resolverlos se pueden usar para resolver cualquier problema de NP después de un paso de traducción de tiempo polinómico.

Recientemente escribí un artículo sobre este tema que proporciona más detalles, incluida una demostración de código para reducir un problema NP a un problema NP-difícil: clases de problemas de complejidad