Os testes podem mostrar a ausência de bugs?

18

$(n + 1)$ pontos são necessários para determinar exclusivamente um polinômio de grau $n$ ; por exemplo, dois pontos em um plano determinam exatamente uma linha.

Quantos pontos são necessários para determinar exclusivamente uma função computável $f : N \rightarrow N$ , dada a duração de um programa que calcula $f$ em um idioma fixo? (isto é, um limite à complexidade Kolmogorov de $f$ ).

A idéia é que, pelo menos teoricamente, alguém possa provar a correção de um programa fazendo testes suficientes.

Se uma tem um programa $P$ de comprimento $L$ que calcula $f$ , há um limite no número de funções que podem ser calculados com um comprimento fonte de, no máximo, $L$ .

Portanto, seria "apenas" necessário provar que:

$f$ podeser calculado com um comprimento de fonte $\leq L$
$P$ não calcula nenhuma outra função computável embytes $L$ ou menos (por teste)

Essa ideia provavelmente não tem conseqüências práticas (os limites certamente serão exponenciais).

cc.complexity-theory computability pbaren
fonte

4

Suponha que suas descrições de funções são dadas em binário, em seguida, há, no máximo,

2^{L + 1} - 1

$2^{L+1}-1$ de descrição comprimento, no máximo

L

$L$ . Mas agora o problema é que, diferentemente dos polinômios, duas funções computáveis distintas podem facilmente aceitar os mesmos valores em um número infinito de entradas. Assim, seu problema parece impossível para mim.

Bruno

Eu entendo sua ideia. Mas duas funções computáveis distintas de comprimento de descrição <= L devem diferir em algum momento (para alguns n0). Alguém poderia encontrar o valor de n0 dado L?

pbaren

4

você pode encontrar esse ponto, se houver, basta computar as funções em todos os valores usando o encaixe, mas se não houver, você nunca saberá, é indecidível, ter um comprimento superior ao tamanho do programa não muda nada.

Kaveh

7

Na verdade, @Kaveh, por seu próprio argumento, um limite superior em

diz algo sobre onde eles diferem, mas não algo computável. Se

, e

, então

onde

é o comprimento do algoritmo você (@Kaveh) descrito e

é a primeira cadeia em que

e

são diferentes. Em 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$ é limitado por alguma função do tipo Busy-castor de

. No entanto, encontrar todos os

tais que

ou computar BB ainda é incontestável. Então, @pbaren: existe um limite, mas é muito mais do que exponencial, é incontestável.

2 L + c

$2L+c$

x

$x$

K (x) \leq 2 L + c

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

21411 Joshua Grochow

6

@Kaveh: Isso é o que eu quis dizer com uma função "Busy-castor-like": seja

o comprimento da corda mais longa cuja complexidade Kolmogorov (conserte uma máquina universal) seja no máximo

. Existem muitas dessas seqüências finitas, portanto isso está bem definido até a escolha da máquina universal. Então

é um limite superior: se duas funções (computáveis totais) da complexidade de Kolmogorov, no máximo

concordam com todos os pontos até o comprimento

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)$ , então eles são iguais.

Joshua Grochow 07/07

9

(Isso foi feito como um comentário, mas demorou muito). Pergunta muito interessante. Se você estiver disposto a pensar em outras medidas de complexidade além das de Kolmogorov, existem algumas respostas na teoria da aprendizagem que podem satisfazê-lo. Deixo para os especialistas da área.

Por exemplo, se não me engano, em "Uma teoria do aprendível", Valiant provou que uma função booleana pode ser reconstruída, dado um número polinomial de "pontos positivos" no tamanho de sua fórmula k-CNF (para qualquer k fixo , e quero dizer com "pontos positivos" os da forma ). $(x_1,\ldots,x_n,1)$

No TAOCP 7.2.1.6 de Knuth, é mostrado de uma maneira surpreendente (usando o padrão de árvore de Natal) que, para reconstruir uma função booleana monote (ou seja, não decrescente em cada variável), você precisa exatamente pontos. ${n+1 \choose \lfloor n/2\rfloor+1}$

Diego de Estrada
fonte

7

Para continuar na linha da resposta de Deigo, a complexidade da amostra padrão limitada pela teoria da aprendizagem diz que, se você estiver satisfeito em encontrar um programa "aproximadamente correto", não precisará tentar muitos pontos. Digamos que estamos codificando programas em binário, de modo que existem apenas programas de comprimento d. Suponhamos também que existe uma certa distribuição ao longo exemplos de entrada . Talvez seu objetivo seja encontrar um programa que você esteja quase certo ("Provavelmente aproximadamente correto", como no modelo de aprendizado do Valiants PAC). Ou seja, você deseja executar um algoritmo que recolherá um pequeno número de amostras junto com e, com probabilidade pelo menos $2^d$ $D$ $x \sim D$ $f(x)$ $(1-\delta)$ saída de algum programa que concorda com em, pelo menos, um fracção de entradas extraídas . $P$ $f$ $(1-\epsilon)$ $D$

Simplesmente desenharemos exemplos e produziremos qualquer programa de comprimento que concorde com em todos os exemplos. (É garantido que existe uma vez que assumimos que tem complexidade Kolmogorov no máximo ) ... $m$ $x \sim D$ $P$ $\leq d$ $f$ $f$ $d$

Qual é a probabilidade de um programa que discordar de em mais de uma fração de exemplos ser consistente com os exemplos que selecionamos? É no máximo . Gostaríamos de considerar essa probabilidade no máximo para que possamos estabelecer uma união entre todos os programas e dizer que, com probabilidade pelo menos , nenhum programa "ruim" é consistente com nossos exemplos desenhados. Resolvendo, vemos que é suficiente pegar apenas exemplos. (isto é, apenas linearmente muitos na complexidade de Kolmogorov de $P$ $f$ $\epsilon$ $m$ $(1-\epsilon)^m$ $\delta/2^d$ $2^d$ $1-\delta$

m \geq \frac{1}{ϵ} (d + \log 1 / δ)

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

f

$f$ ...)

BTW, argumentos como este podem ser usados para justificar "Navalha de Occam": dado um número fixo de observações, dentre todas as teorias que as explicam, você deve escolher aquela com menor complexidade de Kolmogorov, porque há a menor chance de sobreajuste.

Obviamente, se você quiser apenas verificar um único programa fixo dessa maneira, precisará apenas de exemplos de ... $O(\log(1/\delta)/\epsilon)$

Aaron Roth
fonte

3

Aqui está uma resposta trivial: supondo que, Então você precisa saber o valor de em tudopontos para determinar exclusivamente . Portanto, a abordagem que você esboça não ajuda em nada, a menos que você saiba que a duração do programa é extremamente curta: muito menor quebits. $L \ge \lg |N|$ $f$ $|N|$ $f$ $L$ $\lg |N|$

$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$ $O(1)$

$f_i$ $i$ $f_i$ $f_j$ $i$ $j$ $f$ $|N|$ $f_i$ $|N|-1$

DW
fonte

0

Você pode tornar o programa arbitrariamente longo. Portanto, em qualquer programa, você pode decidir se o idioma é equivalente ao deste programa. Você não pode fazer isso pelo teorema de Rice.

Zirui Wang
fonte

1

Você tem um ponto válido de que a idéia de verificar o programa executando-o em várias instâncias não funcionará em geral.

Tsuyoshi Ito

Os testes podem mostrar a ausência de bugs?

Respostas: