Teoria della complessità difficile da verificare il valore di

La funzione di conteggio primo , degradata , è definita come il numero di numeri primi minori o uguali a$\pi(x)$$x$ .

Possiamo definire un problema di decisione da come segue:$\pi(x)$

Dati due numeri e n , scritti in binario, decidere se π ( x ) = n .$x$$n$$\pi(x) = n$

Un amico e io stavamo parlando di questo problema prima di oggi. C'è un algoritmo pseudopolinomiale per questo problema: basta contare fino a , usando la divisione di prova ad ogni passo per vedere quanti numeri sono primi e controllare se è uguale a n . Il problema è anche in PSPACE, poiché l'algoritmo che ho appena descritto può essere implementato per utilizzare solo lo spazio ausiliario polinomiale.$x$$n$

Tuttavia, ho problemi a trovare un modo per collocare questo problema in una classe di complessità inferiore. Non riesco a vedere come costruire un verificatore del tempo polinomiale per il problema, quindi non sono sicuro che sia in NP, e non riesco a pensare a un modo per inserirlo nella gerarchia polinomiale.

Qual è la classe di complessità più appropriata per questo problema?

Grazie!

Questo è molto un problema aperto. Traccerò alcune classi in cui il problema potrebbe "naturalmente" adattarsi.

La tua definizione è in qualche modo scomoda su cui lavorare, il problema è difficile da adattare a qualsiasi classe di complessità esistente. La lingua che hai definito è l'intersezione delle lingue e { ( x , n ) | π ( x ) ≥ n } . Quindi se per esempio { ( x , n ) | π ( x ) ≤ n } era in classe$\{(x,n)|\pi(x)\leq n\}$$\{(x,n)|\pi(x)\geq n\}$$\{(x,n)|\pi(x)\leq n\}$ quindi { ( x , n ) | π ( x ) ≥ n } sarebbe in c o K . Questo rende dando una caratterizzazione della lingua che hai definito difficile, perché si dovrebbe stato "l'intersezione di una lingua in K con un linguaggio in c o K " per dare il più stretto bound.$K$$\{(x,n)|\pi(x)\geq n\}$$coK$$K$$coK$

Il problema "Calcola " è un problema in # P , dove # P ⊆ F P S P A C E è la classe di problemi della forma "Calcola il numero di percorsi accettanti di una TM non deterministica e polinomiale". Chiaramente possiamo costruire una TM non deterministica che indovina un numero q ≤ x , e quindi (con AKS) verifica se q è primo.$\pi(X)$$\#P$$\#P\subseteq FPSPACE$$q \leq x$$q$

Una variante di decisione di è P P , che è la classe di linguaggi che hanno la forma: "Dato un TM polinomiale non deterministico, almeno la metà dei percorsi di calcolo accetta?". Entrambi { ( x , n ) | π ( x ) ≤ n } e { ( x , n ) | π ( x ) ≥ n } sono probabilmente riducibili a un problema in P $\#P$$PP$$\{(x,n)|\pi(x)\leq n\}$$\{(x,n)|\pi(x)\geq n\}$$PP$ (facendo un po 'di confusione con la suddetta TM per bilanciare il numero di percorsi accettanti).

Il tuo problema è in C = P$_=$ tramite l'algoritmo$\hspace{-0.06 in}\text{,}$

$\;\;\;$indovinare in modo non deterministico un numero intero tale che$\big[$m e un po '$\: 0\leq m < 2^{\lceil \hspace{.02 in}\log_{\hspace{.02 in}2}\hspace{-0.02 in}(x+1)\rceil}\big]$b
$\;\;\;$se x < mpoi respingere
$\;\;\;$se b=1quindi:
$\;\;\;\;\;$se m < npoi accetta altrimenti respingi
$\;\;\;$ altro:
$\;\;\;\;\;$se m è primo, accetta altrimenti rifiuta

.


In particolare, il tuo problema è anche in PP, poiché il PP è chiuso in riduzioni della tabella di verità .

In pratica, potresti ottenere la risposta più velocemente o più lentamente :-(

Ci sono approssimazioni ragionevolmente buone per π (x). Quindi calcoli una tale approssimazione e se è troppo lontana sai che π (x) ≠ n. Ad esempio, se n ≥ x allora so che π (x) ≠ n senza calcolare nulla.

Esiste un algoritmo veloce che determina se π (x) è pari o dispari, in esecuzione in O (x ^ (1/2)). È possibile eseguire questo algoritmo e potrebbe rilevare che la parità di n è errata e il gioco è fatto. Ha una probabilità di cinquanta se n è un numero intero casuale vicino a π (x).

A parte questo, non conosco alcun metodo più veloce del calcolo di π (x). Il che è molto scomodo: se scrivo un programma che dovrebbe calcolare π (10 ^ 25) e ottengo un risultato che non è ovviamente sbagliato, allora non c'è modo di verificare che il mio risultato sia corretto se non ripetere il calcolo. E non puoi semplicemente ripetere il calcolo usando il mio programma, devi scrivere un programma diverso, altrimenti non rilevi se il mio programma ha dei bug che lo fanno calcolare una funzione leggermente diversa da π (x).

π (x) può essere calcolato ragionevolmente facilmente in circa O (n ^ (2/3)) e più velocemente con alcuni calcoli molto profondi.