def __init__(self, f, n, name='y'):
R = f.parent()
assert R.variable_name() != name, "variable names must be distinct"
k = R.base_ring()
assert k.characteristic() == 0 or ZZ(n).gcd(k.characteristic(
)) == 1, "the characteristic of the base field must be prime to n"
ff = f.factor()
assert gcd(
[m for g, m in ff] +
[n]) == 1, "the equation y^n=f(x) must be absolutely irreducible"
self._n = n
self._f = f
self._ff = ff
self._name = name
FX = FunctionField(k, R.variable_name())
S = PolynomialRing(FX, 'T')
T = S.gen()
FY = FX.extension(T**n - FX(f), name)
self._function_field = FY
self._constant_base_field = k
self._extra_extension_degree = ZZ(1)
self._covering_degree = n
self._coordinate_functions = self.coordinate_functions()
self._field_of_constants_degree = ZZ(1)
self._is_separable = True
def make_function_field(k):
r"""
Return the function field corresponding to this field.
INPUT:
- ``k`` -- the residue field of a discrete valuation on a function field.
OUTPUT:
the field `k` as a function field; this is rather experimental..
"""
from sage.rings.function_field.function_field import is_FunctionField
if is_FunctionField(k):
return k
if hasattr(k, "base_field"):
# it seems that k is an extension of a rational function field
k0 = k.base_field()
f0 = FunctionField(k0.base_ring(), k0.base().variable_name())
G = k.modulus().change_ring(f0)
# G *should* be irreducible, but unfortunately this is sometimes
# not true, due to a bug in Sage's factoring
assert G.is_irreducible(), "G must be irreducible! This problem is probably caused by a bug in Sage's factoring."
return f0.extension(G, 'y')
else:
# it seems that k is simply a rational function field
return FunctionField(k.base_ring(), k.variable_name())
def _test(self):
from sage.all import FunctionField, QQ, PolynomialRing
K = FunctionField(QQ, 'x')
x = K.gen()
R = PolynomialRing(K, 'y')
y = R.gen()
L = K.extension(y**3 - 1 / x**3 * y + 2 / x**4, 'y')
v = K.valuation(x)
v.extensions(L)
def time_is_semistable(self):
K = FunctionField(QQ, 'x')
x = K.gen()
R = PolynomialRing(K, 'T')
T = R.gen()
f = 64 * x**3 * T - 64 * x**3 + 36 * x**2 * T**2 + 208 * x**2 * T + 192 * x**2 + 9 * x * T**3 + 72 * x * T**2 + 240 * x * T + 64 * x + T**4 + 9 * T**3 + 52 * T**2 + 48 * T
L = K.extension(f, 'y')
Y = SmoothProjectiveCurve(L)
v = QQ.valuation(13)
M = SemistableModel(Y, v)
return M.is_semistable()
def __init__(self, Y, vK):
p = vK.residue_field().characteristic()
assert p == Y.covering_degree()
assert isinstance(Y, SuperellipticCurve)
f = Y.polynomial()
R = f.parent()
assert R.base_ring() is vK.domain(
), "the domain of vK must be the base field of f"
assert p == vK.residue_field().characteristic(
), "the exponent p must be the residue characteristic of vK"
assert not p.divides(f.degree()), "the degree of f must be prime to p"
self._p = p
self._base_valuation = vK
v0 = GaussValuation(R, vK)
phi, psi, f1 = v0.monic_integral_model(f)
# now f1 = phi(f).monic()
if f1 != f.monic():
print(
"We make the coordinate change (x --> %s) in order to work with an integral polynomial f"
% phi(R.gen()))
self._f = f1
a = phi(f).leading_coefficient()
pi = vK.uniformizer()
m = (vK(a) / p).floor()
a = pi**(-p * m) * a
self._a = a
FX = FunctionField(vK.domain(), R.variable_name())
S = PolynomialRing(FX, 'T')
T = S.gen()
FY = FX.extension(T**p - FX(a * f1), 'y')
self._FX = FX
self._FY = FY
Y = SmoothProjectiveCurve(FY)
self._curve = Y
else:
self._f = f.monic()
self._a = vK.domain().one()
self._FY = Y.function_field()
self._FX = Y.rational_function_field()
self._curve = Y
X = BerkovichLine(self._FX, vK)
self._X = X
def __init__(self, f, name='y'):
R = f.parent()
assert R.variable_name() != name, "variable names must be distinct"
k = R.base_ring()
assert k.characteristic() != 3,\
"the characteristic of the base field must not be 3"
assert f.gcd(f.derivative()).is_one(), "f must be separable"
self._n = 3
self._f = f
self._ff = f.factor()
self._name = name
FX = FunctionField(k, R.variable_name())
S = PolynomialRing(FX, 'T')
T = S.gen()
FY = FX.extension(T**3 - FX(f), name)
self._function_field = FY
self._constant_base_field = k
self._extra_extension_degree = ZZ(1)
self._covering_degree = 3
self._coordinate_functions = self.coordinate_functions()
self._field_of_constants_degree = ZZ(1)
self._is_separable = True
def base_change_of_function_field(F, L):
r"""
Return the base change of a function field with respect to an extension
of the base field.
INPUT:
- ``F`` -- a function field over a field `K`
- ``L`` -- a finite field extension of `K`
OUTPUT:
the function field `F_L:= F\otimes_K L`.
It is not checked whether the result is really a function field.
"""
F0 = F.base()
F0L = FunctionField(L, F0.variable_name())
if F0 == F:
# F is a rational function field
return F0L
else:
return F0L.extension(F.polynomial().change_ring(F0L), F.variable_name())