def lower_components(self, u=Infinity):
r"""
Return the lower components relative to a given extension of the base field.
INPUT:
- ``u`` -- an integer, or ``Infinity`` (default: ``Infinity``)
OUTPUT: the list of lower components of the model of the reduction tree
lying over this base component. If `u=\infty` then these components
are computed over the splitting field of the base component. Otherwise,
`u` is assumed to be a break in the ramification filtration of the
splitting field, and then we use the corresponding subfield.
The entries of the list correspond to the irreducible components of the
special fiber of the `v_L`-model `\mathcal{X}` (the normalization of
`\mathcal{X}_0`) lying over the given inertial component.
"""
if u in self._lower_components.keys():
return self._lower_components[u]
# we have already computed this before!
L = self.splitting_field()
if u == Infinity:
vL = L.valuation()
else:
L = L.ramification_subfield(u)
vL = L.valuation()
FX = self.berkovich_line().function_field()
L = vL.domain() # actually, this is the number field underlying L
FXL = FunctionField(L, FX.variable_name())
XL = BerkovichLine(FXL, vL)
f, s = self.type_II_point().discoid()
f = FXL(f)
v0 = self.valuation()
F0 = self.function_field()
x0 = FXL(v0.lift(v0.residue_field().gen()))
k0 = F0.constant_base_field()
lower_valuations = [xi.valuation() for xi in XL.points_from_inequality(f, s)]
lower_components = []
for v in lower_valuations:
F1 = make_function_field(v.residue_field())
# we need to find the correct inclusion of F0 into F1
if k0.is_prime_field():
phi = F0.hom(F1(v.reduce(x0)))
else:
k1 = F1.constant_base_field()
theta0 = FXL(v0.lift(k0.gen()))
psi = k0.hom([k1(F1(v.reduce(theta0)))])
phi = F0.hom(F1(v.reduce(x0)), psi)
lower_components.append(LowerComponent(self, vL, v, phi))
self._lower_components[u] = lower_components
return lower_components
def lower_components(self, u=Infinity):
r"""
Return the lower components relative to a given extension of the base field.
INPUT:
- ``u`` -- an integer, or ``Infinity`` (default: ``Infinity``)
OUTPUT: the list of lower components of the model of the reduction tree
lying over this base component. If `u=\infty` then these components
are computed over the splitting field of the base component. Otherwise,
`u` is assumed to be a break in the ramification filtration of the
splitting field, and then we use the corresponding subfield.
The entries of the list correspond to the irreducible components of the
special fiber of the `v_L`-model `\mathcal{X}` (the normalization of
`\mathcal{X}_0`) lying over the given inertial component. By definition,
the constant base field of these components is the residue field of
`v_L` (and it may differ from its field of constants).
"""
if u in self._lower_components.keys():
return self._lower_components[u]
# we have already computed this before!
L = self.splitting_field()
if u == Infinity:
vL = L.valuation()
else:
L = L.ramification_subfield(u)
vL = L.valuation()
# we construct the base change of the underlying Berkovich line
# to L:
FX = self.berkovich_line().function_field()
L = vL.domain() # actually, this is the number field underlying L
FXL = FunctionField(L, FX.variable_name())
# test that FX is a subring of FXL
assert FX.is_subring(FXL)
# hence there is a natural coercion morphism
XL = BerkovichLine(FXL, vL)
# the representation of xi as a discoid on X, which is defined
# by an inequality v(f) >= s:
f, s = self.type_II_point().discoid()
# the lower components correspon to the connected components of
# the base change to L of the discoid defining the inertial component:
f = FXL(f)
lower_valuations = [xi.valuation() for xi in XL.points_from_inequality(f, s)]
# some preparation:
v0 = self.valuation()
F0 = self.function_field()
x0 = FXL(v0.lift(v0.residue_field().gen()))
# x0 is a lift to FXL of the canonical coordinate on the
# inertial component; we need it to find the natural map from the
# lower components to the inertial component.
k0 = F0.constant_base_field()
theta0 = FXL(v0.lift(k0.gen()))
# now we construct the lower components:
lower_components = []
for v in lower_valuations:
F1, to_F1, _ = make_function_field(v.residue_field())
# we need to find the correct inclusion phi of F0 into F1
if k0.is_prime_field():
# we don't have to worry about the right embedding of the
# constant base field
phi = F0.hom(to_F1(v.reduce(x0)))
else:
k1 = F1.constant_base_field()
# we have to be careful about the correct embedding of k0 into k1
phi_base = k0.hom([k1(to_F1(v.reduce(theta0)))])
# now phi is determined by phi_base and the image of the
# natural coordinate of F0
phi = F0.hom(to_F1(v.reduce(x0)), phi_base)
lower_components.append(LowerComponent(self, vL, v, phi))
self._lower_components[u] = lower_components
return lower_components