### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »
- Cluster Algebras and Quivers »

# ClusterSeed

A cluster seed is a pair \((B,\mathbf{x})\) with \(B\) being a skew-symmetrizable \((n+m \times n)\) -matrix and with \(\mathbf{x}\) being an \(n\)-tuple of independent elements in the field of rational functions in \(n\) variables.

For the compendium on the cluster algebra and quiver package see Arxiv 1102.4844.

AUTHORS:

- Gregg Musiker
- Christian Stump

See also

For mutation types of cluster seeds, see `sage.combinat.cluster_algebra_quiver.quiver_mutation_type.QuiverMutationType()`. Cluster seeds are closely related to `sage.combinat.cluster_algebra_quiver.quiver.ClusterQuiver()`.

class `sage.combinat.cluster_algebra_quiver.cluster_seed.``ClusterSeed`(data, frozen=None, is_principal=None)

  Bases: `sage.structure.sage_object.SageObject`

  The cluster seed associated to an exchange matrix.

  INPUT:

  - `data` – can be any of the following:

        * QuiverMutationType
        * str - a string representing a QuiverMutationType or a common quiver type (see Examples)
        * ClusterQuiver
        * Matrix - a skew-symmetrizable matrix
        * DiGraph - must be the input data for a quiver
        * List of edges - must be the edge list of a digraph for a quiver

  EXAMPLES:

      sage: S = ClusterSeed(['A',5]); S
      A seed for a cluster algebra of rank 5 of type ['A', 5]

      sage: S = ClusterSeed(['A',[2,5],1]); S
      A seed for a cluster algebra of rank 7 of type ['A', [2, 5], 1]

      sage: T = ClusterSeed( S ); T
      A seed for a cluster algebra of rank 7 of type ['A', [2, 5], 1]

      sage: T = ClusterSeed( S._M ); T
      A seed for a cluster algebra of rank 7

      sage: T = ClusterSeed( S.quiver()._digraph ); T
      A seed for a cluster algebra of rank 7

      sage: T = ClusterSeed( S.quiver()._digraph.edges() ); T
      A seed for a cluster algebra of rank 7

      sage: S = ClusterSeed(['B',2]); S
      A seed for a cluster algebra of rank 2 of type ['B', 2]

      sage: S = ClusterSeed(['C',2]); S
      A seed for a cluster algebra of rank 2 of type ['B', 2]

      sage: S = ClusterSeed(['A', [5,0],1]); S
      A seed for a cluster algebra of rank 5 of type ['D', 5]

      sage: S = ClusterSeed(['GR',[3,7]]); S
      A seed for a cluster algebra of rank 6 of type ['E', 6]

      sage: S = ClusterSeed(['F', 4, [2,1]]); S
      A seed for a cluster algebra of rank 6 of type ['F', 4, [1, 2]]

  `b_matrix`()

    Returns the \(B\) -matrix of `self`.

    EXAMPLES:

        sage: ClusterSeed(['A',4]).b_matrix()
        [ 0  1  0  0]
        [-1  0 -1  0]
        [ 0  1  0  1]
        [ 0  0 -1  0]

        sage: ClusterSeed(['B',4]).b_matrix()
        [ 0  1  0  0]
        [-1  0 -1  0]
        [ 0  1  0  1]
        [ 0  0 -2  0]

        sage: ClusterSeed(['D',4]).b_matrix()
        [ 0  1  0  0]
        [-1  0 -1 -1]
        [ 0  1  0  0]
        [ 0  1  0  0]

        sage: ClusterSeed(QuiverMutationType([['A',2],['B',2]])).b_matrix()
        [ 0  1  0  0]
        [-1  0  0  0]
        [ 0  0  0  1]
        [ 0  0 -2  0]

  `b_matrix_class`(depth=+Infinity, up_to_equivalence=True)

    Returns all \(B\)-matrices in the mutation class of `self`.

    INPUT:

    - `depth` – (default:infinity) integer or infinity, only seeds with distance at most depth from self are returned
    - `up_to_equivalence` – (default: True) if True, only ‘B’-matrices up to equivalence are considered.

    EXAMPLES:

    - for examples see `b_matrix_class_iter()`

    TESTS:

        sage: A = ClusterSeed(['A',3]).b_matrix_class()
        sage: A = ClusterSeed(['A',[2,1],1]).b_matrix_class()

  `b_matrix_class_iter`(depth=+Infinity, up_to_equivalence=True)

    Returns an iterator through all \(B\)-matrices in the mutation class of `self`.

    INPUT:

    - `depth` – (default:infinity) integer or infinity, only seeds with distance at most depth from self are returned
    - `up_to_equivalence` – (default: True) if True, only ‘B’-matrices up to equivalence are considered.

    EXAMPLES:

    A standard finite type example:

        sage: S = ClusterSeed(['A',4])
        sage: it = S.b_matrix_class_iter()
        sage: for T in it: print T
        [ 0  0  0  1]
        [ 0  0  1  1]
        [ 0 -1  0  0]
        [-1 -1  0  0]
        [ 0  0  0  1]
        [ 0  0  1  0]
        [ 0 -1  0  1]
        [-1  0 -1  0]
        [ 0  0  1  1]
        [ 0  0  0 -1]
        [-1  0  0  0]
        [-1  1  0  0]
        [ 0  0  0  1]
        [ 0  0 -1  1]
        [ 0  1  0 -1]
        [-1 -1  1  0]
        [ 0  0  0  1]
        [ 0  0 -1  0]
        [ 0  1  0 -1]
        [-1  0  1  0]
        [ 0  0  0 -1]
        [ 0  0 -1  1]
        [ 0  1  0 -1]
        [ 1 -1  1  0]

    A finite type example with given depth:

        sage: it = S.b_matrix_class_iter(depth=1)
        sage: for T in it: print T
        [ 0  0  0  1]
        [ 0  0  1  1]
        [ 0 -1  0  0]
        [-1 -1  0  0]
        [ 0  0  0  1]
        [ 0  0  1  0]
        [ 0 -1  0  1]
        [-1  0 -1  0]
        [ 0  0  1  1]
        [ 0  0  0 -1]
        [-1  0  0  0]
        [-1  1  0  0]

    Finite type example not considered up to equivalence:

        sage: S = ClusterSeed(['A',3])
        sage: it = S.b_matrix_class_iter(up_to_equivalence=False)
        sage: for T in it: print T
        [ 0  1  0]
        [-1  0 -1]
        [ 0  1  0]
        [ 0  1  0]
        [-1  0  1]
        [ 0 -1  0]
        [ 0 -1  0]
        [ 1  0  1]
        [ 0 -1  0]
        [ 0 -1  0]
        [ 1  0 -1]
        [ 0  1  0]
        [ 0 -1  1]
        [ 1  0 -1]
        [-1  1  0]
        [ 0  1 -1]
        [-1  0  1]
        [ 1 -1  0]
        [ 0  0  1]
        [ 0  0 -1]
        [-1  1  0]
        [ 0 -1  1]
        [ 1  0  0]
        [-1  0  0]
        [ 0  0 -1]
        [ 0  0  1]
        [ 1 -1  0]
        [ 0  1 -1]
        [-1  0  0]
        [ 1  0  0]
        [ 0  1  1]
        [-1  0  0]
        [-1  0  0]
        [ 0 -1 -1]
        [ 1  0  0]
        [ 1  0  0]
        [ 0  0 -1]
        [ 0  0 -1]
        [ 1  1  0]
        [ 0  0  1]
        [ 0  0  1]
        [-1 -1  0]

    Infinite (but finite mutation) type example:

        sage: S = ClusterSeed(['A',[1,2],1])
        sage: it = S.b_matrix_class_iter()
        sage: for T in it: print T
        [ 0  1  1]
        [-1  0  1]
        [-1 -1  0]
        [ 0 -2  1]
        [ 2  0 -1]
        [-1  1  0]

    Infinite mutation type example:

        sage: S = ClusterSeed(['E',10])
        sage: it = S.b_matrix_class_iter(depth=3)
        sage: len ( [T for T in it] )
        266

  `c_matrix`(ignore_coefficients=False)

    Returns all c-vectors of `self`.

    Requires principal coefficients, initialized by using principal_extension(), or the user can set ‘ignore_coefficients=True’ to bypass this restriction.

    Warning: this method assumes the sign-coherence conjecture and that the input seed is sign-coherent (has an exchange matrix with columns of like signs). Otherwise, computational errors might arise.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3]).principal_extension()
        sage: S.mutate([2,1,2])
        sage: S.c_matrix()
        [ 1  0  0]
        [ 0  0 -1]
        [ 0 -1  0]

  `c_vector`(k, ignore_coefficients=False)

    Returns the `k`-th c-vector of `self`. It is obtained as the `k`-th column vector of the bottom part of the `B`-matrix of `self`.

    Requires principal coefficients, initialized by using principal_extension(), or the user can set ‘ignore_coefficients=True’ to bypass this restriction.

    Warning: this method assumes the sign-coherence conjecture and that the input seed is sign-coherent (has an exchange matrix with columns of like signs). Otherwise, computational errors might arise.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3]).principal_extension()
        sage: S.mutate([2,1,2])
        sage: [ S.c_vector(k) for k in range(3) ]
        [(1, 0, 0), (0, 0, -1), (0, -1, 0)]

        sage: S = ClusterSeed(Matrix([[0,1],[-1,0],[1,0],[-1,1]])); S
        A seed for a cluster algebra of rank 2 with 2 frozen variables
        sage: S.c_vector(0)
        Traceback (most recent call last):
        ...
        ValueError: No principal coefficients initialized. Use principal_extension, or ignore_coefficients to ignore this.
        sage: S.c_vector(0,ignore_coefficients=True)
        (1, -1)

  `cluster`()

    Returns the cluster of `self`.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3])
        sage: S.cluster()
        [x0, x1, x2]

        sage: S.mutate(1)
        sage: S.cluster()
        [x0, (x0*x2 + 1)/x1, x2]

        sage: S.mutate(2)
        sage: S.cluster()
        [x0, (x0*x2 + 1)/x1, (x0*x2 + x1 + 1)/(x1*x2)]

        sage: S.mutate([2,1])
        sage: S.cluster()
        [x0, x1, x2]

  `cluster_class`(depth=+Infinity, show_depth=False, up_to_equivalence=True)

    Returns the cluster class of `self` with respect to certain constraints.

    INPUT:

    - `depth` – (default: infinity) integer, only seeds with distance at most depth from self are returned
    - `return_depth` – (default False) - if True, ignored if depth is set; returns the depth of the mutation class, i.e., the maximal distance from self of an element in the mutation class
    - `up_to_equivalence` – (default: True) if True, only clusters up to equivalence are considered.

    EXAMPLES:

    - for examples see `cluster_class_iter()`

    TESTS:

        sage: A = ClusterSeed(['A',3]).cluster_class()

  `cluster_class_iter`(depth=+Infinity, show_depth=False, up_to_equivalence=True)

    Returns an iterator through all clusters in the mutation class of `self`.

    INPUT:

    - `depth` – (default: infinity) integer or infinity, only seeds with distance at most depth from self are returned
    - `show_depth` – (default False) - if True, ignored if depth is set; returns the depth of the mutation class, i.e., the maximal distance from self of an element in the mutation class
    - `up_to_equivalence` – (default: True) if True, only clusters up to equivalence are considered.

    EXAMPLES:

    A standard finite type example:

        sage: S = ClusterSeed(['A',3])
        sage: it = S.cluster_class_iter()
        sage: for T in it: print T
        [x0, x1, x2]
        [x0, x1, (x1 + 1)/x2]
        [x0, (x0*x2 + 1)/x1, x2]
        [(x1 + 1)/x0, x1, x2]
        [x0, (x0*x2 + x1 + 1)/(x1*x2), (x1 + 1)/x2]
        [(x1 + 1)/x0, x1, (x1 + 1)/x2]
        [(x1 + 1)/x0, (x0*x2 + x1 + 1)/(x0*x1), x2]
        [x0, (x0*x2 + 1)/x1, (x0*x2 + x1 + 1)/(x1*x2)]
        [(x0*x2 + x1 + 1)/(x0*x1), (x0*x2 + 1)/x1, x2]
        [(x1 + 1)/x0, (x1^2 + x0*x2 + 2*x1 + 1)/(x0*x1*x2), (x1 + 1)/x2]
        [(x1 + 1)/x0, (x0*x2 + x1 + 1)/(x0*x1), (x1^2 + x0*x2 + 2*x1 + 1)/(x0*x1*x2)]
        [(x1^2 + x0*x2 + 2*x1 + 1)/(x0*x1*x2), (x0*x2 + x1 + 1)/(x1*x2), (x1 + 1)/x2]
        [(x0*x2 + x1 + 1)/(x0*x1), (x0*x2 + 1)/x1, (x0*x2 + x1 + 1)/(x1*x2)]
        [(x0*x2 + x1 + 1)/(x1*x2), (x0*x2 + x1 + 1)/(x0*x1), (x1^2 + x0*x2 + 2*x1 + 1)/(x0*x1*x2)]

    A finite type example with given depth:

        sage: it = S.cluster_class_iter(depth=1)
        sage: for T in it: print T
        [x0, x1, x2]
        [x0, x1, (x1 + 1)/x2]
        [x0, (x0*x2 + 1)/x1, x2]
        [(x1 + 1)/x0, x1, x2]

    A finite type example where the depth is returned while computing:

        sage: it = S.cluster_class_iter(show_depth=True)
        sage: for T in it: print T
        [x0, x1, x2]
        Depth: 0     found: 1          Time: ... s
        [x0, x1, (x1 + 1)/x2]
        [x0, (x0*x2 + 1)/x1, x2]
        [(x1 + 1)/x0, x1, x2]
        Depth: 1     found: 4          Time: ... s
        [x0, (x0*x2 + x1 + 1)/(x1*x2), (x1 + 1)/x2]
        [(x1 + 1)/x0, x1, (x1 + 1)/x2]
        [(x1 + 1)/x0, (x0*x2 + x1 + 1)/(x0*x1), x2]
        [x0, (x0*x2 + 1)/x1, (x0*x2 + x1 + 1)/(x1*x2)]
        [(x0*x2 + x1 + 1)/(x0*x1), (x0*x2 + 1)/x1, x2]
        Depth: 2     found: 9          Time: ... s
        [(x1 + 1)/x0, (x1^2 + x0*x2 + 2*x1 + 1)/(x0*x1*x2), (x1 + 1)/x2]
        [(x1 + 1)/x0, (x0*x2 + x1 + 1)/(x0*x1), (x1^2 + x0*x2 + 2*x1 + 1)/(x0*x1*x2)]
        [(x1^2 + x0*x2 + 2*x1 + 1)/(x0*x1*x2), (x0*x2 + x1 + 1)/(x1*x2), (x1 + 1)/x2]
        [(x0*x2 + x1 + 1)/(x0*x1), (x0*x2 + 1)/x1, (x0*x2 + x1 + 1)/(x1*x2)]
        Depth: 3     found: 13         Time: ... s
        [(x0*x2 + x1 + 1)/(x1*x2), (x0*x2 + x1 + 1)/(x0*x1), (x1^2 + x0*x2 + 2*x1 + 1)/(x0*x1*x2)]
        Depth: 4     found: 14         Time: ... s

    Finite type examples not considered up to equivalence:

        sage: it = S.cluster_class_iter(up_to_equivalence=False)
        sage: len( [ T for T in it ] )
        84

        sage: it = ClusterSeed(['A',2]).cluster_class_iter(up_to_equivalence=False)
        sage: for T in it: print T
        [x0, x1]
        [x0, (x0 + 1)/x1]
        [(x1 + 1)/x0, x1]
        [(x1 + 1)/x0, (x0 + x1 + 1)/(x0*x1)]
        [(x0 + x1 + 1)/(x0*x1), (x0 + 1)/x1]
        [(x0 + x1 + 1)/(x0*x1), (x1 + 1)/x0]
        [(x0 + 1)/x1, (x0 + x1 + 1)/(x0*x1)]
        [x1, (x1 + 1)/x0]
        [(x0 + 1)/x1, x0]
        [x1, x0]

    Infinite type examples:

        sage: S = ClusterSeed(['A',[1,1],1])
        sage: it = S.cluster_class_iter()
        sage: it.next()
        [x0, x1]
        sage: it.next()
        [x0, (x0^2 + 1)/x1]
        sage: it.next()
        [(x1^2 + 1)/x0, x1]
        sage: it.next()
        [(x0^4 + 2*x0^2 + x1^2 + 1)/(x0*x1^2), (x0^2 + 1)/x1]
        sage: it.next()
        [(x1^2 + 1)/x0, (x1^4 + x0^2 + 2*x1^2 + 1)/(x0^2*x1)]

        sage: it = S.cluster_class_iter(depth=3)
        sage: for T in it: print T
        [x0, x1]
        [x0, (x0^2 + 1)/x1]
        [(x1^2 + 1)/x0, x1]
        [(x0^4 + 2*x0^2 + x1^2 + 1)/(x0*x1^2), (x0^2 + 1)/x1]
        [(x1^2 + 1)/x0, (x1^4 + x0^2 + 2*x1^2 + 1)/(x0^2*x1)]
        [(x0^4 + 2*x0^2 + x1^2 + 1)/(x0*x1^2), (x0^6 + 3*x0^4 + 2*x0^2*x1^2 + x1^4 + 3*x0^2 + 2*x1^2 + 1)/(x0^2*x1^3)]
        [(x1^6 + x0^4 + 2*x0^2*x1^2 + 3*x1^4 + 2*x0^2 + 3*x1^2 + 1)/(x0^3*x1^2), (x1^4 + x0^2 + 2*x1^2 + 1)/(x0^2*x1)]

  `cluster_variable`(k)

    Returns the \(k\)-th cluster variable of `self`.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3])
        sage: S.mutate([1,2])

        sage: [S.cluster_variable(k) for k in range(3)]
        [x0, (x0*x2 + 1)/x1, (x0*x2 + x1 + 1)/(x1*x2)]

  `coefficient`(k)

    Returns the coefficient of `self` at index `k`.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3]).principal_extension()
        sage: S.mutate([2,1,2])
        sage: [ S.coefficient(k) for k in range(3) ]
        [y0, 1/y2, 1/y1]

  `coefficients`()

    Returns all coefficients of `self`.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3]).principal_extension()
        sage: S.mutate([2,1,2])
        sage: S.coefficients()
        [y0, 1/y2, 1/y1]

  `exchangeable_part`()

    Returns the restriction to the principal part (i.e. the exchangeable variables) of `self`.

    EXAMPLES:

        sage: S = ClusterSeed(['A',4])
        sage: T = ClusterSeed( S.quiver().digraph().edges(), frozen=1 )
        sage: T.quiver().digraph().edges()
        [(0, 1, (1, -1)), (2, 1, (1, -1)), (2, 3, (1, -1))]

        sage: T.exchangeable_part().quiver().digraph().edges()
        [(0, 1, (1, -1)), (2, 1, (1, -1))]

        sage: S2 = S.principal_extension()
        sage: S3 = S2.principal_extension(ignore_coefficients=True)
        sage: S2.exchangeable_part() == S3.exchangeable_part()
        True

  `f_polynomial`(k, ignore_coefficients=False)

    Returns the `k`-th F-polynomial of `self`. It is obtained from the `k`-th cluster variable by setting all \(x_i\) to \(1\).

    Requires principal coefficients, initialized by using principal_extension(), or the user can set ‘ignore_coefficients=True’ to bypass this restriction.

    Warning: this method assumes the sign-coherence conjecture and that the input seed is sign-coherent (has an exchange matrix with columns of like signs). Otherwise, computational errors might arise.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3]).principal_extension()
        sage: S.mutate([2,1,2])
        sage: [S.f_polynomial(k) for k in range(3)]
        [1, y1*y2 + y2 + 1, y1 + 1]

        sage: S = ClusterSeed(Matrix([[0,1],[-1,0],[1,0],[-1,1]])); S
        A seed for a cluster algebra of rank 2 with 2 frozen variables
        sage: T = ClusterSeed(Matrix([[0,1],[-1,0]])).principal_extension(); T
        A seed for a cluster algebra of rank 2 with principal coefficients
        sage: S.mutate(0)
        sage: T.mutate(0)
        sage: S.f_polynomials()
        Traceback (most recent call last):
        ...
        ValueError: No principal coefficients initialized. Use principal_extension, or ignore_coefficients to ignore this.
        sage: S.f_polynomials(ignore_coefficients=True)
        [y0 + y1, 1]
        sage: T.f_polynomials()
        [y0 + 1, 1]

  `f_polynomials`(ignore_coefficients=False)

    Returns all F-polynomials of `self`. These are obtained from the cluster variables by setting all \(x_i\)‘s to \(1\).

    Requires principal coefficients, initialized by using principal_extension(), or the user can set ‘ignore_coefficients=True’ to bypass this restriction.

    Warning: this method assumes the sign-coherence conjecture and that the input seed is sign-coherent (has an exchange matrix with columns of like signs). Otherwise, computational errors might arise.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3]).principal_extension()
        sage: S.mutate([2,1,2])
        sage: S.f_polynomials()
        [1, y1*y2 + y2 + 1, y1 + 1]

  `g_matrix`(ignore_coefficients=False)

    Returns the matrix of all g-vectors of `self`. This are the degree vectors of the cluster variables after setting all \(y_i\)‘s to \(0\).

    Requires principal coefficients, initialized by using principal_extension(), or the user can set ‘ignore_coefficients=True’ to bypass this restriction.

    Warning: this method assumes the sign-coherence conjecture and that the input seed is sign-coherent (has an exchange matrix with columns of like signs). Otherwise, computational errors might arise.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3]).principal_extension()
        sage: S.mutate([2,1,2])
        sage: S.g_matrix()
        [ 1  0  0]
        [ 0  0 -1]
        [ 0 -1  0]

        sage: S = ClusterSeed(['A',3])
        sage: S2 = S.principal_extension()
        sage: S.mutate([0,1])
        sage: S2.mutate([0,1])
        sage: S.g_matrix()
        Traceback (most recent call last):
        ...
        ValueError: No principal coefficients initialized. Use
        principal_extension, or ignore_coefficients to ignore this.
        sage: S.g_matrix(ignore_coefficients=True)
        [-1  0  0]
        [ 1  0  0]
        [ 0  1  1]
        sage: S2.g_matrix()
        [-1 -1  0]
        [ 1  0  0]
        [ 0  0  1]

  `g_vector`(k, ignore_coefficients=False)

    Returns the `k`-th g-vector of `self`. This is the degree vector of the `k`-th cluster variable after setting all \(y_i\)‘s to \(0\).

    Requires principal coefficients, initialized by using principal_extension(), or the user can set ‘ignore_coefficients=True’ to bypass this restriction.

    Warning: this method assumes the sign-coherence conjecture and that the input seed is sign-coherent (has an exchange matrix with columns of like signs). Otherwise, computational errors might arise.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3]).principal_extension()
        sage: S.mutate([2,1,2])
        sage: [ S.g_vector(k) for k in range(3) ]
        [(1, 0, 0), (0, 0, -1), (0, -1, 0)]

  `greedy`(a1, a2, method='by_recursion')

    Returns the greedy element \(x[a_1,a_2]\) assuming that self is rank two.

    The third input can be ‘by_recursion’, ‘by_combinatorics’, or ‘just_numbers’ to specify if the user wants the element computed by the recurrence, combinatorial formula, or wants to set \(x_1\) and \(x_2\) to be one.

    See [LeeLiZe] for more details.

    EXAMPLES:

        sage: S = ClusterSeed(['R2', [3, 3]])
        sage: S.greedy(4, 4)
        (x0^12 + x1^12 + 4*x0^9 + 4*x1^9 + 6*x0^6 + 4*x0^3*x1^3 + 6*x1^6 + 4*x0^3 + 4*x1^3 + 1)/(x0^4*x1^4)
        sage: S.greedy(4, 4, 'by_combinatorics')
        (x0^12 + x1^12 + 4*x0^9 + 4*x1^9 + 6*x0^6 + 4*x0^3*x1^3 + 6*x1^6 + 4*x0^3 + 4*x1^3 + 1)/(x0^4*x1^4)
        sage: S.greedy(4, 4, 'just_numbers')
        35
        sage: S = ClusterSeed(['R2', [2, 2]])
        sage: S.greedy(1, 2)
        (x0^4 + 2*x0^2 + x1^2 + 1)/(x0*x1^2)
        sage: S.greedy(1, 2, 'by_combinatorics')
        (x0^4 + 2*x0^2 + x1^2 + 1)/(x0*x1^2)

    REFERENCES:

    [LeeLiZe] | (1, 2) Lee-Li-Zelevinsky, Greedy elements in rank 2 cluster algebras, Arxiv 1208.2391

  `ground_field`()

    Returns the ground field of the cluster of `self`.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3])
        sage: S.ground_field()
        Fraction Field of Multivariate Polynomial Ring in x0, x1, x2 over Rational Field

  `interact`(fig_size=1, circular=True)

    Only in notebook mode. Starts an interactive window for cluster seed mutations.

    INPUT:

    - `fig_size` – (default: 1) factor by which the size of the plot is multiplied.
    - `circular` – (default: True) if True, the circular plot is chosen, otherwise >>spring<< is used.

    TESTS:

        sage: S = ClusterSeed(['A',4])
        sage: S.interact() # long time
        'The interactive mode only runs in the Sage notebook.'

  `is_acyclic`()

    Returns True iff self is acyclic (i.e., if the underlying quiver is acyclic).

    EXAMPLES:

        sage: ClusterSeed(['A',4]).is_acyclic()
        True

        sage: ClusterSeed(['A',[2,1],1]).is_acyclic()
        True

        sage: ClusterSeed([[0,1],[1,2],[2,0]]).is_acyclic()
        False

  `is_bipartite`(return_bipartition=False)

    Returns True iff self is bipartite (i.e., if the underlying quiver is bipartite).

    INPUT:

    - return_bipartition – (default:False) if True, the bipartition is returned in the case of `self` being bipartite.

    EXAMPLES:

        sage: ClusterSeed(['A',[3,3],1]).is_bipartite()
        True

        sage: ClusterSeed(['A',[4,3],1]).is_bipartite()
        False

  `is_finite`()

    Returns True if `self` is of finite type.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3])
        sage: S.is_finite()
        True

        sage: S = ClusterSeed(['A',[2,2],1])
        sage: S.is_finite()
        False

  `is_mutation_finite`(nr_of_checks=None, return_path=False)

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

    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 cluster seed is mutation infinite if and only if every \(b_{ij}*b_{ji} > -4\). Thus, we apply random mutations in random directions

    WARNING:

    - Uses a non-deterministic method by random mutations in various directions.
    - In theory, it can return a wrong True.

    EXAMPLES:

        sage: S = ClusterSeed(['A',10])
        sage: S._mutation_type = None
        sage: S.is_mutation_finite()
        True

        sage: S = ClusterSeed([(0,1),(1,2),(2,3),(3,4),(4,5),(5,6),(6,7),(7,8),(2,9)])
        sage: S.is_mutation_finite()
        False

  `m`()

    Returns the number of frozen variables of `self`.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3])
        sage: S.n()
        3

        sage: S.m()
        0

        sage: S = S.principal_extension()
        sage: S.m()
        3

  `mutate`(sequence, inplace=True)

    Mutates `self` at a vertex or a sequence of vertices.

    INPUT:

    - `sequence` – a vertex of self or an iterator of vertices of self.
    - `inplace` – (default: True) if False, the result is returned, otherwise `self` is modified.

    EXAMPLES:

        sage: S = ClusterSeed(['A',4]); S.b_matrix()
        [ 0  1  0  0]
        [-1  0 -1  0]
        [ 0  1  0  1]
        [ 0  0 -1  0]

        sage: S.mutate(0); S.b_matrix()
        [ 0 -1  0  0]
        [ 1  0 -1  0]
        [ 0  1  0  1]
        [ 0  0 -1  0]

        sage: T = S.mutate(0, inplace=False); T
        A seed for a cluster algebra of rank 4 of type ['A', 4]

        sage: S.mutate(0)
        sage: S == T
        True

        sage: S.mutate([0,1,0])
        sage: S.b_matrix()
        [ 0 -1  1  0]
        [ 1  0  0  0]
        [-1  0  0  1]
        [ 0  0 -1  0]

        sage: S = ClusterSeed(QuiverMutationType([['A',1],['A',3]]))
        sage: S.b_matrix()
        [ 0  0  0  0]
        [ 0  0  1  0]
        [ 0 -1  0 -1]
        [ 0  0  1  0]

        sage: T = S.mutate(0,inplace=False)
        sage: S == T
        False

  `mutation_class`(depth=+Infinity, show_depth=False, return_paths=False, up_to_equivalence=True, only_sink_source=False)

    Returns the mutation class of `self` with respect to certain constraints.

    INPUT:

    - `depth` – (default: infinity) integer, only seeds with distance at most depth from self are returned.
    - `show_depth` – (default: False) if True, the actual depth of the mutation is shown.
    - `return_paths` – (default: False) if True, a shortest path of mutation sequences from self to the given quiver is returned as well.
    - `up_to_equivalence` – (default: True) if True, only seeds up to equivalence are considered.
    - `sink_source` – (default: False) if True, only mutations at sinks and sources are applied.

    EXAMPLES:

    - for examples see `mutation_class_iter()`

    TESTS:

        sage: A = ClusterSeed(['A',3]).mutation_class()

  `mutation_class_iter`(depth=+Infinity, show_depth=False, return_paths=False, up_to_equivalence=True, only_sink_source=False)

    Returns an iterator for the mutation class of `self` with respect to certain constrains.

    INPUT:

    - `depth` – (default: infinity) integer or infinity, only seeds with distance at most `depth` from `self` are returned.
    - `show_depth` – (default: False) if True, the current depth of the mutation is shown while computing.
    - `return_paths` – (default: False) if True, a shortest path of mutations from `self` to the given quiver is returned as well.
    - `up_to_equivalence` – (default: True) if True, only one seed up to simultaneous permutation of rows and columns of the exchange matrix is recorded.
    - `sink_source` – (default: False) if True, only mutations at sinks and sources are applied.

    EXAMPLES:

    A standard finite type example:

        sage: S = ClusterSeed(['A',3])
        sage: it = S.mutation_class_iter()
        sage: for T in it: print T
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]

    A finite type example with given depth:

        sage: it = S.mutation_class_iter(depth=1)
        sage: for T in it: print T
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]
        A seed for a cluster algebra of rank 3 of type ['A', 3]

    A finite type example where the depth is shown while computing:

        sage: it = S.mutation_class_iter(show_depth=True)
        sage: for T in it: pass
        Depth: 0     found: 1          Time: ... s
        Depth: 1     found: 4          Time: ... s
        Depth: 2     found: 9          Time: ... s
        Depth: 3     found: 13         Time: ... s
        Depth: 4     found: 14         Time: ... s

    A finite type example with shortest paths returned:

        sage: it = S.mutation_class_iter(return_paths=True)
        sage: for T in it: print T
        (A seed for a cluster algebra of rank 3 of type ['A', 3], [])
        (A seed for a cluster algebra of rank 3 of type ['A', 3], [2])
        (A seed for a cluster algebra of rank 3 of type ['A', 3], [1])
        (A seed for a cluster algebra of rank 3 of type ['A', 3], [0])
        (A seed for a cluster algebra of rank 3 of type ['A', 3], [2, 1])
        (A seed for a cluster algebra of rank 3 of type ['A', 3], [0, 2])
        (A seed for a cluster algebra of rank 3 of type ['A', 3], [0, 1])
        (A seed for a cluster algebra of rank 3 of type ['A', 3], [1, 2])
        (A seed for a cluster algebra of rank 3 of type ['A', 3], [1, 0])
        (A seed for a cluster algebra of rank 3 of type ['A', 3], [0, 2, 1])
        (A seed for a cluster algebra of rank 3 of type ['A', 3], [0, 1, 2])
        (A seed for a cluster algebra of rank 3 of type ['A', 3], [2, 1, 0])
        (A seed for a cluster algebra of rank 3 of type ['A', 3], [1, 0, 2])
        (A seed for a cluster algebra of rank 3 of type ['A', 3], [0, 1, 2, 0])

    Finite type examples not considered up to equivalence:

        sage: it = S.mutation_class_iter(up_to_equivalence=False)
        sage: len( [ T for T in it ] )
        84

        sage: it = ClusterSeed(['A',2]).mutation_class_iter(return_paths=True,up_to_equivalence=False)
        sage: for T in it: print T
        (A seed for a cluster algebra of rank 2 of type ['A', 2], [])
        (A seed for a cluster algebra of rank 2 of type ['A', 2], [1])
        (A seed for a cluster algebra of rank 2 of type ['A', 2], [0])
        (A seed for a cluster algebra of rank 2 of type ['A', 2], [0, 1])
        (A seed for a cluster algebra of rank 2 of type ['A', 2], [1, 0])
        (A seed for a cluster algebra of rank 2 of type ['A', 2], [1, 0, 1])
        (A seed for a cluster algebra of rank 2 of type ['A', 2], [0, 1, 0])
        (A seed for a cluster algebra of rank 2 of type ['A', 2], [1, 0, 1, 0])
        (A seed for a cluster algebra of rank 2 of type ['A', 2], [0, 1, 0, 1])
        (A seed for a cluster algebra of rank 2 of type ['A', 2], [1, 0, 1, 0, 1])

    Check that trac ticket #14638 is fixed:

        sage: S = ClusterSeed(['E',6])
        sage: MC = S.mutation_class(depth=7); len(MC)
        534

    Infinite type examples:

        sage: S = ClusterSeed(['A',[1,1],1])
        sage: it = S.mutation_class_iter()
        sage: it.next()
        A seed for a cluster algebra of rank 2 of type ['A', [1, 1], 1]
        sage: it.next()
        A seed for a cluster algebra of rank 2 of type ['A', [1, 1], 1]
        sage: it.next()
        A seed for a cluster algebra of rank 2 of type ['A', [1, 1], 1]
        sage: it.next()
        A seed for a cluster algebra of rank 2 of type ['A', [1, 1], 1]

        sage: it = S.mutation_class_iter(depth=3, return_paths=True)
        sage: for T in it: print T
        (A seed for a cluster algebra of rank 2 of type ['A', [1, 1], 1], [])
        (A seed for a cluster algebra of rank 2 of type ['A', [1, 1], 1], [1])
        (A seed for a cluster algebra of rank 2 of type ['A', [1, 1], 1], [0])
        (A seed for a cluster algebra of rank 2 of type ['A', [1, 1], 1], [1, 0])
        (A seed for a cluster algebra of rank 2 of type ['A', [1, 1], 1], [0, 1])
        (A seed for a cluster algebra of rank 2 of type ['A', [1, 1], 1], [1, 0, 1])
        (A seed for a cluster algebra of rank 2 of type ['A', [1, 1], 1], [0, 1, 0])

  `mutation_sequence`(sequence, show_sequence=False, fig_size=1.2, return_output='seed')

    Returns the seeds obtained by mutating `self` at all vertices in `sequence`.

    INPUT:

    - `sequence` – an iterable of vertices of self.

    - `show_sequence` – (default: False) if True, a png containing the associated quivers is shown.

    - `fig_size` – (default: 1.2) factor by which the size of the plot is multiplied.

    - `return_output` – (default: ‘seed’) determines what output is to be returned:

          * if 'seed', outputs all the cluster seeds obtained by the ``sequence`` of mutations.
          * if 'matrix', outputs a list of exchange matrices.
          * if 'var', outputs a list of new cluster variables obtained at each step.

    EXAMPLES:

        sage: S = ClusterSeed(['A',2])
        sage: for T in S.mutation_sequence([0,1,0]):
        ...     print T.b_matrix()
        [ 0 -1]
        [ 1  0]
        [ 0  1]
        [-1  0]
        [ 0 -1]
        [ 1  0]

        sage: S=ClusterSeed(['A',2])
        sage: S.mutation_sequence([0,1,0,1],return_output='var')
        [(x1 + 1)/x0, (x0 + x1 + 1)/(x0*x1), (x0 + 1)/x1, x0]

  `mutation_type`()

    Returns 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.

    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.
    - Might fail to work if it is used within different Sage processes simultaneously (that happend in the doctesting).

    EXAMPLES:

    - finite types:

          sage: S = ClusterSeed(['A',5])
          sage: S._mutation_type = S._quiver._mutation_type = None
          sage: S.mutation_type()
          ['A', 5]

          sage: S = ClusterSeed([(0,1),(1,2),(2,3),(3,4)])
          sage: S.mutation_type()
          ['A', 5]

    - affine types:

          sage: S = ClusterSeed(['E',8,[1,1]]); S
          A seed for a cluster algebra of rank 10 of type ['E', 8, [1, 1]]
          sage: S._mutation_type = S._quiver._mutation_type = None; S
          A seed for a cluster algebra of rank 10
          sage: S.mutation_type() # long time
          ['E', 8, [1, 1]]

    - the not yet working affine type D:

          sage: S = ClusterSeed(['D',4,1])
          sage: S._mutation_type = S._quiver._mutation_type = None
          sage: S.mutation_type() # todo: not implemented
          ['D', 4, 1]

    - the exceptional types:

          sage: S = ClusterSeed(['X',6])
          sage: S._mutation_type = S._quiver._mutation_type = None
          sage: S.mutation_type() # long time
          ['X', 6]

    - infinite types:

          sage: S = ClusterSeed(['GR',[4,9]])
          sage: S._mutation_type = S._quiver._mutation_type = None
          sage: S.mutation_type()
          'undetermined infinite mutation type'

  `n`()

    Returns the number of exchangeable variables of `self`.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3])
        sage: S.n()
        3

  `plot`(circular=False, mark=None, save_pos=False)

    Returns the plot of the quiver of `self`.

    INPUT:

    - `circular` – (default:False) if True, the circular plot is chosen, otherwise >>spring<< is used.
    - `mark` – (default: None) if set to i, the vertex i is highlighted.
    - `save_pos` – (default:False) if True, the positions of the vertices are saved.

    EXAMPLES:

        sage: S = ClusterSeed(['A',5])
        sage: pl = S.plot()
        sage: pl = S.plot(circular=True)

  `principal_extension`(ignore_coefficients=False)

    Returns the principal extension of self, yielding a 2n-by-n matrix. Raises an error if the input seed has a non-square exchange matrix, unless ‘ignore_coefficients=True’ is set. In this case, the method instead adds n frozen variables to any previously frozen variables. I.e., the seed obtained by adding a frozen variable to every exchangeable variable of `self`.

    EXAMPLES:

        sage: S = ClusterSeed([[0,1],[1,2],[2,3],[2,4]]); S
        A seed for a cluster algebra of rank 5

        sage: T = S.principal_extension(); T
        A seed for a cluster algebra of rank 5 with principal coefficients

        sage: T.b_matrix()
        [ 0  1  0  0  0]
        [-1  0  1  0  0]
        [ 0 -1  0  1  1]
        [ 0  0 -1  0  0]
        [ 0  0 -1  0  0]
        [ 1  0  0  0  0]
        [ 0  1  0  0  0]
        [ 0  0  1  0  0]
        [ 0  0  0  1  0]
        [ 0  0  0  0  1]

        sage: T2 = T.principal_extension()
        Traceback (most recent call last):
        ...
        ValueError: The b-matrix is not square. Use ignore_coefficients to ignore this.

        sage: T2 = T.principal_extension(ignore_coefficients=True); T2.b_matrix()
        [ 0  1  0  0  0]
        [-1  0  1  0  0]
        [ 0 -1  0  1  1]
        [ 0  0 -1  0  0]
        [ 0  0 -1  0  0]
        [ 1  0  0  0  0]
        [ 0  1  0  0  0]
        [ 0  0  1  0  0]
        [ 0  0  0  1  0]
        [ 0  0  0  0  1]
        [ 1  0  0  0  0]
        [ 0  1  0  0  0]
        [ 0  0  1  0  0]
        [ 0  0  0  1  0]
        [ 0  0  0  0  1]

  `quiver`()

    Returns the quiver associated to `self`.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3])
        sage: S.quiver()
        Quiver on 3 vertices of type ['A', 3]

  `reorient`(data)

    Reorients `self` with respect to the given total order, or with respect to an iterator of ordered pairs.

    WARNING:

    - This operation might change the mutation type of `self`.
    - Ignores ordered pairs \((i,j)\) for which neither \((i,j)\) nor \((j,i)\) is an edge of `self`.

    INPUT:

    - `data` – an iterator defining a total order on `self.vertices()`, or an iterator of ordered pairs in `self` defining the new orientation of these edges.

    EXAMPLES:

        sage: S = ClusterSeed(['A',[2,3],1])
        sage: S.mutation_type()
        ['A', [2, 3], 1]

        sage: S.reorient([(0,1),(2,3)])
        sage: S.mutation_type()
        ['D', 5]

        sage: S.reorient([(1,0),(2,3)])
        sage: S.mutation_type()
        ['A', [1, 4], 1]

        sage: S.reorient([0,1,2,3,4])
        sage: S.mutation_type()
        ['A', [1, 4], 1]

  `reset_cluster`()

    Resets the cluster of `self` to the initial cluster.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3])
        sage: S.mutate([1,2,1])
        sage: S.cluster()
        [x0, (x1 + 1)/x2, (x0*x2 + x1 + 1)/(x1*x2)]

        sage: S.reset_cluster()
        sage: S.cluster()
        [x0, x1, x2]

        sage: T = S.principal_extension()
        sage: T.cluster()
        [x0, x1, x2]
        sage: T.mutate([1,2,1])
        sage: T.cluster()
        [x0, (x1*y2 + x0)/x2, (x1*y1*y2 + x0*y1 + x2)/(x1*x2)]

        sage: T.reset_cluster()
        sage: T.cluster()
        [x0, x1, x2]

  `reset_coefficients`()

    Resets the coefficients of `self` to the frozen variables but keeps the current cluster. Raises an error if the number of frozen variables is different than the number of exchangeable variables.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3]).principal_extension()
        sage: S.b_matrix()
        [ 0  1  0]
        [-1  0 -1]
        [ 0  1  0]
        [ 1  0  0]
        [ 0  1  0]
        [ 0  0  1]
        sage: S.mutate([1,2,1])
        sage: S.b_matrix()
        [ 0  1 -1]
        [-1  0  1]
        [ 1 -1  0]
        [ 1  0  0]
        [ 0  1 -1]
        [ 0  0 -1]
        sage: S.reset_coefficients()
        sage: S.b_matrix()
        [ 0  1 -1]
        [-1  0  1]
        [ 1 -1  0]
        [ 1  0  0]
        [ 0  1  0]
        [ 0  0  1]

  `save_image`(filename, circular=False, mark=None, save_pos=False)

    Saves the plot of the underlying digraph of the quiver of `self`.

    INPUT:

    - `filename` – the filename the image is saved to.
    - `circular` – (default: False) if True, the circular plot is chosen, otherwise >>spring<< is used.
    - `mark` – (default: None) if set to i, the vertex i is highlighted.
    - `save_pos` – (default:False) if True, the positions of the vertices are saved.

    EXAMPLES:

        sage: S = ClusterSeed(['F',4,[1,2]])
        sage: S.save_image(os.path.join(SAGE_TMP, 'sage.png'))

  `set_cluster`(cluster)

    Sets the cluster for `self` to `cluster`.

    INPUT:

    - `cluster` – an iterable defining a cluster for `self`.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3])
        sage: cluster = S.cluster()
        sage: S.mutate([1,2,1])
        sage: S.cluster()
        [x0, (x1 + 1)/x2, (x0*x2 + x1 + 1)/(x1*x2)]

        sage: S.set_cluster(cluster)
        sage: S.cluster()
        [x0, x1, x2]

  `show`(fig_size=1, circular=False, mark=None, save_pos=False)

    Shows the plot of the quiver of `self`.

    INPUT:

    - `fig_size` – (default: 1) factor by which the size of the plot is multiplied.
    - `circular` – (default: False) if True, the circular plot is chosen, otherwise >>spring<< is used.
    - `mark` – (default: None) if set to i, the vertex i is highlighted.
    - `save_pos` – (default:False) if True, the positions of the vertices are saved.

    TESTS:

        sage: S = ClusterSeed(['A',5])
        sage: S.show() # long time

  `universal_extension`()

    Returns the universal extension of `self`.

    This is the initial seed of the associated cluster algebra with universal coefficients, as defined in section 12 of Arxiv math/0602259.

    This method works only if `self` is a bipartite, finite-type seed.

    Due to some limitations in the current implementation of `CartanType`, we need to construct the set of almost positive coroots by hand. As a consequence their ordering is not the standard one (the rows of the bottom part of the exchange matrix might be a shuffling of those you would expect).

    EXAMPLES:

        sage: S = ClusterSeed(['A',2])
        sage: T = S.universal_extension()
        sage: T.b_matrix()
        [ 0  1]
        [-1  0]
        [-1  0]
        [ 1  0]
        [ 1 -1]
        [ 0  1]
        [ 0 -1]

        sage: S = ClusterSeed(['A',3])
        sage: T = S.universal_extension()
        sage: T.b_matrix()
        [ 0  1  0]
        [-1  0 -1]
        [ 0  1  0]
        [-1  0  0]
        [ 1  0  0]
        [ 1 -1  0]
        [ 1 -1  1]
        [ 0  1  0]
        [ 0 -1  0]
        [ 0 -1  1]
        [ 0  0 -1]
        [ 0  0  1]

        sage: S = ClusterSeed(['B',2])
        sage: T = S.universal_extension()
        sage: T.b_matrix()
        [ 0  1]
        [-2  0]
        [-1  0]
        [ 1  0]
        [ 1 -1]
        [ 2 -1]
        [ 0  1]
        [ 0 -1]

  `variable_class`(depth=+Infinity, ignore_bipartite_belt=False)

    Returns all cluster variables in the mutation class of `self`.

    INPUT:

    > - `depth` – (default:infinity) integer, only seeds with distance at most depth from self are returned
    > - `ignore_bipartite_belt` – (default:False) if True, the algorithms does not use the bipartite belt

    EXAMPLES:

    - for examples see `variable_class_iter()`

    TESTS:

        sage: A = ClusterSeed(['A',3]).variable_class()

  `variable_class_iter`(depth=+Infinity, ignore_bipartite_belt=False)

    Returns an iterator for all cluster variables in the mutation class of `self`.

    INPUT:

    > - `depth` – (default:infinity) integer, only seeds with distance at most depth from self are returned
    > - `ignore_bipartite_belt` – (default:False) if True, the algorithms does not use the bipartite belt

    EXAMPLES:

    A standard finite type example:

        sage: S = ClusterSeed(['A',3])
        sage: it = S.variable_class_iter()
        sage: for T in it: print T
        x0
        x1
        x2
        (x1 + 1)/x0
        (x1^2 + x0*x2 + 2*x1 + 1)/(x0*x1*x2)
        (x1 + 1)/x2
        (x0*x2 + x1 + 1)/(x0*x1)
        (x0*x2 + 1)/x1
        (x0*x2 + x1 + 1)/(x1*x2)

    Finite type examples with given depth:

        sage: it = S.variable_class_iter(depth=1)
        sage: for T in it: print T
        Found a bipartite seed - restarting the depth counter at zero and constructing the variable class using its bipartite belt.
        x0
        x1
        x2
        (x1 + 1)/x0
        (x1^2 + x0*x2 + 2*x1 + 1)/(x0*x1*x2)
        (x1 + 1)/x2
        (x0*x2 + x1 + 1)/(x0*x1)
        (x0*x2 + 1)/x1
        (x0*x2 + x1 + 1)/(x1*x2)

    Note that the notion of depth depends on whether a bipartite seed is found or not, or if it is manually ignored:

        sage: it = S.variable_class_iter(depth=1,ignore_bipartite_belt=True)
        sage: for T in it: print T
        x0
        x1
        x2
        (x1 + 1)/x2
        (x0*x2 + 1)/x1
        (x1 + 1)/x0

        sage: S.mutate([0,1])
        sage: it2 = S.variable_class_iter(depth=1)
        sage: for T in it2: print T
        (x1 + 1)/x0
        (x0*x2 + x1 + 1)/(x0*x1)
        x2
        (x1^2 + x0*x2 + 2*x1 + 1)/(x0*x1*x2)
        x1
        (x0*x2 + 1)/x1

    Infinite type examples:

        sage: S = ClusterSeed(['A',[1,1],1])
        sage: it = S.variable_class_iter(depth=2)
        sage: for T in it: print T
        Found a bipartite seed - restarting the depth counter at zero and constructing the variable class using its bipartite belt.
        x0
        x1
        (x1^2 + 1)/x0
        (x1^4 + x0^2 + 2*x1^2 + 1)/(x0^2*x1)
        (x0^4 + 2*x0^2 + x1^2 + 1)/(x0*x1^2)
        (x0^2 + 1)/x1
        (x1^6 + x0^4 + 2*x0^2*x1^2 + 3*x1^4 + 2*x0^2 + 3*x1^2 + 1)/(x0^3*x1^2)
        (x1^8 + x0^6 + 2*x0^4*x1^2 + 3*x0^2*x1^4 + 4*x1^6 + 3*x0^4 + 6*x0^2*x1^2 + 6*x1^4 + 3*x0^2 + 4*x1^2 + 1)/(x0^4*x1^3)
        (x0^8 + 4*x0^6 + 3*x0^4*x1^2 + 2*x0^2*x1^4 + x1^6 + 6*x0^4 + 6*x0^2*x1^2 + 3*x1^4 + 4*x0^2 + 3*x1^2 + 1)/(x0^3*x1^4)
        (x0^6 + 3*x0^4 + 2*x0^2*x1^2 + x1^4 + 3*x0^2 + 2*x1^2 + 1)/(x0^2*x1^3)

  `x`(k)

    Returns the \(k\) -th initial cluster variable for the associated cluster seed.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3])
        sage: S.mutate([2,1])
        sage: S.x(0)
        x0

        sage: S.x(1)
        x1

        sage: S.x(2)
        x2

  `y`(k)

    Returns the \(k\) -th initial coefficient (frozen variable) for the associated cluster seed.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3]).principal_extension()
        sage: S.mutate([2,1])
        sage: S.y(0)
        y0

        sage: S.y(1)
        y1

        sage: S.y(2)
        y2

