snappy 3.0.3__cp38-cp38-macosx_11_0_arm64.whl → 3.2__cp38-cp38-macosx_11_0_arm64.whl

snappy/ptolemy/ptolemyVariety.py

@@ -5,6 +5,7 @@ from .ptolemyObstructionClass import PtolemyObstructionClass
 from .ptolemyGeneralizedObstructionClass import PtolemyGeneralizedObstructionClass
 from .ptolemyVarietyPrimeIdealGroebnerBasis import PtolemyVarietyPrimeIdealGroebnerBasis
 from . import processFileBase, processFileDispatch, processMagmaFile
+from .processFileBase import PtolemyPrecomputedObstructionClassMismatchError
 from . import utilities
 from string import Template
 import signal
@@ -21,10 +22,11 @@ try:
 except ImportError:
     _within_sage = False
 
-from urllib.request import urlopen
+from urllib.request import Request, urlopen
 from urllib.request import quote as urlquote
 from urllib.error import HTTPError
 
+
 class PtolemyFileMissingError(Exception):
     """
     An exception indicating that a requested solution file was missing.
@@ -33,8 +35,20 @@ class PtolemyFileMissingError(Exception):
     def __init__(self, message):
         Exception.__init__(self, message)
 
+class PtolemyMissingFileForObstructionClass(Exception):
+    def __init__(self, index):
+
+        msg = (
+            "Pari's implementation of the Smith normal form has changed "
+            "affecting the order in which the cohomology classes are listed "
+            "and the cocycles used to represent them. Unfortunately, the "
+            "pre-computed file uses a cocycle that no longer matches and "
+            "a file matching the new cocycle has not yet been produced. "
+            "Please report the manifold and index (%d)." % index)
+        Exception.__init__(self, msg)
+        self.index = index
 
-class PtolemyVariety(object):
+class PtolemyVariety():
     """
     Holds a reduced Ptolemy variety.
 
@@ -124,7 +138,7 @@ class PtolemyVariety(object):
                 N, manifold.num_tetrahedra(),
                 isinstance(obstruction_class, PtolemyObstructionClass)))
 
-        self.equations = [eqn for eqn in self._ptolemy_relations]
+        self.equations = list(self._ptolemy_relations)
 
         order_of_u = 1
 
@@ -179,7 +193,6 @@ class PtolemyVariety(object):
                 else:
                     u = Polynomial.from_variable_name('u')
 
-
                 firstTerm = (
                     Polynomial.from_variable_name(var1) *
                     u ** (power % order_of_u))
@@ -200,7 +213,7 @@ class PtolemyVariety(object):
         # Only invoked for N >= 4
         for var in self.variables:
             if var[0:2] == 'c_':
-                if not var in self.canonical_representative:
+                if var not in self.canonical_representative:
                     self.canonical_representative[var] = (+1, 0, var)
 
         self.variables_with_non_zero_condition = [ "t" ] + self.variables
@@ -229,7 +242,7 @@ class PtolemyVariety(object):
             def sage_ideal(vars, eqns):
 
                 polynomialRing = PolynomialRing(
-                    RationalField(), vars, order = 'lex')
+                    RationalField(), vars, order='lex')
 
                 return Ideal(
                     polynomialRing, [ sage_eqn(eqn) for eqn in eqns ])
@@ -284,7 +297,7 @@ class PtolemyVariety(object):
 
         >>> eval_section = p.py_eval_section()
         >>> print(eval_section)    #doctest: +ELLIPSIS
