snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/snap/polished_reps.py

@@ -0,0 +1,335 @@
+"""
+A Sage module for finding the holonomy representation of a hyperbolic
+3-manifold to very high precision.
+"""
+from itertools import product, chain
+from ..sage_helper import _within_sage
+from ..math_basics import prod
+from ..pari import pari
+
+from .fundamental_polyhedron import *
+
+if _within_sage:
+    from ..sage_helper import RealField, ComplexField, gcd, prod, powerset
+    from ..sage_helper import MatrixSpace, matrix, vector, ZZ
+    from ..sage_helper import SageObject as Object
+
+    identity = lambda A: MatrixSpace(A.base_ring(), A.nrows())(1)
+    abelian_group_elt = lambda v: vector(ZZ, v)
+else:
+    Object = object
+    from .utilities import Matrix2x2 as matrix, powerset
+    from ..number import Number
+
+    def identity(A):
+        return matrix(A.base_ring(), 1.0, 0.0, 0.0, 1.0)
+    abelian_group_elt = lambda v: v
+
+
+# ----------------------------------------------------------------
+#
+#  Abelianization of the fundamental group
+#
+# ----------------------------------------------------------------
+
+class MapToFreeAbelianization(Object):
+    """
+    >>> import snappy
+    >>> M = snappy.Manifold('m125')
+    >>> G = M.fundamental_group(False, False, False)
+    >>> rho = MapToFreeAbelianization(G)
+    >>> for g in G.generators(): print( g, rho(g) )
+    ...
+    a (3, -1)
+    b (5, -2)
+    c (0, 1)
+    d (1, 0)
+    """
+
+    def __init__(self, fund_group):
+        self.generators = gens = fund_group.generators()
+        self.relators = rels = fund_group.relators()
+        entries = list(chain(*(self.abelianize_word(r) for r in rels)))
+        presentation = pari.matrix(len(rels), len(gens), entries).mattranspose()
+        U, V, D = presentation.matsnf(flag=1) # D = U*R*V is the smith form
+        self.U = U
+        elementary_divisors = D.matsnf().list()
+        self._rank = elementary_divisors.count(0)
+
+    def abelianize_word(self, word):
+        return [word.count(g) - word.count(g.swapcase()) for g in self.generators]
+
+    @property
+    def rank(self):
+        return self._rank
+
+    def __call__(self, word):
+        v = self.U*pari(self.abelianize_word(word)).mattranspose()
+        return abelian_group_elt( tuple(int(x) for x in list(v[0])[:self._rank]) )
+
+# General code for storing high-precision representations.
+
+
+def clean_RR(r, error):
+    return 0 if abs(r) < error else r
+
+
+if _within_sage:
+    def clean_CC(z, error, prec):
+        CC = ComplexField(prec)
+        return CC( clean_RR(z.real(),error), clean_RR(z.imag(), error) )
+else:
+    def clean_CC(z, error, prec):
+        re, im = z.real(), z.imag()
+        prec = re.prec()
+        clean_z = pari.complex( clean_RR(re.gen, error), clean_RR(im.gen, error) )
+        return Number(clean_z, precision=prec)
+
+
+def clean_matrix(A, error, prec):
+    return matrix([[clean_CC(A[x], error, prec) for x in ((i,0),(i,1))]
+                   for i in (0,1)])
+
+
+def SL2C_inverse(A):
+    return matrix([[A[1,1], -A[0, 1]], [-A[1, 0], A[0, 0]]])
+
+
+def matrix_norm(A):
+    return max( [abs(a) for a in A.list()])
+
+
+def matrix_difference_norm(A, B):
+    return max([abs(a - b) for a, b in zip(A.list(), B.list())])
+
+
+def projective_distance(A, B):
+    return min( matrix_norm(A-B), matrix_norm(A+B) )
+
+
+def compare_matrices(Mats0, Mats1):
+    return max([projective_distance(A, B) for A, B in zip(Mats0, Mats1)])
+
+
+def make_epsilon(A):
+    prec = A.base_ring().precision()
+    RR = RealField(prec)
+    return RR(2)**(RR(-0.6)*prec)
+
+
+def make_trace_2(A):
+    P = A if A.trace() > 0 else - A
+    if abs(P.trace() - 2) < make_epsilon(A):
+        return P
+    else:
+        raise ValueError("Matrix of peripheral element doesn't seem to be parabolic")
+
+
+def parabolic_eigenvector(A):
+    P, CC, epsilon = make_trace_2(A), A.base_ring(), make_epsilon(A)
+    for v in [vector(CC, (1, 0) ), vector(CC, (0, 1))]:
+        if (v - P*v).norm() < epsilon:
+            return v
+
+    v = vector( CC , pari(P - 1).matker()[0])
+    assert (v - P*v).norm() < epsilon
+    return v
+
+
+def extend_to_basis(v):
+    u = (1/v.norm())*v
+    w = vector(v.base_ring(), (-u[1].conjugate(), u[0].conjugate()))
+    return matrix( [u, w] ).transpose()
+
+
+def is_essentially_Id2(M, error=10**-3):
+    diff = M - identity(M)
+    error = diff.base_ring()(error)
+    return all(abs(d) < error for d in diff.list())
+
+
+class MatrixRepresentation(Object):
+    def __init__(self, gens, relators, matrices):
+        self._gens, self._relators, self._matrices = gens, relators, matrices
+        self._build_hom_dict()
+        A = matrices[0]
+        self._id = identity(A)
+
+    def _build_hom_dict(self):
+        gens, matrices = self._gens, self._matrices
+        inv_gens = [g.upper() for g in gens]
+        inv_mat = [SL2C_inverse(m) for m in matrices]
+        self._hom_dict = dict(zip(gens + inv_gens, matrices + inv_mat))
+
+    def generators(self):
+        return self._gens
+
+    def num_generators(self):
+        return len(self._gens)
+
+    def relators(self):
+        return self._relators
+
+    def __call__(self, word):
+        return prod([self._hom_dict[g] for g in word], self._id)
+
+    def is_nonprojective_representation(self):
+        """
+        True if this is an SL(2,C)-representation, i.e., if multiplying the generators
+        in a word yields the identity matrix.
+        """
+        return all(is_essentially_Id2(self(R)) for R in self.relators())
+
+    def is_projective_representation(self):
+        """
+        True if this is an PSL(2,C)-representation, i.e., if multiplying the generators
+        in a word yields the identity matrix or its negative.
+        """
+        rel_images = (self(R) for R in self.relators())
+        return all(is_essentially_Id2(M) or is_essentially_Id2(-M)
+                   for M in rel_images)
+
+    def lift_to_SL2C(self):
+        assert self.is_projective_representation()
+        base_gen_images = [self(g) for g in self.generators()]
+        generators, relators = self.generators(), self.relators()
+
+        # Make into a real rep
+        pos_signs = product( *([(1, -1)]*len(base_gen_images)))
+        for signs in pos_signs:
+            gen_images = [ s*M for s, M in zip(signs, base_gen_images)]
+            rho = MatrixRepresentation(generators, relators, gen_images)
+            if rho.is_nonprojective_representation():
+                self._matrices = gen_images
+                self._build_hom_dict()
+                break
+
+        assert self.is_nonprojective_representation()
+
+    def all_lifts_to_SL2C(self):
+        ans = []
+        self.lift_to_SL2C()
+        base_gen_images = [self(g) for g in self.generators()]
+        pos_signs = product( *([(1, -1)]*len(base_gen_images)))
+        for signs in pos_signs:
+            beta = MatrixRepresentation(self.generators(), self.relators(), [ s*A for s, A in zip(signs, base_gen_images)])
+            if beta.is_nonprojective_representation():
+                ans.append(beta)
+        return ans
+
+    def trace_field_generators(self):
+        gens = self.generators()
+        enough_elts = [ ''.join(sorted(s)) for s in powerset(gens) if len(s) > 0]
+        return [self(w).trace() for w in enough_elts]
+
+    def invariant_trace_field_generators(self):
+        gens = self.generators()
+        if min([abs(self(g).trace()) for g in gens]) < 0.001:
+            raise ValueError("Algorithm fails when a generator has trace 0, see page 125 of ML")
+        gens = [2*g for g in gens]
+        enough_elts = [ ''.join(sorted(s)) for s in powerset(gens) if len(s) > 0]
+        return [self(w).trace() for w in enough_elts]
+
+
+class ManifoldGroup(MatrixRepresentation):
+    def __init__(self, gens, relators, peripheral_curves=None, matrices=None):
+        MatrixRepresentation.__init__(self, gens, relators, matrices)
+        self._peripheral_curves = peripheral_curves
+
+    def peripheral_curves(self):
+        return self._peripheral_curves
+
+    def SL2C(self, word):
+        return self(word)
+
+    def check_representation(self):
+        relator_matrices = (self.SL2C(R) for R in self.relators())
+        return max(projective_distance(A, identity(A)) for A in relator_matrices)
+
+    def cusp_shape(self, cusp_num=0):
+        """
+        Get the polished cusp shape for this representation::
+
+          sage: M = ManifoldHP('m015')
+          sage: rho = M.polished_holonomy(bits_prec=100)
+          sage: rho.cusp_shape()   # doctest: +NUMERIC24
+          -0.49024466750661447990098220731 + 2.9794470664789769463726817144*I
+
+        """
+        M, L = (self.SL2C(w) for w in self.peripheral_curves()[cusp_num])
+        C = extend_to_basis(parabolic_eigenvector(M))
+        M, L = ( make_trace_2( C**(-1)*A*C ) for A in [M, L] )
+        z = L[0][1]/M[0][1]
+        return z.conjugate()
+
+    def lift_to_SL2C(self):
+        MatrixRepresentation.lift_to_SL2C(self)
+        # Now make things correspond to our convention that tr(rho(meridian)) = +2, *when possible*.
+        phi = MapToFreeAbelianization(self)
+        meridian = self.peripheral_curves()[0][0]
+        meridian_trace = self(meridian).trace()
+        if phi.rank == 1 and phi(meridian) % 2 != 0 and meridian_trace < 0:
+            def twist(g, gen_image):
+                return gen_image if phi(g)[0] % 2 == 0 else -gen_image
+            self._matrices = [ twist(g, M) for g, M in zip(self._gens, self._matrices) ]
+            self._build_hom_dict()
+            assert self.is_nonprojective_representation()
+            assert self(meridian).trace() > 0
+
+    def all_lifts_to_SL2C(self):
+        ans = []
+        self.lift_to_SL2C()
+        base_gen_images = [self(g) for g in self.generators()]
+        pos_signs = product( *([(1, -1)]*len(base_gen_images)))
+        for signs in pos_signs:
+            beta = ManifoldGroup(self.generators(), self.relators(),
+                                 self.peripheral_curves(),
+                                 [ s*A for s, A in zip(signs, base_gen_images)])
+            if beta.is_nonprojective_representation():
+                ans.append(beta)
+        return ans
+
+    def __repr__(self):
+        return 'Generators:\n   %s\nRelators:\n   %s' % (
+            ','.join(self.generators()),
+            '\n   '.join(self.relators()))
+
+
+def polished_holonomy(manifold,
+                      bits_prec=100,
+                      fundamental_group_args=[],
+                      lift_to_SL2=True,
+                      ignore_solution_type=False,
+                      dec_prec=None,
+                      match_kernel=True):
+    """
+    Return the fundamental group of M equipped with a high-precision version of
+    the holonomy representation::
+
+        sage: M = Manifold('m004')
+        sage: G = M.polished_holonomy()
+        sage: G('a').trace()
+        1.5000000000000000000000000000 - 0.86602540378443864676372317075*I
+        sage: G = M.polished_holonomy(bits_prec=1000)
+        sage: G('a').trace().parent()
+        Complex Field with 1000 bits of precision
+    """
+    M = manifold
+    if dec_prec:
+        bits_prec = None
+        error = 10**(-dec_prec*0.8)
+    else:
+        error = 2**(-bits_prec*0.8)
+    shapes = M.tetrahedra_shapes('rect', bits_prec=bits_prec, dec_prec=dec_prec)
+    G = M.fundamental_group(*fundamental_group_args)
+    f = FundamentalPolyhedronEngine.from_manifold_and_shapes(
+        M, shapes, normalize_matrices=True, match_kernel=match_kernel)
+    mats = f.matrices_for_presentation(G, match_kernel=True)
+    clean_mats = [clean_matrix(A, error=error, prec=bits_prec) for A in mats]
+    PG = ManifoldGroup(G.generators(), G.relators(), G.peripheral_curves(), clean_mats)
+    if lift_to_SL2:
+        PG.lift_to_SL2C()
+    else:
+        assert PG.is_projective_representation()
+
+    return PG

