Quiver mutation types - Combinatorics

Skip to content
Back to top
View this page
Edit this page

# Quiver mutation types

AUTHORS:

- Gregg Musiker (2012, initial version)

- Christian Stump (2012, initial version)

- Hugh Thomas (2012, initial version)

sage.combinat.cluster_algebra_quiver.quiver_mutation_type.QuiverMutationType(*args)
  Quiver mutation types can be seen as a slight generalization of

    generalized Cartan types.

  Background on generalized Cartan types can be found at

  > Wikipedia article Generalized_Cartan_matrix

  For the compendium on the cluster algebra and quiver package in Sage see [MS2011]

  A \(B\)-matrix is a skew-symmetrizable \(( n \times n )\)-matrix \(M\). I.e., there exists an invertible diagonal matrix \(D\) such that \(DM\) is skew-symmetric. \(M\) can be encoded as a quiver by having a directed edge from vertex \(i\) to vertex \(j\) with label \((a,b)\) if \(a = M_{i,j} > 0\) and \(b = M_{j,i} < 0\). We consider quivers up to mutation equivalence.

  To a quiver mutation type we can associate a generalized Cartan type by sending \(M\) to the generalized Cartan matrix \(C(M)\) obtained by replacing all positive entries by their negatives and adding \(2\)’s on the main diagonal.

  `QuiverMutationType` constructs a quiver mutation type object. For more detail on the possible different types, please see the compendium.

  INPUT:

  The input consists either of a quiver mutation type, or of a `letter` (a string), a `rank` (one integer or a list/tuple of integers), and an optional `twist` (an integer or a list of integers). There are several different naming conventions for quiver mutation types.

  - Finite type – `letter` is a Dynkin type (A-G), and `rank` is the rank.

  - Affine type – there is more than one convention for naming affine types.

    > - Kac’s notation: `letter` is a Dynkin type, `rank` is the rank of the associated finite Dynkin diagram, and `twist` is the twist, which could be 1, 2, or 3. In the special case of affine type A, there is more than one quiver mutation type associated to the Cartan type. In this case only, `rank` is a pair of integers (i,j), giving the number of edges pointing clockwise and the number of edges pointing counter-clockwise. The total number of vertices is given by i+j in this case.

    > - Naive notation: `letter` is one of ‘BB’, ‘BC’, ‘BD’, ‘CC’, ‘CD’. The name specifies the two ends of the diagram, which are joined by a path. The total number of vertices is given by `rank +1` (to match the indexing people expect because these are affine types). In general, `rank` must be large enough for the picture to make sense, but we accept `letter` is `BC` and `rank=1`.

    > - Macdonald notation: for the dual of an untwisted affine type (such as [‘C’, 6, 1]), we accept a twist of -1 (i.e., [‘C’,6,-1]).

  - Elliptic type – `letter` is a Dynkin type, `rank` is the rank of the finite Dynkin diagram, and `twist` is a tuple of two integers. We follow Saito’s notation.

  - Other shapes:

    > - Rank 2: `letter` is ‘R2’, and `rank` is a pair of integers specifying the label on the unique edge.

    > - Triangle: `letter` is `TR`, and `rank` is the number of vertices along a side.

    > - T: This defines a quiver shaped like a T. `letter` is ‘T’, and the `rank` is a triple, whose entries specify the number of vertices along each path from the branch point (counting the branch point).

    > - Grassmannian: This defines the cluster algebra (without coefficients) corresponding to the cluster algebra with coefficients which is the coordinate ring of a Grassmannian. `letter` is ‘GR’. `rank` is a pair of integers (\(k\), \(n\)) with ‘k’ < ‘n’ specifying the Grassmannian of \(k\)-planes in \(n\)-space. This defines a quiver given by a (k-1) x (n-k-1) grid where each square is cyclically oriented.

    > - Exceptional mutation finite quivers: The two exceptional mutation finite quivers, found by Derksen-Owen, have `letter` as ‘X’ and `rank` 6 or 7, equal to the number of vertices.

    > - AE, BE, CE, DE: Quivers are built of one end which looks like type (affine A), B, C, or D, and the other end which looks like type E (i.e., it consists of two antennae, one of length one, and one of length two). `letter` is ‘AE’, ‘BE’, ‘CE’, or ‘DE’, and `rank` is the total number of vertices. Note that ‘AE’ is of a slightly different form and requires `rank` to be a pair of integers (i,j) just as in the case of affine type A. See Exercise 4.3 in Kac’s book Infinite Dimensional Lie Algebras for more details.

    > - Infinite type E: It is also possible to obtain infinite-type E quivers by specifying `letter` as ‘E’ and `rank` as the number of vertices.

  REFERENCES:

  - A good reference for finite and affine Dynkin diagrams, including Kac’s notation, is the Wikipedia article Dynkin_diagram.

  - A good reference for the skew-symmetrizable elliptic diagrams is “Cluster algebras of finite mutation type via unfolding” by A. Felikson, M. Shapiro, and P. Tumarkin, [FST2012].

  EXAMPLES:

  Finite types:

  Sage

      sage: QuiverMutationType('A', 1)
      ['A', 1]
      sage: QuiverMutationType('A',5)
      ['A', 5]

      sage: QuiverMutationType('B', 2)
      ['B', 2]
      sage: QuiverMutationType('B',5)
      ['B', 5]

      sage: QuiverMutationType('C', 2)
      ['B', 2]
      sage: QuiverMutationType('C',5)
      ['C', 5]

      sage: QuiverMutationType('D', 2)
      [ ['A', 1], ['A', 1] ]
      sage: QuiverMutationType('D',3)
      ['A', 3]
      sage: QuiverMutationType('D',4)
      ['D', 4]

      sage: QuiverMutationType('E',6)
      ['E', 6]

      sage: QuiverMutationType('G', 2)
      ['G', 2]

      sage: QuiverMutationType('A',(1,0), 1)
      ['A', 1]

      sage: QuiverMutationType('A',(2,0), 1)
      [ ['A', 1], ['A', 1] ]

      sage: QuiverMutationType('A',(7,0), 1)
      ['D', 7]

  Python

      >>> from sage.all import *
      >>> QuiverMutationType('A', Integer(1))
      ['A', 1]
      >>> QuiverMutationType('A',Integer(5))
      ['A', 5]

      >>> QuiverMutationType('B', Integer(2))
      ['B', 2]
      >>> QuiverMutationType('B',Integer(5))
      ['B', 5]

      >>> QuiverMutationType('C', Integer(2))
      ['B', 2]
      >>> QuiverMutationType('C',Integer(5))
      ['C', 5]

      >>> QuiverMutationType('D', Integer(2))
      [ ['A', 1], ['A', 1] ]
      >>> QuiverMutationType('D',Integer(3))
      ['A', 3]
      >>> QuiverMutationType('D',Integer(4))
      ['D', 4]

      >>> QuiverMutationType('E',Integer(6))
      ['E', 6]

      >>> QuiverMutationType('G', Integer(2))
      ['G', 2]

      >>> QuiverMutationType('A',(Integer(1),Integer(0)), Integer(1))
      ['A', 1]

      >>> QuiverMutationType('A',(Integer(2),Integer(0)), Integer(1))
      [ ['A', 1], ['A', 1] ]

      >>> QuiverMutationType('A',(Integer(7),Integer(0)), Integer(1))
      ['D', 7]

  Affine types:

  Sage

      sage: QuiverMutationType('A',(1, 1), 1)
      ['A', [1, 1], 1]
      sage: QuiverMutationType('A',(2,4), 1)
      ['A', [2, 4], 1]

      sage: QuiverMutationType('BB', 2, 1)
      ['BB', 2, 1]
      sage: QuiverMutationType('BB',4, 1)
      ['BB', 4, 1]

      sage: QuiverMutationType('CC', 2, 1)
      ['CC', 2, 1]
      sage: QuiverMutationType('CC',4, 1)
      ['CC', 4, 1]

      sage: QuiverMutationType('BC', 1, 1)
      ['BC', 1, 1]
      sage: QuiverMutationType('BC',5, 1)
      ['BC', 5, 1]

      sage: QuiverMutationType('BD',3, 1)
      ['BD', 3, 1]
      sage: QuiverMutationType('BD',5, 1)
      ['BD', 5, 1]

      sage: QuiverMutationType('CD',3, 1)
      ['CD', 3, 1]
      sage: QuiverMutationType('CD',5, 1)
      ['CD', 5, 1]

      sage: QuiverMutationType('D',4, 1)
      ['D', 4, 1]
      sage: QuiverMutationType('D',6, 1)
      ['D', 6, 1]

      sage: QuiverMutationType('E',6, 1)
      ['E', 6, 1]
      sage: QuiverMutationType('E',7, 1)
      ['E', 7, 1]
      sage: QuiverMutationType('E',8, 1)
      ['E', 8, 1]

      sage: QuiverMutationType('F',4, 1)
      ['F', 4, 1]
      sage: QuiverMutationType('F',4,-1)
      ['F', 4, -1]

      sage: QuiverMutationType('G', 2, 1)
      ['G', 2, 1]
      sage: QuiverMutationType('G', 2,-1)
      ['G', 2, -1]
      sage: QuiverMutationType('A',3, 2) == QuiverMutationType('D',3, 2)
      True

  [Python]

      >>> from sage.all import *
      >>> QuiverMutationType('A',(Integer(1), Integer(1)), Integer(1))
      ['A', [1, 1], 1]
      >>> QuiverMutationType('A',(Integer(2),Integer(4)), Integer(1))
      ['A', [2, 4], 1]

      >>> QuiverMutationType('BB', Integer(2), Integer(1))
      ['BB', 2, 1]
      >>> QuiverMutationType('BB',Integer(4), Integer(1))
      ['BB', 4, 1]

      >>> QuiverMutationType('CC', Integer(2), Integer(1))
      ['CC', 2, 1]
      >>> QuiverMutationType('CC',Integer(4), Integer(1))
      ['CC', 4, 1]

      >>> QuiverMutationType('BC', Integer(1), Integer(1))
      ['BC', 1, 1]
      >>> QuiverMutationType('BC',Integer(5), Integer(1))
      ['BC', 5, 1]

      >>> QuiverMutationType('BD',Integer(3), Integer(1))
      ['BD', 3, 1]
      >>> QuiverMutationType('BD',Integer(5), Integer(1))
      ['BD', 5, 1]

      >>> QuiverMutationType('CD',Integer(3), Integer(1))
      ['CD', 3, 1]
      >>> QuiverMutationType('CD',Integer(5), Integer(1))
      ['CD', 5, 1]

      >>> QuiverMutationType('D',Integer(4), Integer(1))
      ['D', 4, 1]
      >>> QuiverMutationType('D',Integer(6), Integer(1))
      ['D', 6, 1]

      >>> QuiverMutationType('E',Integer(6), Integer(1))
      ['E', 6, 1]
      >>> QuiverMutationType('E',Integer(7), Integer(1))
      ['E', 7, 1]
      >>> QuiverMutationType('E',Integer(8), Integer(1))
      ['E', 8, 1]

      >>> QuiverMutationType('F',Integer(4), Integer(1))
      ['F', 4, 1]
      >>> QuiverMutationType('F',Integer(4),-Integer(1))
      ['F', 4, -1]

      >>> QuiverMutationType('G', Integer(2), Integer(1))
      ['G', 2, 1]
      >>> QuiverMutationType('G', Integer(2),-Integer(1))
      ['G', 2, -1]
      >>> QuiverMutationType('A',Integer(3), Integer(2)) == QuiverMutationType('D',Integer(3), Integer(2))
      True

  Affine types using Kac’s Notation:

  Sage

      sage: QuiverMutationType('A', 1, 1)
      ['A', [1, 1], 1]
      sage: QuiverMutationType('B',5, 1)
      ['BD', 5, 1]
      sage: QuiverMutationType('C',5, 1)
      ['CC', 5, 1]
      sage: QuiverMutationType('A', 2, 2)
      ['BC', 1, 1]
      sage: QuiverMutationType('A',7, 2)
      ['CD', 4, 1]
      sage: QuiverMutationType('A',8, 2)
      ['BC', 4, 1]
      sage: QuiverMutationType('D',6, 2)
      ['BB', 5, 1]
      sage: QuiverMutationType('E',6, 2)
      ['F', 4, -1]
      sage: QuiverMutationType('D',4,3)
      ['G', 2, -1]

  Python

      >>> from sage.all import *
      >>> QuiverMutationType('A', Integer(1), Integer(1))
      ['A', [1, 1], 1]
      >>> QuiverMutationType('B',Integer(5), Integer(1))
      ['BD', 5, 1]
      >>> QuiverMutationType('C',Integer(5), Integer(1))
      ['CC', 5, 1]
      >>> QuiverMutationType('A', Integer(2), Integer(2))
      ['BC', 1, 1]
      >>> QuiverMutationType('A',Integer(7), Integer(2))
      ['CD', 4, 1]
      >>> QuiverMutationType('A',Integer(8), Integer(2))
      ['BC', 4, 1]
      >>> QuiverMutationType('D',Integer(6), Integer(2))
      ['BB', 5, 1]
      >>> QuiverMutationType('E',Integer(6), Integer(2))
      ['F', 4, -1]
      >>> QuiverMutationType('D',Integer(4),Integer(3))
      ['G', 2, -1]

  Elliptic types:

  Sage

      sage: QuiverMutationType('E',6,[1, 1])
      ['E', 6, [1, 1]]
      sage: QuiverMutationType('F',4,[2, 1])
      ['F', 4, [1, 2]]
      sage: QuiverMutationType('G', 2,[3,3])
      ['G', 2, [3, 3]]

  [Python]

      >>> from sage.all import *
      >>> QuiverMutationType('E',Integer(6),[Integer(1), Integer(1)])
      ['E', 6, [1, 1]]
      >>> QuiverMutationType('F',Integer(4),[Integer(2), Integer(1)])
      ['F', 4, [1, 2]]
      >>> QuiverMutationType('G', Integer(2),[Integer(3),Integer(3)])
      ['G', 2, [3, 3]]

  Mutation finite types:

  Rank 2 cases:

  Sage

      sage: QuiverMutationType('R2',(1, 1))
      ['A', 2]
      sage: QuiverMutationType('R2',(1, 2))
      ['B', 2]
      sage: QuiverMutationType('R2',(1,3))
      ['G', 2]
      sage: QuiverMutationType('R2',(1,4))
      ['BC', 1, 1]
      sage: QuiverMutationType('R2',(1,5))
      ['R2', [1, 5]]
      sage: QuiverMutationType('R2',(2, 2))
      ['A', [1, 1], 1]
      sage: QuiverMutationType('R2',(3,5))
      ['R2', [3, 5]]

  Python

      >>> from sage.all import *
      >>> QuiverMutationType('R2',(Integer(1), Integer(1)))
      ['A', 2]
      >>> QuiverMutationType('R2',(Integer(1), Integer(2)))
      ['B', 2]
      >>> QuiverMutationType('R2',(Integer(1),Integer(3)))
      ['G', 2]
      >>> QuiverMutationType('R2',(Integer(1),Integer(4)))
      ['BC', 1, 1]
      >>> QuiverMutationType('R2',(Integer(1),Integer(5)))
      ['R2', [1, 5]]
      >>> QuiverMutationType('R2',(Integer(2), Integer(2)))
      ['A', [1, 1], 1]
      >>> QuiverMutationType('R2',(Integer(3),Integer(5)))
      ['R2', [3, 5]]

  Exceptional Derksen-Owen quivers:

  Sage

      sage: QuiverMutationType('X',6)
      ['X', 6]

  [Python]

      >>> from sage.all import *
      >>> QuiverMutationType('X',Integer(6))
      ['X', 6]

  (Mainly) mutation infinite types:

  Infinite type E:

  Sage

      sage: QuiverMutationType('E',9)
      ['E', 8, 1]
      sage: QuiverMutationType('E', 10)
      ['E', 10]
      sage: QuiverMutationType('E', 12)
      ['E', 12]

      sage: QuiverMutationType('AE',(2,3))
      ['AE', [2, 3]]
      sage: QuiverMutationType('BE',5)
      ['BE', 5]
      sage: QuiverMutationType('CE',5)
      ['CE', 5]
      sage: QuiverMutationType('DE',6)
      ['DE', 6]

  Python

      >>> from sage.all import *
      >>> QuiverMutationType('E',Integer(9))
      ['E', 8, 1]
      >>> QuiverMutationType('E', Integer(10))
      ['E', 10]
      >>> QuiverMutationType('E', Integer(12))
      ['E', 12]

      >>> QuiverMutationType('AE',(Integer(2),Integer(3)))
      ['AE', [2, 3]]
      >>> QuiverMutationType('BE',Integer(5))
      ['BE', 5]
      >>> QuiverMutationType('CE',Integer(5))
      ['CE', 5]
      >>> QuiverMutationType('DE',Integer(6))
      ['DE', 6]

  Grassmannian types:

  Sage

      sage: QuiverMutationType('GR',(2,4))
      ['A', 1]
      sage: QuiverMutationType('GR',(2,6))
      ['A', 3]
      sage: QuiverMutationType('GR',(3,6))
      ['D', 4]
      sage: QuiverMutationType('GR',(3,7))
      ['E', 6]
      sage: QuiverMutationType('GR',(3,8))
      ['E', 8]
      sage: QuiverMutationType('GR',(3, 10))
      ['GR', [3, 10]]

  [Python]

      >>> from sage.all import *
      >>> QuiverMutationType('GR',(Integer(2),Integer(4)))
      ['A', 1]
      >>> QuiverMutationType('GR',(Integer(2),Integer(6)))
      ['A', 3]
      >>> QuiverMutationType('GR',(Integer(3),Integer(6)))
      ['D', 4]
      >>> QuiverMutationType('GR',(Integer(3),Integer(7)))
      ['E', 6]
      >>> QuiverMutationType('GR',(Integer(3),Integer(8)))
      ['E', 8]
      >>> QuiverMutationType('GR',(Integer(3), Integer(10)))
      ['GR', [3, 10]]

  Triangular types:

  Sage

      sage: QuiverMutationType('TR', 2)
      ['A', 3]
      sage: QuiverMutationType('TR',3)
      ['D', 6]
      sage: QuiverMutationType('TR',4)
      ['E', 8, [1, 1]]
      sage: QuiverMutationType('TR',5)
      ['TR', 5]

  Python

      >>> from sage.all import *
      >>> QuiverMutationType('TR', Integer(2))
      ['A', 3]
      >>> QuiverMutationType('TR',Integer(3))
      ['D', 6]
      >>> QuiverMutationType('TR',Integer(4))
      ['E', 8, [1, 1]]
      >>> QuiverMutationType('TR',Integer(5))
      ['TR', 5]

  T types:

  Sage

      sage: QuiverMutationType('T',(1, 1, 1))
      ['A', 1]
      sage: QuiverMutationType('T',(1, 1,4))
      ['A', 4]
      sage: QuiverMutationType('T',(1,4,4))
      ['A', 7]
      sage: QuiverMutationType('T',(2, 2, 2))
      ['D', 4]
      sage: QuiverMutationType('T',(2, 2,4))
      ['D', 6]
      sage: QuiverMutationType('T',(2,3,3))
      ['E', 6]
      sage: QuiverMutationType('T',(2,3,4))
      ['E', 7]
      sage: QuiverMutationType('T',(2,3,5))
      ['E', 8]
      sage: QuiverMutationType('T',(2,3,6))
      ['E', 8, 1]
      sage: QuiverMutationType('T',(2,3,7))
      ['E', 10]
      sage: QuiverMutationType('T',(3,3,3))
      ['E', 6, 1]
      sage: QuiverMutationType('T',(3,3,4))
      ['T', [3, 3, 4]]

  [Python]

      >>> from sage.all import *
      >>> QuiverMutationType('T',(Integer(1), Integer(1), Integer(1)))
      ['A', 1]
      >>> QuiverMutationType('T',(Integer(1), Integer(1),Integer(4)))
      ['A', 4]
      >>> QuiverMutationType('T',(Integer(1),Integer(4),Integer(4)))
      ['A', 7]
      >>> QuiverMutationType('T',(Integer(2), Integer(2), Integer(2)))
      ['D', 4]
      >>> QuiverMutationType('T',(Integer(2), Integer(2),Integer(4)))
      ['D', 6]
      >>> QuiverMutationType('T',(Integer(2),Integer(3),Integer(3)))
      ['E', 6]
      >>> QuiverMutationType('T',(Integer(2),Integer(3),Integer(4)))
      ['E', 7]
      >>> QuiverMutationType('T',(Integer(2),Integer(3),Integer(5)))
      ['E', 8]
      >>> QuiverMutationType('T',(Integer(2),Integer(3),Integer(6)))
      ['E', 8, 1]
      >>> QuiverMutationType('T',(Integer(2),Integer(3),Integer(7)))
      ['E', 10]
      >>> QuiverMutationType('T',(Integer(3),Integer(3),Integer(3)))
      ['E', 6, 1]
      >>> QuiverMutationType('T',(Integer(3),Integer(3),Integer(4)))
      ['T', [3, 3, 4]]

  Reducible types:

  Sage

      sage: QuiverMutationType(['A',3],['B',4])
      [ ['A', 3], ['B', 4] ]

  Python

      >>> from sage.all import *
      >>> QuiverMutationType(['A',Integer(3)],['B',Integer(4)])
      [ ['A', 3], ['B', 4] ]

