def __classcall_private__(cls, R, q=None):
r"""
Normalize input to ensure a unique representation.
TESTS::
sage: R.<q> = LaurentPolynomialRing(QQ)
sage: AW1 = algebras.AskeyWilson(QQ)
sage: AW2 = algebras.AskeyWilson(R, q)
sage: AW1 is AW2
True
sage: AW = algebras.AskeyWilson(ZZ, 0)
Traceback (most recent call last):
...
ValueError: q cannot be 0
sage: AW = algebras.AskeyWilson(ZZ, 3)
Traceback (most recent call last):
...
ValueError: q=3 is not invertible in Integer Ring
"""
if q is None:
R = LaurentPolynomialRing(R, 'q')
q = R.gen()
else:
q = R(q)
if q == 0:
raise ValueError("q cannot be 0")
if 1/q not in R:
raise ValueError("q={} is not invertible in {}".format(q, R))
if R not in Rings().Commutative():
raise ValueError("{} is not a commutative ring".format(R))
return super(AskeyWilsonAlgebra, cls).__classcall__(cls, R, q)
def q_int(n, q=None):
r"""
Return the `q`-analog of the nonnegative integer `n`.
The `q`-analog of the nonnegative integer `n` is given by
.. MATH::
[n]_q = \frac{q^n - q^{-n}}{q - q^{-1}}
= q^{n-1} + q^{n-3} + \cdots + q^{-n+3} + q^{-n+1}.
INPUT:
- ``n`` -- the nonnegative integer `n` defined above
- ``q`` -- (default: `q \in \ZZ[q, q^{-1}]`) the parameter `q`
(should be invertible)
If ``q`` is unspecified, then it defaults to using the generator `q`
for a Laurent polynomial ring over the integers.
.. NOTE::
This is not the "usual" `q`-analog of `n` (or `q`-integer) but
a variant useful for quantum groups. For the version used in
combinatorics, see :mod:`sage.combinat.q_analogues`.
EXAMPLES::
sage: from sage.algebras.quantum_groups.q_numbers import q_int
sage: q_int(2)
q^-1 + q
sage: q_int(3)
q^-2 + 1 + q^2
sage: q_int(5)
q^-4 + q^-2 + 1 + q^2 + q^4
sage: q_int(5, 1)
5
TESTS::
sage: from sage.algebras.quantum_groups.q_numbers import q_int
sage: q_int(1)
1
sage: q_int(0)
0
"""
if q is None:
R = LaurentPolynomialRing(ZZ, 'q')
q = R.gen()
else:
R = q.parent()
if n == 0:
return R.zero()
return R.sum(q**(n - 2 * i - 1) for i in range(n))
def burau_matrix(self, var='t'):
"""
Return the Burau matrix of the braid.
INPUT:
- ``var`` -- string (default: ``'t'``). The name of the
variable in the entries of the matrix.
OUTPUT:
The Burau matrix of the braid. It is a matrix whose entries
are Laurent polynomials in the variable ``var``.
EXAMPLES::
sage: B = BraidGroup(4)
sage: B.inject_variables()
Defining s0, s1, s2
sage: b=s0*s1/s2/s1
sage: b.burau_matrix()
[ -t + 1 0 -t^2 + t t^2]
[ 1 0 0 0]
[ 0 0 1 0]
[ 0 t^-2 t^-1 - t^-2 1 - t^-1]
sage: s2.burau_matrix('x')
[ 1 0 0 0]
[ 0 1 0 0]
[ 0 0 -x + 1 x]
[ 0 0 1 0]
REFERENCES:
http://en.wikipedia.org/wiki/Burau_representation
"""
R = LaurentPolynomialRing(IntegerRing(), var)
t = R.gen()
M = identity_matrix(R, self.strands())
for i in self.Tietze():
A = identity_matrix(R, self.strands())
if i>0:
A[i-1, i-1] = 1-t
A[i, i] = 0
A[i, i-1] = 1
A[i-1, i] = t
if i<0:
A[-1-i, -1-i] = 0
A[-i, -i] = 1-t**(-1)
A[-1-i, -i] = 1
A[-i, -1-i] = t**(-1)
M=M*A
return M
def burau_matrix(self, var='t', reduced=False):
"""
Return the Burau matrix of the braid.
INPUT:
- ``var`` -- string (default: ``'t'``); the name of the
variable in the entries of the matrix
- ``reduced`` -- boolean (default: ``False``); whether to
return the reduced or unreduced Burau representation
OUTPUT:
The Burau matrix of the braid. It is a matrix whose entries
are Laurent polynomials in the variable ``var``. If ``reduced``
is ``True``, return the matrix for the reduced Burau representation
instead.
EXAMPLES::
sage: B = BraidGroup(4)
sage: B.inject_variables()
Defining s0, s1, s2
sage: b = s0*s1/s2/s1
sage: b.burau_matrix()
[ 1 - t 0 t - t^2 t^2]
[ 1 0 0 0]
[ 0 0 1 0]
[ 0 t^-2 -t^-2 + t^-1 -t^-1 + 1]
sage: s2.burau_matrix('x')
[ 1 0 0 0]
[ 0 1 0 0]
[ 0 0 1 - x x]
[ 0 0 1 0]
sage: s0.burau_matrix(reduced=True)
[-t 0 0]
[-t 1 0]
[-t 0 1]
REFERENCES:
- :wikipedia:`Burau_representation`
"""
R = LaurentPolynomialRing(IntegerRing(), var)
t = R.gen()
n = self.strands()
if not reduced:
M = identity_matrix(R, n)
for i in self.Tietze():
A = identity_matrix(R, n)
if i > 0:
A[i-1, i-1] = 1-t
A[i, i] = 0
A[i, i-1] = 1
A[i-1, i] = t
if i < 0:
A[-1-i, -1-i] = 0
A[-i, -i] = 1-t**(-1)
A[-1-i, -i] = 1
A[-i, -1-i] = t**(-1)
M = M * A
else:
M = identity_matrix(R, n - 1)
for j in self.Tietze():
A = identity_matrix(R, n - 1)
if j > 1:
i = j-1
A[i-1, i-1] = 1-t
A[i, i] = 0
A[i, i-1] = 1
A[i-1, i] = t
if j < -1:
i = j+1
A[-1-i, -1-i] = 0
A[-i, -i] = 1-t**(-1)
A[-1-i, -i] = 1
A[-i, -1-i] = t**(-1)
if j == 1:
for k in range(n - 1):
A[k,0] = -t
if j == -1:
A[0,0] = -t**(-1)
for k in range(1, n - 1):
A[k,0] = -1
M = M * A
return M
class ClusterAlgebra(Parent):
r"""
INPUT:
- ``data`` -- some data defining a cluster algebra.
- ``scalars`` -- (default ZZ) the scalars on which the cluster algebra
is defined.
- ``cluster_variables_prefix`` -- string (default 'x').
- ``cluster_variables_names`` -- a list of strings. Superseedes
``cluster_variables_prefix``.
- ``coefficients_prefix`` -- string (default 'y').
- ``coefficients_names`` -- a list of strings. Superseedes
``cluster_variables_prefix``.
- ``principal_coefficients`` -- bool (default: False). Superseedes any
coefficient defined by ``data``.
"""
Element = ClusterAlgebraElement
def __init__(self, data, **kwargs):
r"""
See :class:`ClusterAlgebra` for full documentation.
"""
# TODO: right now we use ClusterQuiver to parse input data. It looks like a good idea but we should make sure it is.
# TODO: in base replace LaurentPolynomialRing with the group algebra of a tropical semifield once it is implemented
# Temporary variables
Q = ClusterQuiver(data)
n = Q.n()
B0 = Q.b_matrix()[:n,:]
I = identity_matrix(n)
if 'principal_coefficients' in kwargs and kwargs['principal_coefficients']:
M0 = I
else:
M0 = Q.b_matrix()[n:,:]
m = M0.nrows()
# Ambient space for F-polynomials
# NOTE: for speed purposes we need to have QQ here instead of the more natural ZZ. The reason is that _mutated_F is faster if we do not cast the result to polynomials but then we get "rational" coefficients
self._U = PolynomialRing(QQ, ['u%s'%i for i in xrange(n)])
# Storage for computed data
self._path_dict = dict([ (v, []) for v in map(tuple,I.columns()) ])
self._F_poly_dict = dict([ (v, self._U(1)) for v in self._path_dict ])
# Determine the names of the initial cluster variables
if 'cluster_variables_names' in kwargs:
if len(kwargs['cluster_variables_names']) == n:
variables = kwargs['cluster_variables_names']
cluster_variables_prefix='dummy' # this is just to avoid checking again if cluster_variables_prefix is defined. Make this better before going public
else:
raise ValueError("cluster_variables_names should be a list of %d valid variable names"%n)
else:
try:
cluster_variables_prefix = kwargs['cluster_variables_prefix']
except:
cluster_variables_prefix = 'x'
variables = [cluster_variables_prefix+'%s'%i for i in xrange(n)]
# why not just put str(i) instead of '%s'%i?
# Determine scalars
try:
scalars = kwargs['scalars']
except:
scalars = ZZ
# Determine coefficients and setup self._base
if m>0:
if 'coefficients_names' in kwargs:
if len(kwargs['coefficients_names']) == m:
coefficients = kwargs['coefficients_names']
else:
raise ValueError("coefficients_names should be a list of %d valid variable names"%m)
else:
try:
coefficients_prefix = kwargs['coefficients_prefix']
except:
coefficients_prefix = 'y'
if coefficients_prefix == cluster_variables_prefix:
offset = n
else:
offset = 0
coefficients = [coefficients_prefix+'%s'%i for i in xrange(offset,m+offset)]
# TODO: (***) base should eventually become the group algebra of a tropical semifield
base = LaurentPolynomialRing(scalars, coefficients)
else:
base = scalars
# TODO: next line should be removed when (***) is implemented
coefficients = []
# setup Parent and ambient
# TODO: (***) _ambient should eventually be replaced with LaurentPolynomialRing(base, variables)
self._ambient = LaurentPolynomialRing(scalars, variables+coefficients)
self._ambient_field = self._ambient.fraction_field()
# TODO: understand why using Algebras() instead of Rings() makes A(1) complain of missing _lmul_
Parent.__init__(self, base=base, category=Rings(scalars).Commutative().Subobjects(), names=variables+coefficients)
# Data to compute cluster variables using separation of additions
# BUG WORKAROUND: if your sage installation does not have trac:`19538` merged uncomment the following line and comment the next
self._y = dict([ (self._U.gen(j), prod([self._ambient.gen(n+i)**M0[i,j] for i in xrange(m)])) for j in xrange(n)])
#self._y = dict([ (self._U.gen(j), prod([self._base.gen(i)**M0[i,j] for i in xrange(m)])) for j in xrange(n)])
self._yhat = dict([ (self._U.gen(j), prod([self._ambient.gen(i)**B0[i,j] for i in xrange(n)])*self._y[self._U.gen(j)]) for j in xrange(n)])
# Have we principal coefficients?
self._is_principal = (M0 == I)
# Store initial data
self._B0 = copy(B0)
self._n = n
self.reset_current_seed()
# Internal data for exploring the exchange graph
self.reset_exploring_iterator()
# Internal data to store exchange relations
# This is a dictionary indexed by a frozen set of two g-vectors (the g-vectors of the exchanged variables)
# Exchange relations are, for the moment, a frozen set of precisely two entries (one for each term in the exchange relation's RHS).
# Each of them contains two things
# 1) a list of pairs (g-vector, exponent) one for each cluster variable appearing in the term
# 2) the coefficient part of the term
# TODO: possibly refactor this producing a class ExchangeRelation with some pretty printing feature
self._exchange_relations = dict()
if 'store_exchange_relations' in kwargs and kwargs['store_exchange_relations']:
self._store_exchange_relations = True
else:
self._store_exchange_relations = False
# Add methods that are defined only for special cases
if n == 2:
self.greedy_element = MethodType(greedy_element, self, self.__class__)
self.greedy_coefficient = MethodType(greedy_coefficient, self, self.__class__)
self.theta_basis_element = MethodType(theta_basis_element, self, self.__class__)
# TODO: understand if we need this
#self._populate_coercion_lists_()
def __copy__(self):
other = type(self).__new__(type(self))
other._U = self._U
other._path_dict = copy(self._path_dict)
other._F_poly_dict = copy(self._F_poly_dict)
other._ambient = self._ambient
other._ambient_field = self._ambient_field
other._y = copy(self._y)
other._yhat = copy(self._yhat)
other._is_principal = self._is_principal
other._B0 = copy(self._B0)
other._n = self._n
# We probably need to put n=2 initializations here also
# TODO: we may want to use __init__ to make the initialization somewhat easier (say to enable special cases) This might require a better written __init__
return other
def __eq__(self, other):
return type(self) == type(other) and self._B0 == other._B0 and self._yhat == other._yhat
# enable standard coercions: everything that is in the base can be coerced
def _coerce_map_from_(self, other):
return self.base().has_coerce_map_from(other)
def _repr_(self):
return "Cluster Algebra of rank %s"%self.rk
def _an_element_(self):
return self.current_seed().cluster_variable(0)
@property
def rk(self):
r"""
The rank of ``self`` i.e. the number of cluster variables in any seed of
``self``.
"""
return self._n
def current_seed(self):
r"""
The current seed of ``self``.
"""
return self._seed
def set_current_seed(self, seed):
r"""
Set ``self._seed`` to ``seed`` if it makes sense.
"""
if self.contains_seed(seed):
self._seed = seed
else:
raise ValueError("This is not a seed in this cluster algebra.")
def contains_seed(self, seed):
computed_sd = self.initial_seed
computed_sd.mutate(seed._path, mutating_F=False)
return computed_sd == seed
def reset_current_seed(self):
r"""
Reset the current seed to the initial one
"""
self._seed = self.initial_seed
@property
def initial_seed(self):
r"""
Return the initial seed
"""
n = self.rk
I = identity_matrix(n)
return ClusterAlgebraSeed(self._B0, I, I, self)
@property
def initial_b_matrix(self):
n = self.rk
return copy(self._B0)
def g_vectors_so_far(self):
r"""
Return the g-vectors of cluster variables encountered so far.
"""
return self._path_dict.keys()
def F_polynomial(self, g_vector):
g_vector= tuple(g_vector)
try:
return self._F_poly_dict[g_vector]
except:
# If the path is known, should this method perform that sequence of mutations to compute the desired F-polynomial?
# Yes, perhaps with the a prompt first, something like:
#comp = raw_input("This F-polynomial has not been computed yet. It can be found using %s mutations. Continue? (y or n):"%str(directions.__len__()))
#if comp == 'y':
# ...compute the F-polynomial...
if g_vector in self._path_dict:
raise ValueError("The F-polynomial with g-vector %s has not been computed yet. You probably explored the exchange tree with compute_F=False. You can compute this F-polynomial by mutating from the initial seed along the sequence %s."%(str(g_vector),str(self._path_dict[g_vector])))
else:
raise ValueError("The F-polynomial with g-vector %s has not been computed yet."%str(g_vector))
@cached_method(key=lambda a,b: tuple(b) )
def cluster_variable(self, g_vector):
g_vector = tuple(g_vector)
if not g_vector in self.g_vectors_so_far():
# Should we let the self.F_polynomial below handle raising the exception?
raise ValueError("This Cluster Variable has not been computed yet.")
F_std = self.F_polynomial(g_vector).subs(self._yhat)
g_mon = prod([self.ambient().gen(i)**g_vector[i] for i in xrange(self.rk)])
# LaurentPolynomial_mpair does not know how to compute denominators, we need to lift to its fraction field
F_trop = self.ambient_field()(self.F_polynomial(g_vector).subs(self._y)).denominator()
return self.retract(g_mon*F_std*F_trop)
def find_cluster_variable(self, g_vector, depth=infinity):
r"""
Returns the shortest mutation path to obtain the cluster variable with
g-vector ``g_vector`` from the initial seed.
``depth``: maximum distance from ``self.current_seed`` to reach.
WARNING: if this method is interrupted then ``self._sd_iter`` is left in
an unusable state. To use again this method it is then necessary to
reset ``self._sd_iter`` via self.reset_exploring_iterator()
"""
g_vector = tuple(g_vector)
mutation_counter = 0
while g_vector not in self.g_vectors_so_far() and self._explored_depth <= depth:
try:
seed = next(self._sd_iter)
self._explored_depth = seed.depth()
except:
raise ValueError("Could not find a cluster variable with g-vector %s up to mutation depth %s after performing %s mutations."%(str(g_vector),str(depth),str(mutation_counter)))
# If there was a way to have the seeds iterator continue after the depth_counter reaches depth,
# the following code would allow the user to continue searching the exchange graph
#cont = raw_input("Could not find a cluster variable with g-vector %s up to mutation depth %s."%(str(g_vector),str(depth))+" Continue searching? (y or n):")
#if cont == 'y':
# new_depth = 0
# while new_depth <= depth:
# new_depth = raw_input("Please enter a new mutation search depth greater than %s:"%str(depth))
# seeds.send(new_depth)
#else:
# raise ValueError("Could not find a cluster variable with g-vector %s after %s mutations."%(str(g_vector),str(mutation_counter)))
mutation_counter += 1
return copy(self._path_dict[g_vector])
def ambient(self):
return self._ambient
def ambient_field(self):
return self._ambient_field
def lift_to_field(self, x):
return self.ambient_field()(1)*x.value
def lift(self, x):
r"""
Return x as an element of self._ambient
"""
return x.value
def retract(self, x):
return self(x)
def gens(self):
r"""
Return the generators of :meth:`self.ambient`
"""
return map(self.retract, self.ambient().gens())
def seeds(self, depth=infinity, mutating_F=True, from_current_seed=False):
r"""
Return an iterator producing all seeds of ``self`` up to distance
``depth`` from ``self.initial_seed`` or ``self.current_seed``.
If ``mutating_F`` is set to false it does not compute F_polynomials
"""
if from_current_seed:
seed = self.current_seed()
else:
seed = self.initial_seed
yield seed
depth_counter = 0
n = self.rk
cl = frozenset(seed.g_vectors())
clusters = {}
clusters[cl] = [ seed, range(n) ]
gets_bigger = True
while gets_bigger and depth_counter < depth:
gets_bigger = False
keys = clusters.keys()
for key in keys:
sd, directions = clusters[key]
while directions:
i = directions.pop()
new_sd = sd.mutate(i, inplace=False, mutating_F=mutating_F)
new_cl = frozenset(new_sd.g_vectors())
if new_cl in clusters:
j = map(tuple,clusters[new_cl][0].g_vectors()).index(new_sd.g_vector(i))
try:
clusters[new_cl][1].remove(j)
except:
pass
else:
gets_bigger = True
# doublecheck this way of producing directions for the new seed: it is taken almost verbatim fom ClusterSeed
new_directions = [ j for j in xrange(n) if j > i or new_sd.b_matrix()[j,i] != 0 ]
clusters[new_cl] = [ new_sd, new_directions ]
# Use this if we want to have the user pass info to the
# iterator
#new_depth = yield new_sd
#if new_depth > depth:
# depth = new_depth
yield new_sd
depth_counter += 1
def reset_exploring_iterator(self, mutating_F=True):
self._sd_iter = self.seeds(mutating_F=mutating_F)
self._explored_depth = 0
@mutation_parse
def mutate_initial(self, k):
r"""
Mutate ``self`` in direction `k` at the initial cluster.
INPUT:
- ``k`` -- integer in between 0 and ``self.rk``
"""
n = self.rk
if k not in xrange(n):
raise ValueError('Cannot mutate in direction %s, please try a value between 0 and %s.'%(str(k),str(n-1)))
#modify self._path_dict using Nakanishi-Zelevinsky (4.1) and self._F_poly_dict using CA-IV (6.21)
new_path_dict = dict()
new_F_dict = dict()
new_path_dict[tuple(identity_matrix(n).column(k))] = []
new_F_dict[tuple(identity_matrix(n).column(k))] = self._U(1)
poly_ring = PolynomialRing(ZZ,'u')
h_subs_tuple = tuple([poly_ring.gen(0)**(-1) if j==k else poly_ring.gen(0)**max(-self._B0[k][j],0) for j in xrange(n)])
F_subs_tuple = tuple([self._U.gen(k)**(-1) if j==k else self._U.gen(j)*self._U.gen(k)**max(-self._B0[k][j],0)*(1+self._U.gen(k))**(self._B0[k][j]) for j in xrange(n)])
for g_vect in self._path_dict:
#compute new path
path = self._path_dict[g_vect]
if g_vect == tuple(identity_matrix(n).column(k)):
new_path = [k]
elif path != []:
if path[0] != k:
new_path = [k] + path
else:
new_path = path[1:]
else:
new_path = []
#compute new g-vector
new_g_vect = vector(g_vect) - 2*g_vect[k]*identity_matrix(n).column(k)
for i in xrange(n):
new_g_vect += max(sign(g_vect[k])*self._B0[i,k],0)*g_vect[k]*identity_matrix(n).column(i)
new_path_dict[tuple(new_g_vect)] = new_path
#compute new F-polynomial
h = 0
trop = tropical_evaluation(self._F_poly_dict[g_vect](h_subs_tuple))
if trop != 1:
h = trop.denominator().exponents()[0]-trop.numerator().exponents()[0]
new_F_dict[tuple(new_g_vect)] = self._F_poly_dict[g_vect](F_subs_tuple)*self._U.gen(k)**h*(self._U.gen(k)+1)**g_vect[k]
self._path_dict = new_path_dict
self._F_poly_dict = new_F_dict
self._B0.mutate(k)
def explore_to_depth(self, depth):
while self._explored_depth <= depth:
try:
seed = next(self._sd_iter)
self._explored_depth = seed.depth()
except:
break
def cluster_fan(self, depth=infinity):
from sage.geometry.cone import Cone
from sage.geometry.fan import Fan
seeds = self.seeds(depth=depth, mutating_F=False)
cones = map(lambda s: Cone(s.g_vectors()), seeds)
return Fan(cones)
# DESIDERATA. Some of these are probably unrealistic
def upper_cluster_algebra(self):
pass
def upper_bound(self):
pass
def lower_bound(self):
pass
def MacMahonOmega(var,
expression,
denominator=None,
op=operator.ge,
Factorization_sort=False,
Factorization_simplify=True):
r"""
Return `\Omega_{\mathrm{op}}` of ``expression`` with respect to ``var``.
To be more precise, calculate
.. MATH::
\Omega_{\mathrm{op}} \frac{n}{d_1 \dots d_n}
for the numerator `n` and the factors `d_1`, ..., `d_n` of
the denominator, all of which are Laurent polynomials in ``var``
and return a (partial) factorization of the result.
INPUT:
- ``var`` -- a variable or a representation string of a variable
- ``expression`` -- a
:class:`~sage.structure.factorization.Factorization`
of Laurent polynomials or, if ``denominator`` is specified,
a Laurent polynomial interpreted as the numerator of the
expression
- ``denominator`` -- a Laurent polynomial or a
:class:`~sage.structure.factorization.Factorization` (consisting
of Laurent polynomial factors) or a tuple/list of factors (Laurent
polynomials)
- ``op`` -- (default: ``operator.ge``) an operator
At the moment only ``operator.ge`` is implemented.
- ``Factorization_sort`` (default: ``False``) and
``Factorization_simplify`` (default: ``True``) -- are passed on to
:class:`sage.structure.factorization.Factorization` when creating
the result
OUTPUT:
A (partial) :class:`~sage.structure.factorization.Factorization`
of the result whose factors are Laurent polynomials
.. NOTE::
The numerator of the result may not be factored.
REFERENCES:
- [Mac1915]_
- [APR2001]_
EXAMPLES::
sage: L.<mu, x, y, z, w> = LaurentPolynomialRing(ZZ)
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y/mu])
1 * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y/mu, 1 - z/mu])
1 * (-x + 1)^-1 * (-x*y + 1)^-1 * (-x*z + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y*mu, 1 - z/mu])
(-x*y*z + 1) * (-x + 1)^-1 * (-y + 1)^-1 * (-x*z + 1)^-1 * (-y*z + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y/mu^2])
1 * (-x + 1)^-1 * (-x^2*y + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu^2, 1 - y/mu])
(x*y + 1) * (-x + 1)^-1 * (-x*y^2 + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y*mu, 1 - z/mu^2])
(-x^2*y*z - x*y^2*z + x*y*z + 1) *
(-x + 1)^-1 * (-y + 1)^-1 * (-x^2*z + 1)^-1 * (-y^2*z + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y/mu^3])
1 * (-x + 1)^-1 * (-x^3*y + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y/mu^4])
1 * (-x + 1)^-1 * (-x^4*y + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu^3, 1 - y/mu])
(x*y^2 + x*y + 1) * (-x + 1)^-1 * (-x*y^3 + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu^4, 1 - y/mu])
(x*y^3 + x*y^2 + x*y + 1) * (-x + 1)^-1 * (-x*y^4 + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu^2, 1 - y/mu, 1 - z/mu])
(x*y*z + x*y + x*z + 1) *
(-x + 1)^-1 * (-x*y^2 + 1)^-1 * (-x*z^2 + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu^2, 1 - y*mu, 1 - z/mu])
(-x*y*z^2 - x*y*z + x*z + 1) *
(-x + 1)^-1 * (-y + 1)^-1 * (-x*z^2 + 1)^-1 * (-y*z + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y*mu, 1 - z*mu, 1 - w/mu])
(x*y*z*w^2 + x*y*z*w - x*y*w - x*z*w - y*z*w + 1) *
(-x + 1)^-1 * (-y + 1)^-1 * (-z + 1)^-1 *
(-x*w + 1)^-1 * (-y*w + 1)^-1 * (-z*w + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y*mu, 1 - z/mu, 1 - w/mu])
(x^2*y*z*w + x*y^2*z*w - x*y*z*w - x*y*z - x*y*w + 1) *
(-x + 1)^-1 * (-y + 1)^-1 *
(-x*z + 1)^-1 * (-x*w + 1)^-1 * (-y*z + 1)^-1 * (-y*w + 1)^-1
sage: MacMahonOmega(mu, mu^-2, [1 - x*mu, 1 - y/mu])
x^2 * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, mu^-1, [1 - x*mu, 1 - y/mu])
x * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, mu, [1 - x*mu, 1 - y/mu])
(-x*y + y + 1) * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, mu^2, [1 - x*mu, 1 - y/mu])
(-x*y^2 - x*y + y^2 + y + 1) * (-x + 1)^-1 * (-x*y + 1)^-1
We demonstrate the different allowed input variants::
sage: MacMahonOmega(mu,
....: Factorization([(mu, 2), (1 - x*mu, -1), (1 - y/mu, -1)]))
(-x*y^2 - x*y + y^2 + y + 1) * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, mu^2,
....: Factorization([(1 - x*mu, 1), (1 - y/mu, 1)]))
(-x*y^2 - x*y + y^2 + y + 1) * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, mu^2, [1 - x*mu, 1 - y/mu])
(-x*y^2 - x*y + y^2 + y + 1) * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, mu^2, (1 - x*mu)*(1 - y/mu)) # not tested because not fully implemented
(-x*y^2 - x*y + y^2 + y + 1) * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, mu^2 / ((1 - x*mu)*(1 - y/mu))) # not tested because not fully implemented
(-x*y^2 - x*y + y^2 + y + 1) * (-x + 1)^-1 * (-x*y + 1)^-1
TESTS::
sage: MacMahonOmega(mu, 1, [1 - x*mu])
1 * (-x + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x/mu])
1
sage: MacMahonOmega(mu, 0, [1 - x*mu])
0
sage: MacMahonOmega(mu, L(1), [])
1
sage: MacMahonOmega(mu, L(0), [])
0
sage: MacMahonOmega(mu, 2, [])
2
sage: MacMahonOmega(mu, 2*mu, [])
2
sage: MacMahonOmega(mu, 2/mu, [])
0
::
sage: MacMahonOmega(mu, Factorization([(1/mu, 1), (1 - x*mu, -1),
....: (1 - y/mu, -2)], unit=2))
2*x * (-x + 1)^-1 * (-x*y + 1)^-2
sage: MacMahonOmega(mu, Factorization([(mu, -1), (1 - x*mu, -1),
....: (1 - y/mu, -2)], unit=2))
2*x * (-x + 1)^-1 * (-x*y + 1)^-2
sage: MacMahonOmega(mu, Factorization([(mu, -1), (1 - x, -1)]))
0
sage: MacMahonOmega(mu, Factorization([(2, -1)]))
1 * 2^-1
::
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - z, 1 - y/mu])
1 * (-z + 1)^-1 * (-x + 1)^-1 * (-x*y + 1)^-1
::
sage: MacMahonOmega(mu, 1, [1 - x*mu], op=operator.lt)
Traceback (most recent call last):
...
NotImplementedError: At the moment, only Omega_ge is implemented.
sage: MacMahonOmega(mu, 1, Factorization([(1 - x*mu, -1)]))
Traceback (most recent call last):
...
ValueError: Factorization (-mu*x + 1)^-1 of the denominator
contains negative exponents.
sage: MacMahonOmega(2*mu, 1, [1 - x*mu])
Traceback (most recent call last):
...
ValueError: 2*mu is not a variable.
sage: MacMahonOmega(mu, 1, Factorization([(0, 2)]))
Traceback (most recent call last):
...
ZeroDivisionError: Denominator contains a factor 0.
sage: MacMahonOmega(mu, 1, [2 - x*mu])
Traceback (most recent call last):
...
NotImplementedError: Factor 2 - x*mu is not normalized.
sage: MacMahonOmega(mu, 1, [1 - x*mu - mu^2])
Traceback (most recent call last):
...
NotImplementedError: Cannot handle factor 1 - x*mu - mu^2.
::
sage: L.<mu, x, y, z, w> = LaurentPolynomialRing(QQ)
sage: MacMahonOmega(mu, 1/mu,
....: Factorization([(1 - x*mu, 1), (1 - y/mu, 2)], unit=2))
1/2*x * (-x + 1)^-1 * (-x*y + 1)^-2
"""
from sage.arith.misc import factor
from sage.misc.misc_c import prod
from sage.rings.integer_ring import ZZ
from sage.rings.polynomial.laurent_polynomial_ring \
import LaurentPolynomialRing, LaurentPolynomialRing_univariate
from sage.structure.factorization import Factorization
if op != operator.ge:
raise NotImplementedError(
'At the moment, only Omega_ge is implemented.')
if denominator is None:
if isinstance(expression, Factorization):
numerator = expression.unit() * \
prod(f**e for f, e in expression if e > 0)
denominator = tuple(f for f, e in expression if e < 0
for _ in range(-e))
else:
numerator = expression.numerator()
denominator = expression.denominator()
else:
numerator = expression
# at this point we have numerator/denominator
if isinstance(denominator, (list, tuple)):
factors_denominator = denominator
else:
if not isinstance(denominator, Factorization):
denominator = factor(denominator)
if not denominator.is_integral():
raise ValueError(
'Factorization {} of the denominator '
'contains negative exponents.'.format(denominator))
numerator *= ZZ(1) / denominator.unit()
factors_denominator = tuple(factor for factor, exponent in denominator
for _ in range(exponent))
# at this point we have numerator/factors_denominator
P = var.parent()
if isinstance(P, LaurentPolynomialRing_univariate) and P.gen() == var:
L = P
L0 = L.base_ring()
elif var in P.gens():
var = repr(var)
L0 = LaurentPolynomialRing(
P.base_ring(), tuple(v for v in P.variable_names() if v != var))
L = LaurentPolynomialRing(L0, var)
var = L.gen()
else:
raise ValueError('{} is not a variable.'.format(var))
other_factors = []
to_numerator = []
decoded_factors = []
for factor in factors_denominator:
factor = L(factor)
D = factor.dict()
if not D:
raise ZeroDivisionError('Denominator contains a factor 0.')
elif len(D) == 1:
exponent, coefficient = next(iter(D.items()))
if exponent == 0:
other_factors.append(L0(factor))
else:
to_numerator.append(factor)
elif len(D) == 2:
if D.get(0, 0) != 1:
raise NotImplementedError(
'Factor {} is not normalized.'.format(factor))
D.pop(0)
exponent, coefficient = next(iter(D.items()))
decoded_factors.append((-coefficient, exponent))
else:
raise NotImplementedError(
'Cannot handle factor {}.'.format(factor))
numerator = L(numerator) / prod(to_numerator)
result_numerator, result_factors_denominator = \
_Omega_(numerator.dict(), decoded_factors)
if result_numerator == 0:
return Factorization([], unit=result_numerator)
return Factorization([(result_numerator, 1)] + list(
(f, -1) for f in other_factors) + list(
(1 - f, -1) for f in result_factors_denominator),
sort=Factorization_sort,
simplify=Factorization_simplify)
def loop_representation(self):
r"""
Return the map `\pi` from ``self`` to `2 \times 2` matrices
over `R[\lambda,\lambda^{-1}]`, where `F` is the fraction field
of the base ring of ``self``.
Let `AW` be the Askey-Wilson algebra over `R`, and let `F` be
the fraction field of `R`. Let `M` be the space of `2 \times 2`
matrices over `F[\lambda, \lambda^{-1}]`. Consider the following
elements of `M`:
.. MATH::
\mathcal{A} = \begin{pmatrix}
\lambda & 1 - \lambda^{-1} \\ 0 & \lambda^{-1}
\end{pmatrix},
\qquad
\mathcal{B} = \begin{pmatrix}
\lambda^{-1} & 0 \\ \lambda - 1 & \lambda
\end{pmatrix},
\qquad
\mathcal{C} = \begin{pmatrix}
1 & \lambda - 1 \\ 1 - \lambda^{-1} & \lambda + \lambda^{-1} - 1
\end{pmatrix}.
From Lemma 3.11 of [Terwilliger2011]_, we define a
representation `\pi: AW \to M` by
.. MATH::
A \mapsto q \mathcal{A} + q^{-1} \mathcal{A}^{-1},
\qquad
B \mapsto q \mathcal{B} + q^{-1} \mathcal{B}^{-1},
\qquad
C \mapsto q \mathcal{C} + q^{-1} \mathcal{C}^{-1},
.. MATH::
\alpha, \beta, \gamma \mapsto \nu I,
where `\nu = (q^2 + q^-2)(\lambda + \lambda^{-1})
+ (\lambda + \lambda^{-1})^2`.
We call this representation the *loop representation* as
it is a representation using the loop group
`SL_2(F[\lambda,\lambda^{-1}])`.
EXAMPLES::
sage: AW = algebras.AskeyWilson(QQ)
sage: q = AW.q()
sage: pi = AW.loop_representation()
sage: A,B,C,a,b,g = [pi(gen) for gen in AW.algebra_generators()]
sage: A
[ 1/q*lambda^-1 + q*lambda ((-q^2 + 1)/q)*lambda^-1 + ((q^2 - 1)/q)]
[ 0 q*lambda^-1 + 1/q*lambda]
sage: B
[ q*lambda^-1 + 1/q*lambda 0]
[((-q^2 + 1)/q) + ((q^2 - 1)/q)*lambda 1/q*lambda^-1 + q*lambda]
sage: C
[1/q*lambda^-1 + ((q^2 - 1)/q) + 1/q*lambda ((q^2 - 1)/q) + ((-q^2 + 1)/q)*lambda]
[ ((q^2 - 1)/q)*lambda^-1 + ((-q^2 + 1)/q) q*lambda^-1 + ((-q^2 + 1)/q) + q*lambda]
sage: a
[lambda^-2 + ((q^4 + 1)/q^2)*lambda^-1 + 2 + ((q^4 + 1)/q^2)*lambda + lambda^2 0]
[ 0 lambda^-2 + ((q^4 + 1)/q^2)*lambda^-1 + 2 + ((q^4 + 1)/q^2)*lambda + lambda^2]
sage: a == b
True
sage: a == g
True
sage: AW.an_element()
(q^-3+3+2*q+q^2)*a*b*g^3 + q*A*C^2*b + 3*q^2*B*a^2*g + A
sage: x = pi(AW.an_element())
sage: y = (q^-3+3+2*q+q^2)*a*b*g^3 + q*A*C^2*b + 3*q^2*B*a^2*g + A
sage: x == y
True
We check the defining relations of the Askey-Wilson algebra::
sage: A + (q*B*C - q^-1*C*B) / (q^2 - q^-2) == a / (q + q^-1)
True
sage: B + (q*C*A - q^-1*A*C) / (q^2 - q^-2) == b / (q + q^-1)
True
sage: C + (q*A*B - q^-1*B*A) / (q^2 - q^-2) == g / (q + q^-1)
True
We check Lemma 3.12 in [Terwilliger2011]_::
sage: M = pi.codomain()
sage: la = M.base_ring().gen()
sage: p = M([[0,-1],[1,1]])
sage: s = M([[0,1],[la,0]])
sage: rho = AW.rho()
sage: sigma = AW.sigma()
sage: all(p*pi(gen)*~p == pi(rho(gen)) for gen in AW.algebra_generators())
True
sage: all(s*pi(gen)*~s == pi(sigma(gen)) for gen in AW.algebra_generators())
True
"""
from sage.matrix.matrix_space import MatrixSpace
q = self._q
base = LaurentPolynomialRing(self.base_ring().fraction_field(),
'lambda')
la = base.gen()
inv = ~la
M = MatrixSpace(base, 2)
A = M([[la, 1 - inv], [0, inv]])
Ai = M([[inv, inv - 1], [0, la]])
B = M([[inv, 0], [la - 1, la]])
Bi = M([[la, 0], [1 - la, inv]])
C = M([[1, 1 - la], [inv - 1, la + inv - 1]])
Ci = M([[la + inv - 1, la - 1], [1 - inv, 1]])
mu = la + inv
nu = (self._q**2 + self._q**-2) * mu + mu**2
nuI = M(nu)
# After #29374 is fixed, the category can become
# Algebras(Rings().Commutative()) as it was before #29399.
category = Rings()
return AlgebraMorphism(self, [
q * A + q**-1 * Ai, q * B + q**-1 * Bi, q * C + q**-1 * Ci, nuI,
nuI, nuI
],
codomain=M,
category=category)
def MacMahonOmega(var, expression, denominator=None, op=operator.ge,
Factorization_sort=False, Factorization_simplify=True):
r"""
Return `\Omega_{\mathrm{op}}` of ``expression`` with respect to ``var``.
To be more precise, calculate
.. MATH::
\Omega_{\mathrm{op}} \frac{n}{d_1 \dots d_n}
for the numerator `n` and the factors `d_1`, ..., `d_n` of
the denominator, all of which are Laurent polynomials in ``var``
and return a (partial) factorization of the result.
INPUT:
- ``var`` -- a variable or a representation string of a variable
- ``expression`` -- a
:class:`~sage.structure.factorization.Factorization`
of Laurent polynomials or, if ``denominator`` is specified,
a Laurent polynomial interpreted as the numerator of the
expression
- ``denominator`` -- a Laurent polynomial or a
:class:`~sage.structure.factorization.Factorization` (consisting
of Laurent polynomial factors) or a tuple/list of factors (Laurent
polynomials)
- ``op`` -- (default: ``operator.ge``) an operator
At the moment only ``operator.ge`` is implemented.
- ``Factorization_sort`` (default: ``False``) and
``Factorization_simplify`` (default: ``True``) -- are passed on to
:class:`sage.structure.factorization.Factorization` when creating
the result
OUTPUT:
A (partial) :class:`~sage.structure.factorization.Factorization`
of the result whose factors are Laurent polynomials
.. NOTE::
The numerator of the result may not be factored.
REFERENCES:
- [Mac1915]_
- [APR2001]_
EXAMPLES::
sage: L.<mu, x, y, z, w> = LaurentPolynomialRing(ZZ)
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y/mu])
1 * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y/mu, 1 - z/mu])
1 * (-x + 1)^-1 * (-x*y + 1)^-1 * (-x*z + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y*mu, 1 - z/mu])
(-x*y*z + 1) * (-x + 1)^-1 * (-y + 1)^-1 * (-x*z + 1)^-1 * (-y*z + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y/mu^2])
1 * (-x + 1)^-1 * (-x^2*y + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu^2, 1 - y/mu])
(x*y + 1) * (-x + 1)^-1 * (-x*y^2 + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y*mu, 1 - z/mu^2])
(-x^2*y*z - x*y^2*z + x*y*z + 1) *
(-x + 1)^-1 * (-y + 1)^-1 * (-x^2*z + 1)^-1 * (-y^2*z + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y/mu^3])
1 * (-x + 1)^-1 * (-x^3*y + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y/mu^4])
1 * (-x + 1)^-1 * (-x^4*y + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu^3, 1 - y/mu])
(x*y^2 + x*y + 1) * (-x + 1)^-1 * (-x*y^3 + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu^4, 1 - y/mu])
(x*y^3 + x*y^2 + x*y + 1) * (-x + 1)^-1 * (-x*y^4 + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu^2, 1 - y/mu, 1 - z/mu])
(x*y*z + x*y + x*z + 1) *
(-x + 1)^-1 * (-x*y^2 + 1)^-1 * (-x*z^2 + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu^2, 1 - y*mu, 1 - z/mu])
(-x*y*z^2 - x*y*z + x*z + 1) *
(-x + 1)^-1 * (-y + 1)^-1 * (-x*z^2 + 1)^-1 * (-y*z + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y*mu, 1 - z*mu, 1 - w/mu])
(x*y*z*w^2 + x*y*z*w - x*y*w - x*z*w - y*z*w + 1) *
(-x + 1)^-1 * (-y + 1)^-1 * (-z + 1)^-1 *
(-x*w + 1)^-1 * (-y*w + 1)^-1 * (-z*w + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - y*mu, 1 - z/mu, 1 - w/mu])
(x^2*y*z*w + x*y^2*z*w - x*y*z*w - x*y*z - x*y*w + 1) *
(-x + 1)^-1 * (-y + 1)^-1 *
(-x*z + 1)^-1 * (-x*w + 1)^-1 * (-y*z + 1)^-1 * (-y*w + 1)^-1
sage: MacMahonOmega(mu, mu^-2, [1 - x*mu, 1 - y/mu])
x^2 * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, mu^-1, [1 - x*mu, 1 - y/mu])
x * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, mu, [1 - x*mu, 1 - y/mu])
(-x*y + y + 1) * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, mu^2, [1 - x*mu, 1 - y/mu])
(-x*y^2 - x*y + y^2 + y + 1) * (-x + 1)^-1 * (-x*y + 1)^-1
We demonstrate the different allowed input variants::
sage: MacMahonOmega(mu,
....: Factorization([(mu, 2), (1 - x*mu, -1), (1 - y/mu, -1)]))
(-x*y^2 - x*y + y^2 + y + 1) * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, mu^2,
....: Factorization([(1 - x*mu, 1), (1 - y/mu, 1)]))
(-x*y^2 - x*y + y^2 + y + 1) * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, mu^2, [1 - x*mu, 1 - y/mu])
(-x*y^2 - x*y + y^2 + y + 1) * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, mu^2, (1 - x*mu)*(1 - y/mu)) # not tested because not fully implemented
(-x*y^2 - x*y + y^2 + y + 1) * (-x + 1)^-1 * (-x*y + 1)^-1
sage: MacMahonOmega(mu, mu^2 / ((1 - x*mu)*(1 - y/mu))) # not tested because not fully implemented
(-x*y^2 - x*y + y^2 + y + 1) * (-x + 1)^-1 * (-x*y + 1)^-1
TESTS::
sage: MacMahonOmega(mu, 1, [1 - x*mu])
1 * (-x + 1)^-1
sage: MacMahonOmega(mu, 1, [1 - x/mu])
1
sage: MacMahonOmega(mu, 0, [1 - x*mu])
0
sage: MacMahonOmega(mu, L(1), [])
1
sage: MacMahonOmega(mu, L(0), [])
0
sage: MacMahonOmega(mu, 2, [])
2
sage: MacMahonOmega(mu, 2*mu, [])
2
sage: MacMahonOmega(mu, 2/mu, [])
0
::
sage: MacMahonOmega(mu, Factorization([(1/mu, 1), (1 - x*mu, -1),
....: (1 - y/mu, -2)], unit=2))
2*x * (-x + 1)^-1 * (-x*y + 1)^-2
sage: MacMahonOmega(mu, Factorization([(mu, -1), (1 - x*mu, -1),
....: (1 - y/mu, -2)], unit=2))
2*x * (-x + 1)^-1 * (-x*y + 1)^-2
sage: MacMahonOmega(mu, Factorization([(mu, -1), (1 - x, -1)]))
0
sage: MacMahonOmega(mu, Factorization([(2, -1)]))
1 * 2^-1
::
sage: MacMahonOmega(mu, 1, [1 - x*mu, 1 - z, 1 - y/mu])
1 * (-z + 1)^-1 * (-x + 1)^-1 * (-x*y + 1)^-1
::
sage: MacMahonOmega(mu, 1, [1 - x*mu], op=operator.lt)
Traceback (most recent call last):
...
NotImplementedError: At the moment, only Omega_ge is implemented.
sage: MacMahonOmega(mu, 1, Factorization([(1 - x*mu, -1)]))
Traceback (most recent call last):
...
ValueError: Factorization (-mu*x + 1)^-1 of the denominator
contains negative exponents.
sage: MacMahonOmega(2*mu, 1, [1 - x*mu])
Traceback (most recent call last):
...
ValueError: 2*mu is not a variable.
sage: MacMahonOmega(mu, 1, Factorization([(0, 2)]))
Traceback (most recent call last):
...
ZeroDivisionError: Denominator contains a factor 0.
sage: MacMahonOmega(mu, 1, [2 - x*mu])
Traceback (most recent call last):
...
NotImplementedError: Factor 2 - x*mu is not normalized.
sage: MacMahonOmega(mu, 1, [1 - x*mu - mu^2])
Traceback (most recent call last):
...
NotImplementedError: Cannot handle factor 1 - x*mu - mu^2.
::
sage: L.<mu, x, y, z, w> = LaurentPolynomialRing(QQ)
sage: MacMahonOmega(mu, 1/mu,
....: Factorization([(1 - x*mu, 1), (1 - y/mu, 2)], unit=2))
1/2*x * (-x + 1)^-1 * (-x*y + 1)^-2
"""
from sage.arith.misc import factor
from sage.misc.misc_c import prod
from sage.rings.integer_ring import ZZ
from sage.rings.polynomial.laurent_polynomial_ring \
import LaurentPolynomialRing, LaurentPolynomialRing_univariate
from sage.structure.factorization import Factorization
if op != operator.ge:
raise NotImplementedError('At the moment, only Omega_ge is implemented.')
if denominator is None:
if isinstance(expression, Factorization):
numerator = expression.unit() * \
prod(f**e for f, e in expression if e > 0)
denominator = tuple(f for f, e in expression if e < 0
for _ in range(-e))
else:
numerator = expression.numerator()
denominator = expression.denominator()
else:
numerator = expression
# at this point we have numerator/denominator
if isinstance(denominator, (list, tuple)):
factors_denominator = denominator
else:
if not isinstance(denominator, Factorization):
denominator = factor(denominator)
if not denominator.is_integral():
raise ValueError('Factorization {} of the denominator '
'contains negative exponents.'.format(denominator))
numerator *= ZZ(1) / denominator.unit()
factors_denominator = tuple(factor
for factor, exponent in denominator
for _ in range(exponent))
# at this point we have numerator/factors_denominator
P = var.parent()
if isinstance(P, LaurentPolynomialRing_univariate) and P.gen() == var:
L = P
L0 = L.base_ring()
elif var in P.gens():
var = repr(var)
L0 = LaurentPolynomialRing(
P.base_ring(), tuple(v for v in P.variable_names() if v != var))
L = LaurentPolynomialRing(L0, var)
var = L.gen()
else:
raise ValueError('{} is not a variable.'.format(var))
other_factors = []
to_numerator = []
decoded_factors = []
for factor in factors_denominator:
factor = L(factor)
D = factor.dict()
if not D:
raise ZeroDivisionError('Denominator contains a factor 0.')
elif len(D) == 1:
exponent, coefficient = next(iteritems(D))
if exponent == 0:
other_factors.append(L0(factor))
else:
to_numerator.append(factor)
elif len(D) == 2:
if D.get(0, 0) != 1:
raise NotImplementedError('Factor {} is not normalized.'.format(factor))
D.pop(0)
exponent, coefficient = next(iteritems(D))
decoded_factors.append((-coefficient, exponent))
else:
raise NotImplementedError('Cannot handle factor {}.'.format(factor))
numerator = L(numerator) / prod(to_numerator)
result_numerator, result_factors_denominator = \
_Omega_(numerator.dict(), decoded_factors)
if result_numerator == 0:
return Factorization([], unit=result_numerator)
return Factorization([(result_numerator, 1)] +
list((f, -1) for f in other_factors) +
list((1-f, -1) for f in result_factors_denominator),
sort=Factorization_sort,
simplify=Factorization_simplify)
def alexander_polynomial(self,
multivar=True,
v='no',
method='default',
norm=True,
factored=False):
"""
Calculates the Alexander polynomial of the link. For links with one component,
can evaluate the alexander polynomial at v::
sage: K = Link('4_1')
sage: K.alexander_polynomial()
t^2 - 3*t + 1
sage: K.alexander_polynomial(v=[4])
5
sage: K = Link('L7n1')
sage: K.alexander_polynomial(norm=False)
t1^-1*t2^-1 + t1^-2*t2^-4
The default algorithm for *knots* is Bar-Natan's super-fast
tangle-based algorithm. For links, we apply Fox calculus to a
Wirtinger presentation for the link::
sage: L = Link('K13n123')
sage: L.alexander_polynomial() == L.alexander_polynomial(method='wirtinger')
True
"""
# sign normalization still missing, but when "norm=True" the
# leading coefficient with respect to the first variable is made
# positive.
if method == 'snappy':
try:
return self.exterior().alexander_polynomial()
except ImportError:
raise RuntimeError('this method for alexander_polynomial ' +
no_snappy_msg)
else:
comp = len(self.link_components)
if comp < 2:
multivar = False
# If single variable, use the super-fast method of Bar-Natan.
if comp == 1 and method == 'default' and norm:
p = alexander.alexander(self)
else: # Use a simple method based on the Wirtinger presentation.
if method not in ['default', 'wirtinger']:
raise ValueError(
"Available methods are 'default' and 'wirtinger'")
if (multivar):
L = LaurentPolynomialRing(
QQ, ['t%d' % (i + 1) for i in range(comp)])
t = list(L.gens())
else:
L = LaurentPolynomialRing(QQ, 't')
t = [L.gen()]
M = self.alexander_matrix(mv=multivar)
C = M[0]
m = C.nrows()
n = C.ncols()
if n > m:
k = m - 1
else:
k = n - 1
subMatrix = C[0:k, 0:k]
p = subMatrix.determinant()
if p == 0: return 0
if multivar:
t_i = M[1][-1]
p = (p.factor()) / (t_i - 1)
p = p.expand()
if (norm):
p = normalize_alex_poly(p, t)
if v != 'no':
return p(*v)
if multivar and factored: # it's easier to view this way
return p.factor()
else:
return p
def burau_matrix(self, var='t', reduced=False):
"""
Return the Burau matrix of the braid.
INPUT:
- ``var`` -- string (default: ``'t'``); the name of the
variable in the entries of the matrix
- ``reduced`` -- boolean (default: ``False``); whether to
return the reduced or unreduced Burau representation
OUTPUT:
The Burau matrix of the braid. It is a matrix whose entries
are Laurent polynomials in the variable ``var``. If ``reduced``
is ``True``, return the matrix for the reduced Burau representation
instead.
EXAMPLES::
sage: B = BraidGroup(4)
sage: B.inject_variables()
Defining s0, s1, s2
sage: b = s0*s1/s2/s1
sage: b.burau_matrix()
[ 1 - t 0 t - t^2 t^2]
[ 1 0 0 0]
[ 0 0 1 0]
[ 0 t^-2 -t^-2 + t^-1 -t^-1 + 1]
sage: s2.burau_matrix('x')
[ 1 0 0 0]
[ 0 1 0 0]
[ 0 0 1 - x x]
[ 0 0 1 0]
sage: s0.burau_matrix(reduced=True)
[-t 0 0]
[-t 1 0]
[-t 0 1]
REFERENCES:
- :wikipedia:`Burau_representation`
"""
R = LaurentPolynomialRing(IntegerRing(), var)
t = R.gen()
n = self.strands()
if not reduced:
M = identity_matrix(R, n)
for i in self.Tietze():
A = identity_matrix(R, n)
if i > 0:
A[i - 1, i - 1] = 1 - t
A[i, i] = 0
A[i, i - 1] = 1
A[i - 1, i] = t
if i < 0:
A[-1 - i, -1 - i] = 0
A[-i, -i] = 1 - t**(-1)
A[-1 - i, -i] = 1
A[-i, -1 - i] = t**(-1)
M = M * A
else:
M = identity_matrix(R, n - 1)
for j in self.Tietze():
A = identity_matrix(R, n - 1)
if j > 1:
i = j - 1
A[i - 1, i - 1] = 1 - t
A[i, i] = 0
A[i, i - 1] = 1
A[i - 1, i] = t
if j < -1:
i = j + 1
A[-1 - i, -1 - i] = 0
A[-i, -i] = 1 - t**(-1)
A[-1 - i, -i] = 1
A[-i, -1 - i] = t**(-1)
if j == 1:
for k in range(n - 1):
A[k, 0] = -t
if j == -1:
A[0, 0] = -t**(-1)
for k in range(1, n - 1):
A[k, 0] = -1
M = M * A
return M
def loop_representation(self):
r"""
Return the map `\pi` from ``self`` to `2 \times 2` matrices
over `R[\lambda,\lambda^{-1}]`, where `F` is the fraction field
of the base ring of ``self``.
Let `AW` be the Askey-Wilson algebra over `R`, and let `F` be
the fraction field of `R`. Let `M` be the space of `2 \times 2`
matrices over `F[\lambda, \lambda^{-1}]`. Consider the following
elements of `M`:
.. MATH::
\mathcal{A} = \begin{pmatrix}
\lambda & 1 - \lambda^{-1} \\ 0 & \lambda^{-1}
\end{pmatrix},
\qquad
\mathcal{B} = \begin{pmatrix}
\lambda^{-1} & 0 \\ \lambda - 1 & \lambda
\end{pmatrix},
\qquad
\mathcal{C} = \begin{pmatrix}
1 & \lambda - 1 \\ 1 - \lambda^{-1} & \lambda + \lambda^{-1} - 1
\end{pmatrix}.
From Lemma 3.11 of [Terwilliger2011]_, we define a
representation `\pi: AW \to M` by
.. MATH::
A \mapsto q \mathcal{A} + q^{-1} \mathcal{A}^{-1},
\qquad
B \mapsto q \mathcal{B} + q^{-1} \mathcal{B}^{-1},
\qquad
C \mapsto q \mathcal{C} + q^{-1} \mathcal{C}^{-1},
.. MATH::
\alpha, \beta, \gamma \mapsto \nu I,
where `\nu = (q^2 + q^-2)(\lambda + \lambda^{-1})
+ (\lambda + \lambda^{-1})^2`.
We call this representation the *loop representation* as
it is a representation using the loop group
`SL_2(F[\lambda,\lambda^{-1}])`.
EXAMPLES::
sage: AW = algebras.AskeyWilson(QQ)
sage: q = AW.q()
sage: pi = AW.loop_representation()
sage: A,B,C,a,b,g = [pi(gen) for gen in AW.algebra_generators()]
sage: A
[ 1/q*lambda^-1 + q*lambda ((-q^2 + 1)/q)*lambda^-1 + ((q^2 - 1)/q)]
[ 0 q*lambda^-1 + 1/q*lambda]
sage: B
[ q*lambda^-1 + 1/q*lambda 0]
[((-q^2 + 1)/q) + ((q^2 - 1)/q)*lambda 1/q*lambda^-1 + q*lambda]
sage: C
[1/q*lambda^-1 + ((q^2 - 1)/q) + 1/q*lambda ((q^2 - 1)/q) + ((-q^2 + 1)/q)*lambda]
[ ((q^2 - 1)/q)*lambda^-1 + ((-q^2 + 1)/q) q*lambda^-1 + ((-q^2 + 1)/q) + q*lambda]
sage: a
[lambda^-2 + ((q^4 + 1)/q^2)*lambda^-1 + 2 + ((q^4 + 1)/q^2)*lambda + lambda^2 0]
[ 0 lambda^-2 + ((q^4 + 1)/q^2)*lambda^-1 + 2 + ((q^4 + 1)/q^2)*lambda + lambda^2]
sage: a == b
True
sage: a == g
True
sage: AW.an_element()
(q^-3+3+2*q+q^2)*a*b*g^3 + q*A*C^2*b + 3*q^2*B*a^2*g + A
sage: x = pi(AW.an_element())
sage: y = (q^-3+3+2*q+q^2)*a*b*g^3 + q*A*C^2*b + 3*q^2*B*a^2*g + A
sage: x == y
True
We check the defining relations of the Askey-Wilson algebra::
sage: A + (q*B*C - q^-1*C*B) / (q^2 - q^-2) == a / (q + q^-1)
True
sage: B + (q*C*A - q^-1*A*C) / (q^2 - q^-2) == b / (q + q^-1)
True
sage: C + (q*A*B - q^-1*B*A) / (q^2 - q^-2) == g / (q + q^-1)
True
We check Lemma 3.12 in [Terwilliger2011]_::
sage: M = pi.codomain()
sage: la = M.base_ring().gen()
sage: p = M([[0,-1],[1,1]])
sage: s = M([[0,1],[la,0]])
sage: rho = AW.rho()
sage: sigma = AW.sigma()
sage: all(p*pi(gen)*~p == pi(rho(gen)) for gen in AW.algebra_generators())
True
sage: all(s*pi(gen)*~s == pi(sigma(gen)) for gen in AW.algebra_generators())
True
"""
from sage.matrix.matrix_space import MatrixSpace
q = self._q
base = LaurentPolynomialRing(self.base_ring().fraction_field(), 'lambda')
la = base.gen()
inv = ~la
M = MatrixSpace(base, 2)
A = M([[la,1-inv],[0,inv]])
Ai = M([[inv,inv-1],[0,la]])
B = M([[inv,0],[la-1,la]])
Bi = M([[la,0],[1-la,inv]])
C = M([[1,1-la],[inv-1,la+inv-1]])
Ci = M([[la+inv-1,la-1],[1-inv,1]])
mu = la + inv
nu = (self._q**2 + self._q**-2) * mu + mu**2
nuI = M(nu)
category = Algebras(Rings().Commutative())
return AlgebraMorphism(self, [q*A + q**-1*Ai, q*B + q**-1*Bi, q*C + q**-1*Ci,
nuI, nuI, nuI],
codomain=M, category=category)
class ClusterAlgebra(Parent):
r"""
INPUT:
- ``data`` -- some data defining a cluster algebra.
- ``scalars`` -- (default ZZ) the scalars on which the cluster algebra
is defined.
- ``cluster_variables_prefix`` -- string (default 'x').
- ``cluster_variables_names`` -- a list of strings. Superseedes
``cluster_variables_prefix``.
- ``coefficients_prefix`` -- string (default 'y').
- ``coefficients_names`` -- a list of strings. Superseedes
``cluster_variables_prefix``.
- ``principal_coefficients`` -- bool (default: False). Superseedes any
coefficient defined by ``data``.
"""
Element = ClusterAlgebraElement
def __init__(self, data, **kwargs):
r"""
See :class:`ClusterAlgebra` for full documentation.
"""
# TODO: right now we use ClusterQuiver to parse input data. It looks like a good idea but we should make sure it is.
# TODO: in base replace LaurentPolynomialRing with the group algebra of a tropical semifield once it is implemented
# Temporary variables
Q = ClusterQuiver(data)
n = Q.n()
B0 = Q.b_matrix()[:n, :]
I = identity_matrix(n)
if 'principal_coefficients' in kwargs and kwargs[
'principal_coefficients']:
M0 = I
else:
M0 = Q.b_matrix()[n:, :]
m = M0.nrows()
# Ambient space for F-polynomials
# NOTE: for speed purposes we need to have QQ here instead of the more natural ZZ. The reason is that _mutated_F is faster if we do not cast the result to polynomials but then we get "rational" coefficients
self._U = PolynomialRing(QQ, ['u%s' % i for i in xrange(n)])
# Storage for computed data
self._path_dict = dict([(v, []) for v in map(tuple, I.columns())])
self._F_poly_dict = dict([(v, self._U(1)) for v in self._path_dict])
# Determine the names of the initial cluster variables
if 'cluster_variables_names' in kwargs:
if len(kwargs['cluster_variables_names']) == n:
variables = kwargs['cluster_variables_names']
cluster_variables_prefix = 'dummy' # this is just to avoid checking again if cluster_variables_prefix is defined. Make this better before going public
else:
raise ValueError(
"cluster_variables_names should be a list of %d valid variable names"
% n)
else:
try:
cluster_variables_prefix = kwargs['cluster_variables_prefix']
except:
cluster_variables_prefix = 'x'
variables = [
cluster_variables_prefix + '%s' % i for i in xrange(n)
]
# why not just put str(i) instead of '%s'%i?
# Determine scalars
try:
scalars = kwargs['scalars']
except:
scalars = ZZ
# Determine coefficients and setup self._base
if m > 0:
if 'coefficients_names' in kwargs:
if len(kwargs['coefficients_names']) == m:
coefficients = kwargs['coefficients_names']
else:
raise ValueError(
"coefficients_names should be a list of %d valid variable names"
% m)
else:
try:
coefficients_prefix = kwargs['coefficients_prefix']
except:
coefficients_prefix = 'y'
if coefficients_prefix == cluster_variables_prefix:
offset = n
else:
offset = 0
coefficients = [
coefficients_prefix + '%s' % i
for i in xrange(offset, m + offset)
]
# TODO: (***) base should eventually become the group algebra of a tropical semifield
base = LaurentPolynomialRing(scalars, coefficients)
else:
base = scalars
# TODO: next line should be removed when (***) is implemented
coefficients = []
# setup Parent and ambient
# TODO: (***) _ambient should eventually be replaced with LaurentPolynomialRing(base, variables)
self._ambient = LaurentPolynomialRing(scalars,
variables + coefficients)
self._ambient_field = self._ambient.fraction_field()
# TODO: understand why using Algebras() instead of Rings() makes A(1) complain of missing _lmul_
Parent.__init__(self,
base=base,
category=Rings(scalars).Commutative().Subobjects(),
names=variables + coefficients)
# Data to compute cluster variables using separation of additions
# BUG WORKAROUND: if your sage installation does not have trac:`19538` merged uncomment the following line and comment the next
self._y = dict([
(self._U.gen(j),
prod([self._ambient.gen(n + i)**M0[i, j] for i in xrange(m)]))
for j in xrange(n)
])
#self._y = dict([ (self._U.gen(j), prod([self._base.gen(i)**M0[i,j] for i in xrange(m)])) for j in xrange(n)])
self._yhat = dict([
(self._U.gen(j),
prod([self._ambient.gen(i)**B0[i, j]
for i in xrange(n)]) * self._y[self._U.gen(j)])
for j in xrange(n)
])
# Have we principal coefficients?
self._is_principal = (M0 == I)
# Store initial data
self._B0 = copy(B0)
self._n = n
self.reset_current_seed()
# Internal data for exploring the exchange graph
self.reset_exploring_iterator()
# Internal data to store exchange relations
# This is a dictionary indexed by a frozen set of two g-vectors (the g-vectors of the exchanged variables)
# Exchange relations are, for the moment, a frozen set of precisely two entries (one for each term in the exchange relation's RHS).
# Each of them contains two things
# 1) a list of pairs (g-vector, exponent) one for each cluster variable appearing in the term
# 2) the coefficient part of the term
# TODO: possibly refactor this producing a class ExchangeRelation with some pretty printing feature
self._exchange_relations = dict()
if 'store_exchange_relations' in kwargs and kwargs[
'store_exchange_relations']:
self._store_exchange_relations = True
else:
self._store_exchange_relations = False
# Add methods that are defined only for special cases
if n == 2:
self.greedy_element = MethodType(greedy_element, self,
self.__class__)
self.greedy_coefficient = MethodType(greedy_coefficient, self,
self.__class__)
self.theta_basis_element = MethodType(theta_basis_element, self,
self.__class__)
# TODO: understand if we need this
#self._populate_coercion_lists_()
def __copy__(self):
other = type(self).__new__(type(self))
other._U = self._U
other._path_dict = copy(self._path_dict)
other._F_poly_dict = copy(self._F_poly_dict)
other._ambient = self._ambient
other._ambient_field = self._ambient_field
other._y = copy(self._y)
other._yhat = copy(self._yhat)
other._is_principal = self._is_principal
other._B0 = copy(self._B0)
other._n = self._n
# We probably need to put n=2 initializations here also
# TODO: we may want to use __init__ to make the initialization somewhat easier (say to enable special cases) This might require a better written __init__
return other
def __eq__(self, other):
return type(self) == type(
other) and self._B0 == other._B0 and self._yhat == other._yhat
# enable standard coercions: everything that is in the base can be coerced
def _coerce_map_from_(self, other):
return self.base().has_coerce_map_from(other)
def _repr_(self):
return "Cluster Algebra of rank %s" % self.rk
def _an_element_(self):
return self.current_seed().cluster_variable(0)
@property
def rk(self):
r"""
The rank of ``self`` i.e. the number of cluster variables in any seed of
``self``.
"""
return self._n
def current_seed(self):
r"""
The current seed of ``self``.
"""
return self._seed
def set_current_seed(self, seed):
r"""
Set ``self._seed`` to ``seed`` if it makes sense.
"""
if self.contains_seed(seed):
self._seed = seed
else:
raise ValueError("This is not a seed in this cluster algebra.")
def contains_seed(self, seed):
computed_sd = self.initial_seed
computed_sd.mutate(seed._path, mutating_F=False)
return computed_sd == seed
def reset_current_seed(self):
r"""
Reset the current seed to the initial one
"""
self._seed = self.initial_seed
@property
def initial_seed(self):
r"""
Return the initial seed
"""
n = self.rk
I = identity_matrix(n)
return ClusterAlgebraSeed(self._B0, I, I, self)
@property
def initial_b_matrix(self):
n = self.rk
return copy(self._B0)
def g_vectors_so_far(self):
r"""
Return the g-vectors of cluster variables encountered so far.
"""
return self._path_dict.keys()
def F_polynomial(self, g_vector):
g_vector = tuple(g_vector)
try:
return self._F_poly_dict[g_vector]
except:
# If the path is known, should this method perform that sequence of mutations to compute the desired F-polynomial?
# Yes, perhaps with the a prompt first, something like:
#comp = raw_input("This F-polynomial has not been computed yet. It can be found using %s mutations. Continue? (y or n):"%str(directions.__len__()))
#if comp == 'y':
# ...compute the F-polynomial...
if g_vector in self._path_dict:
raise ValueError(
"The F-polynomial with g-vector %s has not been computed yet. You probably explored the exchange tree with compute_F=False. You can compute this F-polynomial by mutating from the initial seed along the sequence %s."
% (str(g_vector), str(self._path_dict[g_vector])))
else:
raise ValueError(
"The F-polynomial with g-vector %s has not been computed yet."
% str(g_vector))
@cached_method(key=lambda a, b: tuple(b))
def cluster_variable(self, g_vector):
g_vector = tuple(g_vector)
if not g_vector in self.g_vectors_so_far():
# Should we let the self.F_polynomial below handle raising the exception?
raise ValueError(
"This Cluster Variable has not been computed yet.")
F_std = self.F_polynomial(g_vector).subs(self._yhat)
g_mon = prod(
[self.ambient().gen(i)**g_vector[i] for i in xrange(self.rk)])
# LaurentPolynomial_mpair does not know how to compute denominators, we need to lift to its fraction field
F_trop = self.ambient_field()(self.F_polynomial(g_vector).subs(
self._y)).denominator()
return self.retract(g_mon * F_std * F_trop)
def find_cluster_variable(self, g_vector, depth=infinity):
r"""
Returns the shortest mutation path to obtain the cluster variable with
g-vector ``g_vector`` from the initial seed.
``depth``: maximum distance from ``self.current_seed`` to reach.
WARNING: if this method is interrupted then ``self._sd_iter`` is left in
an unusable state. To use again this method it is then necessary to
reset ``self._sd_iter`` via self.reset_exploring_iterator()
"""
g_vector = tuple(g_vector)
mutation_counter = 0
while g_vector not in self.g_vectors_so_far(
) and self._explored_depth <= depth:
try:
seed = next(self._sd_iter)
self._explored_depth = seed.depth()
except:
raise ValueError(
"Could not find a cluster variable with g-vector %s up to mutation depth %s after performing %s mutations."
% (str(g_vector), str(depth), str(mutation_counter)))
# If there was a way to have the seeds iterator continue after the depth_counter reaches depth,
# the following code would allow the user to continue searching the exchange graph
#cont = raw_input("Could not find a cluster variable with g-vector %s up to mutation depth %s."%(str(g_vector),str(depth))+" Continue searching? (y or n):")
#if cont == 'y':
# new_depth = 0
# while new_depth <= depth:
# new_depth = raw_input("Please enter a new mutation search depth greater than %s:"%str(depth))
# seeds.send(new_depth)
#else:
# raise ValueError("Could not find a cluster variable with g-vector %s after %s mutations."%(str(g_vector),str(mutation_counter)))
mutation_counter += 1
return copy(self._path_dict[g_vector])
def ambient(self):
return self._ambient
def ambient_field(self):
return self._ambient_field
def lift_to_field(self, x):
return self.ambient_field()(1) * x.value
def lift(self, x):
r"""
Return x as an element of self._ambient
"""
return x.value
def retract(self, x):
return self(x)
def gens(self):
r"""
Return the generators of :meth:`self.ambient`
"""
return map(self.retract, self.ambient().gens())
def seeds(self, depth=infinity, mutating_F=True, from_current_seed=False):
r"""
Return an iterator producing all seeds of ``self`` up to distance
``depth`` from ``self.initial_seed`` or ``self.current_seed``.
If ``mutating_F`` is set to false it does not compute F_polynomials
"""
if from_current_seed:
seed = self.current_seed()
else:
seed = self.initial_seed
yield seed
depth_counter = 0
n = self.rk
cl = frozenset(seed.g_vectors())
clusters = {}
clusters[cl] = [seed, range(n)]
gets_bigger = True
while gets_bigger and depth_counter < depth:
gets_bigger = False
keys = clusters.keys()
for key in keys:
sd, directions = clusters[key]
while directions:
i = directions.pop()
new_sd = sd.mutate(i, inplace=False, mutating_F=mutating_F)
new_cl = frozenset(new_sd.g_vectors())
if new_cl in clusters:
j = map(tuple, clusters[new_cl][0].g_vectors()).index(
new_sd.g_vector(i))
try:
clusters[new_cl][1].remove(j)
except:
pass
else:
gets_bigger = True
# doublecheck this way of producing directions for the new seed: it is taken almost verbatim fom ClusterSeed
new_directions = [
j for j in xrange(n)
if j > i or new_sd.b_matrix()[j, i] != 0
]
clusters[new_cl] = [new_sd, new_directions]
# Use this if we want to have the user pass info to the
# iterator
#new_depth = yield new_sd
#if new_depth > depth:
# depth = new_depth
yield new_sd
depth_counter += 1
def reset_exploring_iterator(self, mutating_F=True):
self._sd_iter = self.seeds(mutating_F=mutating_F)
self._explored_depth = 0
@mutation_parse
def mutate_initial(self, k):
r"""
Mutate ``self`` in direction `k` at the initial cluster.
INPUT:
- ``k`` -- integer in between 0 and ``self.rk``
"""
n = self.rk
if k not in xrange(n):
raise ValueError(
'Cannot mutate in direction %s, please try a value between 0 and %s.'
% (str(k), str(n - 1)))
#modify self._path_dict using Nakanishi-Zelevinsky (4.1) and self._F_poly_dict using CA-IV (6.21)
new_path_dict = dict()
new_F_dict = dict()
new_path_dict[tuple(identity_matrix(n).column(k))] = []
new_F_dict[tuple(identity_matrix(n).column(k))] = self._U(1)
poly_ring = PolynomialRing(ZZ, 'u')
h_subs_tuple = tuple([
poly_ring.gen(0)**(-1) if j == k else poly_ring.gen(0)**max(
-self._B0[k][j], 0) for j in xrange(n)
])
F_subs_tuple = tuple([
self._U.gen(k)**(-1) if j == k else self._U.gen(j) *
self._U.gen(k)**max(-self._B0[k][j], 0) *
(1 + self._U.gen(k))**(self._B0[k][j]) for j in xrange(n)
])
for g_vect in self._path_dict:
#compute new path
path = self._path_dict[g_vect]
if g_vect == tuple(identity_matrix(n).column(k)):
new_path = [k]
elif path != []:
if path[0] != k:
new_path = [k] + path
else:
new_path = path[1:]
else:
new_path = []
#compute new g-vector
new_g_vect = vector(
g_vect) - 2 * g_vect[k] * identity_matrix(n).column(k)
for i in xrange(n):
new_g_vect += max(sign(g_vect[k]) * self._B0[i, k],
0) * g_vect[k] * identity_matrix(n).column(i)
new_path_dict[tuple(new_g_vect)] = new_path
#compute new F-polynomial
h = 0
trop = tropical_evaluation(self._F_poly_dict[g_vect](h_subs_tuple))
if trop != 1:
h = trop.denominator().exponents()[0] - trop.numerator(
).exponents()[0]
new_F_dict[tuple(new_g_vect)] = self._F_poly_dict[g_vect](
F_subs_tuple) * self._U.gen(k)**h * (self._U.gen(k) +
1)**g_vect[k]
self._path_dict = new_path_dict
self._F_poly_dict = new_F_dict
self._B0.mutate(k)
def explore_to_depth(self, depth):
while self._explored_depth <= depth:
try:
seed = next(self._sd_iter)
self._explored_depth = seed.depth()
except:
break
def cluster_fan(self, depth=infinity):
from sage.geometry.cone import Cone
from sage.geometry.fan import Fan
seeds = self.seeds(depth=depth, mutating_F=False)
cones = map(lambda s: Cone(s.g_vectors()), seeds)
return Fan(cones)
# DESIDERATA. Some of these are probably unrealistic
def upper_cluster_algebra(self):
pass
def upper_bound(self):
pass
def lower_bound(self):
pass
