Grandes lacunas entre a RAM e a complexidade da máquina de Turing

Se considerarmos apenas os problemas em P, existem grandes lacunas entre o algoritmo de RAM de palavras mais rápido e o algoritmo de máquina de Turing mais rápido para problemas específicos? Estou particularmente interessado se existem grandes lacunas para problemas naturais de interesse geral.

cc.complexity-theory ds.algorithms

— Lembik
fonte

uma máquina de RAM pode ser simulada por uma máquina de Turing com sobrecarga de

em tempo de execução. Portanto, não haverá grandes lacunas.

O (n \log n)

$O(n\log n)$

— Shaull

@ Shaull Existe uma lacuna desse tamanho para qualquer problema natural / popular?

— Lembik 11/05

O Palindrome leva

em uma TM de fita única (e é

na RAM). eecs.yorku.ca/course_archive/2008-09/W/6115/palindrome.pdf

Ω (n^{2})

$\Omega(n^2)$

O (n)

$O(n)$

— SamM

O comentário de Shaull é verdadeiro apenas para máquinas não determinísticas e na configuração de duas fitas TM, tanto quanto eu sei. Citação, Shaull?

— Ryan Williams

@ qbt937 - Uau, que explosão do passado :) Acredito que não citei porque não tinha uma (nem a tenho agora), e pode ser que Ryan Williams esteja correto.

— Shaull

Sabe-se que qualquer problema que você possa calcular em uma máquina de RAM no tempo , poderá fazê-lo em uma máquina de Turing no tempo no máximo . Você precisa observar que o tamanho total da memória usada não pode ser maior que , pois isso significaria que você executou mais operações de gravação que ; portanto, toda vez que você busca algo da memória RAM, o Turing máquina levaria no pior caso $T(n)$ $T(n)^2$ $T(n)$ $T(n)$ $T(n)$ tempo para encontrar o elemento desejado sequencialmente na fita. Além do acesso à memória, o restante das operações deve demorar aproximadamente o mesmo tempo. E assim você recebe o limite.

— Javier Cano
fonte

As RAMs podem calcular o comprimento da entrada (e, portanto, também a parte desse comprimento) em tempo logarítmico, mas as Máquinas de Turing básicas precisam de tempo linear para calcular essa paridade.

O exemplo abaixo prova que um algoritmo que leva para resolver um problema na palavra Ram pode precisar de em uma Turing Machine (TM) de 1 fita que executa exatamente todos os cálculos indicados por . Entendo que a pergunta está relacionada à 1-tape TM e só uso esta na minha resposta. Esta é uma edição para abordar as observações de Emil Jeřábek. $A$ $O(n\log(n))$ $O(n^2 \log(n)^3)$ $A$

Encontraremos a seguinte conclusão mais geral . Para provar que a TM pode resolver em um problema resolvido em por um algoritmo na RAM, não basta executar na TM. Um algoritmo inteligente pode ser necessário. O mesmo se aplica se alguém quiser provar um $O(T(n)^2)$ $O(T(n))$ $A$ $A$ $O(n\log(n))$ a sobrecarga. Provar a existência de um algoritmo inteligente sempre que necessário parece longe de ser imediato, para dizer o mínimo. Isso não está de acordo com outras respostas que basicamente apenas propõem simular / executar na TM todos os cálculos de RAM (do algoritmo ) para anunciar uma complexidade de TM como ou . $A$ $O(T(n)^2)$ $O(T(n)n\log(n))$

Problema: Recebemos uma matriz / tabela com números inteiros, cada um armazenado em bits de . Nos é dada uma segunda matriz com posições de , cada uma registrando um número de bits de . Para qualquer , definimos se a $\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 . Caso contrário, . Saída . Considero que a entrada é dada como uma fita com $\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$ dígitos binários, para endereçar os comentários de Emil Jeřábek. $n\log(n)+\log(n)\log(n)$

Algoritmo na RAM $A$ Uma RAM com tamanho de palavra precisa de = para ler os dados de entrada da string binária. Mas depois de ler os dados, ele pode funcionar apenas com palavras do tamanho do . O algoritmo calcula qualquer em $w=\log(n)$ $O(n\log(n)+\log(n)^2)$ $O(n\log(n))$ $\log(n)$ $A$ $X_t$ passando por todo e testando a condição. O loop principal de éFOR : calcula . A complexidade total é (leitura de dados) + $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))$ (fazendo os cálculos), para que possa fazer tudo em na RAM. $A$ $O(n\log(n))$

