snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/ptolemy/processMagmaFile.py

@@ -0,0 +1,392 @@
+from .polynomial import Polynomial
+from .ptolemyVarietyPrimeIdealGroebnerBasis import PtolemyVarietyPrimeIdealGroebnerBasis
+from . import processFileBase
+from . import utilities
+import snappy
+
+import re
+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)
+
+    untyped_decomposition = processFileBase.find_section(
+        text, "IDEAL=DECOMPOSITION")
+    primary_decomposition = processFileBase.find_section(
+        text, "PRIMARY=DECOMPOSITION")
+    radical_decomposition = processFileBase.find_section(
+        text, "RADICAL=DECOMPOSITION")
+
+    if untyped_decomposition:
+        decomposition = untyped_decomposition[0]
+    elif primary_decomposition:
+        decomposition = primary_decomposition[0]
+    elif radical_decomposition:
+        decomposition = radical_decomposition[0]
+    else:
+        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)
+
+    decomposition_comps = [ c.strip() for c in decomposition.split(']') ]
+    decomposition_components = [ c + ']' for c in decomposition_comps if c ]
+
+    free_variables_section = processFileBase.find_section(
+        text, "FREE=VARIABLES=IN=COMPONENTS")
+    if free_variables_section:
+        free_variables = eval(free_variables_section[0])
+    else:
+        free_variables = len(decomposition_components) * [None]
+
+    witnesses_section = processFileBase.find_section(
+        text, "WITNESSES=FOR=COMPONENTS")
+    if witnesses_section:
+        witnesses_sections = processFileBase.find_section(
+            witnesses_section[0], "WITNESSES")
+    else:
+        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")
+    else:
+        genuses_sections = len(decomposition_components) * [""]
+
+    def process_match(i, comp, free_vars, witnesses_txt, genus_txt):
+
+        if i != 0:
+            if not comp[0] == ',':
+                raise ValueError("Parsing decomposition, expected "
+                                 "separating comma.")
+            comp = comp[1:].strip()
+
+        if genus_txt.strip():
+            genus = int(genus_txt)
+        else:
+            genus = None
+
+        witnesses_txts = processFileBase.find_section(
+            witnesses_txt, "WITNESS")
+
+        witnesses = [
+            _parse_ideal_groebner_basis(
+                utilities.join_long_lines_deleting_whitespace(t).strip(),
+                py_eval, manifold_thunk, free_vars, [], genus)
+            for t in witnesses_txts ]
+
+        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)
+          in enumerate(zip(decomposition_components,
+                           free_variables,
+                           witnesses_sections,
+                           genuses_sections)) ])
+
+
+def _parse_ideal_groebner_basis(text, py_eval, manifold_thunk,
+                                free_vars, witnesses, genus):
+    match = re.match(
+        r"Ideal of Polynomial ring of rank.*?\n"
+        r"\s*?(Order:\s*?(.*?)|(.*?)\s*?Order)\n"
+        r"\s*?Variables:(.*?\n)+"
+        r".*?Dimension (\d+).*?\s*([^,]*[Pp]rime)?.*?\n"
+        r"(\s*?Size of variety over algebraically closed field: (\d+).*?\n)?"
+        r"\s*Groebner basis:\n"
+        r"\s*?\[([^\[\]]*)\]$",
+        text)
+
+    if not match:
+        raise ValueError("Parsing error in component of "
+                         "decomposition: %s" % text)
+
+    (
+        tot_order_str, post_order_str, pre_order_str,
+        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")
+
+    if order_str.strip().lower() == 'lexicographical':
+        term_order = 'lex'
+    else:
+        term_order = 'other'
+
+    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)
+
+
+def triangulation_from_magma(text):
+    """
+    Reads the output from a magma computation and extracts the manifold for
+    which this output contains solutions.
+    """
+    return processFileBase.get_manifold(text)
+
+
+def triangulation_from_magma_file(filename):
+    """
+    Reads the output from a magma computation from the file with the given
+    filename and extracts the manifold for which the file contains solutions.
+    """
+
+    return processFileBase.get_manifold_from_file(filename)
+
+
+def contains_magma_output(text):
+    return ("IDEAL=DECOMPOSITION=BEGINS" in text or
+            "PRIMARY=DECOMPOSITION=BEGINS" in text or
+            "RADICAL=DECOMPOSITION=BEGINS" in text)
+
+
+def solutions_from_magma_file(filename, numerical=False):
+    """
+    Obsolete, use processFileDispatch.parse_solutions_from_file instead.
+
+    Reads the output from a magma computation from the file with the given
+    filename and returns a list of solutions. Also see solutions_from_magma.
+    A non-zero dimensional component of the variety is reported as
+    NonZeroDimensionalComponent.
+    """
+
+    return solutions_from_magma(open(filename).read(), numerical)
+
+
+def solutions_from_magma(output, numerical=False):
+    """
+    Obsolete, use processFileDispatch.parse_solutions instead.
+
+    Assumes the given string is the output of a magma computation, parses
+    it and returns a list of solutions.
+    A non-zero dimensional component of the variety is reported as
+    NonZeroDimensionalComponent.
+    """
+
+    return decomposition_from_magma(output).solutions(
+        numerical=numerical)
+
+
+def magma_executable():
+    for name in ['magma', 'magma.exe']:
+        if shutil.which(name):
+            return name
+    return None
+
+
+def run_magma(content,
+              filename_base, memory_limit, directory, verbose):
+    """
+    call magma on the given content and
+    """
+
+    magma = magma_executable()
+    if magma is None:
+        raise ValueError('Sorry, could not find the Magma executable')
+
+    if directory:
+        resolved_dir = directory
+        if not resolved_dir[-1] == '/':
+            resolved_dir = resolved_dir + '/'
+    else:
+        resolved_dir = tempfile.mkdtemp() + '/'
+
+    in_file = resolved_dir + filename_base + '.magma'
+    out_file = resolved_dir + filename_base + '.magma_out'
+
+    if verbose:
+        print("Writing to file:", in_file)
+
+    open(in_file, 'wb').write(content.encode('ascii'))
+
+    if verbose:
+        print("Magma's output in:", out_file)
+
+    if sys.platform.startswith('win'):
+        cmd = 'echo | %s "%s" > "%s"' % (magma, in_file, out_file)
+    else:
+        cmd = 'ulimit -m %d; echo | %s "%s" > "%s"' % (
+            int(memory_limit / 1024), magma, in_file, out_file)
+
+    if verbose:
+        print("Command:", cmd)
+        print("Starting magma...")
+
+    retcode = subprocess.call(cmd, shell=True)
+
+    result = open(out_file, 'r').read()
+
+    if verbose:
+        print("magma finished.")
+        print("Parsing magma result...")
+
+    return decomposition_from_magma(result)
+
+###############################################################################
+# magma test
+
+
+_magma_output_for_4_1__sl3 = """
+==TRIANGULATION=BEGINS==
+% Triangulation
+4_1
+geometric_solution  2.02988321
+oriented_manifold
+CS_known -0.0000000000000001
+
+1 0
+    torus   0.000000000000   0.000000000000
+
+2
+   1    1    1    1
+ 0132 1302 1023 2031
+   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
+ 0132 1302 1023 2031
+   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
+  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+  0.500000000000   0.866025403784
+
+
+==TRIANGULATION=ENDS==
+PY=EVAL=SECTION=BEGINS=HERE
+{'variable_dict' :
+     (lambda d, negation = (lambda x:-x): {
+          'c_1020_0' : d['c_0012_1'],
+          'c_1020_1' : d['1'],
+          'c_0201_0' : d['c_0201_0'],
+          'c_0201_1' : d['c_0201_0'],
+          'c_2100_0' : d['1'],
+          'c_2100_1' : d['c_0012_1'],
+          'c_2010_0' : d['1'],
+          'c_2010_1' : d['c_0012_1'],
+          'c_0102_0' : d['c_0102_0'],
+          'c_0102_1' : d['c_0102_0'],
+          'c_1101_0' : d['c_1101_0'],
+          'c_1101_1' : negation(d['c_1101_0']),
+          'c_1200_0' : d['c_0012_1'],
+          'c_1200_1' : d['1'],
+          'c_1110_0' : negation(d['c_1011_1']),
+          'c_1110_1' : negation(d['c_1011_0']),
+          'c_0120_0' : d['c_0102_0'],
+          'c_0120_1' : d['c_0102_0'],
+          'c_2001_0' : d['c_0201_0'],
+          'c_2001_1' : d['c_0201_0'],
+          'c_0012_0' : d['1'],
+          'c_0012_1' : d['c_0012_1'],
+          'c_0111_0' : d['1'],
+          'c_0111_1' : negation(d['1']),
+          'c_0210_0' : d['c_0201_0'],
+          'c_0210_1' : d['c_0201_0'],
+          'c_1002_0' : d['c_0102_0'],
+          'c_1002_1' : d['c_0102_0'],
+          'c_1011_0' : d['c_1011_0'],
+          'c_1011_1' : d['c_1011_1'],
+          'c_0021_0' : d['c_0012_1'],
+          'c_0021_1' : d['1']})}
+PY=EVAL=SECTION=ENDS=HERE
+PRIMARY=DECOMPOSITION=BEGINS=HERE
+[
+    Ideal of Polynomial ring of rank 7 over Rational Field
+    Lexicographical Order
+    Variables: t, c_0012_1, c_0102_0, c_0201_0, c_1011_0, c_1011_1, c_1101_0
+    Dimension 0, Radical, Prime
+    Size of variety over algebraically closed field: 2
+    Groebner basis:
+    [
+        t - 3/8*c_1011_1 - 1/2,
+        c_0012_1 + 1/2*c_1011_1 + 3/2,
+        c_0102_0 + 1/2*c_1011_1 + 1/2,
+        c_0201_0 + 1/2*c_1011_1 + 1/2,
+        c_1011_0 - c_1011_1 - 3,
+        c_1011_1^2 + 3*c_1011_1 + 4,
+        c_1101_0 - 1
+    ],
+    Ideal of Polynomial ring of rank 7 over Rational Field
+    Lexicographical Order
+    Variables: t, c_0012_1, c_0102_0, c_0201_0, c_1011_0, c_1011_1, c_1101_0
+    Dimension 0, Radical, Prime
+    Size of variety over algebraically closed field: 2
+    Groebner basis:
+    [
+        t - 1/2*c_1101_0 - 15/8,
+        c_0012_1 - 1,
+        c_0102_0 + 4/3*c_1101_0 - 2/3,
+        c_0201_0 - 4/3*c_1101_0 - 1/3,
+        c_1011_0 - 1/3*c_1101_0 - 1/3,
+        c_1011_1 + 1/3*c_1101_0 + 1/3,
+        c_1101_0^2 - 1/4*c_1101_0 + 1
+    ],
+    Ideal of Polynomial ring of rank 7 over Rational Field
+    Lexicographical Order
+    Variables: t, c_0012_1, c_0102_0, c_0201_0, c_1011_0, c_1011_1, c_1101_0
+    Dimension 0, Radical, Prime
+    Size of variety over algebraically closed field: 2
+    Groebner basis:
+    [
+        t - c_1011_1 - 1,
+        c_0012_1 - 1,
+        c_0102_0 - c_1011_1,
+        c_0201_0 - c_1011_1,
+        c_1011_0 + c_1011_1,
+        c_1011_1^2 + c_1011_1 + 1,
+        c_1101_0 - 1
+    ]
+]
+PRIMARY=DECOMPOSITION=ENDS=HERE
+CPUTIME : 0.020
+
+Total time: 0.419 seconds, Total memory usage: 5.62MB
+"""

