Cálculo de cualquier información sobre Max-3SAT

Para una fórmula 3CNF dejó sea el máximo número de cláusulas satisfechos en cualquier asignación a . Se sabe que Max-3SAT es difícil de aproximar (sujeto a P ≠ NP), es decir, no existe un algoritmo de polytime cuya entrada es una fórmula 3CNF , y cuya salida es el número tal que está dentro de un factor multiplicativo de , donde es una constante positiva absoluta.$C$$M(C)$$C$$C$$M'$$M(C)$$1+c$$M'$$c>0$

Creo que también es NP-difícil calcular para cualquier módulo constante p . Me pregunto si la siguiente generalización común de estos dos hechos es cierta: no existe un algoritmo de polytime cuya entrada es una fórmula C de 3CNF con N cláusulas, y una cadena de bits de aviso \ log_2 NB , y cuya salida es M (C) . Aquí B es una constante absoluta. En palabras simples, no existe un algoritmo que calcule B bits de información de M (C) .$M(C) \bmod p$$p$$C$$N$$\log_2 N-B$$M(C)$$B$$B$$M(C)$

Pido disculpas si la pregunta tiene una respuesta bien conocida, porque no soy un teórico de la complejidad por cierto.

Aquí hay un argumento de que si pudieras resolver Max 3SAT en una instancia de la cláusula m dada una cantidad constante de consejos, la jerarquía polinómica colapsaría.

Solucione un problema NP-completo L. Del teorema de Cook, conocemos una transformación f () de entradas x para L en fórmulas 3SAT f (x), de modo que

1) si $x\in L$ entonces $M(f(x)) = m$

2) si $x\in L$ entonces $M(f(x)) = m-1$

donde $m$ es el número de cláusulas en $f(x)$ .

También tenemos un teorema de Kadin, que dice que, si se le dan $k$ entradas $x_1,\ldots,x_k$ de un problema NP-completo, tiene un algoritmo de tiempo polinomial que realiza consultas $\leq k-1$ a un oráculo NP y determina el respuesta correcta a los problemas $k$ NP $x_i \in ? L$ , entonces la jerarquía polinómica se colapsa.

Supongamos que tenemos un algoritmo que resuelve Max SAT en las entradas de la cláusula m con k consejos. Usaremos el resultado de Hastad para construir un algoritmo como en la premisa del teorema de Kadin.

Empezar desde el K = 2 k + 1 entradas x 1 , ... , x K a problema L . Aplica el teorema de Cook a cada uno de ellos. Después de cierta normalización (que se puede hacer asignando pesos a las cláusulas, o duplicándolas si no queremos usar pesos), construimos K fórmulas F 1 , ... , F K donde, para un cierto m :$K=2^k+1$$x_1,\ldots,x_K$$L$$K$$F_1,\ldots,F_K$$m$

1) M ( F 1 ) = m - 1 si x 1 ∈ L y M ( F 1 ) = m - 2 de lo contrario$M(F_1)= m-1$$x_1 \in L$$M(F_1) = m-2$

2) M ( F 2 ) = m ⋅ ( m - 1 ) si x 2 ∈ L y M ( F 2 ) = m ⋅ ( m - 2 ) de lo contrario$M(F_2) = m\cdot (m-1)$$x_2 \in L$$M(F_2) = m\cdot (m-2)$

...

k) M ( F K ) = m K - 1 ⋅ ( m - 1 ) si x K ∈ L y M ( F K ) = m K - 1 ⋅ ( m - 2 ) de lo contrario$M(F_K) = m^{K-1} \cdot (m-1)$$x_K\in L$$M(F_K) = m^{K-1} \cdot (m-2)$

Ahora toma la unión de las fórmulas, las cuales fueron construidas sobre conjuntos disjuntos de variables, y lo llaman F . Entonces tenemos M ( F ) = M ( F 1 ) + ⋯ + M ( F k ) , y podemos "leer" la respuesta a los problemas de K x i ∈ ? L observando la representación base m de M ( F ) . Si podemos calcular M ( F ) dado $F$$M(F) = M(F_1) + \cdots + M(F_k)$$K$$x_i \in? L$$m$$M(F)$$M(F)$$k$consejos, significa que podemos encontrar 2 k valores de manera que uno de ellos sea M ( F ) . Entonces podemos preguntarle de forma no adaptativa a un oráculo NP si M ( F ) ≥ n i para cada uno de los valores candidatos n 1 , ... , n 2 k generamos. Por lo tanto, hemos podido resolver 2 k + 1 instancias de problemas NP-completos haciendo 2 k consultas no adaptativas a un oráculo NP, lo que implica que la jerarquía polinómica se colapsa.$2^k$$M(F)$$M(F) \geq n_i$$n_1,\ldots,n_{2^k}$$2^k+1$$2^k$