-        {'variable_dict' : 
+        {'variable_dict' :
              (lambda d: {
             ...
 
@@ -313,7 +326,7 @@ class PtolemyVariety(object):
         """
 
         result = "{"
-        result += "'variable_dict' : \n     %s" % self.py_eval_variable_dict()
+        result += "'variable_dict' :\n     %s" % self.py_eval_variable_dict()
 
         # If we have a non-trivial generalized obstruction class,
         # add an extra key to the dictionary to mark it.
@@ -334,8 +347,7 @@ class PtolemyVariety(object):
 
     def to_magma_file(
             self, filename,
-            template_path = "magma/default.magma_template"):
-
+            template_path="magma/default.magma_template"):
         """
         >>> import os, tempfile
         >>> from snappy import Manifold
@@ -349,8 +361,7 @@ class PtolemyVariety(object):
 
     def to_magma(
             self,
-            template_path = "magma/default.magma_template"):
-
+            template_path="magma/default.magma_template"):
         """
         Returns a string with the ideal that can be used as input for magma.
 
@@ -400,29 +411,29 @@ class PtolemyVariety(object):
             utilities.break_long_lines(PREAMBLE))
 
         return Template(template).safe_substitute(
-            PREAMBLE = PREAMBLE,
-            QUOTED_PREAMBLE = QUOTED_PREAMBLE,
+            PREAMBLE=PREAMBLE,
+            QUOTED_PREAMBLE=QUOTED_PREAMBLE,
 
-            VARIABLES = (
+            VARIABLES=(
                 ", ".join(self.variables)),
-            VARIABLES_QUOTED = (
+            VARIABLES_QUOTED=(
                 ", ".join(['"%s"' % v for v in self.variables])),
-            VARIABLE_NUMBER = (
+            VARIABLE_NUMBER=(
                 len(self.variables)),
 
-            VARIABLES_WITH_NON_ZERO_CONDITION = (
+            VARIABLES_WITH_NON_ZERO_CONDITION=(
                 ", ".join(self.variables_with_non_zero_condition)),
-            VARIABLES_WITH_NON_ZERO_CONDITION_QUOTED = (
+            VARIABLES_WITH_NON_ZERO_CONDITION_QUOTED=(
                 ", ".join(['"%s"' % v
                            for v in self.variables_with_non_zero_condition])),
-            VARIABLE_WITH_NON_ZERO_CONDITION_NUMBER = (
+            VARIABLE_WITH_NON_ZERO_CONDITION_NUMBER=(
                 len(self.variables_with_non_zero_condition)),
 
-            EQUATIONS = (
+            EQUATIONS=(
                 ',\n          '.join(
                     [str(eqn)
                      for eqn in self.equations])),
-            EQUATIONS_WITH_NON_ZERO_CONDITION = (
+            EQUATIONS_WITH_NON_ZERO_CONDITION=(
                 ',\n          '.join(
                     [str(eqn)
                      for eqn in self.equations_with_non_zero_condition])))
@@ -446,7 +457,7 @@ class PtolemyVariety(object):
 
         if self._obstruction_class is None:
             obstruction_class = "0"
-        elif not self._obstruction_class._index is None:
+        elif self._obstruction_class._index is not None:
             obstruction_class = "%d" % self._obstruction_class._index
         # filenames which contain regex special characters cause
         # trouble with PyInstaller's globbing module.
@@ -473,12 +484,12 @@ class PtolemyVariety(object):
                          dir,
                          '%02d_tetrahedra' % tets])
 
-    def _solution_file_url(self, data_url = None, rur = False):
+    def _solution_file_url(self, alt=0, ext='magma_out', data_url=None):
 
         if data_url is None:
             from . import DATA_URL as data_url
 
-        if not '://' in data_url:
+        if '://' not in data_url:
             # No schema in url, assume file
             if not data_url[0] == '/':
                 data_url = '/' + data_url
@@ -488,48 +499,91 @@ class PtolemyVariety(object):
         if not data_url[-1] == '/':
             data_url = data_url + '/'
 
-        if rur:
-            ext = '.rur'
+        if alt > 0:
+            suffix = '_alt%d' % alt
         else:
-            ext = '.magma_out'
+            suffix = ''
 
-        filename = self.filename_base() + ext
+        filename = self.filename_base() + suffix + "." + ext
 
         return data_url + self.path_to_file() + '/' + urlquote(filename)
 
-    def _retrieve_solution_file(self, data_url = None, prefer_rur = False,
-                                verbose = False):
-
-        # First try to retrieve solutions from the URL corresponding to
-        # the preferred format (i.e., RUR vs magma decomposition)
-
-        url = self._solution_file_url(data_url = data_url,
-                                      rur = prefer_rur)
-        if verbose:
-            print("Trying to retrieve solutions from %s ..." % url)
-
-        try:
-            return _retrieve_url(url)
-
-        except PtolemyFileMissingError:
-
-            # If that file wasn't there, try to retrieve solutions from URL
-            # corresponding to the non-prefered format
-
-            url = self._solution_file_url(data_url = data_url,
-                                          rur = not prefer_rur)
+    def _retrieve_solution_file_alt(self,
+                                    alt=0,
+                                    data_url=None,
+                                    exts=['magma_out', 'rur'],
+                                    verbose=False):
+        for i, ext in enumerate(exts):
+            url = self._solution_file_url(alt=alt,
+                                          data_url=data_url,
+                                          ext=ext)
             if verbose:
-                print("Retrieving solutions instead from %s ...:" % url)
-            return _retrieve_url(url)
-
-
-    def retrieve_decomposition(self, data_url = None, verbose = True):
-
-        url = self._solution_file_url(data_url = data_url, rur = False)
-        if verbose:
-            print("Retrieving decomposition from %s ..." % url)
-
-        text = _retrieve_url(url)
+                print("Trying to retrieve solutions from %s ..." % url)
+
+            try:
+                return _retrieve_url(url)
+            except PtolemyFileMissingError as e:
+                if i == len(exts) - 1:
+                    raise
+
+    def _retrieve_solution_file(self,
+                                data_url=None,
+                                exts=['magma_out', 'rur'],
+                                verbose=False):
+
+        num_alts = 3
+        
+        for alt in range(num_alts):
+            try:
+                text = self._retrieve_solution_file_alt(alt=alt,
+                                                        data_url=data_url,
+                                                        exts=exts,
+                                                        verbose=verbose)
+                self._check_obstruction_class_for_precomputed_file(text)
+                return text
+            except PtolemyPrecomputedObstructionClassMismatchError as e:
+                if alt == num_alts - 1:
+                    raise
+            except PtolemyFileMissingError as e:
+                if alt == 0:
+                    raise
+                else:
+                    raise PtolemyMissingFileForObstructionClass(
+                        self._obstruction_class._index if self._obstruction_class else 0)
+
+    def _check_obstruction_class_for_precomputed_file(
+            self, text):
+
+        # Grab the PY=EVAL=SECTION
+        # Note that this will be evaluated again later.
+        # But it is cheap enough that the double evaluation should not matter.
+        py_eval = processFileBase.get_py_eval(text)
+
+        # Now get the function that takes a dictionary-like object with
+        # the solutions to the variety and expands it to a dictionary
+        # assigning a value to all Ptolemy coordinates and obstruction class
+        # variables.
+        variable_dict_function = py_eval['variable_dict']
+
+        # As noticed by Nathan, the obstruction classes used for producing
+        # the pre-computed solutions do not match the obstruction classes
+        # we compute now.
+        # This is due to pari changing the code for computing the
+        # Smith normal form in version 2.13 (see
+        # http://pari.math.u-bordeaux.fr/archives/pari-announce-20/msg00006.html)
+        #
+        # We thus check here explicitly that the obstruction class still
+        # matches.
+        #
+        processFileBase.check_obstruction_class_for_variable_dict_function(
+            variable_dict_function,
+            self._obstruction_class)
+
+    def retrieve_decomposition(self, data_url=None, verbose=True):
+
+        text = self._retrieve_solution_file(data_url,
+                                            exts=['magma_out'],
+                                            verbose=verbose)
 
         if verbose:
             print("Parsing...")
@@ -540,14 +594,19 @@ class PtolemyVariety(object):
 
         return processMagmaFile.decomposition_from_magma(text)
 
-    def retrieve_solutions(self, numerical = False,
-                           prefer_rur = False,
-                           data_url = None,
-                           verbose = True):
+    def retrieve_solutions(self, numerical=False,
+                           prefer_rur=False,
+                           data_url=None,
+                           verbose=True):
+
+        exts = ['magma_out.gz', 'magma_out', 'rur']
+        if prefer_rur:
+            exts = exts[::-1]
+
+        text = self._retrieve_solution_file(data_url=data_url,
+                                            exts=exts,
+                                            verbose=verbose)
 
-        text = self._retrieve_solution_file(data_url = data_url,
-                                            prefer_rur = prefer_rur,
-                                            verbose = verbose)
         if verbose:
             print("Parsing...")
 
@@ -555,15 +614,15 @@ class PtolemyVariety(object):
         assert M._to_bytes() == self._manifold._to_bytes(), (
             "Manifold does not match census manifold")
 
-        return processFileDispatch.parse_solutions(text, numerical = numerical)
+        return processFileDispatch.parse_solutions(text, numerical=numerical)
 
     def __repr__(self):
 
-        res =  "Ptolemy Variety for %s, N = %d" % (self._manifold.name(),
-                                                   self._N)
-        if not self._obstruction_class is None:
+        res = "Ptolemy Variety for %s, N = %d" % (self._manifold.name(),
+                                                  self._N)
+        if self._obstruction_class is not None:
             res += ", obstruction_class = "
-            if not self._obstruction_class._index is None:
+            if self._obstruction_class._index is not None:
                 res += "%d" % self._obstruction_class._index
                 if isinstance(self._obstruction_class,
                               PtolemyGeneralizedObstructionClass):
@@ -580,12 +639,11 @@ class PtolemyVariety(object):
 
     def compute_decomposition(
         self,
-        engine = None,
-        memory_limit = 750000000,
-        directory = None,
-        verbose = False,
-        template_path = "magma/default.magma_template"):
-
+        engine=None,
+        memory_limit=750000000,
+        directory=None,
+        verbose=False,
+        template_path="magma/default.magma_template"):
         """
         Starts an engine such as magma to compute the
         radical decomposition of the Ptolemy variety.
@@ -608,11 +666,11 @@ class PtolemyVariety(object):
 
         if engine == 'magma':
             return processMagmaFile.run_magma(
-                self.to_magma(template_path = template_path),
-                filename_base = self.filename_base(),
-                memory_limit = memory_limit,
-                directory = directory,
-                verbose = verbose)
+                self.to_magma(template_path=template_path),
+                filename_base=self.filename_base(),
+                memory_limit=memory_limit,
+                directory=directory,
+                verbose=verbose)
 
         if engine == 'sage':
 
@@ -633,30 +691,27 @@ class PtolemyVariety(object):
                     polys = []
 
                 return PtolemyVarietyPrimeIdealGroebnerBasis(
-                    polys = polys,
-                    term_order = 'lex',
-                    size = None,
-                    dimension = dimension,
-                    is_prime = component.is_prime(),
-                    free_variables = None,
-                    py_eval = eval(self.py_eval_section()),
-                    manifold_thunk = lambda :M)
+                    polys=polys,
+                    term_order='lex',
+                    size=None,
+                    dimension=dimension,
+                    is_prime=component.is_prime(),
+                    free_variables=None,
+                    py_eval=eval(self.py_eval_section()),
+                    manifold_thunk=lambda :M)
 
             return utilities.MethodMappingList(
                 [ process_component(component)
                   for component in sage_radical_decomp
                   if not component.is_one()])
 
-
-
     def compute_solutions(self,
-                          engine = None,
-                          numerical = False,
-                          template_path = "magma/default.magma_template",
-                          memory_limit = 750000000,
-                          directory = None,
-                          verbose = False):
-
+                          engine=None,
+                          numerical=False,
+                          template_path="magma/default.magma_template",
+                          memory_limit=750000000,
+                          directory=None,
+                          verbose=False):
         """
         Starts an engine such as magma to compute the
         radical decomposition of the ideal and computes exact solutions.
@@ -673,15 +728,14 @@ class PtolemyVariety(object):
         """
 
         decomposition = self.compute_decomposition(
-            engine = engine,
-            memory_limit = memory_limit,
-            template_path = template_path,
-            directory = directory,
-            verbose = verbose)
-
+            engine=engine,
+            memory_limit=memory_limit,
+            template_path=template_path,
+            directory=directory,
+            verbose=verbose)
 
         return utilities.MethodMappingList(
-                [ component.solutions(numerical = numerical)
+                [ component.solutions(numerical=numerical)
                   for component in decomposition ])
 
     def degree_to_shapes(self):
@@ -744,13 +798,15 @@ class PtolemyVariety(object):
                            for m in f.get_monomials()})
         return result
 
