I test possono mostrare l'assenza di bug?

18

$(n + 1)$ sono necessari punti per determinare in modo univoco un polinomio di grado $n$ ; per esempio, due punti in un piano determinano esattamente una linea.

Quanti punti sono necessari per determinare in modo univoco una funzione calcolabile , vista la lunghezza di un programma che calcola in una lingua fissa? (cioè legato alla complessità di Kolmogorov di ). $f : N \rightarrow N$ $f$ $f$

L'idea è che, almeno teoricamente, si potrebbe dimostrare la correttezza di un programma facendo abbastanza test.

Se uno ha un programma di lunghezza che calcola , c'è un limite al numero di funzioni che possono essere calcolati con una lunghezza di fonte al massimo . $P$ $L$ $f$ $L$

Pertanto si dovrebbe "solo" dimostrare che:

puòessere calcolato con una lunghezza della sorgente $f$ $\leq L$
non calcola alcuna altra funzione calcolabile in byte o meno (mediante test) $P$ $L$

Questa idea non ha probabilmente conseguenze pratiche (i limiti sono sicuramente destinati a essere esponenziali).

cc.complexity-theory computability

— pbaren
fonte

4

Supponiamo che il vostro descrizioni delle funzioni sono riportati in binario, poi ci sono al massimo

di descrizione di lunghezza al massimo

. Ma ora il problema è che a differenza dei polinomi, due distinte funzioni calcolabili possono facilmente assumere gli stessi valori su un numero infinito di input. Quindi il tuo problema mi sembra impossibile.

2^{L + 1} - 1

$2^{L+1}-1$

L

$L$

— Bruno

Capisco la tua idea. Ma due distinte funzioni calcolabili della lunghezza della descrizione <= L dovrebbero differire ad un certo punto (per alcuni n0). Si potrebbe trovare il valore di n0 dato L?

— pbaren,

4

puoi trovare un punto del genere se ne esiste uno, calcola semplicemente le funzioni su tutti i valori usando la coda di rondine, ma se non c'è allora non lo saprai mai, è indecidibile, avere una lunghezza superiore alle dimensioni del programma non cambia nulla.

— Kaveh,

7

In realtà, @Kaveh, secondo il tuo stesso argomento, un limite superiore su

ti dice qualcosa su dove differiscono, ma non qualcosa di calcolabile. Se

e

, allora

dove

è la lunghezza dell'algoritmo che tu (@Kaveh) hai descritto e

è la prima stringa su cui

e

differiscono. In particolare,

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$ è limitato da una funzione simile a un castoro indaffarato di

. Tuttavia, trovare tutti

tali che

o BB di calcolo sia ancora ineccepibile. Quindi @pbaren: c'è un limite, ma è molto più di un semplice esponenziale, è incontestabile.

2 L + c

$2L+c$

x

$x$

K (x) \leq 2 L + c

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

— Joshua Grochow,

6

@Kaveh: Questo è ciò che intendevo con una funzione "simile a un castoro indaffarato": lascia che

sia la lunghezza della stringa più lunga la cui complessità di Kolmogorov (correggi una macchina universale) è al massimo

. Esistono solo molte stringhe di questo tipo, quindi questo è ben definito fino alla scelta della macchina universale. Quindi

è un limite superiore: se due funzioni (calcolabili totali) della complessità di Kolmogorov al massimo

concordano su tutti i punti fino alla lunghezza

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)$ , quindi sono uguali.

— Joshua Grochow,

9

(Questo era inteso come un commento, ma è andato a lungo). Domanda molto interessante. Se sei disposto a pensare ad altre misure di complessità oltre a quelle di Kolmogorov, allora ci sono alcune risposte nella teoria dell'apprendimento che potrebbero soddisfarti. Lascio per gli esperti della zona.

$(x_1,\ldots,x_n,1)$

In Knuth's TAOCP 7.2.1.6 viene mostrato in modo sorprendente (usando il modello dell'albero di Natale) che per ricostruire una funzione booleana del monote (cioè non decrescente in ogni variabile) è necessario esattamente punti. ${n+1 \choose \lfloor n/2\rfloor+1}$

