snappy 3.1.1__cp312-cp312-macosx_11_0_arm64.whl → 3.2__cp312-cp312-macosx_11_0_arm64.whl

snappy/ptolemy/polynomial.py

@@ -1,10 +1,6 @@
 import re
 import operator
 from fractions import Fraction
-import sys
-
-long = int
-unicode = str
 
 #######################################################
 # Public Definitions of Monomial and Polynomial class
@@ -21,7 +17,7 @@ class Monomial():
     @classmethod
     def from_variable_name(cls, var):
         """Construct a monomial with a single variable given as a string."""
-        assert isinstance(var, str) or isinstance(var, unicode)
+        assert isinstance(var, str)
         return Monomial(1, ((var, 1),))
 
     # Constructs a constant monomial
@@ -47,7 +43,7 @@ class Monomial():
         else:
             assert isinstance(vars, tuple)
             for var, expo in vars:
-                assert isinstance(var, str) or isinstance(var, unicode)
+                assert isinstance(var, str)
                 assert isinstance(expo, int)
                 assert expo > 0
             self._vars = vars
@@ -124,7 +120,7 @@ class Monomial():
 
         # Compute the variables
         var_dict = _combine_dicts(
-            [dict(self._vars),dict(other._vars)],
+            [dict(self._vars), dict(other._vars)],
             operator.add)
 
         return Monomial(coefficient, var_dict)
@@ -138,9 +134,9 @@ class Monomial():
             return Monomial.constant_monomial(1)
         if other == 1:
             return self