class sage.combinat.cluster_algebra_quiver.quiver_mutation_type.QuiverMutationTypeFactory

  Bases: `SageObject`

  samples(finite=None, affine=None, elliptic=None, mutation_finite=None)

    Return a sample of the available quiver mutations types.

    INPUT:

    - `finite`

    - `affine`

    - `elliptic`

    - `mutation_finite`

    All four input keywords default values are `None`. If set to `True` or `False`, only these samples are returned.

    EXAMPLES:

    Sage

        sage: QuiverMutationType.samples()
        [['A', 1], ['A', 5], ['B', 2], ['B', 5], ['C', 3],
         ['C', 5], [ ['A', 1], ['A', 1] ], ['D', 5], ['E', 6],
         ['E', 7], ['E', 8], ['F', 4], ['G', 2],
         ['A', [1, 1], 1], ['A', [4, 5], 1], ['D', 4, 1],
         ['BB', 5, 1], ['E', 6, [1, 1]], ['E', 7, [1, 1]],
         ['R2', [1, 5]], ['R2', [3, 5]], ['E', 10], ['BE', 5],
         ['GR', [3, 10]], ['T', [3, 3, 4]]]

        sage: QuiverMutationType.samples(finite=True)
        [['A', 1], ['A', 5], ['B', 2], ['B', 5], ['C', 3],
         ['C', 5], [ ['A', 1], ['A', 1] ], ['D', 5], ['E', 6],
         ['E', 7], ['E', 8], ['F', 4], ['G', 2]]

        sage: QuiverMutationType.samples(affine=True)
        [['A', [1, 1], 1], ['A', [4, 5], 1], ['D', 4, 1], ['BB', 5, 1]]

        sage: QuiverMutationType.samples(elliptic=True)
        [['E', 6, [1, 1]], ['E', 7, [1, 1]]]

        sage: QuiverMutationType.samples(mutation_finite=False)
        [['R2', [1, 5]], ['R2', [3, 5]], ['E', 10], ['BE', 5],
         ['GR', [3, 10]], ['T', [3, 3, 4]]]

    Python

        >>> from sage.all import *
        >>> QuiverMutationType.samples()
        [['A', 1], ['A', 5], ['B', 2], ['B', 5], ['C', 3],
         ['C', 5], [ ['A', 1], ['A', 1] ], ['D', 5], ['E', 6],
         ['E', 7], ['E', 8], ['F', 4], ['G', 2],
         ['A', [1, 1], 1], ['A', [4, 5], 1], ['D', 4, 1],
         ['BB', 5, 1], ['E', 6, [1, 1]], ['E', 7, [1, 1]],
         ['R2', [1, 5]], ['R2', [3, 5]], ['E', 10], ['BE', 5],
         ['GR', [3, 10]], ['T', [3, 3, 4]]]

        >>> QuiverMutationType.samples(finite=True)
        [['A', 1], ['A', 5], ['B', 2], ['B', 5], ['C', 3],
         ['C', 5], [ ['A', 1], ['A', 1] ], ['D', 5], ['E', 6],
         ['E', 7], ['E', 8], ['F', 4], ['G', 2]]

        >>> QuiverMutationType.samples(affine=True)
        [['A', [1, 1], 1], ['A', [4, 5], 1], ['D', 4, 1], ['BB', 5, 1]]

        >>> QuiverMutationType.samples(elliptic=True)
        [['E', 6, [1, 1]], ['E', 7, [1, 1]]]

        >>> QuiverMutationType.samples(mutation_finite=False)
        [['R2', [1, 5]], ['R2', [3, 5]], ['E', 10], ['BE', 5],
         ['GR', [3, 10]], ['T', [3, 3, 4]]]