+
 def _fix_decoration(N, action_by_decoration_change):
 
     action_matrix, ptolemy_coords, decorations_to_be_fixed = (
         action_by_decoration_change)
 
     return matrix.get_independent_rows(
-        action_matrix, ptolemy_coords, desired_determinant = N)
+        action_matrix, ptolemy_coords, desired_determinant=N)
+
 
 def _generate_ptolemy_relations(N, num_tet,
                                 has_obstruction_class):
@@ -789,6 +845,7 @@ def _generate_ptolemy_relations(N, num_tet,
             for tet in range(num_tet)
             for index in utilities.quadruples_with_fixed_sum_iterator(N-2)]
 
+
 def _non_zero_condition(variables):
     one = Polynomial.constant_polynomial(1)
 
@@ -801,12 +858,14 @@ def _non_zero_condition(variables):
 
     return polynomial
 
+
 def _union(lists):
     all = sum(lists, [])
     all = list(set(all))
     all.sort()
     return all
 
+
 def _identified_variables_canonize(identified_variables):
 
     def merge_two_dicts(sign, power, var1, var2, dict1, dict2):
@@ -814,7 +873,7 @@ def _identified_variables_canonize(identified_variables):
         sign1, power1 = dict1[var1]
         sign2, power2 = dict2[var2]
 
