In quali circostanze gli algoritmi

Supponiamo che, per ogni , vi sia una macchina di Turing che decide una lingua nel tempo . Esiste un singolo algoritmo che decide nel tempo ? (Qui, il termine viene misurato in termini di , la lunghezza di input.)$\epsilon > 0$$M_{\epsilon}$$L$$O(n^{a + \epsilon})$$L$$O(n^{a + o(1)})$$o(1)$$n$

Fa differenza se gli algoritmi $M_{\epsilon}$ sono calcolabili o calcolabili in modo efficiente in termini di $\epsilon$ ?

Motivazione: in molte prove, è più facile costruire algoritmi del tempo $O(n^{a + \epsilon})$ rispetto all'algoritmo limitante $O(n^{a + o(1)})$ . In particolare, è necessario limitare il termine costante in $O(n^{a + \epsilon})$ per passare al limite $O(n^{a+o(1)})$ . Sarebbe bello se ci fosse qualche risultato generale che puoi invocare per passare direttamente al limite.

La domanda è simile alle domande sull'esistenza costruttiva del limite di una sequenza di oggetti (costruttivi). Di solito se puoi costruire in modo uniforme quegli oggetti (qui ) in modo abbastanza efficiente, allora puoi mostrare l'esistenza del limite in modo costruttivo.$M\epsilon$

Ad esempio, supponiamo che abbiamo una TM che esegue M | k | - 1 su x e il suo tempo di esecuzione è O ( n a + | k | - 1 ) + O ( | k | ) (qui anche i limiti sono uniformi, ad esempio qualcosa come O ( 2 k . N a + | k | - 1$N(k,x)$$M_{|k|^{-1}}$$x$$O(n^{a+|k|^{-1}})+O(|k|)$$O(2^k.n^{a+|k|^{-1}})$non funzionerebbe). Quindi possiamo combinare questo simulatore uniforme con la funzione per ottenere la macchina N ( x , x ) che gira nel tempo O ( n a + o ( 1 ) ) .$(k,x)\mapsto x$$N(x,x)$$O(n^{a+o(1)})$

PS: è un po 'ambiguo a causa della nidificazione di notazioni asintotiche, lo sto interpretando come n a + o ( 1 ) . Inoltre abbiamo bisogno di un essere non troppo piccola, per esempio di almeno 1 .$O(n^{a+o(1)})$$n^{a+o(1)}$$a$$1$

Puoi usare l'algoritmo di ricerca universale di Levin. Supponiamo di poter in qualche modo enumerare una sequenza di algoritmi decide L , ciascuno in esecuzione nel tempo C k n a + 1 / k . L'algoritmo di Levin corre nel tempo T ( n ) ≤ D k n a + 1 / k per ogni k , dove D k è una costante dipendente da C k . Quindi per ogni k , τ ( n ) $A_k$$L$$C_k n^{a+1/k}$$T(n) \leq D_k n^{a+1/k}$$k$$D_k$$C_k$$k$ Datoϵ>0, sceglik=⌈2/ϵ⌉e lasciaN=⌈D 2 / ϵ k ⌉. Quindi pern≥N,τ(n)≤ϵ. Pertantoτ(n)→0, e otteniamo che l'algoritmo di Levin viene eseguito nel tempona+τ(n)=na

$$\tau(n) \triangleq \frac{\log T(n)}{\log n} - a \leq \frac{\log D_k + (a+1/k) \log n}{\log n} - a = \frac{\log D_k}{\log n} + \frac{1}{k}.$$ $\epsilon>0$$k = \lceil 2/\epsilon \rceil$$N = \lceil D_k^{2/\epsilon} \rceil$$n \geq N$$\tau(n) \leq \epsilon$$\tau(n) \rightarrow 0$ .$n^{a+\tau(n)} = n^{a+o(1)}$