Les opérations de conversion

L’algorithme19de multiplication modulaire utilise RedCoeff qui introduit un facteur φ⁻¹ dans le résultat. Ainsi, le calcul du produit α1α2· · · αk, avec αi ∈ Z/pZ, en utilisant leurs représentations dans B, donne un polynôme S tel que S(γ) ≡ φ^−kQk

i=1α_i (mod p). Il est donc nécessaire de gérer cette accumulation du facteur φ⁻¹pour ne pas perdre la valeur qui est calculée, i.e.Qk

i=1α_i (mod p). Une solution simple pour gérer ce facteur est de convertir les valeurs α_i dans le domaine de Montgomery. Dans ce domaine, tout élément a ∈ Z/pZ est remplacé par aφ mod p et a une représentation A ∈ B telle que A(γ) ≡ aφ (mod p), i.e. A ≡ (aφ)_B. Ainsi, si A, B ∈ B sont respectivement les représenta-tions dans le domaine de Montgomery de a, b ∈ Z/pZ, alors RedCoeff appli-qué à V = AB mod E donne un polynôme S ∈ Zn−1[X], tel que S(γ) ≡ abφ (mod p). Donc, S est aussi dans le domaine de Montgomery.

Afin d’assurer la consistance de la multiplication modulaire dans l’AMNS, nous convertirons (et conserverons) les éléments de Z/pZ dans le domaine de Montgomery.

Pour la suite, nous supposons que :

ρ > 2wkMk∞ et φ > 2wρ(δ + 1)². Pour rappel, w = 1 + (n − 1)|λ|.

2.3.4.1 Garantie de consistance

Comme mentionné plus haut, RedCoeff n’est intéressant que si φ est une puissance de deux. Ce choix doit être fait en assurant l’existence du polynôme M⁰ = −M⁻¹ mod (E, φ). Dans les sections 2.4.3 et 2.4.4, nous donnons une condition suffisante pour garantir l’existence de ce polynôme, puis présentons des méthodes de génération du polynôme M qui respectent cette condition. Dans la remarque 2.9 plus loin, nous expliquons que cette condition implique que pgcd(E, M ) = 1 dans Q[X]. Ainsi, le corollaire 2.3 nous assure que p 6 (wkM k_∞ + 1)n. Comme ρ > 2wkM k∞, on a alors p 6 ρⁿ. Cette garantie est indispensable pour les algorithmes de conversions vers l’AMNS que nous présentons ici.

2.3.4.2 Conversion du binaire à l’AMNS

L’idée de l’algorithme 22 est d’utiliser la décomposition en base ρ de l’en-tier à convertir. Cet algorithme nécessite les représentations P_i(X) de (ρiφ2) dans B. Nous verrons comment calculer ces représentations. Cet algorithme est identique à l’algorithme 30 dans [Pla05] (section 3.2.3) sauf que la sortie et les polynômes Pi(X) sont différents ici, car les éléments doivent être dans le domaine de Montgomery.

Algorithme 22 Conversion du binaire à l’AMNS Entrée(s) : a ∈ Z/pZ et B = (p, n, γ, ρ, E) Sortie : A ∈ B, tel que A ≡ (aφ)B

1: t = (a_n−1, ..., a₀)_ρ # la décomposition en base ρ de a 2: U ← n−1 P i=0 a_iP_i(X) 3: A ← RedCoeff (U ) 4: retourner A

À la ligne 2 de l’algorithme22, U est une représentation de aφ², avec kU k∞ < nρ2. On a w > n et δ > 0, donc kU k∞ < wρ2(δ + 1)2. Ainsi, d’après la proposition 2.3, on a kAk∞ < ρ, avec A ≡ (aφ)B.

À la ligne 1 de l’algorithme22, une décomposition en base ρ, avec n chiffres, de a est effectuée. Nous avons expliqué que p6 ρn, cette décomposition est donc unique. Le coût de cette décomposition est très faible si ρ est une puissance de deux. Il est toujours possible de faire ce choix. Par exemple, on peut prendre ρ = 2^dlog2(2wkM k∞)e, car il est seulement nécessaire que ρ> 2wkM k∞. Ce choix pour ρ ajoute au maximum un bit supplémentaire pour le stockage des coefficients des éléments de l’AMNS. Sachant qu’un élément de l’AMNS est représenté avec n coefficients, cela implique donc au maximum n bits supplémentaires. Puisque n est très petit en pratique (voir les exemples d’AMNS dans l’annexe B.1), ce surcoût mémoire est négligeable.

