Grandi divari tra RAM e complessità della macchina di Turing

Se consideriamo solo problemi in P, ci sono grandi lacune tra l'algoritmo word-RAM più veloce conosciuto e l'algoritmo Turing machine più veloce conosciuto per problemi particolari? Sono particolarmente interessato se vi sono ampie lacune per problemi naturali di interesse generale.

cc.complexity-theory ds.algorithms

— Lembik
fonte

una macchina RAM può essere simulata da una macchina di Turing con sovraccarico di

O (n \log n)

$O(n\log n)$ in fase di esecuzione. Quindi non ci saranno grandi lacune.

— Shaull,

@Shaull Esiste un divario di quelle dimensioni per qualsiasi problema naturale / popolare?

— Lembik,

Palindrome impiega

Ω (n^{2})

$\Omega(n^2)$ tempo su una TM a nastro singolo (ed è

O (n)

$O(n)$ nella RAM). eecs.yorku.ca/course_archive/2008-09/W/6115/palindrome.pdf

— SamM,

Il commento di Shaull è vero solo per macchine non deterministiche e nell'impostazione TM a due nastri, per quanto ne so. Citazione, Shaull?

— Ryan Williams,

@ qbt937 - Wow, che esplosione del passato :) Credo di non aver fornito una citazione perché non ne avevo una (né ne ho una ora), e potrebbe darsi che Ryan Williams abbia ragione.

— Shaull

È noto che qualsiasi problema che è possibile calcolare su una macchina RAM nel tempo , è possibile farlo in una macchina di Turing in tempo al massimo . Devi notare che la dimensione totale della memoria utilizzata non può essere superiore a , poiché ciò significherebbe che hai fatto più operazioni di scrittura rispetto a , quindi ogni volta che recuperi qualcosa dalla memoria RAM, il Turing la macchina prenderebbe nel caso peggiore $T(n)$ $T(n)^2$ $T(n)$ $T(n)$ $T(n)$ tempo di trovare in sequenza l'elemento desiderato dal nastro. Oltre all'accesso alla memoria, il resto delle operazioni dovrebbe richiedere circa lo stesso tempo. E così ottieni il limite.

— Javier Cano
fonte

Le RAM possono calcolare la lunghezza dell'input (e quindi anche la parte di quella lunghezza) in tempo logaritmico, ma le macchine di Turing di base hanno bisogno di tempo lineare per calcolare quella parità.

L'esempio seguente dimostra che un algoritmo che impiega per risolvere un problema su word-Ram potrebbe aver bisogno di su una Turing Machine (TM) a 1 nastro che esegue esattamente tutti i calcoli indicati da . Comprendo che la domanda riguarda la TM a 1 nastro e la uso solo nella mia risposta. Questa è una modifica per rispondere alle osservazioni di Emil Jeřábek. $A$ $O(n\log(n))$ $O(n^2 \log(n)^3)$ $A$

