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

snappy/ptolemy/processComponents.py

@@ -6,12 +6,13 @@ from . import coordinates
 from .polynomial import Polynomial
 from .ptolemyVarietyPrimeIdealGroebnerBasis import PtolemyVarietyPrimeIdealGroebnerBasis
 
+
 def contains_ideal_components(text):
     return "IDEAL=COMPONENTS=BEGIN" in text
 
+
 def decomposition_from_components(text):
-    
-    
+
     py_eval = processFileBase.get_py_eval(text)
     manifold_thunk = processFileBase.get_manifold_thunk(text)
 
@@ -26,8 +27,8 @@ def decomposition_from_components(text):
 
     params, body = processFileBase.extract_parameters_and_body_from_section(
         decomposition)
-    
-    if not "TYPE" in params.keys():
+
+    if "TYPE" not in params.keys():
         raise Exception("No TYPE given for IDEAL=COMPONENTS")
 
     type = params["TYPE"].strip()
@@ -42,19 +43,21 @@ def decomposition_from_components(text):
                             component)
           for component in components ])
 
+
 def remove_optional_quotes(s):
     if s[0] in ['"', "'"]:
         assert s[0] == s[-1]
         return s[1:-1]
     return s
-    
+
+
 def process_component(py_eval, manifold_thunk, variables,
                       component):
 
     params, body = processFileBase.extract_parameters_and_body_from_section(
         component)
 
-    if not "DIMENSION" in params.keys():
+    if "DIMENSION" not in params.keys():
         raise Exception("No DIMENSION for COMPONENT of IDEAL=COMPONENTS")
 
     dimension = int(params["DIMENSION"].strip())
@@ -79,22 +82,24 @@ def process_component(py_eval, manifold_thunk, variables,
             witnesses = process_witnesses(
                 py_eval, manifold_thunk, witnesses_sections[0], dimension,
                 variables)
-        
+
         # process Groebner Basis ???, add to NonZeroDimensionalComponent ???
 
         return NonZeroDimensionalComponent(
-            witnesses = witnesses,
-            dimension = dimension,
-            free_variables = free_variables)
+            witnesses=witnesses,
+            dimension=dimension,
+            free_variables=free_variables)
+
 
 def process_witnesses(py_eval, manifold_thunk, witnesses_section, for_dimension,
                       variables):
-    
+
     return [ process_solutions_provider(
             py_eval, manifold_thunk, witness_section, for_dimension, variables)
              for witness_section
              in processFileBase.find_section(witnesses_section, "WITNESS") ]
 
+
 def process_solutions_provider(py_eval, manifold_thunk, text, for_dimension,
                                variables):
 
@@ -105,9 +110,9 @@ def process_solutions_provider(py_eval, manifold_thunk, text, for_dimension,
         return SolutionContainer(
             coordinates.PtolemyCoordinates(
                 processRurFile.parse_maple_like_rur(rur_section[0]),
-                is_numerical = False,
-                py_eval_section = py_eval,
-                manifold_thunk = manifold_thunk))
+                is_numerical=False,
+                py_eval_section=py_eval,
+                manifold_thunk=manifold_thunk))
 
     gb_section = processFileBase.find_section(text, "GROEBNER=BASIS")
 
@@ -120,24 +125,24 @@ def process_solutions_provider(py_eval, manifold_thunk, text, for_dimension,
 
         body = processFileBase.remove_optional_outer_square_brackets(
             utilities.join_long_lines_deleting_whitespace(body))
-        
+
         polys = [ Polynomial.parse_string(p)
                   for p in body.replace('\n', ' ').split(',') ]
 
-        if not 'TERM=ORDER' in params.keys():
+        if 'TERM=ORDER' not in params.keys():
             raise Exception("No term order given for Groebner basis")
 
         term_order = params["TERM=ORDER"].strip().lower()
-        
+
         return PtolemyVarietyPrimeIdealGroebnerBasis(
-            polys = polys,
-            term_order = term_order,
-            size = None,
-            dimension = 0,
-            is_prime = True,
-            free_variables = None,
-            py_eval = py_eval,
-            manifold_thunk = manifold_thunk)
+            polys=polys,
+            term_order=term_order,
+            size=None,
+            dimension=0,
+            is_prime=True,
+            free_variables=None,
+            py_eval=py_eval,
+            manifold_thunk=manifold_thunk)
 
     rs_rur = processFileBase.find_section(text, "RS=RUR")
 
