snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/ptolemy/processComponents.py

@@ -0,0 +1,173 @@
+from .component import NonZeroDimensionalComponent
+from . import processFileBase
+from . import processRurFile
+from . import utilities
+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)
+
+    variables_section = processFileBase.find_unique_section(
+        text, "VARIABLES")
+
+    variables = [ remove_optional_quotes(v.strip())
+                  for v in variables_section.split(',') if v.strip() ]
+
+    decomposition = processFileBase.find_unique_section(
+        text, "IDEAL=COMPONENTS")
+
+    params, body = processFileBase.extract_parameters_and_body_from_section(
+        decomposition)
+
+    if "TYPE" not in params.keys():
+        raise Exception("No TYPE given for IDEAL=COMPONENTS")
+
+    type = params["TYPE"].strip()
+
+    if not type == "PTOLEMY":
+        raise Exception("TYPE '%s' not supported" % type)
+
+    components = processFileBase.find_section(text, "COMPONENT")
+
+    return utilities.MethodMappingList(
+        [ process_component(py_eval, manifold_thunk, variables,
+                            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 "DIMENSION" not in params.keys():
+        raise Exception("No DIMENSION for COMPONENT of IDEAL=COMPONENTS")
+
+    dimension = int(params["DIMENSION"].strip())
+
+    free_variables = None
+
+    if dimension > 0 and "FREE=VARIABLES" in params.keys():
+        free_vars_str = processFileBase.remove_optional_outer_square_brackets(
+            params["FREE=VARIABLES"])
+
+        free_variables = [ remove_optional_quotes(v.strip())
+                           for v in free_vars_str.split() ]
+
+    if dimension == 0:
+        return process_solutions_provider(py_eval, manifold_thunk, body, 0,
+                                          variables)
+    else:
+        witnesses = []
+        witnesses_sections = processFileBase.find_section(body, "WITNESSES")
+        if witnesses_sections:
+            assert len(witnesses_sections) == 1
+            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)
+
+
+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):
+
+    rur_section = processFileBase.find_section(text, "MAPLE=LIKE=RUR")
+    if rur_section:
+        assert len(rur_section) == 1
+
+        return SolutionContainer(
+            coordinates.PtolemyCoordinates(
+                processRurFile.parse_maple_like_rur(rur_section[0]),
+                is_numerical=False,
+                py_eval_section=py_eval,
+                manifold_thunk=manifold_thunk))
+
+    gb_section = processFileBase.find_section(text, "GROEBNER=BASIS")
+
+    if gb_section:
+        assert len(gb_section) == 1
+
+        params, body = (
+            processFileBase.extract_parameters_and_body_from_section(
+                gb_section[0]))
+
+        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 '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)
+
+    rs_rur = processFileBase.find_section(text, "RS=RUR")
+
+    if rs_rur:
+        assert len(rs_rur) == 1
+
+        return SolutionContainer(
+            coordinates.PtolemyCoordinates(
+                processRurFile.parse_rs_rur(rs_rur[0], variables),
+                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):
+        if numerical:
+            return self._solutions.numerical()
+        else:
+            return self._solutions
+
+    def number_field(self):
+        return self._solutions.number_field()

snappy/ptolemy/processFileBase.py

@@ -0,0 +1,247 @@
+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):
+    """
+    Finds all sections of the form
+
+    NAME=BEGINS=HERE
+    stuff
+    stuff
+    stuff
+    NAME=ENDS=HERE
+
+    or
+
+    ==NAME=BEGINS==
+    stuff
+    stuff
+    stuff
+    ==NAME=ENDS==
+
+    in text where NAME has to be replaced by name.
+
+    >>> t = (
+    ... "abc abc\\n"
+    ... "==FOO=BEGINS==\\n"
+    ... "bar bar\\n"
+    ... "==FOO=ENDS==\\n")
+    >>> find_section(t, "FOO")
+    ['bar bar']
+    """
+
+    old_style_regex = (name + "=BEGINS=HERE" +
+                       "(.*?)" +
+                       name + "=ENDS=HERE")
+    new_style_regex = ("==" + name + "=BEGINS?==" +
+                       "(.*?)" +
+                       "==" + name + "=ENDS?==")
+    regexs = [ old_style_regex, new_style_regex ]
+
+    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):
+    """
+    Like find_section but ensures that there is only a single
+    such section. Exceptions in all other cases.
+
+    >>> t = "abc abc\\n==FOO=BEGINS==\\nbar bar\\n==FOO=ENDS==\\n"
+    >>> find_unique_section(t, "FOO")
+    'bar bar'
+    """
+
+    sections = find_section(text, name)
+    if len(sections) > 1:
+        raise Exception("Section %s more than once in file" % name)
+    if not sections:
+        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
+    into a dictionary and returns the remaining text.
+
+    >>> t = "==A:1\\n==B:2\\nBody\\nBody"
+    >>> extract_parameters_and_body_from_section(t)[0]['A']
+    '1'
+    """
+
+    params = {}
+
+    while True:
+        m = re.match("==(.*):(.*)\n", section_text)
+        if not m:
+            return params, section_text
+
+        k, v = m.groups()
+        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
+    brackets.
+
+    >>> remove_outer_square_brackets("[a*b*c]")
+    'a*b*c'
+    >>> remove_outer_square_brackets("[[a,b]")
+    '[a,b'
+    """
+
+    if text[0] != '[' or text[-1] != ']':
+        raise ValueError("Error while parsing: outer square brackets missing")
+
+    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):
+    """
+    >>> parse_int_or_empty('3')
+    3
+    >>> parse_int_or_empty('') is None
+    True
+    """
+
+    if s:
+        return int(s)
+    return None
+
+
+def get_py_eval(text):
+    """
+    From a ptolemy solutions file, extract the PY=EVAL=SECTION
+    """
+
+    return eval(
+        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):
+    """
+    From a ptolemy solutions file, extract the manifold.
+    Returned as thunk that evaluates to a snappy manifold.
+    """
+
+    def get_manifold(text=text):
+        triangulation_text = utilities.join_long_lines(
+            find_unique_section(text, "TRIANGULATION"))
+
+        if triangulation_text[:15] == '% Triangulation':
+
+            from snappy import Manifold
+
+            return Manifold(triangulation_text)
+
+        if ('<?xml' 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..." %
+                        triangulation_text[:20])
+
+    return get_manifold
+
+
+def get_manifold(text):
+    """
+    From a ptolemy solutions file, extract the manifold.
+    Returned as snappy Manifold.
+    """
+
+    return get_manifold_thunk(text)()
+
+
+def get_manifold_from_file(filename):
+    """
+    As get_manifold but takes filename. Returns a byte sequence.
+    """
+
+    return get_manifold(open(filename, 'rb').read())

snappy/ptolemy/processFileDispatch.py

@@ -0,0 +1,46 @@
+"""
+This module takes a textual representation of the solutions to a
+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):
+    if processMagmaFile.contains_magma_output(text):
+        return processMagmaFile.decomposition_from_magma(text)
+
+    # Deprecated, will be removed soon!
+    if processRurFile.contains_rur(text):
+        return processRurFile.decomposition_from_rur(text)
+
+    if processComponents.contains_ideal_components(text):
+        return processComponents.decomposition_from_components(text)
+
+    raise Exception("solution file format not recognized")
+
+
+def parse_decomposition_from_file(filename):
+    with open(filename, 'r') as f:
+        return parse_decomposition(f.read())
+
+
+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):
+    """
+    As parse_solutions, but takes a filename instead.
+    """
+    with open(filename, 'r') as f:
+        return parse_solutions(f.read(), numerical)