¿Cómo se elige el anillo interno en el algoritmo Schönhage – Strassen?

He estado tratando de implementar el algoritmo de multiplicación de enteros de Schönhage-Strassen, pero me topé con un obstáculo en el paso recursivo.

Tengo un valor con bits y quiero calcular x ^ 2 \ pmod {2 ^ n + 1} . Originalmente pensé que la idea era elegir una k tal que 4 ^ k \ geq 2n , dividir x en 2 ^ k piezas cada una con 2 ^ {k-1} bits, aplicar la convolución de SSA mientras se trabaja el módulo 2 ^ {2 ^ k} +1 , un anillo con 2 ^ k bits de capacidad por valor, luego vuelve a juntar las piezas. Sin embargo, la salida de la convolución tiene un poco más de 2n bits (es decir, > 2 ^ k$x$$n$$x^2 \pmod {2^n+1}$4 k ≥ 2 n x 2 k 2 k - 1 2 2 k + 1 2 k 2 n > 2 $k$$4^k \geq 2n$$x$$2^k$$2^{k-1}$$2^{2^k}+1$$2^k$$2n$$>2^k$bits por valor de salida, que es más que la capacidad del anillo, debido a que cada valor de salida es una suma de varios productos), por lo que esto no funciona. Tuve que agregar un factor adicional de 2 de relleno.

Ese factor adicional de 2 en el relleno arruina la complejidad. Hace que mi paso recursivo sea demasiado caro. En lugar de un algoritmo $F(n) = n \lg n + \sqrt{n} F(2 \sqrt{n}) = \Theta(n \; \lg n \; \lg \lg n)$ , termino con un algoritmo $F(n) = n \lg n + \sqrt{n} F(4 \sqrt{n}) = \Theta(n \lg^2 n)$ .

Leí algunas referencias vinculadas desde wikipedia, pero todas parecen pasar por alto los detalles de cómo se resuelve este problema. Por ejemplo, podría evitar la sobrecarga de relleno adicional trabajando el módulo $2^{p 2^k} + 1$ para un $p$ que no es una potencia de 2 ... pero luego las cosas se rompen más tarde, cuando solo tengo no poder- de-2 factores restantes y no se puede aplicar Cooley-Tukey sin duplicar el número de piezas. Además, $p$ puede no tener un módulo inverso multiplicativo $2^p+1$ . Entonces todavía hay factores forzados de 2 introducidos.

¿Cómo elijo el anillo para usar durante el paso recursivo, sin soplar la complejidad asintótica?

O, en forma de pseudocódigo:

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

Esta respuesta está tomada del documento "Algoritmos asintóticamente rápidos para la muitiplicación numérica y la división de polinomios con coeficientes complejos" que Markus vinculó en los comentarios.

---

Desea elevar al cuadrado un número de bits, módulo . Esto es lo que haces:2 n + $n$$2^n + 1$

• Encuentra y que satisfacen y .s n = ( p - 1 ) 2 s s ≤ p ≤ 2 $p$$s$$n = (p-1) 2^s$$s \leq p \leq 2s$

• Elija el número de piezas para dividir los bits y los parámetros correspondientes para los tamaños de pieza:$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}$$

  Tenga en cuenta que y continúan satisfaciendo la invariante . También tenga en cuenta que está satisfecho, por lo que la entrada se ajusta con espacio para acarreos.p $s_2$$p_2$2 m 2 s 2 p 2 ≥ 2 n + m + $s_2 \leq p_2 \leq 2 s_2$$2^m 2^{s_2} p_2 \geq 2n + m + 1$

• Realice la convolución negacyclic basada en FFT en las piezas y el resto, como de costumbre.

Esa es la idea general: un factor de relleno logarítmico . Ahora para el análisis de complejidad. La FFT se llevará trabajo por hacer, y estamos recursividad en piezas de tamaño , por lo que ahora podemos hacer operaciones matemáticas muy duro con la recurrencia relación WRT :n m 2 m ( p 2 - 1 ) 2 s 2$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}$$

Lo cual parece correcto, aunque hice trampa en esos pasos.

El 'truco' parece ser el hecho de que terminamos con lugar de en el costo base. Todavía hay dos multiplicaciones por dos por nivel recursivo, como me estaba quejando en la pregunta, pero ahora la reducción a la mitad de está pagando dividendos dobles, por lo que todo funciona. Luego, al final, cancelamos el factor adicional de (que en realidad es un factor de ) gracias a que inicialmente logarítmicamente es grande en relación con .$s^2$$s$$s$$s$$\log n$$p$$s$