class `sage.combinat.cluster_algebra_quiver.cluster_seed.``ClusterVariable`(parent, numerator, denominator, coerce=True, reduce=True, mutation_type=None, variable_type=None)

  Bases: `sage.rings.fraction_field_element.FractionFieldElement`

  This class is a thin wrapper for cluster variables in cluster seeds.

  It provides the extra feature to store if a variable is frozen or not.

  - the associated positive root:

        sage: S = ClusterSeed(['A',3])
        sage: for T in S.variable_class_iter(): print T, T.almost_positive_root()
        x0 -alpha[1]
        x1 -alpha[2]
        x2 -alpha[3]
        (x1 + 1)/x0 alpha[1]
        (x1^2 + x0*x2 + 2*x1 + 1)/(x0*x1*x2) alpha[1] + alpha[2] + alpha[3]
        (x1 + 1)/x2 alpha[3]
        (x0*x2 + x1 + 1)/(x0*x1) alpha[1] + alpha[2]
        (x0*x2 + 1)/x1 alpha[2]
        (x0*x2 + x1 + 1)/(x1*x2) alpha[2] + alpha[3]

  `almost_positive_root`()

    Returns the almost positive root associated to `self` if `self` is of finite type.

    EXAMPLES:

        sage: S = ClusterSeed(['A',3])
        sage: for T in S.variable_class_iter(): print T, T.almost_positive_root()
        x0 -alpha[1]
        x1 -alpha[2]
        x2 -alpha[3]
        (x1 + 1)/x0 alpha[1]
        (x1^2 + x0*x2 + 2*x1 + 1)/(x0*x1*x2) alpha[1] + alpha[2] + alpha[3]
        (x1 + 1)/x2 alpha[3]
        (x0*x2 + x1 + 1)/(x0*x1) alpha[1] + alpha[2]
        (x0*x2 + 1)/x1 alpha[2]
        (x0*x2 + x1 + 1)/(x1*x2) alpha[2] + alpha[3]

