passagemath-graphs 10.5.43__cp311-cp311-macosx_14_0_arm64.whl → 10.6.1rc2__cp311-cp311-macosx_14_0_arm64.whl

sage/combinat/cluster_algebra_quiver/quiver.py

@@ -28,7 +28,10 @@ AUTHORS:
 - Gregg Musiker
 - Christian Stump
 
-.. SEEALSO:: For mutation types of combinatorial quivers, see :meth:`~sage.combinat.cluster_algebra_quiver.quiver_mutation_type.QuiverMutationType`. Cluster seeds are closely related to :meth:`~sage.combinat.cluster_algebra_quiver.cluster_seed.ClusterSeed`.
+.. SEEALSO::
+
+    For mutation types of combinatorial quivers, see :meth:`~sage.combinat.cluster_algebra_quiver.quiver_mutation_type.QuiverMutationType`.
+    Cluster seeds are closely related to :meth:`~sage.combinat.cluster_algebra_quiver.cluster_seed.ClusterSeed`.
 """
 # ****************************************************************************
 #       Copyright (C) 2011 Gregg Musiker <musiker@math.mit.edu>
@@ -40,22 +43,21 @@ AUTHORS:
 from copy import copy
 from itertools import product
 
-from sage.structure.sage_object import SageObject
-from sage.rings.integer_ring import ZZ
-from sage.rings.infinity import infinity
-from sage.graphs.digraph import DiGraph
-from sage.graphs.graph import Graph
-from sage.graphs.views import EdgesView
 from sage.arith.misc import gcd
-from sage.misc.misc_c import prod
-from sage.misc.lazy_import import lazy_import
-from sage.rings.rational_field import QQ
-from sage.rings.polynomial.polynomial_ring import polygen
 from sage.combinat.cluster_algebra_quiver.quiver_mutation_type import QuiverMutationType, QuiverMutationType_Irreducible, QuiverMutationType_Reducible, _edge_list_to_matrix
 from sage.combinat.cluster_algebra_quiver.mutation_class import _principal_part, _digraph_mutate, _matrix_to_digraph, _dg_canonical_form, _mutation_class_iter, _digraph_to_dig6, _dig6_to_matrix
 from sage.combinat.cluster_algebra_quiver.mutation_type import _connected_mutation_type, _mutation_type_from_data, is_mutation_finite
-
 from sage.combinat.cluster_algebra_quiver.interact import cluster_interact
+from sage.graphs.digraph import DiGraph
+from sage.graphs.graph import Graph
+from sage.graphs.views import EdgesView
+from sage.misc.lazy_import import lazy_import
+from sage.misc.misc_c import prod
+from sage.rings.infinity import infinity
+from sage.rings.integer_ring import ZZ
+from sage.rings.polynomial.polynomial_ring import polygen
+from sage.rings.rational_field import QQ
+from sage.structure.sage_object import SageObject
 
 lazy_import('sage.modules.free_module_element', 'vector')
 lazy_import('sage.matrix.constructor', 'matrix')
@@ -69,12 +71,18 @@ class ClusterQuiver(SageObject):
 
     - ``data`` -- can be any of the following::
 
-      * :class:`QuiverMutationType`
-      * :class:`str` -- string representing a :class:`QuiverMutationType` or a common quiver type (see Examples)
-      * :class:`ClusterQuiver`
-      * :class:`Matrix` -- a skew-symmetrizable matrix
-      * :class:`DiGraph` -- must be the input data for a quiver
-      * List of edges -- must be the edge list of a digraph for a quiver
+      - :class:`QuiverMutationType`
+
+      - :class:`str` -- string representing a :class:`QuiverMutationType`
+        or a common quiver type (see Examples)
+
+      - :class:`ClusterQuiver`
+
+      - :class:`Matrix` -- a skew-symmetrizable matrix
+
+      - :class:`DiGraph` -- must be the input data for a quiver
+
+      - List of edges -- must be the edge list of a digraph for a quiver
 
     - ``frozen`` -- (default: ``None``) sets the list of frozen variables
       if the input type is a :class:`DiGraph`, it is ignored otherwise
@@ -148,30 +156,30 @@ class ClusterQuiver(SageObject):
 
         sage: Q = ClusterQuiver(['A',[2,5],1]); Q
         Quiver on 7 vertices of type ['A', [2, 5], 1]
-        sage: T = ClusterQuiver( Q ); T
+        sage: T = ClusterQuiver(Q); T
         Quiver on 7 vertices of type ['A', [2, 5], 1]
 
     From a Matrix::
 
         sage: Q = ClusterQuiver(['A',[2,5],1]); Q
         Quiver on 7 vertices of type ['A', [2, 5], 1]
-        sage: T = ClusterQuiver( Q._M ); T
+        sage: T = ClusterQuiver(Q._M); T
         Quiver on 7 vertices
 
-        sage: Q = ClusterQuiver( matrix([[0,1,-1],[-1,0,1],[1,-1,0],[1,2,3]]) ); Q
+        sage: Q = ClusterQuiver(matrix([[0,1,-1],[-1,0,1],[1,-1,0],[1,2,3]])); Q
         Quiver on 4 vertices with 1 frozen vertex
 
-        sage: Q = ClusterQuiver( matrix([]) ); Q
+        sage: Q = ClusterQuiver(matrix([])); Q
         Quiver without vertices
 
     From a DiGraph::
 
         sage: Q = ClusterQuiver(['A',[2,5],1]); Q
         Quiver on 7 vertices of type ['A', [2, 5], 1]
-        sage: T = ClusterQuiver( Q._digraph ); T
+        sage: T = ClusterQuiver(Q._digraph); T
         Quiver on 7 vertices
 
-        sage: Q = ClusterQuiver( DiGraph([[1,2],[2,3],[3,4],[4,1]]) ); Q
+        sage: Q = ClusterQuiver(DiGraph([[1,2],[2,3],[3,4],[4,1]])); Q
         Quiver on 4 vertices
 
         sage: Q = ClusterQuiver(DiGraph([['a', 'b'], ['b', 'c'], ['c', 'd'], ['d', 'e']]),
@@ -180,13 +188,14 @@ class ClusterQuiver(SageObject):
         sage: Q.mutation_type()
         [ ['A', 2], ['A', 2] ]
         sage: Q
-        Quiver on 5 vertices of type [ ['A', 2], ['A', 2] ] with 1 frozen vertex
+        Quiver on 5 vertices of type [ ['A', 2], ['A', 2] ]
+        with 1 frozen vertex
 
     From a List of edges::
 
         sage: Q = ClusterQuiver(['A',[2,5],1]); Q
         Quiver on 7 vertices of type ['A', [2, 5], 1]
-        sage: T = ClusterQuiver( Q._digraph.edges(sort=True) ); T
+        sage: T = ClusterQuiver(Q._digraph.edges(sort=True)); T
         Quiver on 7 vertices
 
         sage: Q = ClusterQuiver([[1, 2], [2, 3], [3, 4], [4, 1]]); Q
@@ -215,7 +224,7 @@ class ClusterQuiver(SageObject):
         ValueError: the input data was not recognized
     """
 
