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

snappy/ptolemy/manifoldMethods.py

@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 from . import matrix
 from . import homology
 from .ptolemyObstructionClass import PtolemyObstructionClass
@@ -7,13 +5,14 @@ from .ptolemyGeneralizedObstructionClass import PtolemyGeneralizedObstructionCla
 from .ptolemyVariety import PtolemyVariety
 from .utilities import MethodMappingList
 
+
 def _gcd(s, t):
     if t == 0:
         return s
     return _gcd(t, s % t)
 
-def get_ptolemy_obstruction_classes(manifold):
 
+def get_ptolemy_obstruction_classes(manifold):
     """
     Generates a list of obstruction cocycles representing each class in
     H^2(M,bd M; Z/2) suitable as argument for get_ptolemy_variety.
@@ -22,39 +21,39 @@ def get_ptolemy_obstruction_classes(manifold):
     See Definition 1.7 of
     Garoufalidis, Thurston, Zickert
     The Complex Volume of SL(n,C)-Representations of 3-Manifolds
-    http://arxiv.org/abs/1111.2828
+    https://arxiv.org/abs/1111.2828
 
     s_f_t takes values +/-1 and is the value of evaluating the cocycle on
     face f of tetrahedron t.
 
-    === Examples ===
+    **Examples**
 
     Get the obstruction classes for 4_1:
-    
+
     >>> from snappy import Manifold
     >>> M = Manifold("4_1")
     >>> c = get_ptolemy_obstruction_classes(M)
 
-    There are two such clases for 4_1:
-    
+    There are two such classes for 4_1:
+
     >>> len(c)
     2
-    
+
     Print the non-trivial obstruction class:
 
     >>> c[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)
 
     Construct Ptolemy variety for non-trivial obstruction class:
-    
+
     >>> p = get_ptolemy_variety(M, N = 2, obstruction_class = c[1])
 
     Short cut for the above code:
-    
+
     >>> p = get_ptolemy_variety(M, N = 2, obstruction_class = 1)
 
     Obstruction class only makes sense for even N:
-    
+
     >>> p = get_ptolemy_variety(M, N = 3, obstruction_class = c[1])
     Traceback (most recent call last):
         ...
@@ -62,7 +61,7 @@ def get_ptolemy_obstruction_classes(manifold):
 
 
     When specifying N = 3, it automatically uses generalized obstruction class.
-    
+
     >>> len(get_ptolemy_variety(M, N = 3, obstruction_class = 'all'))
     2
     """
@@ -81,8 +80,8 @@ def get_ptolemy_obstruction_classes(manifold):
             for index, H2_element
             in enumerate(H2_elements)]
 
-def get_generalized_ptolemy_obstruction_classes(manifold, N):
 