class sage.combinat.cluster_algebra_quiver.quiver_mutation_type.QuiverMutationType_Irreducible(letter, rank, twist=None)

  Bases: `QuiverMutationType_abstract`

  The mutation type for a cluster algebra or a quiver. Should not be called directly, but through `QuiverMutationType`.

  class_size()

    If it is known, the size of the mutation class of all quivers which are mutation equivalent to the standard quiver of `self` (up to isomorphism) is returned.

    Otherwise, `NotImplemented` is returned.

    Formula for finite type A is taken from Torkildsen - Counting cluster-tilted algebras of type \(A_n\). Formulas for affine type A and finite type D are taken from Bastian, Prellberg, Rubey, Stump - Counting the number of elements in the mutation classes of \(\widetilde A_n\) quivers. Formulas for finite and affine types B and C are proven but not yet published. Conjectural formulas for several other non-simply-laced affine types are implemented. Exceptional Types (finite, affine, and elliptic) E, F, G, and X are hardcoded.

    EXAMPLES:

    Sage

        sage: mut_type = QuiverMutationType( ['A',5] ); mut_type
        ['A', 5]
        sage: mut_type.class_size()
        19

        sage: mut_type = QuiverMutationType( ['A',[10,3], 1] ); mut_type
        ['A', [3, 10], 1]
        sage: mut_type.class_size()
        142120

        sage: mut_type = QuiverMutationType( ['B',6] ); mut_type
        ['B', 6]
        sage: mut_type.class_size()
        132

        sage: mut_type = QuiverMutationType( ['BD',6, 1] ); mut_type
        ['BD', 6, 1]
        sage: mut_type.class_size()
        Warning: This method uses a formula which has not been proved correct.
        504

    Python

        >>> from sage.all import *
        >>> mut_type = QuiverMutationType( ['A',Integer(5)] ); mut_type
        ['A', 5]
        >>> mut_type.class_size()
        19

        >>> mut_type = QuiverMutationType( ['A',[Integer(10),Integer(3)], Integer(1)] ); mut_type
        ['A', [3, 10], 1]
        >>> mut_type.class_size()
        142120

        >>> mut_type = QuiverMutationType( ['B',Integer(6)] ); mut_type
        ['B', 6]
        >>> mut_type.class_size()
        132

        >>> mut_type = QuiverMutationType( ['BD',Integer(6), Integer(1)] ); mut_type
        ['BD', 6, 1]
        >>> mut_type.class_size()
        Warning: This method uses a formula which has not been proved correct.
        504

    Check that Issue #14048 is fixed:

    Sage

        sage: mut_type = QuiverMutationType( ['F',4,(2, 1)] )
        sage: mut_type.class_size()
        90

    [Python]

        >>> from sage.all import *
        >>> mut_type = QuiverMutationType( ['F',Integer(4),(Integer(2), Integer(1))] )
        >>> mut_type.class_size()
        90

  dual()

    Return the `QuiverMutationType` which is dual to `self`.

    EXAMPLES:

    Sage

        sage: mut_type = QuiverMutationType('A',5); mut_type
        ['A', 5]
        sage: mut_type.dual()
        ['A', 5]

        sage: mut_type = QuiverMutationType('B',5); mut_type
        ['B', 5]
        sage: mut_type.dual()
        ['C', 5]
        sage: mut_type.dual().dual()
        ['B', 5]
        sage: mut_type.dual().dual() == mut_type
        True

    Python

        >>> from sage.all import *
        >>> mut_type = QuiverMutationType('A',Integer(5)); mut_type
        ['A', 5]
        >>> mut_type.dual()
        ['A', 5]

        >>> mut_type = QuiverMutationType('B',Integer(5)); mut_type
        ['B', 5]
        >>> mut_type.dual()
        ['C', 5]
        >>> mut_type.dual().dual()
        ['B', 5]
        >>> mut_type.dual().dual() == mut_type
        True

  irreducible_components()

    Return a list of all irreducible components of `self`.

    EXAMPLES:

    Sage

        sage: mut_type = QuiverMutationType('A',3); mut_type
        ['A', 3]
        sage: mut_type.irreducible_components()
        (['A', 3],)

    Python

        >>> from sage.all import *
        >>> mut_type = QuiverMutationType('A',Integer(3)); mut_type
        ['A', 3]
        >>> mut_type.irreducible_components()
        (['A', 3],)

