Minor speedup by more agressive caching

Not sure if this is really worth the little change it makes

Author: saraedum

developing_valuation.py

@@ -200,7 +200,7 @@ def _quo_rem_monomial(self, degree):
         f = self.domain().one() << degree
         return f.quo_rem(self.phi())
 
-    def newton_polygon(self, f):
+    def newton_polygon(self, f, valuations=None):
         r"""
         Return the newton polygon the `\phi`-adic development of ``f``.
 
@@ -228,7 +228,9 @@ def newton_polygon(self, f):
         f = self.domain().coerce(f)
 
         from sage.geometry.newton_polygon import NewtonPolygon
-        return NewtonPolygon(enumerate(self.valuations(f)))
+        if valuations is None:
+            valuations = self.valuations(f)
+        return NewtonPolygon(enumerate(valuations))
 
     def _call_(self, f):
         r"""

inductive_valuation.py

@@ -651,7 +651,7 @@ def augmentation(self, phi, mu, check=True):
         from augmented_valuation import AugmentedValuation
         return AugmentedValuation(self, phi, mu, check)
 
-    def mac_lane_step(self, G, assume_squarefree=False, assume_equivalence_irreducible=False, report_degree_bounds=False):
+    def mac_lane_step(self, G, assume_squarefree=False, assume_equivalence_irreducible=False, report_degree_bounds_and_caches=False, coefficients=None, valuations=None):
         r"""
         Perform an approximation step towards the squarefree monic non-constant
         integral polynomial ``G`` which is not an :meth:`equivalence_unit`.
@@ -686,8 +686,10 @@ def mac_lane_step(self, G, assume_squarefree=False, assume_equivalence_irreducib
         if not G.is_monic():
             raise ValueError("G must be monic")
 
-        coefficients = list(self.coefficients(G))
-        valuations = list(self.valuations(G, coefficients=coefficients))
+        if coefficients is None:
+            coefficients = list(self.coefficients(G))
+        if valuations is None:
+            valuations = list(self.valuations(G, coefficients=coefficients))
 
         if min(valuations) < 0:
             raise ValueError("G must be integral")
@@ -707,7 +709,7 @@ def mac_lane_step(self, G, assume_squarefree=False, assume_equivalence_irreducib
         assert len(F), "%s equivalence-decomposes as an equivalence-unit %s"%(G, F)
         if len(F) == 1 and F[0][1] == 1 and F[0][0].degree() == G.degree():
             assert self.is_key(G, assume_equivalence_irreducible=assume_equivalence_irreducible)
-            ret.append((self.augmentation(G, infinity, check=False), G.degree()))
+            ret.append((self.augmentation(G, infinity, check=False), G.degree(), None, None))
         else:
             for phi,e in F:
                 if G == phi:
@@ -720,7 +722,7 @@ def mac_lane_step(self, G, assume_squarefree=False, assume_equivalence_irreducib
                     prec = min([c.precision_absolute() for c in phi.list()])
                     g = G.map_coefficients(lambda c:c.add_bigoh(prec))
                     assert self.is_key(g)
-                    ret.append((self.augmentation(g, infinity, check=False), g.degree()))
+                    ret.append((self.augmentation(g, infinity, check=False), g.degree(), None, None))
                     assert len(F) == 1
                     break
 
@@ -739,7 +741,9 @@ def mac_lane_step(self, G, assume_squarefree=False, assume_equivalence_irreducib
                 verbose("Determining the augmentation for %s"%phi, level=11)
                 old_mu = self(phi)
                 w = self.augmentation(phi, old_mu, check=False)
-                NP = w.newton_polygon(G).principal_part()
+                w_coefficients = list(w.coefficients(G))
+                w_valuations = list(w.valuations(G, coefficients=w_coefficients))
+                NP = w.newton_polygon(G, valuations=w_valuations).principal_part()
                 verbose("Newton-Polygon for v(phi)=%s : %s"%(self(phi), NP), level=11)
                 slopes = NP.slopes(repetition=True)
                 multiplicities = {slope : len([s for s in slopes if s == slope]) for slope in slopes}
@@ -768,13 +772,14 @@ def mac_lane_step(self, G, assume_squarefree=False, assume_equivalence_irreducib
 
                     phi = G.parent()(phi)
                     w = self._base_valuation.augmentation(phi, infinity, check=False)
-                    ret.append((w, phi.degree()))
+                    ret.append((w, phi.degree(), None, None))
                     continue
 
                 for i, slope in enumerate(slopes):
                     slope = slopes[i]
                     verbose("Slope = %s"%slope, level=12)
                     new_mu = old_mu - slope
+                    new_valuations = [val - (j*slope if slope is not -infinity else (0 if j == 0 else -infinity)) for j,val in enumerate(w_valuations)]
                     base = self
                     if phi.degree() == base.phi().degree():
                         assert new_mu > self(phi)
@@ -786,11 +791,11 @@ def mac_lane_step(self, G, assume_squarefree=False, assume_equivalence_irreducib
                     from sage.rings.all import ZZ
                     assert (phi.degree() / self.phi().degree()) in ZZ 
                     degree_bound = multiplicities[slope] * self.phi().degree()
-                    ret.append((w, degree_bound))
+                    ret.append((w, degree_bound, w_coefficients, new_valuations))
 
         assert ret
-        if not report_degree_bounds:
-            ret = [v for v,_ in ret]
+        if not report_degree_bounds_and_caches:
+            ret = [v for v,_,_,_ in ret]
         return ret
 
     def is_key(self, phi, explain=False, assume_equivalence_irreducible=False):

valuation.py

@@ -637,13 +637,15 @@ def mac_lane_approximants(self, G, assume_squarefree=False, require_final_EF=Tru
         from gauss_valuation import GaussValuation
 
         # Leaves in the computation of the tree of approximants. Each vertex
-        # consists of a triple (v,ef,p) where v is an approximant, i.e., a
-        # valuation, ef is a boolean, and p is the parent of this vertex.
+        # consists of a tuple (v,ef,p,coeffs,vals) where v is an approximant, i.e., a
+        # valuation, ef is a boolean, p is the parent of this vertex, and
+        # coeffs and vals are cached values. (Only v and ef are relevant,
+        # everything else are caches/debug info.)
         # The boolean ef denotes whether v already has the final ramification
         # index E and residue degree F of this approximant.
         # An edge V -- P represents the relation P.v ≤ V.v (pointwise on the
         # polynomial ring K[x]) between the valuations.
-        leaves = [ (GaussValuation(R, self), G.degree() == 1, None) ]
+        leaves = [ (GaussValuation(R, self), G.degree() == 1, None, None, None) ]
 
         if require_maximal_degree:
             # we can only assert maximality of degrees when E and F are final
@@ -660,7 +662,7 @@ def mac_lane_approximants(self, G, assume_squarefree=False, require_final_EF=Tru
                 pass
 
         def is_sufficient(leaf, others):
-            valuation, ef, parent = leaf
+            valuation, ef, _, _, _ = leaf
             if valuation.mu() < required_precision:
                 return False
             if require_final_EF and not ef:
@@ -675,21 +677,21 @@ def is_sufficient(leaf, others):
         while True:
             new_leaves = []
             for leaf in leaves:
-                v, ef, parent = leaf
-                others = [w for (w,_,_) in leaves if w != v]
-                if is_sufficient((v,ef,parent), others):
+                v, ef, coefficients, valuations, parent = leaf
+                others = [w for (w,_,_,_,_) in leaves if w != v]
+                if is_sufficient(leaf, others):
                     new_leaves.append(leaf)
                 else:
-                    augmentations = v.mac_lane_step(G, report_degree_bounds=True)
-                    for w, bound in augmentations:
+                    augmentations = v.mac_lane_step(G, report_degree_bounds_and_caches=True, coefficients=coefficients, valuations=valuations)
+                    for w, bound, coefficients, valuations in augmentations:
                         ef = bound == w.E()*w.F()
-                        new_leaves.append((w, ef, leaf))
+                        new_leaves.append((w, ef, coefficients, valuations, leaf))
 
             if leaves == new_leaves:
                 break
             leaves = new_leaves
 
-        return [v for v,_,_ in leaves]
+        return [v for v,_,_,_,_ in leaves]
 
     def mac_lane_approximant(self, G, valuation, approximants = None):
         r"""