-        new_sign  = sign1  * sign  * sign2
+        new_sign = sign1 * sign * sign2
         new_power = power1 - power - power2
 
         for v2, (s2, p2) in dict2.items():
@@ -822,7 +881,7 @@ def _identified_variables_canonize(identified_variables):
 
         return dict1
 
-    all_variables = { }
+    all_variables = {}
 
     for sign, power, var1, var2 in identified_variables:
         all_variables[var1] = { var1 : (+1, 0) }
@@ -833,10 +892,10 @@ def _identified_variables_canonize(identified_variables):
             new_dict = merge_two_dicts(sign, power, var1, var2,
                                        all_variables[var1],
                                        all_variables[var2])
-            for var in new_dict.keys():
+            for var in new_dict:
                 all_variables[var] = new_dict
 
-    result = { }
+    result = {}
 
     for variable, variable_dict in all_variables.items():
         if variable not in result:
@@ -857,10 +916,11 @@ def _identified_variables_canonize(identified_variables):
 
     return result
 
+
 def _canonical_representative_to_polynomial_substituition(
         canonical_representative, order_of_u):
 
-    result = { }
+    result = {}
 
     for var1, signed_var2 in canonical_representative.items():
         sign, power, var2 = signed_var2
@@ -876,16 +936,17 @@ def _canonical_representative_to_polynomial_substituition(
                  u ** (power % order_of_u))
 
             if var2 == 1:
-                result[var1] =  sign_and_power
+                result[var1] = sign_and_power
             else:
                 result[var1] = (sign_and_power *
                                 Polynomial.from_variable_name(var2))
 
     return result
 
+
 def _retrieve_url(url):
 
-    overview_url = "http://ptolemy.unhyperbolic.org/data/overview.html"
+    overview_url = "https://ptolemy.unhyperbolic.org/data/overview.html"
 
     try:
         # Remember SnapPy's SIGALRM handler (defined in app.py)
@@ -894,7 +955,9 @@ def _retrieve_url(url):
         sigalrm_handler = None
         if hasattr(signal, 'SIGALRM'):
             sigalrm_handler = signal.signal(signal.SIGALRM, signal.SIG_IGN)
-        s = urlopen(url)
+        r = Request(url,
+                    headers={'User-Agent': 'Wget/1.20.3'})
+        s = urlopen(r)
 
     except HTTPError as e:
         if e.code in [404, 406]:
@@ -909,10 +972,10 @@ def _retrieve_url(url):
                 "is not configured correctly: %s. Also see %s" % (
                     e, overview_url))
 
-    except IOError as e:
+    except OSError as e:
         # IOError: this means the file wasn't there or we couldn't connect
         # to the server
-        if url[:5] == 'http:':
+        if url.startswith('http:') or url.startswith('https'):
             # IOError for http means we could not connect to server
             raise RuntimeError(
                 "Problem connecting to server while retrieving %s: "
@@ -930,10 +993,16 @@ def _retrieve_url(url):
         if sigalrm_handler: # Not supported under windows
             signal.signal(signal.SIGALRM, sigalrm_handler)
 
+    text = s.read()
+
+    if url.endswith('.gz'):
+        import gzip
+        text = gzip.decompress(text)
+
     # Read the text
-    text = s.read().decode('ascii').replace('\r\n', '\n')
+    text = text.decode('ascii').replace('\r\n', '\n')
 
-    if url[:5] != 'http:':
+    if not (url.startswith('http:') or url.startswith('https')):
         # If this is a normal file, we are done
         return text
 

snappy/ptolemy/ptolemyVarietyPrimeIdealGroebnerBasis.py

@@ -3,6 +3,7 @@ from . import numericalSolutionsToGroebnerBasis
 from .component import *
 from .coordinates import PtolemyCoordinates
 
+
 class PtolemyVarietyPrimeIdealGroebnerBasis():
 
     """
@@ -17,16 +18,16 @@ class PtolemyVarietyPrimeIdealGroebnerBasis():
                  is_prime,
                  free_variables,
                  py_eval,
-                 manifold_thunk = lambda : None,
-                 witnesses = [],
-                 genus = None):
+                 manifold_thunk=lambda : None,
+                 witnesses=[],
+                 genus=None):
 
         # Polynomials making up the groebner basis
         self.polys = polys
 
         # Term order "lex" for lexicographic
         self.term_order = term_order
-        
+
         self.dimension = dimension
         self.is_prime = is_prime
         self.free_variables = free_variables
@@ -45,7 +46,7 @@ class PtolemyVarietyPrimeIdealGroebnerBasis():
         # Split the polynomials into the ones requiring extensions and
         # the assignments
         self._extensions_and_assignments_cache = None
-        
+
         # Intermediate computations for exact solution
         self._number_field_and_ext_assignments_cache = None
 
@@ -53,7 +54,7 @@ class PtolemyVarietyPrimeIdealGroebnerBasis():
         is_zero_dim = (self.dimension == 0)
         is_prime = self.is_prime
         is_lex = (self.term_order is None) or (self.term_order == "lex")
-        
+
         return is_zero_dim and is_prime and is_lex
 
     def _extensions_and_assignments(self):
@@ -98,10 +99,10 @@ class PtolemyVarietyPrimeIdealGroebnerBasis():
 
         return PtolemyCoordinates(
             assignments,
-            is_numerical = False, 
-            py_eval_section = self.py_eval,
-            manifold_thunk = self.manifold_thunk)
-        
+            is_numerical=False,
+            py_eval_section=self.py_eval,
+            manifold_thunk=self.manifold_thunk)
+
     def _numerical_solutions(self):
         if not self._is_zero_dim_prime_and_lex():
             raise Exception("Can find solutions only for Groebner basis in "
@@ -116,22 +117,22 @@ class PtolemyVarietyPrimeIdealGroebnerBasis():
 
             return PtolemyCoordinates(
                 solution,
-                is_numerical = True,
-                py_eval_section = self.py_eval,
-                manifold_thunk = self.manifold_thunk)
-            
+                is_numerical=True,
+                py_eval_section=self.py_eval,
+                manifold_thunk=self.manifold_thunk)
+
         return ZeroDimensionalComponent(
             [ process_solution(sol) for sol in sols ])
 
-    def solutions(self, numerical = False):
+    def solutions(self, numerical=False):
 
         if self.dimension > 0:
             return NonZeroDimensionalComponent(
-                [ witness.solutions(numerical = numerical)
+                [ witness.solutions(numerical=numerical)
                   for witness in self.witnesses ],
-                dimension = self.dimension,
-                free_variables = self.free_variables,
-                genus = self.genus)
+                dimension=self.dimension,
+                free_variables=self.free_variables,
+                genus=self.genus)
 
         if numerical:
             return self._numerical_solutions()