class sage.combinat.cluster_algebra_quiver.quiver_mutation_type.QuiverMutationType_Reducible(*args)

  Bases: `QuiverMutationType_abstract`

  The mutation type for a cluster algebra or a quiver. Should not be called directly, but through `QuiverMutationType`. Inherits from `QuiverMutationType_abstract`.

  class_size()

    If it is known, the size of the mutation class of all quivers which are mutation equivalent to the standard quiver of `self` (up to isomorphism) is returned.

    Otherwise, `NotImplemented` is returned.

    EXAMPLES:

    Sage

        sage: mut_type = QuiverMutationType(['A',3],['B',3]); mut_type
        [ ['A', 3], ['B', 3] ]
        sage: mut_type.class_size()
        20

        sage: mut_type = QuiverMutationType(['A',3],['B',3],['X',6])
        sage: mut_type
        [ ['A', 3], ['B', 3], ['X', 6] ]
        sage: mut_type.class_size()
        100

    Python

        >>> from sage.all import *
        >>> mut_type = QuiverMutationType(['A',Integer(3)],['B',Integer(3)]); mut_type
        [ ['A', 3], ['B', 3] ]
        >>> mut_type.class_size()
        20

        >>> mut_type = QuiverMutationType(['A',Integer(3)],['B',Integer(3)],['X',Integer(6)])
        >>> mut_type
        [ ['A', 3], ['B', 3], ['X', 6] ]
        >>> mut_type.class_size()
        100

  dual()

    Return the `QuiverMutationType` which is dual to `self`.

    EXAMPLES:

    Sage

        sage: mut_type = QuiverMutationType(['A',5],['B',6],['C',5],['D',4]); mut_type
        [ ['A', 5], ['B', 6], ['C', 5], ['D', 4] ]
        sage: mut_type.dual()
        [ ['A', 5], ['C', 6], ['B', 5], ['D', 4] ]

    Python

        >>> from sage.all import *
        >>> mut_type = QuiverMutationType(['A',Integer(5)],['B',Integer(6)],['C',Integer(5)],['D',Integer(4)]); mut_type
        [ ['A', 5], ['B', 6], ['C', 5], ['D', 4] ]
        >>> mut_type.dual()
        [ ['A', 5], ['C', 6], ['B', 5], ['D', 4] ]

  irreducible_components()

    Return a list of all irreducible components of `self`.

    EXAMPLES:

    Sage

        sage: mut_type = QuiverMutationType('A',3); mut_type
        ['A', 3]
        sage: mut_type.irreducible_components()
        (['A', 3],)

        sage: mut_type = QuiverMutationType(['A',3],['B',3]); mut_type
        [ ['A', 3], ['B', 3] ]
        sage: mut_type.irreducible_components()
        (['A', 3], ['B', 3])

        sage: mut_type = QuiverMutationType(['A',3],['B',3],['X',6])
        sage: mut_type
        [ ['A', 3], ['B', 3], ['X', 6] ]
        sage: mut_type.irreducible_components()
        (['A', 3], ['B', 3], ['X', 6])

    Python

        >>> from sage.all import *
        >>> mut_type = QuiverMutationType('A',Integer(3)); mut_type
        ['A', 3]
        >>> mut_type.irreducible_components()
        (['A', 3],)

        >>> mut_type = QuiverMutationType(['A',Integer(3)],['B',Integer(3)]); mut_type
        [ ['A', 3], ['B', 3] ]
        >>> mut_type.irreducible_components()
        (['A', 3], ['B', 3])

        >>> mut_type = QuiverMutationType(['A',Integer(3)],['B',Integer(3)],['X',Integer(6)])
        >>> mut_type
        [ ['A', 3], ['B', 3], ['X', 6] ]
        >>> mut_type.irreducible_components()
        (['A', 3], ['B', 3], ['X', 6])