Cet algorithme est moins coûteux qu’une multiplication modulaire dans AMNS (voir tableau2.1).

Calcul des représentations P_i. L’algorithme 22 nécessite les représenta-tions P_i(X) de (ρiφ2) dans B. Pour les calculer, nous avons besoin de la propo-sition2.4 qui permet de quantifier la réduction obtenue sur les coefficients d’un polynôme après un appel à RedCoeff.

Proposition 2.4. Soit V ∈ Zn−1[X] un polynôme. Si ρ et φ sont tels que : ρ > 2wkM k∞ et φ > 2wρ(δ + 1)2,

alors un appel à RedCoeff (avec V comme entrée) retourne un polynôme S tel que :

• kSk∞ < ^{kV k}∞

ρ , si kV k∞ > ρ2.

Démonstration. Soit S = RedCoeff(V ), i.e. S est la sortie de RedCoeff avec V comme entrée. On a kSk∞6 (kV k∞+ kT k∞)/φ. D’après la proposition 2.1, on a kT k_∞ < wφkM k_∞, car kQk_∞ < φ. Par conséquent, kSk_∞ < (kV k_∞ + wφkM k∞)/φ. On a φ > 2wρ(δ + 1)2 > 2ρ et ρ > 2wkM k∞. Donc, kSk∞ <

kV k∞

2ρ +^ρ₂. Ainsi, si kV k∞ < ρ², alors kSk∞ < ρ ; i.e. S ∈ B. Mais, si kV k∞> ρ², alors kSk∞ < ^{kV k}∞

ρ ; i.e. un appel à RedCoeff divise les coefficients de V par au moins ρ, si kV k∞ > ρ2.

Soit τ = φⁿ⁻¹ mod p. L’algorithme 23, basé sur la proposition 2.4, décrit une méthode itérative pour calculer une représentation exacte dans B d’un élément a ∈ Z/pZ. Cette idée de conversion itérative a déjà été mentionnée dans [BIP04] (section 6.1) et aussi dans [Pla05] (section 3.2.3). À la ligne 2 de Algorithme 23 Conversion exacte du binaire à l’AMNS

Entrée(s) : a ∈ Z/pZ, B = (p, n, γ, ρ, E) et τ = φⁿ⁻¹mod p Sortie : A ≡ aB, tel que kAk∞ < 2wkM k∞

1: α = a τ mod p 2: A = (α, 0, . . . , 0) # un polynôme de degré 0 3: for i = 0 to n − 2 do 4: A ← RedCoeff (A) 5: end for 6: retourner A

l’algorithme 23, A est un polynôme de degré 0 dont le coefficient constant est strictement inférieur à p. Puisque p6 ρⁿ, appeler n − 1 fois RedCoeff sur A assure que l’algorithme retourne A ∈ B, avec kAk∞ < 2wkM k∞. En effet, dans la section 2.3.4.1, nous avons expliqué que p6 (wkM k∞+ 1)n 6 (2wkM k∞)n. Donc, d’après la proposition2.4, après les n − 2 premières itérations de boucle dans l’algorithme 23, on aura kAk∞ < (2wkM k∞)2, car ρ > 2wkM k∞. Pour la dernière itération, on aura alors : kAk∞ < ((2wkM k∞)2 + wφkM k∞)/φ = (2wkM k∞)²/φ + wkM k∞. Donc, kAk∞ < 2wkM k∞, car φ > 2wρ(δ + 1)² et ρ > 2wkMk∞.

L’algorithme 23 requiert une multiplication modulaire dans Z/pZ. Cet al-gorithme ne convient donc pas pour convertir les éléments de Z/pZ dans B. En effet, l’objectif étant d’utiliser l’AMNS pour effectuer les opérations arithmé-tiques, il serait absurde d’effectuer un opération intermédiaire dans un autre système de représentation. De plus, cet algorithme est beaucoup plus coûteux que l’algorithme22, car il nécessite n−1 appels à RedCoeff. Nous ne l’utilisons donc que pour pré-calculer les représentations P_i(X).