-    def __init__(self, data, frozen=None, user_labels=None):
+    def __init__(self, data, frozen=None, user_labels=None) -> None:
         """
         TESTS::
 
@@ -226,11 +235,12 @@ class ClusterQuiver(SageObject):
         from sage.structure.element import Matrix
 
         if isinstance(user_labels, list):
-            user_labels = [tuple(x) if isinstance(x, list) else x for x in user_labels]
+            user_labels = [tuple(x) if isinstance(x, list) else x
+                           for x in user_labels]
         elif isinstance(user_labels, dict):
-            values = [tuple(user_labels[x]) if isinstance(user_labels[x], list) else user_labels[x] for x in user_labels]
-            user_labels = dict(zip(user_labels.keys(),
-                                   values))
+            user_labels = {x: tuple(label) if isinstance(label, list)
+                           else label
+                           for x, label in user_labels.items()}
 
         # constructs a quiver from a mutation type
         if isinstance(data, (QuiverMutationType_Irreducible,
@@ -241,7 +251,7 @@ class ClusterQuiver(SageObject):
                       ' Use set_frozen to freeze vertices.')
 
             mutation_type = data
-            self.__init__( mutation_type.standard_quiver() )
+            self.__init__(mutation_type.standard_quiver())
             if user_labels:
                 self.relabel(user_labels)
                 self._nlist = list(user_labels)
@@ -251,9 +261,10 @@ class ClusterQuiver(SageObject):
         # NOTE: for now, any string representing a *reducible type* is
         #   coerced into the standard quiver, but there is now more flexibility
         #   in how to input a connected (irreducible) quiver.
-        elif (isinstance(data, (list,tuple))
-              and (isinstance(data[0], str) or all(isinstance(comp, (list,tuple))
-                   and isinstance(comp[0], str) for comp in data))):
+        elif (isinstance(data, (list, tuple))
+              and (isinstance(data[0], str) or
+                   all(isinstance(comp, (list, tuple))
+                       and isinstance(comp[0], str) for comp in data))):
             if frozen is not None:
                 print('The input specifies a mutation type, so the additional'
                       ' parameter frozen is ignored. Use set_frozen to freeze vertices.')
@@ -265,50 +276,54 @@ class ClusterQuiver(SageObject):
             #   format the input appropriately.  Thus we handle several
             #   special cases this way.
             if len(data) == 2 and isinstance(data[0], str):
-                if data[0] == 'TR' or data[0] == 'GR' or (data[0] == 'C' and data[1] == 2):
-                    if data[1] in ZZ:
-                        quiv = ClusterQuiver( QuiverMutationType_Irreducible( data[0], data[1] )._digraph )
+                d0, d1 = data
+                if d0 == 'TR' or d0 == 'GR' or (d0 == 'C' and d1 == 2):
+                    if d1 in ZZ:
+                        quiv = ClusterQuiver(QuiverMutationType_Irreducible(d0, d1)._digraph)
                         quiv._mutation_type = mutation_type
-                        self.__init__( quiv )
-                    elif isinstance(data[1], list):
-                        quiv = ClusterQuiver( QuiverMutationType_Irreducible( data[0], tuple(data[1]) )._digraph )
+                        self.__init__(quiv)
+                    elif isinstance(d1, list):
+                        quiv = ClusterQuiver(QuiverMutationType_Irreducible(d0, tuple(d1))._digraph)
                         quiv._mutation_type = mutation_type
-                        self.__init__( quiv )
+                        self.__init__(quiv)
                 else:
-                    self.__init__( mutation_type.standard_quiver() )
+                    self.__init__(mutation_type.standard_quiver())
             elif len(data) == 3 and isinstance(data[0], str):
-                if (data[0] == 'F' and data[1] == 4 and data[2] == [2,1]) or (data[0] == 'G' and data[1] == 2 and data[2] == [3,1]):
-                    quiv = ClusterQuiver( QuiverMutationType_Irreducible( data[0], data[1], tuple(data[2]) )._digraph )
+                d0, d1, d2 = data
+                if ((d0 == 'F' and d1 == 4 and d2 == [2, 1]) or
+                        (d0 == 'G' and d1 == 2 and d2 == [3, 1])):
+                    quiv = ClusterQuiver(QuiverMutationType_Irreducible(d0, d1, tuple(d2))._digraph)
                     quiv._mutation_type = mutation_type
-                    self.__init__( quiv )
-                elif (data[0] == 'F' and data[1] == 4 and data[2] == (2,1) ) or (data[0] == 'G' and data[1] == 2 and data[2] == (3,1) ):
-                    quiv = ClusterQuiver( QuiverMutationType_Irreducible( data[0], data[1], data[2] )._digraph )
+                    self.__init__(quiv)
+                elif ((d0 == 'F' and d1 == 4 and d2 == (2, 1)) or
+                      (d0 == 'G' and d1 == 2 and d2 == (3, 1))):
+                    quiv = ClusterQuiver(QuiverMutationType_Irreducible(d0, d1, d2)._digraph)
                     quiv._mutation_type = mutation_type
-                    self.__init__( quiv )
-                elif data[0] == 'A' and isinstance(data[1], list) and data[2] == 1:
-                    if len(data[1]) == 2 and min(data[1]) == 0:
-                        quiv = ClusterQuiver( QuiverMutationType_Irreducible( data[0], tuple(data[1]), data[2] )._digraph )
+                    self.__init__(quiv)
+                elif d0 == 'A' and isinstance(d1, list) and d2 == 1:
+                    if len(d1) == 2 and min(d1) == 0:
+                        quiv = ClusterQuiver(QuiverMutationType_Irreducible(d0, tuple(d1), d2)._digraph)
                         quiv._mutation_type = mutation_type
-                        self.__init__( quiv )
+                        self.__init__(quiv)
                     else:
-                        self.__init__( mutation_type.standard_quiver() )
+                        self.__init__(mutation_type.standard_quiver())
 
-                elif data[0] == 'A' and isinstance(data[1], tuple) and data[2] == 1:
-                    if len(data[1]) == 2 and min(data[1]) == 0:
-                        quiv = ClusterQuiver( QuiverMutationType_Irreducible( data[0], data[1], data[2] )._digraph )
+                elif d0 == 'A' and isinstance(d1, tuple) and d2 == 1:
+                    if len(d1) == 2 and min(d1) == 0:
+                        quiv = ClusterQuiver(QuiverMutationType_Irreducible(d0, d1, d2)._digraph)
                         quiv._mutation_type = mutation_type
-                        self.__init__( quiv )
+                        self.__init__(quiv)
                     else:
-                        self.__init__( mutation_type.standard_quiver() )
+                        self.__init__(mutation_type.standard_quiver())
 
                 else:
-                    self.__init__( mutation_type.standard_quiver() )
+                    self.__init__(mutation_type.standard_quiver())
             else:
-                self.__init__( mutation_type.standard_quiver() )
+                self.__init__(mutation_type.standard_quiver())
 
             if user_labels:
                 if isinstance(user_labels, dict):
-                    self._nlist = list(user_labels.keys())
+                    self._nlist = list(user_labels)
                 else:
                     self._nlist = user_labels
 
@@ -316,7 +331,7 @@ class ClusterQuiver(SageObject):
 
         # constructs a quiver from a cluster seed
         elif isinstance(data, ClusterSeed):
-            self.__init__( data.quiver() )
+            self.__init__(data.quiver())
 
         # constructs a quiver from a quiver
         elif isinstance(data, ClusterQuiver):
@@ -330,14 +345,14 @@ class ClusterQuiver(SageObject):
             self._m = data._m
             self._mlist = list(data._mlist)
             self._nlist = list(data._nlist)
-            self._digraph = copy( data._digraph )
+            self._digraph = copy(data._digraph)
             self._vertex_dictionary = data._vertex_dictionary
             self._mutation_type = data._mutation_type
             self._description = data._description
 
         # constructs a quiver from a matrix
         elif isinstance(data, Matrix):
-            if not _principal_part(data).is_skew_symmetrizable( positive=True ):
+            if not _principal_part(data).is_skew_symmetrizable(positive=True):
                 raise ValueError('The principal part of the matrix data must be skew-symmetrizable.')
 
             if frozen is not None:
@@ -347,20 +362,20 @@ class ClusterQuiver(SageObject):
             self._M.set_immutable()
             self._n = n = self._M.ncols()
             self._m = m = self._M.nrows() - self._n
-            self._digraph = _matrix_to_digraph( self._M )
+            self._digraph = _matrix_to_digraph(self._M)
             self._vertex_dictionary = {}
             self._mutation_type = None
 
             if user_labels:
                 if isinstance(user_labels, dict):
-                    self._nlist = list(user_labels.keys())[0:n]
-                    self._mlist = list(user_labels.keys())[n:n+m]
+                    self._nlist = list(user_labels)[0:n]
+                    self._mlist = list(user_labels)[n:n+m]
                 elif isinstance(user_labels, list):
                     self._nlist = user_labels[0:n]
                     self._mlist = user_labels[n:n+m]
                 self._digraph.relabel(self._nlist + self._mlist)
             else:
-                self._mlist = list(range(n,n+m))
+                self._mlist = list(range(n, n+m))
                 self._nlist = list(range(n))
             if n+m == 0:
                 self._description = 'Quiver without vertices'
@@ -417,34 +432,34 @@ class ClusterQuiver(SageObject):
                     else:
                         multi_edges[(v1, v2)] = label
                     dg.delete_edge(v1, v2)
-                dg.add_edges([(v1, v2, multi_edges[(v1,v2)])
+                dg.add_edges([(v1, v2, multi_edges[(v1, v2)])
                               for v1, v2 in multi_edges])
 
-            for edge in dg.edge_iterator():
-                if edge[0] >= n and edge[1] >= n:
+            for e0, e1, lab in dg.edge_iterator():
+                if e0 >= n and e1 >= n:
                     raise ValueError("the input digraph contains edges"
                                      " within the frozen vertices")
-                if edge[2] is None:
-                    dg.set_edge_label( edge[0], edge[1], (1,-1) )
-                    edge = (edge[0],edge[1],(1,-1))
-                elif edge[2] in ZZ:
-                    dg.set_edge_label( edge[0], edge[1], (edge[2],-edge[2]) )
-                    edge = (edge[0],edge[1],(edge[2],-edge[2]))
-                elif isinstance(edge[2], list) and len(edge[2]) != 2:
+                if lab is None:
+                    lab = (1, -1)
+                    dg.set_edge_label(e0, e1, lab)
+                elif lab in ZZ:
+                    lab = (lab, -lab)
+                    dg.set_edge_label(e0, e1, lab)
+                elif isinstance(lab, list) and len(lab) != 2:
                     raise ValueError("the input digraph contains an edge with"
                                      " the wrong type of list as a label")
-                elif isinstance(edge[2], list) and len(edge[2]) == 2:
-                    dg.set_edge_label( edge[0], edge[1], (edge[2][0], edge[2][1]))
-                    edge = (edge[0],edge[1],(edge[2][0],edge[2][1]))
-                elif ( edge[0] >= n or edge[1] >= n ) and not edge[2][0] == - edge[2][1]:
+                elif isinstance(lab, list) and len(lab) == 2:
+                    lab = tuple(lab)
+                    dg.set_edge_label(e0, e1, lab)
+                elif (e0 >= n or e1 >= n) and not lab[0] == -lab[1]:
                     raise ValueError("the input digraph contains an edge to or"
                                      " from a frozen vertex which is not skew-symmetric")
-                if edge[2][0] < 0:
-                    raise ValueError("the input digraph contains an edge of the"
-                                     " form (a,-b) with negative a")
+                if lab[0] < 0:
+                    raise ValueError("the input digraph contains an edge of "
+                                     "the form (a,-b) with negative a")
 
-            M = _edge_list_to_matrix( dg.edge_iterator(), list(range(n)),
-                                      list(range(n, n + m)) )
+            M = _edge_list_to_matrix(dg.edge_iterator(), list(range(n)),
+                                     list(range(n, n + m)))
             if not _principal_part(M).is_skew_symmetrizable(positive=True):
                 raise ValueError("the input digraph must be skew-symmetrizable")
 
@@ -465,7 +480,8 @@ class ClusterQuiver(SageObject):
 
         # if data is a list of edges, the appropriate digraph is constructed.
 
-        elif isinstance(data, (list, EdgesView)) and all(isinstance(x, (list,tuple)) for x in data):
+        elif (isinstance(data, (list, EdgesView))
+              and all(isinstance(x, (list, tuple)) for x in data)):
             dg = DiGraph(data)
             self.__init__(data=dg, frozen=frozen)
 
@@ -485,16 +501,16 @@ class ClusterQuiver(SageObject):
         EXAMPLES::
 
             sage: Q = ClusterQuiver(['A',5])
-            sage: T = Q.mutate( 2, inplace=False )
-            sage: Q.__eq__( T )
+            sage: T = Q.mutate(2, inplace=False)
+            sage: Q.__eq__(T)
             False
-            sage: T.mutate( 2 )
-            sage: Q.__eq__( T )
+            sage: T.mutate(2)
+            sage: Q.__eq__(T)
             True
         """
         return isinstance(other, ClusterQuiver) and self._M == other._M
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         """
         Return a hash of ``self``.
 
@@ -507,7 +523,7 @@ class ClusterQuiver(SageObject):
         """
         return hash(self._M)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return the description of ``self``.
 
