Équivalence des définitions de Kolmogorov-Complexity

Il existe de nombreuses façons de définir la complexité de Kolmogorov et, généralement, toutes ces définitions sont équivalentes jusqu'à une constante additive. C'est-à-dire que si et sont des fonctions de complexité de kolmogorov (définies via différents langages ou modèles), alors il existe une constante telle que pour chaque chaîne , . Je crois que c'est parce que pour chaque fonction de complexité de Kolmogorov et pour chaque il tient que , pour une constante . $K_1$ $K_2$ $c$ $x$ $|K_1(x) - K_2(x)| < c$ $K$ $x$ $K(x) \le |x| +c$ $c$

Je suis intéressé par les définitions suivantes de , basées sur les machines de Turing $K$

nombre d'états : Définissez comme le nombre minimal tel qu'une MT avec états génère sur la chaîne vide. $K_1(x)$ $q$ $q$ $x$
Durée du programme : Définissez comme le "programme" le plus court qui génère . À savoir, fixer un moyen de coder les MT en chaînes binaires; pour une machine désigne son encodage (binaire) comme . où le minimum est supérieur à tous les qui produisent sur une entrée vide. $K_2(x)$ $x$ $M$ $\langle M \rangle$ $K_2(x) = \min |\langle M \rangle|$ $M$ $x$

Est-ce que $K_1$ et $K_2$ équivalents? Quelle est la relation entre eux, et laquelle saisit mieux le concept de complexité de Kolmogorov, s'ils ne sont pas équivalents.

Ce qui me dérange surtout, c'est l' augmentation du taux $K_2$ avec $x$ , qui ne semble pas être super-linéaire (ou au moins linéaire avec une constante $C>1$ telle que $K_2 < C|x|$ , plutôt que $|x|+c$ ). Considérez la MT la plus simple qui génère $x$ - celle qui code simplement $x$ dans le cadre de sa fonction d'états et de transitions. il est immédiat de voir que $K_1(x) \le |x|+1$ . Cependant l'encodage de la même machine est beaucoup plus grand, et la borne triviale que j'obtiens est $K_2(x) \le |x|\log |x|$ .

computability kolmogorov-complexity

— A sonné.
source

Il existe plus de

2^{n^{2}}

$2^{n^2}$ machines avec

n

$n$ états, et leur taille moyenne est d'au moins

n^{2}

$n^2$ , il est donc peu probable que celles-ci ne diffèrent que par une constante additive.

— Kaveh

Il existe une borne bien connue quepour certains fixes ne dépendant pas de . En effet, nous pouvons coder dans un langage sans préfixe en doublant simplement chaque bit de et en terminant par . Cela prend bits pour représenter . Ainsi, parce que est défini en termes de machine universelle sans préfixe, pour certains fixes . Cela peut être amélioré en utilisant une manière plus intelligente d'encoder dans un langage sans préfixe.

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

Je ne vois pas comment. Il semble que soit soit donné dans le cadre de l'encodage (sous forme de données brutes), soit vous devez construire par votre machine à états. La première option semble tricher et je ne vois pas comment elle peut être comparable à la deuxième option (ce qui implique )

x

$x$

x

$x$

K_{1}

$K_1$

— Ran G.

@Ran G .: Le point clé est le théorème d'invariance décrit sur en.wikipedia.org/wiki/Invariance_theorem . Si je peux décrire un système efficace qui a un taux de croissance dealors une machine de Turing universelle (comme vous le décrivez pour ) rencontrera cela dans une constante additive. La machine universelle est celle qui prend entrée et renvoie la sortie de si s'arrête.

2 | x |

$2|x|$

K_{2}

$K_2$

⟨ M ⟩

$\langle M\rangle$

M

$M$

M

$M$

— Carl Mummert

Je m'excuse à l'avance d'avoir donné trop de détails, mais je suis sur le point de contredire les gens.

À propos de $K(x)≤K'(x)+c$

Le fait que provient généralement d'un interprète du langage de description # 2 dans le langage de description # 1 et non d'une traduction de programmes de # 2 en programmes de # 1. $K_1(x)≤K_2(x)+c$

Par exemple et vous obtenez cette inégalité aussi simplement que ceci: $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)");
}

Ensuite, votre constante sera quelque chose comme où est le nombre de bits pour ce code et bits est la taille de l'interpréteur Python officiel écrit en sûr, vous n'avez besoin que d'interpréter ce qui est possible dans votre langage de description pour Python afin que vous puissiez faire mieux que 69 Mo :-) $c_\mathtt{py2c}$ $528+490240688$ $528$ $490240688$