@@ -147,17 +152,18 @@ def process_solutions_provider(py_eval, manifold_thunk, text, for_dimension,
         return SolutionContainer(
             coordinates.PtolemyCoordinates(
                 processRurFile.parse_rs_rur(rs_rur[0], variables),
-                is_numerical = False,
-                py_eval_section = py_eval,
-                manifold_thunk = manifold_thunk))
-    
+                is_numerical=False,
+                py_eval_section=py_eval,
+                manifold_thunk=manifold_thunk))
+
     raise Exception("No parsable solution type given: %s..." % text[:100])
 
+
 class SolutionContainer():
     def __init__(self, solutions):
         self._solutions = solutions
 
-    def solutions(self, numerical = False):
+    def solutions(self, numerical=False):
         if numerical:
             return self._solutions.numerical()
         else:

snappy/ptolemy/processFileBase.py

@@ -1,23 +1,40 @@
 import re
 
 from . import utilities
+from .ptolemyObstructionClass import PtolemyObstructionClass
 
 """
 Basic functions to read a ptolemy solutions file.
 """
 
-def find_section(text, name):
+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):
     """
     Finds all sections of the form
-    
+
     NAME=BEGINS=HERE
     stuff
     stuff
     stuff
     NAME=ENDS=HERE
-    
-    or 
+
+    or
 
     ==NAME=BEGINS==
     stuff
@@ -46,13 +63,13 @@ def find_section(text, name):
 
     if not isinstance(text, str):
         text = text.decode('ascii')
-        
+
     return [ s.strip()
              for regex in regexs
              for s in re.findall(regex, text, re.DOTALL) ]
 
-def find_unique_section(text, name):
 
+def find_unique_section(text, name):
     """
     Like find_section but ensures that there is only a single
     such section. Exceptions in all other cases.
@@ -69,6 +86,7 @@ def find_unique_section(text, name):
         raise Exception("No section %s in file" % name)
     return sections[0]
 
+
 def extract_parameters_and_body_from_section(section_text):
     """
     Turns patterns of the form "==KEY:VALUE" at the beginning lines
@@ -79,7 +97,6 @@ def extract_parameters_and_body_from_section(section_text):
     '1'
     """
 
-
     params = {}
 
     while True:
@@ -91,6 +108,7 @@ def extract_parameters_and_body_from_section(section_text):
         params[k] = v
         section_text = section_text.split('\n',1)[1]
 
+
 def remove_outer_square_brackets(text):
     """
     Checks that test is of the form "[...]" and returns result between
@@ -107,15 +125,16 @@ def remove_outer_square_brackets(text):
 
     return text[1:-1]
 
+
 def remove_optional_outer_square_brackets(text):
-    
+
     if text[0] == '[':
         return remove_outer_square_brackets(text)
 
     return text
 
-def parse_int_or_empty(s):
 
+def parse_int_or_empty(s):
     """
     >>> parse_int_or_empty('3')
     3