snappy/ptolemy/processRurFile.py

@@ -0,0 +1,150 @@
+import re
+
+from .utilities import MethodMappingList
+from .component import NonZeroDimensionalComponent
+from .coordinates import PtolemyCoordinates
+from .rur import RUR
+from . import processFileBase
+from ..pari import pari
+
+
+def contains_rur(text):
+    return 'RUR=DECOMPOSITION=BEGINS' in text
+
+
+def decomposition_from_rur(text):
+
+    py_eval = processFileBase.get_py_eval(text)
+    manifold_thunk = processFileBase.get_manifold_thunk(text)
+
+    rursection = processFileBase.find_unique_section(text, "RUR=DECOMPOSITION")
+
+    rurs = processFileBase.find_section(rursection, "COMPONENT")
+
+    result = MethodMappingList(
+        [ SolutionContainer(
+                _process_rur_component(rur, py_eval, manifold_thunk))
+          for rur in rurs ])
+
+    return result
+
+
+def _process_rur_component(text, py_eval, manifold_thunk):
+    lines = text.split('\n')
+
+    dimension = None
+    is_prime = False
+    format = None
+
+    body = ""
+    for line in lines:
+        m = re.match(r'==(.*):(.*)', line)
+        if m:
+            key, val = m.groups()
+            val = val.strip()
+            if key == "DIMENSION":
+                dimension = int(val)
+            elif key == "IS_PRIME":
+                if val == "TRUE":
+                    is_prime = True
+                elif val != "FALSE":
+                    raise Exception("IS_PRIME needs to be TRUE or FALSE")
+            elif key == "FORMAT":
+                format = val
+            else:
+                raise Exception("Unrecognized key %s" % key)
+        else:
+            body += line + "\n"
+
+    if dimension is None:
+        return NonZeroDimensionalComponent()
+    if dimension > 0:
+        return NonZeroDimensionalComponent(dimension=dimension)
+
+    if format is None:
+        raise Exception("No format specified")
+
+    if format == "MAPLE-LIKE":
+        d = parse_maple_like_rur(body.strip())
+        return PtolemyCoordinates(d, is_numerical=False,
+                                  py_eval_section=py_eval,
+                                  manifold_thunk=manifold_thunk)
+    else:
+        raise Exception("Unknown format %s" % format)
+
+
+def parse_maple_like_rur(text):
+
+    m = re.match(r"(.*?)\s*=\s*0\s*,\s*\{(.*?)\}", text, re.DOTALL)
+
+    if not m:
+        raise Exception("Format not detected")
+
+    poly_text, assignments_text = m.groups()
+    var = _find_var_of_poly(poly_text)
+
+    poly = pari(poly_text.replace(var, 'x'))
+    assignments_text = assignments_text.replace(var, 'x')
+
+    return dict([_parse_assignment(assignment, poly)
+                 for assignment in assignments_text.split(',')])
+
+
+def parse_rs_rur(text, variables):
+
+    m = re.match(r'\[([^,\]]+),\s*([^,\]]+),\s*\[([^\]]+)\]\s*,\s*\[\s*\]\s*\]',
+                 text, re.DOTALL)
+
+    if not m:
+        raise Exception("Format not detected")
+
+    extension_str, denominator_str, numerators_str = m.groups()
+
+    var = _find_var_of_poly(extension_str)
+
+    extension = pari(extension_str.replace(var, 'x'))
+    denominator = pari(denominator_str.replace(var, 'x'))
+    numerators = [ pari(numerator_str.replace(var, 'x'))
+                   for numerator_str in numerators_str.split(',') ]
+
+    fracs = [
+        RUR( [ (  numerator.Mod(extension), 1),
+               (denominator.Mod(extension), -1) ] )
+        for numerator in numerators ]
+
+    return dict(list(zip(variables, fracs)) + [('1', RUR.from_int(1))])
+
+
+def _find_var_of_poly(text):
+    return re.search(r'[_A-Za-z][_A-Za-z0-9]*',text).group(0)
+
+
+def _parse_assignment(text, poly):
+    var, expression = re.match(r'\s*([_A-Za-z][_A-Za-z0-9]*)\s*=\s*(.*)$',
+                               text).groups()
+
+    return (
+        var,
+        RUR.from_pari_fraction_and_number_field(pari(expression), poly))
+
+
+_test_case = """
+_Z^6-3*_Z^5+3*_Z^4-2*_Z^3+_Z-1 = 0,
+ {c_0012_0 = 1, c_0012_2 = _Z^5-3*_Z^4+3*_Z^3-_Z^2-2*_Z+1, c_0111_2 = -_Z*(_Z^4-2*_Z^3+_Z-1), c_1011_0 = -_Z^2*(-1+_Z), c_1101_0 = -_Z*(-1+_Z), c_1101_1 = _Z*(-1+_Z), c_1110_0 = _Z, a = (_Z^3+_Z^2)/(_Z^3+34*_Z^2+3)}
+"""
+
+
+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()
+
+# print parse_maple_like_rur(_test_case)