-        if other % 2 == 1:
-            return self * (self ** (other-1))
-        return (self * self) ** (other//2)
+        if other % 2:
+            return self * (self ** (other - 1))
+        return (self * self) ** (other // 2)
 
     def __neg__(self):
         """Negate this monomial."""
@@ -166,7 +162,7 @@ class Monomial():
 
     def split_variable(self, variable):
         """Split the specified variable from the others."""
-        remaining_terms = { }
+        remaining_terms = {}
         exponent = 0
         for var, expo in self._vars:
             if var == variable:
@@ -258,12 +254,12 @@ class Polynomial():
     @classmethod
     def constant_polynomial(cls, constant):
         """Construct a constant polynomial."""
-        return Polynomial( (Monomial.constant_monomial(constant),))
+        return Polynomial((Monomial.constant_monomial(constant),))
 
     @classmethod
     def from_variable_name(cls, var):
         """Construct a polynomial consisting of a single variable."""
-        return Polynomial( (Monomial.from_variable_name(var),))
+        return Polynomial((Monomial.from_variable_name(var),))
 
     # constructor takes a tuple of polynomials which are combined
 
@@ -279,7 +275,7 @@ class Polynomial():
         # and value being the coefficient
 
         list_of_vars_coeff_dicts = [
-            { monomial.get_vars() : monomial.get_coefficient() }
+            {monomial.get_vars(): monomial.get_coefficient()}
             for monomial in monomials]
 
         # combine the dictionaries using sum
@@ -327,9 +323,9 @@ class Polynomial():
             return Polynomial((Monomial.constant_monomial(1),))
         if other == 1:
             return self
-        if other % 2 == 1:
-            return self * (self ** (other-1))
-        return (self * self) ** (other//2)
+        if other % 2:
+            return self * (self ** (other - 1))
+        return (self * self) ** (other // 2)
 
     def __mul__(self, other):
         monomials = []
@@ -352,7 +348,7 @@ class Polynomial():
 
         other = other.convert_coefficients(Fraction)
         other = other * Polynomial.constant_polynomial(
-            Fraction(1,1) / other.leading_coefficient())
+            Fraction(1, 1) / other.leading_coefficient())
 
         variable = other.variables()[0]
         assert ((not other.variables())
@@ -392,8 +388,8 @@ class Polynomial():
         """Convert all coefficients using conversion_function."""
 
         return Polynomial(tuple(
-                [monomial.convert_coefficient(conversion_function)
-                 for monomial in self._monomials]))
+            [monomial.convert_coefficient(conversion_function)
+             for monomial in self._monomials]))
 
     def substitute(self, d):
         """
@@ -417,11 +413,11 @@ class Polynomial():
 
             for var, expo in vars:
                 if var not in d:
-                    new_vars.append((var,expo))
+                    new_vars.append((var, expo))
 
             poly = Polynomial((
-                    Monomial(monomial.get_coefficient(),
-                             tuple(new_vars)),))
+                Monomial(monomial.get_coefficient(),
+                         tuple(new_vars)),))
 
             for var, expo in vars:
                 if var in d:
@@ -430,7 +426,7 @@ class Polynomial():
             return poly
 
         return sum([substitute_monomial(monomial)
-                     for monomial in self._monomials], Polynomial(()))
+                    for monomial in self._monomials], Polynomial(()))
 
     def variables(self):
         """Return a list of all variables in the polynomial."""
@@ -478,11 +474,11 @@ class Polynomial():
         """Assert univariance; return True iff this polynomial is monic."""
         return self.leading_coefficient() == 1
 
-    def get_coefficients(self, conversion_function=lambda x:x):
+    def get_coefficients(self, conversion_function=lambda x: x):
         """Assert univariance; return the coefficients in degree order."""
         assert self.is_univariate()
         degree = self.degree()
-        list_of_coefficients = (degree + 1) * [ conversion_function(0) ]
+        list_of_coefficients = (degree + 1) * [conversion_function(0)]
         for monomial in self._monomials:
             list_of_coefficients[degree - monomial.degree()] = (
                 conversion_function(monomial.get_coefficient()))
@@ -533,7 +529,7 @@ class Polynomial():
 
     def factor_out_variables(self):
 
-        if self._monomials == ():
+        if not self._monomials:
             return self
 
         def intersect(lists):
@@ -543,22 +539,21 @@ class Polynomial():
             return s
 
         non_trivial_variables = intersect(
-            [ monomial.variables() for monomial in self._monomials])
+            [monomial.variables() for monomial in self._monomials])
 
-        lowest_powers = dict([ (var,1000000) for var in non_trivial_variables ])
+        lowest_powers = {var: 1000000 for var in non_trivial_variables}
 
-        def safe_dict(d,var):
+        def safe_dict(d, var):
             if var in d:
                 return d[var]
-            else:
-                return 0
+            return 0
 
         for monomial in self._monomials:
             for var, expo in monomial.get_vars():
-                lowest_powers[var] = min(safe_dict(lowest_powers,var), expo)
+                lowest_powers[var] = min(safe_dict(lowest_powers, var), expo)
 
-        return Polynomial(tuple([ monomial.reduce_exponents(lowest_powers)
-                                  for monomial in self._monomials]))
+        return Polynomial(tuple([monomial.reduce_exponents(lowest_powers)
+                                 for monomial in self._monomials]))
 
 ###############################################################
 # Default functions for parsing and printing the coefficients
@@ -568,7 +563,7 @@ class Polynomial():
 
 
 def parse_int_coefficient(s):
-    coeff, rest = re.match('([0-9]*)(.*)',s).groups()
+    coeff, rest = re.match('([0-9]*)(.*)', s).groups()
     if coeff:
         coeff = int(coeff)
     else:
@@ -577,7 +572,7 @@ def parse_int_coefficient(s):
 
 
 def parse_int_or_fraction(s):
-    m = re.match('([0-9]+/[0-9]+)(.*)',s)
+    m = re.match('([0-9]+/[0-9]+)(.*)', s)
     if m:
         frac, rest = m.groups()
         return Fraction(frac), rest
@@ -623,9 +618,9 @@ def _storage_type_policy(type_a, type_b):
     assert isinstance(type_a, type)
     assert isinstance(type_b, type)
 
-    if type_a in [int, long]:
+    if type_a in [int]:
         return type_b
-    if type_b in [int, long]:
+    if type_b in [int]:
         return type_a
 
     if not type_a == type_b:
@@ -642,9 +637,9 @@ def _operator_type_policy(obj_a, obj_b, op=operator.add):
 
         if type(obj_a) == type(obj_b):
             return op(obj_a, obj_b)
-        if type(obj_a) in [int, long]:
+        if type(obj_a) in [int]:
             return op(type(obj_b)(obj_a), obj_b)
-        if type(obj_b) in [int, long]:
+        if type(obj_b) in [int]:
             return op(type(obj_a)(obj_b), obj_a)
 
         raise Exception
@@ -660,23 +655,21 @@ def _operator_type_policy(obj_a, obj_b, op=operator.add):
 
 
 _operators = {
-    '+' : operator.add,
-    '-' : operator.sub,
-    '*' : operator.mul,
-    '^' : operator.pow
-    }
+    '+': operator.add,
+    '-': operator.sub,
+    '*': operator.mul,
+    '^': operator.pow}
 
 _operator_precedence = {
-    None : 0,
-    '+' : 1,
-    '-' : 1,
-    '*' : 2,
-    '^' : 3
-    }
+    None: 0,
+    '+': 1,
+    '-': 1,
+    '*': 2,
+    '^': 3}
 
 
 def _apply_operator(op, l, r):
-    return _operators[op](l,r)
+    return _operators[op](l, r)
 
 # Helper functions for parsing
 
@@ -690,7 +683,7 @@ def _coefficient_is_non_trivial(c):
 
 
 def _parse_variable(s):
-    r = re.match(r'([_A-Za-z][_A-Za-z0-9]*)(.*)$',s)
+    r = re.match(r'([_A-Za-z][_A-Za-z0-9]*)(.*)$', s)
     if r:
         return r.groups()
     else:
@@ -709,7 +702,7 @@ def _parse_polynomial_from_string(s, parse_coefficient_function):
 
     # Has there been an operand since the opening parenthesis
     # e.g. parse things like "(+ x)"
-    no_operand_since_opening_parenthesis = [ True ]
+    no_operand_since_opening_parenthesis = [True]
 
     def debug_print(s):
         print("=" * 75)
@@ -730,7 +723,7 @@ def _parse_polynomial_from_string(s, parse_coefficient_function):
 
             # or if the top operator is not preceding
             if (_operator_precedence[top_operator] <
-                _operator_precedence[operator]):
+                    _operator_precedence[operator]):
                 return
 
             top_operator = operator_stack.pop()
@@ -766,7 +759,7 @@ def _parse_polynomial_from_string(s, parse_coefficient_function):
 
         next_char, rest = s[0], s[1:]
 
-        if next_char in list(_operators.keys()):
+        if next_char in _operators:
             operator = next_char
             eval_preceding_operators_on_stack(operator)
             operator_stack.append(operator)

snappy/ptolemy/processFileBase.py

@@ -1,11 +1,28 @@
 import re
 
 from . import utilities
+from .ptolemyObstructionClass import PtolemyObstructionClass
 
 """
 Basic functions to read a ptolemy solutions file.
 """
 
+class PtolemyPrecomputedObstructionClassMismatchError(Exception):
+    def __init__(self, index, actual_class, precomputed_class):
+
+        msg = (
+            "The obstruction class in the pre-computed file does not match "
+            "the obstruction class of the Ptolemy variety (index %d). "
+            "The underlying reason is that the pari's implementation of the "
+            "Smith normal form has changed affecting the order in which we "
+            "list the cohomology classes or the cocycles we use as "
+            "representatives. A pre-computed file for the new cocycle has "
+            "not yet been computed.") % index
+
+        Exception.__init__(self, msg)
+        self.index = index
+        self.actual_class = actual_class
+        self.precomputed_class = precomputed_class
 
 def find_section(text, name):
     """
@@ -139,6 +156,49 @@ def get_py_eval(text):
         utilities.join_long_lines(
             find_unique_section(text, "PY=EVAL=SECTION")))
 
+# A dict-like object we can feed into the variable dict
+# function in the pre-computed solution file.
+#
+# It is sufficient to evaluate the obstruction class but
+# returns 1 for all other keys.
+#
+class _DummyDict:
+    def __getitem__(self, key):
+        if key == '1' or key[0] == 'c':
+            return 1
+        raise KeyError(key)
+
+def check_obstruction_class_for_variable_dict_function(
+        variable_dict_function, obstruction_class):
+
+    if not isinstance(obstruction_class, PtolemyObstructionClass):
+        # Note that no obstruction class has always been
+        # corresponding to index 0 ("c0" in file name).
+        # So nothing to check.
+        #
+        # We also don't check for the generalized
+        # obstruction class.
+        #
+        # We should double check that our solutions
+        # for PSL(n,C) with n>2 are still fine...
+        #
+        return
+
+    variable_dict = variable_dict_function(_DummyDict())
+    precomputed_class = [
+        variable_dict[var_name]
+        for var_name in obstruction_class._explain_basis ]
+
+    # Obstruction class contains element in Z/2 as additive group.
+    # We need to convert it to be in multiplicative group {-1, 1}.
+    actual_class = [
+        (-1) ** i for i in obstruction_class._H2_element ]
+
+    if actual_class != precomputed_class:
+        raise PtolemyPrecomputedObstructionClassMismatchError(
+            obstruction_class._index,
+            actual_class,
+            precomputed_class)
 
 def get_manifold_thunk(text):
     """

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
@@ -34,6 +35,18 @@ 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():
     """
@@ -125,7 +138,7 @@ class PtolemyVariety():
                 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
 
@@ -471,7 +484,7 @@ class PtolemyVariety():
                          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
@@ -486,47 +499,91 @@ class PtolemyVariety():
         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)