@@ -123,13 +142,12 @@ def parse_int_or_empty(s):
     True
     """
 
-
     if s:
         return int(s)
     return None
 
-def get_py_eval(text):
 
+def get_py_eval(text):
     """
     From a ptolemy solutions file, extract the PY=EVAL=SECTION
     """
@@ -138,14 +156,57 @@ def get_py_eval(text):
         utilities.join_long_lines(
             find_unique_section(text, "PY=EVAL=SECTION")))
 
-def get_manifold_thunk(text):
+# 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):
     """
     From a ptolemy solutions file, extract the manifold.
     Returned as thunk that evaluates to a snappy manifold.
     """
 
-    def get_manifold(text = text):
+    def get_manifold(text=text):
         triangulation_text = utilities.join_long_lines(
             find_unique_section(text, "TRIANGULATION"))
 
@@ -154,22 +215,22 @@ def get_manifold_thunk(text):
             from snappy import Manifold
 
             return Manifold(triangulation_text)
-        
+
         if ('<?xml' in triangulation_text and
-            '<reginadata' in triangulation_text and 
+            '<reginadata' in triangulation_text and
             '<packet' in triangulation_text):
 
             from reginaWrapper import NTriangulationForPtolemy
 
             return NTriangulationForPtolemy.from_xml(triangulation_text)
 
-        raise Exception("Triangulation format not supported: %s..." % 
+        raise Exception("Triangulation format not supported: %s..." %
                         triangulation_text[:20])
 
     return get_manifold
 
-def get_manifold(text):
 
+def get_manifold(text):
     """
     From a ptolemy solutions file, extract the manifold.
     Returned as snappy Manifold.
@@ -177,8 +238,8 @@ def get_manifold(text):
 
     return get_manifold_thunk(text)()
 
-def get_manifold_from_file(filename):
 
+def get_manifold_from_file(filename):
     """
     As get_manifold but takes filename. Returns a byte sequence.
     """

snappy/ptolemy/processFileDispatch.py

@@ -1,15 +1,14 @@
 """
 This module takes a textual representation of the solutions to a
-Ptolemy variety and parses it by detecting the type of the textural
+Ptolemy variety and parses it by detecting the type of the textual
 representation and dispatching it to the corresponding module.
 """
-
 from . import processMagmaFile
 from . import processRurFile
 from . import processComponents
 
-def parse_decomposition(text):
 
+def parse_decomposition(text):
     if processMagmaFile.contains_magma_output(text):
         return processMagmaFile.decomposition_from_magma(text)
 
@@ -20,28 +19,28 @@ def parse_decomposition(text):
     if processComponents.contains_ideal_components(text):
         return processComponents.decomposition_from_components(text)
 
-    raise Exception("Solution file format not recognized")
-    
+    raise Exception("solution file format not recognized")
+
+
 def parse_decomposition_from_file(filename):
-    
-    return parse_decomposition(open(filename, 'r').read())
+    with open(filename, 'r') as f:
+        return parse_decomposition(f.read())
 
-def parse_solutions(text, numerical = False):
 
+def parse_solutions(text, numerical=False):
     """
     Reads the text containing the solutions from a magma computation
     or a rur computation and returns a list of solutions.
+
     A non-zero dimensional component of the variety is reported as
     NonZeroDimensionalComponent.
     """
-
     return parse_decomposition(text).solutions(numerical)
 
-    
-def parse_solutions_from_file(filename, numerical = False):
-    
+
+def parse_solutions_from_file(filename, numerical=False):
     """
     As parse_solutions, but takes a filename instead.
     """
-
-    return parse_solutions(open(filename, 'r').read(), numerical)
+    with open(filename, 'r') as f:
+        return parse_solutions(f.read(), numerical)

snappy/ptolemy/processMagmaFile.py

@@ -9,12 +9,13 @@ import sys
 import tempfile
 import subprocess
 import shutil
-        
+
 ###############################################################################
 # functions
 
+
 def decomposition_from_magma(text):
-    
+
     py_eval = processFileBase.get_py_eval(text)
     manifold_thunk = processFileBase.get_manifold_thunk(text)
 
@@ -23,7 +24,7 @@ def decomposition_from_magma(text):
     primary_decomposition = processFileBase.find_section(
         text, "PRIMARY=DECOMPOSITION")
     radical_decomposition = processFileBase.find_section(
-        text,  "RADICAL=DECOMPOSITION")
+        text, "RADICAL=DECOMPOSITION")
 
     if untyped_decomposition:
         decomposition = untyped_decomposition[0]
@@ -35,11 +36,11 @@ def decomposition_from_magma(text):
         raise ValueError(
             "File not recognized as magma output "
             "(missing primary decomposition or radical decomposition)")