snappy/ptolemy/ptolemyGeneralizedObstructionClass.py

@@ -0,0 +1,102 @@
+from . import matrix
+from .polynomial import Polynomial
+from ..pari import pari
+
+
+class PtolemyGeneralizedObstructionClass():
+    """
+    Represents an obstruction cocycle of a PSL(n,C) representation in
+    H^2(M,partial M;Z/n).
+
+    >>> from snappy import Manifold
+    >>> M = Manifold("m004")
+
+    Create an obstruction class, this has to be in the kernel of d^2:
+
+    >>> c = PtolemyGeneralizedObstructionClass([2,0,0,1])
+
+    For better accounting, give it an index:
+
+    >>> c = PtolemyGeneralizedObstructionClass([2,0,0,1], index = 1)
+
+    Get corresponding ptolemy variety:
+
+    >>> p = M.ptolemy_variety(N=3, obstruction_class=c)
+
+    Canonical filename base:
+
+    >>> p.filename_base()
+    'm004__sl3_c1'
+
+    Now pick something not in the kernel:
+
+    >>> c = PtolemyGeneralizedObstructionClass([1,0,0,1])
+    >>> p = M.ptolemy_variety(N=3, obstruction_class=c)
+    Traceback (most recent call last):
+    ...
+    AssertionError: PtolemyGeneralizedObstructionClass not in kernel of d2
+
+    """
+
+    def __init__(self, H2_class, index=None, N=None, manifold=None):
+
+        self.H2_class = H2_class
+        self._index = index
+        self._N = N
+        self._manifold = manifold
+
+    def _checkManifoldAndN(self, manifold, N):
+        if self._manifold is not None:
+            assert manifold == self._manifold, (
+                "PtolemyGeneralizedObstructionClass for wrong manifold")
+
+        if self._N is not None:
+            assert N == self._N, (
+                "PtolemyGeneralizedObstructionClass for wrong N")
+
+        assert len(self.H2_class) == 2 * manifold.num_tetrahedra(), (
+            "PtolemyGeneralizedObstructionClass does not match number of "
+            "face classes")
+
+        # compute boundary maps for cellular chain complex
+        chain_d3, dummy_rows, dummy_columns = (
+            manifold._ptolemy_equations_boundary_map_3())
+
+        # transpose to compute cohomology
+        cochain_d2 = matrix.matrix_transpose(chain_d3)
+
+        assert matrix.is_vector_zero(
+            matrix.vector_modulo(
+                matrix.matrix_mult_vector(cochain_d2, self.H2_class),
+                N)), ("PtolemyGeneralizedObstructionClass not in kernel of "
+                      "d2")
+
+    def _is_non_trivial(self, N):
+        for h in self.H2_class:
+            if h % N != 0:
+                return True
+        return False
+
+    def _get_equation_for_u(self, N):
+
+        # the information about the root of unity u we use:
+        # returns order_of_u, identified_variables, equations
+
+        if self._is_non_trivial(N):
+
+            # If we have a non-trivial obstruction class
+
+            if N == 2:
+                # For N == 2, we set u to -1, no extra equations necessary
+                return 2, []
+
+            else:
+                # Return the cyclotomic polynomial as extra equation in u
+                cyclo = Polynomial.parse_string(str(pari.polcyclo(N, 'u')))
+                return N, [cyclo]
+        else:
+            # If we have the trivial cohomology class, no u returned
+            return 1, []
+
+    def __repr__(self):
+        return "PtolemyGeneralizedObstructionClass(%s)" % self.H2_class

