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

snappy/snap/peripheral/peripheral.py

@@ -3,7 +3,8 @@ from .. import t3mlite as t3m
 from . import link, dual_cellulation
 
 if sage_helper._within_sage:
-    from sage.all import matrix, vector, ZZ
+    from ...sage_helper import matrix, vector, ZZ
+
 
 def peripheral_curve_from_snappy(dual_cell, snappy_data):
     D = dual_cell
@@ -67,7 +68,7 @@ def peripheral_curve_package(snappy_manifold):
     A = matrix([[alpha(meridian), beta(meridian)], [alpha(longitude), beta(longitude)]])
     assert abs(A.det()) == 1
     Ainv = A.inverse().change_ring(ZZ)
-    B = Ainv.transpose()*matrix(ZZ, [alpha.weights, beta.weights])
+    B = Ainv.transpose() * matrix(ZZ, [alpha.weights, beta.weights])
     mstar = dual_cellulation.OneCocycle(D, list(B[0]))
     lstar = dual_cellulation.OneCocycle(D, list(B[1]))
     AA = matrix([[mstar(meridian), lstar(meridian)], [mstar(longitude), lstar(longitude)]])
@@ -78,13 +79,14 @@ def peripheral_curve_package(snappy_manifold):
     N.cusp_dual_cellulation = D
     D.meridian, D.longitude = meridian, longitude
     D.meridian_star, D.longitude_star = mstar, lstar
+
     def slope(onecycle):
         return vector([D.meridian_star(onecycle), D.longitude_star(onecycle)])
     D.slope = slope
     return N, C, D, (mstar, lstar)
 
 
-class PeripheralOneCocycle(object):
+class PeripheralOneCocycle():
     """
     Let M be an ideal triangulation with one cusp, and consider the
     induced triangulation T of the cusp torus.  This object is a
@@ -103,7 +105,7 @@ class PeripheralOneCocycle(object):
         tet = self.mcomplex.Tetrahedra[tet_num]
         triangle = tet.CuspCorners[V]
         for side in triangle.oriented_sides():
-            E0, E1 = [link.TruncatedSimplexCorners[V][v] for v in side.vertices]
+            E0, E1 = (link.TruncatedSimplexCorners[V][v] for v in side.vertices)
             if E0 | E1 == F:
                 break
         assert E0 | E1 == F
@@ -116,23 +118,27 @@ class PeripheralOneCocycle(object):
 
 def peripheral_cohomology_basis(manifold):
     """
-    sage: M = Manifold('v0000')
-    sage: m, l = peripheral_cohomology_basis(M)
-    sage: face_corners = [(t, f, v) for t in range(7) for f in t3m.TwoSubsimplices for v in t3m.ZeroSubsimplices if f & v ]
-    sage: [m[fc] for fc in face_corners]  # doctest: +SKIP
-    [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, 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, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, -1, 0, -1, -1, 0, -1, 0, 0, -1, 0, 1, 0, 1, 0, 1, 0]
+    TESTS::
+
+        sage: M = Manifold('v0000')
+        sage: m, l = peripheral_cohomology_basis(M)
+        sage: face_corners = [(t, f, v) for t in range(7) for f in t3m.TwoSubsimplices for v in t3m.ZeroSubsimplices if f & v ]
+        sage: [m[fc] for fc in face_corners]  # doctest: +SKIP
+        [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, 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, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, -1, 0, -1, -1, 0, -1, 0, 0, -1, 0, 1, 0, 1, 0, 1, 0]
     """
-
     assert manifold.is_orientable() and manifold.num_cusps() == 1
     N, T, D, (m, l) = peripheral_curve_package(manifold)
     return PeripheralOneCocycle(m), PeripheralOneCocycle(l)
 
+
 def test_peripheral_curves(n=100, progress=True):
     """
-    sage: test_peripheral_curves(5, False)
+    TESTS::
+
+        sage: test_peripheral_curves(5, False)
     """
     import snappy
     census = snappy.OrientableCuspedCensus(cusps=1)
@@ -142,10 +148,12 @@ def test_peripheral_curves(n=100, progress=True):
             print(M.name())
         peripheral_curve_package(M)
 
+
 def doctest_globals():
     import snappy
     return {'Manifold':snappy.Manifold}
 
+
 if __name__ == '__main__':
     import doctest
     doctest.testmod(extraglobs=doctest_globals())

snappy/snap/peripheral/surface.py

@@ -2,14 +2,14 @@ from collections import OrderedDict
 from ... import sage_helper
 
 if sage_helper._within_sage:
-    from sage.all import (ZZ, matrix, vector, ChainComplex,
-                          cached_method, line, arrow, text)
+    from ...sage_helper import ZZ, matrix, vector, cached_method, ChainComplex
+    from sage.plot.all import line, arrow, text
 else:
     def cached_method(func):
         return func
 
 
-class Triangle(object):
+class Triangle():
     """
     The vertices are numbered 0, 1, 2 in an anti-clockwise
     orientation.