@@ -572,7 +588,7 @@ class ClusterQuiver(SageObject):
             g2 = graphs.CycleGraph(m).get_pos()
             for i in g2:
                 z = CC(g2[i])*e**(-pi*I/(2*m))
-                g2[i] = (z.real_part(),z.imag_part())
+                g2[i] = (z.real_part(), z.imag_part())
             for i in range(m):
                 g1[n+i] = [2*g2[i][0], 2*g2[i][1]]
             return g1
@@ -582,28 +598,30 @@ class ClusterQuiver(SageObject):
         nlist = copy(self._nlist)
         mlist = copy(self._mlist)
         colors = rainbow(11)
-        color_dict = { colors[0]:[], colors[1]:[], colors[6]:[], colors[5]:[] }
+        color_dict = {colors[0]: [], colors[1]: [],
+                      colors[6]: [], colors[5]: []}
 
-        # Set up our graph. If it's directed we have a digraph, else just a normal graph
+        # Set up our graph. If it's directed we have a digraph, else
+        # just a normal graph
         if directed:
-            dg = DiGraph( self._digraph )
+            dg = self._digraph.copy(immutable=False)
         else:
-            dg = Graph( self._digraph )
+            dg = Graph(self._digraph)
 
         # For each edge in our graph we assign a color
