Trova il resto di un grande polinomio fisso quando diviso per un piccolo polinomio sconosciuto

Supponiamo di operare in un campo finito. Ci viene dato un grande polinomio fisso p (x) (di, diciamo, grado 1000) su questo campo. Questo polinomio è noto in anticipo e ci è permesso fare calcoli usando molte risorse nella "fase iniziale". Questi risultati possono essere memorizzati in tabelle di ricerca ragionevolmente piccole.

Alla fine della "fase iniziale", ci verrà dato un piccolo polinomio sconosciuto q (x) (di, diciamo, grado 5 o meno).

Esiste un modo rapido per calcolare p (x) mod q (x) dato che ci è permesso fare alcuni calcoli complicati nella "fase iniziale"? Un modo ovvio è calcolare p (x) mod q (x) per tutti i possibili valori di q (x). C'è un modo migliore per farlo?

I seguenti algoritmi funziona bene se il campo sottostante ha un ordine molto piccolo .$s$

Supponiamo di sapere che è irriducibile, di grado fisso d . Quindi, mod q , sappiamo che x s d = x regge. Quindi è sufficiente pre-calcolare p ( x $q$$d$$q$$x^{s^d} = x$ .$p(x) \mod x^{s^d} - x$

In generale, può decomporsi in un prodotto di polinomi irriducibili q = q 1 … q r . In questo caso, un argomento simile si applica al calcolo di p modulo ogni q 1 , … , q r separatamente, e quindi mettendo insieme i risultati. Quindi abbiamo davvero bisogno di calcolare p ( x $q(x)$$q = q_1 \dots q_r$$p$$q_1, \dots, q_r$ per ogni d ′ ≤ d .$p(x) \mod x^{s^{d'}} - x$$d' \leq d$

Penso che ci sia un modo abbastanza veloce per farlo. Lascia che i coefficienti del polinomio ancora sconosciuto siano b i , quindi q = ∑ d i = 0 b i x i dove d è un numero piccolo. Ora cominciamo a calcolare $q$$b_i$$q=\sum_{i=0}^d b_ix^i$$d$ dove p = ∑ D i = 0 a i x i , dove D è grande e a i sono noti. Ciò che facciamo riducendo il grado con uguaglianze come un D x D = - un $p \pmod q$$p=\sum_{i=0}^D a_ix^i$$D$$a_i$. Alla fine ciò che otteniamo è un grado<d-1polinomiale, i cui coefficienti sono polinomi dellabi(poiché laaiè nota). Questi polinomi possiamo calcolare velocemente una volta che otteniamoq.$a_Dx^D= \frac {-a_D}{b_d} \sum_{i=1}^{d-1} b_{d-i}x^{D-i}$$<d-1$$b_i$$a_i$$q$

Vedi commenti eccellenti su questo post qui sotto. :)

pre-elaborazione; input: $p(x)$

1. Fattore come p ( x ) = ∏ 1000 i = 0 ( x i - r i ) .$p(x)$$p(x)=\prod_{i=0}^{1000} (x_i-r_i)$

2. Conservare questo come una tabella di radici distinte r j e le loro rispettive molteplicità m j .$T$$r_j$$m_j$

Fase online; input: $q(x)$

1. Fattore come q ( x ) = ∏ 5 i = 0 ( x i - r ′ i ) .$q(x)$$q(x)=\prod_{i=0}^5 (x_i-r'_i)$

2. Memorizzare questo come un elenco di radici distinte r ′ j e le rispettive molteplicità m ′ j .$L$$r'_j$$m'_j$

3. Mentre non è vuota, rimuovere la prossima radice / molteplicità da L e qualsiasi termini simili a T .$L$$L$$T$

4. Leggere dalla tabella modificata e stampare.$p(x)\bmod{q(x)}$$T$

Altri commenti:

• Ovviamente vuoi ordinare la tabella e accedervi con la ricerca binaria (o un albero).$T$
• (Sia il grado di .) Se vuoi che l'output sia nella rappresentazione dei coefficienti, puoi semplicemente fare un mucchio di FFT alla fine per ottenere tempo.p ( x ) p ( x ) mod q ( x ) ˜ O ( d $d$$p(x)$$p(x)\bmod{q(x)}$$\tilde{O}(d)$
• A seconda di come lo formalizzi, puoi probabilmente pre-calcolare molti dei vari modi in cui ricombinerai i termini in anticipo (stile di programmazione dinamica), in modo che la maggior parte (o tutte) delle moltiplicazioni siano solo ricerche. Il costo dominante è quindi il numero di ricerche, o approssimativamente . Se , questa è solo una manciata di operazioni aritmetiche concrete.O ( log d ) d = $T$$O(\log d)$$d=1000$