-    
+
     # Remove "\" at the wrapped lines
     decomposition = utilities.join_long_lines_deleting_whitespace(
         decomposition)
-    
+
     # Remove outer square brackets
     decomposition = processFileBase.remove_outer_square_brackets(decomposition)
 
@@ -51,7 +52,7 @@ def decomposition_from_magma(text):
     if free_variables_section:
         free_variables = eval(free_variables_section[0])
     else:
-        free_variables = len(decomposition_components) * [ None ]
+        free_variables = len(decomposition_components) * [None]
 
     witnesses_section = processFileBase.find_section(
         text, "WITNESSES=FOR=COMPONENTS")
@@ -59,15 +60,15 @@ def decomposition_from_magma(text):
         witnesses_sections = processFileBase.find_section(
             witnesses_section[0], "WITNESSES")
     else:
-        witnesses_sections = len(decomposition_components) * [ "" ]
+        witnesses_sections = len(decomposition_components) * [""]
 
     genuses_section = processFileBase.find_section(
         text, "GENUSES=FOR=COMPONENTS")
     if genuses_section:
         genuses_sections = processFileBase.find_section(
-           genuses_section[0], "GENUS=FOR=COMPONENT")
+            genuses_section[0], "GENUS=FOR=COMPONENT")
     else:
-        genuses_sections = len(decomposition_components) * [ "" ]
+        genuses_sections = len(decomposition_components) * [""]
 
     def process_match(i, comp, free_vars, witnesses_txt, genus_txt):
 
@@ -84,7 +85,7 @@ def decomposition_from_magma(text):
 
         witnesses_txts = processFileBase.find_section(
             witnesses_txt, "WITNESS")
-        
+
         witnesses = [
             _parse_ideal_groebner_basis(
                 utilities.join_long_lines_deleting_whitespace(t).strip(),
@@ -93,7 +94,7 @@ def decomposition_from_magma(text):
 
         return _parse_ideal_groebner_basis(comp, py_eval, manifold_thunk,
                                            free_vars, witnesses, genus)
-        
+
     return utilities.MethodMappingList(
         [ process_match(i, comp, free_vars, witnesses, genus_txt)
           for i, (comp, free_vars, witnesses, genus_txt)
@@ -102,6 +103,7 @@ def decomposition_from_magma(text):
                            witnesses_sections,
                            genuses_sections)) ])
 