`sage.combinat.cluster_algebra_quiver.cluster_seed.``PathSubset`(n, m)

  Encodes a maximal Dyck path from (0,0) to (n,m) (for n >= m >= 0) as a subset of {0,1,2,..., 2n-1}. The encoding is given by indexing horizontal edges by odd numbers and vertical edges by evens.

  The horizontal between (i,j) and (i+1,j) is indexed by the odd number 2*i+1. The vertical between (i,j) and (i,j+1) is indexed by the even number 2*j.

  EXAMPLES:

      sage: from sage.combinat.cluster_algebra_quiver.cluster_seed import PathSubset
      sage: PathSubset(4,0)
      {1, 3, 5, 7}
      sage: PathSubset(4,1)
      {1, 3, 5, 6, 7}
      sage: PathSubset(4,2)
      {1, 2, 3, 5, 6, 7}
      sage: PathSubset(4,3)
      {1, 2, 3, 4, 5, 6, 7}
      sage: PathSubset(4,4)
      {0, 1, 2, 3, 4, 5, 6, 7}

`sage.combinat.cluster_algebra_quiver.cluster_seed.``SetToPath`(T)

  Rearranges the encoding for a maximal Dyck path (as a set) so that it is a list in the proper order of the edges.

  EXAMPLES:

      sage: from sage.combinat.cluster_algebra_quiver.cluster_seed import PathSubset
      sage: from sage.combinat.cluster_algebra_quiver.cluster_seed import SetToPath
      sage: SetToPath(PathSubset(4,0))
      [1, 3, 5, 7]
      sage: SetToPath(PathSubset(4,1))
      [1, 3, 5, 7, 6]
      sage: SetToPath(PathSubset(4,2))
      [1, 3, 2, 5, 7, 6]
      sage: SetToPath(PathSubset(4,3))
      [1, 3, 2, 5, 4, 7, 6]
      sage: SetToPath(PathSubset(4,4))
      [1, 0, 3, 2, 5, 4, 7, 6]

`sage.combinat.cluster_algebra_quiver.cluster_seed.``coeff_recurs`(p, q, a1, a2, b, c)

  Coefficients in Laurent expansion of greedy element, as defined by recursion.

  EXAMPLES:

      sage: from sage.combinat.cluster_algebra_quiver.cluster_seed import coeff_recurs
      sage: coeff_recurs(1, 1, 5, 5, 3, 3)
      10

`sage.combinat.cluster_algebra_quiver.cluster_seed.``is_LeeLiZel_allowable`(T, n, m, b, c)

  Check if the subset T contributes to the computation of the greedy element x[m,n] in the rank two (b,c)-cluster algebra.

  This uses the conditions of Lee-Li-Zelevinsky’s paper [LeeLiZe].

  EXAMPLES:

      sage: from sage.combinat.cluster_algebra_quiver.cluster_seed import is_LeeLiZel_allowable
      sage: is_LeeLiZel_allowable({1,3,2,5,7,6},4,2,6,6)
      False
      sage: is_LeeLiZel_allowable({1,2,5},3,3,1,1)
      True

### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »
- Cluster Algebras and Quivers »