# 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

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)

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:

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:

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: next(it)
[x0, x1]
sage: next(it)
[x0, (x0^2 + 1)/x1]
sage: next(it)
[(x1^2 + 1)/x0, x1]
sage: next(it)
[(x0^4 + 2*x0^2 + x1^2 + 1)/(x0*x1^2), (x0^2 + 1)/x1]
sage: next(it)
[(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:

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: next(it)
A seed for a cluster algebra of rank 2 of type ['A', [1, 1], 1]
sage: next(it)
A seed for a cluster algebra of rank 2 of type ['A', [1, 1], 1]
sage: next(it)
A seed for a cluster algebra of rank 2 of type ['A', [1, 1], 1]
sage: next(it)
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:

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)

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


#### Previous topic

Cluster algebra and quivers features that are imported by default in the interpreter namespace

mutation_class