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