-        for edge in dg.edges(sort=True):
-            v1,v2,(a,b) = edge
+        for v1, v2, ab in dg.edges(sort=True):
 
             if v1 in nlist and v2 in nlist:
-                if (a,b) == (1,-1):
-                    color_dict[ colors[0] ].append((v1,v2))
+                if ab == (1, -1):
+                    color_dict[colors[0]].append((v1, v2))
                 else:
-                    color_dict[ colors[6] ].append((v1,v2))
+                    color_dict[colors[6]].append((v1, v2))
             else:
-                if (a,b) == (1,-1):
-                    color_dict[ colors[1] ].append((v1,v2))
+                if ab == (1, -1):
+                    color_dict[colors[1]].append((v1, v2))
                 else:
-                    color_dict[ colors[5] ].append((v1,v2))
+                    color_dict[colors[5]].append((v1, v2))
+            a, b = ab
             if a == -b:
                 if a == 1:
                     dg.set_edge_label(v1, v2, '')
@@ -621,7 +639,7 @@ class ClusterQuiver(SageObject):
                 mlist.remove(mark)
                 partition = (nlist, mlist, [mark])
             else:
-                raise ValueError("The given mark is not a vertex of self.")
+                raise ValueError("the given mark is not a vertex of self")
         else:
 
             # Partition out the green vertices
@@ -644,7 +662,7 @@ class ClusterQuiver(SageObject):
             'vertex_labels': True,
         }
         if circular:
-            pp = _graphs_concentric_circles( n, m )
+            pp = _graphs_concentric_circles(n, m)
             options['pos'] = {}
             for v in pp:
                 # If we're using vertex dictionary set that as key
@@ -652,9 +670,10 @@ class ClusterQuiver(SageObject):
                     vkey = self._vertex_dictionary[v]
                 else:
                     vkey = v
