def __init__(self, Z, v):
self._inertial_component = Z.inertial_component()
self._lower_component = Z
self._base_valuation = Z.base_valuation()
self._valuation = v
F, to_F, from_F = make_function_field(v.residue_field())
self._component = SmoothProjectiveCurve(F, Z.constant_base_field())
# we have to construct the embedding of the function field of Z into
# the function field of W (this component), which gives rise to the
# natural map W-->Z. The defining property of this embedding is its
# compatibility with the canonical embedding of FXL into FYL
v0 = Z.valuation()
F0 = Z.function_field()
# we need the isomorphism between the residue field of v0 and F0:
from_F0 = Z._from_function_field
# we have to find an element x0 in F which reduces to the generator
# of F0
x0 = to_F(v.reduce(v0.lift(from_F0(F0.gen()))))
# we also have to define the right map between the constant base fields
k0 = F0.constant_base_field() # note: this may not the equal to the
# constant base field of Z
k = F.constant_base_field() # and this may not be equal to the cbf of W
if k0.is_prime_field():
# there is no choice; we can take the identity on k0:
phi_base = k0.hom(k0)
else:
# we have to find the element in k to which a generator
# of k0 has to be mapped
alpha = to_F(v.reduce((v0.lift(from_F0(k0.gen())))))
phi_base = k0.hom(alpha, k)
phi = F0.hom(x0, phi_base)
self._map_to_lower_component = MorphismOfSmoothProjectiveCurves(
self._component, Z.component(), phi)
def map_to_lower_component(self):
r"""
Return the natural map from this upper component to the lower component beneath.
"""
# we hope that this works by the natural inclusion of function fields:
return MorphismOfSmoothProjectiveCurves(self.curve(), self.lower_component().curve())
def map_to_inertial_component(self):
r"""
Return the natural map from this lower component to its inertial component.
"""
# we hope that this works by the natural inclusion of function fields:
return MorphismOfSmoothProjectiveCurves(self.curve(),
self.inertial_component().curve(), self._phi)
def structure_map(self):
r""" Return the canonical map from this curve to the projective line.
"""
if hasattr(self, "_structure_map"):
return self._structure_map
else:
from mclf.curves.morphisms_of_smooth_projective_curves import\
MorphismOfSmoothProjectiveCurves
X = SmoothProjectiveCurve(self.rational_function_field())
self._structure_map = MorphismOfSmoothProjectiveCurves(self, X)
return self._structure_map
def __init__(self, Z0, vL, v, phi):
from mclf.curves.smooth_projective_curves import make_finite_field
self._inertial_component = Z0
self._valuation = v
self._base_valuation = vL
F, to_F, from_F = make_function_field(v.residue_field())
self._to_function_field = to_F
self._from_function_field = from_F
k, _, _ = make_finite_field(vL.residue_field())
# we force k to be the constant base field of the component;
# note that we can ignore the isomorphism, because
# - as an absolute finite field, k can be coerced into F,
# - the embedding itself is irrelevant; only the image matters
self._component = SmoothProjectiveCurve(F, k)
# construct the natural morphis Z-->Z0;
# the corresponding morphis of function fields is the given embedding
# phi of the function field of Z0 into the residue field of v,
# composed with the canonical isomorphism to F
self._map_to_inertial_component = MorphismOfSmoothProjectiveCurves(
self.component(), Z0.component(), phi.post_compose(to_F))