class sage.combinat.cluster_algebra_quiver.quiver_mutation_type.QuiverMutationType_abstract

  Bases: `UniqueRepresentation`, `SageObject`

  EXAMPLES:

  Sage

      sage: mut_type1 = QuiverMutationType('A',5)
      sage: mut_type2 = QuiverMutationType('A',5)
      sage: mut_type3 = QuiverMutationType('A',6)
      sage: mut_type1 == mut_type2
      True
      sage: mut_type1 == mut_type3
      False

  Python

      >>> from sage.all import *
      >>> mut_type1 = QuiverMutationType('A',Integer(5))
      >>> mut_type2 = QuiverMutationType('A',Integer(5))
      >>> mut_type3 = QuiverMutationType('A',Integer(6))
      >>> mut_type1 == mut_type2
      True
      >>> mut_type1 == mut_type3
      False

  b_matrix()

    Return the B-matrix of the standard quiver of `self`.

    The conventions for B-matrices agree with Fomin-Zelevinsky (up to a reordering of the simple roots).

    EXAMPLES:

    Sage

        sage: mut_type = QuiverMutationType(['A',5]); mut_type
        ['A', 5]
        sage: mut_type.b_matrix()                                                   # needs sage.modules
        [ 0  1  0  0  0]
        [-1  0 -1  0  0]
        [ 0  1  0  1  0]
        [ 0  0 -1  0 -1]
        [ 0  0  0  1  0]

        sage: mut_type = QuiverMutationType(['A',3],['B',3]); mut_type
        [ ['A', 3], ['B', 3] ]
        sage: mut_type.b_matrix()                                                   # needs sage.modules
        [ 0  1  0  0  0  0]
        [-1  0 -1  0  0  0]
        [ 0  1  0  0  0  0]
        [ 0  0  0  0  1  0]
        [ 0  0  0 -1  0 -1]
        [ 0  0  0  0  2  0]

    Python

        >>> from sage.all import *
        >>> mut_type = QuiverMutationType(['A',Integer(5)]); mut_type
        ['A', 5]
        >>> mut_type.b_matrix()                                                   # needs sage.modules
        [ 0  1  0  0  0]
        [-1  0 -1  0  0]
        [ 0  1  0  1  0]
        [ 0  0 -1  0 -1]
        [ 0  0  0  1  0]

        >>> mut_type = QuiverMutationType(['A',Integer(3)],['B',Integer(3)]); mut_type
        [ ['A', 3], ['B', 3] ]
        >>> mut_type.b_matrix()                                                   # needs sage.modules
        [ 0  1  0  0  0  0]
        [-1  0 -1  0  0  0]
        [ 0  1  0  0  0  0]
        [ 0  0  0  0  1  0]
        [ 0  0  0 -1  0 -1]
        [ 0  0  0  0  2  0]

  cartan_matrix()

    Return the Cartan matrix of `self`.

    Note that (up to a reordering of the simple roots) the convention for the definition of Cartan matrix, used here and elsewhere in Sage, agrees with the conventions of Kac, Fulton-Harris, and Fomin-Zelevinsky, but disagrees with the convention of Bourbaki. The \((i,j)\) entry is \(2(\alpha_i,\alpha_j)/(\alpha_i,\alpha_i)\).

    EXAMPLES:

    Sage

        sage: mut_type = QuiverMutationType(['A',5]); mut_type
        ['A', 5]
        sage: mut_type.cartan_matrix()                                              # needs sage.modules
        [ 2 -1  0  0  0]
        [-1  2 -1  0  0]
        [ 0 -1  2 -1  0]
        [ 0  0 -1  2 -1]
        [ 0  0  0 -1  2]

        sage: mut_type = QuiverMutationType(['A',3],['B',3]); mut_type
        [ ['A', 3], ['B', 3] ]
        sage: mut_type.cartan_matrix()                                              # needs sage.modules
        [ 2 -1  0  0  0  0]
        [-1  2 -1  0  0  0]
        [ 0 -1  2  0  0  0]
        [ 0  0  0  2 -1  0]
        [ 0  0  0 -1  2 -1]
        [ 0  0  0  0 -2  2]

    Python

        >>> from sage.all import *
        >>> mut_type = QuiverMutationType(['A',Integer(5)]); mut_type
        ['A', 5]
        >>> mut_type.cartan_matrix()                                              # needs sage.modules
        [ 2 -1  0  0  0]
        [-1  2 -1  0  0]
        [ 0 -1  2 -1  0]
        [ 0  0 -1  2 -1]
        [ 0  0  0 -1  2]

        >>> mut_type = QuiverMutationType(['A',Integer(3)],['B',Integer(3)]); mut_type
        [ ['A', 3], ['B', 3] ]
        >>> mut_type.cartan_matrix()                                              # needs sage.modules
        [ 2 -1  0  0  0  0]
        [-1  2 -1  0  0  0]
        [ 0 -1  2  0  0  0]
        [ 0  0  0  2 -1  0]
        [ 0  0  0 -1  2 -1]
        [ 0  0  0  0 -2  2]

  is_affine()

    Return `True` if `self` is of affine type.

    EXAMPLES:

    Sage

        sage: mt = QuiverMutationType(['A', 2])
        sage: mt.is_affine()
        False

        sage: mt = QuiverMutationType(['A',[4, 2], 1])
        sage: mt.is_affine()
        True

    Python

        >>> from sage.all import *
        >>> mt = QuiverMutationType(['A', Integer(2)])
        >>> mt.is_affine()
        False

        >>> mt = QuiverMutationType(['A',[Integer(4), Integer(2)], Integer(1)])
        >>> mt.is_affine()
        True

  is_elliptic()

    Return `True` if `self` is of elliptic type.

    EXAMPLES:

    Sage

        sage: mt = QuiverMutationType(['A', 2])
        sage: mt.is_elliptic()
        False

        sage: mt = QuiverMutationType(['E',6,[1, 1]])
        sage: mt.is_elliptic()
        True

    Python

        >>> from sage.all import *
        >>> mt = QuiverMutationType(['A', Integer(2)])
        >>> mt.is_elliptic()
        False

        >>> mt = QuiverMutationType(['E',Integer(6),[Integer(1), Integer(1)]])
        >>> mt.is_elliptic()
        True

  is_finite()

    Return `True` if `self` is of finite type.

    This means that the cluster algebra associated to `self` has only a finite number of cluster variables.

    EXAMPLES:

    Sage

        sage: mt = QuiverMutationType(['A', 2])
        sage: mt.is_finite()
        True

        sage: mt = QuiverMutationType(['A',[4, 2], 1])
        sage: mt.is_finite()
        False

    Python

        >>> from sage.all import *
        >>> mt = QuiverMutationType(['A', Integer(2)])
        >>> mt.is_finite()
        True

        >>> mt = QuiverMutationType(['A',[Integer(4), Integer(2)], Integer(1)])
        >>> mt.is_finite()
        False

  is_irreducible()

    Return `True` if `self` is irreducible.

    EXAMPLES:

    Sage

        sage: mt = QuiverMutationType(['A', 2])
        sage: mt.is_irreducible()
        True

    Python

        >>> from sage.all import *
        >>> mt = QuiverMutationType(['A', Integer(2)])
        >>> mt.is_irreducible()
        True

  is_mutation_finite()

    Return `True` if `self` is of finite mutation type.

    This means that its mutation class has only finitely many different B-matrices.

    EXAMPLES:

    Sage

        sage: mt = QuiverMutationType(['D',5, 1])
        sage: mt.is_mutation_finite()
        True

    Python

        >>> from sage.all import *
        >>> mt = QuiverMutationType(['D',Integer(5), Integer(1)])
        >>> mt.is_mutation_finite()
        True

  is_simply_laced()

    Return `True` if `self` is simply laced.

    This means that the only arrows that appear in the quiver of `self` are single unlabelled arrows.

    EXAMPLES:

    Sage

        sage: mt = QuiverMutationType(['A', 2])
        sage: mt.is_simply_laced()
        True

        sage: mt = QuiverMutationType(['B', 2])
        sage: mt.is_simply_laced()
        False

        sage: mt = QuiverMutationType(['A',(1, 1), 1])
        sage: mt.is_simply_laced()
        False

    Python

        >>> from sage.all import *
        >>> mt = QuiverMutationType(['A', Integer(2)])
        >>> mt.is_simply_laced()
        True

        >>> mt = QuiverMutationType(['B', Integer(2)])
        >>> mt.is_simply_laced()
        False

        >>> mt = QuiverMutationType(['A',(Integer(1), Integer(1)), Integer(1)])
        >>> mt.is_simply_laced()
        False

  is_skew_symmetric()

    Return `True` if the B-matrix of `self` is skew-symmetric.

    EXAMPLES:

    Sage

        sage: mt = QuiverMutationType(['A', 2])
        sage: mt.is_skew_symmetric()
        True

        sage: mt = QuiverMutationType(['B', 2])
        sage: mt.is_skew_symmetric()
        False

        sage: mt = QuiverMutationType(['A',(1, 1), 1])
        sage: mt.is_skew_symmetric()
        True

    Python

        >>> from sage.all import *
        >>> mt = QuiverMutationType(['A', Integer(2)])
        >>> mt.is_skew_symmetric()
        True

        >>> mt = QuiverMutationType(['B', Integer(2)])
        >>> mt.is_skew_symmetric()
        False

        >>> mt = QuiverMutationType(['A',(Integer(1), Integer(1)), Integer(1)])
        >>> mt.is_skew_symmetric()
        True

  letter()

    Return the classification letter of `self`.

    EXAMPLES:

    Sage

        sage: mut_type = QuiverMutationType( ['A',5] ); mut_type
        ['A', 5]
        sage: mut_type.letter()
        'A'

        sage: mut_type = QuiverMutationType( ['BC',5, 1] ); mut_type
        ['BC', 5, 1]
        sage: mut_type.letter()
        'BC'

        sage: mut_type = QuiverMutationType(['A',3],['B',3]); mut_type
        [ ['A', 3], ['B', 3] ]
        sage: mut_type.letter()
        'A x B'

        sage: mut_type = QuiverMutationType(['A',3],['B',3],['X',6]); mut_type
        [ ['A', 3], ['B', 3], ['X', 6] ]
        sage: mut_type.letter()
        'A x B x X'

    Python

        >>> from sage.all import *
        >>> mut_type = QuiverMutationType( ['A',Integer(5)] ); mut_type
        ['A', 5]
        >>> mut_type.letter()
        'A'

        >>> mut_type = QuiverMutationType( ['BC',Integer(5), Integer(1)] ); mut_type
        ['BC', 5, 1]
        >>> mut_type.letter()
        'BC'

        >>> mut_type = QuiverMutationType(['A',Integer(3)],['B',Integer(3)]); mut_type
        [ ['A', 3], ['B', 3] ]
        >>> mut_type.letter()
        'A x B'

        >>> mut_type = QuiverMutationType(['A',Integer(3)],['B',Integer(3)],['X',Integer(6)]); mut_type
        [ ['A', 3], ['B', 3], ['X', 6] ]
        >>> mut_type.letter()
        'A x B x X'

  plot(circular=False, directed=True)

    Return the plot of the underlying graph or digraph of `self`.

    INPUT:

    - `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

    EXAMPLES:

    Sage

        sage: QMT = QuiverMutationType(['A',5])
        sage: pl = QMT.plot()                                                       # needs sage.plot sage.symbolic
        sage: pl = QMT.plot(circular=True)                                          # needs sage.plot sage.symbolic

    Python

        >>> from sage.all import *
        >>> QMT = QuiverMutationType(['A',Integer(5)])
        >>> pl = QMT.plot()                                                       # needs sage.plot sage.symbolic
        >>> pl = QMT.plot(circular=True)                                          # needs sage.plot sage.symbolic

  properties()

    Print a scheme of all properties of `self`.

    Most properties have natural definitions for either irreducible or reducible types. `affine` and `elliptic` are only defined for irreducible types.

    EXAMPLES:

    Sage

        sage: mut_type = QuiverMutationType(['A',3]); mut_type
        ['A', 3]
        sage: mut_type.properties()
        ['A', 3] has rank 3 and the following properties:
            - irreducible:       True
            - mutation finite:   True
            - simply-laced:      True
            - skew-symmetric:    True
            - finite:            True
            - affine:            False
            - elliptic:          False

        sage: mut_type = QuiverMutationType(['B',3]); mut_type
        ['B', 3]
        sage: mut_type.properties()
        ['B', 3] has rank 3 and the following properties:
            - irreducible:       True
            - mutation finite:   True
            - simply-laced:      False
            - skew-symmetric:    False
            - finite:            True
            - affine:            False
            - elliptic:          False

        sage: mut_type = QuiverMutationType(['B',3, 1]); mut_type
        ['BD', 3, 1]
        sage: mut_type.properties()
        ['BD', 3, 1] has rank 4 and the following properties:
            - irreducible:       True
            - mutation finite:   True
            - simply-laced:      False
            - skew-symmetric:    False
            - finite:            False
            - affine:            True
            - elliptic:          False

        sage: mut_type = QuiverMutationType(['E',6,[1, 1]]); mut_type
        ['E', 6, [1, 1]]
        sage: mut_type.properties()
        ['E', 6, [1, 1]] has rank 8 and the following properties:
            - irreducible:       True
            - mutation finite:   True
            - simply-laced:      False
            - skew-symmetric:    True
            - finite:            False
            - affine:            False
            - elliptic:          True

        sage: mut_type = QuiverMutationType(['A',3],['B',3]); mut_type
        [ ['A', 3], ['B', 3] ]
        sage: mut_type.properties()
        [ ['A', 3], ['B', 3] ] has rank 6 and the following properties:
            - irreducible:       False
            - mutation finite:   True
            - simply-laced:      False
            - skew-symmetric:    False
            - finite:            True

        sage: mut_type = QuiverMutationType('GR',[4,9]); mut_type
        ['GR', [4, 9]]
        sage: mut_type.properties()
        ['GR', [4, 9]] has rank 12 and the following properties:
            - irreducible:       True
            - mutation finite:   False
            - simply-laced:      True
            - skew-symmetric:    True
            - finite:            False
            - affine:            False
            - elliptic:          False

    Python

        >>> from sage.all import *
        >>> mut_type = QuiverMutationType(['A',Integer(3)]); mut_type
        ['A', 3]
        >>> mut_type.properties()
        ['A', 3] has rank 3 and the following properties:
            - irreducible:       True
            - mutation finite:   True
            - simply-laced:      True
            - skew-symmetric:    True
            - finite:            True
            - affine:            False
            - elliptic:          False

        >>> mut_type = QuiverMutationType(['B',Integer(3)]); mut_type
        ['B', 3]
        >>> mut_type.properties()
        ['B', 3] has rank 3 and the following properties:
            - irreducible:       True
            - mutation finite:   True
            - simply-laced:      False
            - skew-symmetric:    False
            - finite:            True
            - affine:            False
            - elliptic:          False

        >>> mut_type = QuiverMutationType(['B',Integer(3), Integer(1)]); mut_type
        ['BD', 3, 1]
        >>> mut_type.properties()
        ['BD', 3, 1] has rank 4 and the following properties:
            - irreducible:       True
            - mutation finite:   True
            - simply-laced:      False
            - skew-symmetric:    False
            - finite:            False
            - affine:            True
            - elliptic:          False

        >>> mut_type = QuiverMutationType(['E',Integer(6),[Integer(1), Integer(1)]]); mut_type
        ['E', 6, [1, 1]]
        >>> mut_type.properties()
        ['E', 6, [1, 1]] has rank 8 and the following properties:
            - irreducible:       True
            - mutation finite:   True
            - simply-laced:      False
            - skew-symmetric:    True
            - finite:            False
            - affine:            False
            - elliptic:          True

        >>> mut_type = QuiverMutationType(['A',Integer(3)],['B',Integer(3)]); mut_type
        [ ['A', 3], ['B', 3] ]
        >>> mut_type.properties()
        [ ['A', 3], ['B', 3] ] has rank 6 and the following properties:
            - irreducible:       False
            - mutation finite:   True
            - simply-laced:      False
            - skew-symmetric:    False
            - finite:            True

        >>> mut_type = QuiverMutationType('GR',[Integer(4),Integer(9)]); mut_type
        ['GR', [4, 9]]
        >>> mut_type.properties()
        ['GR', [4, 9]] has rank 12 and the following properties:
            - irreducible:       True
            - mutation finite:   False
            - simply-laced:      True
            - skew-symmetric:    True
            - finite:            False
            - affine:            False
            - elliptic:          False

  rank()

    Return the rank in the standard quiver of `self`.

    The rank is the number of vertices.

    EXAMPLES:

    Sage

        sage: mut_type = QuiverMutationType( ['A',5] ); mut_type
        ['A', 5]
        sage: mut_type.rank()
        5

        sage: mut_type = QuiverMutationType( ['A',[4,5], 1] ); mut_type
        ['A', [4, 5], 1]
        sage: mut_type.rank()
        9

        sage: mut_type = QuiverMutationType( ['BC',5, 1] ); mut_type
        ['BC', 5, 1]
        sage: mut_type.rank()
        6

        sage: mut_type = QuiverMutationType(['A',3],['B',3]); mut_type
        [ ['A', 3], ['B', 3] ]
        sage: mut_type.rank()
        6

        sage: mut_type = QuiverMutationType(['A',3],['B',3],['X',6]); mut_type
        [ ['A', 3], ['B', 3], ['X', 6] ]
        sage: mut_type.rank()
        12

    Python

        >>> from sage.all import *
        >>> mut_type = QuiverMutationType( ['A',Integer(5)] ); mut_type
        ['A', 5]
        >>> mut_type.rank()
        5

        >>> mut_type = QuiverMutationType( ['A',[Integer(4),Integer(5)], Integer(1)] ); mut_type
        ['A', [4, 5], 1]
        >>> mut_type.rank()
        9

        >>> mut_type = QuiverMutationType( ['BC',Integer(5), Integer(1)] ); mut_type
        ['BC', 5, 1]
        >>> mut_type.rank()
        6

        >>> mut_type = QuiverMutationType(['A',Integer(3)],['B',Integer(3)]); mut_type
        [ ['A', 3], ['B', 3] ]
        >>> mut_type.rank()
        6

        >>> mut_type = QuiverMutationType(['A',Integer(3)],['B',Integer(3)],['X',Integer(6)]); mut_type
        [ ['A', 3], ['B', 3], ['X', 6] ]
        >>> mut_type.rank()
        12

  show(circular=False, directed=True)

    Show the plot of the underlying digraph of `self`.

    INPUT:

    - `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

  standard_quiver()

    Return the standard quiver of `self`.

    EXAMPLES:

    Sage

        sage: mut_type = QuiverMutationType( ['A',5] ); mut_type
        ['A', 5]
        sage: mut_type.standard_quiver()                                            # needs sage.modules
        Quiver on 5 vertices of type ['A', 5]

        sage: mut_type = QuiverMutationType( ['A',[5,3], 1] ); mut_type
        ['A', [3, 5], 1]
        sage: mut_type.standard_quiver()                                            # needs sage.modules
        Quiver on 8 vertices of type ['A', [3, 5], 1]

        sage: mut_type = QuiverMutationType(['A',3],['B',3]); mut_type
        [ ['A', 3], ['B', 3] ]
        sage: mut_type.standard_quiver()                                            # needs sage.modules
        Quiver on 6 vertices of type [ ['A', 3], ['B', 3] ]

        sage: mut_type = QuiverMutationType(['A',3],['B',3],['X',6]); mut_type
        [ ['A', 3], ['B', 3], ['X', 6] ]
        sage: mut_type.standard_quiver()                                            # needs sage.modules
        Quiver on 12 vertices of type [ ['A', 3], ['B', 3], ['X', 6] ]

    Python

        >>> from sage.all import *
        >>> mut_type = QuiverMutationType( ['A',Integer(5)] ); mut_type
        ['A', 5]
        >>> mut_type.standard_quiver()                                            # needs sage.modules
        Quiver on 5 vertices of type ['A', 5]

        >>> mut_type = QuiverMutationType( ['A',[Integer(5),Integer(3)], Integer(1)] ); mut_type
        ['A', [3, 5], 1]
        >>> mut_type.standard_quiver()                                            # needs sage.modules
        Quiver on 8 vertices of type ['A', [3, 5], 1]

        >>> mut_type = QuiverMutationType(['A',Integer(3)],['B',Integer(3)]); mut_type
        [ ['A', 3], ['B', 3] ]
        >>> mut_type.standard_quiver()                                            # needs sage.modules
        Quiver on 6 vertices of type [ ['A', 3], ['B', 3] ]

        >>> mut_type = QuiverMutationType(['A',Integer(3)],['B',Integer(3)],['X',Integer(6)]); mut_type
        [ ['A', 3], ['B', 3], ['X', 6] ]
        >>> mut_type.standard_quiver()                                            # needs sage.modules
        Quiver on 12 vertices of type [ ['A', 3], ['B', 3], ['X', 6] ]

sage.combinat.cluster_algebra_quiver.quiver_mutation_type.save_quiver_data(n, up_to=True, types='ClassicalExceptional', verbose=True)

  Save mutation classes of certain quivers of ranks up to and equal to \(n\) or equal to \(n\) to `DOT_SAGE/cluster_algebra_quiver/mutation_classes_n.dig6`.

  This data will then be used to determine quiver mutation types.

  INPUT:

  - `n` – the rank (or the upper limit on the rank) of the mutation classes that are being saved

  - `up_to` – (default: `True`) if `True`, saves data for ranks smaller than or equal to \(n\); if `False`, saves data for rank exactly \(n\)

  - `types` – (default: `'ClassicalExceptional'`) if all, saves data for both exceptional mutation-finite quivers and for classical quiver; the input ‘Exceptional’ or ‘Classical’ is also allowed to save only part of this data