Usando el teorema de Hastad en lugar del teorema de Cook, es posible empujar el tamaño de F a O ( 1 ) k ⋅ m en lugar de m k , por lo que es posible empujar k para registrar m , y la cantidad de bits de consejos para registrar log m . Comprender lo que sucede cuando se le da un bit de consejo log m - O ( 1 ) parece realmente difícil.$F$$O(1)^k \cdot m$$m^k$$k$$\log m$$\log\log m$$\log m - O(1)$

Editado para agregar: Krentel ( The Complexity of Optimization Problems . J. Comput. Syst. Sci. 36 (3): 490-509 (1988) ) demostró que calcular el valor del óptimo del problema de la camarilla máxima está completo para F P N P [ O ( l o g n ) ] , la clase de funciones computables en tiempo polinomial con consultas O ( l o g n ) a un oráculo NP. La integridad está bajo "reducciones de una consulta", en la cual la función f es reducible a la función g si se puede escribir f ( x ) = $FP^{NP[O(log n)]}$$O(log n)$1 ( g ( r 2 ( x ) ) para el tiempo polinomio computable r 1 y r 2 . Presumiblemente, el mismo es cierto para Max Clique. Ahora, si Max Clique tenía un algoritmo de tiempo polinómico que produce una lista de m o ( 1 ) posible valores, estaría en F P N P [ o ( l o g n ) ] , porque podría usar la búsqueda binaria para encontrar el óptimo con una cantidad de consultas que es el registro del tamaño de la lista.$f(x) = r_1(g(r_2(x))$$r_1$$r_2$$m^{o(1)}$$FP^{NP[o(logn)]}$

Ahora, si tenemos F P N P [ O ( l o g n ) ] = F P N P [ o ( l o g n ) ] definitivamente tendríamos P N P [ O ( l o g n ) ] = P N P [ o ( l o g n ) $FP^{NP[O(log n)]} = FP^{NP[o(log n)]}$$P^{NP[O(log n)]} = P^{NP[o(log n)]}$, que es el caso especial para problemas de decisión, y eso se conoce, por los resultados de Wagner (que mejora un resultado de Kadin que se aplica a un número constante de consultas), para colapsar la jerarquía polinómica. Pero creo que podría saberse que $FP^{NP[O(log n)]} = FP^{NP[o(log n)]}$ implicaría realmente P = NP. Pero, en cualquier caso, los resultados de Krentel y Kadin-Wagner deberían ser suficientes para dar otra prueba del resultado de Andy Drucker. Ahora me pregunto si es realmente la misma prueba, es decir, si el resultado Fortnow-Van Melkebeek funciona, explícita o implícitamente, a través de un argumento de "simulación de consultas NP con menos consultas NP".

Una buena encuesta que explica lo que está sucediendo con los problemas de optimización y las clases de consulta acotadas:

http://www.csee.umbc.edu/~chang/papers/bqabh/npfsat.pdf

Me gustaría indicar una razón por la cual es difícil demostrar la dureza NP de este problema.

En un comentario sobre la pregunta, Luca Trevisan dio una buena manera de reformular el problema: ¿Se puede resolver el siguiente problema en tiempo polinómico para cada k constante ? Dada una fórmula C de CNF con cláusulas m , genera como máximo m / k enteros para que uno de ellos sea igual a M ( C ). Aquí k está relacionado con B por k = 2 ^B .

Sin embargo, exijamos más. A saber, consideramos el siguiente problema: dada una fórmula C de CNF , genera dos enteros para que uno de ellos sea igual a M ( C ). Denotamos este problema por Π. El problema Π es al menos tan difícil como el problema original, por lo que si el problema original es NP-hard, Π también debe ser NP-hard.

Tenga en cuenta que Π es un problema de relación. Uno de los tipos más simples de reducciones que pueden usarse para reducir algún problema L a un problema de relación Π es una reducción de Levin en tiempo polinomial, que es un caso especial de una reducción de Turing en tiempo polinomial donde la reducción llama al oráculo para Π solo una vez.

Afirmamos que P ^{Π [1]} = P. Obviamente, esto implica que NP⊈P ^{Π [1] a} menos que P = NP, es decir, Π no es NP-duro bajo la reducibilidad de Levin en tiempo polinómico a menos que P = NP.

Prueba . Deje L ∈P ^{Π [1]} , o en otras palabras, existe una reducción de Levin de L a Π. Esto significa que existe un par ( f , g ) de una función computable de tiempo polinomial f : {0,1} ^* → {0,1} ^* que asigna cada instancia x del problema L a alguna fórmula CNF f ( x ) y un predicado computable de tiempo polinómico g : {0,1} ^* × ℕ × ℕ → {0,1} tal que g ( x , i , j ) = L( x ) si i o j es igual a M ( f ( x )). (Aquí L ( x ) = 1 si x es una instancia de sí de L y L ( x ) = 0 si x es una instancia de no).

Construimos un algoritmo de tiempo polinómico para L a partir de esto de la siguiente manera. Deje x ser una entrada.

1. Deje C = f ( x ), y dejar que m sea el número de cláusulas en C .
2. Encuentre uno i ∈ {0, ..., m } de modo que el valor g ( x , i , j ) sea constante independientemente de j ∈ {0, ..., m }.
3. Salida de esta constante g ( x , i , 0).

En el paso 2, tal i siempre existe porque i = M ( f ( x )) satisface la condición. Además, este algoritmo no puede generar una respuesta incorrecta porque g ( x , i , M ( f ( x ))) debe ser la respuesta correcta. Por lo tanto, este algoritmo resuelve L correctamente. QED .

Si no me equivoco, se puede usar la misma idea para demostrar que P ^{Π [ k ( n )]} ⊆DTIME [ n ^{O ( k ( n ))} ]. Esto implica que NP⊈P ^{Π [ k ]} para cualquier constante k a menos que P = NP y que NP⊈P ^{Π [polylog] a} menos que NP⊆DTIME [2 ^polylog ]. Sin embargo, esta idea por sí sola no parece descartar la posibilidad de que Π sea NP-duro bajo la reducibilidad de Turing en tiempo polinómico.

Creo que podemos mostrar:

Reclamación. Hay un valor 0 < c < 1 tal que lo siguiente es verdadero. Supongamos que hay un algoritmo de tiempo poli determinista que, dada una m -clause 3-SAT ejemplo φ , da salida a una lista de S de en la mayoría de m c valores, tal que M ( φ ) ∈ S ; entonces la jerarquía polinómica se colapsa.$0 < c < 1$$m$$\phi$$S$$m^c$$M(\phi) \in S$

La prueba utiliza los resultados de Fortnow y Santhanam sobre la inviabilidad de la compresión de instancias de su documento http://www.cs.uchicago.edu/~fortnow/papers/compress.pdf

Específicamente, al ver su prueba de Thm 3.1, creo que uno puede extraer lo siguiente (volveré a verificar esto pronto):

"Teorema" [FS]. Hay enteros 0 < d ′ < d, de modo que lo siguiente es verdadero. Supongamos que en el tiempo polivinílico determinista, uno puede transformar un OR de n d fórmulas booleanas (cada una de longitud ≤ n , y en conjuntos variables disjuntos) en un OR de n d ′ fórmulas (de nuevo variable-disjunta y de longitud ≤ n ) , preservando la satisfacción / insatisfacción de la OR. Entonces N P ⊆ c o N P / p o l y la jerarquía polinómica se colapsa.$0 < d' < d$$n^d$$\leq n$$n^{d'}$$\leq n$$\mathsf{NP} \subseteq \mathsf{coNP/poly}$

La prueba de nuestra afirmación será una reducción de la tarea de compresión OR mencionada en el teorema [FS] anterior, al problema de la computación en lista M ( ϕ ) . Suponga que ψ 1 , ... , ψ n d es una lista de fórmulas cuyo OR queremos comprimir.$M(\phi)$$\psi_1, \ldots, \psi_{n^d}$

Primer paso: definir un circuito de tamaño polinómico Γ en cadenas de entrada ( v , y 1 , ... , y n d ) . Aquí la cadena y i codifica una asignación a ψ i , y v ∈ { 0 , 1 } d log n + 1 codifica un número entre 0 y n d .$\Gamma$$(v, y_1, \ldots, y_{n^d})$$y_i$$\psi_i$$v \in \{0, 1\}^{d \log n + 1}$$0$$n^d$

Tenemos Γ aceptar iff v = 0 , o ψ v ( y v ) = 1 .$\Gamma$$v = 0$$\psi_v(y_v) = 1$

Ahora dejemos que M ∗ ( Γ ) denote el valor máximo v , de modo que el circuito restringido Γ ( v , ⋅ , ... , ⋅ ) sea ​​satisfactoria. (Esta cantidad es siempre al menos 0).$M^*(\Gamma)$$v$$\Gamma(v, \cdot, \ldots, \cdot)$

Supongamos que podemos producir eficientemente una lista S de posibles valores para M ∗ ( Γ ) . Entonces la afirmación es que en nuestra lista ψ 1 , ... , ψ n d , podemos tirar todo ψ i para el cual i ∉ S ; la lista resultante contiene una fórmula satisfactoria si la original lo hizo. Espero que esto quede claro por inspección.$S$$M^*(\Gamma)$$\psi_1, \ldots, \psi_{n^d}$$\psi_i$$i \notin S$

Conclusión: no podemos producir de manera confiable una lista S de ≤ n d ′ posibles valores para M ∗ ( Γ ) , a menos que la jerarquía poli se colapse.$S$$\leq n^{d'}$$M^*(\Gamma)$

Segundo paso: reducimos del problema de la computación en lista M ∗ ( Γ ) al problema de la computación en lista M ( ϕ ) para las instancias 3-SAT ϕ .$M^*(\Gamma)$$M(\phi)$$\phi$

Para hacer esto, primero ejecutamos la reducción de Cook en Γ para obtener una instancia de 3-SAT ϕ 1 de tamaño m = p o l y ( n d ) . ϕ 1 tiene el mismo conjunto de variables que Γ , junto con algunas variables auxiliares. Lo más importante para nuestros propósitos, ϕ 1 ( v , ⋅ ) es satisfactoria si f Γ ( v , ⋅ ) es satisfactoria.$\Gamma$$\phi_1$$m = poly(n^d)$$\phi_1$$\Gamma$$\phi_1(v, \cdot)$$\Gamma(v, \cdot)$

Llamamos a ϕ 1 las 'fuertes restricciones'. Le damos a cada una de estas restricciones un peso de 2 m (agregando restricciones duplicadas).$\phi_1$$2m$

Luego agregamos un conjunto de 'restricciones débiles' ϕ 2 que agregan una preferencia para que el índice v (definido en el paso 1) sea lo más alto posible. Hay una restricción para cada bit v t de v , a saber [ v t = 1 ] . Dejamos que el t -ésimo bit más significativo de v tenga una restricción de peso m / 2 t - 1 . Dado que v es de longitud d log n + 1 , estos pesos pueden hacerse integrales (solo necesitamos rellenar para dejar que $\phi_2$$v$$v_t$$v$$[v_t = 1]$$t$$v$$m/2^{t-1}$$v$$d \log n + 1$$m$ ser un poder de 2).

Finalmente, dejemos que ϕ = ϕ 1 ∧ ϕ 2 sea ​​el resultado de nuestra reducción.$\phi = \phi_1 \wedge \phi_2$

Para analizar ϕ , deje que ( v , z ) sea ​​el conjunto variable de ϕ , con v como antes. Primero tenga en cuenta que dada cualquier asignación a ( v , z ) , se puede inferir el valor de v de la cantidad N ( v , z ) = (peso total de las restricciones ϕ satisfechas por v , z ). Esto se desprende del diseño jerárquico de los pesos de restricción (de manera similar a una técnica de la respuesta de Luca). Del mismo modo, el valor máximo alcanzable $\phi$$(v,z)$$\phi$$v$$(v, z)$$v$$N(v, z) =$$\phi$$v, z$
( ϕ ) se logra mediante un ajuste ( v , z ) que satisface todas las restricciones fuertes, y donde (sujeto a esto) v es lo más grande posible. Esta v es el índice más grande para el cual Γ ( v , ⋅ ) es satisfactoria, es decir, M ∗ ( Γ ) . (Tenga en cuenta que siempre es posible, estableciendo v = all-0, para satisfacer todas las restricciones fuertes, ya que en ese caso Γ ( v , ⋅ ) es satisfactoria).$M(\phi)$$(v, z)$$v$$v$$\Gamma(v, \cdot)$$M^*(\Gamma)$$v =$$\Gamma(v, \cdot)$

Se deduce que, si se nos da una lista S de posibles valores de M ( ϕ ) , podemos derivar una lista de | S | posibles valores de M ∗ ( Γ ) . Por lo tanto no podemos tener | S | ≤ n d 'a menos que la poli jerarquía se colapse. Esto da la Reclamación, ya que n d ' = m Ω ( 1 ) .$S$$M(\phi)$$|S|$$M^*(\Gamma)$$|S| \leq n^{d'}$$n^{d'} = m^{\Omega(1)}$