Comment la bague intérieure est-elle choisie dans l'algorithme Schönhage – Strassen?

J'ai essayé d'implémenter l'algorithme de multiplication de Schönhage – Strassen, mais j'ai rencontré une pierre d'achoppement à l'étape récursive.

J'ai une valeur avec n bits et je veux calculer . Je pensais à l'origine que l'idée était de choisir un tel que , diviser en morceaux chacun avec bits, appliquer la convolution de SSA tout en travaillant modulo , un anneau avec bits de capacité par valeur, puis remontez les morceaux. Cependant, la sortie de la convolution a un peu plus de bits (c'est-à-dire$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$bits par valeur de sortie, ce qui est supérieur à la capacité de l'anneau, car chaque valeur de sortie étant une somme de plusieurs produits), cela ne fonctionne donc pas. J'ai dû ajouter un facteur supplémentaire de 2 de rembourrage.

Ce facteur supplémentaire de 2 dans le rembourrage ruine la complexité. Cela rend mon étape récursive trop chère. Au lieu d'un algorithme , je me retrouve avec un algorithme .$F(n) = n \lg n + \sqrt{n} F(2 \sqrt{n}) = \Theta(n \; \lg n \; \lg \lg n)$$F(n) = n \lg n + \sqrt{n} F(4 \sqrt{n}) = \Theta(n \lg^2 n)$

J'ai lu quelques références liées à partir de wikipedia, mais elles semblent toutes masquer les détails de la façon dont ce problème est résolu. Par exemple, je pourrais éviter la surcharge de remplissage supplémentaire en travaillant modulo pour un qui n'est pas une puissance de 2 ... mais alors les choses se cassent plus tard, quand je n'ai que de la non-puissance- de-2 facteurs restants et ne peuvent pas appliquer Cooley-Tukey sans doubler le nombre de pièces. De plus, peut ne pas avoir un modulo inverse multiplicatif . Il y a donc toujours des facteurs forcés de 2 introduits.$2^{p 2^k} + 1$$p$$p$$2^p+1$

Comment choisir la bague à utiliser lors de l'étape récursive, sans souffler la complexité asymptotique?

Ou, sous forme de pseudo code:

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);
  ...

Cette réponse est tirée de l'article «Algorithmes asymptotiquement rapides pour la multiplication numérique et la division de polynômes à coefficients complexes» que Markus a lié dans les commentaires.

---

Vous voulez mettre au carré un nombre à bits, modulo . Voici ce que vous faites:$n$$2^n + 1$

• Trouvez et qui satisfont et .$p$$s$$n = (p-1) 2^s$$s \leq p \leq 2s$

• Choisissez le nombre de pièces pour diviser les bits et les paramètres correspondants pour les tailles de pièces:$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}$$

  Notez que et continuent de satisfaire l' . Notez également que est satisfait, donc l'entrée correspond à la place pour les reports.$s_2$$p_2$$s_2 \leq p_2 \leq 2 s_2$$2^m 2^{s_2} p_2 \geq 2n + m + 1$

• Effectuez la convolution négacyclique basée sur la FFT sur les pièces et le reste, comme d'habitude.

Voilà donc l'idée générale: un facteur de remplissage logarithmique . Maintenant pour l'analyse de complexité. La FFT nécessitera un travail de , et nous récursions sur des pièces de de taille , donc maintenant nous pouvons faire des calculs extrêmement approximatifs avec la relation de récurrence 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}$$

Ce qui semble correct, même si j'ai beaucoup triché dans ces étapes.

Le «truc» semble être le fait que nous nous retrouvons avec au lieu de dans le coût de base. Il y a encore deux multiplications par deux par niveau récursif, comme je me plaignais de la question, mais maintenant la réduction de moitié de paie des doubles dividendes, donc tout fonctionne. Ensuite, à la fin, nous annulons le facteur supplémentaire de (qui est en fait un facteur de ) grâce à la taille de logarithmiquement grande par rapport à initialement.$s^2$$s$$s$$s$$\log n$$p$$s$