+def get_generalized_ptolemy_obstruction_classes(manifold, N):
     """
     See SnapPy.pyx for documentation
 
@@ -96,7 +95,7 @@ def get_generalized_ptolemy_obstruction_classes(manifold, N):
     [PtolemyGeneralizedObstructionClass([0, 0, 0, 0]), PtolemyGeneralizedObstructionClass([3, 0, 0, 1]), PtolemyGeneralizedObstructionClass([2, 0, 0, 2])]
     >>> get_generalized_ptolemy_obstruction_classes(M, 5)
     [PtolemyGeneralizedObstructionClass([0, 0, 0, 0]), PtolemyGeneralizedObstructionClass([4, 0, 0, 1])]
-  
+
     >>> M = Manifold("m202")
     >>> len(get_generalized_ptolemy_obstruction_classes(M, 2))
     4
@@ -104,7 +103,7 @@ def get_generalized_ptolemy_obstruction_classes(manifold, N):
     5
     >>> len(get_generalized_ptolemy_obstruction_classes(M, 4))
     10
-    
+
     >>> M = Manifold("m207")
     >>> len(get_generalized_ptolemy_obstruction_classes(M, 2))
     2
@@ -129,11 +128,11 @@ def get_generalized_ptolemy_obstruction_classes(manifold, N):
                 already_seen.add(
                     tuple([(x * u) % N for x in H2_element]))
 
-    return [PtolemyGeneralizedObstructionClass(H2_element, index = index,
-                                               N = N, manifold = manifold)
+    return [PtolemyGeneralizedObstructionClass(H2_element, index=index,
+                                               N=N, manifold=manifold)
             for index, H2_element
             in enumerate(filtered_H2_elements)]
-    
+
 
 def get_obstruction_classes(manifold, N):
 
@@ -150,77 +149,78 @@ def get_obstruction_classes(manifold, N):
     return (homology.homology_representatives(cochain_d2, cochain_d1, N),
             explain_columns)
 
+
 class PtolemyVarietyList(list):
     def retrieve_decomposition(self, *args, **kwargs):
         return MethodMappingList(
             [ p.retrieve_decomposition(*args, **kwargs)
               for p in self ])
+
     def compute_decomposition(self, *args, **kwargs):
         return MethodMappingList(
             [ p.compute_decomposition(*args, **kwargs)
               for p in self ])
+
     def retrieve_solutions(self, *args, **kwargs):
         return MethodMappingList(
             [ p.retrieve_solutions(*args, **kwargs)
               for p in self ])
+
     def compute_solutions(self, *args, **kwargs):
         return MethodMappingList(
             [ p.compute_solutions(*args, **kwargs)
               for p in self ])
-        
 
-def get_ptolemy_variety(manifold, N, obstruction_class = None,
-                        simplify = True, eliminate_fixed_ptolemys = False):
 
+def get_ptolemy_variety(manifold, N, obstruction_class = None,
+                        simplify : bool =True,
+                        eliminate_fixed_ptolemys : bool =False):
     """
     Generates Ptolemy variety as described in
     (1) Garoufalidis, Thurston, Zickert
     The Complex Volume of SL(n,C)-Representations of 3-Manifolds
-    http://arxiv.org/abs/1111.2828
-    
+    https://arxiv.org/abs/1111.2828
+
     (2) Garoufalidis, Goerner, Zickert:
-    Gluing Equations for PGL(n,C)-Representations of 3-Manifolds 
-    http://arxiv.org/abs/1207.6711
+    Gluing Equations for PGL(n,C)-Representations of 3-Manifolds
+    https://arxiv.org/abs/1207.6711
 
     The variety can be exported to magma or sage and solved there. The
     solutions can be processed to compute invariants. See below.
 
-    === Arguments ===
+    :param N: which SL(N,C) we want the variety.
 
-    N --- which SL(N,C) we want the variety.
+    :param obstruction_class: class from Definition 1.7 of (1).
+        ``None`` for trivial class,
+        a value returned from :meth:`get_ptolemy_obstruction_classes`,
+        an integer indexing the obstruction classes returned from
+        :meth:`get_ptolemy_obstruction_classes`,
+        or 'all' to return a list of Ptolemy varieties, one for each
+        obstruction class.
 
-    obstruction_class --- class from Definition 1.7 of (1).
-    None for trivial class or a value returned from get_ptolemy_obstruction_classes.
-    Short cuts: obstruction_class = 'all' returns a list of Ptolemy varieties
-    for each obstruction. For easier iteration, can set obstruction_class to 
-    an integer.
+    :param simplify: indicate whether to simplify the equations which
+          significantly reduces the number of variables. Simplifying means that several identified Ptolemy coordinates :math:`x = y = z = ...`
+         are eliminated instead of adding relations :math:`x - y = 0, y - z = 0, ...`
 
-    simplify --- boolean to indicate whether to simplify the equations which
-    significantly reduces the number of variables.
-    Simplifying means that several identified Ptolemy coordinates x = y = z = ...
-    are eliminated instead of adding relations x - y = 0, y - z = 0, ...
-    Defaults to True.
+    :param eliminate_fixed_ptolemys: boolean to indicate whether to eliminate
+       the Ptolemy coordinates that are set to 1 for fixing the decoration.
+       Even though this simplifies the resulting representation, setting it to
+       ``True`` can cause magma to run longer when finding a Groebner basis.
 