Algoritmo na TM com 1 fita: $A$ Argumento que a TM com uma fita precisa de tempo para um fixo . Do ponto de vista da TM, a determinação é equivalente a testar a igualdade das duas cadeias binárias de comprimento . Por exemplo, a operação MOD MOD pode ser equivalente a remover o bit da $O(n^2 \log(n)^2)$ $t$ $A_t$ $O(n\log(n))$ $\texttt{tab}[i]$ $\texttt{d}[t]$ $0$ . Em tais casos, a determinação é equivalente ao teste de igualdade em cadeias de bits com um comprimento . É sabido que testar a igualdade de duas seqüências de comprimento requer na 1-tape TM, mas não consigo realmente encontrar uma referência no momento. No entanto, forneço uma prova no ps. Se a TM executar oloop principalde , precisará gastar pelo menos $\texttt{tab}[i]$ $A_t$ $n(\log(n)-1)/2$ $m$ $O(m^2)$ $A$ para cada , terminando em . $O((n\log n)^2)$ $t=0, 1, 2, \dots \log(n)-1$ $O(n^2 \log(n)^3)$

ps. Eu mostro que o teste de igualdade em cadeias de bits com bits não pode ser mais rápido do que o teste de síndrome em cadeias com bits (sabe-se que a síndrome leva pelo menos tempo). Podemos modificar qualquer algoritmo de TM para teste de igualdade para resolver palíndromo. Suponha que a TM de teste de igualdade comece com dois números inteiros: um à esquerda da cabeça, um à direita (este é o formulário de entrada mais simples para a TM). Cada movimento sobre as posições da esquerda pode ser espelhado (refletido) sobre as posições da direita. Construímos uma TM espelhada: sempre que a TM inicial estiver em uma posição (à esquerda), a TM espelhada estará na posição $m$ $m$ $O(m^2)$ $-x<0$ $x$ (a direita). Se um TM resolvesse o teste de igualdade em menos de , esse TM espelhado modificado resolveria o palíndromo em menos de . $O(m^2)$ $O(m^2)$

Além disso, existem alguns algoritmos de TM para teste de igualdade e todos eles exigem tempo quadrático porque precisam de zigue-zague, veja, por exemplo, o Exemplo 2 da Máquina de Turing em cursos.cs.washington.edu/courses/cse431/14sp/scribes/ lec3.pdf

— Daniel Porumbel
fonte

O limite inferior para palíndromos é válido apenas para o modelo de fita única não natural. É simples testar a igualdade de duas strings em uma TM em tempo linear. O mesmo vale para a igualdade de duas seqüências de entradas mais longas. Além disso, para que a questão faça algum sentido, as entradas para os dois modelos de máquinas devem ser idênticas, ou seja, escritas como cadeias de caracteres sobre um alfabeto finito. Assim, sua RAM precisaria de tempo O (log n) para ler cada entrada e convertê-la em uma palavra, tornando essa operação inútil.

— Emil Jerabek

@Emil Jeřábek, editarei minha resposta para indicar que só penso na 1-tape TM. Quando você diz que uma TM pode testar a igualdade no tempo linear, suponho que você pense em uma TM com 2 fitas. No entanto, entendi que toda a questão é sobre TMs de 1 fita. Em relação ao formulário de entrada, devo confessar que você pode estar certo, pelo menos para algumas RAMs de palavras. Mas, tanto quanto eu sei, uma matriz int C ++ armazena os números inteiros um após o outro sem separador, como se eles armazenassem juntos uma sequência de bits. 10 ints em 16 bits ocupam exatamente 160 bits, não? Mesmo se não for esse o caso, pode-se construir uma máquina funcionando dessa maneira.

— Daniel Porumbel

O (\log n)

$O(\log n)$

O (1)

$O(1)$

\log n

$\log n$

O (n \log n)

$O(n\log n)$

O (n \log (n))

$O(n\log(n))$