-                options['pos'][vkey] = (pp[v][0] + center[0], pp[v][1] + center[1])
+                options['pos'][vkey] = (pp[v][0] + center[0],
+                                        pp[v][1] + center[1])
 
-        return dg.plot( **options )
+        return dg.plot(**options)
 
     def show(self, fig_size=1, circular=False, directed=True, mark=None, save_pos=False, greens=[]):
         """
@@ -681,11 +700,12 @@ class ClusterQuiver(SageObject):
             sage: Q.show() # long time
         """
         n, m = self._n, self._m
-        plot = self.plot( circular=circular, directed=directed, mark=mark, save_pos=save_pos, greens=greens)
+        plot = self.plot(circular=circular, directed=directed,
+                         mark=mark, save_pos=save_pos, greens=greens)
         if circular:
-            plot.show( figsize=[fig_size*3*(n+m)/4+1,fig_size*3*(n+m)/4+1] )
+            plot.show(figsize=[fig_size*3*(n+m)/4+1, fig_size*3*(n+m)/4+1])
         else:
-            plot.show( figsize=[fig_size*n+1,fig_size*n+1] )
+            plot.show(figsize=[fig_size*n+1, fig_size*n+1])
 
     def interact(self, fig_size=1, circular=True):
         r"""
@@ -764,7 +784,7 @@ class ClusterQuiver(SageObject):
         if self.m():
             from sage.matrix.constructor import matrix
             from sage.matrix.constructor import block_matrix
-            M1 = M.matrix_from_rows(list(range(self.n())))
+            M1 = M.matrix_from_rows(range(self.n()))
             M2 = M.matrix_from_rows(list(range(self.n(), self.n() + self.m())))
             M3 = matrix(self.m(), self.m())
             M = block_matrix([[M1, -M2.transpose()], [M2, M3]])
@@ -877,7 +897,7 @@ class ClusterQuiver(SageObject):
             sage: ClusterQuiver(['C', 4], user_labels = ['x', 'y', 'z', 'w']).digraph().edges(sort=True)
             [('x', 'y', (1, -1)), ('z', 'w', (2, -1)), ('z', 'y', (1, -1))]
         """
-        return copy(self._digraph)
+        return self._digraph.copy()
 
     def mutation_type(self):
         """
@@ -952,15 +972,15 @@ class ClusterQuiver(SageObject):
         examples from page 8 of [Ke2008]_::
 
             sage: dg = DiGraph(); dg.add_edges([(9,0),(9,4),(4,6),(6,7),(7,8),(8,3),(3,5),(5,6),(8,1),(2,3)])
-            sage: ClusterQuiver( dg ).mutation_type() # long time
+            sage: ClusterQuiver(dg).mutation_type() # long time
             ['E', 8, [1, 1]]
 
-            sage: dg = DiGraph( { 0:[3], 1:[0,4], 2:[0,6], 3:[1,2,7], 4:[3,8], 5:[2], 6:[3,5], 7:[4,6], 8:[7] } )
-            sage: ClusterQuiver( dg ).mutation_type() # long time
+            sage: dg = DiGraph({ 0:[3], 1:[0,4], 2:[0,6], 3:[1,2,7], 4:[3,8], 5:[2], 6:[3,5], 7:[4,6], 8:[7] })
+            sage: ClusterQuiver(dg).mutation_type() # long time
             ['E', 8, 1]
 
-            sage: dg = DiGraph( { 0:[3,9], 1:[0,4], 2:[0,6], 3:[1,2,7], 4:[3,8], 5:[2], 6:[3,5], 7:[4,6], 8:[7], 9:[1] } )
-            sage: ClusterQuiver( dg ).mutation_type() # long time
+            sage: dg = DiGraph({ 0:[3,9], 1:[0,4], 2:[0,6], 3:[1,2,7], 4:[3,8], 5:[2], 6:[3,5], 7:[4,6], 8:[7], 9:[1] })
+            sage: ClusterQuiver(dg).mutation_type() # long time
             ['E', 8, [1, 1]]
 
         infinite types::
@@ -1013,7 +1033,7 @@ class ClusterQuiver(SageObject):
             connected_components = sorted(dg.connected_components(sort=False))
             for component in connected_components:
                 # constructing the digraph for this component
-                dg_component = dg.subgraph( component )
+                dg_component = dg.subgraph(component)
                 dg_component.relabel()
                 # turning dg_component into a canonical form
                 _dg_canonical_form(dg_component)
@@ -1028,7 +1048,7 @@ class ClusterQuiver(SageObject):
                     mut_type_part = 'undetermined infinite mutation type'
                 else:
                     # checking if this quiver is in the database
-                    mut_type_part = _mutation_type_from_data( dg_component.order(), dig6, compute_if_necessary=False )
+                    mut_type_part = _mutation_type_from_data(dg_component.order(), dig6, compute_if_necessary=False)
                     # checking if the algorithm can determine the mutation type
                     if mut_type_part == 'unknown':
                         mut_type_part = _connected_mutation_type(dg_component)
@@ -1037,7 +1057,7 @@ class ClusterQuiver(SageObject):
                         mut_type_part = _mutation_type_from_data(dg_component.order(), dig6, compute_if_necessary=True)
                     if mut_type_part == 'unknown':
                         mut_type_part = 'undetermined finite mutation type'
-                mutation_type.append( mut_type_part )
+                mutation_type.append(mut_type_part)
 
             # the empty quiver case
             if len(mutation_type) == 0:
@@ -1046,12 +1066,9 @@ class ClusterQuiver(SageObject):
             elif len(mutation_type) == 1:
                 mutation_type = mutation_type[0]
             # the reducible quiver case
-            elif len(mutation_type) > 1:
-                if any(isinstance(mut_type_part, str)
-                       for mut_type_part in mutation_type):
-                    pass
-                else:
-                    mutation_type = QuiverMutationType(mutation_type)
+            elif not any(isinstance(mut_type_part, str)
+                         for mut_type_part in mutation_type):
+                mutation_type = QuiverMutationType(mutation_type)
             self._mutation_type = mutation_type
         return self._mutation_type
 
@@ -1090,7 +1107,7 @@ class ClusterQuiver(SageObject):
         """
         return self._m
 
