Como o anel interno é escolhido no algoritmo de Schönhage – Strassen?

Eu tenho tentado implementar o algoritmo de multiplicação de números inteiros Schönhage-Strassen, mas atingi um obstáculo na etapa recursiva.

Eu tenho um valor com bits e quero calcular x ^ 2 \ pmod {2 ^ n + 1} . Eu originalmente pensei que a idéia era escolher um k tal que 4 ^ k \ geq 2n , dividir x em 2 ^ k pedaços cada um com 2 ^ {k-1} bits, aplicar a convolução da SSA enquanto trabalhava no módulo 2 ^ {2 ^ k} +1 , um anel com 2 ^ k bits de capacidade por valor e, em seguida, reinstale as peças. No entanto, a saída da convolução tem um pouco mais de 2n bits (ou seja, > 2 ^ kn x $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 por valor de saída, que é mais do que a capacidade do anel, devido a cada valor de saída ser uma soma de vários produtos) para que isso não funcione. Eu tive que adicionar um fator extra de 2 de preenchimento.

Esse fator extra de 2 no preenchimento arruina a complexidade. Isso torna meu passo recursivo muito caro. Em vez de um $F(n) = n \lg n + \sqrt{n} F(2 \sqrt{n}) = \Theta(n \; \lg n \; \lg \lg n)$ , acabo com um algoritmo $F(n) = n \lg n + \sqrt{n} F(4 \sqrt{n}) = \Theta(n \lg^2 n)$ .

Li algumas referências vinculadas da wikipedia, mas todas parecem encobrir os detalhes de como esse problema foi resolvido. Por exemplo, eu poderia evitar a sobrecarga do preenchimento extra trabalhando no módulo $2^{p 2^k} + 1$ para um $p$ que não é uma potência de 2 ... mas depois as coisas quebram mais tarde, quando eu tenho apenas de-2 fatores restantes e não pode aplicar o Cooley-Tukey sem dobrar o número de peças. Além disso, $p$ pode não ter um módulo inverso multiplicativo $2^p+1$ . Portanto, ainda há fatores forçados de 2 sendo introduzidos.

Como escolho o anel para usar durante a etapa recursiva, sem soprar a complexidade assintótica?

Ou, na forma de pseudo-có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 resposta é retirada do artigo "Algoritmos assintoticamente rápidos para a multiplicação e divisão numérica de polinômios com coeficientes complexos" que Markus vinculou nos comentários.

---

Você deseja quadrado um número de bits, módulo . Aqui está o que você faz:2 n + $n$$2^n + 1$

• Encontrar e que satisfazem e .s n = ( p - 1 ) 2 s s ≤ p ≤ 2 $p$$s$$n = (p-1) 2^s$$s \leq p \leq 2s$

• Escolha o número de peças para dividir os bits e os parâmetros correspondentes para os tamanhos das peças:$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}$$

  Observe que e$s_2$$p_2$ continuam satisfazendo os invariantes . Observe também que 2 m 2 s 2 p 2 ≥ 2 n + m + 1 é satisfeito, portanto a entrada se encaixa com espaço para transporte.$s_2 \leq p_2 \leq 2 s_2$$2^m 2^{s_2} p_2 \geq 2n + m + 1$

• Realize a convolução negacíclica baseada na FFT nas peças e no restante, como de costume.

Então essa é a ideia geral: um fator de preenchimento logarítmico . Agora, para a análise de complexidade. A FFT levará n m trabalho a fazer, e estamos recorrendo em peças de 2 m de tamanho ( p 2 - 1 ) 2 s 2 , para que agora possamos fazer contas extremamente grosseiras com a relação de recorrência wrt s :$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}$$

O que parece certo, embora eu tenha trapaceado bastante nessas etapas.

O "truque" parece ser o fato de acabarmos com vez de s no custo base. Ainda existem duas multiplicações por duas por nível recursivo, como eu estava reclamando na pergunta, mas agora a metade de s está pagando dividendos duplos, para que tudo dê certo. Então, no final, cancelamos o fator extra de s (que na verdade é um fator de log n ), graças a tornar p logaritmicamente grande em relação a s inicialmente.$s^2$$s$$s$$s$$\log n$$p$$s$