P vs EXPTIME

• P = ⋃ _c ≥ 1 TIME(n^c)
• EXPTIME = ⋃ _c ≥ 1TIME(2^nc).
• time hierarchy theorem → P  ⊂  EXPTIME

• PATH = {⌊(G, s, t)⌋ ∣  G un grafo dirigido con camino s → t}
  • algoritmo brute-force (m^m caminos posibles) → PATH  ∈  2EXPTIME
  • algoritmo goal-oriented → PATH  ∈  P (Sipser, thm. 7.14)

• RELPRIME = {⌊(x, y)⌋ ∣  x, y ∈ ℕ  relativamente primos }
  • enumerar todos los dividores de x y y, si otro que 1 aparece en ambas listas, output 0, sino 1
    → RELPRIME  ∈  EXPTIME si ⌊(x, y)⌋ en binario!
  • algoritmo de Euclides:  ∈  P (Sipser, thm. 7.15)

Algoritmo de Euclides:

E: input: x,y
   hasta que y == 0:
       a) x ← x mod y
       b) intercambiar x y
   output x

R: input: x,y
   si E(x,y) == 1 output accept
   si no, output reject       

• 2COLOR = {⌊G⌋ ∣  G es coloreable por 2 colores }
  •  ∈  P
• 3COLOR = {⌊G⌋ ∣  G es coloreable por 3 colores }
  •  ∈  P? no se sabe
  •  ∈  EXPTIME por cierto
  •  ∈  TIME(O(1. 3289ⁿ)) (Beigel y Eppstein, 2000)

• VERTEXCOVER =
  {⌊(G, k)⌋ ∣  se puede "cubrir" el grafo G con k nodos }
•  ∈  EXPTIME
•  ∈  P? no se sabe

LIN(0,1) = sistemas de inecuaciónes lineales con solución booleanas

(0-1 integer programming)

• sea E = :
  • x₁ + 2x₂ + x₃ + x₄ ≥ 3
    x₁ + x₄ ≥ 0
    2x₁ + x₂ − x₃ ≤ 1
  • solución: (1, 1, 0, 0)
  • E  ∈  LIN(0,1)

LIN(0,1)  ∈  EXPTIME (enumerar soluciones y verificar).

no se sabe si  ∈  P

• formulas de lógica proposicional:
  φ : : x_i ∣ ¬ φ ∣ φ₁ ∧ φ₂ ∣ φ₁ ∨ φ₂
• sea x₁, …, x_n la variables que aparecen en φ,
  escribimos φ(z) el valor de φ cuando sus variables son asignadas a z ∈ {0, 1}ⁿ
• si existe tal z, φ es satisfacible
• SAT = {⌊φ⌋ ∣  φ satisfacible }
•  ∈  EXPTIME, no se sabe si  ∈  P > si ⌊x⌋ ∈  SAT, 3COLOR, ..., x es un problema que tiene una solución, > que es pequeña y verificable rapidamente

No es el caso de todos los lenguajes en EXPTIME.

NP

• M se llama la verificadora de L, y u un certificado de x (con respeto a L y M).
• La definición de NP es asimétrica!

Lenguajes en NP

existencia de certificados cortos = pertenencia a NP:

• SAT, LIN(0,1), 3COLOR
• traveling salesman
• subset sum
• graph isomorphism
• numeros compositos
• ...

P  ⊆  NP  ⊆  EXPTIME

• No se sabe si P ≠ NP, ni si NP ≠ EXPTIME.

P y NP

• en P están los problemas fáciles
• en NP están los problemas que tienen soluciones facilmente chequeables
• NP representa los problemas de búsqueda con soluciones cortas

MMTT nondeterminísticas

• Una MTND tiene δ₀ and δ₁ y un estado especial q_accept.
• En cada paso, una MTND hace una elección arbitraria entre las dos funciones de transición.
• Para un input x, si existe una secuencia de esos pasos (elecciones nondeterminísticas) que hace que M alcanza q_accept, decimos que M(x) = 1.
• Si toda secuencia de elecciones hace que M se detiene sin alcanzar q_accept, decimos que M(x) = 0.
• M corre en tiempo T(n) si para todo input x ∈ {0, 1}^* y toda secuencia de elecciones nondeterminísticas, M alcanza q_halt o q_accept dentro de T(∣x∣) pasos.

Observación

Una MTND no representa cálculos fisicamente realisables.

Definición tradicional de NP

Equivalencia

