passagemath-graphs 10.6.1rc1__cp310-cp310-musllinux_1_2_aarch64.whl

sage/combinat/cluster_algebra_quiver/quiver.py

@@ -0,0 +1,2290 @@
+# sage_setup: distribution = sagemath-graphs
+# sage.doctest: needs sage.graphs sage.modules
+r"""
+Quiver
+
+A *quiver* is an oriented graph without loops, two-cycles, or multiple
+edges. The edges are labelled by pairs `(i,-j)` (with `i` and `j` being
+positive integers) such that the matrix `M = (m_{ab})` with
+`m_{ab} = i, m_{ba} = -j` for an edge `(i,-j)` between vertices
+`a` and `b` is skew-symmetrizable.
+
+.. WARNING::
+
+    This is not the standard definition of a quiver. Normally, in
+    cluster algebra theory, a quiver is defined as an oriented graph
+    without loops and two-cycles but with multiple edges allowed; the
+    edges are unlabelled. This notion of quivers, however, can be seen
+    as a particular case of our notion of quivers. Namely, if we have
+    a quiver (in the regular sense of this word) with (precisely)
+    `i` edges from `a` to `b`, then we represent it by a quiver
+    (in our sense of this word) with an edge from `a` to `b` labelled
+    by the pair `(i,-i)`.
+
+For the compendium on the cluster algebra and quiver package see [MS2011]_
+
+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`.
+"""
+# ****************************************************************************
+#       Copyright (C) 2011 Gregg Musiker <musiker@math.mit.edu>
+#                          Christian Stump <christian.stump@univie.ac.at>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+from copy import copy
+from itertools import product
+
+from sage.arith.misc import gcd
+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')
+
+
+class ClusterQuiver(SageObject):
+    """
+    The *quiver* associated to an *exchange matrix*.
+
+    INPUT:
+
+    - ``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
+
+    - ``frozen`` -- (default: ``None``) sets the list of frozen variables
+      if the input type is a :class:`DiGraph`, it is ignored otherwise
+
+    - ``user_labels`` -- (default: ``None``) sets the names of the labels for
+      the vertices of the quiver if the input type is not a :class:`DiGraph`;
+      otherwise it is ignored
+
+    EXAMPLES:
+
+    From a :class:`QuiverMutationType`::
+
+        sage: Q = ClusterQuiver(['A',5]); Q
+        Quiver on 5 vertices of type ['A', 5]
+
+        sage: Q = ClusterQuiver(['B',2]); Q
+        Quiver on 2 vertices of type ['B', 2]
+        sage: Q2 = ClusterQuiver(['C',2]); Q2
+        Quiver on 2 vertices of type ['B', 2]
+        sage: MT = Q.mutation_type(); MT.standard_quiver() == Q
+        True
+        sage: MT = Q2.mutation_type(); MT.standard_quiver() == Q2
+        False
+
+        sage: Q = ClusterQuiver(['A',[2,5],1]); Q
+        Quiver on 7 vertices of type ['A', [2, 5], 1]
+
+        sage: Q = ClusterQuiver(['A', [5,0],1]); Q
+        Quiver on 5 vertices of type ['D', 5]
+        sage: Q.is_finite()
+        True
+        sage: Q.is_acyclic()
+        False
+
+        sage: Q = ClusterQuiver(['F', 4, [2,1]]); Q
+        Quiver on 6 vertices of type ['F', 4, [1, 2]]
+        sage: MT = Q.mutation_type(); MT.standard_quiver() == Q
+        False
+        sage: dg = Q.digraph(); Q.mutate([2,1,4,0,5,3])
+        sage: dg2 = Q.digraph(); dg2.is_isomorphic(dg,edge_labels=True)
+        False
+        sage: dg2.is_isomorphic(MT.standard_quiver().digraph(),edge_labels=True)
+        True
+
+        sage: Q = ClusterQuiver(['G',2, (3,1)]); Q
+        Quiver on 4 vertices of type ['G', 2, [1, 3]]
+        sage: MT = Q.mutation_type(); MT.standard_quiver() == Q
+        False
+
+        sage: Q = ClusterQuiver(['GR',[3,6]]); Q
+        Quiver on 4 vertices of type ['D', 4]
+        sage: MT = Q.mutation_type(); MT.standard_quiver() == Q
+        False
+
+        sage: Q = ClusterQuiver(['GR',[3,7]]); Q
+        Quiver on 6 vertices of type ['E', 6]
+
+        sage: Q = ClusterQuiver(['TR',2]); Q
+        Quiver on 3 vertices of type ['A', 3]
+        sage: MT = Q.mutation_type(); MT.standard_quiver() == Q
+        False
+        sage: Q.mutate([1,0]); MT.standard_quiver() == Q
+        True
+
+        sage: Q = ClusterQuiver(['TR',3]); Q
+        Quiver on 6 vertices of type ['D', 6]
+        sage: MT = Q.mutation_type(); MT.standard_quiver() == Q
+        False
+
+    From a :class:`ClusterQuiver`::
+
+        sage: Q = ClusterQuiver(['A',[2,5],1]); Q
+        Quiver on 7 vertices of type ['A', [2, 5], 1]
+        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
+        Quiver on 7 vertices
+
+        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
+        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
+        Quiver on 7 vertices
+
+        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']]),
+        ....:          frozen=['c']); Q
+        Quiver on 5 vertices with 1 frozen vertex
+        sage: Q.mutation_type()
+        [ ['A', 2], ['A', 2] ]
+        sage: Q
+        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
+        Quiver on 7 vertices
+
+        sage: Q = ClusterQuiver([[1, 2], [2, 3], [3, 4], [4, 1]]); Q
+        Quiver on 4 vertices
+
+    TESTS::
+
+        sage: Q = ClusterQuiver(DiGraph([[1,1]]))
+        Traceback (most recent call last):
+        ...
+        ValueError: cannot add edge from 1 to 1 in graph without loops
+
+        sage: Q = ClusterQuiver([[1,1]])
+        Traceback (most recent call last):
+        ...
+        ValueError: cannot add edge from 1 to 1 in graph without loops
+
+        sage: Q = ClusterQuiver(DiGraph([[1, 0],[0,1]]))
+        Traceback (most recent call last):
+        ...
+        ValueError: the input DiGraph contains two-cycles
+
+        sage: Q = ClusterQuiver('whatever')
+        Traceback (most recent call last):
+        ...
+        ValueError: the input data was not recognized
+    """
+
+    def __init__(self, data, frozen=None, user_labels=None) -> None:
+        """
+        TESTS::
+
+            sage: Q = ClusterQuiver(['A',4])
+            sage: TestSuite(Q).run()
+        """
+        from sage.combinat.cluster_algebra_quiver.cluster_seed import ClusterSeed
+        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]
+        elif isinstance(user_labels, dict):
+            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,
+                             QuiverMutationType_Reducible)):
+            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.')
+
+            mutation_type = data
+            self.__init__(mutation_type.standard_quiver())
+            if user_labels:
+                self.relabel(user_labels)
+                self._nlist = list(user_labels)
+
+        # constructs a quiver from string representing a mutation type
+        #   or a common quiver type (see Examples)
+        # 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))):
+            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.')
+            mutation_type = QuiverMutationType(data)
+
+            # The command QuiverMutationType_Irreducible (which is not imported
+            #   globally) already creates the desired digraph as long as we
+            #   bypass the mutation type checking of QuiverMutationType and
+            #   format the input appropriately.  Thus we handle several
+            #   special cases this way.
+            if len(data) == 2 and isinstance(data[0], str):
+                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(d1, list):
+                        quiv = ClusterQuiver(QuiverMutationType_Irreducible(d0, tuple(d1))._digraph)
+                        quiv._mutation_type = mutation_type
+                        self.__init__(quiv)
+                else:
+                    self.__init__(mutation_type.standard_quiver())
+            elif len(data) == 3 and isinstance(data[0], str):
+                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 ((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 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)
+                    else:
+                        self.__init__(mutation_type.standard_quiver())
+
+                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)
+                    else:
+                        self.__init__(mutation_type.standard_quiver())
+
+                else:
+                    self.__init__(mutation_type.standard_quiver())
+            else:
+                self.__init__(mutation_type.standard_quiver())
+
+            if user_labels:
+                if isinstance(user_labels, dict):
+                    self._nlist = list(user_labels)
+                else:
+                    self._nlist = user_labels
+
+                self.relabel(self._nlist)
+
+        # constructs a quiver from a cluster seed
+        elif isinstance(data, ClusterSeed):
+            self.__init__(data.quiver())
+
+        # constructs a quiver from a quiver
+        elif isinstance(data, ClusterQuiver):
+            if frozen is not None:
+                print('The input data is a quiver, therefore the additional'
+                      ' parameter frozen is ignored. Use set_frozen to freeze vertices.')
+
+            self._M = copy(data._M)
+            self._M.set_immutable()
+            self._n = data._n
+            self._m = data._m
+            self._mlist = list(data._mlist)
+            self._nlist = list(data._nlist)
+            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):
+                raise ValueError('The principal part of the matrix data must be skew-symmetrizable.')
+
+            if frozen is not None:
+                print('The input data is a matrix, therefore the additional parameter frozen is ignored. Frozen vertices read off accordingly if the matrix is not square.')
+
+            self._M = copy(data).sparse_matrix()
+            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._vertex_dictionary = {}
+            self._mutation_type = None
+
+            if user_labels:
+                if isinstance(user_labels, dict):
+                    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._nlist = list(range(n))
+            if n+m == 0:
+                self._description = 'Quiver without vertices'
+            elif n+m == 1:
+                self._description = 'Quiver on 1 vertex'
+            else:
+                self._description = 'Quiver on %d vertices' % (n+m)
+
+        # constructs a quiver from a digraph
+        elif isinstance(data, DiGraph):
+            if frozen is None:
+                frozen = []
+            if not isinstance(frozen, (list, tuple)):
+                raise ValueError("'frozen' must be a list of vertices")
+            frozen = set(frozen)
+            if not frozen.issubset(data.vertex_iterator()):
+                raise ValueError("frozen elements must be vertices")
+
+            mlist = self._mlist = list(frozen)
+            m = self._m = len(mlist)
+
+            try:
+                nlist = sorted(x for x in data if x not in frozen)
+            except TypeError:
+                nlist = sorted([x for x in data if x not in frozen], key=str)
+            self._nlist = nlist
+            n = self._n = len(nlist)
+            labelDict = {x: i for i, x in enumerate(nlist + mlist)}
+
+            dg = copy(data)
+            if data.has_loops():
+                raise ValueError("the input DiGraph contains a loop")
+
+            edges = set(data.edge_iterator(labels=False))
+            if any((b, a) in edges for (a, b) in edges):
+                raise ValueError("the input DiGraph contains two-cycles")
+
+            dg_labelling = False
+            if not set(dg.vertex_iterator()) == set(range(n + m)):
+                # relabelling to integers
+                # frozen vertices must be preserved
+                dg_labelling = nlist + mlist
+                dg.relabel(labelDict)
+
+            multiple_edges = dg.multiple_edges()
+            if multiple_edges:
+                multi_edges = {}
+                for v1, v2, label in multiple_edges:
+                    if label not in ZZ:
+                        raise ValueError("the input DiGraph contains multiple"
+                                         " edges labeled by non-integers")
+                    elif (v1, v2) in multi_edges:
+                        multi_edges[(v1, v2)] += label
+                    else:
+                        multi_edges[(v1, v2)] = label
+                    dg.delete_edge(v1, v2)
+                dg.add_edges([(v1, v2, multi_edges[(v1, v2)])
+                              for v1, v2 in multi_edges])
+
+            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 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(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 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)))
+            if not _principal_part(M).is_skew_symmetrizable(positive=True):
+                raise ValueError("the input digraph must be skew-symmetrizable")
+
+            self._digraph = dg
+            self._vertex_dictionary = {}
+            if dg_labelling is not False:
+                self.relabel(dg_labelling)  # relabelling back
+
+            self._M = M
+            self._M.set_immutable()
+            if n + m == 0:
+                self._description = 'Quiver without vertices'
+            elif n + m == 1:
+                self._description = 'Quiver on %d vertex' % (n+m)
+            else:
+                self._description = 'Quiver on %d vertices' % (n+m)
+            self._mutation_type = None
+
+        # 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)):
+            dg = DiGraph(data)
+            self.__init__(data=dg, frozen=frozen)
+
+        # otherwise, an error is raised
+        else:
+            raise ValueError("the input data was not recognized")
+
+        # stopgap for bugs arising from coefficients
+        if self._m:
+            from sage.misc.stopgap import stopgap
+            stopgap("Having frozen nodes is known to produce wrong answers", 22381)
+
+    def __eq__(self, other):
+        """
+        Return ``True`` if ``self`` and ``other`` represent the same quiver.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',5])
+            sage: T = Q.mutate(2, inplace=False)
+            sage: Q.__eq__(T)
+            False
+            sage: T.mutate(2)
+            sage: Q.__eq__(T)
+            True
+        """
+        return isinstance(other, ClusterQuiver) and self._M == other._M
+
+    def __hash__(self) -> int:
+        """
+        Return a hash of ``self``.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',5])
+            sage: hash(Q)  # indirect doctest
+            7654921743699262111  # 64-bit
+            -1264862561          # 32-bit
+        """
+        return hash(self._M)
+
+    def _repr_(self) -> str:
+        """
+        Return the description of ``self``.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',5])
+            sage: Q._repr_()
+            "Quiver on 5 vertices of type ['A', 5]"
+        """
+        name = self._description
+        if self._mutation_type:
+            if isinstance(self._mutation_type, str):
+                name += ' of ' + self._mutation_type
+            else:
+                name += ' of type ' + str(self._mutation_type)
+        if self._m == 1:
+            name += ' with %s frozen vertex' % self._m
+        elif self._m > 1:
+            name += ' with %s frozen vertices' % self._m
+        return name
+
+    def plot(self, circular=True, center=(0, 0), directed=True, mark=None,
+             save_pos=False, greens=[]):
+        """
+        Return the plot of the underlying digraph of ``self``.
+
+        INPUT:
+
+        - ``circular`` -- boolean (default: ``True``); if ``True``, the
+          circular plot is chosen, otherwise >>spring<< is used
+        - ``center`` -- (default: (0,0)) sets the center of the circular plot,
+          otherwise it is ignored
+        - ``directed`` -- boolean (default: ``True``); if ``True``, the
+          directed version is shown, otherwise the undirected
+        - ``mark`` -- (default: ``None``) if set to i, the vertex i is
+          highlighted
+        - ``save_pos`` -- boolean (default: ``False``); if ``True``, the
+          positions of the vertices are saved
+        - ``greens`` -- (default: ``[]``) if set to a list, will display the green
+          vertices as green
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',5])
+            sage: Q.plot()                                                              # needs sage.plot sage.symbolic
+            Graphics object consisting of 15 graphics primitives
+            sage: Q.plot(circular=True)                                                 # needs sage.plot sage.symbolic
+            Graphics object consisting of 15 graphics primitives
+            sage: Q.plot(circular=True, mark=1)                                         # needs sage.plot sage.symbolic
+            Graphics object consisting of 15 graphics primitives
+        """
+        from sage.plot.colors import rainbow
+        from sage.graphs.graph_generators import GraphGenerators
+        from sage.symbolic.constants import e, pi
+        from sage.rings.cc import CC
+        from sage.rings.imaginary_unit import I
+        graphs = GraphGenerators()
+        # returns positions for graph vertices on two concentric cycles with radius 1 and 2
+
+        def _graphs_concentric_circles(n, m):
+            g1 = graphs.CycleGraph(n).get_pos()
+            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())
+            for i in range(m):
+                g1[n+i] = [2*g2[i][0], 2*g2[i][1]]
+            return g1
+
+        n, m = self._n, self._m
+        # So that we don't remove elements of these lists later
+        nlist = copy(self._nlist)
+        mlist = copy(self._mlist)
+        colors = rainbow(11)
+        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
+        if directed:
+            dg = self._digraph.copy(immutable=False)
+        else:
+            dg = Graph(self._digraph)
+
+        # For each edge in our graph we assign a color
+        for v1, v2, ab in dg.edges(sort=True):
+
+            if v1 in nlist and v2 in nlist:
+                if ab == (1, -1):
+                    color_dict[colors[0]].append((v1, v2))
+                else:
+                    color_dict[colors[6]].append((v1, v2))
+            else:
+                if ab == (1, -1):
+                    color_dict[colors[1]].append((v1, v2))
+                else:
+                    color_dict[colors[5]].append((v1, v2))
+            a, b = ab
+            if a == -b:
+                if a == 1:
+                    dg.set_edge_label(v1, v2, '')
+                else:
+                    dg.set_edge_label(v1, v2, a)
+
+        # If a mark is given, then we set that mark apart from the rest
+        # The mark is assumed to be a vertex
+        if mark is not None:
+
+            if mark in nlist:
+                nlist.remove(mark)
+                partition = (nlist, mlist, [mark])
+            elif mark in mlist:
+                mlist.remove(mark)
+                partition = (nlist, mlist, [mark])
+            else:
+                raise ValueError("the given mark is not a vertex of self")
+        else:
+
+            # Partition out the green vertices
+            for i in greens:
+                if i in nlist:
+                    nlist.remove(i)
+                else:
+                    mlist.remove(i)
+            partition = (nlist, mlist, greens)
+
+        vertex_color_dict = {'tomato': partition[0],
+                             'lightblue': partition[1],
+                             'lightgreen': partition[2]}
+
+        options = {
+            'graph_border': True,
+            'edge_colors': color_dict,
+            'vertex_colors': vertex_color_dict,
+            'edge_labels': True,
+            'vertex_labels': True,
+        }
+        if circular:
+            pp = _graphs_concentric_circles(n, m)
+            options['pos'] = {}
+            for v in pp:
+                # If we're using vertex dictionary set that as key
+                if v in self._vertex_dictionary:
+                    vkey = self._vertex_dictionary[v]
+                else:
+                    vkey = v
+                options['pos'][vkey] = (pp[v][0] + center[0],
+                                        pp[v][1] + center[1])
+
+        return dg.plot(**options)
+
+    def show(self, fig_size=1, circular=False, directed=True, mark=None, save_pos=False, greens=[]):
+        """
+        Show the plot of the underlying digraph of ``self``.
+
+        INPUT:
+
+        - ``fig_size`` -- (default: 1) factor by which the size of the plot
+          is multiplied
+        - ``circular`` -- boolean (default: ``False``); if ``True``, the
+          circular plot is chosen, otherwise >>spring<< is used
+        - ``directed`` -- boolean (default: ``True``); if ``True``, the directed
+          version is shown, otherwise the undirected
+        - ``mark`` -- boolean (default: ``None``); if set to i, the vertex i is
+          highlighted
+        - ``save_pos`` -- boolean (default: ``False``); if ``True``, the
+          positions of the vertices are saved
+        - ``greens`` -- (default: ``[]``) if set to a list, will display the
+          green vertices as green
+
+        TESTS::
+
+            sage: Q = ClusterQuiver(['A',5])
+            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)
+        if circular:
+            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])
+
+    def interact(self, fig_size=1, circular=True):
+        r"""
+        Start an interactive window for cluster quiver mutations.
+
+        Only in *Jupyter notebook mode*.
+
+        INPUT:
+
+        - ``fig_size`` -- (default: 1) factor by which the size of the
+          plot is multiplied
+
+        - ``circular`` -- boolean (default: ``True``); if ``True``, the
+          circular plot is chosen, otherwise >>spring<< is used
+
+        TESTS::
+
+            sage: S = ClusterQuiver(['A',4])
+            sage: S.interact()                                                          # needs sage.plot sage.symbolic
+            ...VBox(children=...
+        """
+        return cluster_interact(self, fig_size, circular, kind='quiver')
+
+    def save_image(self, filename, circular=False):
+        """
+        Save the plot of the underlying digraph of ``self``.
+
+        INPUT:
+
+        - ``filename`` -- the filename the image is saved to
+        - ``circular`` -- boolean (default: ``False``); if ``True``, the
+          circular plot is chosen, otherwise >>spring<< is used
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['F',4,[1,2]])
+            sage: import tempfile
+            sage: with tempfile.NamedTemporaryFile(suffix='.png') as f:                 # needs sage.plot sage.symbolic
+            ....:     Q.save_image(f.name)
+        """
+        graph_plot = self.plot(circular=circular)
+        graph_plot.save(filename=filename)
+
+    def qmu_save(self, filename=None):
+        """
+        Save ``self`` in a ``.qmu`` file.
+
+        This file can then be opened in Bernhard Keller's Quiver Applet.
+
+        See https://webusers.imj-prg.fr/~bernhard.keller/quivermutation/
+
+        INPUT:
+
+        - ``filename`` -- the filename the image is saved to
+
+        If a filename is not specified, the default name is
+        ``from_sage.qmu`` in the current sage directory.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['F',4,[1,2]])
+            sage: import tempfile
+            sage: with tempfile.NamedTemporaryFile(suffix='.qmu') as f:                 # needs sage.plot sage.symbolic
+            ....:     Q.qmu_save(f.name)
+
+        Make sure we can save quivers with `m != n` frozen variables, see :issue:`14851`::
+
+            sage: S = ClusterSeed(['A',3])
+            sage: T1 = S.principal_extension()
+            sage: Q = T1.quiver()
+            sage: import tempfile
+            sage: with tempfile.NamedTemporaryFile(suffix='.qmu') as f:                 # needs sage.plot sage.symbolic
+            ....:     Q.qmu_save(f.name)
+        """
+        M = self.b_matrix()
+        if self.m():
+            from sage.matrix.constructor import matrix
+            from sage.matrix.constructor import block_matrix
+            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]])
+        dg = self.digraph()
+        dg.plot(save_pos=True)
+        PP = dg.get_pos()
+        m = M.ncols()
+
+        if filename is None:
+            filename = 'from_sage.qmu'
+        try:
+            self._default_filename = filename
+        except AttributeError:
+            pass
+        if filename[-4:] != '.qmu':
+            filename += '.qmu'
+
+        string = []
+        string.append('//Number of points')
+        string.append(str(m))
+        string.append('//Vertex radius')
+        string.append('9')
+        string.append('//Labels shown')
+        string.append('1')
+        string.append('//Matrix')
+        string.append(str(m) + ' ' + str(m))
+        string.extend(' '.join(str(M[i, j]) for j in range(m))
+                      for i in range(m))
+        string.append('//Points')
+
+        for i in range(m):
+            x, y = PP[i]
+            txt = '9 ' + str(100 * x) + ' ' + str(100 * y)
+            if i >= self.n():
+                txt += ' 1'
+            string.append(txt)
+
+        string.append('//Historycounter')
+        string.append('-1')
+        string.append('//History')
+        string.append('')
+        string.append('//Cluster is null')
+
+        string = '\n'.join(string)
+
+        with open(filename, 'w') as myfile:
+            myfile.write(string)
+
+    def b_matrix(self):
+        """
+        Return the b-matrix of ``self``.
+
+        EXAMPLES::
+
+            sage: ClusterQuiver(['A',4]).b_matrix()
+            [ 0  1  0  0]
+            [-1  0 -1  0]
+            [ 0  1  0  1]
+            [ 0  0 -1  0]
+
+            sage: ClusterQuiver(['B',4]).b_matrix()
+            [ 0  1  0  0]
+            [-1  0 -1  0]
+            [ 0  1  0  1]
+            [ 0  0 -2  0]
+
+            sage: ClusterQuiver(['D',4]).b_matrix()
+            [ 0  1  0  0]
+            [-1  0 -1 -1]
+            [ 0  1  0  0]
+            [ 0  1  0  0]
+
+            sage: ClusterQuiver(QuiverMutationType([['A',2],['B',2]])).b_matrix()
+            [ 0  1  0  0]
+            [-1  0  0  0]
+            [ 0  0  0  1]
+            [ 0  0 -2  0]
+        """
+        return copy(self._M)
+
+    def digraph(self):
+        """
+        Return the underlying digraph of ``self``.
+
+        EXAMPLES::
+
+            sage: ClusterQuiver(['A',1]).digraph()
+            Digraph on 1 vertex
+            sage: list(ClusterQuiver(['A',1]).digraph())
+            [0]
+            sage: ClusterQuiver(['A',1]).digraph().edges(sort=True)
+            []
+
+            sage: ClusterQuiver(['A',4]).digraph()
+            Digraph on 4 vertices
+            sage: ClusterQuiver(['A',4]).digraph().edges(sort=True)
+            [(0, 1, (1, -1)), (2, 1, (1, -1)), (2, 3, (1, -1))]
+
+            sage: ClusterQuiver(['B',4]).digraph()
+            Digraph on 4 vertices
+            sage: ClusterQuiver(['A',4]).digraph().edges(sort=True)
+            [(0, 1, (1, -1)), (2, 1, (1, -1)), (2, 3, (1, -1))]
+
+            sage: ClusterQuiver(QuiverMutationType([['A',2],['B',2]])).digraph()
+            Digraph on 4 vertices
+
+            sage: ClusterQuiver(QuiverMutationType([['A',2],['B',2]])).digraph().edges(sort=True)
+            [(0, 1, (1, -1)), (2, 3, (1, -2))]
+
+            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 self._digraph.copy()
+
+    def mutation_type(self):
+        """
+        Return the mutation type of ``self``.
+
+        Return the mutation_type of each connected component of ``self`` if it
+        can be determined, otherwise, the mutation type of this component is
+        set to be unknown.
+
+        The mutation types of the components are ordered by vertex labels.
+
+        If you do many type recognitions, you should consider to save
+        exceptional mutation types using
+        :meth:`~sage.combinat.cluster_algebra_quiver.quiver_mutation_type.save_quiver_data`
+
+        WARNING:
+
+        - All finite types can be detected,
+        - All affine types can be detected, EXCEPT affine type D (the algorithm is not yet implemented)
+        - All exceptional types can be detected.
+
+        EXAMPLES::
+
+            sage: ClusterQuiver(['A',4]).mutation_type()
+            ['A', 4]
+            sage: ClusterQuiver(['A',(3,1),1]).mutation_type()
+            ['A', [1, 3], 1]
+            sage: ClusterQuiver(['C',2]).mutation_type()
+            ['B', 2]
+            sage: ClusterQuiver(['B',4,1]).mutation_type()
+            ['BD', 4, 1]
+
+        finite types::
+
+            sage: Q = ClusterQuiver(['A',5])
+            sage: Q._mutation_type = None
+            sage: Q.mutation_type()
+            ['A', 5]
+
+            sage: Q = ClusterQuiver([(0,1),(1,2),(2,3),(3,4)])
+            sage: Q.mutation_type()
+            ['A', 5]
+
+            sage: Q = ClusterQuiver(DiGraph([['a', 'b'], ['c', 'b'], ['c', 'd'], ['e', 'd']]),
+            ....:                   frozen=['c'])
+            sage: Q.mutation_type()
+            [ ['A', 2], ['A', 2] ]
+
+        affine types::
+
+            sage: Q = ClusterQuiver(['E',8,[1,1]]); Q
+            Quiver on 10 vertices of type ['E', 8, [1, 1]]
+            sage: Q._mutation_type = None; Q
+            Quiver on 10 vertices
+            sage: Q.mutation_type() # long time
+            ['E', 8, [1, 1]]
+
+        the not yet working affine type D (unless user has saved small classical quiver data)::
+
+            sage: Q = ClusterQuiver(['D',4,1])
+            sage: Q._mutation_type = None
+            sage: Q.mutation_type() # todo: not implemented
+            ['D', 4, 1]
+
+        the exceptional types::
+
+            sage: Q = ClusterQuiver(['X',6])
+            sage: Q._mutation_type = None
+            sage: Q.mutation_type() # long time
+            ['X', 6]
+
+        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
+            ['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
+            ['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
+            ['E', 8, [1, 1]]
+
+        infinite types::
+
+            sage: Q = ClusterQuiver(['GR',[4,9]])
+            sage: Q._mutation_type = None
+            sage: Q.mutation_type()
+            'undetermined infinite mutation type'
+
+        reducible types::
+
+            sage: Q = ClusterQuiver([['A', 3], ['B', 3]])
+            sage: Q._mutation_type = None
+            sage: Q.mutation_type()
+            [ ['A', 3], ['B', 3] ]
+
+            sage: Q = ClusterQuiver([['A', 3], ['T', [4,4,4]]])
+            sage: Q._mutation_type = None
+            sage: Q.mutation_type()
+            [['A', 3], 'undetermined infinite mutation type']
+
+            sage: Q = ClusterQuiver([['A', 3], ['B', 3], ['T', [4,4,4]]])
+            sage: Q._mutation_type = None
+            sage: Q.mutation_type()
+            [['A', 3], ['B', 3], 'undetermined infinite mutation type']
+
+            sage: Q = ClusterQuiver([[0,1,2],[1,2,2],[2,0,2],[3,4,1],[4,5,1]])
+            sage: Q.mutation_type()
+            ['undetermined finite mutation type', ['A', 3]]
+
+        TESTS::
+
+            sage: Q = ClusterQuiver(matrix([[0, 3], [-1, 0], [1, 0], [0, 1]]))
+            sage: Q.mutation_type()
+            ['G', 2]
+            sage: Q = ClusterQuiver(matrix([[0, -1, -1, 1, 0], [1, 0, 1, 0, 1], [1, -1, 0, -1, 0], [-1, 0, 1, 0, 1], [0, -1, 0, -1, 0], [0, 1, 0, -1, -1], [0, 1, -1, 0, 0]]))
+            sage: Q.mutation_type()
+            'undetermined infinite mutation type'
+        """
+        # checking if the mutation type is known already
+        if self._mutation_type is None:
+            # checking mutation type only for the principal part
+            if self._m > 0:
+                dg = self._digraph.subgraph(self._nlist)
+            else:
+                dg = self._digraph
+
+            # checking the type for each connected component
+            mutation_type = []
+            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.relabel()
+                # turning dg_component into a canonical form
+                _dg_canonical_form(dg_component)
+                # turning dg_component into a canonical form
+                dig6 = _digraph_to_dig6(dg_component, hashable=True)
+                # and getting the corresponding matrix
+                M = _dig6_to_matrix(dig6)
+
+                # checking if this quiver is mutation infinite
+                is_finite, path = is_mutation_finite(M)
+                if is_finite is False:
+                    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)
+                    # checking if the algorithm can determine the mutation type
+                    if mut_type_part == 'unknown':
+                        mut_type_part = _connected_mutation_type(dg_component)
+                    # checking if this quiver is of exceptional type by computing the exceptional mutation classes
+                    if mut_type_part == 'unknown':
+                        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)
+
+            # the empty quiver case
+            if len(mutation_type) == 0:
+                mutation_type = None
+            # the connected quiver case
+            elif len(mutation_type) == 1:
+                mutation_type = mutation_type[0]
+            # the reducible quiver case
+            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
+
+    def n(self):
+        """
+        Return the number of free vertices of ``self``.
+
+        EXAMPLES::
+
+            sage: ClusterQuiver(['A',4]).n()
+            4
+            sage: ClusterQuiver(['A',(3,1),1]).n()
+            4
+            sage: ClusterQuiver(['B',4]).n()
+            4
+            sage: ClusterQuiver(['B',4,1]).n()
+            5
+        """
+        return self._n
+
+    def m(self):
+        """
+        Return the number of frozen vertices of ``self``.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',4])
+            sage: Q.m()
+            0
+
+            sage: T = ClusterQuiver(Q.digraph().edges(sort=True), frozen=[3])
+            sage: T.n()
+            3
+            sage: T.m()
+            1
+        """
+        return self._m
+
+    def free_vertices(self) -> list:
+        """
+        Return the list of free vertices of ``self``.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(DiGraph([['a', 'b'], ['c', 'b'], ['c', 'd'], ['e', 'd']]),
+            ....:                   frozen=['b', 'd'])
+            sage: Q.free_vertices()
+            ['a', 'c', 'e']
+        """
+        return self._nlist
+
+    def frozen_vertices(self) -> list:
+        """
+        Return the list of frozen vertices of ``self``.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(DiGraph([['a', 'b'], ['c', 'b'], ['c', 'd'], ['e', 'd']]),
+            ....:                   frozen=['b', 'd'])
+            sage: sorted(Q.frozen_vertices())
+            ['b', 'd']
+        """
+        return self._mlist
+
+    def canonical_label(self, certificate=False):
+        """
+        Return the canonical labelling of ``self``.
+
+        See :meth:`sage.graphs.generic_graph.GenericGraph.canonical_label`.
+
+        INPUT:
+
+        - ``certificate`` -- boolean (default: ``False``); if ``True``, the
+          dictionary from ``self.vertices()`` to the vertices of the returned
+          quiver is returned as well
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',4]); Q.digraph().edges(sort=True)
+            [(0, 1, (1, -1)), (2, 1, (1, -1)), (2, 3, (1, -1))]
+
+            sage: T = Q.canonical_label(); T.digraph().edges(sort=True)
+            [(0, 3, (1, -1)), (1, 2, (1, -1)), (1, 3, (1, -1))]
+
+            sage: T, iso = Q.canonical_label(certificate=True)
+            sage: T.digraph().edges(sort=True); iso
+            [(0, 3, (1, -1)), (1, 2, (1, -1)), (1, 3, (1, -1))]
+            {0: 0, 1: 3, 2: 1, 3: 2}
+
+            sage: Q = ClusterQuiver(QuiverMutationType([['B',2],['A',1]])); Q
+            Quiver on 3 vertices of type [ ['B', 2], ['A', 1] ]
+
+            sage: Q.canonical_label()
+            Quiver on 3 vertices of type [ ['A', 1], ['B', 2] ]
+
+            sage: Q.canonical_label(certificate=True)
+            (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 = self._digraph.copy()
+        iso, _ = _dg_canonical_form(dg, frozen=self._mlist)
+        frozen = [iso[i] for i in self._mlist]
+        Q = ClusterQuiver(dg, frozen=frozen)
+        # getting the new ordering for the mutation type if necessary
+        if self._mutation_type:
+            if dg.is_connected():
+                Q._mutation_type = self._mutation_type
+            else:
+                CC = sorted(self._digraph.connected_components(sort=False))
+                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 = [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) -> bool:
+        """
+        Return true if ``self`` is acyclic.
+
+        EXAMPLES::
+
+            sage: ClusterQuiver(['A',4]).is_acyclic()
+            True
+
+            sage: ClusterQuiver(['A',[2,1],1]).is_acyclic()
+            True
+
+            sage: ClusterQuiver([[0,1],[1,2],[2,0]]).is_acyclic()
+            False
+        """
+        return self._digraph.is_directed_acyclic()
+
+    def is_bipartite(self, return_bipartition=False):
+        """
+        Return ``True`` if ``self`` is bipartite.
+
+        EXAMPLES::
+
+            sage: ClusterQuiver(['A',[3,3],1]).is_bipartite()
+            True
+
+            sage: ClusterQuiver(['A',[4,3],1]).is_bipartite()
+            False
+        """
+        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:
+            return True
+        return dg.to_undirected().bipartite_sets()
+
+    def exchangeable_part(self):
+        """
+        Return the restriction to the principal part (i.e. exchangeable part) of ``self``, the subquiver obtained by deleting the frozen vertices of ``self``.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',4])
+            sage: T = ClusterQuiver(Q.digraph().edges(sort=True), frozen=[3])
+            sage: T.digraph().edges(sort=True)
+            [(0, 1, (1, -1)), (2, 1, (1, -1)), (2, 3, (1, -1))]
+
+            sage: T.exchangeable_part().digraph().edges(sort=True)
+            [(0, 1, (1, -1)), (2, 1, (1, -1))]
+
+            sage: Q2 = Q.principal_extension()
+            sage: Q3 = Q2.principal_extension()
+            sage: Q2.exchangeable_part() == Q3.exchangeable_part()
+            True
+        """
+        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.
+
+        This is the quiver obtained by adding an outgoing edge to
+        every mutable vertex of ``self``.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',2]); Q
+            Quiver on 2 vertices of type ['A', 2]
+            sage: T = Q.principal_extension(); T
+            Quiver on 4 vertices of type ['A', 2] with 2 frozen vertices
+            sage: T2 = T.principal_extension(); T2
+            Quiver on 6 vertices of type ['A', 2] with 4 frozen vertices
+            sage: Q.digraph().edges(sort=True)
+            [(0, 1, (1, -1))]
+            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))]
+        """
+        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)
+        else:
+            return Q
+
+    def first_sink(self):
+        r"""
+        Return the first vertex of ``self`` that is a sink.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',5])
+            sage: Q.mutate([1,2,4,3,2])
+            sage: Q.first_sink()
+            0
+        """
+        sinks = self.digraph().sinks()
+
+        if sinks:
+            return sinks[0]
+        return None
+
+    def sinks(self) -> list:
+        r"""
+        Return all vertices of ``self`` that are sinks.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',5])
+            sage: Q.mutate([1,2,4,3,2])
+            sage: Q.sinks()
+            [0, 2]
+
+            sage: Q = ClusterQuiver(['A',5])
+            sage: Q.mutate([2,1,3,4,2])
+            sage: Q.sinks()
+            [3]
+        """
+        return self.digraph().sinks()
+
+    def first_source(self):
+        r"""
+        Return the first vertex of ``self`` that is a source.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',5])
+            sage: Q.mutate([2,1,3,4,2])
+            sage: Q.first_source()
+            1
+        """
+        sources = self.digraph().sources()
+
+        if sources:
+            return sources[0]
+        return None
+
+    def sources(self) -> list:
+        r"""
+        Return all vertices of ``self`` that are sources.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',5])
+            sage: Q.mutate([1,2,4,3,2])
+            sage: Q.sources()
+            []
+
+            sage: Q = ClusterQuiver(['A',5])
+            sage: Q.mutate([2,1,3,4,2])
+            sage: Q.sources()
+            [1]
+        """
+        return self.digraph().sources()
+
+    def mutate(self, data, inplace=True):
+        """
+        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
+        - ``inplace`` -- boolean (default: ``True``); if ``False``, the result
+          is returned, otherwise ``self`` is modified
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',4]); Q.b_matrix()
+            [ 0  1  0  0]
+            [-1  0 -1  0]
+            [ 0  1  0  1]
+            [ 0  0 -1  0]
+
+            sage: Q.mutate(0); Q.b_matrix()
+            [ 0 -1  0  0]
+            [ 1  0 -1  0]
+            [ 0  1  0  1]
+            [ 0  0 -1  0]
+
+            sage: T = Q.mutate(0, inplace=False); T
+            Quiver on 4 vertices of type ['A', 4]
+
+            sage: Q.mutate(0)
+            sage: Q == T
+            True
+
+            sage: Q.mutate([0,1,0])
+            sage: Q.b_matrix()
+            [ 0 -1  1  0]
+            [ 1  0  0  0]
+            [-1  0  0  1]
+            [ 0  0 -1  0]
+
+            sage: Q = ClusterQuiver(QuiverMutationType([['A',1],['A',3]]))
+            sage: Q.b_matrix()
+            [ 0  0  0  0]
+            [ 0  0  1  0]
+            [ 0 -1  0 -1]
+            [ 0  0  1  0]
+
+            sage: T = Q.mutate(0,inplace=False)
+            sage: Q == T
+            True
+
+            sage: Q = ClusterQuiver(['A',3]); Q.b_matrix()
+            [ 0  1  0]
+            [-1  0 -1]
+            [ 0  1  0]
+            sage: Q.mutate('first_sink'); Q.b_matrix()
+            [ 0 -1  0]
+            [ 1  0  1]
+            [ 0 -1  0]
+            sage: Q.mutate('first_source'); Q.b_matrix()
+            [ 0  1  0]
+            [-1  0 -1]
+            [ 0  1  0]
+
+            sage: dg = DiGraph()
+            sage: dg.add_vertices(['a','b','c','d','e'])
+            sage: dg.add_edges([['a','b'], ['b','c'], ['c','d'], ['d','e']])
+            sage: Q2 = ClusterQuiver(dg, frozen=['c']); Q2.b_matrix()
+            [ 0  1  0  0]
+            [-1  0  0  0]
+            [ 0  0  0  1]
+            [ 0  0 -1  0]
+            [ 0 -1  1  0]
+            sage: Q2.mutate('a'); Q2.b_matrix()
+            [ 0 -1  0  0]
+            [ 1  0  0  0]
+            [ 0  0  0  1]
+            [ 0  0 -1  0]
+            [ 0 -1  1  0]
+
+            sage: dg = DiGraph([['a', 'b'], ['b', 'c']], format='list_of_edges')
+            sage: Q = ClusterQuiver(dg);Q
+            Quiver on 3 vertices
+            sage: Q.mutate(['a','b'],inplace=False).digraph().edges(sort=True)
+            [('a', 'b', (1, -1)), ('c', 'b', (1, -1))]
+
+        TESTS::
+
+            sage: Q = ClusterQuiver(['A',4]); Q.mutate(0,1)
+            Traceback (most recent call last):
+            ...
+            ValueError: The second parameter must be boolean.  To mutate at a sequence of length 2, input it as a list.
+
+            sage: Q = ClusterQuiver(['A',4]); Q.mutate(0,0)
+            Traceback (most recent call last):
+            ...
+            ValueError: The second parameter must be boolean.  To mutate at a sequence of length 2, input it as a list.
+        """
+        dg = self._digraph
+        V = nlist = self._nlist
+        mlist = self._mlist
+
+        # If we get a string which is not a cluster variable, execute as a function
+        if isinstance(data, str):
+            if data not in V:
+                data = getattr(self, data)()
+
+        # If we get a function, execute it
+        if callable(data):
+            # function should return either integer or sequence
+            data = data(self)
+
+        if data is None:
+            raise ValueError('Not mutating: No vertices given.')
+
+        if data in V:
+            seq = [data]
+        else:
+            seq = data
+        if isinstance(seq, tuple):
+            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):
+            raise ValueError('The second parameter must be boolean.  To mutate at a sequence of length 2, input it as a list.')
+        if any(v not in V for v in seq):
+            v = next(v for v in seq if v not in V)
+            raise ValueError('The quiver cannot be mutated at the vertex %s' % v)
+
+        for v in seq:
+            dg = _digraph_mutate(dg, v, frozen=mlist)
+
+        if inplace:
+            self._M = _edge_list_to_matrix(dg.edge_iterator(), nlist, mlist)
+            self._M.set_immutable()
+            self._digraph = dg
+        else:
+            Q = ClusterQuiver(dg, frozen=mlist)
+            Q._mutation_type = self._mutation_type
+            return Q
+
+    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.
+
+        INPUT:
+
+        - ``sequence`` -- list or tuple of vertices of ``self``
+        - ``show_sequence`` -- boolean (default: ``False``); if ``True``, a png
+          containing the mutation sequence is shown
+        - ``fig_size`` -- (default: 1.2) factor by which the size of the
+          sequence is expanded
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',4])
+            sage: seq = Q.mutation_sequence([0,1]); seq
+            [Quiver on 4 vertices of type ['A', 4],
+             Quiver on 4 vertices of type ['A', 4],
+             Quiver on 4 vertices of type ['A', 4]]
+            sage: [T.b_matrix() for T in seq]
+            [
+            [ 0  1  0  0]  [ 0 -1  0  0]  [ 0  1 -1  0]
+            [-1  0 -1  0]  [ 1  0 -1  0]  [-1  0  1  0]
+            [ 0  1  0  1]  [ 0  1  0  1]  [ 1 -1  0  1]
+            [ 0  0 -1  0], [ 0  0 -1  0], [ 0  0 -1  0]
+            ]
+        """
+        n = self._n
+        m = self._m
+        if m == 0:
+            width_factor = 3
+            fig_size = fig_size*2*n/3
+        else:
+            width_factor = 6
+            fig_size = fig_size*4*n/3
+        V = range(n)
+
+        if isinstance(sequence, tuple):
+            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')
+        if any(v not in V for v in sequence):
+            v = next(v for v in sequence if v not in V)
+            raise ValueError(f'the quiver can only be mutated at the vertex {v}')
+
+        quiver = copy(self)
+        quiver_sequence = []
+        quiver_sequence.append(copy(quiver))
+
+        for v in sequence:
+            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)
+
+            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])
+                else:
+                    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])
+        return quiver_sequence
+
+    def reorient(self, data):
+        """
+        Reorient ``self`` with respect to the given total order, or
+        with respect to an iterator of edges in ``self`` to be
+        reverted.
+
+        .. WARNING::
+
+            This operation might change the mutation type of ``self``.
+
+        INPUT:
+
+        - ``data`` -- an iterator defining a total order on
+          ``self.vertices()``, or an iterator of edges in ``self`` to
+          be reoriented.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',(2,3),1])
+            sage: Q.mutation_type()
+            ['A', [2, 3], 1]
+
+            sage: Q.reorient([(0,1),(1,2),(2,3),(3,4)])
+            sage: Q.mutation_type()
+            ['D', 5]
+
+            sage: Q.reorient([0,1,2,3,4])
+            sage: Q.mutation_type()
+            ['A', [1, 4], 1]
+
+        TESTS::
+
+            sage: Q = ClusterQuiver(['A',2])
+            sage: Q.reorient([])
+            Traceback (most recent call last):
+            ...
+            ValueError: empty input
+            sage: Q.reorient([3,4])
+            Traceback (most recent call last):
+            ...
+            ValueError: not a total order on the vertices of the quiver or
+            a list of edges to be oriented
+        """
+        if not data:
+            raise ValueError('empty input')
+        first = data[0]
+
+        if set(data) == set(range(self._n + self._m)):
+            dg_new = DiGraph()
+            for edge in self._digraph.edges(sort=True):
+                if data.index(edge[0]) < data.index(edge[1]):
+                    dg_new.add_edge(edge[0], edge[1], edge[2])
+                else:
+                    dg_new.add_edge(edge[1], edge[0], edge[2])
+            self._digraph = dg_new
+            self._M = _edge_list_to_matrix(dg_new.edges(sort=True),
+                                           self._nlist, self._mlist)
+            self._M.set_immutable()
+            self._mutation_type = None
+        elif isinstance(first, (list, tuple)) and len(first) == 2:
+            edges = self._digraph.edges(sort=True, labels=False)
+            for edge in data:
+                if (edge[1], edge[0]) in edges:
+                    label = self._digraph.edge_label(edge[1], edge[0])
+                    self._digraph.delete_edge(edge[1], edge[0])
+                    self._digraph.add_edge(edge[0], edge[1], label)
+            self._M = _edge_list_to_matrix(self._digraph.edges(sort=True),
+                                           self._nlist, self._mlist)
+            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')
+
+    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.
+
+        INPUT:
+
+        - ``depth`` -- integer (default: infinity); only quivers with distance
+          at most depth from ``self`` are returned.
+        - ``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
+        - ``data_type`` -- (default: ``'quiver'``) can be one of the following::
+
+            * "quiver"
+            * "matrix"
+            * "digraph"
+            * "dig6"
+            * "path"
+
+        - ``up_to_equivalence`` -- boolean (default: ``True``); if ``True``,
+          only one quiver for each graph-isomorphism class is recorded
+        - ``sink_source`` -- boolean (default: ``False``); if ``True``, only
+          mutations at sinks and sources are applied
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',3])
+            sage: it = Q.mutation_class_iter()
+            sage: for T in it: print(T)
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+
+            sage: it = Q.mutation_class_iter(depth=1)
+            sage: for T in it: print(T)
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+
+            sage: it = Q.mutation_class_iter(show_depth=True)
+            sage: for T in it: pass
+            Depth: 0     found: 1          Time: ... s
+            Depth: 1     found: 3          Time: ... s
+            Depth: 2     found: 4          Time: ... s
+
+            sage: it = Q.mutation_class_iter(return_paths=True)
+            sage: for T in it: print(T)
+            (Quiver on 3 vertices of type ['A', 3], [])
+            (Quiver on 3 vertices of type ['A', 3], [1])
+            (Quiver on 3 vertices of type ['A', 3], [0])
+            (Quiver on 3 vertices of type ['A', 3], [0, 1])
+
+            sage: it = Q.mutation_class_iter(up_to_equivalence=False)
+            sage: for T in it: print(T)
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            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: mutation_class = list(it)
+            sage: len(mutation_class)
+            14
+            sage: mutation_class[0]
+            (Quiver on 3 vertices of type ['A', 3], [])
+
+            sage: Q = ClusterQuiver(['A',3])
+            sage: it = Q.mutation_class_iter(data_type='path')
+            sage: for T in it: print(T)
+            []
+            [1]
+            [0]
+            [0, 1]
+
+            sage: Q = ClusterQuiver(['A',3])
+            sage: it = Q.mutation_class_iter(return_paths=True,
+            ....:        data_type='matrix')
+            sage: next(it)
+            (
+            [ 0  0  1]
+            [ 0  0  1]
+            [-1 -1  0], []
+            )
+
+            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,
+             Quiver on 3 vertices with 1 frozen vertex,
+             Quiver on 3 vertices with 1 frozen vertex]
+        """
+        if data_type == 'path':
+            return_paths = False
+        if data_type == "dig6":
+            return_dig6 = True
+        else:
+            return_dig6 = False
+
+        # jump to the standard labelling convention
+        dg = ClusterQuiver(self._M).digraph()
+        frozen = list(range(self._n, self._n + self._m))
+
+        MC_iter = _mutation_class_iter(dg, self._n, self._m, depth=depth,
+                                       return_dig6=return_dig6,
+                                       show_depth=show_depth,
+                                       up_to_equivalence=up_to_equivalence,
+                                       sink_source=sink_source)
+        for data in MC_iter:
+            if data_type == "quiver":
+                next_element = ClusterQuiver(data[0], frozen=frozen)
+                next_element._mutation_type = self._mutation_type
+            elif data_type == "matrix":
+                next_element = ClusterQuiver(data[0], frozen=frozen)._M
+            elif data_type == "digraph":
+                next_element = data[0]
+            elif data_type == "dig6":
+                next_element = data[0]
+            elif data_type == "path":
+                next_element = data[1]
+            else:
+                raise ValueError("the parameter for data_type was "
+                                 "not recognized")
+            if return_paths:
+                yield (next_element, data[1])
+            else:
+                yield next_element
+
+    def mutation_class(self, depth=infinity, show_depth=False, return_paths=False,
+                       data_type='quiver', up_to_equivalence=True, sink_source=False):
+        """
+        Return the mutation class of ``self`` together with certain constraints.
+
+        INPUT:
+
+        - ``depth`` -- (default: ``infinity``) integer, only seeds with
+          distance at most depth from ``self`` are returned
+        - ``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
+        - ``data_type`` -- (default: ``'quiver'``) can be one of
+          the following:
+
+          * ``'quiver'`` -- the quiver is returned
+          * ``'dig6'`` -- the dig6-data is returned
+          * ``'path'`` -- shortest paths of mutation sequences from
+            ``self`` are returned
+
+        - ``sink_source`` -- boolean (default: ``False``); if ``True``, only
+          mutations at sinks and sources are applied
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',3])
+            sage: Ts = Q.mutation_class()
+            sage: for T in Ts: print(T)
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+
+            sage: Ts = Q.mutation_class(depth=1)
+            sage: for T in Ts: print(T)
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+
+            sage: Ts = Q.mutation_class(show_depth=True)
+            Depth: 0     found: 1          Time: ... s
+            Depth: 1     found: 3          Time: ... s
+            Depth: 2     found: 4          Time: ... s
+
+            sage: Ts = Q.mutation_class(return_paths=True)
+            sage: for T in Ts: print(T)
+            (Quiver on 3 vertices of type ['A', 3], [])
+            (Quiver on 3 vertices of type ['A', 3], [1])
+            (Quiver on 3 vertices of type ['A', 3], [0])
+            (Quiver on 3 vertices of type ['A', 3], [0, 1])
+
+            sage: Ts = Q.mutation_class(up_to_equivalence=False)
+            sage: for T in Ts: print(T)
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+            Quiver on 3 vertices of type ['A', 3]
+
+            sage: Ts = Q.mutation_class(return_paths=True,up_to_equivalence=False)
+            sage: len(Ts)
+            14
+            sage: Ts[0]
+            (Quiver on 3 vertices of type ['A', 3], [])
+
+            sage: Ts = Q.mutation_class(show_depth=True)
+            Depth: 0     found: 1          Time: ... s
+            Depth: 1     found: 3          Time: ... s
+            Depth: 2     found: 4          Time: ... s
+
+            sage: Ts = Q.mutation_class(show_depth=True, up_to_equivalence=False)
+            Depth: 0     found: 1          Time: ... s
+            Depth: 1     found: 4          Time: ... s
+            Depth: 2     found: 6          Time: ... s
+            Depth: 3     found: 10        Time: ... s
+            Depth: 4     found: 14        Time: ... s
+
+        TESTS::
+
+            sage: all(len(ClusterQuiver(['A',n]).mutation_class())
+            ....:     == ClusterQuiver(['A',n]).mutation_type().class_size()
+            ....:     for n in [2..6])
+            True
+
+            sage: all(len(ClusterQuiver(['B',n]).mutation_class())
+            ....:     == ClusterQuiver(['B',n]).mutation_type().class_size()
+            ....:     for n in [2..6])
+            True
+        """
+        if depth is infinity and not self.is_mutation_finite():
+            raise ValueError('the mutation class can - for infinite mutation'
+                             ' types - only be computed up to a given depth')
+        return list(self.mutation_class_iter(depth=depth, show_depth=show_depth,
+                                             return_paths=return_paths,
+                                             data_type=data_type,
+                                             up_to_equivalence=up_to_equivalence,
+                                             sink_source=sink_source))
+
+    def is_finite(self) -> bool:
+        """
+        Return ``True`` if ``self`` is of finite type.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',3])
+            sage: Q.is_finite()
+            True
+            sage: Q = ClusterQuiver(['A',[2,2],1])
+            sage: Q.is_finite()
+            False
+            sage: Q = ClusterQuiver([['A',3],['B',3]])
+            sage: Q.is_finite()
+            True
+            sage: Q = ClusterQuiver(['T',[4,4,4]])
+            sage: Q.is_finite()
+            False
+            sage: Q = ClusterQuiver([['A',3],['T',[4,4,4]]])
+            sage: Q.is_finite()
+            False
+            sage: Q = ClusterQuiver([['A',3],['T',[2,2,3]]])
+            sage: Q.is_finite()
+            True
+            sage: Q = ClusterQuiver([['A',3],['D',5]])
+            sage: Q.is_finite()
+            True
+            sage: Q = ClusterQuiver([['A',3],['D',5,1]])
+            sage: Q.is_finite()
+            False
+
+            sage: Q = ClusterQuiver([[0,1,2],[1,2,2],[2,0,2]])
+            sage: Q.is_finite()
+            False
+
+            sage: Q = ClusterQuiver([[0,1,2],[1,2,2],[2,0,2],[3,4,1],[4,5,1]])
+            sage: Q.is_finite()
+            False
+        """
+        mt = self.mutation_type()
+        return (type(mt) in [QuiverMutationType_Irreducible,
+                             QuiverMutationType_Reducible] and mt.is_finite())
+
+    def is_mutation_finite(self, nr_of_checks=None, return_path=False) -> bool:
+        """
+        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:
+
+        - ``nr_of_checks`` -- (default: ``None``) number of mutations applied;
+          Standard is 500*(number of vertices of ``self``)
+        - ``return_path`` -- (default: ``False``) if ``True``, in case of
+          ``self`` not being mutation finite, a path from ``self`` to a quiver
+          with an edge label `(a,-b)` and `a*b > 4` is returned
+
+        ALGORITHM:
+
+        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::
+
+            sage: Q = ClusterQuiver(['A',10])
+            sage: Q._mutation_type = None
+            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.is_mutation_finite()
+            False
+        """
+        if self._n <= 2:
+            is_finite = True
+            path = None
+        elif not return_path and self._mutation_type == 'undetermined infinite mutation type':
+            is_finite = False
+        elif (isinstance(self._mutation_type, (QuiverMutationType_Irreducible,
+                                               QuiverMutationType_Reducible))
+              and self._mutation_type.is_mutation_finite()):
+            is_finite = True
+            path = None
+        elif (not return_path and isinstance(self._mutation_type,
+                                             (QuiverMutationType_Irreducible,
+                                              QuiverMutationType_Reducible))
+              and not self._mutation_type.is_mutation_finite()):
+            is_finite = False
+        else:
+            # turning dg_component into a canonical form
+            dig6 = _digraph_to_dig6(self.digraph())
+            # and getting the corresponding matrix
+            M = _dig6_to_matrix(dig6)
+
+            is_finite, path = is_mutation_finite(M, nr_of_checks=nr_of_checks)
+        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.
+
+        OUTPUT: integer of the number of edges
+
+        EXAMPLES::
+
+            sage: S = ClusterQuiver(['A',4]); S.number_of_edges()
+            3
+
+            sage: S = ClusterQuiver(['B',4]); S.number_of_edges()
+            3
+        """
+        return sum(label[0] for label in self.digraph().edge_labels())
+
+    def relabel(self, relabelling, inplace=True):
+        r"""
+        Return the quiver after doing a relabelling.
+
+        Will relabel the vertices of the quiver.
+
+        INPUT:
+
+        - ``relabelling`` -- dictionary of labels to move around
+        - ``inplace`` -- boolean (default: ``True``); if ``True``, will return
+          a duplicate of the quiver
+
+        EXAMPLES::
+
+            sage: S = ClusterQuiver(['A',4]).relabel({1:'5',2:'go'})
+        """
+        if inplace:
+            quiver = self
+        else:
+            quiver = ClusterQuiver(self)
+
+        # Instantiation variables
+        old_vertices = list(quiver.digraph())
+        digraph_labels = {}
+        dict_labels = {}
+
+        # Organize labels noting that for:
+        #    _digraph: {old_vertex: new_vertex}
+        #    _vertex_dictionary: {num: new_vertex}
+        if isinstance(relabelling, list):
+            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:
+                val = relabelling[key]
+
+                if key in old_vertices:
+                    # If the key is in the old vertices, use that mapping
+                    digraph_labels[key] = val
+                    # And place it in the right order for our dictionary
+                    loc = [i for i, x in enumerate(old_vertices)
+                           if x == key][0]
+                    dict_labels[loc] = val
+                elif isinstance(key, int) and len(old_vertices) > key:
+                    # If the key is an integer, grab that particular vertex
+                    digraph_labels[old_vertices[key]] = val
+                    # And copy it over to our dictionary
+                    dict_labels[key] = val
+
+        quiver._digraph.relabel(digraph_labels)
+        quiver._vertex_dictionary = dict_labels
+        return quiver
+
+    def poincare_semistable(self, theta, d):
+        r"""
+        Return the Poincaré polynomial of the moduli space of semi-stable
+        representations of dimension vector `d`.
+
+        INPUT:
+
+        - ``theta`` -- stability weight, as list or vector of rationals
+        - ``d`` -- dimension vector, as list or vector of coprime integers
+
+        The semi-stability is taken with respect to the slope function
+
+        .. MATH::
+
+             \mu(d) = \theta(d) / \operatorname{dim}(d)
+
+        where `d` is a dimension vector.
+
+        This uses the matrix-inversion algorithm from [Rei2002]_.
+
+        EXAMPLES::
+
+            sage: Q = ClusterQuiver(['A',2])
+            sage: Q.poincare_semistable([1,0],[1,0])
+            1
+            sage: Q.poincare_semistable([1,0],[1,1])
+            1
+
+            sage: K2 = ClusterQuiver(matrix([[0,2],[-2,0]]))
+            sage: theta = (1, 0)
+            sage: K2.poincare_semistable(theta, [1,0])
+            1
+            sage: K2.poincare_semistable(theta, [1,1])
+            v^2 + 1
+            sage: K2.poincare_semistable(theta, [1,2])
+            1
+            sage: K2.poincare_semistable(theta, [1,3])
+            0
+
+            sage: K3 = ClusterQuiver(matrix([[0,3],[-3,0]]))
+            sage: theta = (1, 0)
+            sage: K3.poincare_semistable(theta, (2,3))
+            v^12 + v^10 + 3*v^8 + 3*v^6 + 3*v^4 + v^2 + 1
+            sage: K3.poincare_semistable(theta, (3,4))(1)
+            68
+
+        TESTS::
+
+            sage: Q = ClusterQuiver(['A',2])
+            sage: Q.poincare_semistable([1,0],[2,2])
+            Traceback (most recent call last):
+            ...
+            ValueError: dimension vector d is not coprime
+
+            sage: Q = ClusterQuiver(['A',3])
+            sage: Q.poincare_semistable([1,1,0],[2,3,4])
+            0
+
+        REFERENCES:
+
+        .. [Rei2002] Markus Reineke, *The Harder-Narasimhan system in quantum
+           groups and cohomology of quiver moduli*, :arxiv:`math/0204059`
+        """
+        if gcd([x for x in d if x]) != 1:
+            raise ValueError("dimension vector d is not coprime")
+        d = vector(ZZ, d)
+        theta = vector(theta)
+
+        n = self.n()
+        b_mat = self.b_matrix()
+        Eu = matrix(ZZ, n, n,
+                    lambda i, j: -b_mat[i, j] if b_mat[i, j] > 0 else 0)
+        Eu = 1 + Eu
+        edges = list(self.digraph().edges(sort=True, labels=False))
+
+        mu_d = theta.dot_product(d) / sum(d)
+
+        Li = [0 * d]
+        it = (vector(e) for e in product(*[range(d_i + 1)
+                                           for d_i in d]))
+        Li += [e for e in it if e.dot_product(theta) > mu_d * sum(e)]
+        Li.append(d)
+        N = len(Li) - 1
+
+        q = polygen(QQ, 'v')  # q stands for v**2 until the last line
+
+        def cardinal_RG(d):
+            cardinal_G = prod(q**d_i - q**k for d_i in d for k in range(d_i))
+            cardinal_R = prod(q**(b_mat[i, j] * d[i] * d[j])
+                              for i, j in edges)
+            return cardinal_R / cardinal_G
+
+        Reineke_submat = matrix(q.parent().fraction_field(), N, N)
+
+        for i, e in enumerate(Li[:-1]):
+            for j, f in enumerate(Li[1:]):
+                if e == f:
+                    Reineke_submat[i, j] = 1
+                    continue
+                f_e = f - e
+                if all(x >= 0 for x in f_e):
+                    power = (-f_e) * Eu * e
+                    Reineke_submat[i, j] = q**power * cardinal_RG(f_e)
+
+        poly = (-1)**N * ((1 - q) * Reineke_submat.det()).numerator()
+        return poly(q**2)  # replacing q by v**2
+
+    def d_vector_fan(self):
+        r"""
+        Return the d-vector fan associated with the quiver.
+
+        It is the fan whose maximal cones are generated by the
+        d-matrices of the clusters.
+
+        This is a complete simplicial fan (and even smooth when the
+        initial quiver is acyclic). It only makes sense for quivers of
+        finite type.
+
+        EXAMPLES::
+
+            sage: # needs sage.geometry.polyhedron sage.libs.singular
+            sage: Fd = ClusterQuiver([[1,2]]).d_vector_fan(); Fd
+            Rational polyhedral fan in 2-d lattice N
+            sage: Fd.ngenerating_cones()
+            5
+            sage: Fd = ClusterQuiver([[1,2],[2,3]]).d_vector_fan(); Fd
+            Rational polyhedral fan in 3-d lattice N
+            sage: Fd.ngenerating_cones()
+            14
+            sage: Fd.is_smooth()
+            True
+            sage: Fd = ClusterQuiver([[1,2],[2,3],[3,1]]).d_vector_fan(); Fd
+            Rational polyhedral fan in 3-d lattice N
+            sage: Fd.ngenerating_cones()
+            14
+            sage: Fd.is_smooth()
+            False
+
+        TESTS::
+
+            sage: ClusterQuiver(['A',[2,2],1]).d_vector_fan()
+            Traceback (most recent call last):
+            ...
+            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.cone import Cone
+
+        seed = ClusterSeed(self)
+        return Fan([Cone(s.d_matrix().columns())
+                    for s in seed.mutation_class()])
+
+    def g_vector_fan(self):
+        r"""
+        Return the g-vector fan associated with the quiver.
+
+        It is the fan whose maximal cones are generated by the
+        g-matrices of the clusters.
+
+        This is a complete simplicial fan. It is only supported for
+        quivers of finite type.
+
+        EXAMPLES::
+
+            sage: # needs sage.geometry.polyhedron
+            sage: Fg = ClusterQuiver([[1,2]]).g_vector_fan(); Fg
+            Rational polyhedral fan in 2-d lattice N
+            sage: Fg.ngenerating_cones()
+            5
+
+            sage: # needs sage.geometry.polyhedron
+            sage: Fg = ClusterQuiver([[1,2],[2,3]]).g_vector_fan(); Fg
+            Rational polyhedral fan in 3-d lattice N
+            sage: Fg.ngenerating_cones()
+            14
+            sage: Fg.is_smooth()
+            True
+
+            sage: # needs sage.geometry.polyhedron
+            sage: Fg = ClusterQuiver([[1,2],[2,3],[3,1]]).g_vector_fan(); Fg
+            Rational polyhedral fan in 3-d lattice N
+            sage: Fg.ngenerating_cones()
+            14
+            sage: Fg.is_smooth()
+            True
+
+        TESTS::
+
+            sage: # needs sage.geometry.polyhedron
+            sage: ClusterQuiver(['A',[2,2],1]).g_vector_fan()
+            Traceback (most recent call last):
+            ...
+            ValueError: only supported for quivers of finite type
+        """
+        from .cluster_seed import ClusterSeed
+        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')
+        seed = ClusterSeed(self).principal_extension()
+        return Fan([Cone(s.g_matrix().columns())
+                    for s in seed.mutation_class()])