GivaroZpz : base de Montgomery

Une autre implantation de la biblioth`eque Givaro est bas´ee sur l’utilisation de la repr´ esenta-tion de Montgomery. En 1985 Peter. L. Montgomery a propos´e un algorithme de multiplication modulaire pour des moduli g´en´eriques sans aucune division [59]. Le principe de cet algorithme est de changer la repr´esentation des entiers en les multipliant par une puissance de la base de re-pr´esentation et d’utiliser l’´equation de Bezout pour remplacer la division par un simple d´ecalage.

Soient x, y∈Z tels quex=Pk

i=0x_ibⁱ ety=Pk

i=0y_ibⁱ, soitr =b^s tel quer > p > x, y alors la repr´esentation dex ety dans la base de Montgomery est ¯x=xr mod p et ¯y=yr mod p. Soit z≡xy mod palors la repr´esentation dezdans la base de Montgomery doit ˆetre ´equivalente au produit de ¯x et ¯y. L’algorithme propos´e par Montgomery permet de satisfaire cette ´equivalence.

Algorithme Montgomery-Multmod(¯x,¯y,p,r) Entr´ees : x¯=xr mod p, ¯y=yr mod p,p,r Sortie : x¯¯yr⁻¹ mod p=xyr mod p

Conditions : x, y < p < r=b^s, pgcd(p, r) = 1 Pr´ecalculs :p⁰= (−p)⁻¹ mod r

q:= (¯xy¯ mod r)p⁰ modr t:= (¯xy¯+pq)/r

si(t≥p) alors t:=t−p retourner t;

Lemme 2.2.1. Soientx, y∈Zp etr une puissance de la base de repr´esentation dex etytel que p < r et pgcd(p, r) = 1. Si l’on connaˆıt p⁰ = (−p)⁻¹ mod r alors la multiplication de x par y modulop s’effectue `a partir de 2 multiplications, 1 d´ecalage et une addition grˆace `a l’algorithme Montgomery-Multmod.

Preuve. Pour prouver que l’algorithmeMontgomery-Multmod est correct il faut montrer que

¯

xy¯+qp est divisible par r et que le r´esultat est born´e par 2p car par construction t ≡ x¯¯yr⁻¹ mod p. En rempla¸cant la variable q par sa valeur dans l’expression ¯xy¯+qp on peut ´ecrire l’´equation suivante :

¯

x¯y+qp ≡ x¯y¯+ ¯xyp¯ ⁰p mod r²

≡ x¯y(1 +¯ pp⁰) mod r².

En utilisant l’´equation de Bezoutrr⁰−pp⁰ = 1 on obtient ¯x¯y+qp≡x¯yrr¯ ⁰ mod r², ce qui signifie que ¯xy¯+qp est bien divisible parr. Par hypoth`ese, on sait que ¯x,y < p < b¯ et par construction de q on a q < r. On peut donc borner la valeur de tpar

t <(p²+pr)/r <(2pr)/r <2p.

2.2. Corps finis premiers 51 Les seules op´erations effectu´ees durant cet algorithme sont 2 multiplications, 1 addition et 1 soustraction. Du fait quer est une puissance de la base de repr´esentation, les op´erations de r´eduction modulo r et de division par r s’effectuent respectivement `a partir d’un masque bit `a bit et d’un d´ecalage.

L’implantation propos´ee par la biblioth`eque Givaro est donc bas´ee sur une repr´esentation des

´el´ements dans la base de Montgomery, c’est-`a-dire que pour un entierx∈Zp, sa repr´esentation est x.2<sup>s</sup> mod p tel que p < 2<sup>s</sup> avec 2<sup>s</sup> la base de Montgomery. Les op´erations d’addition et de soustraction sont effectu´ees de fa¸con classique (op´eration puis r´eduction) du fait que la loi additive est converv´ee par la repr´esentation (x+y mod p→x2<sup>s</sup>+y2<sup>s</sup> mod p). L’op´eration de multiplication est implant´ee par l’algorithme Montgomery-Multmod qui conserve les propri´et´es de la repr´esentation. Toutefois, l’op´eration d’inversion n´ecessite une implantation particuli`ere car l’inverse modulaire classique par r´esolution de l’´equation de Bezout ne conserve pas la repr´ esen-tation : (x.2^s)⁻¹ mod p 6≡ x⁻¹2^s mod p. L’implantation propos´ee par la biblioth`eque Givaro consiste `a corriger le r´esultat obtenu par l’inversion classique en le multipliant par une puissance de la base de Montgomery. En utilisant l’algorithmeMontgomery-Multmod pour effectuer cette correction, il faut alors choisir le cube de la base de Montgomery.

Montgomery−Multmod(2^3s modp,(x2^s)⁻¹ modp,p,2^s) =x⁻¹2^s modp.

L’utilisation de la base de Montgomery pour repr´esenter les ´el´ements d’un corps fini permet de b´en´eficier d’une op´eration de multiplication modulaire sans aucune division. N´eanmoins, l’algorithme Montgomery-Multmod n´ecessite de calculer des valeurs interm´ediaires plus grandes que dans l’approche classique avec division. En effet, il faut calculerqettqui sont respectivement born´es par q ≤ (r−1)² et t ≤ (p−1)²+p(r−1). En consid´erant que les ´el´ements ont une pr´ecision dembits, la taille des corps finis et la base de Montgomery doivent satisfaire le syst`eme suivant :

