Ticket #11630: trac_11630_localize_tates_algorithm.patch

sage/schemes/elliptic_curves/ell_local_data.py

@@ -61 +61 @@
     sage: EK = E.base_extend(K)
     sage: da = EK.local_data(1+i)
     sage: da.minimal_model()
-    Elliptic Curve defined by y^2 = x^3 + i over Number Field in i with defining polynomial x^2 + 1
+    Elliptic Curve defined by y^2 = x^3 + (-i) over Number Field in i with defining polynomial x^2 + 1
 
 REFERENCES:
     
@@ -151 +151 @@
 
     """
     
-    def __init__(self, E, P, proof=None, algorithm="pari"):
+    def __init__(self, E, P, proof=None, algorithm="pari", globally=False):
         r"""
         Initializes the reduction data for the elliptic curve `E` at the prime `P`.
 
@@ -173 +173 @@
           `\QQ`. If "generic", use the general number field
           implementation.
 
+        - ``globally`` (bool, default: False) -- If True, the algorithm
+          uses the generators of principal ideals rather than an arbitrary
+          uniformizer.
+
         .. note::
 
            This function is not normally called directly by users, who
@@ -267 +271 @@
             if self._fp>0:
                 self._reduction_type = Eint.ap(p) # = 0,-1 or +1
         else:        
-            self._Emin, ch, self._val_disc, self._fp, self._KS, self._cp, self._split = self._tate(proof)
+            self._Emin, ch, self._val_disc, self._fp, self._KS, self._cp, self._split = self._tate(proof, globally)
             if self._fp>0:
                 if self._Emin.c4().valuation(p)>0:
                     self._reduction_type = 0
@@ -604 +608 @@
         """
         return self._reduction_type == 0
        
-    def _tate(self, proof = None):
+    def _tate(self, proof = None, globally=False):
         r"""
         Tate's algorithm for an elliptic curve over a number field.
 
@@ -617 +621 @@
         principal, the minimal model returned will preserve
         integrality at other primes, but not minimality.
 
+        The optional argument globally, when set to True, tells the algorithm to use
+        the generator of the prime ideal if it is principal. Otherwise just any
+        uniformizer will be used.
+
         .. note:: 
 
            Called only by ``EllipticCurveLocalData.__init__()``.
@@ -664 +672 @@
             sage: E.tamagawa_number(K.ideal(2))
             4
 
+        This is to show that the bug #11630 is fixed. (The computation
+        of the class group would produce a warning)::
+
+             sage: K.<t> = NumberField(x^7-2*x+177)
+             sage: E = EllipticCurve([0,1,0,t,t])
+             sage: P = K.ideal(2,t^3 + t + 1)
+             sage: E.local_data(P).kodaira_symbol()
+             II
+
         """
         E = self._curve
         P = self._prime
@@ -683 +700 @@
         # primes, so that we can divide by it without losing
         # integrality at other primes.
 
-        principal_flag = P.is_principal()
-        if principal_flag:
+        if globally:
+            principal_flag = P.is_principal()
+        else:
+            principal_flag = False
+
+        if (K is QQ) or principal_flag :
             pi = P.gens_reduced()[0]
             verbose("P is principal, generator pi = %s"%pi, t, 1)
         else:
             pi = K.uniformizer(P, 'positive')
-            verbose("P is not principal, uniformizer pi = %s"%pi, t, 1)
+            verbose("uniformizer pi = %s"%pi, t, 1)
         pi2 = pi*pi; pi3 = pi*pi2; pi4 = pi*pi3
         pi_neg = None
         prime = pi if K is QQ else P

sage/schemes/elliptic_curves/ell_number_field.py

@@ -667 +667 @@
         raise DeprecationWarning, "local_information is deprecated; use local_data instead"
         return self.local_data(P,proof)
 
-    def local_data(self, P=None, proof = None, algorithm="pari"):
+    def local_data(self, P=None, proof = None, algorithm="pari", globally=False):
         r"""
         Local data for this elliptic curve at the prime `P`.
 
@@ -685 +685 @@
           ``ellglobalred`` implementation of Tate's algorithm over
           `\QQ`. If "generic", use the general number field
           implementation.
-                     
+
+        - ``globally`` (boolean, default=False) -- indicates if Tate's
+          algorithm should use a generator for principal ideals rather
+          than just a local uniformizer.
+
         OUTPUT:
 
         If `P` is specified, returns the ``EllipticCurveLocalData``
@@ -755 +759 @@
         from sage.schemes.elliptic_curves.ell_local_data import check_prime
         P = check_prime(self.base_field(),P)
 
-        return self._get_local_data(P,proof,algorithm)
+        return self._get_local_data(P,proof,algorithm,globally)
 
-    def _get_local_data(self, P, proof, algorithm="pari"):
+    def _get_local_data(self, P, proof, algorithm="pari",globally=False):
         r"""
         Internal function to create data for this elliptic curve at the prime `P`.
         
@@ -779 +783 @@
           ``ellglobalred`` implementation of Tate's algorithm over
           `\QQ`. If "generic", use the general number field
           implementation.
-                     
+
+        - ``globally`` (boolean, default=False) -- indicates if Tate's
+          algorithm should use a generator for principal ideals rather
+          than just a local uniformizer.
+
         EXAMPLES::
 
             sage: K.<i> = NumberField(x^2+1)
@@ -803 +811 @@
             False
         """
         try:
-            return self._local_data[P, proof, algorithm]
+            return self._local_data[P, proof, algorithm, globally]
         except AttributeError:
             self._local_data = {}
         except KeyError:
             pass
         from sage.schemes.elliptic_curves.ell_local_data import EllipticCurveLocalData
-        self._local_data[P, proof, algorithm] = EllipticCurveLocalData(self, P, proof, algorithm)
-        return self._local_data[P, proof, algorithm]
+        self._local_data[P, proof, algorithm, globally] = EllipticCurveLocalData(self, P, proof, algorithm, globally)
+        return self._local_data[P, proof, algorithm, globally]
 
     def local_minimal_model(self, P, proof = None, algorithm="pari"):
         r"""
@@ -830 +838 @@
           ``ellglobalred`` implementation of Tate's algorithm over
           `\QQ`. If "generic", use the general number field
           implementation.
-                     
+
         OUTPUT:
 
         A model of the curve which is minimal (and integral) at `P`.
@@ -839 +847 @@
 
            The model is not required to be integral on input.
 
-           For principal `P`, a generator is used as a uniformizer,
-           and integrality or minimality at other primes is not
-           affected.  For non-principal `P`, the minimal model
-           returned will preserve integrality at other primes, but not
-           minimality.
+           The minimal model returned will preserve integrality
+           at other primes, but not minimality.
 
         EXAMPLES::
 
@@ -858 +863 @@
             # We use the "number_field" flag because the actual proof dependence is in PARI's number field functions.
             proof = sage.structure.proof.proof.get_flag(None, "number_field")
 
-        return self.local_data(P, proof, algorithm).minimal_model()
+        return self.local_data(P, proof, algorithm, globally=False).minimal_model()
 
     def has_good_reduction(self, P):
         r"""
@@ -1351 +1356 @@
         E = self.global_integral_model()
         primes = E.base_ring()(E.discriminant()).support()
         for P in primes:
-            E = E.local_data(P,proof).minimal_model()
+            E = E.local_data(P,proof,globally=True).minimal_model()
         return E._reduce_model()
 
     def reduction(self,place):