Calcolo della lunghezza dell'input su una macchina Turing a nastro singolo

In relazione a questa domanda , mi sono chiesto: qual è la complessità temporale di una macchina di Turing a testa singola a nastro singolo per calcolare la lunghezza del suo input? Per essere precisi, supponiamo che l'alfabeto del nastro sia , l'input è una stringa in circondata da spazi vuoti, la macchina inizia dal simbolo di input più a sinistra e deve termina con il simbolo più a sinistra di una stringa in (di nuovo circondato da spazi) che fornisce la rappresentazione binaria della lunghezza di input. Questo può anche essere considerato come il problema di convertire un numero da unario a binario. $\{0,1,b\}$ $(0+1)^*$ $(0+1)^*$

È facile risolverlo su una macchina a due nastri o due teste in tempo lineare (basta scansionare l'ingresso con una testa mentre si usa l'altra testa per incrementare ripetutamente un contatore; l'incremento è un'operazione di tempo ammortizzato costante). Ma le soluzioni a testa singola che posso trovare sono solo (ad es. Incrementare ripetutamente un contatore e quindi spostarlo di una posizione lungo il nastro). Esiste un limite inferiore corrispondente? $O(n\log n)$

Ho provato alcune ricerche, ma frasi come "una testa" e "lunghezza di input" sono così comuni da rendere difficile la ricerca in letteratura di risultati noti su questo problema.

turing-machines

— David Eppstein
fonte

Interessante .. Questo è meno ovvio di quanto sembri. Sono curioso di sapere se esiste una relazione tra un limite inferiore per questo e un limite inferiore per la simulazione TM ignara. (Qualsiasi TM che risolve questo problema sarebbe, per definizione, ignaro (o avrebbe un codice non necessario).)

— Daniel Apon,

Non può essere calcolato nel tempo . $o(n\lg n)$

Sia una macchina che ha dato una stringa di input ferma con la dimensione di scritta in binario sul nastro. $M$ $x$ $x$

Possiamo aggiungere un semplice DFA (tempo lineare zero-spazio) a per verificare se la dimensione dell'ingresso è una potenza di due: basta controllare che il primo bit sia 1 e il resto sia zero. $M$

Supponiamo che passi il tempo . Quindi possiamo decidere nel tempo che la dimensione di input è una potenza di due. In altre parole, la seguente lingua è decidibile in . Segue da $M$ $o(n \lg n)$ $o(n \lg n)$ $\mathsf{DTime}(n \lg n)$

L = {0^{i} ∣ \exists k i = 2^{k}}

$L = \{ 0^i \mid \exists k \ i = 2^k\}$

che

dovrebbe essere regolare. Ma è facile verificare che la lingua non sia regolare. Quindi

non può funzionare nel tempo

D T i m e (o (n \lg n)) = R e g

$\mathsf{DTime}(o(n \lg n)) = \mathsf{Reg}$

L

$L$

M

$M$

o (n \lg n)

$o(n \lg n)$

— Kaveh
fonte

D T i m e (o (n \lg n)) = R e g

$\mathsf{DTime}(o(n\lg n))=\mathsf{Reg}$

D T i m e (n \lg n) = R e g

$\mathsf{DTime}(n \lg n) = \mathsf{Reg}$

Grazie per i suggerimenti, ho dato un'occhiata a "Teoria della ricorsione classica" vol. II. Per il fatto che è cambiato, non è così chiaro per me. Ad esempio, il libro di Sipser utilizza TM a nastro singolo per definire le classi di complessità temporale, ma il libro di Hopcroft-Ullman e le più recenti Arora-Barak e Goldreich utilizzano TM multitape.

— Bruno,

@Bruno, penso che la definizione più comune di DTime sia più complicata. Ad esempio l'affermazione comunemente affermata che "il teorema della gerarchia temporale non è noto per essere stretta" è vera solo per le macchine a nastro singolo, per le macchine a nastro doppio è nota per essere stretta dal 1982.

— Kaveh

D T i m e

$\mathsf{DTime}$