DSPACE (n) = DSPACE (1.5n) è?


11

Dal teorema della gerarchia spaziale è noto che se è costruibile nello spazio, DSPACE ( ) non è uguale a DSPACE ( .ff2 f ( n )2f(n)f ( n ) )f(n))

Qui, per DSPACE ( intendo la classe di tutti i problemi che possono essere risolti nello spazio da una macchina di Turing con un alfabeto fisso. Ciò consente di considerare il teorema della gerarchia spaziale con tale precisione.f ( n ) ) f(n))f ( n )f(n)

L'argomento standard fornisce la costante moltiplicativa : abbiamo bisogno dello spazio per costruire un calcolo di una macchina di Turing da uno universale. Inoltre abbiamo bisogno di per risolvere un problema con l'arresto.2 2f ( n ) f(n)f ( n )f(n)

Domanda: Is DSPACE ( ) pari a DSPACE ( )? f ( n )f(n)32 f ( n )32f(n)


2
Qualche motivo per cui sei interessato a ? Sarebbe 1+ \ Omega (1) essere altrettanto interessante? 32 1+Ω(1)321+Ω(1)
Thomas,

1
Perché pensi che il teorema della gerarchia spaziale dia ? Suppongo che tu sostenga che abbiamo bisogno di spazio per la simulazione e spazio per contare il numero di passaggi per evitare cicli infiniti. Ma in entrambi i casi dobbiamo prima contrassegnare la posizione sul nastro (può essere fatto poiché è costruibile nello spazio) e come faresti la marcatura? Il tuo argomento è OK se supponi che alle macchine non sia permesso scrivere *, ma per il resto sono necessarie ulteriori complicazioni. 2 f ( n ) f ( n ) log | Σ | | Σ | f ( n ) f ( n ) f2f(n)f(n)log|Σ||Σ|f(n)f(n)f
domotorp,

@Thomas In realtà voglio1 + o ( 1 )1+o(1)
Alexey Milovanov il

Risposte:


9

Si può dimostrare che DSPACE DSPACE se cresce almeno linearmente usando una semplice variante dell'argomento di riempimento standard. Per una lingua , lascia .( f ( 32 n))(f(32n)) (f(n))fLL={x0| x| /2xL}(f(n))fLL={x0|x|/2xL}

Richiesta. DSPACE se e solo se DSPACE se .L L( f ( n ) ) L ( f ( 2(f(n))L3 n))(f(23n))f(n)32 nf(n)32n

(La mia prima risposta aveva diverse affermazioni errate, grazie a Emil per averlo individuato.)

Mostrerò innanzitutto come utilizzare l'affermazione per dimostrare la gerarchia. Poiché cresce almeno in modo lineare, abbiamo DSPACE DSPACE . Prendi una lingua DSPACE DSPACE . Usando la rivendicazione, DSPACE DSPACE , dove l'ultima uguaglianza è l'assunzione indiretta. Ma poi DSPACE DSPACE , dove l'ultima uguaglianza è di nuovo assunta indirettamente, dando una contraddizione.f f( 2 f ( n ) ) ( f ( 2 n ) ) L ( f ( 2 n ) ) ( f ( n ) ) L ( f ( 4(2f(n))(f(2n))L(f(2n)) (f(n))L3 n))=(f(43n))= (f(n))L(f(3(f(n))L2 n))=(f(32n))= (f(n))(f(n))

Prova del reclamo. Se DSPACE , quindi per dimostrare DSPACE , dobbiamo solo scrivere 0 alla fine dell'input e simulare la macchina che ha accettato . Poiché , ciò non aumenta lo spazio che utilizziamo. (In effetti, sapere quanti 0 scrivere non è affatto chiaro se è piccolo e non possiamo aumentare la dimensione dell'alfabeto - invece, possiamo usare un altro nastro e scrivere su tutto ciò che verrebbe dopo la fine di .)L L( f ( 23 n))(f(23n))LL (f( n ) ) ( f( n ) )| x | / 2 | x | / 2x XL L' f ( n ) 32 nf( n ) 32nffxX

L'altra direzione è proprio così semplice sostituendo gli 0 con *, se ci è permesso scrivere *. (Vedi i problemi con questo nel mio commento alla domanda.) Se non ci è permesso scrivere stelle, modifichiamo leggermente la definizione di come . Ora, invece di scrivere le stelle, manteniamo l'input originaleL L'L = { x 10 | x | / 2x L } L'= { x 10| x | / 2xL}x 10 | x | / 2x10|x|/2e lavorare con quello. Ma ogni volta che raggiungiamo un 1, andiamo a destra fino a quando non colpiamo un altro 1 per verificare se era la fine della parola 1 o meno. Se ne abbiamo trovato un altro 1, torniamo al nostro 1. Se non l'abbiamo fatto, torniamo ancora indietro, ma sapremo che dovrebbe essere trattato come una stella - se dovessimo scrivere su di esso, allora scriviamo anche un 10 dopo di esso per avere un nuovo marcatore di parole di fine corrente. (In effetti, c'è anche un piccolo problema in questa parte se è piccolo - come possiamo verificare se l'input è nel formato ? Senza distruggere l'input, posso risolverlo solo usando teste multiple per piccoli .) f fx 10 | x | / 2x10|x|/2 ff


Non capisco affatto l'argomento. In ogni caso, la costruzione del padding mostra solo che se , allora , che è piuttosto diverso (attenzione alla posizione di ). Allo stesso modo, la direzione opposta non è affatto chiara come affermato, ciò che mi è chiaro solo è che se , allora . Anche se prendo il reclamo al valore nominale, la prova del risultato principale è errata: dà solo . L D S P A C E ( f ( n ) ) L D S P A C E ( f ( 2LDSPACE(f(n))3 n))2LDSPACE(f(23n))3 LDSPACE(f(2233 n))LDSPACE(f(n)+nLDSPACE(f(23n))2 ) L D S P A C E ( 2 f ( n ) ) L D S P A C E ( 4LDSPACE(f(n)+n2)LDSPACE(2f(n))3 f(n)+n3 ))LDSPACE(43f(n)+n3))
Emil Jeřábek,

1
@Emil Hai ragione. Ho provato a ripararlo, sembra migliore?
domotorp,

1
Non mi è del tutto chiaro quale modello di macchina stai usando, ma nel modello standard con un nastro di input di sola lettura la cui lunghezza non conta per il limite dello spazio, non vedo come mostrare L D S P A C E ( f ( 23 n))LDSPACE(f(23n))LDSPACE(f(n))O(logn)fD S P A C E ( f ( n ) ) D S P A C E ( ( 1 + ϵ ) f ( n ) ) ϵ > 0DSPACE(f(n))DSPACE((1+ϵ)f(n))

2
@Emil Non penso che il nastro di input sia di sola lettura - AFAIK che si assume solo se . f ( n ) < n
domotorp,
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.