attachment:pdescent.sage of daysff/mw

   1 This is code to compute the p-descent in char. p based on code by
   2 D. Ulmer. Assumes we have a class for a point on elliptic curve
   3 over function fields, a class for the elliptic curve over function
   4 fields and a class for function fields. The class for function 
   5 fields need to provide a separating element u (currently using
   6 generator, will cause problem) so we can differentiate wrto u.
   7 We also need the characteristic of the field. From the elliptic
   8 curve class we just need the usual invariants.
   9 Current version by F. Voloch.
  10 
  11 
  12 def p_descent(self):
  13    r""" Computes the p-descent map for a point on an elliptic curve 
  14         defined over a function field of positive characteristic p
  15         as long as the j-invariant is not a p-th power in the field.
  16         Takes a point on an elliptic curve over a function field as
  17         input and returns an element of the function field as output.
  18         Based on formulas due to A. Broumas (Compositio 107, 1997).
  19 
  20     """
  21 
  22    E = self.curve()       #assumes that E is an elliptic curve containing the point.
  23    k = self.base_field()  #assumes that k is a function field.
  24    u = k.gen()            #later will need k/F_p(u) separable, will be nice to have workaround.
  25    p = k.characteristic()
  26 
  27    if p == 0:
  28          raise ValueError('p-descent specific for positive characteristic p')
  29    elif p == 2: 
  30          raise ValueError('Not implemented yet for characteristic two')
  31    elif p == 3:
  32          R = k['x']
  33          x = R.gen()
  34          ES = E.short_weierstrass_model(complete_cube=False)
  35          a2 = ES.a2()
  36          EL = ES.change_weierstrass_model([k.(1),a2,0,0])
  37          a6 = EL.a6()
  38          A = a2
  39          def wp(z):
  40             return z**p-A*z
  41          delta = EL.discriminant()
  42          a6_prime = derivative(j,u)       #assumes can differentiate wrto u
  43          if a6_prime == 0:
  44              raise ValueError('p-descent only defined if j is not a p-th power')
  45          def DD(z):
  46             return (a2*a6/a6_prime)*derivative(z,u)
  47 
  48          if 2*P==E(0):
  49             return 0
  50          else:
  51             x=self[0]/self[2]
  52             y=self[1]/self[2]
  53             return wp(DD(x)/(2*y))+y+wp((x**2+(-DD(a2)/a2+DD(a6)/a6)*x)/(2*y))
  54 
  55 
  56  
  57    else:
  58          R = k['x']
  59          x = R.gen()
  60          ES = E.short_weierstrass_model()
  61          a4 = ES.a4()
  62          a6 = ES.a6()
  63          f=(x**3 + a4*x + a6)**((p-1)//2)
  64          A = f.coeffs()[p-1]    #Hasse invariant of E, maybe replace by function call
  65          M =  f.quo_rem(x**p)[0]
  66 
  67          def wp(z):
  68             return z**p-A*z
  69 
  70          delta = ES.discriminant()
  71          j = ES.j_invariant()
  72          j_prime = derivative(j,u)       #assumes can differentiate wrto u
  73          if j_prime == 0:
  74              raise ValueError('p-descent only defined if j is not a p-th power')
  75 
  76          def DD(z):
  77             return 18*(a6/a4)*(j/j_prime)*derivative(z,u)
  78 
  79 
  80          if 2*P==E(0):
  81             return 0
  82          else:
  83             x=self[0]/self[2]
  84             y=self[1]/self[2]
  85             return wp(DD(x)/(2*y))+y*M(x)+wp((-2*x**2-(1/6)*(DD(delta)/delta)*x-(4/3)*a4)/(2*y))