Equivalenza delle definizioni di Kolmogorov-complessità

Esistono molti modi per definire la complessità di Kolmogorov e , di solito, tutte queste definizioni sono equivalenti a una costante additiva. Cioè se e sono funzioni di complessità di kolmogorov (definite tramite linguaggi o modelli diversi), allora esiste una costante tale che per ogni stringa , . Credo che ciò sia dovuto al fatto che per ogni funzione di complessità di Kolmogorov e per ogni sostiene che , per qualche costante . $K_1$ $K_2$ $c$ $x$ $|K_1(x) - K_2(x)| < c$ $K$ $x$ $K(x) \le |x| +c$ $c$

Sono interessato alle seguenti definizioni per $K$ , basate su macchine di Turing

numero di stati : definire $K_1(x)$ come numero minimo $q$ tale che una TM con stati $q$ emetta $x$ sulla stringa vuota.
Lunghezza del programma : definire $K_2(x)$ come il "programma" più breve che genera $x$ . Vale a dire, fissa un modo per codificare le TM in stringhe binarie; per una macchina $M$ denota la sua codifica (binaria) come $\langle M \rangle$ . $K_2(x) = \min |\langle M \rangle|$ dove il minimo è su tutte le $M$ che producono $x$ su input vuoto.

Sono $K_1$ e $K_2$ equivalente? Qual è la relazione tra loro e quale afferriamo meglio il concetto di complessità di Kolmogorov, se non equivalenti.

Ciò che in particolare mi dà è l' $K_2$ aumento del tasso con $x$ , che non sembra essere super-lineare (o almeno lineare con costante $C>1$ tale che $K_2 < C|x|$ , piuttosto che $|x|+c$ ). Considera la TM più semplice che genera $x$ - quella che codifica solo $x$ come parte dei suoi stati e delle sue funzioni di transizione. è immediato vedere che $K_1(x) \le |x|+1$ . Tuttavia, la codifica della stessa macchina è molto più grande e il limite banale che ottengo è $K_2(x) \le |x|\log |x|$ .

computability kolmogorov-complexity

— Suonò.
fonte

Esistono più di macchine con stati e la loro dimensione media è almeno , quindi è improbabile che differiscano solo per una costante additiva.

2^{n^{2}}

$2^{n^2}$

n

$n$

n^{2}

$n^2$

— Kaveh,

C'è un limite ben noto cheper alcuni fissi non dipendenti da . Questo perché possiamo codificare in un linguaggio privo di prefissi semplicemente raddoppiando ogni bit di e terminando con . Questo richiede bit per rappresentare . Pertanto, poiché è definito in termini di macchina universale priva di , per alcuni fissi . Questo può essere migliorato in parte usando un modo più intelligente per codificare in un linguaggio libero prefisso.

K_{2} (x) \leq c + 2 | x |

$K_2(x) \leq c + 2|x|$

c

$c$

x

$x$

x

$x$

x

$x$

01

$01$

2 | x | + 2

$2|x| + 2$

x

$x$

K_{2}

$K_2$

