def __init__(self, L, q=None): """ Initialize ``self``. TESTS:: sage: L = posets.BooleanLattice(4) sage: M = L.quantum_moebius_algebra() sage: TestSuite(M).run() # long time """ if not L.is_lattice(): raise ValueError("L must be a lattice") if q is None: q = LaurentPolynomialRing(ZZ, 'q').gen() self._q = q R = q.parent() cat = Algebras(R).WithBasis() if L in FiniteEnumeratedSets(): cat = cat.Commutative().FiniteDimensional() self._lattice = L self._category = cat Parent.__init__(self, base=R, category=self._category.WithRealizations())
def testJonesPolynomial(self): L = LaurentPolynomialRing(QQ, 'q') q = L.gen() data = [ ('K3_1', ('q^3 + q - 1', -4)), ('K7_2', ('q^7 - q^6 + 2*q^5 - 2*q^4 + 2*q^3 - q^2 + q - 1', -8)), ('K8_3', ('q^8 - q^7 + 2*q^6 - 3*q^5 + 3*q^4 - 3*q^3 + 2*q^2 - q + 1', -4)), ('K8_13', ('-q^8 + 2*q^7 - 3*q^6 + 5*q^5 - 5*q^4 + 5*q^3 - 4*q^2 + 3*q - 1', -3)), ('L6a2', ('-q^6 + q^5 - 2*q^4 + 2*q^3 - 2*q^2 + q - 1', 1)), ('L6a4', ('-q^6 + 3*q^5 - 2*q^4 + 4*q^3 - 2*q^2 + 3*q - 1', -3)), ('L7a3', ('-q^7 + q^6 - 3*q^5 + 2*q^4 - 3*q^3 + 3*q^2 - 2*q + 1', -7)), ('L10n1', ('q^8 - 2*q^7 + 2*q^6 - 4*q^5 + 3*q^4 - 3*q^3 + 2*q^2 - 2*q + 1', -2)) ] for link_name, (poly, exp) in data: link = getattr(self, link_name) self.assertEqual(link.jones_polynomial(new_convention=False), L(poly) * q**exp)
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) t2^-1 + t1^-1*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 _LKB_matrix_(self, braid, variab): """ Compute the Lawrence-Krammer-Bigelow representation matrix. The variables of the matrix must be given. This actual computation is done in this helper method for caching purposes. INPUT: - ``braid`` -- tuple of integers. The Tietze list of the braid. - ``variab`` -- string. the names of the variables that will appear in the matrix. They must be given as a string, separated by a comma OUTPUT: The LKB matrix of the braid, with respect to the variables. TESTS:: sage: B=BraidGroup(3) sage: B._LKB_matrix_((2, 1, 2), 'x, y') [ 0 -x^4*y + x^3*y -x^4*y] [ 0 -x^3*y 0] [ -x^2*y x^3*y - x^2*y 0] sage: B._LKB_matrix_((1, 2, 1), 'x, y') [ 0 -x^4*y + x^3*y -x^4*y] [ 0 -x^3*y 0] [ -x^2*y x^3*y - x^2*y 0] sage: B._LKB_matrix_((-1, -2, -1, 2, 1, 2), 'x, y') [1 0 0] [0 1 0] [0 0 1] """ n = self.strands() if len(braid)>1: A = self._LKB_matrix_(braid[:1], variab) for i in braid[1:]: A = A*self._LKB_matrix_((i,), variab) return A l = list(Set(range(n)).subsets(2)) R = LaurentPolynomialRing(IntegerRing(), variab) q = R.gens()[0] t = R.gens()[1] if len(braid)==0: return identity_matrix(R, len(l), sparse=True) A = matrix(R, len(l), sparse=True) if braid[0]>0: i = braid[0]-1 for m in range(len(l)): j = min(l[m]) k = max(l[m]) if i==j-1: A[l.index(Set([i, k])), m] = q A[l.index(Set([i, j])), m] = q*q-q A[l.index(Set([j, k])), m] = 1-q elif i==j and not j==k-1: A[l.index(Set([j, k])), m] = 0 A[l.index(Set([j+1, k])), m] = 1 elif k-1==i and not k-1==j: A[l.index(Set([j, i])), m] = q A[l.index(Set([j, k])), m] = 1-q A[l.index(Set([i, k])), m] = (1-q)*q*t elif i==k: A[l.index(Set([j, k])), m] = 0 A[l.index(Set([j, k+1])), m] = 1 elif i==j and j==k-1: A[l.index(Set([j, k])), m] = -t*q*q else: A[l.index(Set([j, k])), m] = 1 return A else: i = -braid[0]-1 for m in range(len(l)): j = min(l[m]) k = max(l[m]) if i==j-1: A[l.index(Set([j-1, k])), m] = 1 elif i==j and not j==k-1: A[l.index(Set([j+1, k])), m] = q**(-1) A[l.index(Set([j, k])), m] = 1-q**(-1) A[l.index(Set([j, j+1])), m] = t**(-1)*q**(-1)-t**(-1)*q**(-2) elif k-1==i and not k-1==j: A[l.index(Set([j, k-1])), m] = 1 elif i==k: A[l.index(Set([j, k+1])), m] = q**(-1) A[l.index(Set([j, k])), m] = 1-q**(-1) A[l.index(Set([k, k+1])), m] = -q**(-1)+q**(-2) elif i==j and j==k-1: A[l.index(Set([j, k])), m] = -t**(-1)*q**(-2) else: A[l.index(Set([j, k])), m] = 1 return A
def alexander_polynomial(self, var='t', normalized=True): r""" Return the Alexander polynomial of the closure of the braid. INPUT: - ``var`` -- string (default: ``'t'``); the name of the variable in the entries of the matrix - ``normalized`` -- boolean (default: ``True``); whether to return the normalized Alexander polynomial OUTPUT: The Alexander polynomial of the braid closure of the braid. This is computed using the reduced Burau representation. The unnormalized Alexander polynomial is a Laurent polynomial, which is only well-defined up to multiplication by plus or minus times a power of `t`. We normalize the polynomial by dividing by the largest power of `t` and then if the resulting constant coefficient is negative, we multiply by `-1`. EXAMPLES: We first construct the trefoil:: sage: B = BraidGroup(3) sage: b = B([1,2,1,2]) sage: b.alexander_polynomial(normalized=False) 1 - t + t^2 sage: b.alexander_polynomial() t^-2 - t^-1 + 1 Next we construct the figure 8 knot:: sage: b = B([-1,2,-1,2]) sage: b.alexander_polynomial(normalized=False) -t^-2 + 3*t^-1 - 1 sage: b.alexander_polynomial() t^-2 - 3*t^-1 + 1 Our last example is the Kinoshita-Terasaka knot:: sage: B = BraidGroup(4) sage: b = B([1,1,1,3,3,2,-3,-1,-1,2,-1,-3,-2]) sage: b.alexander_polynomial(normalized=False) -t^-1 sage: b.alexander_polynomial() 1 REFERENCES: - :wikipedia:`Alexander_polynomial` """ n = self.strands() p = (self.burau_matrix(reduced=True) - identity_matrix(n - 1)).det() K, t = LaurentPolynomialRing(IntegerRing(), var).objgen() if p == 0: return K.zero() qn = sum(t ** i for i in range(n)) p //= qn if normalized: p *= t ** (-p.degree()) if p.constant_coefficient() < 0: p = -p 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 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 Omega_ge(a, exponents): r""" Return `\Omega_{\ge}` of the expression specified by the input. To be more precise, calculate .. MATH:: \Omega_{\ge} \frac{\mu^a}{ (1 - z_0 \mu^{e_0}) \dots (1 - z_{n-1} \mu^{e_{n-1}})} and return its numerator and a factorization of its denominator. Note that `z_0`, ..., `z_{n-1}` only appear in the output, but not in the input. INPUT: - ``a`` -- an integer - ``exponents`` -- a tuple of integers OUTPUT: A pair representing a quotient as follows: Its first component is the numerator as a Laurent polynomial, its second component a factorization of the denominator as a tuple of Laurent polynomials, where each Laurent polynomial `z` represents a factor `1 - z`. The parents of these Laurent polynomials is always a Laurent polynomial ring in `z_0`, ..., `z_{n-1}` over `\ZZ`, where `n` is the length of ``exponents``. EXAMPLES:: sage: from sage.rings.polynomial.omega import Omega_ge sage: Omega_ge(0, (1, -2)) (1, (z0, z0^2*z1)) sage: Omega_ge(0, (1, -3)) (1, (z0, z0^3*z1)) sage: Omega_ge(0, (1, -4)) (1, (z0, z0^4*z1)) sage: Omega_ge(0, (2, -1)) (z0*z1 + 1, (z0, z0*z1^2)) sage: Omega_ge(0, (3, -1)) (z0*z1^2 + z0*z1 + 1, (z0, z0*z1^3)) sage: Omega_ge(0, (4, -1)) (z0*z1^3 + z0*z1^2 + z0*z1 + 1, (z0, z0*z1^4)) sage: Omega_ge(0, (1, 1, -2)) (-z0^2*z1*z2 - z0*z1^2*z2 + z0*z1*z2 + 1, (z0, z1, z0^2*z2, z1^2*z2)) sage: Omega_ge(0, (2, -1, -1)) (z0*z1*z2 + z0*z1 + z0*z2 + 1, (z0, z0*z1^2, z0*z2^2)) sage: Omega_ge(0, (2, 1, -1)) (-z0*z1*z2^2 - z0*z1*z2 + z0*z2 + 1, (z0, z1, z0*z2^2, z1*z2)) :: sage: Omega_ge(0, (2, -2)) (-z0*z1 + 1, (z0, z0*z1, z0*z1)) sage: Omega_ge(0, (2, -3)) (z0^2*z1 + 1, (z0, z0^3*z1^2)) sage: Omega_ge(0, (3, 1, -3)) (-z0^3*z1^3*z2^3 + 2*z0^2*z1^3*z2^2 - z0*z1^3*z2 + z0^2*z2^2 - 2*z0*z2 + 1, (z0, z1, z0*z2, z0*z2, z0*z2, z1^3*z2)) :: sage: Omega_ge(0, (3, 6, -1)) (-z0*z1*z2^8 - z0*z1*z2^7 - z0*z1*z2^6 - z0*z1*z2^5 - z0*z1*z2^4 + z1*z2^5 - z0*z1*z2^3 + z1*z2^4 - z0*z1*z2^2 + z1*z2^3 - z0*z1*z2 + z0*z2^2 + z1*z2^2 + z0*z2 + z1*z2 + 1, (z0, z1, z0*z2^3, z1*z2^6)) TESTS:: sage: Omega_ge(0, (2, 2, 1, 1, 1, -1, -1))[0].number_of_terms() # long time 1695 sage: Omega_ge(0, (2, 2, 1, 1, 1, 1, 1, -1, -1))[0].number_of_terms() # not tested (too long, 1 min) 27837 :: sage: Omega_ge(1, (2,)) (1, (z0,)) """ import logging logger = logging.getLogger(__name__) logger.info('Omega_ge: a=%s, exponents=%s', a, exponents) from sage.arith.all import lcm, srange from sage.rings.integer_ring import ZZ from sage.rings.polynomial.laurent_polynomial_ring import LaurentPolynomialRing from sage.rings.number_field.number_field import CyclotomicField if not exponents or any(e == 0 for e in exponents): raise NotImplementedError rou = sorted(set(abs(e) for e in exponents) - set([1])) ellcm = lcm(rou) B = CyclotomicField(ellcm, 'zeta') zeta = B.gen() z_names = tuple('z{}'.format(i) for i in range(len(exponents))) L = LaurentPolynomialRing(B, ('t', ) + z_names, len(z_names) + 1) t = L.gens()[0] Z = LaurentPolynomialRing(ZZ, z_names, len(z_names)) powers = {i: L(zeta**(ellcm // i)) for i in rou} powers[2] = L(-1) powers[1] = L(1) exponents_and_values = tuple( (e, tuple(powers[abs(e)]**j * z for j in srange(abs(e)))) for z, e in zip(L.gens()[1:], exponents)) x = tuple(v for e, v in exponents_and_values if e > 0) y = tuple(v for e, v in exponents_and_values if e < 0) def subs_power(expression, var, exponent): r""" Substitute ``var^exponent`` by ``var`` in ``expression``. It is assumed that ``var`` only occurs with exponents divisible by ``exponent``. """ p = tuple(var.dict().popitem()[0]).index( 1) # var is the p-th generator def subs_e(e): e = list(e) assert e[p] % exponent == 0 e[p] = e[p] // exponent return tuple(e) parent = expression.parent() result = parent( {subs_e(e): c for e, c in iteritems(expression.dict())}) return result def de_power(expression): expression = Z(expression) for e, var in zip(exponents, Z.gens()): if abs(e) == 1: continue expression = subs_power(expression, var, abs(e)) return expression logger.debug('Omega_ge: preparing denominator') factors_denominator = tuple( de_power(1 - factor) for factor in _Omega_factors_denominator_(x, y)) logger.debug('Omega_ge: preparing numerator') numerator = de_power(_Omega_numerator_(a, x, y, t)) logger.info('Omega_ge: completed') return numerator, factors_denominator
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)
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__)