-    def free_vertices(self):
+    def free_vertices(self) -> list:
         """
         Return the list of free vertices of ``self``.
 
@@ -1103,7 +1120,7 @@ class ClusterQuiver(SageObject):
         """
         return self._nlist
 
-    def frozen_vertices(self):
+    def frozen_vertices(self) -> list:
         """
         Return the list of frozen vertices of ``self``.
 
@@ -1151,7 +1168,7 @@ class ClusterQuiver(SageObject):
             (Quiver on 3 vertices of type [ ['A', 1], ['B', 2] ], {0: 1, 1: 2, 2: 0})
         """
         # computing the canonical form respecting the frozen variables
-        dg = copy(self._digraph)
+        dg = self._digraph.copy()
         iso, _ = _dg_canonical_form(dg, frozen=self._mlist)
         frozen = [iso[i] for i in self._mlist]
         Q = ClusterQuiver(dg, frozen=frozen)
@@ -1164,16 +1181,15 @@ class ClusterQuiver(SageObject):
                 CC_new = sorted(zip([sorted(iso[i] for i in L) for L in CC],
                                     range(len(CC))))
                 comp_iso = [L[1] for L in CC_new]
-                Q._mutation_type = []
-                for i in range( len( CC_new ) ):
-                    Q._mutation_type.append( copy( self._mutation_type.irreducible_components()[ comp_iso[i] ] ) )
-                Q._mutation_type = QuiverMutationType( Q._mutation_type )
+                Q._mutation_type = [copy(self._mutation_type.irreducible_components()[comp_i])
+                                    for comp_i in comp_iso]
+                Q._mutation_type = QuiverMutationType(Q._mutation_type)
         if certificate:
             return Q, iso
         else:
             return Q
 
-    def is_acyclic(self):
+    def is_acyclic(self) -> bool:
         """
         Return true if ``self`` is acyclic.
 
@@ -1202,8 +1218,8 @@ class ClusterQuiver(SageObject):
             sage: ClusterQuiver(['A',[4,3],1]).is_bipartite()
             False
         """
-        dg = copy(self._digraph)
-        dg.delete_vertices(list(range(self._n, self._n + self._m)))
+        dg = self._digraph.copy(immutable=False)
+        dg.delete_vertices(range(self._n, self._n + self._m))
         if any(dg.in_degree(i) and dg.out_degree(i) for i in dg):
             return False
         if not return_bipartition:
@@ -1229,15 +1245,19 @@ class ClusterQuiver(SageObject):
             sage: Q2.exchangeable_part() == Q3.exchangeable_part()
             True
         """
-        dg = DiGraph( self._digraph )
-        dg.delete_vertices(list(range(self._n, self._n + self._m)))
-        Q = ClusterQuiver( dg )
+        dg = self._digraph.copy(immutable=False)
+        dg.delete_vertices(range(self._n, self._n + self._m))
+        Q = ClusterQuiver(dg)
         Q._mutation_type = self._mutation_type
         return Q
 
     def principal_extension(self, inplace=False):
         """
-        Return the principal extension of ``self``, adding n frozen vertices to any previously frozen vertices. I.e., the quiver obtained by adding an outgoing edge to every mutable vertex of ``self``.
+        Return the principal extension of ``self``, adding n frozen vertices
+        to any previously frozen vertices.
+
+        This is the quiver obtained by adding an outgoing edge to
+        every mutable vertex of ``self``.
 
         EXAMPLES::
 
@@ -1252,11 +1272,13 @@ class ClusterQuiver(SageObject):
             sage: T.digraph().edges(sort=True)
             [(0, 1, (1, -1)), (2, 0, (1, -1)), (3, 1, (1, -1))]
             sage: T2.digraph().edges(sort=True)
-            [(0, 1, (1, -1)), (2, 0, (1, -1)), (3, 1, (1, -1)), (4, 0, (1, -1)), (5, 1, (1, -1))]
+            [(0, 1, (1, -1)), (2, 0, (1, -1)), (3, 1, (1, -1)),
+             (4, 0, (1, -1)), (5, 1, (1, -1))]
         """
-        dg = DiGraph(self._digraph)
-        dg.add_edges( [(self._n+self._m+i,i) for i in range(self._n)] )
-        Q = ClusterQuiver( dg, frozen=list(range(self._n, self._n+self._m+self._n)) )
+        dg = self._digraph.copy(immutable=False)
+        dg.add_edges([(self._n + self._m + i, i) for i in range(self._n)])
+        Q = ClusterQuiver(dg, frozen=list(range(self._n,
+                                                2 * self._n + self._m)))
         Q._mutation_type = self._mutation_type
         if inplace:
             self.__init__(Q)
@@ -1280,7 +1302,7 @@ class ClusterQuiver(SageObject):
             return sinks[0]
         return None
 
-    def sinks(self):
+    def sinks(self) -> list:
         r"""
         Return all vertices of ``self`` that are sinks.
 
@@ -1315,7 +1337,7 @@ class ClusterQuiver(SageObject):
             return sources[0]
         return None
 
-    def sources(self):
+    def sources(self) -> list:
         r"""
         Return all vertices of ``self`` that are sources.
 
@@ -1335,15 +1357,15 @@ class ClusterQuiver(SageObject):
 
     def mutate(self, data, inplace=True):
         """
-        Mutates ``self`` at a sequence of vertices.
+        Mutate ``self`` at a sequence of vertices.
 
         INPUT:
 
         - ``sequence`` -- a vertex of ``self``, an iterator of vertices of
           ``self``, a function which takes in the ClusterQuiver and returns a
           vertex or an iterator of vertices, or a string of the parameter