(r−1)² < 2^m,

(p−1)²+p(r−1) < 2^m. (2.2)

L’implantation propos´ee par la biblioth`eque Givaro s’appuie sur des entiers non sign´es 32 bits avec une base de Montgomery r = 2<sup>16</sup>. La taille des corps finis possible est donc limi-t´ee par p <= 40499, soit 15 bits. En pratique, la fonction de multiplication-addition (axpy) n’est pas implant´ee `a la mani`ere de la multiplication car cela n´ecessiterait une multiplication suppl´ementaire pour synchroniser l’op´erande de l’addition avec le r´esultat de la multiplication (¯x¯y+ ¯z=xyr²+zr). L’implantation de cette op´eration par deux op´erations successives est ici plus efficace.

Comme pour les autres implantations de corps finis de la biblioth`eque Givaro, l’int´ egra-tion de cette implantaegra-tion `a la biblioth`eque LinBox est imm´ediate en red´efinissant les fonctions d’initialisation et de conversion sur le type d’entiers multipr´ecision de LinBox. Lewrapper Lin-Box int´egrant cette implantation est la classe GivaroMontg.

2.2.5 NTL

L’implantation de l’arithm´etique des corps premiers dans la biblioth`eque NTL se base sur une arithm´etique modulaire classique. La d´efinition de corps premiers se fait par l’initialisation d’une variable globale fixant la caract´eristique du corps. Ainsi les op´erations sont directement implant´ees sur les ´el´ements du corps premier sans avoir `a d´efinir de domaine de calcul. Cette

approche ne permet cependant que la manipulation d’un seul corps premier `a la fois du fait du caract`ere statique des caract´eristiques.

Deux types d’arithm´etique de corps premiers sont disponibles. La premi`ere appel´eeNTL::zz_p est bas´ee sur des entiers machine 32 bits ou 64 bits selon l’architecture utilis´ee. L’arithm´etique utilis´ee est une arithm´etique modulaire classique (op´erations + r´eduction). Une des particularit´es de cette implantation est qu’elle propose des sch´emas particuliers de r´eduction modulaire.

La r´eduction modulaire d’entiers compris entre 0 et 2p, typiquement le r´esultat d’une addition modulop, peut ˆetre effectu´ee sans aucune comparaison. L’id´ee est de toujours calculerz=x−p pour 0 ≤ x < 2p et de se servir du bit de signe de z pour corriger le r´esultat. En effet, en r´ecup´erant le bit de signe de z par d´ecalage on obtient soit 0 si le r´esultat est positif ou nul soit−1. Du fait que les nombres n´egatifs sont cod´es en compl´ement `a la base, le codage binaire de −1 est une suite de 1 (−1 = 1111...1111) alors que le codage de 0 est une suite de 0. En utilisant le codage binaire du signe de z comme masque bit `a bit sur p, on obtient la valeur de la correction (0 oup) qu’il faut ajouter `a zpour obtenir le bon r´esultat.

Soitx, y∈Zp, cod´es sur des entiers sign´es ayant une pr´ecision dembits l’addition modulaire z≡x+y mod p s’´ecrit

z = x + y - p +(( x + y - p ) > > m - 1)& p

Une autre id´ee d´evelopp´ee dans la biblioth`eque NTL est d’utiliser une approximation du quotient de la division enti`ere pour effectuer les r´eductions modulaires apr`es multiplication des op´erandes [4]. En pratique, l’id´ee est d’extraire la partie enti`ere du quotient flottant. Ce quotient approche le quotient exact `a 1 pr`es `a cause des arrondis flottants. Il suffit donc de calculer le r´esultat en soustrayant le produit du quotient approch´e et du modulo, et finir de corriger s’il le faut. On peut donc calculer le reste de la division enti`ere en soustrayant le produit du quotient approch´e et du modulo, et finir de corriger s’il le faut.

