# Patent

## Title
Computing modular polynomials modulo large primes

## Abstract

Systems and methods for computing modular polynomials modulo large primes are described. In one aspect, the systems and methods generate l-isogenous elliptic curves. A modular polynomial modulo a large prime p is then computed as a function of l-isogenous elliptic curves modulo p. In one aspect, the modular polynomial may be used in a cryptosystem.

## Background
RELATED APPLICATION
This application is a continuation of and claims priority to U.S. patent application Ser. No. 11/079,642, filed on Mar. 14, 2005, the disclosure of which is incorporated by reference herein.


TECHNICAL FIELD
This disclosure relates to cryptology.
BACKGROUND
Modular polynomials are defining equations for modular curves, and are useful in many different aspects of computational number theory and cryptography. For example, computations with modular polynomials have been used to speed elliptic curve point-counting algorithms. The lth modular polynomial, φl(x, y), parameterizes pairs of elliptic curves with a cyclic isogeny of degree l between them. A conventional method for computing modular polynomials consists of computing the Fourier expansion of the modular j-function and solving a linear system of equations to obtain the integral coefficients of φl(x, y). Thus, the lth modular polynomial is a polynomial of two variables such that a zero is a pair of j-invariants of two elliptic curves which are isogenous with isogeny of degree l. These polynomials are extremely difficult to compute because the coefficients are so large (of size exponential in l). The largest l for which the modular polynomial has been computed in current tables is l=59.
SUMMARY
Systems and methods for computing modular polynomials modulo large primes are described. In one aspect, the systems and methods generate l-isogenous elliptic curves. A modular polynomial modulo a large prime p is then computed as a function of l-isogenous elliptic curves modulo p.



BRIEF DESCRIPTION OF THE DRAWINGS
In the Figures, the left-most digit of a component reference number identifies the particular Figure in which the component first appears.
FIG. 1 illustrates an exemplary system for computing modular polynomials modulo large primes.
FIG. 2 shows an exemplary procedure to compute a univariate polynomial φl(x, j) modulo a prime p given a j-invariant (φl(x, j) is a polynomial of a single variable as j is a quantity (a number modulo p)).
FIG. 3 shows an exemplary procedure to compute a bivariate polynomial φl(x, y) modulo a prime p given φl(x, j) for various j via interpolation φl(x, y) is a polynomial of two variables (two unknowns)).
FIG. 4 shows an example of a suitable computing environment in which systems and methods for computing modular polynomials modulo large primes may be fully or partially implemented.



DETAILED DESCRIPTION
Overview
Systems and methods for computing modular polynomials modulo large primes are described with respect to FIGS. 1-3. In general, the systems and methods generate a pair of l-isogenous elliptic curves modulo a large prime p. The isogenous elliptic curves are determined using Velu's formulas. These and other aspects of the systems and methods for computing modular polynomials modulo large primes are now described in greater detail.
An Exemplary System
Although not required, the systems and methods for computing modular polynomials modulo large primes are described in the general context of computer-executable instructions (program modules) being executed by a computing device such as a personal computer. Program modules generally include routines, programs, objects, components, data structures, etc., that perform particular tasks or implement particular abstract data types. While the systems and methods are described in the foregoing context, acts and operations described hereinafter may also be implemented in hardware.
FIG. 1 illustrates an exemplary system 100 for computing modular polynomials modulo large primes. In this implementation, system 100 includes computing device 102. Computing device 102 is any type of computing device such as a personal computer, a laptop, a server, small form factor mobile computing device (e.g., a cellular phone, personal digital assistant, or handheld computer), etc. Computing device 102 includes program modules 104 and program data 106. Program modules 102 include, for example, polynomial computation module 108 and other program modules 110. Polynomial computation module computes modular polynomials modulo large primes p. (Large primes p are shown as respective portions of “other data” 112). To this end, polynomial computation module 108 generates a pair of n-isogenous elliptic curves 114 modulo a large prime p. The elliptic curves 114 are determined from Velu's formulas (see, component 116 of FIG. 1).
More particularly, and in one implementation (i.e., algorithm 1), polynomial computation module 108 computes an lth modular polynomial modulo p by computing all isogenies 118 of degree l from a given supersingular elliptic curve 114 modulo p via Vélu's well-known formulae. (See [11], Vélu, Jacques; Isogénies entre courbes elliptiques, C. R. Acad. Sc. Paris, 238-241, 1971). Next, modular polynomial computation module 108, for a given j-invariant 120 of a supersingular elliptic curve 114 over Fp2,computes φl(x, j) (i.e., the univariate polynomial 116) modulo p by computing the l+1 distinct subgroups of order l and computing the j-invariants 120 of the l+1 corresponding l-isogenous elliptic curves 114. In contrast to conventional systems and techniques, this implementation does not use the factorization of the l-division polynomials to produce the subgroups of order l. Instead this implementation generates independent l-torsion points by picking random points with coordinates in an extension of Fp which contains all the l-torsion points and taking a scalar multiple, which is the group order divided by l. This is more efficient than factoring the lth division polynomial for large l. This approach also provides, as a corollary, a very fast way to compute a random l-isogeny of an elliptic curve over a finite field for large l.
In another implementation (i.e., algorithm 2), polynomial computation module 108, uses the connectedness of the graph of supersingular elliptic curves 114 over Fp2 to move around the graph, obtaining different values of j as described above in paragraph [0012], until enough information is obtained to compute φl(x, y) modulo p (i.e., the univariate polynomial 116) via interpolation. The assumption that the number of supersingular elliptic curves mod p (the quantity S(p)) is at least l+1 guarantees that we have enough information to do the interpolation. This implementation computes φl(x, y) modulo p by doing only computations with supersingular elliptic curves 114 in characteristic p even though φl(x, y) is a general object giving information about isogenies between elliptic curves 114 in characteristic 0 and ordinary elliptic curves 114 in characteristic p. Thus, for all of the isomorphism classes of supersingular elliptic curves 114, the full l-torsion is defined over an extension of degree O(l) of the base field Fp2, whereas for non-supersingular elliptic curves the field of definition of the l-torsion can be of degree O(l2).
Computing a Univariate Polynomial Modulo Prime p Given j-Invariant j
FIG. 2 shows an exemplary procedure 200 to compute a univariate polynomial φl(x, j) modulo a prime p given a j-invariant j. An ingredient of an exemplary first implementation (algorithm 1) for computing modular polynomials modulo large primes is the computation of the univariate polynomial φl(x, j) modulo a prime p given a j-invariant j. Input into polynomial computation module 108 are two (2) distinct primes p and l, and j the j-invariant 120 of a supersingular elliptic curve E 114 over a finite field Fq of degree at most two (2) over a prime field of characteristic p. The output is polynomial 116, such that




  
    
      φ
      l
    
    ⁡
    
      (
      
        x
        ,
        j
      
      )
    
  
  =
  
    
      
        ∏
        
          
            
              E
              ′
            
            ⁢
            l
          
          -
          
            isogenous
            ⁢
            
              
            
            ⁢
            to
            ⁢
            
              
            
            ⁢
            E
          
        
      
      ⁢
      
        
      
      ⁢
      
        (
        
          x
          -
          
            j
            ⁡
            
              (
              
                E
                ′
              
              )
            
          
        
        )
      
    
    ∈
    
      
        
          F
          
            p
            2
          
        
        ⁡
        
          [
          x
          ]
        
      
      .
    
  