— Diego de Estrada
fonte

7

Per continuare sulla falsariga della risposta di Deigo, i limiti standard della complessità del campione dalla teoria dell'apprendimento ti dicono che se sei soddisfatto di trovare un programma "approssimativamente corretto", non devi assolutamente provare molti punti. Diciamo che stiamo codificando i programmi in binario, quindi ci sono solo programmi di lunghezza d. Consente supponiamo anche che v'è una certa distribuzione su esempi di ingresso . Forse il tuo obiettivo è trovare un programma che sei quasi sicuro sia quasi giusto ("Probabilmente approssimativamente corretto", ad esempio come nel modello di apprendimento PAC dei Valiant). Cioè, si desidera eseguire un algoritmo che prenderà un piccolo numero di campioni insieme a e con probabilità almeno $2^d$ $D$ $x \sim D$ $f(x)$ $(1-\delta)$ uscita qualche programma che concorda con su almeno una frazione ingressi tratte da . $P$ $f$ $(1-\epsilon)$ $D$

Disegneremo semplicemente esempi e genereremo qualsiasi programma di lunghezza che sia d'accordo con su tutti gli esempi. (Uno è garantito per esistere poiché supponiamo che abbia la complessità di Kolmogorov al massimo ) ... $m$ $x \sim D$ $P$ $\leq d$ $f$ $f$ $d$

Qual è la probabilità che un particolare programma che non sia d'accordo con su più di una frazione di esempi sia coerente con gli esempi abbiamo selezionato? È al massimo . Vorremmo prendere questa probabilità di essere al massimo modo da poter prendere un'unione vincolata su tutti i programmi e dire che con probabilità almeno , nessun programma "cattivo" è coerente con i nostri esempi disegnati. Risolvendo, vediamo che è sufficiente prendere solo esempi . (cioè solo linearmente molti nella complessità di Kolmogorov di $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$ ...)

A proposito, argomenti come questo possono essere usati per giustificare "Occam's Razor": dato un numero fisso di osservazioni, tra tutte le teorie che le spiegano, dovresti scegliere quella con la più bassa complessità di Kolmogorov, perché c'è la minima possibilità di overfitting.

Naturalmente, se si desidera controllare solo un singolo programma fisso in questo modo, sono necessari solo esempi ... $O(\log(1/\delta)/\epsilon)$

— Aaron Roth
fonte

3

Ecco una risposta banale: assumendo, Allora avete bisogno di conoscere il valore di affattopunti per determinare in modo univoco . Pertanto, l'approccio che disegni non ti aiuta affatto, a meno che tu non sappia in qualche modo che la lunghezza del programma è estremamente breve: molto più breve dibit. $L \ge \lg |N|$ $f$ $|N|$ $f$ $L$ $\lg |N|$

Considera la famiglia di funzioni , dove è definita come la funzione se e se . Si noti che la complessità di Kolmogorov è di circabit, dato che è possibile codificare il valore di nel codice sorgente e quindi è sufficiente una semplice istruzione condizionale ( extra). $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)$

Tuttavia, non è possibile distinguere dalla funzione di tutti zeri a meno che non venga verificato all'ingresso . Non è possibile distinguere da se non si test all'ingresso o . Pertanto, è necessario valutare affattoinput, per determinare in modo univoco con quale abbiamo a che fare. (OK, tecnicamente, è necessario valutarlo con input , ma comunque.) $f_i$ $i$ $f_i$ $f_j$ $i$ $j$ $f$ $|N|$ $f_i$ $|N|-1$

— DW
fonte

0

È possibile rendere il programma arbitrariamente lungo. Quindi, dato qualsiasi programma, puoi decidere se la sua lingua è equivalente a quella di questo programma. Non puoi farlo secondo il teorema di Rice.

— Zirui Wang
fonte

1

Hai un punto valido sul fatto che l'idea di controllare il programma eseguendolo su più istanze non funzionerà in generale.

— Tsuyoshi Ito,