def _sollya_annotate(self, center, rad, polys):
import sagesollya as sollya
logger = logging.getLogger(__name__ + ".sollya")
logger.info("calling annotatefunction() on %s derivatives", len(polys))
center = QQ(center)
sollya_fun = self._sollya_object
# sollya keeps all annotations, let's not bother with selecting
# the best one
for ord, pol0 in enumerate(polys):
pol = ZZ(ord).factorial() * pol0
sollya_pol = sum(
[c.center() * sollya.x**k for k, c in enumerate(pol)])
dom = RIF(center - rad,
center + rad) # XXX: dangerous when inexact
err_pol = pol.map_coefficients(lambda c: c - c.squash())
err = RIF(err_pol(RBF.zero().add_error(rad)))
with sollya.settings(display=sollya.dyadic):
logger = logging.getLogger(__name__ + ".sollya.annotate")
logger.debug("annotatefunction(%s, %s, %s, %s, %s);",
sollya_fun, sollya_pol, sollya.SollyaObject(dom),
sollya.SollyaObject(err),
sollya.SollyaObject(center))
sollya.annotatefunction(sollya_fun, sollya_pol, dom, err, center)
sollya_fun = sollya.diff(sollya_fun)
logger.info("...done")
def flipper_nf_to_sage(K, name='a'):
r"""
Convert a flipper number field into a Sage number field
.. NOTE::
Currently, the code is not careful at all with root isolation.
EXAMPLES::
sage: import flipper # optional - flipper
sage: import realalg # optional - flipper
sage: from flatsurf.geometry.similarity_surface_generators import flipper_nf_to_sage
sage: K = realalg.RealNumberField([-2r] + [0r]*5 + [1r]) # optional - flipper
sage: K_sage = flipper_nf_to_sage(K) # optional - flipper
sage: K_sage # optional - flipper
Number Field in a with defining polynomial x^6 - 2 with a = 1.122462048309373?
sage: AA(K_sage.gen()) # optional - flipper
1.122462048309373?
"""
r = K.lmbda.interval()
l = r.lower * ZZ(10)**(-r.precision)
u = r.upper * ZZ(10)**(-r.precision)
p = QQ['x'](K.coefficients)
s = AA.polynomial_root(p, RIF(l, u))
return NumberField(p, name, embedding=s)
def number_field_to_AA(a):
r"""
It is a mess to convert an element of a number field to the algebraic field
``AA``. This is a temporary fix.
"""
try:
return AA(a)
except TypeError:
return AA.polynomial_root(a.minpoly(), RIF(a))
def __init__(self,
dop,
ini,
name="dfinitefun",
max_prec=256,
max_rad=RBF('inf')):
self.dop = dop = DifferentialOperator(dop)
if not isinstance(ini, dict):
ini = {0: ini}
if len(ini) != 1:
# In the future, we should support specifying several vectors of
# initial values.
raise NotImplementedError
self.ini = ini
self.name = name
# Global maximum width for the approximation intervals. In the case of
# equations with no finite singular point, we try to avoid cancellation
# and interval blowup issues by taking polynomial approximations on
# intervals on which the general term of the series doesn't grow too
# large. The expected order of magnitude of the “top of the hump” is
# about exp(κ·|αx|^(1/κ)) and doesn't depend on the base point. We also
# let the user impose a maximum width, even in other cases.
self.max_rad = RBF(max_rad)
if dop.leading_coefficient().is_constant():
kappa, alpha = _growth_parameters(dop)
self.max_rad = self.max_rad.min(1 / (alpha * RBF(kappa)**kappa))
self.max_prec = max_prec
self._inivecs = {}
self._polys = {}
self._sollya_object = None
self._sollya_domain = RIF('-inf', 'inf')
self._max_derivatives = dop.order()
self._update_approx_hook = (lambda *args: None)
def from_mathematica(a):
try:
return QQ(a.sage())
except Exception:
pass
try:
return AA(a.sage())
except Exception:
coefficients = mathematica.CoefficientList(
mathematica.MinimalPolynomial(a, 'x'), 'x').sage()
x = polygen(QQ)
minpoly = x.parent()(coefficients)
interval = mathematica.IsolatingInterval(a).sage()
rif_interval = RIF(interval)
return AA.polynomial_root(minpoly, rif_interval)
def wrapper(pt, ord, prec):
if RBF(pt.diameter()) >= self.max_rad / 4:
return self._known_bound(RBF(pt), post_transform=Dx**ord)
try:
val = self.approx(pt, prec, post_transform=Dx**ord)
except Exception:
logger.info("pt=%s, ord=%s, prec=%s, error",
pt,
ord,
prec,
exc_info=(pt.absolute_diameter() < .5))
return RIF('nan')
logger.debug("pt=%s, ord=%s, prec=%s, val=%s", pt, ord, prec, val)
if not pt.overlaps(self._sollya_domain):
backtrace = sollya.getbacktrace()
logger.debug("%s not in %s", pt.str(style='brackets'),
self._sollya_domain.str(style='brackets'))
logger.debug("sollya backtrace: %s", [
sollya.objectname(t.struct.called_proc) for t in backtrace
])
return val
def bound_kolyvagin(self, D=0, regulator=None,
ignore_nonsurj_hypothesis=False):
r"""
Given a fundamental discriminant `D \neq -3,-4` that satisfies the
Heegner hypothesis for `E`, return a list of primes so that
Kolyvagin's theorem (as in Gross's paper) implies that any
prime divisor of `Sha` is in this list.
INPUT:
- ``D`` - (optional) a fundamental discriminant < -4 that satisfies
the Heegner hypothesis for `E`; if not given, use the first such `D`
- ``regulator`` -- (optional) regulator of `E(K)`; if not given, will
be computed (which could take a long time)
- ``ignore_nonsurj_hypothesis`` (optional: default ``False``) --
If ``True``, then gives the bound coming from Heegner point
index, but without any hypothesis on surjectivity
of the mod-`p` representation.
OUTPUT:
- list - a list of primes such that if `p` divides `Sha(E/K)`, then
`p` is in this list, unless `E/K` has complex multiplication or
analytic rank greater than 2 (in which case we return 0).
- index - the odd part of the index of the Heegner point in the full
group of `K`-rational points on E. (If `E` has CM, returns 0.)
REMARKS:
1) We do not have to assume that the Manin constant is 1
(or a power of 2). If the Manin constant were
divisible by a prime, that prime would get included in
the list of bad primes.
2) We assume the Gross-Zagier theorem is true under the
hypothesis that `gcd(N,D) = 1`, instead of the stronger
hypothesis `gcd(2\cdot N,D)=1` that is in the original
Gross-Zagier paper. That Gross-Zagier is true when
`gcd(N,D)=1` is "well-known" to the experts, but does not
seem to written up well in the literature.
3) Correctness of the computation is guaranteed using
interval arithmetic, under the assumption that the
regulator, square root, and period lattice are
computed to precision at least `10^{-10}`, i.e., they are
correct up to addition or a real number with absolute
value less than `10^{-10}`.
EXAMPLES::
sage: E = EllipticCurve('37a')
sage: E.sha().bound_kolyvagin()
([2], 1)
sage: E = EllipticCurve('141a')
sage: E.sha().an()
1
sage: E.sha().bound_kolyvagin()
([2, 7], 49)
We get no information when the curve has rank 2.::
sage: E = EllipticCurve('389a')
sage: E.sha().bound_kolyvagin()
(0, 0)
sage: E = EllipticCurve('681b')
sage: E.sha().an()
9
sage: E.sha().bound_kolyvagin()
([2, 3], 9)
"""
E = self.Emin
if E.has_cm():
return 0, 0
if D == 0:
D = -5
while not E.satisfies_heegner_hypothesis(D):
D -= 1
if not E.satisfies_heegner_hypothesis(D):
raise ArithmeticError("Discriminant (=%s) must be a fundamental discriminant that satisfies the Heegner hypothesis."%D)
if D == -3 or D == -4:
raise ArithmeticError("Discriminant (=%s) must not be -3 or -4."%D)
eps = E.root_number()
L1_vanishes = E.lseries().L1_vanishes()
if eps == 1 and L1_vanishes:
return 0, 0 # rank even hence >= 2, so Kolyvagin gives nothing.
alpha = sqrt(abs(D))/(2*E.period_lattice().complex_area())
F = E.quadratic_twist(D)
k_E = 2*sqrt(E.conductor()) + 10
k_F = 2*sqrt(F.conductor()) + 10
#k_E = 2
#k_F = 2
MIN_ERR = 1e-10 # we assume that regulator and
# discriminant, etc., computed to this accuracy.
tries = 0
while True:
tries += 1
if tries >= 6:
raise RuntimeError("Too many precision increases in bound_kolyvagin")
if eps == 1: # E has even rank
verbose("Conductor of twist = %s"%F.conductor())
LF1, err_F = F.lseries().deriv_at1(k_F)
LE1, err_E = E.lseries().at1(k_E)
err_F = max(err_F, MIN_ERR)
err_E = max(err_E, MIN_ERR)
if regulator is not None:
hZ = regulator/2
else:
hZ = F.regulator(use_database=True)/2
#print alpha * LE1 * LF1 / hZ
I = RIF(alpha) * RIF(LE1-err_E,LE1+err_E) * RIF(LF1-err_F,LF1+err_F) / hZ
#print I
else: # E has odd rank
if regulator is not None:
hZ = regulator/2
else:
hZ = E.regulator(use_database=True)/2
LE1, err_E = E.lseries().deriv_at1(k_E)
LF1, err_F = F.lseries().at1(k_F)
err_F = max(err_F, MIN_ERR)
err_E = max(err_E, MIN_ERR)
#I = alpha * LE1 * LF1 / hZ
I = RIF(alpha) * RIF(LE1-err_E,LE1+err_E) * RIF(LF1-err_F,LF1+err_F) / hZ
verbose('interval = %s'%I)
t, n = I.is_int()
if t:
break
elif I.absolute_diameter() < 1:
raise RuntimeError("Problem in bound_kolyvagin; square of index is not an integer -- D=%s, I=%s."%(D,I))
verbose("Doubling bounds")
k_E *= 2
k_F *= 2
# end while
# We include 2 since Kolyvagin (in Gross) says nothing there
if n == 0: return 0, 0 # no bound
F = factor(n)
B = [2]
for p, e in factor(n):
if p > 2:
if e%2 != 0:
raise RuntimeError("Problem in bound_kolyvagin; square of index is not a perfect square! D=%s, I=%s, n=%s, e=%s."%(D,I,n,e))
B.append(p)
else:
n /= 2**e # replace n by its odd part
if not ignore_nonsurj_hypothesis:
for p in E.galois_representation().non_surjective():
B.append(p)
B = sorted(set([int(x) for x in B]))
return B, n
def bound_kolyvagin(self, D=0, regulator=None,
ignore_nonsurj_hypothesis=False):
r"""
Given a fundamental discriminant `D \neq -3,-4` that satisfies the
Heegner hypothesis for `E`, return a list of primes so that
Kolyvagin's theorem (as in Gross's paper) implies that any
prime divisor of `Sha` is in this list.
INPUT:
- ``D`` - (optional) a fundamental discriminant < -4 that satisfies the
Heegner hypothesis for `E`; if not given, use the first such `D`
- ``regulator`` -- (optional) regulator of `E(K)`; if not given, will
be computed (which could take a long time)
- ``ignore_nonsurj_hypothesis`` (optional: default ``False``) --
If ``True``, then gives the bound coming from Heegner point
index, but without any hypothesis on surjectivity
of the mod-`p` representation.
OUTPUT:
- list - a list of primes such that if `p` divides `Sha(E/K)`, then
`p` is in this list, unless `E/K` has complex multiplication or
analytic rank greater than 2 (in which case we return 0).
- index - the odd part of the index of the Heegner point in the full
group of `K`-rational points on E. (If `E` has CM, returns 0.)
REMARKS:
1) We do not have to assume that the Manin constant is 1
(or a power of 2). If the Manin constant were
divisible by a prime, that prime would get included in
the list of bad primes.
2) We assume the Gross-Zagier theorem is true under the
hypothesis that `gcd(N,D) = 1`, instead of the stronger
hypothesis `gcd(2\cdot N,D)=1` that is in the original
Gross-Zagier paper. That Gross-Zagier is true when
`gcd(N,D)=1` is "well-known" to the experts, but does not
seem to written up well in the literature.
3) Correctness of the computation is guaranteed using
interval arithmetic, under the assumption that the
regulator, square root, and period lattice are
computed to precision at least `10^{-10}`, i.e., they are
correct up to addition or a real number with absolute
value less than `10^{-10}`.
EXAMPLES::
sage: E = EllipticCurve('37a')
sage: E.sha().bound_kolyvagin()
([2], 1)
sage: E = EllipticCurve('141a')
sage: E.sha().an()
1
sage: E.sha().bound_kolyvagin()
([2, 7], 49)
We get no information when the curve has rank 2.::
sage: E = EllipticCurve('389a')
sage: E.sha().bound_kolyvagin()
(0, 0)
sage: E = EllipticCurve('681b')
sage: E.sha().an()
9
sage: E.sha().bound_kolyvagin()
([2, 3], 9)
"""
E = self.Emin
if E.has_cm():
return 0, 0
if D == 0:
D = -5
while not E.satisfies_heegner_hypothesis(D):
D -= 1
if not E.satisfies_heegner_hypothesis(D):
raise ArithmeticError("Discriminant (=%s) must be a fundamental discriminant that satisfies the Heegner hypothesis."%D)
if D == -3 or D == -4:
raise ArithmeticError("Discriminant (=%s) must not be -3 or -4."%D)
eps = E.root_number()
L1_vanishes = E.lseries().L1_vanishes()
if eps == 1 and L1_vanishes:
return 0, 0 # rank even hence >= 2, so Kolyvagin gives nothing.
alpha = sqrt(abs(D))/(2*E.period_lattice().complex_area())
F = E.quadratic_twist(D)
k_E = 2*sqrt(E.conductor()) + 10
k_F = 2*sqrt(F.conductor()) + 10
#k_E = 2
#k_F = 2
MIN_ERR = 1e-10 # we assume that regulator and
# discriminant, etc., computed to this accuracy.
tries = 0
while True:
tries += 1
if tries >= 6:
raise RuntimeError("Too many precision increases in bound_kolyvagin")
if eps == 1: # E has even rank
verbose("Conductor of twist = %s"%F.conductor())
LF1, err_F = F.lseries().deriv_at1(k_F)
LE1, err_E = E.lseries().at1(k_E)
err_F = max(err_F, MIN_ERR)
err_E = max(err_E, MIN_ERR)
if regulator != None:
hZ = regulator/2
else:
hZ = F.regulator(use_database=True)/2
#print alpha * LE1 * LF1 / hZ
I = RIF(alpha) * RIF(LE1-err_E,LE1+err_E) * RIF(LF1-err_F,LF1+err_F) / hZ
#print I
else: # E has odd rank
if regulator != None:
hZ = regulator/2
else:
hZ = E.regulator(use_database=True)/2
LE1, err_E = E.lseries().deriv_at1(k_E)
LF1, err_F = F.lseries().at1(k_F)
err_F = max(err_F, MIN_ERR)
err_E = max(err_E, MIN_ERR)
#I = alpha * LE1 * LF1 / hZ
I = RIF(alpha) * RIF(LE1-err_E,LE1+err_E) * RIF(LF1-err_F,LF1+err_F) / hZ
verbose('interval = %s'%I)
t, n = I.is_int()
if t:
break
elif I.absolute_diameter() < 1:
raise RuntimeError("Problem in bound_kolyvagin; square of index is not an integer -- D=%s, I=%s."%(D,I))
verbose("Doubling bounds")
k_E *= 2
k_F *= 2
# end while
# We include 2 since Kolyvagin (in Gross) says nothing there
if n == 0: return 0, 0 # no bound
F = factor(n)
B = [2]
for p, e in factor(n):
if p > 2:
if e%2 != 0:
raise RuntimeError("Problem in bound_kolyvagin; square of index is not a perfect square! D=%s, I=%s, n=%s, e=%s."%(D,I,n,e))
B.append(p)
else:
n /= 2**e # replace n by its odd part
if not ignore_nonsurj_hypothesis:
for p in E.galois_representation().non_surjective():
B.append(p)
B = list(set([int(x) for x in B]))
B.sort()
return B, n
- 251568270025211201955389171860338579171675714868104052152789880989805712726614197574887246767925108246607970007160940134370673529705101398997875679835167365081669374673539993436160000*t**3
- 141772430429024326881509616736177148212059744813752208473666088996700368688933789363560771135161864201721524861419389136852260702560567771393655430337183040528733205980885277265100800000*t**2
- 25817606346086956476758470208850883766420383787607030339022713274189365873405154695767797745935894060883806800961601773820707673481632102376182116930107064769426021006200320503617211596800*t
+ 34918206405098505823938790072675572231488655998026261577866691497637535623661745400444768148106948876570405151317417742685700849593772165309178580940805695949542187927076864000)*Dt)
quadric_slice_pol = (
4980990673427087034113103774848375913397675011396681161337606780457883155824640000000000*t**12
- 16313074573215242896867677175985719375664055250377801991087546344967331905536000000000*t**9
- 14852779293587242300314544658084523021409425155052443959294262319432698489552764928000000*t**8
+ 18694126910889886952945780127491545129704079293214429569400282861674612412907520000*t**6
+ 32429224374768702788524801575483580065598417846595577296275963028007688596147404800000*t**5
+ 14763130935033327878568955564665179022508855828282305094488782847988800598441515915673600*t**4
- 7447056930374930458107131157447569387299331973073657492405996702806537404416000*t**3
- 18581243794708202636835504417848386599346688512251081679746508518773002589362454528*t**2
- 16116744082275656666424675660780874575937043631040306492377025123023286892432343685120*t
- 4891341219838850087826096307272910719484535278552470341569283855964428449539674077056375)
quadric_slice_crit = AA.polynomial_root(quadric_slice_pol, RIF(-0.999,-0.998))
aa = AA.polynomial_root(AA.common_polynomial(t**2 - t - 6256320), RIF(-RR(2500.7637305969961), -RR(2500.7637305969956)))
K, a = NumberField(t**2 - t - 6256320, 'a', embedding=aa).objgen()
DiffOps_x, x, Dx = DifferentialOperators(K, 'x')
iint_quadratic_alg = IVP(
dop = (
(8680468749131953125000000000000000000000*x**13
+ (34722222218750000000000000000000*a
- 8680555572048611109375000000000000000000)*x**12
- 43419899820094632213834375000000000000000*x**11
+ (
-173681336093739466250000000000000*a
+ 43420334110275534609369733125000000000000)*x**10
+ 86874920665761352031076792873375000000000*x**9
+ (347503157694622354347850650000000*a
* t**8 +
18694126910889886952945780127491545129704079293214429569400282861674612412907520000
* t**6 +
32429224374768702788524801575483580065598417846595577296275963028007688596147404800000
* t**5 +
14763130935033327878568955564665179022508855828282305094488782847988800598441515915673600
* t**4 -
7447056930374930458107131157447569387299331973073657492405996702806537404416000
* t**3 -
18581243794708202636835504417848386599346688512251081679746508518773002589362454528
* t**2 -
16116744082275656666424675660780874575937043631040306492377025123023286892432343685120
* t -
4891341219838850087826096307272910719484535278552470341569283855964428449539674077056375
)
quadric_slice_crit = AA.polynomial_root(quadric_slice_pol, RIF(-0.999, -0.998))
aa = AA.polynomial_root(AA.common_polynomial(t**2 - t - 6256320),
RIF(-RR(2500.7637305969961), -RR(2500.7637305969956)))
K, a = NumberField(t**2 - t - 6256320, 'a', embedding=aa).objgen()
DiffOps_x, x, Dx = DifferentialOperators(K, 'x')
iint_quadratic_alg = IVP(
dop=((8680468749131953125000000000000000000000 * x**13 +
(34722222218750000000000000000000 * a -
8680555572048611109375000000000000000000) * x**12 -
43419899820094632213834375000000000000000 * x**11 +
(-173681336093739466250000000000000 * a +
43420334110275534609369733125000000000000) * x**10 +
86874920665761352031076792873375000000000 * x**9 +
(347503157694622354347850650000000 * a -
86875789597407167434273839673925325000000) * x**8 -
class DFiniteFunction(object):
r"""
At the moment, this class just provides a simple caching mechanism for
repeated evaluations of a D-Finite function on the real line. It may
evolve to support evaluations on the complex plane, branch cuts, ring
operations on D-Finite functions, and more. Do not expect any API stability.
TESTS::
sage: from ore_algebra import *
sage: from ore_algebra.analytic.function import DFiniteFunction
sage: from ore_algebra.analytic.path import Point
sage: from sage.rings.infinity import AnInfinity
sage: Dops, x, Dx = DifferentialOperators()
sage: f = DFiniteFunction(Dx - 1, [1], max_rad=7/8)
sage: f._disk(Point(pi, dop=Dx-1))
(7/2, 0.5000000000000000)
sage: f = DFiniteFunction(Dx^2 - x,
....: [1/(gamma(2/3)*3^(2/3)), -1/(gamma(1/3)*3^(1/3))],
....: name='my_Ai')
sage: f.plot((-5,5))
Graphics object consisting of 1 graphics primitive
sage: f._known_bound(RBF(RIF(1/3, 2/3)), post_transform=Dops.one())
[0.2...]
sage: f._known_bound(RBF(RIF(-1, 5.99)), post_transform=Dops.one())
[+/- ...]
sage: f._known_bound(RBF(RIF(-1, 6.01)), Dops.one())
[+/- inf]
sage: f = DFiniteFunction((x^2 + 1)*Dx^2 + 2*x*Dx, [0, 1])
sage: f.plot((0, 4))
Graphics object consisting of 1 graphics primitive
sage: f._known_bound(RBF(RIF(1,4)), Dops.one())
[1e+0 +/- 0.3...]
sage: f.approx(1, post_transform=Dx), f.approx(2, post_transform=Dx)
([0.5000000000000...], [0.2000000000000...])
sage: f._known_bound(RBF(RIF(1.1, 2.9)), post_transform=Dx)
[+/- 0.4...]
sage: f._known_bound(RBF(AnInfinity()), Dops.one())
[+/- inf]
sage: f = DFiniteFunction((x + 1)*Dx^2 + 2*x*Dx, [0, 1])
sage: f._known_bound(RBF(RIF(1,10)),Dops.one())
nan
sage: f._known_bound(RBF(AnInfinity()), Dops.one())
nan
sage: f = DFiniteFunction(Dx^2 + 2*x*Dx, [1, -2/sqrt(pi)], name='my_erfc')
sage: f._known_bound(RBF(RIF(-1/2,1/2)), post_transform=Dx^2)
[+/- inf]
sage: _ = f.approx(1/2, post_transform=Dx^2)
sage: _ = f.approx(-1/2, post_transform=Dx^2)
sage: f._known_bound(RBF(RIF(-1/2,1/2)), post_transform=Dx^2)
[+/- 1.5...]
"""
# Stupid, but simple and deterministic caching strategy:
#
# - To any center c = m·2^k with k ∈ ℤ and m *odd*, we associate the disk of
# radius 2^k. Any two disks with the same k have at most one point in
# common.
#
# - Thus, in the case of an equation with at least one finite singular
# point, there is a unique largest disk of the previous collection that
# contains any given ordinary x ∈ ℝ \ ℤ·2^(-∞) while staying “far enough”
# from the singularities.
#
# - When asked to evaluate f at x, we actually compute and store a
# polynomial approximation on (the real trace of) the corresponding disk
# and/or a vector of initial conditions at its center, which can then be
# reused for subsequent evaluations.
#
# - We may additionally want to allow disks (of any radius?) centered at
# real regular singular points, and perhaps, as a special case, at 0.
# These would be used when possible, and one would revert to the other
# family otherwise.
def __init__(self,
dop,
ini,
name="dfinitefun",
max_prec=256,
max_rad=RBF('inf')):
self.dop = dop = DifferentialOperator(dop)
if not isinstance(ini, dict):
ini = {0: ini}
if len(ini) != 1:
# In the future, we should support specifying several vectors of
# initial values.
raise NotImplementedError
self.ini = ini
self.name = name
# Global maximum width for the approximation intervals. In the case of
# equations with no finite singular point, we try to avoid cancellation
# and interval blowup issues by taking polynomial approximations on
# intervals on which the general term of the series doesn't grow too
# large. The expected order of magnitude of the “top of the hump” is
# about exp(κ·|αx|^(1/κ)) and doesn't depend on the base point. We also
# let the user impose a maximum width, even in other cases.
self.max_rad = RBF(max_rad)
if dop.leading_coefficient().is_constant():
kappa, alpha = _growth_parameters(dop)
self.max_rad = self.max_rad.min(1 / (alpha * RBF(kappa)**kappa))
self.max_prec = max_prec
self._inivecs = {}
self._polys = {}
self._sollya_object = None
self._sollya_domain = RIF('-inf', 'inf')
self._max_derivatives = dop.order()
self._update_approx_hook = (lambda *args: None)
def __repr__(self):
return self.name
@cached_method
def _is_everywhere_defined(self):
return not any(
rt.imag().contains_zero()
for rt, mult in self.dop.leading_coefficient().roots(CIF))
def _disk(self, pt):
assert pt.is_real()
# Since approximation disks satisfy 2·rad ≤ dist(center, sing), any
# approximation disk containing pt must have rad ≤ dist(pt, sing)
max_rad = pt.dist_to_sing().min(self.max_rad)
# What we want is the largest such disk containing pt
expo = ZZ(max_rad.log(2).upper().ceil()) - 1 # rad = 2^expo
logger.log(logging.DEBUG - 2, "max_rad = %s, expo = %s", max_rad, expo)
while True:
approx_pt = pt.approx_abs_real(-expo)
mantissa = (approx_pt.squash() >> expo).floor()
if ZZ(mantissa) % 2 == 0:
mantissa += 1
center = mantissa << expo
dist = Point(center, pt.dop).dist_to_sing()
rad = RBF.one() << expo
logger.log(
logging.DEBUG - 2,
"candidate disk: approx_pt = %s, mantissa = %s, "
"center = %s, dist = %s, rad = %s", approx_pt, mantissa,
center, dist, rad)
if safe_ge(dist >> 1, rad):
break
expo -= 1
logger.debug("disk for %s: center=%s, rad=%s", pt, center, rad)
# pt may be a ball with nonzero radius: check that it is contained in
# our candidate disk
log = RBF.zero() if 0 in approx_pt else approx_pt.abs().log(2)
F = RealBallField(ZZ((expo - log).max(0).upper().ceil()) + 10)
dist_to_center = (F(approx_pt) - F(center)).abs()
if not safe_le(dist_to_center, rad):
assert not safe_gt((approx_pt.squash() - center).squash(), rad)
logger.info("check that |%s - %s| < %s failed", approx_pt, center,
rad)
return None, None
# exactify center so that subsequent computations are not limited by the
# precision of its parent
center = QQ(center)
return center, rad
def _rad(self, center):
return RBF.one() << QQ(center).valuation(2)
def _path_to(self, dest, prec=None):
r"""
Find a path from a point with known "initial" values to pt
"""
# TODO:
# - attempt to start as close as possible to the destination
# [and perhaps add logic to change for a starting point with exact
# initial values if loosing too much precision]
# - return a path passing through "interesting" points (and cache the
# associated initial vectors)
start, ini = self.ini.items()[0]
return ini, [start, dest]
# Having the update (rather than the full test-and-update) logic in a
# separate method is convenient to override it in subclasses.
def _update_approx(self, center, rad, prec, derivatives):
ini, path = self._path_to(center, prec)
eps = RBF.one() >> prec
# keep="all" won't do anything until _path_to returns better paths
ctx = ancont.Context(self.dop, path, eps, keep="all")
pairs = ancont.analytic_continuation(ctx, ini=ini)
for (vert, val) in pairs:
known = self._inivecs.get(vert)
if known is None or known[0].accuracy() < val[0][0].accuracy():
self._inivecs[vert] = [c[0] for c in val]
logger.info(
"computing new polynomial approximations: "
"ini=%s, path=%s, rad=%s, eps=%s, ord=%s", ini, path, rad, eps,
derivatives)
polys = polapprox.doit(self.dop,
ini=ini,
path=path,
rad=rad,
eps=eps,
derivatives=derivatives,
x_is_real=True,
economization=polapprox.chebyshev_economization)
logger.info("...done")
approx = self._polys.get(center, [])
new_approx = []
for ord, pol in enumerate(polys):
if ord >= len(approx) or approx[ord].prec < prec:
new_approx.append(RealPolApprox(pol, prec))
else:
new_approx.append(approx[ord])
self._update_approx_hook(center, rad, polys)
self._polys[center] = new_approx
return polys
def _sollya_annotate(self, center, rad, polys):
import sagesollya as sollya
logger = logging.getLogger(__name__ + ".sollya")
logger.info("calling annotatefunction() on %s derivatives", len(polys))
center = QQ(center)
sollya_fun = self._sollya_object
# sollya keeps all annotations, let's not bother with selecting
# the best one
for ord, pol0 in enumerate(polys):
pol = ZZ(ord).factorial() * pol0
sollya_pol = sum(
[c.center() * sollya.x**k for k, c in enumerate(pol)])
dom = RIF(center - rad,
center + rad) # XXX: dangerous when inexact
err_pol = pol.map_coefficients(lambda c: c - c.squash())
err = RIF(err_pol(RBF.zero().add_error(rad)))
with sollya.settings(display=sollya.dyadic):
logger = logging.getLogger(__name__ + ".sollya.annotate")
logger.debug("annotatefunction(%s, %s, %s, %s, %s);",
sollya_fun, sollya_pol, sollya.SollyaObject(dom),
sollya.SollyaObject(err),
sollya.SollyaObject(center))
sollya.annotatefunction(sollya_fun, sollya_pol, dom, err, center)
sollya_fun = sollya.diff(sollya_fun)
logger.info("...done")
def _known_bound(self, iv, post_transform):
post_transform = normalize_post_transform(self.dop, post_transform)
Balls = iv.parent()
Ivs = RealIntervalField(Balls.precision())
mid = [
c for c in self._polys.keys()
if Balls(c).add_error(self._rad(c)).overlaps(iv)
]
mid.sort()
rad = [self._rad(c) for c in mid]
crude_bound = (Balls(AnInfinity())
if self._is_everywhere_defined() else Balls('nan'))
if len(mid) < 1 or not mid[0] - rad[0] <= iv <= mid[-1] + rad[-1]:
return crude_bound
if not all(
safe_eq(mid[i] + rad[i], mid[i + 1] - rad[i + 1])
for i in range(len(mid) - 1)):
return crude_bound
bound = None
for c, r in zip(mid, rad):
if len(self._polys[c]) <= post_transform.order():
return crude_bound
polys = [a.pol for a in self._polys[c]]
dom = Balls(Ivs(Balls(c).add_error(r)).intersection(Ivs(iv)))
reduced_dom = dom - c
img = sum(
ZZ(j).factorial() * coeff(dom) * polys[j](reduced_dom)
for j, coeff in enumerate(post_transform))
bound = img if bound is None else bound.union(img)
return bound
def approx(self, pt, prec=None, post_transform=None):
r"""
TESTS::
sage: from ore_algebra import *
sage: from ore_algebra.analytic.function import DFiniteFunction
sage: DiffOps, x, Dx = DifferentialOperators()
sage: h = DFiniteFunction(Dx^3-1, [0, 0, 1])
sage: h.approx(0, post_transform=Dx^2)
[2.0000000000000...]
sage: f = DFiniteFunction((x^2 + 1)*Dx^2 + 2*x*Dx, [0, 1], max_prec=20)
sage: f.approx(1/3, prec=10)
[0.32...]
sage: f.approx(1/3, prec=40)
[0.321750554396...]
sage: f.approx(1/3, prec=10, post_transform=Dx)
[0.9...]
sage: f.approx(1/3, prec=40, post_transform=Dx)
[0.900000000000...]
sage: f.approx(1/3, prec=10, post_transform=Dx^2)
[-0.54...]
sage: f.approx(1/3, prec=40, post_transform=Dx^2)
[-0.540000000000...]
"""
pt = Point(pt, self.dop)
if prec is None:
prec = _guess_prec(pt)
if post_transform is None:
post_transform = self.dop.parent().one()
derivatives = min(post_transform.order() + 1, self._max_derivatives)
post_transform = normalize_post_transform(self.dop, post_transform)
if prec >= self.max_prec or not pt.is_real():
logger.info(
"performing high-prec evaluation "
"(pt=%s, prec=%s, post_transform=%s)", pt, prec,
post_transform)
ini, path = self._path_to(pt)
eps = RBF.one() >> prec
return self.dop.numerical_solution(ini,
path,
eps,
post_transform=post_transform)
center, rad = self._disk(pt)
if center is None:
# raise NotImplementedError
logger.info("falling back on generic evaluator")
ini, path = self._path_to(pt)
eps = RBF.one() >> prec
return self.dop.numerical_solution(ini,
path,
eps,
post_transform=post_transform)
approx = self._polys.get(center, [])
Balls = RealBallField(prec)
# due to the way the polynomials are recomputed, the precisions attached
# to the successive derivatives are nonincreasing
if (len(approx) < derivatives or approx[derivatives - 1].prec < prec):
polys = self._update_approx(center, rad, prec, derivatives)
else:
polys = [a.pol for a in approx]
bpt = Balls(pt.value)
reduced_pt = bpt - Balls(center)
val = sum(
ZZ(j).factorial() * coeff(bpt) * polys[j](reduced_pt)
for j, coeff in enumerate(post_transform))
return val
def __call__(self, x, prec=None):
return self.approx(x, prec=prec)
def plot(self, xrange, **options):
r"""
Plot this function.
The plot is intended to give an idea of the accuracy of the evaluations
that led to it. However, it may not be a rigorous enclosure of the graph
of the function.
EXAMPLES::
sage: from ore_algebra import *
sage: from ore_algebra.analytic.function import DFiniteFunction
sage: DiffOps, x, Dx = DifferentialOperators()
sage: f = DFiniteFunction(Dx^2 - x,
....: [1/(gamma(2/3)*3^(2/3)), -1/(gamma(1/3)*3^(1/3))])
sage: plot(f, (-10, 5), color='black')
Graphics object consisting of 1 graphics primitive
"""
mids = generate_plot_points(lambda x: self.approx(x, 20).mid(),
xrange,
plot_points=200)
ivs = [(x, self.approx(x, 20)) for x, _ in mids]
bounds = [(x, y.upper()) for x, y in ivs]
bounds += [(x, y.lower()) for x, y in reversed(ivs)]
options.setdefault('aspect_ratio', 'automatic')
g = plot.polygon(bounds, thickness=1, **options)
return g
def plot_known(self):
r"""
TESTS::
sage: from ore_algebra import *
sage: from ore_algebra.analytic.function import DFiniteFunction
sage: DiffOps, x, Dx = DifferentialOperators()
sage: f = DFiniteFunction((x^2 + 1)*Dx^2 + 2*x*Dx, [0, 1])
sage: f(-10, 100) # long time
[-1.4711276743037345918528755717...]
sage: f.approx(5, post_transform=Dx) # long time
[0.038461538461538...]
sage: f.plot_known() # long time
Graphics object consisting of ... graphics primitives
"""
g = plot.Graphics()
for center, polys in self._polys.iteritems():
center, rad = self._disk(Point(center, self.dop))
xrange = (center - rad).mid(), (center + rad).mid()
for i, a in enumerate(polys):
# color palette copied from sage.plot.plot.plot
color = plot.Color((0.66666 + i * 0.61803) % 1,
1,
0.4,
space='hsl')
Balls = a.pol.base_ring()
g += plot.plot(lambda x: a.pol(Balls(x)).mid(),
xrange,
color=color)
g += plot.text(str(a.prec), (center, a.pol(center).mid()),
color=color)
for point, ini in self._inivecs.iteritems():
g += plot.point2d((point, 0), size=50)
return g
def _sollya_(self):
r"""
EXAMPLES::
sage: import logging; logging.basicConfig(level=logging.INFO)
sage: logger = logging.getLogger("ore_algebra.analytic.function.sollya")
sage: logger.setLevel(logging.DEBUG)
sage: import ore_algebra
sage: DiffOps, x, Dx = ore_algebra.DifferentialOperators()
sage: from ore_algebra.analytic.function import DFiniteFunction
sage: f = DFiniteFunction(Dx - 1, [1])
sage: import sagesollya as sollya # optional - sollya
sage: sollya.plot(f, sollya.Interval(0, 1)) # not tested
...
"""
if self._sollya_object is not None:
return self._sollya_object
import sagesollya as sollya
logger = logging.getLogger(__name__ + ".sollya.eval")
Dx = self.dop.parent().gen()
def wrapper(pt, ord, prec):
if RBF(pt.diameter()) >= self.max_rad / 4:
return self._known_bound(RBF(pt), post_transform=Dx**ord)
try:
val = self.approx(pt, prec, post_transform=Dx**ord)
except Exception:
logger.info("pt=%s, ord=%s, prec=%s, error",
pt,
ord,
prec,
exc_info=(pt.absolute_diameter() < .5))
return RIF('nan')
logger.debug("pt=%s, ord=%s, prec=%s, val=%s", pt, ord, prec, val)
if not pt.overlaps(self._sollya_domain):
backtrace = sollya.getbacktrace()
logger.debug("%s not in %s", pt.str(style='brackets'),
self._sollya_domain.str(style='brackets'))
logger.debug("sollya backtrace: %s", [
sollya.objectname(t.struct.called_proc) for t in backtrace
])
return val
wrapper.__name__ = self.name
self._sollya_object = sollya.sagefunction(wrapper)
for pt, ini in self.ini.iteritems():
pt = RIF(pt)
if pt.is_exact():
fun = self._sollya_object
for ord, val in enumerate(ini):
try:
sollya.annotatefunction(fun, val, pt, RIF.zero())
except TypeError:
logger.info("annotation failed: D^%s(%s)(%s) = %s",
ord, self.name, pt, val)
fun = sollya.diff(fun)
self._update_approx_hook = self._sollya_annotate
return self._sollya_object
def _sollya_(self):
r"""
EXAMPLES::
sage: import logging; logging.basicConfig(level=logging.INFO)
sage: logger = logging.getLogger("ore_algebra.analytic.function.sollya")
sage: logger.setLevel(logging.DEBUG)
sage: import ore_algebra
sage: DiffOps, x, Dx = ore_algebra.DifferentialOperators()
sage: from ore_algebra.analytic.function import DFiniteFunction
sage: f = DFiniteFunction(Dx - 1, [1])
sage: import sagesollya as sollya # optional - sollya
sage: sollya.plot(f, sollya.Interval(0, 1)) # not tested
...
"""
if self._sollya_object is not None:
return self._sollya_object
import sagesollya as sollya
logger = logging.getLogger(__name__ + ".sollya.eval")
Dx = self.dop.parent().gen()
def wrapper(pt, ord, prec):
if RBF(pt.diameter()) >= self.max_rad / 4:
return self._known_bound(RBF(pt), post_transform=Dx**ord)
try:
val = self.approx(pt, prec, post_transform=Dx**ord)
except Exception:
logger.info("pt=%s, ord=%s, prec=%s, error",
pt,
ord,
prec,
exc_info=(pt.absolute_diameter() < .5))
return RIF('nan')
logger.debug("pt=%s, ord=%s, prec=%s, val=%s", pt, ord, prec, val)
if not pt.overlaps(self._sollya_domain):
backtrace = sollya.getbacktrace()
logger.debug("%s not in %s", pt.str(style='brackets'),
self._sollya_domain.str(style='brackets'))
logger.debug("sollya backtrace: %s", [
sollya.objectname(t.struct.called_proc) for t in backtrace
])
return val
wrapper.__name__ = self.name
self._sollya_object = sollya.sagefunction(wrapper)
for pt, ini in self.ini.iteritems():
pt = RIF(pt)
if pt.is_exact():
fun = self._sollya_object
for ord, val in enumerate(ini):
try:
sollya.annotatefunction(fun, val, pt, RIF.zero())
except TypeError:
logger.info("annotation failed: D^%s(%s)(%s) = %s",
ord, self.name, pt, val)
fun = sollya.diff(fun)
self._update_approx_hook = self._sollya_annotate
return self._sollya_object
def mcmullen_genus2_prototype(w, h, t, e, rel=0):
r"""
McMullen prototypes in the stratum H(2).
These prototype appear at least in McMullen "Teichmüller curves in genus
two: Discriminant and spin" (2004). The notation from that paper are
quadruple ``(a, b, c, e)`` which translates in our notation as
``w = b``, ``h = c``, ``t = a`` (and ``e = e``).
The associated discriminant is `D = e^2 + 4 wh`.
If ``rel`` is a positive parameter (less than w-lambda) the surface belongs
to the eigenform locus in H(1,1).
EXAMPLES::
sage: from flatsurf import translation_surfaces
sage: from surface_dynamics import AbelianStratum
sage: prototypes = {
....: 5: [(1,1,0,-1)],
....: 8: [(1,1,0,-2), (2,1,0,0)],
....: 9: [(2,1,0,-1)],
....: 12: [(1,2,0,-2), (2,1,0,-2), (3,1,0,0)],
....: 13: [(1,1,0,-3), (3,1,0,-1), (3,1,0,1)],
....: 16: [(3,1,0,-2), (4,1,0,0)],
....: 17: [(1,2,0,-3), (2,1,0,-3), (2,2,0,-1), (2,2,1,-1), (4,1,0,-1), (4,1,0,1)],
....: 20: [(1,1,0,-4), (2,2,1,-2), (4,1,0,-2), (4,1,0,2)],
....: 21: [(1,3,0,-3), (3,1,0,-3)],
....: 24: [(1,2,0,-4), (2,1,0,-4), (3,2,0,0)],
....: 25: [(2,2,0,-3), (2,2,1,-3), (3,2,0,-1), (4,1,0,-3)]}
sage: for D in sorted(prototypes):
....: for w,h,t,e in prototypes[D]:
....: T = translation_surfaces.mcmullen_genus2_prototype(w,h,t,e)
....: assert T.stratum() == AbelianStratum(2)
....: assert (D.is_square() and T.base_ring() is QQ) or (T.base_ring().polynomial().discriminant() == D)
An example with some relative homology::
sage: U8 = translation_surfaces.mcmullen_genus2_prototype(2,1,0,0,1/4) # discriminant 8
sage: U12 = translation_surfaces.mcmullen_genus2_prototype(3,1,0,0,3/10) # discriminant 12
sage: U8.stratum()
H_2(1^2)
sage: U8.base_ring().polynomial().discriminant()
8
sage: U8.j_invariant()
(
[4 0]
(0), (0), [0 2]
)
sage: U12.stratum()
H_2(1^2)
sage: U12.base_ring().polynomial().discriminant()
12
sage: U12.j_invariant()
(
[6 0]
(0), (0), [0 2]
)
"""
w = ZZ(w)
h = ZZ(h)
t = ZZ(t)
e = ZZ(e)
g = w.gcd(h)
gg = g.gcd(t).gcd(e)
if w <= 0 or h <= 0 or t < 0 or t >= g or not g.gcd(t).gcd(
e).is_one() or e + h >= w:
raise ValueError("invalid parameters")
x = polygen(QQ)
poly = x**2 - e * x - w * h
if poly.is_irreducible():
emb = AA.polynomial_root(poly, RIF(0, w))
K = NumberField(poly, 'l', embedding=emb)
l = K.gen()
else:
K = QQ
D = e**2 + 4 * w * h
d = D.sqrt()
l = (e + d) / 2
rel = K(rel)
# (lambda,lambda) square on top
# twisted (w,0), (t,h)
s = Surface_list(base_ring=K)
if rel:
if rel < 0 or rel > w - l:
raise ValueError("invalid rel argument")
s.add_polygon(
polygons(vertices=[(0, 0), (l, 0), (l + rel, l), (rel, l)],
ring=K))
s.add_polygon(
polygons(vertices=[(0, 0), (rel, 0), (rel + l, 0), (w, 0),
(w + t, h), (l + rel + t, h), (t + l, h),
(t, h)],
ring=K))
s.set_edge_pairing(0, 1, 0, 3)
s.set_edge_pairing(0, 0, 1, 6)
s.set_edge_pairing(0, 2, 1, 1)
s.set_edge_pairing(1, 2, 1, 4)
s.set_edge_pairing(1, 3, 1, 7)
s.set_edge_pairing(1, 0, 1, 5)
else:
s.add_polygon(
polygons(vertices=[(0, 0), (l, 0), (l, l), (0, l)], ring=K))
s.add_polygon(
polygons(vertices=[(0, 0), (l, 0), (w, 0), (w + t, h),
(l + t, h), (t, h)],
ring=K))
s.set_edge_pairing(0, 1, 0, 3)
s.set_edge_pairing(0, 0, 1, 4)
s.set_edge_pairing(0, 2, 1, 0)
s.set_edge_pairing(1, 1, 1, 3)
s.set_edge_pairing(1, 2, 1, 5)
s.set_immutable()
return TranslationSurface(s)
def arnoux_yoccoz(genus):
r"""
Construct the Arnoux-Yoccoz surface of genus 3 or greater.
This presentation of the surface follows Section 2.3 of
Joshua P. Bowman's paper "The Complete Family of Arnoux-Yoccoz
Surfaces."
EXAMPLES::
sage: from flatsurf import *
sage: s = translation_surfaces.arnoux_yoccoz(4)
sage: TestSuite(s).run()
sage: s.is_delaunay_decomposed()
True
sage: s = s.canonicalize()
sage: field=s.base_ring()
sage: a = field.gen()
sage: from sage.matrix.constructor import Matrix
sage: m = Matrix([[a,0],[0,~a]])
sage: ss = m*s
sage: ss = ss.canonicalize()
sage: s.cmp(ss) == 0
True
The Arnoux-Yoccoz pseudo-Anosov are known to have (minimal) invariant
foliations with SAF=0::
sage: S3 = translation_surfaces.arnoux_yoccoz(3)
sage: Jxx, Jyy, Jxy = S3.j_invariant()
sage: Jxx.is_zero() and Jyy.is_zero()
True
sage: Jxy
[ 0 2 0]
[ 2 -2 0]
[ 0 0 2]
sage: S4 = translation_surfaces.arnoux_yoccoz(4)
sage: Jxx, Jyy, Jxy = S4.j_invariant()
sage: Jxx.is_zero() and Jyy.is_zero()
True
sage: Jxy
[ 0 2 0 0]
[ 2 -2 0 0]
[ 0 0 2 2]
[ 0 0 2 0]
"""
g = ZZ(genus)
assert g >= 3
x = polygen(AA)
p = sum([x**i for i in range(1, g + 1)]) - 1
cp = AA.common_polynomial(p)
alpha_AA = AA.polynomial_root(cp, RIF(1 / 2, 1))
field = NumberField(alpha_AA.minpoly(), 'alpha', embedding=alpha_AA)
a = field.gen()
V = VectorSpace(field, 2)
p = [None for i in range(g + 1)]
q = [None for i in range(g + 1)]
p[0] = V(((1 - a**g) / 2, a**2 / (1 - a)))
q[0] = V((-a**g / 2, a))
p[1] = V((-(a**(g - 1) + a**g) / 2, (a - a**2 + a**3) / (1 - a)))
p[g] = V((1 + (a - a**g) / 2, (3 * a - 1 - a**2) / (1 - a)))
for i in range(2, g):
p[i] = V(((a - a**i) / (1 - a), a / (1 - a)))
for i in range(1, g + 1):
q[i] = V(((2 * a - a**i - a**(i + 1)) / (2 * (1 - a)),
(a - a**(g - i + 2)) / (1 - a)))
P = ConvexPolygons(field)
s = Surface_list(field)
T = [None] * (2 * g + 1)
Tp = [None] * (2 * g + 1)
from sage.matrix.constructor import Matrix
m = Matrix([[1, 0], [0, -1]])
for i in range(1, g + 1):
# T_i is (P_0,Q_i,Q_{i-1})
T[i] = s.add_polygon(
P(edges=[q[i] - p[0], q[i - 1] - q[i], p[0] - q[i - 1]]))
# T_{g+i} is (P_i,Q_{i-1},Q_{i})
T[g + i] = s.add_polygon(
P(edges=[q[i - 1] - p[i], q[i] - q[i - 1], p[i] - q[i]]))
# T'_i is (P'_0,Q'_{i-1},Q'_i)
Tp[i] = s.add_polygon(m * s.polygon(T[i]))
# T'_{g+i} is (P'_i,Q'_i, Q'_{i-1})
Tp[g + i] = s.add_polygon(m * s.polygon(T[g + i]))
for i in range(1, g):
s.change_edge_gluing(T[i], 0, T[i + 1], 2)
s.change_edge_gluing(Tp[i], 2, Tp[i + 1], 0)
for i in range(1, g + 1):
s.change_edge_gluing(T[i], 1, T[g + i], 1)
s.change_edge_gluing(Tp[i], 1, Tp[g + i], 1)
#P 0 Q 0 is paired with P' 0 Q' 0, ...
s.change_edge_gluing(T[1], 2, Tp[g], 2)
s.change_edge_gluing(Tp[1], 0, T[g], 0)
# P1Q1 is paired with P'_g Q_{g-1}
s.change_edge_gluing(T[g + 1], 2, Tp[2 * g], 2)
s.change_edge_gluing(Tp[g + 1], 0, T[2 * g], 0)
# P1Q0 is paired with P_{g-1} Q_{g-1}
s.change_edge_gluing(T[g + 1], 0, T[2 * g - 1], 2)
s.change_edge_gluing(Tp[g + 1], 2, Tp[2 * g - 1], 0)
# PgQg is paired with Q1P2
s.change_edge_gluing(T[2 * g], 2, T[g + 2], 0)
s.change_edge_gluing(Tp[2 * g], 0, Tp[g + 2], 2)
for i in range(2, g - 1):
# PiQi is paired with Q'_i P'_{i+1}
s.change_edge_gluing(T[g + i], 2, Tp[g + i + 1], 2)
s.change_edge_gluing(Tp[g + i], 0, T[g + i + 1], 0)
s.set_immutable()
return TranslationSurface(s)