-    eliminate_fixed_ptolemys --- boolean to indicate whether to eliminate
-    the Ptolemy coordinates that are set to 1 for fixing the decoration.
-    Even though this simplifies the resulting representation, setting it to
-    True can cause magma to run longer when finding a Groebner basis.
-    Defaults to False.
+    **Examples for 4_1**
 
-    === Examples for 4_1 ===
-    
     >>> from snappy import Manifold
     >>> M = Manifold("4_1")
 
     Get the varieties for all obstruction classes at once (use
     help(varieties[0]) for more information):
-    
+
     >>> varieties = get_ptolemy_variety(M, N = 2, obstruction_class = "all")
 
     Print the variety as an ideal (sage object) for the non-trivial class:
 
     >>> varieties[1].ideal    #doctest: +SKIP
-    Ideal (-c_0011_0^2 + c_0011_0*c_0101_0 + c_0101_0^2, -c_0011_0^2 - c_0011_0*c_0101_0 + c_0101_0^2, c_0011_0 - 1) of Multivariate Polynomial Ring in c_0011_0, c_0101_0 over Rational Field                                                       
+    Ideal (-c_0011_0^2 + c_0011_0*c_0101_0 + c_0101_0^2, -c_0011_0^2 - c_0011_0*c_0101_0 + c_0101_0^2, c_0011_0 - 1) of Multivariate Polynomial Ring in c_0011_0, c_0101_0 over Rational Field
     (skip doctest because example only works in sage and not plain python)
 
     >>> for eqn in varieties[1].equations:
@@ -230,7 +230,7 @@ def get_ptolemy_variety(manifold, N, obstruction_class = None,
          - 1 + c_0011_0
 
     Generate a magma input to compute Groebner basis for N = 3:
-    
+
     >>> p = get_ptolemy_variety(M, N = 3)
     >>> s = p.to_magma()
 
@@ -246,20 +246,20 @@ def get_ptolemy_variety(manifold, N, obstruction_class = None,
 
 
 
-    === If you have a magma installation ===
+    **If you have a magma installation**
 
     Call p.compute_solutions() to automatically call magma on the above output
     and produce exact solutions!!!
-    
+
     >>> try:
     ...     sols = p.compute_solutions(verbose)
     ... except:
     ...     sols = None     # magma failed, use precomputed output instead
 
-    === If you do not have a magma installation ===
+    **If you do not have a magma installation**
 
     Load a precomputed example from magma which is provided with the package:
-    
+
     >>> from snappy.ptolemy.processMagmaFile import _magma_output_for_4_1__sl3, solutions_from_magma, triangulation_from_magma
     >>> print(_magma_output_for_4_1__sl3)      #doctest: +ELLIPSIS
     <BLANKLINE>
@@ -280,11 +280,11 @@ def get_ptolemy_variety(manifold, N, obstruction_class = None,
     >>> if sols is None:    # calling magma failed, so use precomputed example
     ...     sols = solutions_from_magma(_magma_output_for_4_1__sl3)
 
-    === Continue here whether you have or do not have magma ===
+    **Continue here whether you have or do not have magma**
 
     Pick the first solution of the three different solutions (up to Galois
     conjugates):
-    
+
     >>> len(sols)
     3
     >>> solution = sols[0]
@@ -304,10 +304,10 @@ def get_ptolemy_variety(manifold, N, obstruction_class = None,
     >>> len(simplified.equations), len(full.equations)
     (24, 72)
 
-    === ONLY DOCTESTS, NOT PART OF DOCUMENTATION ===
+    **ONLY DOCTESTS, NOT PART OF DOCUMENTATION**
 
     >>> varieties = get_ptolemy_variety(M, N = 2, obstruction_class = "all", eliminate_fixed_ptolemys = True)
-    
+
     >>> for eqn in varieties[1].equations:
     ...     print("    ", eqn)
          1 - c_0101_0 + c_0101_0^2
@@ -322,12 +322,12 @@ def get_ptolemy_variety(manifold, N, obstruction_class = None,
         ...
 
     """
-    
+
     if hasattr(manifold, 'cusp_info'):
         if False in manifold.cusp_info('is_complete'):
             raise Exception("Dehn fillings not supported by Ptolemy variety")
-    
-    # Typing M.ptolemy_variety(N = 3, 1) into sage makes 
+
+    # Typing M.ptolemy_variety(N = 3, 1) into sage makes
     # N have type sage.rings.integer.Integer
     N = int(N)
 
@@ -338,8 +338,8 @@ def get_ptolemy_variety(manifold, N, obstruction_class = None,
          isinstance(obstruction_class, PtolemyGeneralizedObstructionClass)):
         return PtolemyVariety(
             manifold, N, obstruction_class,
-            simplify = simplify,
-            eliminate_fixed_ptolemys = eliminate_fixed_ptolemys)
+            simplify=simplify,
+            eliminate_fixed_ptolemys=eliminate_fixed_ptolemys)
 
     # Will we return a list of obstruction classes versus a list
     list_obstruction_classes = False
@@ -360,7 +360,7 @@ def get_ptolemy_variety(manifold, N, obstruction_class = None,
             manifold, N)
         list_obstruction_classes = True
     else:
-        # New mode: 
+        # New mode:
         if N == 2:
             # N = 2 uses Z/2-obstruction class (so that we can compute
             # complex volume)
@@ -374,23 +374,22 @@ def get_ptolemy_variety(manifold, N, obstruction_class = None,
         # List all obstruction classes
         if obstruction_class == 'all':
             list_obstruction_classes = True
-            
+
     # Give a list of all obstruction classes
     if list_obstruction_classes:
         return PtolemyVarietyList([
             PtolemyVariety(
                 manifold, N, obstruction_class,
-                simplify = simplify,
-                eliminate_fixed_ptolemys = eliminate_fixed_ptolemys)
+                simplify=simplify,
+                eliminate_fixed_ptolemys=eliminate_fixed_ptolemys)
             for obstruction_class in obstruction_classes])
-    
+
     # Otherwise try to interpret obstruction_class as an index
     try:
         obstruction_class = obstruction_classes[int(obstruction_class)]
-    except:
+    except (KeyError, IndexError):
         raise Exception("Bad index for obstruction class")
 
     return PtolemyVariety(manifold, N, obstruction_class,
-                          simplify = simplify,
-                          eliminate_fixed_ptolemys = eliminate_fixed_ptolemys)
-
+                          simplify=simplify,
+                          eliminate_fixed_ptolemys=eliminate_fixed_ptolemys)

snappy/ptolemy/matrix.py

@@ -1,53 +1,64 @@
-from __future__ import print_function
-
 from ..pari import pari
 import fractions
 
+
 def num_rows(m):
     return len(m)
 
+
 def num_cols(m):
     if len(m) == 0:
         return 0
     return len(m[0])
 
+
 def col_is_zero(m, col):
     if col < 0:
         return True
     for row in m:
-        if not row[col]==0:
+        if not row[col] == 0:
             return False
     return True
 
+
 def max_abs_of_col(m, col):
     return max([abs(row[col]) for row in m])
 
+
 def row_is_zero(m, row):
     if row < 0:
         return True
     return is_vector_zero(m[row])
 
+
 def max_abs_of_row(m, row):
     return max([abs(x) for x in m[row]])
 
+
 def vector_add(v1, v2):
     return [x1 + x2 for x1, x2 in zip(v1, v2)]
 
+
 def matrix_diagonal(m):
     return [r[i] for i, r in enumerate(m)]
 
+
 def matrix_trace(m):
     return sum(matrix_diagonal(m))
 
+
 def matrix_mult_vector(m, v):
     return [_inner_product(row, v) for row in m]
 
+
 def matrix_add(m1, m2):
     return [[c1 + c2 for c1, c2 in zip(r1, r2)] for r1, r2 in zip(m1, m2)]
 
+
 def matrix_sub(m1, m2):
     return [[c1 - c2 for c1, c2 in zip(r1, r2)] for r1, r2 in zip(m1, m2)]
 
+
 def matrix_mult(m, n):
     num_rows_m = num_rows(m)
     num_cols_m = num_cols(m)
@@ -62,30 +73,35 @@ def matrix_mult(m, n):
     return [ [ compute_entry(i,j) for j in range(num_cols_n) ]
              for i in range(num_rows_m) ]
 
+
 def vector_modulo(v, mod):
     return [x % mod for x in v]
 
+
 def matrix_modulo(m, mod):
     return [vector_modulo(row, mod) for row in m]
 
+
 def is_vector_zero(v):
     for e in v:
         if not e == 0:
             return False
     return True
 
+
 def is_matrix_zero(m):
     for row in m:
         if not is_vector_zero(row):
             return False
     return True
 
+
 def matrix_transpose(m):
     if len(m) == 0:
         return []
-    
+
     return [[m[r][c] for r in range(len(m))]
-            for c in range(len(m[0]))]            
+            for c in range(len(m[0]))]
 
 
 def simultaneous_smith_normal_form(in1, in2):
@@ -99,13 +115,13 @@ def simultaneous_smith_normal_form(in1, in2):
                                     matrix_mult(
             matrix_inverse(v1), in2)) == d2
 
-
     # d1 d2 are m and n in new system
     # next three are coordinate changes in groups
-        
+
     return (u1, matrix_mult(v1, u2), v2,
             d1, d2)
 
+
 def test_simultaneous_smith_normal_form(in1, in2, u0, u1, u2, d1, d2):
     _assert_at_most_one_zero_entry_per_row_or_column(d1)
     _assert_at_most_one_zero_entry_per_row_or_column(d2)
@@ -117,8 +133,10 @@ def test_simultaneous_smith_normal_form(in1, in2, u0, u1, u2, d1, d2):
     assert is_matrix_zero(matrix_mult(in1, in2))
     assert is_matrix_zero(matrix_mult(d1, d2))
 
+
 def has_full_rank(matrix):
-    return len(_internal_to_pari(matrix).mattranspose().matker(flag = 1)) == 0
+    return len(_internal_to_pari(matrix).mattranspose().matker(flag=1)) == 0
+
 
 def _debug_print_matrix(m):
     for row in m:
@@ -131,12 +149,14 @@ def _debug_print_matrix(m):
 
 # internal representation of a matrix is as a list of list:
 # list of rows, each row is a list of columns.
+
+
 def _pari_to_internal(m):
     num_cols = len(m)
     if num_cols == 0:
         return []
     num_rows = len(m[0])
-    
+
     def convert(p):
         d = int(p.denominator())
         n = int(p.numerator())
@@ -147,35 +167,42 @@ def _pari_to_internal(m):
     return [[convert(m[(r,c)]) for c in range(num_cols)]
             for r in range(num_rows)]
 
+
 def _internal_to_pari(m):
     num_rows = len(m)
     if num_rows == 0:
         return pari.matrix(0,0)
     num_cols = len(m[0])
-    
+
     return pari.matrix(
         num_rows,num_cols,
         [i for row in m for i in row])
 
+
 def _expand_square_matrix(m, num_cols_rows):
 
     def upleft(row):
         return m[row]
+
     def upright(row):
         return [0 for col in range(num_cols_rows)]
+
     def downleft(row):
         return [0 for col in range(len(m))]
+
     def downright(row):
         return [1 if row == col else 0 for col in range(num_cols_rows)]
 
-    up   = [  upleft(row) +   upright(row) for row in range(len(m))]
+    up = [upleft(row) + upright(row) for row in range(len(m))]
     down = [downleft(row) + downright(row) for row in range(num_cols_rows)]
 
     return up + down
 
+
 def _identity_matrix(s):
-    return _expand_square_matrix([],s)
-    
+    return _expand_square_matrix([], s)
+
+
 def _get_only_non_zero_entry_in_col(m, col):
     entry = None
     for row in m:
@@ -183,10 +210,11 @@ def _get_only_non_zero_entry_in_col(m, col):
             assert (entry is None), (
                 "more than one non-zero entry in column %d" % col)
             entry = row[col]
-    if not entry is None:
+    if entry is not None:
         return entry
     return 0
 
+
 def _get_only_non_zero_entry_in_row(m, row):
     entry = None
     for i in m[row]:
@@ -194,58 +222,67 @@ def _get_only_non_zero_entry_in_row(m, row):
             assert (entry is None), (
                 "more than one non-zero entry in row %d" % row)
             entry = i
-    if not entry is None:
+    if entry is not None:
         return entry
     return 0
 
+
 def _split_matrix_bottom_zero_rows(m):
     for number_top_rows in range(len(m), -1, -1):
         if not row_is_zero(m, number_top_rows - 1):
             break
-    
+
     return m[:number_top_rows], m[number_top_rows:]
 
+
 def matrix_inverse(m):
     return _pari_to_internal(_internal_to_pari(m)**(-1))
 
+
 def matrix_determinant(m):
     return _internal_to_pari(m).matdet()
 
+
 def _inner_product(v1, v2):
     assert len(v1) == len(v2)
     return sum([e1 * e2 for e1, e2 in zip(v1, v2)])
 
+
 def smith_normal_form(m):
-    u, v, d = _internal_to_pari(m).matsnf(flag = 1)
+    u, v, d = _internal_to_pari(m).matsnf(flag=1)
     return (_pari_to_internal(u),
             _pari_to_internal(v),
             _pari_to_internal(d))
 
+
 def _smith_normal_form_with_inverse(m):
-    u, v, d = _internal_to_pari(m).matsnf(flag = 1)
+    u, v, d = _internal_to_pari(m).matsnf(flag=1)
     return (_pari_to_internal(u**(-1)),
             _pari_to_internal(v),
             _pari_to_internal(d))
 
+
 def _bottom_row_stable_smith_normal_form(m):
     m_up, m_down = _split_matrix_bottom_zero_rows(m)
-    
+
     if len(m_up) == 0:
         return (_identity_matrix(len(m)),
                 _identity_matrix(len(m[0])),
                 m)
-    
+
     u_upleft, v, d_up = _smith_normal_form_with_inverse(m_up)
 
     return (_expand_square_matrix(u_upleft, len(m_down)),
-            v, 
+            v,
             d_up + m_down)
 
+
 def _change_coordinates(u, v, m):
     return matrix_mult(
         matrix_mult(
             matrix_inverse(u), m), v)
 
+
 def _assert_at_most_one_zero_entry_per_row_or_column(m):
     for i in range(len(m)):
         num_non_zero_entries = 0
@@ -261,14 +298,15 @@ def _assert_at_most_one_zero_entry_per_row_or_column(m):
                 num_non_zero_entries += 1
         assert num_non_zero_entries < 2
 
+
 def get_independent_rows(rows, explain_rows,
-                         desired_determinant = None,
-                         sort_rows_key = None):
+                         desired_determinant=None,
+                         sort_rows_key=None):
 
     row_explain_pairs = list(zip(rows, explain_rows))
     if sort_rows_key:
         row_explain_pairs.sort(
-            key = (
+            key=(
                 lambda row_explain_pair: sort_rows_key(
                     row_explain_pair[1])))
 
@@ -279,13 +317,14 @@ def get_independent_rows(rows, explain_rows,
         raise Exception("Could not find enough independent rows")
 
     return result
-        
+
+
 def _get_independent_rows_recursive(row_explain_pairs,
                                     length,
                                     desired_determinant,
                                     selected_rows,
                                     selected_explains):
-    
+
     if len(selected_rows) == length:
         if desired_determinant is None:
             return selected_explains