+
 def _parse_ideal_groebner_basis(text, py_eval, manifold_thunk,
                                 free_vars, witnesses, genus):
     match = re.match(
@@ -113,7 +115,7 @@ def _parse_ideal_groebner_basis(text, py_eval, manifold_thunk,
         r"\s*Groebner basis:\n"
         r"\s*?\[([^\[\]]*)\]$",
         text)
-        
+
     if not match:
         raise ValueError("Parsing error in component of "
                          "decomposition: %s" % text)
@@ -123,17 +125,17 @@ def _parse_ideal_groebner_basis(text, py_eval, manifold_thunk,
         var_str,
         dimension_str, prime_str,
         variety_str, size_str,
-        
+
         poly_strs                                      ) = match.groups()
-        
+
     dimension = int(dimension_str)
-        
+
     if dimension == 0:
         polys = [ Polynomial.parse_string(p)
                   for p in poly_strs.replace('\n',' ').split(',') ]
     else:
         polys = []
-            
+
     order_str = post_order_str if post_order_str else pre_order_str
     if not order_str:
         raise ValueError("Could not parse order in decomposition")
@@ -145,17 +147,17 @@ def _parse_ideal_groebner_basis(text, py_eval, manifold_thunk,
 
     is_prime = (prime_str is None) or (prime_str.lower() == 'prime')
 
-    return  PtolemyVarietyPrimeIdealGroebnerBasis(
-        polys = polys,
-        term_order = term_order,
-        size = processFileBase.parse_int_or_empty(size_str),
-        dimension = dimension,
-        is_prime = is_prime,
-        free_variables = free_vars,
-        py_eval = py_eval,
-        manifold_thunk = manifold_thunk,
-        witnesses = witnesses,
-        genus = genus)
+    return PtolemyVarietyPrimeIdealGroebnerBasis(
+        polys=polys,
+        term_order=term_order,
+        size=processFileBase.parse_int_or_empty(size_str),
+        dimension=dimension,
+        is_prime=is_prime,
+        free_variables=free_vars,
+        py_eval=py_eval,
+        manifold_thunk=manifold_thunk,
+        witnesses=witnesses,
+        genus=genus)
 
 
 def triangulation_from_magma(text):
@@ -180,8 +182,8 @@ def contains_magma_output(text):
             "PRIMARY=DECOMPOSITION=BEGINS" in text or
             "RADICAL=DECOMPOSITION=BEGINS" in text)
 
-def solutions_from_magma_file(filename, numerical = False):
 
+def solutions_from_magma_file(filename, numerical=False):
     """
     Obsolete, use processFileDispatch.parse_solutions_from_file instead.
 
@@ -193,7 +195,8 @@ def solutions_from_magma_file(filename, numerical = False):
 
     return solutions_from_magma(open(filename).read(), numerical)
 
-def solutions_from_magma(output, numerical = False):
+
+def solutions_from_magma(output, numerical=False):
     """
     Obsolete, use processFileDispatch.parse_solutions instead.
 
@@ -204,7 +207,8 @@ def solutions_from_magma(output, numerical = False):
     """
 
     return decomposition_from_magma(output).solutions(
-        numerical = numerical)
+        numerical=numerical)
+
 
 def magma_executable():
     for name in ['magma', 'magma.exe']:
@@ -212,11 +216,11 @@ def magma_executable():
             return name
     return None
 
+
 def run_magma(content,
               filename_base, memory_limit, directory, verbose):
-
     """
-    call magma on the given content and 
+    call magma on the given content and
     """
 
     magma = magma_executable()
@@ -230,7 +234,7 @@ def run_magma(content,
     else:
         resolved_dir = tempfile.mkdtemp() + '/'
 
-    in_file  = resolved_dir + filename_base + '.magma'
+    in_file = resolved_dir + filename_base + '.magma'
     out_file = resolved_dir + filename_base + '.magma_out'
 
     if verbose:
@@ -251,7 +255,7 @@ def run_magma(content,
         print("Command:", cmd)
         print("Starting magma...")
 
-    retcode = subprocess.call(cmd, shell = True)
+    retcode = subprocess.call(cmd, shell=True)
 
     result = open(out_file, 'r').read()
 
@@ -264,6 +268,7 @@ def run_magma(content,
 ###############################################################################
 # magma test
 
+
 _magma_output_for_4_1__sl3 = """
 ==TRIANGULATION=BEGINS==
 % Triangulation
@@ -276,18 +281,18 @@ CS_known -0.0000000000000001
     torus   0.000000000000   0.000000000000
 
 2
-   1    1    1    1 
+   1    1    1    1
  0132 1302 1023 2031
-   0    0    0    0 
+   0    0    0    0
   0  0  0  0  0  0  1 -1  0  0  0  0  0  0  0  0
   0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
   0  1  0 -1 -1  0  2 -1  0 -1  0  1  0  1 -1  0
   0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
   0.500000000000   0.866025403784
 
-   0    0    0    0 
+   0    0    0    0
  0132 1302 1023 2031
-   0    0    0    0 
+   0    0    0    0
   0  1 -1  0  0  0  0  0  0  0  0  0  0  0  0  0
   0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
   0  1 -2  1  1  0  0 -1  0  1  0 -1  0 -1  1  0
@@ -297,7 +302,7 @@ CS_known -0.0000000000000001
 
 ==TRIANGULATION=ENDS==
 PY=EVAL=SECTION=BEGINS=HERE
-{'variable_dict' : 
+{'variable_dict' :
      (lambda d, negation = (lambda x:-x): {
           'c_1020_0' : d['c_0012_1'],
           'c_1020_1' : d['1'],