For purposes of discussion and illustration, operations of the procedure are described with respect to components of FIG. 1. The left-most digit of a component reference number identifies the particular figure in which the component first appears.

At block 202, polynomial computation module 108 find the generators P and Q of E[l]. To this end:

    (a) Let n be such that Fq(E[l])⊂Fqn.
    (b) Let S=éE(Fqn), the number of Fqn rational points on E. (Original)
    (c) Set s=S/lk, where lk is the largest power of l that divides S (note k≧2).
    (d) Pick two points P and Q at random from E[l]:
    
        (i) Pick two points U, V at random from E(Fqn).
        (ii) Set P′=sU and Q′=sV, if either P′ or Q′ equals O then repeat step (i).
        (iii) Find the smallest i1, i2 such that li1P′≠O and li2Q′≠O but li1+1P′=O and li2+1Q′=O.
        (iv) Set P=li1P′ and Q=li2Q′.
    
    
    (e) Using the well-known Shanks's Baby-steps-Giant-steps algorithm, determine if Q belongs to the group generated by P. If so, step (d) is repeated.


At block 204, polynomial computation module 108 determines the j-invariants j1, . . . , jl+1 in Fp2 of the l+1 elliptic curves that are isogenous to E. To this end:

    (a) Let G1=<Q> and G1+i=<P+(i−1)*Q> for 1≦i≦l.
    (b) For each i, 1≦i≦l+1 compute the j-invariant of the elliptic curve E/Gi using Vélu's formulas.


At block 206, polynomial computation module 108 outputs




  
    
      φ
      l
    
    ⁡
    
      (
      
        x
        ,
        j
      
      )
    
  
  =
  
    
      
        ∏
        
          1
          ≤
          i
          ≤
          
            l
            +
            1
          
        
      
      ⁢
      
        
      
      ⁢
      
        (
        
          x
          -
          
            j
            i
          
        
        )
      
    
    :
  




univariate Polynomial 116. Polynomial 116 has coefficients in Fp2[x] since all the curves l-isogenous to E are supersingular and hence their j-invariants belong to Fp2.

The following lemma 1 gives the possibilities for the value of n at block 202 (a). Let E/Fq be an elliptic curve, and let l be a prime not equal to the characteristic of Fq. Then E[l]⊂E(Fqn) where n is a divisor of either l(l−1) or l2−1. The Weil-pairing tells us that if E[l]⊂Fqn then μl⊂Fqn ([12] Corollary 8.1.1). We seek, however, an upper bound on n, to do this we use the Galois representation coming from the l-division points of E. Indeed, we have an injective group homomorphism:

ρl: (Fq(E[l])/Fq)→Aut(E[l])≅2(Fl).

The Galois group (Fq(E[l])/Fq) is cyclic, thus by ρl the possibilities for (Fq(E[l])/Fq) are limited to cyclic subgroups of 2(Fl). We study the following map

2(Fl)ψ→2(Fl)→2(Fl),

wherein the map ψ is given by





  
    ψ
    ⁡
    
      (
      M
      )
    
  
  =
  
    
      1
      
        det
        ⁢
        
          
        
        ⁢
        M
      
    
    ⁢
    
      M
      .
    
  




The cyclic subgroups of 2(Fl) are either of order l or of cardinality dividing (l±1)/k , where k=gcd(l−1, 2). If C is a cyclic subgroup of 2(Fl) then its image in 2(Fl) is annihilated by either l or l±1. Since the image is obtained by quotienting out by scalars and then a group of order 2, C is annihilated by either l(l−1) or (l−1)(l+1)=l2−1. Thus the degree of the field extension containing the l-torsion points on E must divide either l(l−1) or l2−1.

The operations of block 202 use n=l2−1. However, if corresponding operations (d) and (e) do not succeed for some K (a constant) number of iterations, n=l(l−1) is utilized. The following analysis shows that a sufficiently large constant K will work.
Operation (b) of block 202 does not need a point counting algorithm to determine S. Since E is a supersingular elliptic curve, 114 we have the following choices for the trace of Frobenius aq:




  
    a
    q
  
  =
  
    {
    
      
        
          0
        
        
          
            if
            ⁢
            
              
            
            ⁢
            E
            ⁢
            
              
            
            ⁢
            is
            ⁢
            
              
            
            ⁢
            over
            ⁢
            
              
            
            ⁢
            
              F
              p
            
          
        
      
      
        
          
            
              0
              ,
              
                ±
                p
              
              ,
              
                
                  ±
                  2
                
                ⁢
                
                  
                
                ⁢
                p
              
            
            ⁢
            
              
            
          
        
        
          
            if
            ⁢
            
              
            
            ⁢
            E
            ⁢
            
              
            
            ⁢
            is
            ⁢
            
              
            
            ⁢
            over
            ⁢
            
              
            
            ⁢
            
              
                F
                
                  p
                  2
                
              
              .
            
          
        
      
    
  




A deterministic point counting algorithm could also be used to find #E(Fq), but this would cost O(log6 q) field operations.

The probability with which operations of block 202 (d) succeeds is determined as follows. For a random choice of the points U and V in (d)(i), the probability that step (d)(ii) succeeds is at least




  
    
      (
      
        1
        -
        
          1
          
            l
            2
          
        
      
      )
    
    2
  
  .




As a group E(Fqn)≅Z/NZ×Z/MNZ, where N=lN′ since l-torsion points of E are Fqn rational. Using this isomorphism one sees that the probability that sU=O is bounded above by





  
    
      
        N
        ′
      
      N
    
    ⁢
    
      
        MN
        ′
      
      MN
    
  
  =
  
    
      1
      
        l
        2
      
    
    .
  




At block 202 (d) completion, we have two random l-torsion points of E namely, P and Q. The probability that Q belongs to the cyclic group generated by P is




  
    l
    
      l
      2
    
  
  =
  
    
      1
      l
    
    .
  




Thus with high probability we will find in block 202 (e), two generators for E[l].

In this implementation, execution time for operations of block 202 is O(l4+o(1) log2+o(1)q). The finite field Fqn is constructed by picking an irreducible polynomial of degree n. A randomized method that requires on average O((n2 log n+n log q)log n loglog n) operations over Fq is given in [11]. Thus the field can be constructed in O(l4+o(1) log2+o(1)q) time since n≦l2. Step (1d) requires picking a random point on E. We can do this by picking a random element in Fqn treating it as the x-coordinate of a point on E and solving the resulting quadratic equation for the y-coordinate. Choosing a random element in Fqn can be done in O(l2 log q) time. Solving the quadratic equation can be done probabilistically in O(l2 log q) field operations. Thus to pick a point on E can be done in O(l4+o(1) log2+o(2)q) time. The computation in steps (1d i-iv) computes integer multiples of a point on the elliptic curve, where the integer is at most qn, and this can be done in O(4+o(1) log2+o(1)q) time using the repeated squaring method and fast multiplication. Shank's Baby-steps-giant-steps algorithm for a cyclic group G requires O(√{square root over (|G|)}) group operations. Thus step (1e) runs in time




  
    O
    ⁡
    
      (
      
        
          l
          
            
              5
              2
            
            +
            
              o
              ⁡
              
                (
                1
                )
              
            
          
        
        ⁢
        
          log
          
            1
            +
            
              o
              ⁡
              
                (
                1
                )
              
            
          
        
        ⁢
        q
      
      )
    
  
  ,




since the group is cyclic of order l.

Let C be a subgroup of E, Vélu [11] provides explicit formulas for determining the equation of the isogeny E→E/C and the Weierstrass equation of the curve E/C. Let E is given by the equation

y2+a1xy+a3y=x3+a2x2+a4x+a6,

wherein S is a set of representatives for (C−{O})/±1. The following two functions are defined in Fq(E) for Q=(x, y) a point on E−{O}: define

gx(Q)=3x2+2a2x+a4−a1y 

gy(Q)=−2y−a1x−a3.

The following is set:





  
    
      t
      ⁡
      
        (
        Q
        )
      
    
    =
    
      {
      
        
          
            
              
                g
                x
              
              ⁡
              
                (
                Q
                )
              
            
            ⁢
            
              
            
            ⁢
            if
            ⁢
            
              
            
            ⁢
            Q
          
          =
          
            
              -
              Q
            
            ⁢
            
              
            
            ⁢
            on
            ⁢
            
              
            
            ⁢
            E
          
        
        ;
        
          
        
        ⁢
        
          
            2
            ⁢
            
              
                g
                x
              
              ⁡
              
                (
                Q
                )
              
            
          
          -
          
            
              a
              1
            
            ⁢
            
              
                g
                y
              
              ⁡
              
                (
                Q
                )
              
            
          
        
      
      }
    
  
  ,
  
    

  
  ⁢
  
    
      u
      ⁡
      
        (
        Q
        )
      
    
    =
    
      
        
          
            (
            
              
                g
                y
              
              ⁡
              
                (
                Q
                )
              
            
            )
          
          2
        
        ⁢
        t
      
      =
      
        
          
            ∑
            
              Q
              ∈
              S
            
          
          ⁢
          
            
          
          ⁢
          
            
              t
              ⁡
              
                (
                Q
                )
              
            
            ⁢
            w
          
        
        =
        
          
            ∑
            
              Q
              ∈
              S
            
          
          ⁢
          
            
              (
              
                
                  u
                  ⁡
                  
                    (
                    Q
                    )
                  
                
                +
                
                  
                    x
                    ⁡
                    
                      (
                      Q
                      )
                    
                  
                  ⁢
                  
                    t
                    ⁡
                    
                      (
                      Q
                      )
                    
                  
                
              
              )
            
            .
          
        
      
    
  




otherwise,

The curve E/C is given by the Weierstrass equation:

Y2+A1XY+A3Y=X3+A2X2+A4X+A6,

wherein

A1=a1, A2=a2, A3=a3, A4=a4−5t, A6=a6−(a12+4a2)t−7w. 

From the Weierstrass equation of E/C we can determine the j-invariant of E/C. These operations are implemented using O(l) elliptic curve operations for each of the groups Gi, 1≦i≦l+1. Thus operations of block 204 are implemented in O(l4+o(1) log1+o(1)q) time steps. Operations of block 206 require only O(l) field operations. As such, running time of this implementation of procedure 200 is dominated by the running time of operations associated with blocks 202 and 204.
In view of the above, procedure 200 computes φl(x, j)εFp2[x] together with the list of its roots and has an expected running time of O(n2+o(1) log2+o(1)q+√{square root over (l)}n1+o(1) log1+o(1)q+l2n1+o(1) log q). The running time of procedure 200 depends on terms of the quantity n. As described below in reference to FIG. 3, this dependence becomes explicit. In the case of ordinary elliptic curve 114, operations of block 202 can used once the number of points on E/Fq has been determined, by Lemma 2 the degree of the extension, n, is still O(l2). This leads to the following two results: If E/Fq is an elliptic curve, we can pick a random l-torsion point on E( Fq) in time O(l4+o(1) log2+o(1)q+log6+o(1)q). If E/Fq is an elliptic curve, we can construct a random l-isogenous curve to E in time O(l4+o(1) log2+o(1)q+log6+o(1)q).
Computing a Univariate Polynomial Modulo Prime p via Interpolation
FIG. 3 shows an exemplary procedure 300 to compute φl(x, y)mod p provided S(p)≧l+1, where S(p) is the number of isomorphism classes of supersingular elliptic curves modulo p (computing a univariate polynomial modulo a prime p given a j-invariant j via interpolation). In characteristic p>2 there are exactly




  
    
  
  ⁢
  
    
      S
      ⁡
      
        (
        p
        )
      
    
    =
    
      
        ⌊
        
          p
          12
        
        ⌋
      
      +
      
        ɛ
        p
      
    
  




supersingular j-invariants where

εp=0,1,1,2 if p≡1,5,7,11mod12.

For purposes of discussion and illustration, operations of the procedure are described with respect to components of FIG. 1 and operations procedure 200 of FIG. 2. The left-most digit of a component reference number identifies the particular figure in which the component first appears.

Input to procedure 300 are two distinct primes l and p with S(p)≧l+1. At block 302, polynomial computation module 108 calculates the smallest (in absolute value) discriminant D<0 such that




  
    (
    
      D
      p
    
    )
  
  =
  
    -
    1.
  




At block 304, polynomial computation module 108 computes the Hilbert Class polynomial HD(X)mod p. Let j0 be a root of HD(X) in Fp2. At block 306, and with i initially set to equal zero (0), polynomial computation module 108 computes φi=φl(x, ji)εFp2 via operations of procedure 200, which was described above with respect to FIG. 2.

At block 308, let ji+1 be a root of φk for k≦i which is not one of j0, . . . , ji. At block 310, if i<l then polynomial computation module 108 sets i=i+1 and repeats operations of block 306. At this point, and writing




  
    
  
  ⁢
  
    
      
        
          φ
          l
        
        ⁡
        
          (
          
            x
            ,
            y
          
          )
        
      
      =
      
        
          x
          
            l
            +
            1
          
        
        +
        
          
            ∑
            
              0
              ≤
              k
              ≤
              l
            
          
          ⁢
          
            
          
          ⁢
          
            
              
                p
                k
              
              ⁡
              
                (
                y
                )
              
            
            ⁢
            
              x
              k
            
          
        
      
    
    ,
  




we have l+1 systems of equations of the form pk(ji)=vki for 0≦k, i≦l. At block 312, polynomial computation module 108 solves these equations for each pk(y), 0≦k≦l. At block 314, polynomial computation module 108 outputs univariate polynomial 116, or in this implementation, φl(x, y)εFp[x, y].

Lemma 2, as follows, shows that this second implementation is correct. For operations of block 302, we note that if p≡3mod4, then D=−4 works. Otherwise, −1 is a quadratic residue and writing (without loss of generality) D as −4d, we are looking for the smallest d such that




  
    
  
  ⁢
  
    
      (
      
        d
        p
      
      )
    
    =
    
      -
      1.
    
  




A theorem of Burgess ([4]) tells us that





  
    
  
  ⁢
  
    
      Rectangle
      =
      
        p
        
          1
          
            4
            ⁢
            
              e
            
          
        
      
    
    ,
  




and under the assumption of Generalized Riemann Hypothesis (GRH) the estimate of Ankeny gives Rectangle=log2 p (Techniques to implement this estimate are well-known—Ankeny, N., C.; The least quadratic non-residue, Annals of Math., (2), 65-72, 1952). Computing HD(x)mod p can be done in O(d2(log d)2) time [8] §5.10. Thus operations of block 304 use O(√{square root over (p)} log2 p) time, and under the assumption of GRH uses O(log4 p(loglog p)2) time. Since





  
    
  
  ⁢
  
    
      (
      
        D
        p
      
      )
    
    =
    
      -
      1
    
  




all roots of HD(x) are supersingular j-invariants in characteristic p. HD(x) is a polynomial of degree h(√{square root over (−D)}), the class number of the order of discriminant D, and this is





  
    Rectangle
    =
    
      
        
        D
        
      
      
        
          1
          2
        
        +
        ɛ
      
    
  
  ,




by Siegel's well-known theorem. Finding a root of HD(x)εFp2 is done in O(dl+εlog2+o(1)p) time using probabilistic factoring algorithms, where d=|D|. The graph with supersingular j-invariants over characteristic p as vertices and l-isogenies as edges is connected (see [7]), consequently, we will always find a j-invariant in block 308 that is not one of j0, . . . , ji. Thus the loop represented by blocks 306-310 executed exactly l+1 times under the assumption that S(p)≧+1. Even though algorithm 1, as described above, uses Õ(l4 log2 q) time in the worst case, we assert that for substantially all of the iterations of the loop, algorithm 1 actually runs in Õ(l3 log2 q) time. (Soft-Oh Õ notation is used when factors of the form log l or loglog p are ignored).

Let E1, . . . , ES(p) be the supersingular elliptic curves (unique up to isomorphism) 114 defined over Fp2. Then for all elliptic curves 114 the extension degree

[Fp2(Ei[l]): Fp2], 1≦i≦S(p)

divides 6(l−1). Let E/Fp2 be a supersingular curve 114 and let t be the trace of Frobenius. Then the Frobenius map φ satisfies

φ2−tφ+p2=0.

Suppose t=±2p, then the characteristic equation of Frobenius factors as (φ±p)2. Thus the action of Frobenius on the vector space of l-torsion points is not irreducible. In particular, there is a non-zero eigenspace V⊂E[l], where φ acts as multiplication by ±p. Thus there is a non-zero vector vεV whose orbit under Frobenius is of size dividing l−1. Let P be the l-torsion point corresponding to v. Then [Fp2(P): Fp2] divides l−1. Since E is supersingular, its embedding degree is 6,thus the extension Fp2(E[l])/Fp2(P) is of degree dividing 6. The other cases can be handled similarly.
In view of the above, algorithm 1 can be run with the quantity n=6(l−1) (the value and feasibility of n is efficiently tested). Thus, algorithm 1 runs in expected time O(l3+o(1) log2+o(1)p) for all iterations of the loop. As such, the loop runs in expected time O(l4+o(1) log2+o(1)p).
Writing the modular polynomial (i.e., component 116) φl(x, y) as




  
    
  
  ⁢
  
    
      
        x
        
          l
          +
          1
        
      
      +
      
        
          ∑
          
            0
            ≤
            k
            ≤
            l
          
        
        ⁢
        
          
        
        ⁢
        
          
            
              p
              k
            
            ⁡
            
              (
              y
              )
            
          
          ⁢
          
            x
            k
          
        
      
    
    ,
  




we know that p0(y) is monic of degree l+1 and deg(pk(y))≦l for 1≦k≦l. Thus at the end of the loop of blocks 306 through 310, there is enough information to solve for the Pk(y) in the operations of block 312. More particularly, l+1 systems of equations are being solved, each using an inversion of a matrix of size (l+1)×(l+1). This is done in O(l4 log1+o(1)p) time. Since the polynomial φl(x, y)mod p is a reduction of the classical modular polynomial, a polynomial with integer coefficients, the polynomial 116 generated by the systems and methods of system 100 has coefficients in Fp. Accordingly, we have proved the following theorem:

Given l and p distinct primes such that S(p)≧l+1, algorithm 2 computes φl(x, y)εFp[x, y] in expected time O(l4+o(1) log2+o(1)p+log4 p loglog p) under the assumption of GRH. Hence, φl(x, y) modulo a prime p is computed in Õ(l4 log2 p+log4 p) time if p≧12l+13.
When allowed to pick a prime p, such as would be the case when computing φl over the integers using the Chinese Remainder Theorem combined with the method of FIGS. 2 and 3, then the assumption of GRH in the above theorem can be eliminated. For example, for primes p≡3mod4 the j-invariant 1728 is supersingular. Thus in block 304 of FIG. 3, j0=1728 can be initially utilized for any such prime. Hence the GRH to a bound D is not needed in the analysis of the running time of these operations.
An Exemplary Operating Environment
FIG. 4 illustrates an example of a suitable computing environment 400 in which the systems and methods for computing modular polynomials modulo large primes may be fully or partially implemented. Exemplary computing environment 400 is only one example of a suitable computing environment for the exemplary system of FIG. 1 and exemplary operations of FIG. 2, and is not intended to suggest any limitation as to the scope of use or functionality of systems and methods the described herein. Neither should computing environment 400 be interpreted as having any dependency or requirement relating to any one or combination of components illustrated in computing environment 400.
The methods and systems described herein are operational with numerous other general purpose or special purpose computing system, environments or configurations. Examples of well-known computing systems, environments, and/or configurations that may be suitable for use include, but are not limited to, personal computers, laptops, small form factor mobile computing device (e.g., a cellular phone, personal digital assistant, or handheld computer), server computers, multiprocessor systems, microprocessor-based systems, network PCs, minicomputers, mainframe computers, distributed computing environments that include any of the above systems or devices, and so on. Compact or subset versions of the framework may also be implemented in clients of limited resources, such as handheld computers, or other computing devices. The invention is practiced in a distributed computing environment where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote memory storage devices.
With reference to FIG. 4, an exemplary system 400 illustrates an example of a suitable computing environment in which systems and methods for computing modular polynomials modulo large primes may be fully or partially implemented. System 400 includes a general purpose computing device in the form of a computer 410 implementing, for example, computing device 102 of FIG. 1. Components of computer 410 may include, but are not limited to, processing unit(s) 420, a system memory 430, and a system bus 421 that couples various system components including the system memory to the processing unit 420. The system bus 421 may be any of several types of bus structures including a memory bus or memory controller, a peripheral bus, and a local bus using any of a variety of bus architectures. By way of example and not limitation, such architectures may include Industry Standard Architecture (ISA) bus, Micro Channel Architecture (MCA) bus, Enhanced ISA (EISA) bus, Video Electronics Standards Association (VESA) local bus, and Peripheral Component Interconnect (PCI) bus also known as Mezzanine bus.
A computer 410 typically includes a variety of computer-readable media. Computer-readable media can be any available media that can be accessed by computer 410 and includes both volatile and nonvolatile media, removable and non-removable media. By way of example, and not limitation, computer-readable media may comprise computer storage media and communication media. Computer storage media includes volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer-readable instructions, data structures, program modules or other data. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by computer 410.
Communication media typically embodies computer-readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism, and includes any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example and not limitation, communication media includes wired media such as a wired network or a direct-wired connection, and wireless media such as acoustic, RF, infrared and other wireless media. Combinations of the any of the above should also be included within the scope of computer-readable media.
System memory 430 includes computer storage media in the form of volatile and/or nonvolatile memory such as read only memory (ROM) 431 and random access memory (RAM) 432. A basic input/output system 433 (BIOS), containing the basic routines that help to transfer information between elements within computer 410, such as during start-up, is typically stored in ROM 431. RAM 432 typically contains data and/or program modules that are immediately accessible to and/or presently being operated on by processing unit 420. By way of example and not limitation, FIG. 4 illustrates operating system 434, application programs 435, other program modules 436, and program data 437.
The computer 410 may also include other removable/non-removable, volatile/nonvolatile computer storage media. By way of example only, FIG. 4 illustrates a hard disk drive 441 that reads from or writes to non-removable, nonvolatile magnetic media, a magnetic disk drive 451 that reads from or writes to a removable, nonvolatile magnetic disk 452, and an optical disk drive 455 that reads from or writes to a removable, nonvolatile optical disk 456 such as a CD ROM or other optical media. Other removable/non-removable, volatile/nonvolatile computer storage media that can be used in the exemplary operating environment include, but are not limited to, magnetic tape cassettes, flash memory cards, digital versatile disks, digital video tape, solid state RAM, solid state ROM, and the like. The hard disk drive 441 is typically connected to the system bus 421 through a non-removable memory interface such as interface 440, and magnetic disk drive 451 and optical disk drive 455 are typically connected to the system bus 421 by a removable memory interface, such as interface 450.
The drives and their associated computer storage media discussed above and illustrated in FIG. 4, provide storage of computer-readable instructions, data structures, program modules and other data for the computer 410. In FIG. 4, for example, hard disk drive 441 is illustrated as storing operating system 444, application programs 445, other program modules 446, and program data 447. Note that these components can either be the same as or different from operating system 434, application programs 435, other program modules 436, and program data 437. Application programs 435 include, for example, program modules 104 of FIG. 1. Program data 437 includes, for example, program data 106 of FIG. 1. Operating system 444, application programs 445, other program modules 446, and program data 447 are given different numbers here to illustrate that they are at least different copies.
A user may enter commands and information into the computer 410 through input devices such as a keyboard 462 and pointing device 461, commonly referred to as a mouse, trackball or touch pad. Other input devices (not shown) may include a microphone, joystick, game pad, satellite dish, scanner, or the like. These and other input devices are often connected to the processing unit 420 through a user input interface 460 that is coupled to the system bus 421, but may be connected by other interface and bus structures, such as a parallel port, game port or a universal serial bus (USB).
In one implementation, a monitor 491 or other type of display device is also connected to the system bus 421 via an interface, such as a video interface 490. In addition to the monitor, computers may also include other peripheral output devices such as printer 496 and audio devices 497, which may be connected through an output peripheral interface 495.
The computer 410 operates in a networked environment using logical connections to one or more remote computers, such as a remote computer 480. The remote computer 480 may be a personal computer, a server, a router, a network PC, a peer device or other common network node, and as a function of its particular implementation, may include many or all of the elements (e.g., program module(s) 104 and program data 106, etc.) described above relative to the computer 102, although only a memory storage device 481 has been illustrated in FIG. 4. The logical connections depicted in FIG. 4 include a local area network (LAN) 471 and a wide area network (WAN) 473, but may also include other networks. Such networking environments are commonplace in offices, enterprise-wide computer networks, intranets and the Internet.
When used in a LAN networking environment, the computer 410 is connected to the LAN 471 through a network interface or adapter 470. When used in a WAN networking environment, the computer 410 typically includes a modem 472 or other means for establishing communications over the WAN 473, such as the Internet. The modem 472, which may be internal or external, may be connected to the system bus 421 via the user input interface 460, or other appropriate mechanism. In a networked environment, program modules depicted relative to the computer 410, or portions thereof, may be stored in the remote memory storage device. By way of example and not limitation, FIG. 4 illustrates remote application programs 485 as residing on memory device 481. The network connections shown are exemplary and other means of establishing a communications link between the computers may be used.
Conclusion
Although the systems and methods for computing modular polynomials modulo large primes have been described in language specific to structural features and/or methodological operations or actions, it is understood that the implementations defined in the appended claims are not necessarily limited to the specific features or actions described. For example, the operations of polynomial computation module 108 of FIG. 1 can be utilized in a cryptosystem, for computational number theory, and/or in an elliptic curve point-counting algorithm. Examples of a cryptosystem module, a program module using computational number theory, or a module that implements an elliptic curve point-counting algorithm are shown as respective portions of “other program modules” 110 of FIG. 1. Accordingly, the specific features and operations are disclosed as exemplary forms of implementing the claimed subject matter.
References
The following references are hereby incorporated by reference:
[1] Agashe, A.; Lauter, K.; Venkatesan, R.; Constructing Elliptic Curves with a known number of points over a prime field, in Lectures in honour of the 60th birthday of Hugh Cowie Williams, Fields Institute Communications Series, 1-17, 2003.
[2] Blake, I.; Seroussi, G.; Smart, N.; Elliptic Curves in Cryptography, Lond. Math. Soc., Lecture Note Series, Cambridge University Press, 1999.
[3] Bosma, W.; Cannon, J.; Handbook of MAGMA functions, Sydney, 2003.
[4] Burgess, D., A.; On character sums and primitive roots, Proc. London Math. Soc., III, 179-192, 1962.
[5] Elkies, Noam; Elliptic and modular curves over finite fields and related computational issues, in Computational Perspectives on Number Theory: Proceedings of a Conference in Honor of A. O. L. Atkin (D. A. Buell and J. T. Teitelbaum, eds.), AMS/International Press, 21-76, 1998.
[6] Lenstra, A., K.; Lenstra, H., W., Jr.; Algorithms in Number Theory, Handbook of Theoretical Computer Science, Vol. A. Elsevier, 673-715, 1990.
[7] Mestre, J.-F.; La méthode des graphes. Exemples et applications, Proceedings of the international conference on class numbers and fundamental units of algebraic number fields, Nagoya Univ., Nagoya, 217-242, 1986.
[8] Schoof, René; Nonsingular Plane Cubic Curves over Finite Fields, J. Combinatorial Theory, 2, 183-208, 1987.
[9] Shoup, Victor; Fast construction of irreducible polynomials over finite fields, J. Symbolic Computation, 471-391, 1994.
[10] Silverman, Joseph, H.; The Arithmetic of Elliptic Curves, Graduate Texts in Mathematics, Springer-Verlag, 1986.
[11] Vélu, Jacques; Isogénies entre courbes elliptiques, C. R. Acad. Sc. Paris, 238-241, 1971.

## Claims

1. A method, implemented by a computing device, the method comprising:
under the control of one or more processors of the computing devices executing computer readable instructions:
generating l-isogenous elliptic curves modulo p;
computing a modular polynomial modulo a large prime p as a function of the l-isogenous elliptic curves wherein the computing comprises:
interpolating information based on connectedness of a graph of the generated l-isogenous elliptic curves modulo p;
determining a set of isogenies of degree l between supersingular elliptic curves modulo p; and
for a given j-invariant of a supersingular elliptic curve over a finite field Fp2, determining a univariate polynomial φl(x, j) modulo p as a function of l+1 distinct subgroups of order l and j-invariants of l+1 corresponding l-isogenous elliptic curves of the set of isogenies;

wherein l and p are distinct primes; and
storing the modular polynomial to memory for utilization in a cryptosystem, for computational number theory, or in an elliptic curve point-counting algorithm.

2. A method as recited in claim 1, wherein computing the modular polynomial modulo p does not use a factorization of l-division polynomials to produce subgroups of order l.

3. A method as recited in claim 1, wherein computing the modular polynomial modulo p further comprises:
generating independent 1-torsion points as a function of randomly selected points with coordinates in a suitable extension of Fp; and
determining a scalar multiple, which is a group order divided by l.

4. A computer-readable memory comprising computer-program instructions executable by a processor for:
generating l-isogenous elliptic curves modulo p;
computing a modular polynomial modulo a large prime p as a function of the l-isogenous elliptic curves wherein the computing comprises:
interpolating information based on connectedness of a graph of the generated l-isogenous elliptic curves modulo p; wherein l and p are distinct primes;
utilizing connectedness of a graph of supersingular elliptic curves over a finite field Fp2to move around the graph;
obtaining different values of j as a function of l+1 distinct subgroups of order l and j-invariants of l+1 corresponding l-isogenous elliptic curves enough information is obtained to compute a bivariate polynomial φl(x, y) modulo p via interpolation; and
computing the univariate polynomial modulo p via interpolation; and

implementing the modular polynomial in a cryptosystem.

5. A computer-readable memory as recited in claim 4, wherein φl(x, y) is a general object giving information about isogenies between elliptic curves in characteristic 0 and ordinary elliptic curves in characteristic p , and wherein the computer-program instructions for computing the univariate polynomial modulo p via interpolation further comprise instructions for:
calculating the univariate polynomial modulo p only with computations based on supersingular elliptic curves in characteristic p .

6. A computing device comprising:
one or more processors; and
memory coupled to the one or more processors, the memory comprising computer-program instructions executable by the one or more processors for:
generating l-isogenous elliptic curves modulo p; and
computing a modular polynomial modulo a large prime p as a function of the l-isogenous elliptic curves wherein the computing comprises:
interpolating information based on connectedness of a graph of the generated l-isogenous elliptic curves modulo p;
determining all isogenies of degree l between supersingular elliptic curves modulo p; and
for a given j-invariant of the supersingular elliptic curve over a finite field Fp2 , determining a univariate polynomial φl(x, j) modulo p as a function of l+1 distinct subgroups of order l and j-invariants of l+1 corresponding l-isogenous elliptic curves;


wherein l and p are distinct primes; and
implementing the modular polynomial in a cryptosystem.

7. A computing device as recited in claim 6, wherein the computer-program instructions for computing the modular polynomial modulo p does not use a factorization of l-division polynomials to produce subgroups of order l.

8. A computing device as recited in claim 7, wherein the computer-program instructions for computing the modular polynomial modulo p further comprise instructions for:
generating independent l-torsion points as a function of randomly selected points with coordinates in a suitable extension of Fp; and
determining a scalar multiple, which is a group order divided by l.