snappy/ptolemy/ptolemyObstructionClass.py

@@ -0,0 +1,64 @@
+class PtolemyObstructionClass():
+    """
+    Represents an obstruction cocycle of a pSL(n,C) representation as
+    described in Definition 1.7 of
+
+    Garoufalidis, Thurston, Zickert
+    The Complex Volume of SL(n,C)-Representations of 3-Manifolds
+    https://arxiv.org/abs/1111.2828
+
+    To generate such an obstruction class, call:
+
+    >>> from snappy import Manifold
+    >>> M = Manifold("4_1")
+    >>> cs = M.ptolemy_obstruction_classes()
+
+    Print out the values:
+
+    >>> for c in cs: print(c)
+    PtolemyObstructionClass(s_0_0 - 1, s_1_0 - 1, s_2_0 - 1, s_3_0 - 1, s_0_0 - s_0_1, s_1_0 - s_3_1, s_2_0 - s_2_1, s_3_0 - s_1_1)
+    PtolemyObstructionClass(s_0_0 + 1, s_1_0 - 1, s_2_0 - 1, s_3_0 + 1, s_0_0 - s_0_1, s_1_0 - s_3_1, s_2_0 - s_2_1, s_3_0 - s_1_1)
+    """
+
+    def __init__(self, manifold, index, H2_element, explain_basis,
+                 identified_face_classes):
+
+        self._manifold = manifold
+        self._index = index
+        self._H2_element = H2_element
+        self._explain_basis = explain_basis
+        self._identified_face_classes = identified_face_classes
+
+        def H2_element_entry_to_identified_variable(entry, variable):
+            return ((-1)**entry, 0, variable, 1)
+
+        self.identified_variables = (
+            [H2_element_entry_to_identified_variable(entry, variable)
+             for entry, variable in zip(H2_element, explain_basis)] +
+            [(+1, 0, var1, var2)
+             for sign, power, var1, var2 in self._identified_face_classes])
+
+    def _checkManifoldAndN(self, manifold, N):
+        if self._manifold is not None:
+            assert manifold == self._manifold, (
+                "PtolemyObstructionClass for wrong manifold")
+
+        assert N % 2 == 0, (
+            "PtolemyObstructionClass only makes sense for even N, "
+            "try PtolemyGeneralizedObstructionClass")
+
+    def __repr__(self):
+
+        def to_string(i):
+            sign, power, var1, var2 = i
+            var2 = str(var2)
+
+            assert sign in [+1, -1]
+
+            if sign == +1:
+                return var1 + " - " + var2
+            else:
+                return var1 + " + " + var2
+
+        return "PtolemyObstructionClass(%s)" % ', '.join(
+            to_string(i) for i in self.identified_variables)