Alfabeto della macchina di Turing a nastro singolo


40

Ogni funzione calcolabile nel tempo t su una macchina Turing a nastro singolo usando un alfabeto di dimensione essere calcolata nel tempo su una macchina di Turing a nastro singolo che utilizza un alfabeto di dimensione (diciamo, e vuoto)?f:{0,1}{0,1}tO ( t ) 3 0 , 1 ,k=O(1)O(t)30,1,

(Dai commenti sotto dell'OP) Notare che l'input è scritto usando , ma la macchina di Turing che usa un alfabeto di dimensione può sovrascrivere i simboli di input con simboli dell'alfabeto più grande. Non vedo come codificare i simboli nell'alfabeto più grande nell'alfabeto più piccolo senza dover spostare l'input che costerebbe il tempo .k n 20,1kn2


8
Nota che l'input è scritto usando , ma la macchina di Turing che usa un alfabeto di dimensione può sovrascrivere i simboli di input con simboli dell'alfabeto più grande. Non vedo come codificare i simboli nell'alfabeto più grande nell'alfabeto più piccolo senza dover spostare l'input che costerebbe il tempo . k n 20,1kn2
Manu,

4
@Emanuele: dovresti modificare la domanda ed enfatizzare questo aspetto; altrimenti suona esattamente come un normale esercizio da manuale ...
Jukka Suomela,

3
@Tsuyoshi, penso che tu abbia frainteso la domanda.
Suresh Venkat,

4
@Jukka: Su una macchina Turing a nastro singolo, tutto ciò che può essere calcolato nel tempo sono in realtà lingue regolari. o(nlogn)
Kristoffer Arnsfelt Hansen,

6
@Abel: Il risultato che citi da Arora e Barak risolve qui il problema principale perché nel loro modello (che è abbastanza standard per le TM multi-nastro), hanno un nastro di input separato, di sola lettura.
Joshua Grochow,

Risposte:


5

Una risposta parziale se TM viene eseguito in o(|x|log|x|)

Se TM4 è una TM a 4 simboli (con alfabeto ) che calcola f : { 0 , 1 } { 0 , 1 } , ovvero decide la lingua L = { x | fΣ4={ϵ,0,1,2}f:{0,1}{0,1} in ( o ( | x | log | x | ) )L={x|f(x)=1}(o(|x|log|x|))

Una complessità deterministica di tempo lineare deterministica è 1DLIN=1DTime(O(n))

  • Hennie ha dimostrato (1) che REG=1DLIN
  • Kobayashi lo ha dimostrato (2) REG=1DTime(o(nlogn))

Quindi è regolare ed è ovviamente ancora regolare sull'alfabeto Σ 3 = { ϵ , 0 , 1 }LΣ3={ϵ,0,1}

Quindi c'è un DFA che decide L e usa solo simboli in . Un TM3 a un nastro e 3 simboli può essere creato direttamente dal DFA e decide L usando lo stesso input non imbottito del TM4 originale .Σ3

... non puoi costruirlo direttamente da TM4, ma esiste TM3.

Se TM4 funziona in è possibile spostare l'ingresso ed effettuare una conversione diretta da TM4 a TM3.Ω(n2)

Come notato nei commenti, il caso difficile è quando TM4 funziona in .Ω(nlogn)o(n2)


(1) Hennie, One-tape, off-line Turing machine computations (1965)

(2) Kobayashi, Sulla struttura della gerarchia temporale non deterministica della macchina di Turing a un nastro (1985)


1
Il punto su è già stato notato da Kristoffer Arnsfelt Hansen nei commenti sotto la domanda. Il caso davvero interessante è Ω ( n log n ) o ( n 2 ) . o(nlogn)Ω(nlogn)o(n2)
Kaveh,

Hai ragione non ho notato il commento di Kristoffer. Ho espresso male il caso interessante (non so come dimostrarlo), quindi ho aggiornato la risposta.
Marzio De Biasi,

1
@Kaveh: Che ne pensi delle macchine -time per problemi promettenti? Sappiamo già come convertire, ad esempio, qualsiasi macchina che risolva un problema di promessa in O ( n ) tempo? Non vedo come farlo e la connessione con le lingue normali non è più valida (a meno che non mi sbagli di grosso). o(nlogn)O(n)
Jukka Suomela,

1
@Kaveh: Non puoi semplicemente prendere un problema che non è un linguaggio normale ma può essere risolto con una macchina di Turing in, ad esempio, O ( n 2 ) round, e definire un problema di promessa come segue: sì-istanze consistono in una stringa x L seguita da | x | 2 bit di imbottitura; nessuna istanza è costituita da una stringa x L seguita da | x | 2 pezzetti di imbottitura. Il problema della promessa è risolvibile in O ( n )LO(n2)xL|x|2xL|x|2O(n)tempo, e non è risolvibile utilizzando una macchina a stati finiti.
Jukka Suomela,

1
@Kaveh: Immagino che l'argomento intuitivo fallisca a causa del seguente motivo: Sì, c'è un problema non promettente che viene risolto dalla stessa macchina. Tuttavia, il tempo di funzionamento della macchina può essere alto quanto per determinati ingressi. (Intuitivamente, la macchina non può verificare che ci sia abbastanza imbottitura, e quindi "per giocare in sicurezza" deve presumere che ci sia abbastanza imbottitura dopo il prefisso x . Quindi perde tempo ast ( | x | 2 ) per determinare se x L , e questo è troppo se, ad esempio, avessimo solo ΘΘ(n2)xΘ(|x|2)xLΘ(|x|)pezzetti di imbottitura.)
Jukka Suomela,

-4

Per tutte le dimensioni dell'alfabeto superiori a , i runtime cambiano solo di un fattore costante poiché log k ( x ) Θ ( log l ( x ) ) per tutti k , l > 1 .1logk(x)Θ(logl(x))k,l>1

ttk{0,1,,k1}log2(k)log2(k){0,1}(gli spazi sono riservati per contrassegnare le celle non utilizzate). Si noti che si tratta essenzialmente di cifre con codice binario.

log2(k)tO(t)

{0,1}O(n2)O(n2)+log2(k)t

t(n)Ω(n2)Ω(n2)


3
Fino a quando non mi convincerai del perché questo dovrebbe essere il caso, terrò questo voto negativo.
Andrej Bauer,

1
Vorrei sentire alcune prove per la tua richiesta. Tutto questo, è solo un'affermazione.
Andrej Bauer,

2
Oh, capisco a cosa ti riferisci. Ok scusa. Tuttavia, la domanda non riguarda questo . È una leggera variazione.
Andrej Bauer,

6
Penso che il caso con t = Ω (n ^ 2) sia il caso semplice perché puoi permetterti il ​​tempo di spostare la stringa di input. Il caso essenziale è quando t = o (n ^ 2). Non so quanto sia importante considerare la TM a nastro singolo con o (n ^ 2) tempo, ma la domanda riguarda questo.
Tsuyoshi Ito,

3
Ω(n2)
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.