Moltiplicazione in

10

Stavo guardando qui e ho notato che il miglior runtime per la moltiplicazione di due numeri -bit è , ma posso facilmente notare un algoritmo che gira in . $n$ $O(n\cdot \log n \cdot 2^{O(\log^* n)}$ $O(n\cdot \log n)$

Dopotutto, sappiamo come moltiplicare due polinomi dal grado in runtime . Ma moltiplicando polinomi è lo stesso di moltiplicare due numeri -bits. Così abbiamo un algoritmo per moltiplicare due numeri -bits a . Ora l'unico problema che potrebbe verificarsi è il carry, ma in ogni fase possiamo risolverlo nel tempo , spostandoci semplicemente sul bit più a destra e sul suo vicino di sinistra, fino alla fine. Cioè, il nostro tempo di esecuzione deve rimanere $n$ $O(n \log n)$ $n$ $n$ $O(n \log n )$ $O(n)$ . $O(n \cdot \log n)$

Quindi ho fatto una nuova (e abbastanza ovvia) scoperta? O la pagina di Wikipedia non è aggiornata? O forse ho qualche errore?

runtime-analysis

— TheEmeritus
fonte

In che modo "sappiamo" "moltiplicare due polinomi dal grado

in runtime

"?

n

$n$

O (n \log n)

$O(n \log n)$

$\hspace{.46 in}$

8

Come già sottolineato da @DavidRicherby, la confusione sorge perché diverse misure di complessità si stanno confondendo. Ma lasciami elaborare un po '.

Di solito, quando si studiano algoritmi per la moltiplicazione polinomiale su anelli arbitrari, si è interessati al numero di operazioni aritmetiche nell'anello utilizzate da un algoritmo. In particolare, dati alcuni anello (commutativo, unitario) e due polinomi di grado inferiore a , l'algoritmo di Schönhage-Strassen necessita di moltiplicazioni e aggiunte in per calcolare $R$ $f,g \in R[X]$ $n$ $O(n \log{n} \log{\log{n}})$ $R$ $fg \in R[X]$ da, approssimativamente, adiacente -esimo radici primitive di unità di per ottenere qualche grande anello e quindi, mediante la trasformata di Fourier su , calcolando il prodotto . $n$ $R$ $D \supset R$ $D$ $D$

Se l'anello contiene un radice -esimo di unità, allora questo può essere accelerato a operazioni in utilizzando Fast Fourier Transform direttamente sopra . Più specificamente, su , puoi farlo usando le operazioni dell'anello (ignorando il fatto che ciò richiederebbe un'aritmetica esatta sui numeri complessi). $n$ $O(n \log n)$ $R$ $R$ $\mathbb{Z} \subset \mathbb{C}$ $O(n \log n)$

L'altra misura che può essere presa in considerazione è la complessità dei bit di un'operazione. E questo è ciò che ci interessa quando si moltiplicano due numeri interi di lunghezza bit . Qui, le operazioni primitive si stanno moltiplicando e aggiungendo due cifre (con carry). Quindi, quando si moltiplicano due polinomi su , in realtà è necessario tenere conto del fatto che i numeri che sorgono durante il calcolo non possono essere moltiplicati utilizzando un numero costante di operazioni primitive. Questo e il fatto che non abbia una -esima radice primitiva di unità per ti impedisce di applicare $n$ $\mathbb{Z}$ $\mathbb{Z}$ $n$ $n > 2$ $O(n \log n)$ algoritmo. Superare questo considerando con coefficienti dall'anello , dato che i coefficienti del polinomio prodotto non supererà questo vincolato. Lì (quando è una potenza di due), hai (la classe di congruenza di) come -esima radice di unità, e chiamando ricorsivamente l'algoritmo per le moltiplicazioni dei coefficienti, puoi ottenere un totale di primitive (cioè bit). Questo quindi passa alla moltiplicazione dei numeri interi. $f,g$ $\mathbb{Z}/\langle 2^n + 1 \rangle$ $n$ $2$ $n$ $O(n \log n \log \log n)$

Per un esempio che evidenzi bene l'importanza della differenza tra operazioni ad anello e operazioni primitive, considera due metodi per valutare i polinomi: il metodo di Horner e il metodo di Estrin. Il metodo di Horner valuta un polinomio ad alcuni sfruttando l'identità $f = \sum_{i=0}^n f_i X^i$ $x \in \mathbb{Z}$ mentre il metodo di Estrin divide in due parti e cioè, contiene i termini del grado e i termini di grado (assumere

f (x) = (\dots (f_{n} x + f_{n - 1}) x + \dots + \dots) + f_{0}

$f(x) = (\ldots (f_n x + f_{n-1})x + \ldots + \ldots) + f_0$

f

$f$

H = \sum_{i = 1}^{n / 2} f_{n / 2 + i} X^{i}

$H = \sum_{i=1}^{n/2} f_{n/2+i} X^i$

L = \sum_{i = 0}^{n / 2} f_{i} X^{i}

$L = \sum_{i=0}^{n/2} f_{i} X^i$

H

$H$

> n / 2

$>n/2$

L

$L$

\leq n / 2

$\leq n/2$

n

$n$ è un potere di due, per semplicità).

Quindi, possiamo calcolare usando e applicando l'algoritmo in modo ricorsivo. $f(x)$

f (x) = H (x) x^{n / 2} + L (x)

$f(x) = H(x)x^{n/2} + L(x)$

Il primo, usando addizioni e moltiplicazioni, si è dimostrato ottimale rispetto al numero di addizioni e moltiplicazioni (ovvero operazioni ad anello), il secondo ha bisogno di più (almeno ). $n$ $n + \log n$

$n/2$ $n/2$ $\Omega(n^2)$ $n$ $O(n)$ $O(n \log^c n) = \tilde{O}(n)$ $c > 0$

— Marchio Cornelius
fonte

9

$n$ $O(n\log n)$ $n$ $O(2^{\log^*n}n\log n)$ $n$ $O(n\log n)$

— David Richerby
fonte

5

Non penso che questo sia il problema. Se pensiamo numeri come polinomi i cui "x" è la base, ad esempio 2, quindi tipicamente si può moltiplicare gradi da zero polinomi (numeri più piccoli rispetto alla base) nel tempo costante. Immagino che il problema sia che l'algoritmo O (n * log n) utilizza FFT e all'interno dell'algoritmo FFT potrebbero emergere numeri asintoticamente più grandi.

— jkff,