@@ -28,27 +28,29 @@ class Triangle(object):
     def oriented_sides(self):
         return [Side(self, e) for e in oriented_edges_of_triangle]
 
+
 def opposite_vertex_from_edge_function( vertices ):
-    other = [v for v in range(3) if not v in vertices]
+    other = [v for v in range(3) if v not in vertices]
     assert len(vertices) == 2 and len(other) == 1
     return other[0]
 
+
 opposite_vertex_from_edge_dict = {(i,j):opposite_vertex_from_edge_function((i,j))
                                   for i in range(3) for j in range(3) if i != j}
 
 oriented_edges_of_triangle = [ (1,2), (2,0), (0, 1)]
 
 
-class Edge(object):
+class Edge():
     """
     An oriented edge 0 -> 1.
     """
-    def __init__(self, sides = None, vertices=None):
-        self.sides, self.vertices= sides, vertices
+    def __init__(self, sides=None, vertices=None):
+        self.sides, self.vertices = sides, vertices
         self.index = None
 
     def glued_to(self, side):
-        for sides in ( [S for S in self.sides],  [-S for S in self.sides] ):
+        for sides in ( list(self.sides), [-S for S in self.sides] ):
             if side in sides:
                 sides.remove(side)
                 return sides[0]
@@ -73,14 +75,15 @@ class Edge(object):
         self.vertices = (self.vertices[1], self.vertices[0])
         self.sides = tuple( [-s for s in self.sides] )
 
-class EdgeList(object):
+
+class EdgeList():
     """
     A list with one item for each edge in a Triangle.  The contents
     can be accessed either by a pair of vertices or by the opposite
     vertex.
     """
     def __init__(self, items):
-        self.data = dict()
+        self.data = {}
         for i, x in enumerate(items):
             self[i] = x
 
@@ -97,8 +100,9 @@ class EdgeList(object):
     def __repr__(self):
         return '[%s, %s, %s]' % (self.data[0], self.data[1], self.data[2])
 
-class Vertex(object):
-    def __init__(self, corners = None):
+
+class Vertex():
+    def __init__(self, corners=None):
         self.corners = corners
         self.index = None
         self.incoming, self.outgoing = [], []
@@ -106,11 +110,12 @@ class Vertex(object):
     def __repr__(self):
         return "<Vertex %s: %s %s : %s>" % (self.index, [e.index for e in self.incoming], [e.index for e in self.outgoing], self.corners)
 
-class Side(object):
+
+class Side():
     """
     A neighborhood of an oriented edge in a triangle
     """
-    def __init__(self, triangle = None, vertices = None):
+    def __init__(self, triangle=None, vertices=None):
         self.triangle, self.vertices = triangle, vertices
         self.index = None
 
@@ -128,7 +133,7 @@ class Side(object):
             t, T = self.triangle, other.triangle
             v, w = self.vertices
             V, W = other.vertices
-            return t==T and v==V and w==W
+            return t == T and v == V and w == W
 
     def __ne__(self, other):
         return not self.__eq__(other)
@@ -144,7 +149,8 @@ class Side(object):
     def opposite_vertex(self):
         return opposite_vertex_from_edge_dict[self.vertices]
 
-class Corner(object):
+
+class Corner():
     """
     A neighborhood of a vertex V in a triangle T.
     """
@@ -171,12 +177,13 @@ class Corner(object):
 
     def __eq__(self, other):
         if isinstance(other, Corner):
-            return (self.triangle==other.triangle) and (self.vertex==other.vertex)
+            return (self.triangle == other.triangle) and (self.vertex == other.vertex)
 
     def __ne__(self, other):
         return not self.__eq__(other)
 
-class Surface(object):
+
+class Surface():
     """
     An oriented surface.
     """
@@ -199,7 +206,7 @@ class Surface(object):
             e1 = (b, a)
 
             S0, S1 = Side(T0, e0), Side(T1, e1)
-            E = Edge( sides = (S0,S1) )
+            E = Edge( sides=(S0,S1) )
 
             T0.edges[opposite_vertex_from_edge_dict[e0]] = E
             T1.edges[opposite_vertex_from_edge_dict[e1]] = E
@@ -230,7 +237,7 @@ class Surface(object):
             vertices.append(V)
 
         self.vertices = vertices