-          wanting to be called on ClusterQuiver that will return a vertex or
-          an iterator of vertices
+          wanting to be called on ``ClusterQuiver`` that will return a vertex
+          or an iterator of vertices
         - ``inplace`` -- boolean (default: ``True``); if ``False``, the result
           is returned, otherwise ``self`` is modified
 
@@ -1455,7 +1477,7 @@ class ClusterQuiver(SageObject):
         else:
             seq = data
         if isinstance(seq, tuple):
-            seq = list( seq )
+            seq = list(seq)
         if not isinstance(seq, list):
             raise ValueError('The quiver can only be mutated at a vertex or at a sequence of vertices')
         if not isinstance(inplace, bool):
@@ -1476,7 +1498,7 @@ class ClusterQuiver(SageObject):
             Q._mutation_type = self._mutation_type
             return Q
 
-    def mutation_sequence(self, sequence, show_sequence=False, fig_size=1.2 ):
+    def mutation_sequence(self, sequence, show_sequence=False, fig_size=1.2):
         """
         Return a list containing the sequence of quivers obtained from ``self``
         by a sequence of mutations on vertices.
@@ -1512,44 +1534,46 @@ class ClusterQuiver(SageObject):
         else:
             width_factor = 6
             fig_size = fig_size*4*n/3
-        V = list(range(n))
+        V = range(n)
 
         if isinstance(sequence, tuple):
-            sequence = list( sequence )
+            sequence = list(sequence)
         if not isinstance(sequence, list):
-            raise ValueError('The quiver can only be mutated at a vertex or at a sequence of vertices')
+            raise ValueError('the quiver can only be mutated at a vertex'
+                             ' or at a sequence of vertices')
         if any(v not in V for v in sequence):
             v = next(v for v in sequence if v not in V)
-            raise ValueError('The quiver can only be mutated at the vertex %s' % v )
+            raise ValueError(f'the quiver can only be mutated at the vertex {v}')
 
-        quiver = copy( self )
+        quiver = copy(self)
         quiver_sequence = []
-        quiver_sequence.append( copy( quiver ) )
+        quiver_sequence.append(copy(quiver))
 
         for v in sequence:
-            quiver.mutate( v )
-            quiver_sequence.append( copy( quiver ) )
+            quiver.mutate(v)
+            quiver_sequence.append(copy(quiver))
 
         if show_sequence:
             from sage.plot.plot import Graphics
             from sage.plot.text import text
 
-            def _plot_arrow( v, k, center=(0, 0) ):
-                return text(r"$\longleftrightarrow$",(center[0],center[1]), fontsize=25) + text(r"$\mu_"+str(v)+"$",(center[0],center[1]+0.15), fontsize=15) \
-                    + text("$"+str(k)+"$",(center[0],center[1]-0.2), fontsize=15)
+            def _plot_arrow(v, k, center=(0, 0)):
+                return text(r"$\longleftrightarrow$", (center[0], center[1]), fontsize=25) + text(r"$\mu_"+str(v)+"$", (center[0], center[1]+0.15), fontsize=15) \
+                    + text("$"+str(k)+"$", (center[0], center[1]-0.2), fontsize=15)
 
-            plot_sequence = [ quiver_sequence[i].plot( circular=True, center=(i*width_factor,0) ) for i in range(len(quiver_sequence)) ]
-            arrow_sequence = [ _plot_arrow( sequence[i],i+1,center=((i+0.5)*width_factor,0) ) for i in range(len(sequence)) ]
+            plot_sequence = [quiver_sequence[i].plot(circular=True, center=(i*width_factor, 0)) for i in range(len(quiver_sequence))]
+            arrow_sequence = [_plot_arrow(sequence[i], i+1, center=((i+0.5)*width_factor, 0)) for i in range(len(sequence))]
             sequence = []
-            for i in range( len( plot_sequence ) ):
-                if i < len( arrow_sequence ):
-                    sequence.append( plot_sequence[i] + arrow_sequence[i] )
+            for i in range(len(plot_sequence)):
+                if i < len(arrow_sequence):
+                    sequence.append(plot_sequence[i] + arrow_sequence[i])
                 else:
-                    sequence.append( plot_sequence[i] )
+                    sequence.append(plot_sequence[i])
             plot_obj = Graphics()
             for elem in sequence:
                 plot_obj += elem
-            plot_obj.show(axes=False, figsize=[fig_size*len(quiver_sequence),fig_size])
+            plot_obj.show(axes=False, figsize=[fig_size*len(quiver_sequence),
+                                               fig_size])
         return quiver_sequence
 
     def reorient(self, data):
@@ -1623,13 +1647,15 @@ class ClusterQuiver(SageObject):
             self._M.set_immutable()
             self._mutation_type = None
         else:
-            raise ValueError('not a total order on the vertices of the quiver or a list of edges to be oriented')
+            raise ValueError('not a total order on the vertices of the quiver'
+                             ' or a list of edges to be oriented')
 
     def mutation_class_iter(self, depth=infinity, show_depth=False,
                             return_paths=False, data_type='quiver',
                             up_to_equivalence=True, sink_source=False):
         """
-        Return an iterator for the mutation class of ``self`` together with certain constraints.
+        Return an iterator for the mutation class of ``self``
+        together with certain constraints.
 
         INPUT:
 
@@ -1699,7 +1725,8 @@ class ClusterQuiver(SageObject):
             Quiver on 3 vertices of type ['A', 3]
             Quiver on 3 vertices of type ['A', 3]
 
-            sage: it = Q.mutation_class_iter(return_paths=True,up_to_equivalence=False)
+            sage: it = Q.mutation_class_iter(return_paths=True,
+            ....:        up_to_equivalence=False)
             sage: mutation_class = list(it)
             sage: len(mutation_class)
             14
@@ -1715,7 +1742,8 @@ class ClusterQuiver(SageObject):
             [0, 1]
 
             sage: Q = ClusterQuiver(['A',3])
