Ticket #9684: 9684_dirty_model.patch

sage/schemes/elliptic_curves/ell_local_data.py

@@ -262 +262 @@
             self._KS = KodairaSymbol(data[1].python())
             self._cp = data[3].python()
             # We use a global minimal model since we can:
-            self._Emin = Eint.minimal_model()
-            self._val_disc = self._Emin.discriminant().valuation(p)
+            self._Emin_tidy = Eint.minimal_model()
+            self._val_disc = self._Emin_tidy.discriminant().valuation(p)
             if self._fp>0:
                 self._reduction_type = Eint.ap(p) # = 0,-1 or +1
         else:        
@@ -294 +294 @@
         red_type = "good"
         if not self._reduction_type is None:
             red_type = ["bad non-split multiplicative","bad additive","bad split multiplicative"][1+self._reduction_type]
-        return "Local data at %s:\nReduction type: %s\nLocal minimal model: %s\nMinimal discriminant valuation: %s\nConductor exponent: %s\nKodaira Symbol: %s\nTamagawa Number: %s"%(self._prime,red_type,self._Emin,self._val_disc,self._fp,self._KS,self._cp)
+        return "Local data at %s:\nReduction type: %s\nLocal minimal model: %s\nMinimal discriminant valuation: %s\nConductor exponent: %s\nKodaira Symbol: %s\nTamagawa Number: %s"%(self._prime,red_type,self.minimal_model(),self._val_disc,self._fp,self._KS,self._cp)
 
-    def minimal_model(self):
+    def minimal_model(self, tidy=True):
         """
         Return the (local) minimal model from this local reduction data.
 
+        INPUT:
+
+        - ``tidy`` -- (default: True) if set to True the EC returned by Tate's algorithm will be 
+          "tidied" as specified in _tidy_model() for curves over number fields.
+
         EXAMPLES::
 
             sage: from sage.schemes.elliptic_curves.ell_local_data import EllipticCurveLocalData
@@ -310 +315 @@
             Elliptic Curve defined by y^2 = x^3 + 1 over Rational Field
             sage: data.minimal_model() == E.local_minimal_model(2)
             True
+
+        To demonstrate the behaviour of the parameter ``tidy``::
+
+            sage: K.<a> = NumberField(x^3+x+1)
+            sage: E = EllipticCurve(K, [0, 0, a, 0, 1])
+            sage: E.local_data(K.ideal(a-1)).minimal_model()
+            Elliptic Curve defined by y^2 + a*y = x^3 + 1 over Number Field in a with defining polynomial x^3 + x + 1
+            sage: E.local_data(K.ideal(a-1)).minimal_model(tidy=False)
+            Elliptic Curve defined by y^2 + (a+2)*y = x^3 + 3*x^2 + 3*x + (-a+1) over Number Field in a with defining polynomial x^3 + x + 1
+
+            sage: E = EllipticCurve([2, 1, 0, -2, -1])
+            sage: E.local_data(ZZ.ideal(2), algorithm="generic").minimal_model(tidy=False)
+            Elliptic Curve defined by y^2 + 2*x*y + 2*y = x^3 + x^2 - 4*x - 2 over Rational Field
+            sage: E.local_data(ZZ.ideal(2), algorithm="pari").minimal_model(tidy=False)
+            Traceback (most recent call last):
+            ...
+            ValueError: the argument tidy must not be False if algorithm=pari is used
+            sage: E.local_data(ZZ.ideal(2), algorithm="generic").minimal_model()
+            Elliptic Curve defined by y^2 = x^3 - x^2 - 3*x + 2 over Rational Field
+            sage: E.local_data(ZZ.ideal(2), algorithm="pari").minimal_model()
+            Elliptic Curve defined by y^2 = x^3 - x^2 - 3*x + 2 over Rational Field
         """