+    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("Trying to retrieve solutions from %s ..." % url)
 
-        except PtolemyFileMissingError:
+            try:
+                return _retrieve_url(url)
+            except PtolemyFileMissingError as e:
+                if i == len(exts) - 1:
+                    raise
 
-            # If that file wasn't there, try to retrieve solutions from URL
-            # corresponding to the non-prefered format
+    def _retrieve_solution_file(self,
+                                data_url=None,
+                                exts=['magma_out', 'rur'],
+                                verbose=False):
 
-            url = self._solution_file_url(data_url=data_url,
-                                          rur=not prefer_rur)
-            if verbose:
-                print("Retrieving solutions instead from %s ...:" % url)
-            return _retrieve_url(url)
+        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):
 
-        url = self._solution_file_url(data_url=data_url, rur=False)
-        if verbose:
-            print("Retrieving decomposition from %s ..." % url)
-
-        text = _retrieve_url(url)
+        text = self._retrieve_solution_file(data_url,
+                                            exts=['magma_out'],
+                                            verbose=verbose)
 
         if verbose:
             print("Parsing...")
@@ -542,9 +599,14 @@ class PtolemyVariety():
                            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,
-                                            prefer_rur=prefer_rur,
+                                            exts=exts,
                                             verbose=verbose)
+
         if verbose:
             print("Parsing...")
 