Ce qui est important, c'est que vous pouvez écrire votre programme Python de façon linéaire dans votre code C. Par exemple, une langue où vous devez mettre "BANANA" entre chaque caractère n'est pas un très bon programme de description et la propriété est alors fausse. (Mais si le langage de description vous autorise à écrire des données dans un fichier séparé ou dans un bloc, ce problème disparaît)

Pourquoi votre est défectueux $K_1(x)=q$

Le problème avec votre définition de est que vous pouvez avoir besoin de plus de bits pour décrire une machine de Turing avec états car vous devez coder des transitions. $K_1$ $q$ $q$

Donc aucun et sont probablement pas équivalents, mais c'est principalement la faute de . Je pense que nous pouvons prouver que pour tout il y a une telle que . Bien sûr, tout suffit pour réfuter le fait que n'est pas une fonction valide, car cela signifierait que nous pouvons coder plus toutes les chaînes de longueur possibles $K_1$ $K_2$ $K_1$ $a>0$ $c_a$ $K_1(x)≤a|x|+c_a$ $a<1$ $K_1$ $2^n$ dans des bits. $n$ $an+c_a$

Mais la taille est une limite incroyablement serrée lors de la construction de machines Turing. L'idée est que dans un bloc de états, il existe façons de trouver des transitions pour chaque état et c'est mieux que les façons habituelles de remplir bits. Ensuite, vous pouvez stocker dans chaque bloc bits d'informations. (pas car vous devez entrer et sortir du bloc d'une manière ou d'une autre) $b$ $b^{2b}$ $2^b$ $b$ $\log_2 b$ $2\log_2 b$

Alors oui ... Avec des blocs de taille vous pourriez probablement prouver . Mais j'ai déjà trop écrit sur les raisons pour lesquelles le nombre d'états n'est pas une fonction de complexité de Kolmogorov valide. Si vous voulez que j'élabore, je le ferai. $2^{1/a}$ $K_1(x)≤a|x|+c_a$

Maintenant sur $K_2$

Le langage descriptif naïf correspond approximativement à (c'est-à-dire pour chaque état suivant et détails sur l'écriture et la terminaison). $K_2(x)=q\cdot 2 \cdot (\log_2 q + 2)$ $\log_2q$

Comme vous semblez l'être, je suis convaincu qu'une meilleure façon / tricherie serait d'autoriser à encoder des "données" dans la machine Turing, peut-être en ajoutant une balise binaire dans le langage de description qui indique si un état est un état de données ( qui écrit juste un peu et passe à l'état suivant) ou s'il fait autre chose. De cette façon, vous pouvez stocker un bit de votre dans un bit de votre langage descriptif. $x$

Cependant, si vous gardez le même vous pouvez utiliser la même technique que j'ai utilisée dans la partie précédente pour enregistrer quelques bits, mais il me semble que je suis bloqué à (pour tout ) .. peut-être moins que , même, mais obtenir semble difficile. (Et je m'attends à ce que ce soit , pas même $K_2$ $K_2(x)≤a|x|\log|x|+c$ $a>0$ $\log|x|$ $O(|x|)$ $|x|$ .) $O(|x|)$

— jmad
source

prétendez-vous que

n'est pas une fonction de complexité de kolmogorov? C'est très surprenant pour moi, car

est en fait la définition utilisée dans certains cours d'introduction à la calculabilité que j'ai pris une fois (non pas qu'il dise quoi que ce soit sur son exactitude).

K_{1}

$K_1$

K_{1}

$K_1$

— Ran G.

Eh bien le fait que

est assez dérangeant. Considérez ceci: il y a

mots possibles de

bits et vous pouvez les encoder en utilisant un

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

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

2^{n}

$2^n$

n

$n$

bits? Cela impliquerait

\frac{1}{2} n + c

$\frac12n+c$

(votre encodage doit être injectif)

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

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

— jmad

Que faire si le programme python a des caractères réservés par C?

— PyRulez

Équivalence des définitions de Kolmogorov-Complexity

À propos deK(x)≤K′(x)+cK(x)≤K′(x)+cK(x)≤K'(x)+c

Pourquoi votre est défectueuxK1(x)=qK1(x)=qK_1(x)=q

Maintenant sur K2K2K_2

À propos de $K(x)≤K'(x)+c$

Pourquoi votre est défectueux $K_1(x)=q$

Maintenant sur $K_2$