-            sage: it = Q.mutation_class_iter(return_paths=True,data_type='matrix')
+            sage: it = Q.mutation_class_iter(return_paths=True,
+            ....:        data_type='matrix')
             sage: next(it)
             (
             [ 0  0  1]
@@ -1723,7 +1751,8 @@ class ClusterQuiver(SageObject):
             [-1 -1  0], []
             )
 
-            sage: dg = DiGraph([['a', 'b'], ['b', 'c']], format='list_of_edges')
+            sage: dg = DiGraph([['a', 'b'], ['b', 'c']],
+            ....:        format='list_of_edges')
             sage: S = ClusterQuiver(dg, frozen=['b'])
             sage: S.mutation_class()
             [Quiver on 3 vertices with 1 frozen vertex,
@@ -1778,8 +1807,8 @@ class ClusterQuiver(SageObject):
         - ``show_depth`` -- boolean (default: ``False``); if ``True``, the
           actual depth of the mutation is shown
         - ``return_paths`` -- boolean (default: ``False``); if ``True``, a
-          shortest path of mutation sequences from ``self`` to the given quiver is
-          returned as well
+          shortest path of mutation sequences from ``self`` to the given
+          quiver is returned as well
         - ``data_type`` -- (default: ``'quiver'``) can be one of
           the following:
 
@@ -1875,7 +1904,7 @@ class ClusterQuiver(SageObject):
                                              up_to_equivalence=up_to_equivalence,
                                              sink_source=sink_source))
 
-    def is_finite(self):
+    def is_finite(self) -> bool:
         """
         Return ``True`` if ``self`` is of finite type.
 
@@ -1918,10 +1947,12 @@ class ClusterQuiver(SageObject):
         return (type(mt) in [QuiverMutationType_Irreducible,
                              QuiverMutationType_Reducible] and mt.is_finite())
 
-    def is_mutation_finite( self, nr_of_checks=None, return_path=False ):
+    def is_mutation_finite(self, nr_of_checks=None, return_path=False) -> bool:
         """
-        Uses a non-deterministic method by random mutations in various
-        directions. Can result in a wrong answer.
+        Return whether ``self`` is mutation-finite.
+
+        This uses a non-deterministic method by random mutations in various
+        directions. This can result in a wrong answer.
 
         INPUT:
 
@@ -1933,7 +1964,8 @@ class ClusterQuiver(SageObject):
 
         ALGORITHM:
 
-        A quiver is mutation infinite if and only if every edge label (a,-b) satisfy a*b > 4.
+        A quiver is mutation infinite if and only if every
+        edge label (a,-b) satisfy a*b > 4.
         Thus, we apply random mutations in random directions
 
         EXAMPLES::
@@ -1943,7 +1975,8 @@ class ClusterQuiver(SageObject):
             sage: Q.is_mutation_finite()
             True
 
-            sage: Q = ClusterQuiver([(0,1),(1,2),(2,3),(3,4),(4,5),(5,6),(6,7),(7,8),(2,9)])
+            sage: Q = ClusterQuiver([(0,1),(1,2),(2,3),(3,4),
+            ....:                    (4,5),(5,6),(6,7),(7,8),(2,9)])
             sage: Q.is_mutation_finite()
             False
         """
@@ -1969,17 +2002,17 @@ class ClusterQuiver(SageObject):
             M = _dig6_to_matrix(dig6)
 
             is_finite, path = is_mutation_finite(M, nr_of_checks=nr_of_checks)
-        if return_path:
-            return is_finite, path
-        else:
-            return is_finite
+        return (is_finite, path) if return_path else is_finite
 
     def number_of_edges(self):
         r"""
         Return the total number of edges on the quiver.
 
-        Note: This only works with non-valued quivers. If used on a
-        non-valued quiver then the positive value is taken to be the number of edges added
+        .. NOTE::
+
+            This only works with non-valued quivers. If used on a
+            non-valued quiver then the positive value is taken to be
+            the number of edges added.
 
         OUTPUT: integer of the number of edges
 
@@ -1991,13 +2024,7 @@ class ClusterQuiver(SageObject):
             sage: S = ClusterQuiver(['B',4]); S.number_of_edges()
             3
         """
-        digraph_edges = self.digraph().edges(sort=True)
-
-        total_edges = 0
-        for edge in digraph_edges:
-            total_edges += edge[2][0]
-
-        return total_edges
+        return sum(label[0] for label in self.digraph().edge_labels())
 
     def relabel(self, relabelling, inplace=True):
         r"""
@@ -2026,11 +2053,11 @@ class ClusterQuiver(SageObject):
         dict_labels = {}
 
         # Organize labels noting that for:
-        #    _digraph: { old_vertex: new_vertex}
+        #    _digraph: {old_vertex: new_vertex}
         #    _vertex_dictionary: {num: new_vertex}
         if isinstance(relabelling, list):
-            digraph_labels = {old_vertices[i]: relabelling[i] for i in range(len(relabelling))}
-            dict_labels = {range(len(relabelling))[i]: relabelling[i] for i in range(len(relabelling))}
+            digraph_labels = dict(zip(old_vertices, relabelling))
+            dict_labels = dict(enumerate(relabelling))
         elif isinstance(relabelling, dict):
             # need to make sure we map correctly
             for key in relabelling:
@@ -2198,11 +2225,12 @@ class ClusterQuiver(SageObject):
             ...
             ValueError: only makes sense for quivers of finite type
         """
+        from sage.geometry.fan import Fan
+
         if not self.is_finite():
             raise ValueError('only makes sense for quivers of finite type')
 
         from .cluster_seed import ClusterSeed
-        from sage.geometry.fan import Fan
         from sage.geometry.cone import Cone
 
         seed = ClusterSeed(self)
@@ -2252,8 +2280,8 @@ class ClusterQuiver(SageObject):
             ValueError: only supported for quivers of finite type
         """
         from .cluster_seed import ClusterSeed
-        from sage.geometry.fan import Fan
         from sage.geometry.cone import Cone
+        from sage.geometry.fan import Fan
 
         if not (self.is_finite()):
             raise ValueError('only supported for quivers of finite type')