Teórico da complexidade difícil de verificar o valor de ?

A função de contagem primária , despromovida , é definida como o número de números primos menor ou igual a .$\pi(x)$$x$

Podemos definir um problema de decisão de seguinte maneira:$\pi(x)$

Dados dois números e , escritos em binário, decida se .$x$$n$$\pi(x) = n$

Um amigo e eu estávamos conversando sobre esse problema hoje cedo. Existe um algoritmo de tempo pseudopolinomial para esse problema - apenas conte até , usando a divisão de teste a cada etapa para ver quantos dos números são primos e verifique se é igual a . O problema também está no PSPACE, pois o algoritmo que acabei de descrever pode ser implementado para usar apenas o espaço auxiliar polinomial.$x$$n$

No entanto, estou tendo problemas para encontrar uma maneira de colocar esse problema em uma classe de menor complexidade. Não consigo ver como criar um verificador de tempo polinomial para o problema, por isso não tenho certeza se está no NP e não consigo pensar em uma maneira de colocá-lo na hierarquia polinomial.

Qual é a classe de complexidade mais apropriada para esse problema?

Obrigado!

Este é um problema muito aberto. Vou esboçar algumas classes em que o problema poderia "naturalmente" se encaixar.

Sua definição é um pouco estranha de se trabalhar, o problema é difícil de se encaixar em qualquer classe de complexidade existente. O idioma que você definiu é a interseção dos idiomas e { ( x , n ) | π ( x ) ≥ n } . Então, se por exemplo { ( x , n ) | π ( x ) ≤ n } estava na classe$\{(x,n)|\pi(x)\leq n\}$$\{(x,n)|\pi(x)\geq n\}$$\{(x,n)|\pi(x)\leq n\}$ então { ( x , n ) | π ( x ) ≥ n } seria em c o K . Isso torna difícil caracterizar o idioma que você definiu porque seria necessário declarar "a interseção de um idioma em K com um idioma em c o K " para fornecer o limite mais rígido.$K$$\{(x,n)|\pi(x)\geq n\}$$coK$$K$$coK$

O problema "Computar " é um problema em # P , onde # P ⊆ F P S P A C E é a classe de problemas da forma "Calcule o número de caminhos aceitáveis ​​de uma TM polinomial e não determinística". Claramente, podemos construir uma TM não determinística que adivinhe um número q ≤ x , e então (com AKS) testa se q é primo.$\pi(X)$$\#P$$\#P\subseteq FPSPACE$$q \leq x$$q$

Uma variante de decisão de é P P , que é a classe de idiomas que tem a forma: "Dada uma TM polinomial não determinística, pelo menos metade dos caminhos de computação aceita?". Ambos { ( x , n ) | π ( x ) ≤ n } e { ( x , n ) | π ( x ) ≥ n } são provavelmente redutíveis a um problema em P $\#P$$PP$$\{(x,n)|\pi(x)\leq n\}$$\{(x,n)|\pi(x)\geq n\}$$PP$ (fazendo algumas alterações na MT mencionada acima para equilibrar o número de caminhos aceitantes).

Seu problema está em C = P$_=$ através do algoritmo$\hspace{-0.06 in}\text{,}$

$\;\;\;$palpite não determinístico um número inteiro que$\big[$m e um pouco$\: 0\leq m < 2^{\lceil \hspace{.02 in}\log_{\hspace{.02 in}2}\hspace{-0.02 in}(x+1)\rceil}\big]$b
$\;\;\;$se x < mentão rejeitar
$\;\;\;$se b=1então:
$\;\;\;\;\;$se m < nentão aceitar mais rejeitar
$\;\;\;$ outro:
$\;\;\;\;\;$se m é primo, então aceite mais rejeitar

.


Em particular, seu problema também está no PP, pois o PP é fechado sob reduções da tabela verdade .

Na prática, você pode obter a resposta mais rápida ou mais devagar :-(

Existem aproximações razoavelmente boas para π (x). Então você calcula tal aproximação e, se estiver muito longe, sabe que π (x) ≠ n. Por exemplo, se n ≥ x, eu sei que π (x) ≠ n sem calcular nada.

Existe um algoritmo rápido que determina se π (x) é par ou ímpar, executando em O (x ^ (1/2)). Você pode executar esse algoritmo e ele pode detectar que a paridade de n está incorreta e está pronto. Tem cinquenta chances se n for um número inteiro aleatório próximo de π (x).

Fora isso, não conheço nenhum método que seja mais rápido que calcular π (x). O que é muito inconveniente - se eu escrever um programa que deve calcular π (10 ^ 25) e obter um resultado que não esteja obviamente errado, não há como verificar se meu resultado está correto, exceto repetir o Cálculo. E você não pode simplesmente repetir o cálculo usando o meu programa, você precisa escrever um programa diferente, caso contrário você não detectaria se o meu programa possui algum erro que o faça calcular uma função ligeiramente diferente de π (x).

π (x) pode ser calculado razoavelmente facilmente em cerca de O (n ^ (2/3)) e mais rápido com algumas matemáticas realmente profundas.