1. L ∈ NP_old → L ∈ NP
   • si existe una MTND M que decide L, se puede construir una MTD Mʹ que, con input (x, u) y u de longitud adecuada, simula una computación de M con input x eligiendo δ_u[n] en cada paso n.
2. L ∈ NP → L ∈ NP_old
   • se puede construir una MTND que, con input x, genera un certificado en p(∣x∣) pasos de manera nondeterministica, y luego lo averigua con la verificadora de L.

Filología computacional

Travelling Salesman está en NP porque una gira satisfaciendo l ≤ k puede ser eligida nondeterministicalmente en n pasos y luego la condicion l ≤ k verificada en un número polinomial de pasos [...].

(John E. Savage, Models of Computation: Exploring the Power of Computing, 1997)

Reducciones

Ejercicio

• Mostrar que 3COLOR  ≤ _p SAT:
• Proveer una traducción G → φ_G
• Demostrar que: G tiene un coloreo → φ_G tiene una asignación
• Demostrar que: φ_G tiene una asignación → G tiene un coloreo

NP hardness, completeness

Un lenguaje NP completo

TMSAT = {⌊M, x, 1ⁿ, 1^t⌋ ∣ ∃ u ∈ {0, 1}ⁿ. M(x, u) = 1 en t pasos}

• TMSAT  ∈  NP: la verificadora de N es una máquina universal de Turing que simula M con input (x,u) y verifica que su output es 1 despues de t pasos. Su corrida es polinomial en función de su input porque se puede simular máquinas con una desaceleración polinomial.
• Sea L  ∈  NP. Existe verificadora M corriendo en tiempo polinomial q(n), y existe un polinomio p(n) que determine el tamaño de los cartificados. Entonces a toda $x\inL$ le asociamos la string ⌊M, x, 1^p(n), 1^{q(n + p(n))}⌋.

CNF-SAT

• un literal es una variable o una variable negada (x_i, ¬ x_i)
• una cláusula es una disyuncción de literales tal que no aparece un literal y su contrario
• ej: x₁ ∨ ¬ x₂ ∨ ¬ x₃
• una formula proposicional es en Forma Normal Conjunctiva si es una conjuncción de cláusulas
• ej: (x₁ ∨ x₃) ∧ (x₁ ∨ ¬ x₂ ∨ ¬ x₃ ∨ x₄) ∧ (¬ x₁ ∨ ¬ x₄)
• definimos CNF-SAT = {⌊φ⌋ ∣ φ es en FNC y es satisfacible }

• Idea: introducir variables nuevas para evitar explosión exponencial

3SAT

• una formula es en 3FNC si es en FNC y cada cláusula tiene como máximo 3 literales
• ej: (x₁ ∨ x₃) ∧ (¬ x₂ ∨ ¬ x₃ ∨ x₄) ∧ (¬ x₁ ∨ ¬ x₄)
• 3SAT = {⌊φ⌋ ∣ φ es en 3FNC y es satisfacible }

• Idea: introducir variables nuevas para evitar explosión exponencial

Teorema de Cook-Levin

• Cook "The Complexity of Theorem Proving Procedures", 1971
• Levin "Универсальные задачи перебора", 1973

Poder expresivo booleano

• Igualdad: la formula
  (x₁ ∨ ¬ y₁) ∧ (¬ x₁ ∨ y₁) ∧ … ∧ (x_n ∨ ¬ y_n) ∧ (¬ x_n ∨ y_n)
  es satisfacible por una asignación z ssi x_i(z) = y_i(z) para todo i.
• Funciónes booleanas: dada f: {0, 1}^k ↦ {0, 1}:
  • para v ∈ {0, 1}^k, definimos C_v(x_i, . . , x_k) una cláusula tal que C_v(v) = 0 y C_v(u) = 1 para u ≠ v
  • definimos φ = ⋀ _{{v ∣ f(v) = 0}}C_v(x₁, x₂, …, x_k)
  • entonces:
    • ∀ z ∈ {0, 1}^k, φ(z) = f(z)
    • ∣φ∣ ≤ k2^k

Sea L ∈  NP, queremos mostrar que L ≤ _pSAT.

Por definición, ∃  M corriendo en tiempo polinomial y p polinomio tal que para todo x ∈ {0, 1}^*:
x ∈ L ↔ ∃ u ∈ {0, 1}^p(∣x∣). M(x, u) = 1

Queremos una transformación en tiempo polinomial x ↦ φ_x tq:
∃ u ∈ {0, 1}^p(∣x∣). M(x, u) = 1 ↔ φ_x ∈ SAT

