¿Las pruebas pueden mostrar la ausencia de errores?

18

$(n + 1)$ se requieren puntos para determinar unívocamente un polinomio de grado $n$ ; Por ejemplo, dos puntos en un plano determinan exactamente una línea.

¿Cuántos puntos se requieren para determinar de manera única una función computable $f : N \rightarrow N$ , dada la longitud de un programa que computa $f$ en un lenguaje fijo? (es decir, un límite en la complejidad de Kolmogorov de $f$ ).

La idea es que, al menos teóricamente, uno podría probar la corrección de un programa haciendo suficientes pruebas.

Si uno tiene un programa $P$ de longitud $L$ que calcula $f$ , hay un límite en el número de funciones que pueden calcularse con una longitud de fuente de máximo $L$ .

Por lo tanto, "solo" sería necesario demostrar que:

$f$ sepuede calcular con una longitud de fuente $\leq L$
$P$ no calcula ninguna otra función computable en $L$ bytes o menos (mediante prueba)

Esta idea probablemente no tiene consecuencias prácticas (los límites seguramente serán exponenciales).

cc.complexity-theory computability

— pbaren
fuente

44

Supongamos que su descripciones de funciones se dan en binario, entonces hay a lo sumo

de la descripción longitud como máximo

. Pero ahora el problema es que, a diferencia de los polinomios, dos funciones computables distintas pueden tomar fácilmente los mismos valores en un número infinito de entradas. Por lo tanto, tu problema me parece imposible.

2^{L + 1} - 1

$2^{L+1}-1$

L

$L$

— Bruno

Entiendo tu idea. Pero dos funciones computables distintas de longitud de descripción <= L deberían diferir en algún punto (para algunos n0). ¿Se podría encontrar el valor de n0 dado L?

— pbaren

44

puede encontrar ese punto si existe uno, solo calcule las funciones en todos los valores utilizando la combinación, pero si no existe, nunca lo sabrá, es indecidible, tener una longitud superior en el tamaño del programa no cambia nada.

— Kaveh

77

En realidad, @Kaveh, según su propio argumento, un límite superior en

le dice algo sobre dónde difieren, pero no algo computable. Si

y

, entonces

donde

es la longitud del algoritmo que usted (@Kaveh) describió

es la primera cadena en la que

y

difieren. En particular,

K (f)

$K(f)$

K (f) \leq L

$K(f) \leq L$

f \neq g

$f \neq g$

K (x) \leq 2 L + c

$K(x) \leq 2L + c$

c

$c$

x

$x$

f

$f$

g

$g$

x

$x$ está delimitado por alguna función tipo Busy-beaver de

. Sin embargo, encontrar todo

tal que

o calcular BB sea aún incuestionable. Entonces @pbaren: hay un límite, pero es mucho más que exponencial, es indiscutible.

2 L + c

$2L+c$

x

$x$

K (x) \leq 2 L + c

$K(x) \leq 2L + c$

— Joshua Grochow

66

@Kaveh: Eso es lo que quise decir con una función "Busy-beaver-like": que

sea la longitud de la cadena más larga cuya complejidad de Kolmogorov (arreglar una máquina universal) es como máximo

. Solo hay muchas cadenas de este tipo, por lo que está bien definido hasta la elección de la máquina universal. Entonces

es un límite superior: si dos funciones (computables totales) de complejidad de Kolmogorov como máximo

coinciden en todos los puntos hasta la longitud