@@ -819,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) }
@@ -830,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:
@@ -884,7 +946,7 @@ def _canonical_representative_to_polynomial_substituition(
 
 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)
@@ -910,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: "
@@ -931,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/reginaWrapper.py

@@ -40,7 +40,7 @@ class NTriangulationForPtolemy(NTriangulation):
         """
         Constructor - takes same arguments as NTriangulation.
         """
-        super(NTriangulationForPtolemy, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
 
         # Make sure we are oriented
         if not self.isOriented():
@@ -146,10 +146,10 @@ class NTriangulationForPtolemy(NTriangulation):
 
         * Stavros Garoufalidis, Dyland Thurston, Christian K. Zickert:
           "The Complex Volume of SL(n,C)-Representations of 3-Manifolds"
-          (http://arxiv.org/abs/1111.2828)
+          (https://arxiv.org/abs/1111.2828)
         * Stavros Garoufalidis, Matthias Goerner, Christian K. Zickert:
           "Gluing Equations for PGL(n,C)-Representations of 3-Manifolds "
-          (http://arxiv.org/abs/1207.6711)
+          (https://arxiv.org/abs/1207.6711)
 
         The variety can be exported to magma or sage and solved there. The
         solutions can be processed to compute invariants.
@@ -439,7 +439,7 @@ class NTriangulationForPtolemy(NTriangulation):
         # Following Remark 5.7 of
         # Garoufalidis, Goerner, Zickert:
         # Gluing Equations for PGL(n,C)-Representations of 3-Manifolds
-        # http://arxiv.org/abs/1207.6711
+        # https://arxiv.org/abs/1207.6711
         # we discard all even entries and get a permutation called
         # "effective_perm" here.
         effective_perm = []

snappy/ptolemy/rur.py

@@ -443,7 +443,7 @@ class RUR():
                     return
 
         def term_to_expand_fraction_by(old_terms):
-            result = [ pair for pair in new_denominator_terms ]
+            result = list(new_denominator_terms)
             for p, e in old_terms:
                 if e < 0:
                     subtract_denominator_from_list(p, e, result)