Reemplazamos la verificadora M por una version que:

1. tiene 2 cintas (con input en lectura sola)
2. es indiferente:
   • las corridas de M toman el mismo tiempo para todo input de tamaño n
   • la ubicación de los cabezales de M en un paso i sólo dependen del tamaño del input y de i

Un instantáneo de M es un tuple (a, b, q) ∈ Γ ² × Q.

Un instantáneo puede ser representado con c bits, c dependiendo de Γ  y Q (y independiente del input).

Una traza es una succesión de instantáneos.

• ¿Cuales son las condiciones que debe cumplir una traza para representar una corrida exitosa de M con input (x, u)?
• Vamos a construir φ_x como un patrón de traza que es satisfacible si y sólo si existe un u tal que M(x, u) = 1

A partir de la función de transición de M definimos:

• δ_write: Γ ² × Q ↦ Γ 
• δ_state: Γ ² × Q ↦ Q

Como M es indiferente, se pueden definir las funciones ℕ  ↦ ℕ :

• inpos(i) la posición del cabezal de input en el paso i.
• prev(i) el último paso antes de i tal que el cabezal de escritura está en el mismo lugar que en el paso i. Definimos prev(i) = 1 por defecto.

Los valores de inpos(i) and prev(i) no dependen del input y = (x, u). Además esos valores pueden ser calculados en tiempo polinomial, corriendo M con un input trivial.

Restricciones que debe cumplir una traza [z₁, z₂, . . . , z_T(n)] para representar una corrida exitosa de M con input y:

• z₁ = ( ⊳ ,  ⊳ , q_start)
• z_T(n) = (a, 1, q_halt), a ∈ Γ 
• para todo z_i = (a_i, b_i, q_i) con i ∈ {2, …, T(n)}:
  • a_i = y_inpos(i)
  • b_i = δ_write(z_prev(i))
  • q_i = δ_state(z_i − 1)
• para cada i ∈ {2, …, T(n)}, existe une función f tal que esas restricciones son cumplidas ssi f(y_inpos(i), z_prev(i), z_i − 1, z_i) = 1

Queremos: φ_x ∈ SAT ↔ ∃ u ∈ {0, 1}^p(∣x∣). y = (x, u). M(y) = 1

Variables de φ_x:

• Y_i con i ∈ [1. . n + p(n)]
• Z_i con i ∈ [1. . cT(n)]

Codificación de las restricciónes:

• y[1. . n] = x → formula de tamaño 2n
• z₁ → formula de tamaño 2c
• z_T(n) → formula de tamaño  ≤ 2c

• para cada i ∈ [2. . T(n)],
  f(y_inpos(i), z_prev(i), z_i − 1, z_i) = 1
  → formula φ_i de tamaño (3c + 1)2^3c + 1 tal que
  φ_i(Yʹ, Zʹ₁, Zʹ₂, Zʹ₃) = 1 ↔ f(. . . ) = 1
  , con:
  • Yʹ son las variables que codifican y_inpos(i)
  • Zʹ₁ son las variables que codifican z_prev(i)
  • Zʹ₂ → z_i − 1
  • Zʹ₃ → z_i
  • para cada i, para conocer Yʹ, Zʹ₁, Zʹ₂, Zʹ₃, hay que conocer inpos(i) y prev(i), y para eso hay que correr y observar M(0^n + p(n))

Tamaño de φ_x:

2n + 2c + 2c + (T(n) − 1)(3c + 1)2^3c + 1  ≤  d(n + T(n)), d ∈ ℕ 

• se puede construir x ↦ φ_x en tiempo polinomial:
  1. correr M(0^n + p(n))
  2. generar φ_x
• φ_x es en FNC

• supongamos x ∈ L
  → ∃ u ∈ {0, 1}ⁿ. M(x, u) = 1
   → existe una traza que reprensenta la corrida exitosa de M(x, u)
  → usando u y la traza, se puede construir una asignacion z tal que φ_x(z) = 1
  → φ_x ∈  CNF-SAT
• supongamos φ_x ∈  CNF-SAT
  → existe z, φ_x(z) = 1
  → constuir u a partir de z
  → x ∈ L

• L  ≤ _p CNF-SAT
• Entonces CNF-SAT es NP-difícil
• Entonces es NP-completo

Conclusiones

No tenemos ninguna demostración que P ≠ NP (≠ EXPTIME) pero hoy en día se supone que NP es más dificil que P (y más fácil que EXPTIME).