Multiplicação em

10

Eu estava olhando aqui e notei que o melhor tempo de execução para multiplicação de dois números de bits é , mas posso notar facilmente um algoritmo executado em . $n$ $O(n\cdot \log n \cdot 2^{O(\log^* n)}$ $O(n\cdot \log n)$

Afinal, sabemos como multiplicar dois polinômios do grau no tempo de execução . Mas multiplicar polinômios é o mesmo que multiplicar dois números de bits. Portanto, temos um algoritmo para multiplicar dois números de bits em . Agora, o único problema que pode ocorrer é o carry, mas em cada fase podemos consertar isso em tempo, simplesmente movendo o bit mais à direita e seu vizinho esquerdo, até o fim. Ou seja, nosso tempo de execução permanecerá . $n$ $O(n \log n)$ $n$ $n$ $O(n \log n )$ $O(n)$ $O(n \cdot \log n)$

Então, eu fiz uma nova descoberta (e bastante óbvia)? Ou a página da Wikipedia está desatualizada? Ou talvez eu tenha algum erro?

runtime-analysis

— TheEmeritus
fonte

Qual é a maneira pela qual "sabemos" "multiplicar dois polinômios do grau no tempo de execução "?

n

$n$

O (n \log n)

$O(n \log n)$

$\hspace{.46 in}$

8

Como o @DavidRicherby já aponta, a confusão surge porque diferentes medidas de complexidade estão se misturando. Mas deixe-me elaborar um pouco.

Geralmente, ao estudar algoritmos para multiplicação polinomial por anéis arbitrários, interessa-se o número de operações aritméticas no anel que um algoritmo usa. Em particular, dado alguns anéis (comutativos, unitários) e dois polinômios de grau menor que , o algoritmo Schönhage-Strassen precisa de multiplicações e adições em para calcular , aproximando-se da ésima raiz primitiva da unidade de para para obter um anel maior e, em seguida, usando o Fast Transformada de Fourier sobre $R$ $f,g \in R[X]$ $n$ $O(n \log{n} \log{\log{n}})$ $R$ $fg \in R[X]$ $n$ $R$ $D \supset R$ $D$ , Calculando o produto em . $D$

Se o anel contém um raiz -ésimo de unidade, então este pode ser acelerado para operações em , usando a Fast Fourier Transform directamente sobre . Mais especificamente, em , você pode fazer isso usando operações de anel (ignorando o fato de que isso exigiria aritmética exata sobre os números complexos). $n$ $O(n \log n)$ $R$ $R$ $\mathbb{Z} \subset \mathbb{C}$ $O(n \log n)$

A outra medida que pode ser levada em consideração é a complexidade de bits de uma operação. E é nisso que estamos interessados ao multiplicar dois números inteiros de comprimento de bit . Aqui, as operações primitivas estão se multiplicando e adicionando dois dígitos (com carry). Portanto, ao multiplicar dois polinômios sobre , é necessário levar em consideração o fato de que os números que surgem durante o cálculo não podem ser multiplicados usando um número constante de operações primitivas. Isso e o fato de que não possui a ésima raiz primitiva da unidade para impede que você aplique o algoritmo . Você supera isso considerando $n$ $\mathbb{Z}$ $\mathbb{Z}$ $n$ $n > 2$ $O(n \log n)$ $f,g$ com coeficientes do anel , pois os coeficientes do polinômio do produto não excederão esse limite. Lá (quando é uma potência de dois), você tem (a classe de congruência de) como a ésima raiz da unidade e, chamando recursivamente o algoritmo para multiplicações de coeficientes, você pode obter um total de ) operações primitivas (isto é, bit). Isso então é transferido para a multiplicação inteira. $\mathbb{Z}/\langle 2^n + 1 \rangle$ $n$ $2$ $n$ $O(n \log n \log \log n)$

Para um exemplo que destaca bem a importância da diferença entre operações em anel e operações primitivas, considere dois métodos para avaliar polinômios: o método de Horner e o método de Estrin. O método de Horner avalia um polinômio em algum explorando a identidade enquanto de Estrin método divide em duas partes e ie, contém os termos de grau e os termos de grau $f = \sum_{i=0}^n f_i X^i$ $x \in \mathbb{Z}$

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$ (suponha que é uma potência de dois, por simplicidade).

n

$n$

Então, podemos calcular usando e aplicando o algoritmo recursivamente. $f(x)$

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

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

O primeiro, usando adições e multiplicações, provou ser ótimo em relação ao número de adições e multiplicações (isto é, operações em anel), o último precisa de mais (pelo menos ). $n$ $n + \log n$

Mas, no nível das operações de bits, pode-se (facilmente) mostrar que, no pior dos casos, o método de Horner realiza multiplicações de números de tamanho pelo menos , levando a muitos bits operações (isso ocorre mesmo se assumirmos que dois números de bits podem ser multiplicados no tempo ), enquanto o esquema de Estrin usa operações para algumas operações , que é, de longe, assintoticamente mais rápido. $n/2$ $n/2$ $\Omega(n^2)$ $n$ $O(n)$ $O(n \log^c n) = \tilde{O}(n)$ $c > 0$

— Cornelius Brand
fonte

9

Dizer que você pode multiplicar dois polinômios de grau no tempo implica que, em particular, você pode multiplicar polinômios de grau zero, ou seja, constantes, em tempo constante. Claramente, portanto, as afirmações "multiplicar números de bits leva tempo " e "multiplicar graus polinômios leva tempo " são relativas diferentes modelos de computação, portanto não são diretamente comparáveis. $n$ $O(n\log n)$ $n$ $O(2^{\log^*n}n\log n)$ $n$ $O(n\log n)$

— David Richerby
fonte

5

Eu não acho que esse seja o problema. Se pensarmos números como polinómios cujos "x" é a base de, por exemplo 2, em seguida, tipicamente, que pode multiplicar graus diferentes de zero polinomiais (números menores do que a base) em tempo constante. Eu acho que o problema é que o algoritmo O (n * log n) usa FFT e números assintoticamente maiores podem surgir dentro do algoritmo FFT.

— Jkff