-        self._vertex_containing_corner = dict([( (C.triangle, C.vertex), V) for V in vertices for C in V.corners])
+        self._vertex_containing_corner = {(C.triangle, C.vertex): V for V in vertices for C in V.corners}
 
     def build(self):
         """
@@ -270,7 +277,7 @@ class Surface(object):
         for e in self.edges:
             v_init = vertex_to_row[e.vertices[0]]
             v_term = vertex_to_row[e.vertices[1]]
-            D[v_term, e.index]+= 1
+            D[v_term, e.index] += 1
             D[v_init, e.index] += -1
 
         return D
@@ -307,25 +314,23 @@ class Surface(object):
         return self.B2().transpose()
 
     def euler(self):
-        return  len(self.vertices) - len(self.edges) + len(self.triangles)
+        return len(self.vertices) - len(self.edges) + len(self.triangles)
 
     def homology_test(self):
         B1, B2 = self.B1(), self.B2()
-        assert B1*B2 == 0
-        r1, r2 = B1.rank(), B2.rank()
-        b0 = len(self.vertices) - r1
+        assert B1 * B2 == 0
+        b0 = len(self.vertices) - B1.rank()
         b1 = B1.right_kernel().dimension() - B2.rank()
         b2 = B2.right_kernel().dimension()
         assert b0 - b1 + b2 == self.euler()
 
-
     @cached_method
     def chain_complex(self):
-         return ChainComplex( {1:self.B1(), 2:self.B2()} , degree=-1 )
+        return ChainComplex({1: self.B1(), 2: self.B2()}, degree=-1)
 
     @cached_method
     def cochain_complex(self):
-         return self.chain_complex().dual()
+        return self.chain_complex().dual()
 
     @cached_method
     def betti(self, dimension=1):
@@ -334,16 +339,10 @@ class Surface(object):
 
     @cached_method
     def integral_cohomology_basis(self, dimension=1):
+        # Removed use of Chomp per https://trac.sagemath.org/ticket/33777
         C = self.cochain_complex()
-        from sage.interfaces.chomp import have_chomp
-        if have_chomp():
-            if C.betti(1) != 0:
-                ans = C.homology(generators=True)[1][1]
-            else:
-                ans = []
-        else:
-            homology = C.homology(generators=True, algorithm='no_chomp')[dimension]
-            ans = [factor[1].vector(dimension) for factor in homology]
+        homology = C.homology(generators=True)[dimension]
+        ans = [factor[1].vector(dimension) for factor in homology]
 
         if dimension == 1:
             assert len(ans) == 2 - self.euler()
@@ -352,16 +351,10 @@ class Surface(object):
 
     @cached_method
     def integral_homology_basis(self, dimension=1):
+        # Removed use of Chomp per https://trac.sagemath.org/ticket/33777
         C = self.chain_complex()
-        from sage.interfaces.chomp import have_chomp
-        if have_chomp():
-            if C.betti(1) != 0:
-                ans = C.homology(generators=True)[1][1]
-            else:
-                ans = []
-        else:
-            homology = C.homology(generators=True, algorithm='no_chomp')[dimension]
-            ans = [factor[1].vector(dimension) for factor in homology]
+        homology = C.homology(generators=True)[dimension]
+        ans = [factor[1].vector(dimension) for factor in homology]
 
         if dimension == 1:
             assert len(ans) == 2 - self.euler()
@@ -375,6 +368,7 @@ def first_pair_differing_in_first_component(L):
         if a[0] != b[0]:
             return a, b
 
+
 def segments_into_components(L):
     components = []
     while L:
@@ -391,6 +385,7 @@ def segments_into_components(L):
 
     return components
 
+
 def component_to_cycle(surface, component):
     w = len(surface.edges)*[0,]
     for s in component:
@@ -399,7 +394,7 @@ def component_to_cycle(surface, component):
 
 
 class OneCycleSegment:
-    def __init__(self, edge, orientation_agrees, family_index, next = None, previous = None):
+    def __init__(self, edge, orientation_agrees, family_index, next=None, previous=None):
         self.edge, self.orientation_agrees = edge, orientation_agrees
         self.next, self.previous = next, previous
         self.family_index = family_index
@@ -407,6 +402,7 @@ class OneCycleSegment:
     def __repr__(self):
         return "<OCSeg: %d %d>" % (self.edge.index, self.family_index)
 
+
 class Cycle:
     """
     Base class of OneCycle and OneCocycle.  The get/setitem allows one to
