Come viene scelto l'anello interno nell'algoritmo di Schönhage – Strassen?

Ho cercato di implementare l'algoritmo di moltiplicazione di interi Schönhage-Strassen, ma ho colpito un ostacolo nel passaggio ricorsivo.

Ho un valore con bit e voglio calcolare x ^ 2 \ pmod {2 ^ n + 1} . Inizialmente pensavo che l'idea fosse quella di scegliere un k tale che 4 ^ k \ geq 2n , dividere x in 2 ^ k pezzi ciascuno con 2 ^ {k-1} bit, applicare la convoluzione di SSA mentre si lavora modulo 2 ^ {2 ^ k} +1 , un anello con 2 ^ k bit di capacità per valore, quindi rimettere insieme i pezzi. Tuttavia, l'output della convoluzione ha poco più di 2n bit (ovvero > 2 ^ k$x$$n$$x^2 \pmod {2^n+1}$$k$$4^k \geq 2n$$x$$2^k$$2^{k-1}$$2^{2^k}+1$$2^k$$2n$$>2^k$bit per valore di uscita, che è superiore alla capacità dell'anello, poiché ciascun valore di uscita è una somma di più prodotti), quindi non funziona. Ho dovuto aggiungere un ulteriore fattore di 2 di imbottitura.

Quel fattore aggiuntivo di 2 nell'imbottitura rovina la complessità. Rende il mio passaggio ricorsivo troppo costoso. Invece di un algoritmo $F(n) = n \lg n + \sqrt{n} F(2 \sqrt{n}) = \Theta(n \; \lg n \; \lg \lg n)$ , finisco con un algoritmo $F(n) = n \lg n + \sqrt{n} F(4 \sqrt{n}) = \Theta(n \lg^2 n)$ .

Ho letto alcuni riferimenti collegati da Wikipedia, ma tutti sembrano sorvolare i dettagli di come questo problema è stato risolto. Ad esempio, potrei evitare il sovraccarico di imbottitura extra lavorando modulo $2^{p 2^k} + 1$ per una $p$ che non è una potenza di 2 ... ma poi le cose si rompono più tardi, quando ho solo non-power- di 2 fattori rimanenti e non è possibile applicare Cooley-Tukey senza raddoppiare il numero di pezzi. Inoltre, $p$ potrebbe non avere un modulo moltiplicativo inverso $2^p+1$ . Quindi ci sono ancora fattori forzati per l'introduzione di 2.

Come scelgo l'anello da usare durante la fase ricorsiva, senza soffiare sulla complessità asintotica?

Oppure, in forma di pseudo codice:

multiply_in_ring(a, b, n):
  ...
  // vvv                          vvv //
  // vvv HOW DOES THIS PART WORK? vvv //
  // vvv                          vvv //
  let inner_ring = convolution_ring_for_values_of_size(n);
  // ^^^                          ^^^ //
  // ^^^ HOW DOES THIS PART WORK? ^^^ //
  // ^^^                          ^^^ //

  let input_bits_per_piece = ceil(n / inner_ring.order);
  let piecesA = a.splitIntoNPiecesOfSize(inner_ring.order, input_bits_per_piece);
  let piecesB = b.splitIntoNPiecesOfSize(inner_ring.order, input_bits_per_piece);

  let piecesC = inner_ring.negacyclic_convolution(piecesA, piecesB);
  ...

Questa risposta è tratta dall'articolo "Algoritmi asintoticamente veloci per la muitiplicazione numerica e la divisione di polinomi con coefficienti complessi" che Markus ha collegato nei commenti.

---

Vuoi quadrare un numero bit, modulo . Ecco cosa fai:$n$$2^n + 1$

• Trova e che Satisfy e .$p$$s$$n = (p-1) 2^s$$s \leq p \leq 2s$

• Scegli il numero di pezzi in cui dividere gli bit e i parametri corrispondenti per le dimensioni del pezzo:$2^m$$n$

  $$\begin{align} m &= \lfloor s/2 \rfloor + 1 \\s_2 &= \lceil s/2 \rceil + 1 \\ p_2 &= \lceil p/2 \rceil + 1 \end{align}$$

  Si noti che e continuano a soddisfare l' invariante . Si noti inoltre che è soddisfatto, quindi l'ingresso si adatta con spazio per carry.$s_2$$p_2$$s_2 \leq p_2 \leq 2 s_2$$2^m 2^{s_2} p_2 \geq 2n + m + 1$

• Esegui la convoluzione negaciclica basata su FFT sui pezzi e il resto, come al solito.

Quindi questa è l'idea generale: un fattore di imbottitura logaritmica . Ora per l'analisi della complessità. La FFT impiegherà lavoro da fare e stiamo ricorrendo a pezzi di dimensioni , quindi ora possiamo fare matematica estremamente approssimativa con la relazione di ricorrenza wrt :$p$$n m$$2^m$$(p_2-1) 2^{s_2}$$s$

$$\begin{align} F(s) &(\leq)\; (p-1)2^sm + 2^m F(\lceil s/2\rceil+1) \\ &(\leq)\; 2s2^s (\lfloor s/2\rfloor+1) + 2^{\lfloor s/2\rfloor+1} F(\lceil s/2\rceil+1) \\ &(\leq)\; s^2 2^s + 2 \cdot 2^{s/2} F(s/2+1) \\ &(\leq)\; s^2 2^s + 4 (s/2)^2 2^s + 16(s/4)^2 2^s + ... \\ &(\leq)\; 2^s s^2 \lg(s) \\ &(\leq)\; \frac{n}{\lg n} \left(\lg \frac{n}{\lg n}\right)^2 \lg \lg \frac{n}{\lg n} \\ &(\leq)\; \frac{n}{\lg n} (\lg^2 n) \lg \lg n \\ &(\leq)\; n \;(\lg n) \lg \lg n \end{align}$$

Il che sembra giusto, anche se ho barato parecchio in quei passaggi.

Il "trucco" sembra essere il fatto che finiamo con invece di nel costo base. Ci sono ancora due moltiplicazioni per due per livello ricorsivo, come mi stavo lamentando nella domanda, ma ora la metà di sta pagando i doppi dividendi, quindi tutto funziona. Quindi, alla fine, cancelliamo il fattore aggiuntivo di (che in realtà è un fattore di ) grazie a rendere inizialmente logaritmicamente grande rispetto a inizialmente.$s^2$$s$$s$$s$$\log n$$p$$s$