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__)