snappy/snap/shapes.py

@@ -0,0 +1,152 @@
+from ..sage_helper import _within_sage
+from ..pari import pari, prec_dec_to_bits, prec_bits_to_dec, Gen
+
+if _within_sage:
+    from ..sage_helper import ComplexField
+else:
+    from snappy.number import Number
+
+
+def is_pari(x) -> bool:
+    return isinstance(x, Gen)
+
+
+def pari_matrix(A):
+    return pari.matrix(len(A), len(A[0]), [pari(x) for x in sum(A, [])])
+
+
+def pari_row_vector(v):
+    return pari(v).Vec()
+
+
+def pari_column_vector(v):
+    return pari(v).Col()
+
+
+def pari_vector_to_list(v):
+    return v.Vec().python_list()
+
+
+def pari_matrix_to_lists(A):
+    'Return the entries of A in *column major* order'
+    return [pari_vector_to_list(v) for v in A.list()]
+
+
+def eval_gluing_equation(eqn, shapes):
+    if is_pari(eqn):
+        shapes = pari_vector_to_list(shapes)
+    a, b, c = eqn
+    ans = int(c)
+    for i, z in enumerate(shapes):
+        ans = ans * (z**int(a[i]) * (1 - z)**int(b[i]))
+    return ans
+
+
+def gluing_equation_errors(eqns, shapes):
+    return [eval_gluing_equation(eqn, shapes) - 1 for eqn in eqns]
+
+
+def infinity_norm(L):
+    if is_pari(L):
+        L = pari_vector_to_list(L)
+    return max([abs(x) for x in L])
+
+
+def gluing_equation_error(eqns, shapes):
+    return infinity_norm(gluing_equation_errors(eqns, shapes))
+
+
+def enough_gluing_equations(manifold):
+    """
+    Select a full-rank portion of the gluing equations.
+    """
+    n_tet = manifold.num_tetrahedra()
+    n_cusps = manifold.num_cusps()
+    eqns = manifold.gluing_equations("rect")
+    edge_eqns = pari_matrix([a + b for a, b, _ in eqns[:n_tet]])
+    edge_eqns_with_RHS = pari_matrix([a + b + [(1 - c) // 2]
+                                      for a, b, c in eqns[:n_tet]])
+    H, U = edge_eqns.mattranspose().mathnf(flag=1)
+    assert H.ncols() == n_tet - n_cusps
+    edge_eqns_with_RHS = pari_matrix_to_lists((edge_eqns_with_RHS.mattranspose() * U))[n_cusps:]
+    edge_eqns_with_RHS = [(e[:n_tet], e[n_tet: 2 * n_tet], pari(-1)**e[-1])
+                          for e in edge_eqns_with_RHS]
+
+    cusp_eqns = []
+    j = n_tet
+    for i in range(n_cusps):
+        cusp_eqns.append(eqns[j])
+        j += 2 if manifold.cusp_info(i)['complete?'] else 1
+
+    ans_eqns = edge_eqns_with_RHS + cusp_eqns
+
+    ans_matrix = pari_matrix([a + b for a, b, _ in ans_eqns])
+    assert len(ans_eqns) == n_tet and len(ans_matrix.mattranspose().matkerint()) == 0
+    return [(list(map(int, A)), list(map(int, B)), int(c)) for A, B, c in ans_eqns]
+
+
+def float_to_pari(x, dec_prec):
+    return pari(0) if x == 0 else pari(x).precision(dec_prec)
+
+
+def complex_to_pari(z, dec_prec):
+    return pari.complex(float_to_pari(z.real, dec_prec),
+                        float_to_pari(z.imag, dec_prec))
+
+
+def polished_tetrahedra_shapes(manifold, dec_prec=None, bits_prec=200, ignore_solution_type=False):
+    """
+    Refines the current solution to the gluing equations to one with
+    the specified accuracy.
+    """
+    if dec_prec is None:
+        dec_prec = prec_bits_to_dec(bits_prec)
+    else:
+        bits_prec = prec_dec_to_bits(dec_prec)
+    working_prec = dec_prec + 10
+    target_espilon = float_to_pari(10.0, working_prec)**-dec_prec
+    if _within_sage:
+        CC = ComplexField(bits_prec)
+        number = CC
+    else:
+        def number(z):
+            return Number(z, precision=bits_prec)
+
+    # This is a potentially long calculation, so we cache the result
+
+    if "polished_shapes" in manifold._cache:
+        curr_bits_prec, curr_sol = manifold._cache["polished_shapes"]
+        if bits_prec <= curr_bits_prec:
+            return [number(s) for s in pari_vector_to_list(curr_sol)]
+
+    # Check and make sure initial solution is reasonable
+
+    if not ignore_solution_type and manifold.solution_type() not in ['all tetrahedra positively oriented', 'contains negatively oriented tetrahedra']:
+        raise ValueError('Initial solution to gluing equations has flat or degenerate tetrahedra')
+
+    init_shapes = pari_column_vector([complex_to_pari(complex(z), working_prec) for z in manifold.tetrahedra_shapes('rect')])
+    init_equations = manifold.gluing_equations('rect')
+    if gluing_equation_error(init_equations, init_shapes) > pari(0.000001):
+        raise ValueError('Initial solution not very good')
+
+    # Now begin the actual computation
+    eqns = enough_gluing_equations(manifold)
+    shapes = init_shapes
+    initial_error = infinity_norm(gluing_equation_errors(eqns, shapes))
+    for i in range(100):
+        errors = gluing_equation_errors(eqns, shapes)
+        error = infinity_norm(errors)
+        if error < target_espilon or error > 100 * initial_error:
+            break
+        derivative = pari_matrix([[eqn[0][i] / z - eqn[1][i] / (1 - z)
+                                   for i, z in enumerate(pari_vector_to_list(shapes))] for eqn in eqns])
+        gauss = derivative.matsolve(pari_column_vector(errors))
+        shapes = shapes - gauss
+
+    # Check to make sure things worked out ok.
+    error = gluing_equation_error(init_equations, shapes)
+    total_change = infinity_norm(init_shapes - shapes)
+    if error > 1000 * target_espilon or total_change > pari(0.0000001):
+        raise ValueError('Did not find a good solution to the gluing equations')
+    manifold._cache["polished_shapes"] = (bits_prec, shapes)
+    return [number(s) for s in pari_vector_to_list(shapes)]

snappy/snap/slice_obs_HKL/__init__.py

@@ -0,0 +1,194 @@
+"""
+Using metabelian representations to obstruct slicing
+====================================================
+
+Based on::
+
+  Herald, Kirk, and Livingston, Math Zeit., 2010
+  https://dx.doi.org/10.1007/s00209-009-0548-1
+  https://arXiv.org/abs/0804.1355
+
+and::
+
+  Dunfield and Gong, "Ribbon concordances and slice obstructions:
+  experiments and examples", https://arXiv.org/abs/2512.21825
+
+In in the basic case, the implementation follows the [HKL] paper closely, with a
+few minor changes:
+
+1. We use the default simplified presentation for pi_1(knot exterior)
+   that SnapPy provides, rather than a Wirtinger presentation, as the
+   former has many fewer generators (but of course much longer
+   relators).
+
+2. The construction of the metabelian representations in Section 7 of
+   [HKL] is done the language of twisted cohomology and specifically
+   twisted cocycles, whereas this viewpoint is not quite explicit
+   (though clearly implied) in [HKL].
+
+3. To match the conventions of the other twisted Alexander polynomials
+   computed by SnapPy, we insist on all actions are on the left,
+   rather than the mix of left and right actions used in [HKL].
+
+4. For the final check of whether the twisted polynomial is a norm, we
+   simply use that Sage can factor univariate polynomials over
+   cyclotomic fields into irreducibles, rather than the various
+   generalizations of Gauss's Lemma in [HKL].
+
+Additionally, we implement the refinements and generalizations
+introduced in [DG].
+"""
+
+from ... import SnapPy
+from ...sage_helper import _within_sage, sage_method
+if _within_sage:
+    from ...sage_helper import ZZ, prime_range, prime_powers
+from . import basics, rep_theory, direct
+
+
+def expand_prime_power_spec(spec):
+    if spec in ZZ:
+        a, b = 0, spec
+    else:
+        if len(spec) != 2:
+            raise ValueError(f'Spec {spec} does not specify a range')
+        a, b = spec
+    return prime_powers(a, b + 1)
+
+
+def expand_prime_spec(spec):
+    if spec in ZZ:
+        a, b = 0, spec
+    else:
+        if len(spec) != 2:
+            raise ValueError(f'Spec {spec} does not specify a range')
+        a, b = spec
+    return prime_range(a, b + 1)
+
+
+@sage_method
+def slice_obstruction_HKL(self,
+                          primes_spec,
+                          verbose=0,
+                          check_in_S3=True,
+                          method='advanced',
+                          ribbon_mode=False):
+    """
+
+    For the exterior of a knot in the 3-sphere, search for a
+    Herald-Kirk-Livingston (HKL) topological slice obstruction as
+    described in Section 3 of Dunfield and Gong's paper
+    `[DG] <https://arXiv.org/abs/2512.21825>`_.
+
+    Specifically, it looks at the cyclic branched covers of the knot
+    of prime-power order p and the F_q homology thereof where q is
+    prime. The range of such (p, q) pairs searched is given by
+    primes_spec as a list of (p_max, [q_min, q_max]).  It returns the
+    pair (p, q) of the first nonzero obstruction found (in which case
+    K is not slice), and otherwise returns ``None``::
+
+       sage: M = Manifold('K12n813')
+       sage: spec = [(10, [0, 20]), (20, [0, 10])]
+       sage: M.slice_obstruction_HKL(spec, method='basic', verbose=1)
+           Looking at (2, 3) ...
+           Looking at (3, 2) ...
+           Looking at (3, 7) ...
+       (3, 7)
+
+    You can also specify the p to examine by a range [p_min, p_max] or
+    the q by just q_max::
+
+       sage: spec = [([5, 10], 10)]
+       sage: M.slice_obstruction_HKL(spec, method='advanced', verbose=1)
+           Looking at (8, 3) ...
+       (8, 3)
+
+    If primes_spec is just a pair (p, q) then only that obstruction is
+    checked::
+
+       sage: M.slice_obstruction_HKL((3, 7))
+       (3, 7)
+
+    The ``method`` argument determines which HKL tests are employed:
+
+    * ``method='basic'`` employs Lemma 3.5 of [DG] and corresponds
+      roughly to the test used in SnapPy 3.1 and 3.2, though these
+      earlier versions required p to be prime and forbid q = 2.
+
+    * ``method='advanced'`` is the default and employs Theorem 3.8
+      from [DG]. This subsumes the `basic` method, but can be quite
+      slow when the multiplicity of an irreducible V_i is large.
+
+      An example where this method has more success::
+
+        sage: M.slice_obstruction_HKL((2, 3), method='basic')  # returns None
+        sage: M.slice_obstruction_HKL((2, 3), method='advanced')
+        (2, 3)
+
+    * ``method='direct'`` employs the method of Section 3.20 of [DG] to
+      consider not just the F_q homology of the cover, but
+      epimorphisms of its group to Z/q^e Z for e > 1.  This is the
+      most computationally expensive method.  Example::
+
+        sage: M = Manifold('K14n16945')
+        sage: M.slice_obstruction_HKL((2, 3), method='advanced') # returns None
+        sage: M.slice_obstruction_HKL((2, 3), method='direct')
+        (2, 3)
+
+    For any method, q = 2 is handled using Section 3.11 of [DG].
+
+    If ``verbose`` is ``1`` or ``True``, it prints each pair (p, q) being considered;
+    when ``verbose`` is ``2``, information is printed about each step.
+
+    Finally, if ``ribbon_mode`` is ``True`` then it searches for
+    obstructions to being topologically homotopy ribbon.  These differ
+    from the slice case only when q = 2; see Theorem 3.12 of [DG]::
+
+      sage: M = Manifold('DT: qaqcJpEHnoDKBMqIgfal')  # The knot 17nh_0630889
+      sage: M.slice_obstruction_HKL((3, 2)) # returns None
+      sage: M.slice_obstruction_HKL((3, 2), ribbon_mode=True)
+      (3, 2)
+    """
+    if method not in ['basic', 'advanced', 'direct']:
+        raise ValueError("Argument method is not 'basic', 'advanced', or 'direct'")
+
+    M = self
+
+    if M.cusp_info('is_complete') != [True]:
+        raise ValueError('Need exactly one cusp which should be unfilled')
+    if M.homology().elementary_divisors() != [0]:
+        raise ValueError('Not the exterior of knot in S^3 as H_1 != Z')
+    if check_in_S3:
+        T = SnapPy.Triangulation(M)
+        T.dehn_fill((1, 0))
+        if T.fundamental_group().num_generators() != 0:
+            raise ValueError('The (1, 0) filling is not obviously S^3')
+
+    # Special case of only one (p, q) to check
+    if len(primes_spec) == 2 and primes_spec[0] in ZZ and primes_spec[1] in ZZ:
+        primes_spec = [([primes_spec[0]], [primes_spec[1]])]
+    else:
+        primes_spec = [(expand_prime_power_spec(a), expand_prime_spec(b))
+                       for a, b in primes_spec]
+
+    for ps, qs in primes_spec:
+        for p in ps:
+            d = basics.nonzero_divisor_product(M, p)
+            for q in qs:
+                if d % q == 0:
+                    if verbose:
+                        print('    Looking at', (p, q), '...')
+                    if method=='direct':
+                        success = direct.slicing_obstructed_by_larger_quotient(M, p, q,
+                                                                               ribbon_mode=ribbon_mode,
+                                                                               verbose=(verbose > 1))
+                    else:
+                        success = rep_theory.slicing_is_obstructed(M, p, q,
+                                                                   skip_higher_mult=(method=='basic'),
+                                                                   ribbon_mode=ribbon_mode,
+                                                                   verbose=(verbose > 1))
+                    if verbose > 1:
+                        print()
+
+                    if success:
+                        return (p, q)