-        return self._Emin
+        if tidy:
+            try:
+                return self._Emin_tidy
+            except AttributeError:
+                pass
+            self._Emin_tidy = self._Emin._tidy_model()
+            return self._Emin_tidy
+        else:
+            try:
+                return self._Emin
+            except AttributeError:
+                raise ValueError, "the argument tidy must not be False if algorithm=pari is used"
 
     def prime(self):
         """
@@ -938 +975 @@
                 pie *= pi # now pie=pi^6
                 a6 /= pie
                 verbose("Non-minimal equation, dividing out...\nNew model is %s"%([a1, a2, a3, a4, a6]), t, 1)
-        C = C._tidy_model()
         return (C, p, val_disc, fp, KS, cp, split)
     
     

sage/schemes/elliptic_curves/ell_number_field.py

@@ -439 +439 @@
         raise DeprecationWarning, "local_information is deprecated; use local_data instead"
         return self.local_data(P,proof)
 
-    def local_data(self, P=None, proof = None):
+    def local_data(self, P=None, proof = None, algorithm="pari"):
         r"""
         Local data for this elliptic curve at the prime `P`.
 
@@ -451 +451 @@
           (default controlled by global proof module).  Note that the
           proof module is number_field, not elliptic_curves, since the
           functions that actually need the flag are in number fields.
+
+        - ``algorithm`` (string, default: "pari") -- Ignored unless the
+          base field is `\QQ`.  If "pari", use the PARI C-library
+          ``ellglobalred`` implementation of Tate's algorithm over
+          `\QQ`. If "generic", use the general number field
+          implementation.
                      
         OUTPUT:
 
@@ -521 +527 @@
         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)       
+        return self._get_local_data(P,proof,algorithm)       
 
-    def _get_local_data(self, P, proof):
+    def _get_local_data(self, P, proof, algorithm="pari"):
         r"""
         Internal function to create data for this elliptic curve at the prime `P`.
         
@@ -539 +545 @@
           (default controlled by global proof module).  Note that the
           proof module is number_field, not elliptic_curves, since the
           functions that actually need the flag are in number fields.
+
+        - ``algorithm`` (string, default: "pari") -- Ignored unless the
+          base field is `\QQ`.  If "pari", use the PARI C-library
+          ``ellglobalred`` implementation of Tate's algorithm over
+          `\QQ`. If "generic", use the general number field
+          implementation.
                      
         EXAMPLES::
 
@@ -554 +566 @@
             Kodaira Symbol: I0
             Tamagawa Number: 1
             
-        Verify that we cache based on the proof value::
+        Verify that we cache based on the proof value and the algorithm choice::
 
             sage: E._get_local_data(p, False) is E._get_local_data(p, True)
             False
+
+            sage: E._get_local_data(p, None, "pari") is E._get_local_data(p, None, "generic")
+            False
         """
         try:
-            return self._local_data[P, proof]
+            return self._local_data[P, proof, algorithm]
         except AttributeError:
             self._local_data = {}
         except KeyError:
             pass
         from sage.schemes.elliptic_curves.ell_local_data import EllipticCurveLocalData    
-        self._local_data[P, proof] = EllipticCurveLocalData(self, P, proof)
-        return self._local_data[P, proof]       
+        self._local_data[P, proof, algorithm] = EllipticCurveLocalData(self, P, proof, algorithm)
+        return self._local_data[P, proof, algorithm]       
 
-    def local_minimal_model(self, P, proof = None):
+    def local_minimal_model(self, P, proof = None, algorithm="pari"):
         r"""
         Returns a model which is integral at all primes and minimal at `P`.
 
@@ -581 +596 @@
           (default controlled by global proof module).  Note that the
           proof module is number_field, not elliptic_curves, since the
           functions that actually need the flag are in number fields.
+
+        - ``algorithm`` (string, default: "pari") -- Ignored unless the
+          base field is `\QQ`.  If "pari", use the PARI C-library
+          ``ellglobalred`` implementation of Tate's algorithm over
+          `\QQ`. If "generic", use the general number field
+          implementation.
                      
         OUTPUT:
 
@@ -609 +630 @@
             # 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).minimal_model()
+        return self.local_data(P, proof, algorithm).minimal_model()
 
     def has_good_reduction(self, P):
         r"""