Troveremo la seguente conclusione più generale . Per dimostrare che il TM può risolvere in un problema risolto in da un algoritmo RAM, è non sufficiente corsa sul TM. Potrebbe essere necessario un algoritmo intelligente . Lo stesso vale se si vuole dimostrare una $O(T(n)^2)$ $O(T(n))$ $A$ $A$ $O(n\log(n))$ spese generali. Dimostrare l'esistenza di un algoritmo intelligente quando necessario sembra tutt'altro che immediato, per non dire altro. Ciò non è in linea con altre risposte che fondamentalmente propongono di simulare / eseguire sul TM tutti i calcoli della RAM (dell'algoritmo ) per annunciare una complessità TM come o . $A$ $O(T(n)^2)$ $O(T(n)n\log(n))$

Problema: ci viene fornita una array / tabella con numeri interi ciascuno memorizzato su bit di . Ci viene dato un secondo array con posizioni , ciascuna delle quali registra un numero di bit . Per ogni , definiamo se $\texttt{tab}$ $n=2k$ $\log(n)$ $\texttt{d}$ $\log(n)$ $\log(n)$ $t\in[0..\log(n)-1]$ $X_t=1$ $\texttt{tab}[i]$ MOD MOD . Altrimenti, . Uscita . Ritengo che l'input sia dato come un nastro con $\texttt{d}[t]=\texttt{tab}[n/2+i]$ $\texttt{d}[t]~\forall i\in [0..n/2-1]$ $X_t=0$ $\sum_{t=0}^{\log(n)-1} X_t$ cifre binarie, per rispondere ai commenti di Emil Jeřábek. $n\log(n)+\log(n)\log(n)$

Algoritmo su RAM $A$ Una RAM con dimensioni di parole richiede = per leggere i dati di input della stringa binaria. Ma dopo aver letto i dati, può funzionare solo con parole di dimensioni . L'algoritmo calcola qualsiasi in $w=\log(n)$ $O(n\log(n)+\log(n)^2)$ $O(n\log(n))$ $\log(n)$ $A$ $X_t$ esaminandotutto e verificando la condizione. Il ciclo principale di èFOR : calcola . La complessità totale è (lettura dati) + $O(n)$ $i\in [0..n/2-1]$ $A$ $t=0, 1, 2, \dots \log(n)-1$ $X_t$ $O(n\log(n))$ $O(n\log(n))$ (facendo i calcoli), quindi può fare tutto in su RAM. $A$ $O(n\log(n))$

Algoritmo sulla TM a 1 nastro: $A$ sostengo che la TM a nastro singolo abbia bisogno del tempo per una fissa . Dal punto di vista della TM, determinare equivale a verificare l'uguaglianza di due stringhe binarie di lunghezza . Ad esempio, la operativa MOD MOD potrebbe essere equivalente alla rimozione del bit della $O(n^2 \log(n)^2)$ $t$ $A_t$ $O(n\log(n))$ $\texttt{tab}[i]$ $\texttt{d}[t]$ $0$ . In tali casi, determinare equivale al test di uguaglianza su stringhe di bit con lunghezza . È noto che testare l'uguaglianza di due stringhe di lunghezza richiede sul TM a 1 nastro, ma non riesco proprio a trovare un riferimento in questo momento. Tuttavia, fornisco una prova in ps. Se la TM esegue ilciclo principaledi , deve spendere almeno $\texttt{tab}[i]$ $A_t$ $n(\log(n)-1)/2$ $m$ $O(m^2)$ $A$ per ogni , che termina in . $O((n\log n)^2)$ $t=0, 1, 2, \dots \log(n)-1$ $O(n^2 \log(n)^3)$

ps. Mostro che il test di uguaglianza su stringhe di bit con bit non può essere più veloce del test di palinite su stringhe con bit (è noto che la palindrome impiega almeno tempo). Possiamo modificare qualsiasi algoritmo TM per test di uguaglianza per risolvere palindromo. Supponiamo che il test di uguaglianza TM inizi con due numeri interi: uno a sinistra della testa, uno a destra (questa è la forma di input più semplice per la TM). Ogni spostamento sulle posizioni di sinistra può essere speculare (riflesso) sulle posizioni di destra. Costruiamo una TM con mirroring: ogni volta che la TM iniziale si trova in una posizione (a sinistra), la TM con mirroring è nella posizione $m$ $m$ $O(m^2)$ $-x<0$ $x$ (sulla destra). Se una TM risolse il test di uguaglianza in meno di , questa TM speculare modificata risolverebbe il palindromo in meno di . $O(m^2)$ $O(m^2)$

Inoltre, ci sono alcuni algoritmi TM per il test di uguaglianza e tutti richiedono tempo quadratico perché hanno bisogno di un po 'di zigzag, vedi per esempio l'esempio 2 di Turing Machine a corsi.cs.washington.edu/courses/cse431/14sp/scribes/ lec3.pdf

— Daniel Porumbel
fonte

Il limite inferiore per i palindromi vale solo per il modello innaturale a nastro singolo. È semplice testare l'uguaglianza di due stringhe su una TM in tempo lineare. Lo stesso vale per l'uguaglianza di due sequenze di voci più lunghe. Inoltre, affinché la domanda abbia un senso, gli input per entrambi i modelli di macchine devono essere identici, cioè scritti come stringhe su un alfabeto finito. Pertanto, la tua RAM avrebbe bisogno del tempo O (log n) per leggere ogni voce e convertirla in una parola, rendendo inutile questa operazione.

— Emil Jeřábek,

@Emil Jeřábek, modificherò la mia risposta per indicare che penso solo alla TM a 1 nastro. Quando dici che una TM può testare l'uguaglianza in tempo lineare, suppongo che tu pensi a una TM a 2 nastri. Tuttavia, ho capito che l'intera domanda riguarda le TM a 1 nastro. Per quanto riguarda il modulo di input, devo confessare che potresti avere ragione, almeno per alcune word-RAM. Ma per quanto ne so, un array int C ++ memorizza gli interi uno dopo l'altro senza separatore, come se memorizzassero insieme una sequenza di bit. 10 in 16 bit occupano esattamente 160 bit, no? Anche se non fosse così, si potrebbe costruire una macchina che funzioni in questo modo.

— Daniel Porumbel,

Il modello standard di Turing in teoria della complessità è il multi-nastro. Non riesco a vedere come il C ++ abbia rilevanza qui, non stiamo discutendo del C ++, ma del modello RAM. In questo modello, le singole posizioni di memoria possono contenere numeri di lunghezza

, ma possiamo ancora operare solo su una (o

) posizione di memoria alla volta. In particolare, possiamo accedere all'input solo una posizione alla volta: non vi è alcuna operazione che ti consenta di fare “leggere

posizioni di input e

insieme in una sola parola” in tempo costante.

O (\log n)

$O(\log n)$

O (1)

$O(1)$

\log n

$\log n$

— Emil Jeřábek,

Esistono due possibilità: (1) La posizione di input [0] contiene il primo bit del primo numero, la posizione [1] contiene il secondo bit del primo numero e così via. Quindi è necessario il tempo

per leggere su RAM, proprio come per una macchina Turing. Pertanto, anche con TM a nastro singolo, si ottiene solo una velocità quadratica. (2) La posizione di input [0] contiene il primo numero, la posizione [1] il secondo numero e così via. Quindi il problema non ha senso su una TM, in quanto non è in grado di elaborare l'input di questo modulo. Pertanto, non si ottiene alcuna accelerazione, ma un problema che è espressibile solo in uno dei modelli di macchina.

O (n \log n)

$O(n\log n)$

— Emil Jeřábek,

@Emil Jeřábek, in seguito alle tue osservazioni, ho modificato la domanda per proporre un problema e un algoritmo RAM che impiega esplicitamente

per leggere i dati (da un nastro). Ho rimosso alcune delle mie osservazioni che non sono più pertinenti. Spero che questo risolva il problema che hai sottolineato.

O (n \log (n))

$O(n\log(n))$

— Daniel Porumbel,