¿Por qué las igualdades entre clases de complejidad se traducen hacia arriba y no hacia abajo?

Hola chicos, entiendo que el truco de relleno nos permite traducir clases de complejidad hacia arriba - por ejemplo, . El relleno funciona "inflando" la entrada, ejecutando la conversión (digamos de N P a P ), lo que produce un algoritmo "mágico" que puede ejecutar en la entrada rellenada. Si bien esto tiene sentido técnico, no puedo tener una buena intuición de cómo funciona. Qué está pasando aquí? ¿Existe una analogía simple de lo que es el relleno?$P=NP \rightarrow EXP=NEXP$$NP$$P$

¿Puede proporcionar un sentido común por qué este es el caso?

Creo que la mejor manera de obtener intuición para este tema es pensar cuáles son los problemas completos para las clases de tiempo exponencial. Por ejemplo, los problemas completos para NE son los problemas NP completos completos en entradas que se pueden describir de manera sucinta, por ejemplo, dado un circuito que describe la matriz de adyacencia de un gráfico, ¿es el gráfico de 3 colores? Entonces, el problema de si E = NE se convierte en equivalente a si los problemas de NP pueden resolverse en tiempo polinómico en las entradas que se pueden describir de manera sucinta, por ejemplo, aquellos con una pequeña complejidad efectiva de Kolmogorov. Obviamente, esto no es más fuerte que si se pueden resolver en todas las entradas. Cuanto mayor es el límite de tiempo, menor es la complejidad de Kolmogorov de las entradas relevantes, por lo que los colapsos para límites de tiempo más grandes son algoritmos en efecto que funcionan en subconjuntos más pequeños de entradas.

Russell Impagliazzo

OK, entonces su objetivo es mostrar que basándose en C L A S S 1 [ g ( n ) ] = C L A S S 2 [ h ( n ) $CLASS_1[g(f(n))] = CLASS_2[h(f(n))]$$CLASS_1[g(n)] = CLASS_2[h(n)]$(no especificamos qué son exactamente estas clases, solo sabemos que de alguna manera están parametrizadas con el tamaño de entrada). Tenemos un lenguaje , decidido por algún algoritmo A . Ahora hacemos un lenguaje L ′ rellenando cada palabra en x ∈ L , de modo que su longitud ahora sea f ( n ) , y vemos que está contenida en C L A S S 1 [ $L \in CLASS_1[g(f(n))]$$A$$L'$$x \in L$$f(n)$ (nuestro nuevo algoritmo A ' básicamente ignora los ceros agregados y ejecuta A en la entrada corta real).$CLASS_1[g(n)]$$A'$$A$

Lo que hacemos es: tomamos un lenguaje de la clase más grande y lo rellenamos, para que pueda resolverse mediante un algoritmo más débil que nos da contención en la clase más pequeña; el algoritmo más débil puede hacerlo, porque tiene la misma cantidad de 'trabajo real' para hacer como antes, pero tiene sus restricciones (que son una función de la longitud de entrada) levantadas al extender la entrada.

Ahora sabemos que y, por lo tanto, L ′ ∈ C L A S S 2 [ h ( n ) ] (decidido por algún algoritmo B ′ ). Nos gustaría llegar de aquí a L ∈ C L A S S 2 [ h ( f ( n ) ) $L' \in CLASS_1[g(n)]$$L' \in CLASS_2[h(n)]$$B'$$L \in CLASS_2[h(f(n))]$. Pero eso es sencillo: el algoritmo decide que L simplemente rellena la entrada en consecuencia y ejecuta B ' en la entrada acolchada.$B$$L$$B'$

Este paso puede resumirse de la siguiente manera: queremos decidir en la clase más grande y con más recursos. Usando nuestros recursos adicionales, rellenamos la entrada y ejecutamos el algoritmo para decidir el idioma rellenado$L$ .

Por supuesto, hay algunos detalles técnicos involucrados aquí (por ejemplo, debemos asegurarnos de que el relleno se pueda implementar en las clases que consideramos), pero simplemente los ignoro para dar una intuición general.

Veo los argumentos de relleno en términos de compacidad de representación. Piense en dos máquinas de traducción de Turing: explota las instancias y C las comprime nuevamente.$B$$C$

El argumento de relleno funciona con , al componer B con la versión determinista de la TM para el lenguaje en la clase no determinista inferior. Las salidas de B forman colectivamente un lenguaje que no está representado de manera compacta, por lo que esto se vuelve "más fácil".$B$$B$$B$

No es posible aplicar la idea de otra manera, usando , porque solo algunos de los lenguajes en la clase fácil se generan al hacer volar los lenguajes en la clase difícil.$C$

Para hacerlo más intuitivo, veamos lo que está sucediendo de manera más abstracta.

Tenemos dos transformaciones, una para las entradas y otra para los problemas. Denotaré ambas por , será claro por el contexto cuándo es la primera y cuándo es la segunda.$pad$

Estas dos transformaciones tienen la siguiente propiedad:

I. para todos los problemas , para todas las entradas x ∈ Σ ∗ :$A\subseteq \Sigma^{ * }$$x\in\Sigma^{ * }$

iff x ∈ A ,$pad(x) \in pad(A)$$x \in A$

II si está en E X P ( N E X P ), entonces p a d ( A ) está en P ( N P ).$A$$EXP$$NEXP$$pad(A)$$P$$NP$

III. la transformación para entradas está en la clase de complejidad ,$EXP$

Está claro que las transformaciones para el relleno tienen estas propiedades.

$EXP$$P$$NEXP$$NP$

No tengo un argumento formal de por qué no hay tales transformaciones en este momento, pero intuitivamente lo que dijo András Salamon es correcto. Es fácil aumentar el tamaño de las entradas, pero no está claro cómo se pueden comprimir.

$P=NP$$NEXP=NTime(2^{n^{O(1)}})$$x$$n$$N=2^{n^{O(1)}}$

$NEXP(n) = NTime(2^{n^{O(1)}}) = NTime(N) \subseteq NP(N) \subseteq P(N) = Time(N^{O(1)}) = Time(2^{n^{O(1)}}) = EXP(n)$