Avec l’algorithme 23, les représentations P_i(X) peuvent être calculées de deux manières. La première (la plus simple) est de calculer chaque Pi comme la sortie de l’algorithme 23avec ρiφ2 comme entrée. La seconde méthode (plus rapide) consiste à d’abord calculer les polynômes Φ ≡ (ρφ)B et P₀ ≡ (φ2)B,

en utilisant l’algorithme 23. Ensuite, pour 1 6 i < n, Pi est calculé comme le produit de P_i−1 et Φ, en utilisant l’algorithme 19. Cette seconde approche nécessite 3n − 3 appels à RedCoeff plus deux multiplications modulaires dans Z/pZ, tandis que la première nécessite (n − 1)² appels à RedCoeff plus n multiplications modulaires dans Z/pZ.

2.3.4.3 Conversion de l’AMNS au binaire

Pour convertir un élément de l’AMNS au binaire, nous prenons en compte la conversion dans le domaine de Montgomery qui a été faite pour garantir la consistance des opérations en utilisant RedCoeff. Nous présentons ici des modifications de deux algorithmes donnés dans [Pla05] pour la conversion de l’AMNS au binaire.

Remarque 2.4. Soient A ∈ Zn−1[X] et a ∈ Z/pZ, tels que A ≡ (aφ)B. Lors du calcul de a à partir de A, on a deux options pour sortir du domaine de Montgo-mery. On peut d’abord calculer b = A(γ) mod p, puis calculer a = bφ⁻¹ mod p. On peut également calculer dans un premier temps B = RedCoeff (A), puis calculer a = B(γ) mod p.

La seconde option est moins coûteuse que la première, car elle nécessite un appel à RedCoeff alors que la première requiert une multiplication modulaire dans Z/pZ, par φ⁻¹ mod p (qu’on peut éventuellement pré-calculer). C’est donc la seconde option que nous adoptons ici.

Méthode 1. On peut facilement effectuer cette opération grâce au schéma classique d’Horner [Hor19]. L’algorithme 24 est une légère modification de l’al-gorithme 31 dans [Pla05] (section 3.2.3). Par rapport à cet algorithme, nous ajoutons la ligne 1 pour sortir du domaine de Montgomery. L’algorithme 24 a donc un coût supplémentaire d’un appel à RedCoeff.

Algorithme 24 Conversion de l’AMNS au binaire Entrée(s) : A ∈ Zn−1[X] et B = (p, n, γ, ρ, E) Sortie : a ∈ Z/pZ, tel que a = A(γ)φ⁻¹ mod p

1: A ← RedCoeff (A) 2: a ← an−1 3: for i = n − 2 to 0 do 4: a ← (aγ + a_i) mod p 5: end for 6: retourner a

Méthode 2. L’algorithme24est simple et ne nécessite aucun pré-calcul. Ce-pendant, il nécessite n − 1 multiplications modulaires et un appel à RedCoeff. L’algorithme 25 améliore l’algorithme 24 au prix de quelques pré-calculs. Les valeurs g_i = γi mod p, pour i = 1, . . . , (n − 1), doivent être pré-calculées avant de l’utiliser. Cet algorithme est une légère modification de l’algorithme 32 dans

[Pla05] (section 3.2.3). Par rapport à cet algorithme, nous ajoutons la ligne 1 pour sortir du domaine de Montgomery. L’algorithme 25 a donc un coût sup-plémentaire d’un appel à RedCoeff.

Algorithme 25 Conversion de l’AMNS au binaire

Entrée(s) : A ∈ Zn−1[X], B = (p, n, γ, ρ, E) et g_i = γi mod p, pour i = 1, . . . , (n − 1)

Sortie : a ∈ Z/pZ, tel que a = A(γ)φ⁻¹ mod p

1: A ← RedCoeff (A) 2: a ← a₀ 3: for i = 1 to n − 1 do 4: a ← a + a_ig_i 5: end for 6: a ← a mod p 7: retourner a

Dans cet algorithme, n − 1 multiplications et une réduction modulaire sont effectuées (plus un appel à RedCoeff ). Si A ∈ B, alors |ai| < ρ. Ainsi, les multiplications a_ig_ine sont pas des multiplications complètes dans Z/pZ. Aussi, à la fin de la boucle (avant la ligne 6), nous avons |a| < (nρ)p. Comme ρ ≈ p1/n, la réduction modulaire à la ligne 6 est moins chère qu’une réduction modulaire complète dans Z/pZ.