K_{2} (x) \leq 2 | x | + 2 + c^{'}

$K_2(x) \leq 2|x| + 2 + c'$

c

$c$

x

$x$

— Carl Mummert

Non vedo come. Sembra che sia dato come parte della codifica (come dati non elaborati) o che tu debba costruire dalla tua macchina a stati. La prima opzione sembra barare e non vedo come possa essere paragonabile alla seconda opzione (che implica )

x

$x$

x

$x$

K_{1}

$K_1$

— Ran G.

@Ran G .: Il punto chiave è il teorema di invarianza descritto in en.wikipedia.org/wiki/Invariance_theorem . Se riesco a descrivere qualsiasi sistema efficace che ha un tasso di crescita diallora una macchina di Turing universale (come descrivi per ) incontrerà questo all'interno di una costante additiva. La macchina universale è quella che accetta sono input e restituisce l'output di se ferma.

2 | x |

$2|x|$

K_{2}

$K_2$

⟨ M ⟩

$\langle M\rangle$

M

$M$

M

$M$

— Carl Mummert,

Mi scuso in anticipo per aver dato troppi dettagli, ma sto per contraddire le persone.

Circa $K(x)≤K'(x)+c$

Il fatto che solito provenga da un interprete della lingua di descrizione n. 2 nella lingua di descrizione n. 1 e non da una traduzione da programmi di n. 2 a programmi di n. 1. $K_1(x)≤K_2(x)+c$

Ad esempio e ottieni questa disuguaglianza semplicemente come questa: $K_\mathtt{C}(x)≤K_\mathtt{Python}(x)+c_\mathtt{py2c}$

void py_run(char * s) {
    // code of your Python interpreter
}

int main(void) {
    py_run("Put here your Python program of size Kpython(x)");
}

Quindi la tua costante sarà qualcosa come dove è il numero di bit per questo codice e bit è la dimensione dell'interprete ufficiale di Python scritta in C. Naturalmente devi solo interpretare ciò che è possibile nel linguaggio di descrizione per Python in modo da poter fare meglio di 69 MB :-) $c_\mathtt{py2c}$ $528+490240688$ $528$ $490240688$

Ciò che è importante è che puoi scrivere il tuo programma Python in modo lineare nel tuo codice C. Ad esempio, una lingua in cui è necessario inserire "BANANA" tra ogni personaggio non è un ottimo programma di descrizione e la proprietà è quindi falsa. (Ma se il linguaggio descrittivo ti autorizza a scrivere i dati in un file separato o in un blocco, questo problema scompare)

Perché il tuo è difettoso $K_1(x)=q$

Il problema con la tua definizione di è che potresti aver bisogno di più di bit per descrivere una macchina di Turing con stati perché devi codificare le transizioni. $K_1$ $q$ $q$

Quindi nessun e probabilmente non sono equivalenti, ma è principalmente colpa di . Penso che possiamo dimostrare che per tutti esiste un tale che . Ovviamente qualsiasi è sufficiente per confutare il fatto che non è una funzione valida, poiché ciò significherebbe che possiamo codificare più tutte le possibili stringhe di lunghezza in bit . $K_1$ $K_2$ $K_1$ $a>0$ $c_a$ $K_1(x)≤a|x|+c_a$ $a<1$ $K_1$ $2^n$ $n$ $an+c_a$

Ma le dimensioni sono un limite incredibilmente stretto quando si costruiscono macchine Turing. L'idea è che in un blocco di stati ci sono modi per trovare le transizioni per ogni stato ed è meglio dei soliti modi in cui puoi riempire bit. Quindi è possibile memorizzare in ciascun blocco bit di informazione. (non perché devi entrare e uscire dal blocco in un modo o nell'altro) $b$ $b^{2b}$ $2^b$ $b$ $\log_2 b$ $2\log_2 b$

Quindi sì ... Con blocchi di dimensioni probabilmente potresti provare . Ma ho già scritto troppo sul perché il numero di stati non è una valida funzione di complessità di Kolmogorov. Se vuoi che ti elabori, lo farò. $2^{1/a}$ $K_1(x)≤a|x|+c_a$

Ora su $K_2$

La lingua descrittiva ingenua corrisponde approssimativamente a (cioè per ogni stato successivo e dettagli su scrittura e terminazione). $K_2(x)=q\cdot 2 \cdot (\log_2 q + 2)$ $\log_2q$

Come sembri, sono convinto che un modo migliore / imbroglione sarebbe quello di autorizzare la codifica di "dati" nella macchina di Turing, magari aggiungendo un tag binario nel linguaggio descrittivo che indica se uno stato è uno stato di dati ( che scrive solo un po 'e passa allo stato successivo) o se fa qualcos'altro. In questo modo potresti memorizzare un bit della tua in un bit del tuo linguaggio descrittivo. $x$

Tuttavia se mantieni lo stesso potresti usare la stessa tecnica che ho usato nella parte precedente per salvare alcuni bit, ma mi sembra di essere bloccato a (per qualsiasi ) .. forse inferiore a , anche, ma ottenere sembra difficile. (E mi aspetto che dovrebbe essere , nemmeno $K_2$ $K_2(x)≤a|x|\log|x|+c$ $a>0$ $\log|x|$ $O(|x|)$ $|x|$ .) $O(|x|)$

— jmad
fonte

affermi che

non è una funzione di complessità kolmogorov? Questo è molto sorprendente per me, dal momento che

è in realtà la definizione usata in alcuni corsi di introduzione alla calcolabilità che ho seguito una volta (non che dice nulla sulla sua correttezza).

K_{1}

$K_1$

K_{1}

$K_1$

— Ran G.

Bene il fatto che

è abbastanza inquietante. Considera questo: ci sono

parole possibili di

bit e potresti codificarle usando un

K_{1} (x) \leq \frac{1}{2} | x | + c

$K_1(x)≤\frac12|x|+c$

2^{n}

$2^n$

n

$n$

bit? Ciò implicherebbe

\frac{1}{2} n + c

$\frac12n+c$

(la codifica deve essere iniettiva)

2^{n} = O (2^{\frac{1}{2} n})

$2^n=O(2^{\frac12n})$

— jmad

Cosa succede se il programma Python ha caratteri riservati da C?

— PyRulez,

Equivalenza delle definizioni di Kolmogorov-complessità

CircaK(x)≤K′(x)+cK(x)≤K′(x)+cK(x)≤K'(x)+c

Perché il tuo è difettosoK1(x)=qK1(x)=qK_1(x)=q

Ora su K2K2K_2

Circa $K(x)≤K'(x)+c$

Perché il tuo è difettoso $K_1(x)=q$

Ora su $K_2$