Existe-t-il des preuves non constructives de l'existence de «petites» machines de Turing / NFA?

Après avoir lu une question connexe , sur les preuves d'existence d'algorithmes non constructives, je me demandais s'il existe des méthodes pour montrer l'existence de "petites" machines de calcul (disons, par état) sans les construire.

Officiellement:

supposons qu'on nous donne un langage et fixons un modèle de calcul (NFAs / machine de turing / etc.). $L\subseteq \Sigma^*$

Existe-t-il des résultats d'existence non constructifs montrant qu'une machine à états pour existe, mais sans la capacité de la trouver (en temps )? $n$ $L$ $poly(n,|\Sigma|)$

Par exemple, existe-t-il un langage régulier pour lequel nous pouvons afficher mais nous ne savons pas comment construire un automate à états? $L$ $nsc(L)\leq n$ $n$

( est la complexité d'état non déterministe de , c'est-à-dire le nombre d'états dans le NFA minimal qui accepte ). $nsc(L)$ $L$ $L$

EDIT: après quelques discussions avec Marzio (merci!) Je pense que je peux mieux formuler la question comme suit:

Existe-t-il un langage et un modèle de calcul pour lesquels: $L$

Nous savons comment construire une machine qui calcule qui a états. $L$ $m$

Nous avons une preuve qu'il existe une machine à états pour (où ), mais soit nous ne la trouvons pas du tout, soit cela prendrait un temps exponentiel pour le calculer. $n$ $L$ $n << m$

qu'est-ce que nsc (L)? la question semble liée à la complexité de la compression / Kolmogorov qui demande de trouver de petites (est) machines pour représenter les cordes ...

vzn

nsc (L) est la complexité d'état non déterministe de L (le nombre d'états dans le plus petit NFA qui accepte L).

autre idée / angle, peut-être existe-t-il des "petites" classes de circuits (un autre modèle de calcul) pour lesquelles il est prouvé qu'elles peuvent calculer certaines fonctions mais la construction réelle est délicate? SJ a récemment mentionné Barrington thm que les programmes de branchement de largeur 5 peuvent calculer la majorité ...?

vzn

@vzn La preuve du théorème de Barrington donne une procédure simple pour convertir des formules en programmes de branchement.

Sasho Nikolov

@RB: ok, vous pouvez trouver des exemples plus intéressants de la complexité de Kolmogorov limitée par les ressources (en particulier la complexité limitée par le temps). Par exemple, étant donné une chaîne , quelle est la plus petite machine qui s'exécute dans le temps qui imprime

? Dans ce cas, nous pouvons facilement construire une MT qui imprime

, mais trouver la plus petite nécessite de scanner toutes les MT

(la limite de temps le rend calculable). Quand j'aurai plus de temps, je développerai ma réponse.

x

$x$

O (2^{n})

$O(2^n)$

x

$x$

x

$x$

| M | < | x |

$|M|<|x|$

Marzio De Biasi

Réponses:

Seul un commentaire étendu avec un exemple trivial; vous pouvez choisir la langue à un élément:

L_{k} = {M ∣ σ (M) = Σ (k)}

$L_k = \{ M \mid \sigma(M) = \Sigma(k) \}$

c'est-à-dire que contient la première machine de Turing de castor occupée (dans l'ordre lexicographique) de taille (la machine de Turing de taille qui atteint le plus grand nombre de 1 sur sa bande après l'arrêt). $L_k$ $k$ $k$

Pour chaque le langage est régulier ... mais nous n'avons aucune idée de la façon de construire le petit DFA qui le reconnaît (bien qu'il n'ait que états) :-) $k$ $L_k$ $\leq 2*k(\log k+2)$

Marzio De Biasi
la source

Bien que je convienne que cela fonctionne, je cherchais l'existence montrant des techniques pour un langage explicitement donné L.

Qu'est-ce qu'une "langue explicitement donnée"?

Jeffε

La langue (pour un nombre premier ) peut être reconnu par un -state quantiques finis automates borné d'erreur (soq) , mais la preuve est non constructif. $\mathtt{MOD_p} = \{a^{ip} \mid i \geq 0\}$ $p$ $O(\log p)$

$O(\log^{2+o(1)}p)$ $\mathtt{MOD_p}$

REF: Section 4.2 de (Ambainis et Yakaryilmaz, 2015) .

Abuzer Yakaryilmaz
la source

Une autre solution consiste à utiliser le lemme de Higman :

Une langue fermée sous des sous-mots est régulière.

$u$ $v$ $u$ $v$

Prenez donc n'importe quel langage L, sa fermeture de sous-mot est régulière mais n'est pas du tout constructible puisque L est arbitraire.

CP
la source