@@ -417,8 +413,8 @@ class Cycle:
     """
     def __init__(self, surface, weights=None, check=True):
         self.surface, self.weights = surface, weights
-        if weights == None:
-            self.weights = len(surface.edges)*[None]
+        if weights is None:
+            self.weights = len(surface.edges) * [None]
         else:
             if check:
                 self.check()
@@ -454,6 +450,7 @@ class Cycle:
             return self.__class__(self.surface, [s + o for s, o in zip(self.weights, other.weights)],
                                   check=False)
 
+
 class OneCycle(Cycle):
     def check(self):
         w = vector(self.weights)
@@ -476,7 +473,7 @@ class OneCycle(Cycle):
         support = [i for i, w in enumerate(W) if w != 0]
         segments = {}
         for i in support:
-            E =S.edges[i]
+            E = S.edges[i]
             w = self.weights[i]
             o = 1 if w > 0 else -1
             segments[i] = [OneCycleSegment(E, o, a) for a in range(abs(w))]

snappy/snap/peripheral/test.py

@@ -1,9 +1,11 @@
-import sys, getopt
+import sys
+import getopt
 import doctest
 
 from . import dual_cellulation, link, peripheral, surface
 modules = [dual_cellulation, link, peripheral, surface]
 
+
 def verbose():
     try:
         optlist, args = getopt.getopt(sys.argv[1:], 'v', ['verbose'])
@@ -13,23 +15,21 @@ def verbose():
         verbose = False
     return verbose
 
+
 def doctest_globals(module):
     if hasattr(module, 'doctest_globals'):
         return module.doctest_globals()
-    else:
-        return dict()
+    return {}
+
 
 if __name__ == '__main__':
     failed, attempted = 0, 0
     for module in modules:
         print(module.__name__)
         result = doctest.testmod(module,
-                                 extraglobs= doctest_globals(module),
+                                 extraglobs=doctest_globals(module),
                                  verbose=verbose())
-        print(4*' ' + repr(result))
+        print(4 * ' ' + repr(result))
         failed += result.failed
         attempted += result.attempted
     print('\nAll doctests:\n    %s failures out of %s tests.' % (failed, attempted))
-
-    
-        

snappy/snap/polished_reps.py

@@ -1,44 +1,36 @@
-from __future__ import print_function
-
 """
 A Sage module for finding the holonomy representation of a hyperbolic
 3-manifold to very high precision.
 """
-import os, sys, re, string, tempfile
 from itertools import product, chain
-from functools import reduce
 from ..sage_helper import _within_sage
+from ..math_basics import prod
 from ..pari import pari
 
 from .fundamental_polyhedron import *
 
 if _within_sage:
-    import sage
-    from sage.all import RealField, ComplexField, gcd, prod, powerset
-    from sage.all import MatrixSpace, matrix, vector, ZZ
-    Object = sage.structure.sage_object.SageObject
+    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)
-    def prod(L, initial=None):
-        if initial:
-            return reduce(lambda x, y : x*y, L, initial)
-        elif L:
-            return reduce(lambda x, y : x*y, L)
-        else:
-            return 1
     abelian_group_elt = lambda v: v
 
-#----------------------------------------------------------------
+
+# ----------------------------------------------------------------
 #
 #  Abelianization of the fundamental group
 #
-#----------------------------------------------------------------
+# ----------------------------------------------------------------
 
 class MapToFreeAbelianization(Object):
     """
@@ -46,9 +38,8 @@ class MapToFreeAbelianization(Object):
     >>> M = snappy.Manifold('m125')
     >>> G = M.fundamental_group(False, False, False)
     >>> rho = MapToFreeAbelianization(G)
-    >>> from __future__ import print_function
     >>> for g in G.generators(): print( g, rho(g) )
-    ... 
+    ...
     a (3, -1)
     b (5, -2)
     c (0, 1)
@@ -78,9 +69,11 @@ class MapToFreeAbelianization(Object):
 
 # 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)
@@ -92,30 +85,38 @@ else:
         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())])
+    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)])
+    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):
@@ -123,13 +124,14 @@ def make_trace_2(A):
     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()._sage_().list() )
+    v = vector( CC , pari(P - 1).matker()[0])
     assert (v - P*v).norm() < epsilon
     return v
 
@@ -207,7 +209,7 @@ class MatrixRepresentation(Object):
     def all_lifts_to_SL2C(self):
         ans = []
         self.lift_to_SL2C()
-        base_gen_images = map(self, self.generators())
+        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)])
@@ -228,6 +230,7 @@ class MatrixRepresentation(Object):
         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)
@@ -240,13 +243,22 @@ class ManifoldGroup(MatrixRepresentation):
         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])
+        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):
-        M, L = map(self.SL2C, self.peripheral_curves()[cusp_num])
+        """
+        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] ]
+        M, L = ( make_trace_2( C**(-1)*A*C ) for A in [M, L] )
         z = L[0][1]/M[0][1]
         return z.conjugate()
 
@@ -264,21 +276,35 @@ class ManifoldGroup(MatrixRepresentation):
             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'%(
+        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):
+                      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 equipt with a high-precision version of the
-    holonomy representation::
+    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()
@@ -297,9 +323,9 @@ def polished_holonomy(manifold,
     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 ]
+        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()
@@ -307,4 +333,3 @@ def polished_holonomy(manifold,
         assert PG.is_projective_representation()
 
     return PG
-