Le modulo ´etant toujours le mˆeme pour un corps premier donn´e, le pr´ecalcul de l’inverse du modulo sur un nombre flottant double pr´ecision permet de remplacer la division par une multiplication. Cette m´ethode de r´eduction modulaire permet de remplacer la division enti`ere par une multiplication flottante, une multiplication enti`ere et quelques op´erations d’addition/-soustraction. En pratique, cette r´eduction est plus efficace que la version par division enti`ere car la plupart des processeurs ne poss`edent pas d’unit´e arithm´etique de division enti`ere. N´eanmoins, les conversions entre entiers et nombres flottants peuvent entraˆıner des effets de bord coˆuteux, en particulier au niveaux despipelines. L’implantation de cette r´eduction modulaire s’´ecrit :

lo ng N T L _ m o d ( lon g r , lo ng t , l ong modulus , d o u b l e i n v _ m o d u l u s ){

lo ng q = (( d o u b l e ) t ) * i n v _ m o d u l u s ; r = t - q * t ;

if ( r > m o d u l u s ) r -= m o d u l u s ; if ( r < 0) r += m o d u l u s ; r e t u r n r ;

}

2.2. Corps finis premiers 53 Cette r´eduction modulaire est essentiellement utilis´ee dans NTL pour l’op´eration de mul-tiplication modulaire simple pr´ecision. Cependant, cette r´eduction pourrait ˆetre utilis´ee pour l’implantation de la fonctionaxpymais cette derni`ere n’est pas disponible dans la biblioth`eque NTL. Une partie int´eressante de cette r´eduction est qu’elle autorise une taille de corps premier sup´erieure `a la moiti´e de la pr´ecision des entiers. En effet, la taille des corps premiers est ici born´ee parp <2<sup>30</sup>pour des machines 32 bits etp <2<sup>52</sup>pour des machines 64 bits. Cela provient du fait que le calcul du reste par soustraction ne fait intervenir que les bits de poids faible. La valeur absolue du reste obtenu par soustraction est ici inf´erieure `a 2p. Il suffit donc que 2psoit repr´esentable pour utiliser cette r´eduction. Cette implantation n´ecessitant des entiers sign´es, la borne maximale est donc de 2^m0−1, o`u m<sup>0</sup> d´efinit le nombre de bits de pr´ecision des entiers non sign´es. Toutefois, cette borne n’est plus valable pour les entiers 64 bits du fait de l’utilisation de flottants double pr´ecision. En effet, pour que le calcul du quotient approch´e soit correct `a 1 pr`es, il faut que les op´erandes soient repr´esentables en double pr´ecision. Or, nous avons vu pr´ec´edemment que le plus grand entier repr´esentable `a partir d’un flottant double pr´ecision est 2⁵³−1. Cela implique donc qu’il faut limiter la taille des corps premiers `a p < 2⁵² pour des machines 64 bits.

Une alternative possible qui n’est pas implant´ee dans la biblioth`eque NTL serait d’utiliser une implantation des doubles ´etendus qui garantissent une mantisse d’au moins 64 bits sans aucun bit implicite [1]. En pratique, les long double en C propose une mantisse cod´ee sur 64 bits. L’utilisation de ce type de donn´ees permettrait donc d’obtenir une limite pour les corps premiers dep <2⁶³ sur n’importe quelle architecture.

L’autre implantation de corps premiers, appel´eeNTL::ZZ_p, est bas´ee sur des entiers multipr´ e-cision et une arithm´etique modulaire classique. Les entiers multipr´ecisions utilis´es peuvent soit provenir de la biblioth`eque GMP<sup>27</sup> soit provenir d’une implantation fournie par la biblioth`eque NTL elle-mˆeme. L’arithm´etique modulaire est effectu´ee par des calculs entiers suivis soit par une correction soit par une division enti`ere multipr´ecision.

L’int´egration de ces deux implantations dans la biblioth`eque LinBox a ´et´e faite au travers d’un wrapper g´en´erique appel´e UnparametricField. Ce wrapper est une classe g´en´erique non param´etr´ee permettant de synchroniser les types de donn´ees munis des op´erateurs (+,-,×,/) avec l’arch´etype des corps finis de LinBox. Afin de proposer un domaine de calcul param´etrable pour cewrapper, nous avons d´evelopp´e les classes NTL_zz_pet NTL_ZZ_pqui surchargent le wrapper g´en´erique pour les typesNTL::zz_p etNTL::ZZ_p.