B B^{'} (n)

$BB'(n)$

n

$n$

B B^{'} (2 L + c)

$BB'(2L+c)$

L

$L$

B B^{'} (2 L + c)

$BB'(2L+c)$ , entonces son iguales.

— Joshua Grochow

9

(Esto fue un comentario, pero fue largo). Pregunta muy interesante Si está dispuesto a pensar en otras medidas de complejidad además de las de Kolmogorov, entonces hay algunas respuestas en la teoría del aprendizaje que podrían satisfacerlo. Lo dejo para los expertos en el área.

Por ejemplo, si no me equivoco, en "Una teoría de lo que se puede aprender", Valiant demostró que una función booleana se puede reconstruir dado un número polinómico de "puntos positivos" en el tamaño de su fórmula k-CNF (para cualquier k fijo , y quiero decir con "puntos positivos" los de la forma ). $(x_1,\ldots,x_n,1)$

En el TAOCP 7.2.1.6 de Knuth se muestra de una manera sorprendente (usando el patrón del árbol de Navidad) que para reconstruir una función booleana monote (es decir, no decreciente en cada variable) necesita exactamente puntos. ${n+1 \choose \lfloor n/2\rfloor+1}$

— Diego de Estrada
fuente

7

Para continuar en la línea de la respuesta de Deigo, los límites de complejidad de la muestra estándar de la teoría del aprendizaje le dicen que si está satisfecho con encontrar un programa que sea "aproximadamente correcto", no necesita probar muchos puntos. Digamos que estamos codificando programas en binario, por lo que solo hay programas de longitud d. Lets Supongamos también que hay una cierta distribución sobre ejemplos de entrada . Quizás su objetivo es encontrar un programa que esté bastante seguro de que es casi correcto ("Probablemente aproximadamente correcto", es decir, como en el modelo de aprendizaje Valiants PAC). Es decir, desea ejecutar un algoritmo que tomará una pequeña cantidad de muestras junto con $2^d$ $D$ $x \sim D$ $f(x)$ , Y la voluntad con una probabilidad de al menos de salida de un programa que está de acuerdo con sobre al menos una fracción de entradas procedentes de . $(1-\delta)$ $P$ $f$ $(1-\epsilon)$ $D$

Simplemente dibujaremos ejemplos , y sacaremos cualquier programa de longitud que coincida con en todos los ejemplos. (Se garantiza que existe uno dado que suponemos que tiene complejidad de Kolmogorov como máximo ) ... $m$ $x \sim D$ $P$ $\leq d$ $f$ $f$ $d$

¿Cuál es la probabilidad de que un programa particular que no está de acuerdo con en más de una fracción de ejemplos sea consistente con los ejemplos que seleccionamos? Es como máximo . Nos gustaría considerar que esta probabilidad es como máximo para que podamos tomar una unión unida a todos los programas y decir que con una probabilidad de al menos , ningún programa "malo" es consistente con nuestros ejemplos dibujados . Resolviendo, vemos que es suficiente tomar solo $P$ $f$ $\epsilon$ $m$ $(1-\epsilon)^m$ $\delta/2^d$ $2^d$ $1-\delta$ ejemplos. (es decir, solo linealmente muchos en la complejidad de Kolmogorov de...)

m \geq \frac{1}{ϵ} (re + Iniciar sesión 1 / / δ)

$m \geq \frac{1}{\epsilon}\left(d+\log 1/\delta\right)$

f

$f$

Por cierto, argumentos como este se pueden usar para justificar "Navaja de Occam": dado un número fijo de observaciones, entre todas las teorías que las explican, debe elegir la que tenga la menor complejidad de Kolmogorov, porque hay menos posibilidades de sobreajuste.

Por supuesto, si solo desea verificar un solo programa fijo de esta manera, solo necesita ejemplos ... $O(\log(1/\delta)/\epsilon)$

— Aaron Roth
fuente

3

Aquí hay una respuesta trivial: suponiendo que , entonces necesita saber el valor de en absoluto puntos para determinar de manera única . Por lo tanto, el enfoque que bosqueje no le ayuda en absoluto, a menos que sepa de alguna manera que la longitud del programa es extremadamente corta: mucho más corta que bits $L \ge \lg |N|$ $f$ $|N|$ $f$ $L$ $\lg |N|$

Considere la familia de funciones , donde se define como la función si y si . Observe que la complejidad de Kolmogorov de la computación se trata de bits, ya que puede codificar el valor de $F=\{f_i:i\in N\}$ $f_i$ $f_i(x) = 1$ $i=x$ $f_i(x)=0$ $i\ne x$ $f_i$ $\lg |N|$ $i$ en el código fuente y luego todo lo que necesita es una simple declaración condicional ( extra). $O(1)$

Sin embargo, no puede distinguir de la función todos ceros a menos que lo pruebe en la entrada . No puede distinguir de menos que pruebe en la entrada o . Por lo tanto, deberá evaluar en absoluto entradas, para determinar de forma única con qué estamos tratando. (OK, técnicamente, debe evaluarlo en las entradas , pero lo que sea). $f_i$ $i$ $f_i$ $f_j$ $i$ $j$ $f$ $|N|$ $f_i$ $|N|-1$

— DW
fuente

0

Puede hacer que el programa sea arbitrariamente largo. Entonces, dado cualquier programa, puede decidir si su idioma es equivalente al de este programa. No se puede hacer eso por el teorema de Rice.

— Zirui Wang
fuente

1

Tiene un punto válido de que la idea de verificar el programa ejecutándolo en varias instancias no funcionará en general.

— Tsuyoshi Ito