Order-thirteen exclusion proof support, part 3 of 21
DefinitionMazurN13_DirectProofSupport3of21_p0mazur-torsion
Verified auxiliary constructions and lemmas used in the formal proof excluding rational points of order thirteen on elliptic curves over the rationals. This part retains source declarations in dependency order.
Definition code
import Definitions.Def_MazurN13_DirectProofSupport2of21_p0
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13ContractQuotientXYBasis
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
open Module
open Polynomial
open scoped TensorProduct
/-!
# Coordinate bases for finite quadratic contractions
For a finite canonical contraction of a quadratic N13 Mumford quotient,
the special fibre is a two-dimensional algebra generated by the literal
coordinates `x` and `y`. Thus either `{1,x}` or `{1,y}` is a basis on the
special fibre. Finite flat lifting gives the same literal alternative
over the two-adic integers.
-/
namespace MazurProof.N13ContractQuotientXYBasis
noncomputable section
universe uF uK uA uι
theorem exists_basis_restrictScalars_of_surjective
{F : Type uF} {K : Type uK} {A : Type uA} {ι : Type uι}
[Field F] [Field K] [CommRing A]
[Algebra F K] [Algebra F A] [Algebra K A]
[IsScalarTower F K A] [Fintype ι]
(hFK : Function.Surjective (algebraMap F K))
(b : Basis ι K A) :
∃ bF : Basis ι F A, (bF : ι → A) = b := by
have hli :
LinearIndependent F (b : ι → A) :=
b.linearIndependent.restrict_scalars' F
have hspan :
⊤ ≤ Submodule.span F (Set.range (b : ι → A)) := by
intro z _
rw [← b.sum_repr z]
apply Submodule.sum_mem
intro i _
obtain ⟨a, ha⟩ := hFK (b.repr z i)
rw [← ha, IsScalarTower.algebraMap_smul K]
exact
Submodule.smul_mem _ a
(Submodule.subset_span (Set.mem_range_self i))
let bF : Basis ι F A :=
Basis.mk hli hspan
exact ⟨bF, Basis.coe_mk hli hspan⟩
local instance instFactPrimeOfNatNat_fLT : Fact (Nat.Prime 2) :=
⟨Nat.prime_two⟩
abbrev R₂ : Type := N13IntegralModelContraction.R₂
abbrev Q₂ : Type := N13IntegralModelContraction.Q₂
abbrev k : Type := N13GoodCoordinateRingTwo.K
abbrev κ : Type := IsLocalRing.ResidueField R₂
abbrev IntegralRing : Type := N13IntegralModelContraction.IntegralRing
abbrev RationalRing : Type := N13IntegralModelContraction.RationalRing
abbrev SpecialRing : Type :=
N13GeneralizedMumfordReduction.SpecialRing
abbrev Model : SexticMumford.Model Q₂ :=
N13GoodSexticCoordinateEquiv.M (K := Q₂)
local instance baseSpecialAlgebra : Algebra R₂ k :=
N13GeneralizedMumfordReduction.reduceBase.toAlgebra
def integralY : IntegralRing :=
N13GeneralizedMumfordIntegral.yClass (R := R₂)
theorem specialQuotientMap_comp_algebraMap
(I : Ideal IntegralRing)
(J : Ideal SpecialRing)
(hmap :
Ideal.map
N13GeneralizedMumfordReduction.reduceCoordinate I =
J) :
(N13QuotientReduction.reduceCoordinateQuotient
I J hmap).comp
(algebraMap R₂ (IntegralRing ⧸ I)) =
(algebraMap k (SpecialRing ⧸ J)).comp
(algebraMap R₂ k) := by
ext r
change
Ideal.Quotient.mk J
(N13GeneralizedMumfordReduction.reduceCoordinate
(algebraMap R₂ IntegralRing r)) =
Ideal.Quotient.mk J
(algebraMap k SpecialRing
(N13GeneralizedMumfordReduction.reduceBase r))
congr 1
change
N13GeneralizedMumfordReduction.reduceCoordinate
(N13GeneralizedMumfordIntegral.xClass (C r)) =
N13GoodCoordinateRingTwo.xClass
(C (N13GeneralizedMumfordReduction.reduceBase r))
rw [N13GeneralizedMumfordReduction.reduce_xClass]
simp [N13GeneralizedMumfordReduction.reducePoly]
theorem exists_contractQuotient_basis_oneX_or_oneY
(D : SexticMumford.SemiMumford Model)
(hdeg : D.u.natDegree = 2)
(hfinite :
Module.Finite R₂
(IntegralRing ⧸
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D))) :
(∃ b : Basis (Fin 2) R₂
(IntegralRing ⧸
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)),
(b : Fin 2 →
IntegralRing ⧸
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)) =
N13FiniteFlatBasisLift.oneX
(Ideal.Quotient.mk
(N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D))
N13CanonicalContractionQuotient.integralX)) ∨
(∃ b : Basis (Fin 2) R₂
(IntegralRing ⧸
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)),
(b : Fin 2 →
IntegralRing ⧸
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)) =
N13FiniteFlatBasisLift.oneX
(Ideal.Quotient.mk
(N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D))
integralY)) := by
let I :=
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)
let J : Ideal SpecialRing :=
Ideal.map N13GeneralizedMumfordReduction.reduceCoordinate I
let B := IntegralRing ⧸ I
let C := SpecialRing ⧸ J
let g : B →+* C :=
N13QuotientReduction.reduceCoordinateQuotient I J rfl
letI : Module.Finite R₂ B := hfinite
letI : Module.Flat R₂ B :=
N13QuotientVerticalFlatness.contractQuotient_flat
(N13CanonicalContractionQuotient.graphIdeal D)
letI : Module.Free R₂ B :=
Module.free_of_flat_of_isLocalRing
letI : IsScalarTower R₂ k C :=
IsScalarTower.of_algebraMap_eq
(R := R₂) (S := k) (A := C) fun _ => rfl
have hfactor :
g.comp (algebraMap R₂ B) =
(algebraMap k C).comp (algebraMap R₂ k) := by
exact specialQuotientMap_comp_algebraMap I J rfl
have hg : Function.Surjective g :=
N13QuotientReduction.reduceCoordinateQuotient_surjective
I J rfl
have hker :
RingHom.ker g =
Ideal.span ({algebraMap R₂ B (2 : R₂)} : Set B) :=
N13QuotientReduction.ker_reduceCoordinateQuotient_eq_span_two
I J rfl
let eK : k ⊗[R₂] B ≃ₗ[k] C :=
N13TensorSpecialFiber.tensorLinearEquiv
(g := g)
(hfactor := hfactor)
(hq := ZMod.ringHom_surjective PadicInt.toZMod)
(π := (2 : R₂))
(hπ := N13GeneralizedMumfordReduction.reduceBase_two)
(hg := hg)
(hker := hker)
have hfinB : Module.finrank R₂ B = 2 := by
exact
N13GenericQuotientLocalization.contractQuotient_finrank_eq_two
D hdeg
have hfinC : Module.finrank k C = 2 := by
rw [← eK.finrank_eq, Module.finrank_baseChange, hfinB]
letI : Nontrivial C :=
Module.nontrivial_of_finrank_pos
(R := k) (M := C) (by rw [hfinC]; decide)
let xB : B :=
Ideal.Quotient.mk I
N13CanonicalContractionQuotient.integralX
let yB : B :=
Ideal.Quotient.mk I integralY
let xC : C :=
Ideal.Quotient.mk J
(N13GoodCoordinateRingTwo.xClass X)
let yC : C :=
Ideal.Quotient.mk J
N13GoodCoordinateRingTwo.yClass
have hgen :
Algebra.adjoin k ({xC, yC} : Set C) = ⊤ := by
exact
N13TwoGeneratorFiberBasis.quotient_coordinate_adjoin_eq_top J
have hexC :=
N13TwoGeneratorFiberBasis.exists_basis_oneX_or_oneY
xC yC hfinC hgen
have hfactorκ :
g.comp (algebraMap R₂ B) =
(algebraMap κ C).comp (IsLocalRing.residue R₂) := by
ext r
calc
g (algebraMap R₂ B r) =
algebraMap k C (algebraMap R₂ k r) := by
simpa only [RingHom.comp_apply] using
DFunLike.congr_fun hfactor r
_ = algebraMap R₂ C r :=
(IsScalarTower.algebraMap_apply R₂ k C r).symm
_ = algebraMap κ C (algebraMap R₂ κ r) :=
IsScalarTower.algebraMap_apply R₂ κ C r
_ = algebraMap κ C
(IsLocalRing.residue R₂ r) := by
rfl
have htwo :
(2 : R₂) ∈ IsLocalRing.maximalIdeal R₂ := by
rw [PadicInt.maximalIdeal_eq_span_p]
exact Ideal.subset_span (Set.mem_singleton (2 : R₂))
let eκ : κ ⊗[R₂] B ≃ₗ[κ] C :=
N13TensorSpecialFiber.residueLinearEquiv
g hfactorκ (2 : R₂) htwo hg hker
have eκ_tmul_one (b : B) :
eκ (TensorProduct.mk R₂ κ B 1 b) = g b := by
change
(N13TensorSpecialFiber.residueLinearEquiv
g hfactorκ (2 : R₂) htwo hg hker)
((1 : κ) ⊗ₜ[R₂] b) = g b
simpa only [one_smul] using
(N13TensorSpecialFiber.residueLinearEquiv_tmul
(g := g) (hfactor := hfactorκ)
(π := (2 : R₂))
(hπ := htwo)
(hg := hg) (hker := hker)
(1 : κ) b)
have hκk :
Function.Surjective (algebraMap κ k) := by
intro a
obtain ⟨r, hr⟩ :=
ZMod.ringHom_surjective PadicInt.toZMod a
refine ⟨IsLocalRing.residue R₂ r, ?_⟩
calc
algebraMap κ k (IsLocalRing.residue R₂ r) =
algebraMap R₂ k r := by
exact
(IsScalarTower.algebraMap_apply R₂ κ k r).symm
_ = a := hr
have ex_map :
g xB = xC := by
change
N13QuotientReduction.reduceCoordinateQuotient I J rfl
(Ideal.Quotient.mk I
N13CanonicalContractionQuotient.integralX) =
xC
rw [N13QuotientReduction.reduceCoordinateQuotient_mk,
N13CanonicalContractionQuotient.integralX,
N13GeneralizedMumfordReduction.reduce_xClass]
simp [xC, N13GeneralizedMumfordReduction.reducePoly,
N13GeneralizedMumfordReduction.reduceBase]
have ey_map :
g yB = yC := by
change
N13QuotientReduction.reduceCoordinateQuotient I J rfl
(Ideal.Quotient.mk I integralY) =
yC
rw [N13QuotientReduction.reduceCoordinateQuotient_mk,
integralY,
N13GeneralizedMumfordReduction.reduce_yClass]
rcases hexC with ⟨bC, hbC⟩ | ⟨bC, hbC⟩
· left
obtain ⟨bCκ, hbCκ⟩ :=
exists_basis_restrictScalars_of_surjective hκk bC
let b₀ : Basis (Fin 2) κ (κ ⊗[R₂] B) :=
N13TensorSpecialFiber.pullbackBasis eκ bCκ
have heval (i : Fin 2) :
eκ (TensorProduct.mk R₂ κ B 1
(N13FiniteFlatBasisLift.oneX xB i)) =
bCκ i := by
rw [eκ_tmul_one]
fin_cases i
· simpa [N13FiniteFlatBasisLift.oneX] using
(congrFun hbC (0 : Fin 2)).symm.trans
(congrFun hbCκ (0 : Fin 2)).symm
· simpa [N13FiniteFlatBasisLift.oneX, ex_map] using
(congrFun hbC (1 : Fin 2)).symm.trans
(congrFun hbCκ (1 : Fin 2)).symm
have hb₀ (i : Fin 2) :
TensorProduct.mk R₂ κ B 1
(N13FiniteFlatBasisLift.oneX xB i) =
b₀ i :=
N13TensorSpecialFiber.mk_eq_pullbackBasis
eκ (N13FiniteFlatBasisLift.oneX xB) bCκ heval i
simpa [I, B, xB] using
N13FiniteFlatBasisLift.exists_basis_oneX
(R := R₂) (B := B) xB b₀ hb₀
· right
obtain ⟨bCκ, hbCκ⟩ :=
exists_basis_restrictScalars_of_surjective hκk bC
let b₀ : Basis (Fin 2) κ (κ ⊗[R₂] B) :=
N13TensorSpecialFiber.pullbackBasis eκ bCκ
have heval (i : Fin 2) :
eκ (TensorProduct.mk R₂ κ B 1
(N13FiniteFlatBasisLift.oneX yB i)) =
bCκ i := by
rw [eκ_tmul_one]
fin_cases i
· simpa [N13FiniteFlatBasisLift.oneX] using
(congrFun hbC (0 : Fin 2)).symm.trans
(congrFun hbCκ (0 : Fin 2)).symm
· simpa [N13FiniteFlatBasisLift.oneX, ey_map] using
(congrFun hbC (1 : Fin 2)).symm.trans
(congrFun hbCκ (1 : Fin 2)).symm
have hb₀ (i : Fin 2) :
TensorProduct.mk R₂ κ B 1
(N13FiniteFlatBasisLift.oneX yB i) =
b₀ i :=
N13TensorSpecialFiber.mk_eq_pullbackBasis
eκ (N13FiniteFlatBasisLift.oneX yB) bCκ heval i
simpa [I, B, yB] using
N13FiniteFlatBasisLift.exists_basis_oneX
(R := R₂) (B := B) yB b₀ hb₀
end
end MazurProof.N13ContractQuotientXYBasis
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13RankTwoIdealRecovery
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Recovering the literal graph ideal from a rank-two quotient
Once a quotient has basis `{1,x̄}`, the characteristic polynomial `u` of
multiplication by `x̄` generates the evaluation kernel. Expressing `ȳ` as
`v(x̄)` then recovers the original ambient ideal literally as
`(u(x), y-v(x))`.
This is an ideal-correspondence argument. It does not assume that the
original ideal was already given in Mumford graph form.
-/
open Polynomial
namespace MazurProof.N13RankTwoIdealRecovery
noncomputable section
universe uR uA
variable {R : Type uR} {A : Type uA}
variable [CommRing R] [CommRing A] [Algebra R A]
/-- Polynomial normal form of degree at most one in the second coordinate. -/
def HasRankTwoPolynomialNormalForm (x y : A) : Prop :=
∀ a : A, ∃ p q : R[X],
a = aeval x p + aeval x q * y
/--
If evaluation at `x̄` has kernel `(u)` and `ȳ=v(x̄)`, then the ambient
ideal is exactly `(u(x),y-v(x))`.
-/
theorem ideal_eq_span_aeval_y_sub
(x y : A)
(I : Ideal A)
(u v : R[X])
(hnormal : HasRankTwoPolynomialNormalForm (R := R) x y)
(hker :
RingHom.ker
((aeval (Ideal.Quotient.mk I x) :
R[X] →ₐ[R] A ⧸ I).toRingHom) =
Ideal.span ({u} : Set R[X]))
(hy :
Ideal.Quotient.mk I y =
aeval (Ideal.Quotient.mk I x) v) :
I =
Ideal.span
({aeval x u, y - aeval x v} : Set A) := by
let π : A →ₐ[R] A ⧸ I := Ideal.Quotient.mkₐ R I
have hker' :
RingHom.ker
((aeval (π x) : R[X] →ₐ[R] A ⧸ I).toRingHom) =
Ideal.span ({u} : Set R[X]) := by
simpa [π] using hker
have hy' : π y = aeval (π x) v := by
simpa [π] using hy
apply le_antisymm
· intro a ha
obtain ⟨p, q, hform⟩ := hnormal a
have ha0 : π a = 0 := by
simpa [π] using
(Ideal.Quotient.eq_zero_iff_mem.mpr ha)
have hpoly0 :
aeval (π x) (p + q * v) = 0 := by
calc
aeval (π x) (p + q * v) =
aeval (π x) p +
aeval (π x) q * aeval (π x) v := by
simp only [map_add, map_mul]
_ =
aeval (π x) p +
aeval (π x) q * π y := by
rw [← hy']
_ =
π (aeval x p) +
π (aeval x q) * π y := by
rw [Polynomial.aeval_algHom_apply π x p,
Polynomial.aeval_algHom_apply π x q]
_ = π (aeval x p + aeval x q * y) := by
rw [map_add, map_mul]
_ = π a := by rw [← hform]
_ = 0 := ha0
have hpqSpan :
p + q * v ∈ Ideal.span ({u} : Set R[X]) := by
rw [← hker']
exact RingHom.mem_ker.mpr hpoly0
obtain ⟨w, hw⟩ :=
Ideal.mem_span_singleton.mp hpqSpan
refine
(Ideal.mem_span_pair).2
⟨aeval x w, aeval x q, ?_⟩
calc
aeval x w * aeval x u +
aeval x q * (y - aeval x v) =
aeval x (u * w) +
aeval x q * y -
aeval x (q * v) := by
simp only [map_mul]
ring
_ =
aeval x (p + q * v) +
aeval x q * y -
aeval x (q * v) := by
rw [← hw]
_ = aeval x p + aeval x q * y := by
simp only [map_add, map_mul]
ring
_ = a := hform.symm
· rw [Ideal.span_le]
intro z hz
simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
rcases hz with rfl | rfl
· have huKer :
u ∈
RingHom.ker
((aeval (π x) :
R[X] →ₐ[R] A ⧸ I).toRingHom) := by
rw [hker']
exact Ideal.mem_span_singleton_self u
have hzero : π (aeval x u) = 0 := by
calc
π (aeval x u) = aeval (π x) u :=
(Polynomial.aeval_algHom_apply π x u).symm
_ = 0 := RingHom.mem_ker.mp huKer
exact
Ideal.Quotient.eq_zero_iff_mem.mp
(by simpa [π] using hzero)
· have hzero : π (y - aeval x v) = 0 := by
calc
π (y - aeval x v) =
π y - π (aeval x v) := by
exact map_sub π y (aeval x v)
_ = π y - aeval (π x) v := by
rw [← Polynomial.aeval_algHom_apply π x v]
_ = 0 := by rw [hy', sub_self]
exact
Ideal.Quotient.eq_zero_iff_mem.mp
(by simpa [π] using hzero)
end
end MazurProof.N13RankTwoIdealRecovery
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13SymmetricSquareTwo
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# The symmetric-square route to `#J(F₂)=19`
For a genus-two curve, the Abel map `Sym²(C) → J` is an isomorphism away
from the canonical divisor class. Its exceptional fibre is the canonical
linear system `P¹`. Over `F₂` this replaces three points by one.
The good N13 model has six `F₂`-points, so its ordinary symmetric square has
`6 multichoose 2 = 21` points. This file proves the finite fibre-counting
argument that turns the geometric Abel-fibre statement into
`#J(F₂)=21-2=19`. It deliberately isolates the remaining geometric input
as a structure, rather than assuming a general zeta-function API or
enumerating Jacobian representatives.
-/
namespace MazurProof.N13SymmetricSquareTwo
noncomputable section
open scoped BigOperators
abbrev CurvePoint :=
N13GoodModelTwo.CompletedPoint N13GoodModelTwo.F2
/-- Unordered effective divisors of degree two on the special fibre. -/
abbrev EffectiveDivisorTwo :=
Sym2 CurvePoint
/-- Six curve points give twenty-one unordered degree-two divisors. -/
theorem effectiveDivisorTwo_card :
Nat.card EffectiveDivisorTwo = 21 := by
rw [Sym2.natCard, N13GoodModelTwo.completed_points_f2_card]
norm_num [Nat.choose]
section FiberCounting
variable {A B : Type*} [Fintype A] [Fintype B] [DecidableEq B]
/-- A fibre of a function, as a finite type. -/
abbrev Fiber (f : A → B) (b : B) :=
{a : A // f a = b}
/-- A finite type is the disjoint union of the fibres of any map out of it. -/
def sigmaFiberEquiv (f : A → B) :
A ≃ Σ b : B, Fiber f b where
toFun a := ⟨f a, ⟨a, rfl⟩⟩
invFun a := a.2.1
left_inv _ := rfl
right_inv a := by
rcases a with ⟨b, a, ha⟩
subst b
rfl
theorem card_eq_sum_fibers (f : A → B) :
Fintype.card A = ∑ b : B, Fintype.card (Fiber f b) := by
classical
rw [Fintype.card_congr (sigmaFiberEquiv f), Fintype.card_sigma]
/-- If one fibre has three elements and every other fibre is a singleton,
the source has two more elements than the target. -/
theorem card_source_eq_card_target_add_two
(f : A → B) (exceptional : B)
(hexceptional : Fintype.card (Fiber f exceptional) = 3)
(hregular : ∀ b : B, b ≠ exceptional →
Fintype.card (Fiber f b) = 1) :
Fintype.card A = Fintype.card B + 2 := by
classical
rw [card_eq_sum_fibers f]
calc
(∑ b : B, Fintype.card (Fiber f b)) =
∑ b : B, if b = exceptional then 3 else 1 := by
apply Finset.sum_congr rfl
intro b _
by_cases hb : b = exceptional
· subst b
simp [hexceptional]
· simp [hb, hregular b hb]
_ = Fintype.card B + 2 := by
have hsplit (b : B) :
(if b = exceptional then 3 else 1) =
1 + if b = exceptional then 2 else 0 := by
by_cases hb : b = exceptional <;> simp [hb]
simp_rw [hsplit]
rw [Finset.sum_add_distrib]
simp
end FiberCounting
/-- Exact geometric data needed from the genus-two Abel map. Constructing
this package is the remaining algebraic-geometry seam; all cardinal
arithmetic after it is formalized here. -/
structure AbelFiberData (J : Type*) [Finite J] where
abel : EffectiveDivisorTwo → J
canonicalClass : J
canonical_fiber :
Nat.card {D : EffectiveDivisorTwo // abel D = canonicalClass} = 3
regular_fiber :
∀ c : J, c ≠ canonicalClass →
Nat.card {D : EffectiveDivisorTwo // abel D = c} = 1
/-- The genus-two Abel-fibre theorem and the six curve points imply
`#J(F₂)=19`. -/
theorem jacobian_card_eq_nineteen
{J : Type*} [Finite J] (D : AbelFiberData J) :
Nat.card J = 19 := by
classical
letI : Fintype J := Fintype.ofFinite J
letI : Fintype CurvePoint := Fintype.ofFinite CurvePoint
letI : Fintype EffectiveDivisorTwo := Fintype.ofFinite EffectiveDivisorTwo
have hsource : Fintype.card EffectiveDivisorTwo = 21 := by
rw [← Nat.card_eq_fintype_card]
exact effectiveDivisorTwo_card
have hexceptional :
Fintype.card (Fiber D.abel D.canonicalClass) = 3 := by
rw [← Nat.card_eq_fintype_card]
exact D.canonical_fiber
have hregular :
∀ c : J, c ≠ D.canonicalClass →
Fintype.card (Fiber D.abel c) = 1 := by
intro c hc
rw [← Nat.card_eq_fintype_card]
exact D.regular_fiber c hc
have hcount := card_source_eq_card_target_add_two
D.abel D.canonicalClass hexceptional hregular
rw [hsource] at hcount
rw [Nat.card_eq_fintype_card]
omega
/-- Consequently the finite additive Jacobian is annihilated by nineteen. -/
theorem jacobian_exponent_nineteen
{J : Type*} [AddCommGroup J] [Finite J] (D : AbelFiberData J) :
∀ P : J, 19 • P = 0 := by
classical
letI : Fintype J := Fintype.ofFinite J
have hcard : Fintype.card J = 19 := by
rw [← Nat.card_eq_fintype_card]
exact jacobian_card_eq_nineteen D
intro P
rw [← hcard]
exact card_nsmul_eq_zero
end
end MazurProof.N13SymmetricSquareTwo
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13AbelFiberTwoModel
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# A finite set model for the N13 Abel fibres at two
The six points of the good characteristic-two model form three
hyperelliptic pairs. On `Sym²(C)(F₂)`, collapse the three corresponding
canonical divisors to one class and leave every other divisor unchanged.
The resulting quotient has nineteen elements.
This quotient is only a set-level model of the expected Abel fibres. It is
not asserted to be the geometric Picard group. The structure
`GeometricAbelCriterion` records exactly the geometric statements required
to transfer the same fibre calculation to a genuine Picard target.
-/
namespace MazurProof.N13AbelFiberTwoModel
noncomputable section
open N13GoodModelTwo
open N13SymmetricSquareTwo
abbrev K := F2
abbrev CurvePoint := CompletedPoint K
/-- The three rational points of the hyperelliptic base. -/
abbrev BasePoint := K ⊕ Unit
/-- The six curve points are the three base points times two sheets. -/
def curvePointEquiv : CurvePoint ≃ BasePoint × K where
toFun
| Sum.inl P => (Sum.inl P.1.1, P.1.2)
| Sum.inr P => (Sum.inr (), P.1)
invFun
| (Sum.inl x, y) =>
Sum.inl ⟨(x, y), (affineEquation_iff_fixed f2_fourth_eq x y).2
⟨ZMod.pow_card x, ZMod.pow_card y⟩⟩
| (Sum.inr _, v) =>
Sum.inr ⟨v, (infinityChartEquation_zero_iff_fixed v).2
(ZMod.pow_card v)⟩
left_inv P := by
rcases P with P | P
· rfl
· rfl
right_inv P := by
rcases P with ⟨b, z⟩
rcases b with x | u
· rfl
· cases u
rfl
theorem basePoint_card : Nat.card BasePoint = 3 := by
rw [Nat.card_sum]
norm_num [BasePoint, K, F2]
/-- The hyperelliptic fibre over `b`, as an effective divisor of degree two. -/
def canonicalDivisor (b : BasePoint) : EffectiveDivisorTwo :=
s(curvePointEquiv.symm (b, 0), curvePointEquiv.symm (b, 1))
theorem canonicalDivisor_injective :
Function.Injective canonicalDivisor := by
intro b c h
change
s(curvePointEquiv.symm (b, 0), curvePointEquiv.symm (b, 1)) =
s(curvePointEquiv.symm (c, 0), curvePointEquiv.symm (c, 1)) at h
rw [Sym2.eq_iff] at h
rcases h with h | h
· exact congrArg Prod.fst (curvePointEquiv.symm.injective h.1)
· have hz : (0 : K) = 1 :=
congrArg Prod.snd (curvePointEquiv.symm.injective h.1)
exact (zero_ne_one hz).elim
/-- The three divisors in the canonical pencil over `F₂`. -/
def IsCanonical (D : EffectiveDivisorTwo) : Prop :=
D ∈ Set.range canonicalDivisor
theorem canonicalDivisor_isCanonical (b : BasePoint) :
IsCanonical (canonicalDivisor b) :=
Set.mem_range_self b
/-- Equality except that all three canonical divisors are identified. -/
def AbelRel (D E : EffectiveDivisorTwo) : Prop :=
D = E ∨ IsCanonical D ∧ IsCanonical E
theorem abelRel_equivalence : Equivalence AbelRel where
refl D := Or.inl rfl
symm := by
intro D E h
rcases h with rfl | ⟨hD, hE⟩
· exact Or.inl rfl
· exact Or.inr ⟨hE, hD⟩
trans := by
intro D E F hDE hEF
rcases hDE with rfl | ⟨hD, hE⟩
· exact hEF
rcases hEF with rfl | ⟨_, hF⟩
· exact Or.inr ⟨hD, hE⟩
· exact Or.inr ⟨hD, hF⟩
def abelSetoid : Setoid EffectiveDivisorTwo :=
⟨AbelRel, abelRel_equivalence⟩
/-- Set-level quotient obtained by collapsing the canonical pencil. -/
abbrev PicTwoSetModel := Quotient abelSetoid
def abel : EffectiveDivisorTwo → PicTwoSetModel :=
Quotient.mk''
theorem abel_eq_iff (D E : EffectiveDivisorTwo) :
abel D = abel E ↔ AbelRel D E :=
Quotient.eq''
def baseAtInfinity : BasePoint := Sum.inr ()
def canonicalClass : PicTwoSetModel :=
abel (canonicalDivisor baseAtInfinity)
theorem abel_eq_canonicalClass_iff (D : EffectiveDivisorTwo) :
abel D = canonicalClass ↔ IsCanonical D := by
change abel D = abel (canonicalDivisor baseAtInfinity) ↔ IsCanonical D
rw [abel_eq_iff]
constructor
· rintro (rfl | ⟨hD, _⟩)
· exact canonicalDivisor_isCanonical baseAtInfinity
· exact hD
· intro hD
exact Or.inr ⟨hD, canonicalDivisor_isCanonical baseAtInfinity⟩
def exceptionalFiberEquivCanonical :
{D : EffectiveDivisorTwo // abel D = canonicalClass} ≃
{D : EffectiveDivisorTwo // IsCanonical D} :=
Equiv.subtypeEquivRight (fun D => abel_eq_canonicalClass_iff D)
theorem canonical_fiber_card :
Nat.card {D : EffectiveDivisorTwo // abel D = canonicalClass} = 3 := by
calc
Nat.card {D : EffectiveDivisorTwo // abel D = canonicalClass} =
Nat.card {D : EffectiveDivisorTwo // IsCanonical D} :=
Nat.card_congr exceptionalFiberEquivCanonical
_ = Nat.card BasePoint :=
(Nat.card_congr
(Equiv.ofInjective canonicalDivisor canonicalDivisor_injective)).symm
_ = 3 := basePoint_card
theorem regular_fiber_subsingleton
(c : PicTwoSetModel) (hc : c ≠ canonicalClass) :
Subsingleton {D : EffectiveDivisorTwo // abel D = c} := by
constructor
intro D E
apply Subtype.ext
have hDE : abel D.1 = abel E.1 := D.2.trans E.2.symm
rw [abel_eq_iff] at hDE
rcases hDE with h | ⟨hD, hE⟩
· exact h
· have hregularD : ¬IsCanonical D.1 := by
intro hcanonical
apply hc
calc
c = abel D.1 := D.2.symm
_ = canonicalClass :=
(abel_eq_canonicalClass_iff D.1).2 hcanonical
exact (hregularD hD).elim
theorem regular_fiber_nonempty (c : PicTwoSetModel) :
Nonempty {D : EffectiveDivisorTwo // abel D = c} :=
⟨Quotient.out c, Quotient.out_eq c⟩
theorem regular_fiber_card
(c : PicTwoSetModel) (hc : c ≠ canonicalClass) :
Nat.card {D : EffectiveDivisorTwo // abel D = c} = 1 := by
rw [Nat.card_eq_one_iff_unique]
exact ⟨regular_fiber_subsingleton c hc, regular_fiber_nonempty c⟩
/-- The set quotient has the expected Abel fibre sizes. -/
def abelFiberData : AbelFiberData PicTwoSetModel where
abel := abel
canonicalClass := canonicalClass
canonical_fiber := canonical_fiber_card
regular_fiber := regular_fiber_card
theorem picTwoSetModel_card : Nat.card PicTwoSetModel = 19 :=
jacobian_card_eq_nineteen abelFiberData
/-! ## Interface to a genuine geometric Picard target -/
/-- The geometric facts needed to transfer the set-level fibre calculation.
Surjectivity is the genus-two Riemann--Roch input; `eq_iff` is the
degree-two linear-equivalence theorem. -/
structure GeometricAbelCriterion (J : Type*) where
abel : EffectiveDivisorTwo → J
canonicalClass : J
canonical_eq :
∀ b : BasePoint, abel (canonicalDivisor b) = canonicalClass
surjective : Function.Surjective abel
eq_iff :
∀ D E : EffectiveDivisorTwo,
abel D = abel E ↔ AbelRel D E
/-- The intrinsic nineteen-element quotient itself satisfies the geometric
Abel-fibre interface. This lets later arguments use Abel rigidity without
postulating a separate special Picard-group implementation. -/
def picTwoSetModelCriterion :
GeometricAbelCriterion PicTwoSetModel where
abel := abel
canonicalClass := canonicalClass
canonical_eq := by
intro b
change
abel (canonicalDivisor b) =
abel (canonicalDivisor baseAtInfinity)
rw [abel_eq_iff]
exact Or.inr
⟨canonicalDivisor_isCanonical b,
canonicalDivisor_isCanonical baseAtInfinity⟩
surjective := Quotient.mk_surjective
eq_iff := abel_eq_iff
namespace GeometricAbelCriterion
variable {J : Type*} (G : GeometricAbelCriterion J)
theorem abel_eq_canonical_iff (D : EffectiveDivisorTwo) :
G.abel D = G.canonicalClass ↔ IsCanonical D := by
constructor
· intro hD
have hpair :
G.abel D = G.abel (canonicalDivisor baseAtInfinity) := by
rw [G.canonical_eq]
exact hD
rcases (G.eq_iff D (canonicalDivisor baseAtInfinity)).1 hpair with
hEq | ⟨hcanonical, _⟩
· exact hEq ▸ canonicalDivisor_isCanonical baseAtInfinity
· exact hcanonical
· rintro ⟨b, rfl⟩
exact G.canonical_eq b
theorem canonical_fiber_card :
Nat.card {D : EffectiveDivisorTwo //
G.abel D = G.canonicalClass} = 3 := by
calc
Nat.card {D : EffectiveDivisorTwo //
G.abel D = G.canonicalClass} =
Nat.card {D : EffectiveDivisorTwo // IsCanonical D} :=
Nat.card_congr
(Equiv.subtypeEquivRight (fun D => G.abel_eq_canonical_iff D))
_ = Nat.card BasePoint :=
(Nat.card_congr
(Equiv.ofInjective canonicalDivisor canonicalDivisor_injective)).symm
_ = 3 := basePoint_card
theorem regular_fiber_card
(c : J) (hc : c ≠ G.canonicalClass) :
Nat.card {D : EffectiveDivisorTwo // G.abel D = c} = 1 := by
obtain ⟨E, hE⟩ := G.surjective c
rw [Nat.card_eq_one_iff_unique]
constructor
· constructor
intro D D'
apply Subtype.ext
have hDD' : G.abel D.1 = G.abel D'.1 := D.2.trans D'.2.symm
rcases (G.eq_iff D.1 D'.1).1 hDD' with h | ⟨hcanonical, _⟩
· exact h
· have : G.abel D.1 = G.canonicalClass :=
(G.abel_eq_canonical_iff D.1).2 hcanonical
exact (hc (D.2 ▸ this)).elim
· exact ⟨⟨E, hE⟩⟩
def toAbelFiberData [Finite J] : AbelFiberData J where
abel := G.abel
canonicalClass := G.canonicalClass
canonical_fiber := G.canonical_fiber_card
regular_fiber := G.regular_fiber_card
end GeometricAbelCriterion
end
end MazurProof.N13AbelFiberTwoModel
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13FormalAbelLinearization
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# The integral linearization of an N13 Abel chart
The two integral points `(0,0)` and `(-1,0)` reduce to points with distinct
`x`-coordinates. Their degree-two sum is therefore away from the canonical
hyperelliptic pencil. In generalized Mumford coordinates its base
polynomial is `X² + X`, and the linearized curve relation has determinant
`-1`.
This file proves the polynomial identities behind that unit Jacobian over an
arbitrary nontrivial commutative ring. No point or divisor enumeration is
used.
-/
open Polynomial
namespace MazurProof.N13FormalAbelLinearization
noncomputable section
universe u
variable {R : Type u} [CommRing R]
/-- The monic polynomial of the base divisor `(0,0)+(-1,0)`. -/
def uBase : R[X] :=
X ^ 2 + X
/-- The coefficient of `Y` in the good generalized equation. -/
def hPoly : R[X] :=
X ^ 3 + X + 1
theorem uBase_monic : (uBase : R[X]).Monic := by
unfold uBase
(monicity; norm_num)
theorem uBase_natDegree [Nontrivial R] :
(uBase : R[X]).natDegree = 2 := by
unfold uBase
(compute_degree; norm_num)
/-- The two selected points lie on the integral generalized model. -/
theorem base_points_on_curve :
N13GoodModelTwo.AffineEquation (0 : R) 0 ∧
N13GoodModelTwo.AffineEquation (-1 : R) 0 := by
constructor
· simp [N13GoodModelTwo.AffineEquation,
N13GoodModelTwo.h, N13GoodModelTwo.rhs]
· simp [N13GoodModelTwo.AffineEquation,
N13GoodModelTwo.h, N13GoodModelTwo.rhs]
ring
/-- The `Y`-derivatives at the two base points are the units `1` and `-1`. -/
theorem base_derivativeY :
N13GoodModelTwo.affineDerivativeY (0 : R) 0 = 1 ∧
N13GoodModelTwo.affineDerivativeY (-1 : R) 0 = -1 := by
constructor
· simp [N13GoodModelTwo.affineDerivativeY,
N13GoodModelTwo.h]
· simp [N13GoodModelTwo.affineDerivativeY,
N13GoodModelTwo.h]
ring
private theorem linear_remainder_degree_lt
[Nontrivial R]
(a b : R) :
(C a * X + C b).degree < (uBase : R[X]).degree := by
rw [degree_eq_natDegree uBase_monic.ne_zero, uBase_natDegree]
(compute_degree; norm_num)
/-- Reduction of `h` modulo the base divisor polynomial. -/
theorem hPoly_mod_uBase [Nontrivial R] :
(hPoly : R[X]) %ₘ uBase = 2 * X + 1 := by
calc
(hPoly : R[X]) %ₘ uBase =
(2 * X + 1 : R[X]) %ₘ uBase := by
apply modByMonic_eq_of_dvd_sub uBase_monic
refine ⟨X - 1, ?_⟩
simp only [hPoly, uBase]
ring
_ = 2 * X + 1 := by
apply (modByMonic_eq_self_iff uBase_monic).2
have huDegree : (uBase : R[X]).degree = 2 := by
rw [degree_eq_natDegree uBase_monic.ne_zero, uBase_natDegree]
norm_num
rw [huDegree]
(compute_degree; norm_num)
/-- A linear polynomial used for the nearby generalized Mumford graph. -/
def vLinear (c d : R) : R[X] :=
C c * X + C d
/-- Exact linearized remainder of the generalized Mumford relation at the
base divisor. -/
theorem neg_h_mul_linear_mod [Nontrivial R]
(c d : R) :
(-(hPoly * vLinear c d) : R[X]) %ₘ uBase =
C (c - 2 * d) * X + C (-d) := by
calc
(-(hPoly * vLinear c d) : R[X]) %ₘ uBase =
(C (c - 2 * d) * X + C (-d)) %ₘ uBase := by
apply modByMonic_eq_of_dvd_sub uBase_monic
refine
⟨-C c * X ^ 2 + C (c - d) * X + C (d - 2 * c), ?_⟩
simp [hPoly, vLinear, uBase, C_ofNat]
ring
_ = C (c - 2 * d) * X + C (-d) := by
apply (modByMonic_eq_self_iff uBase_monic).2
exact linear_remainder_degree_lt (c - 2 * d) (-d)
/-- Jacobian of the two remainder coefficients with respect to the two
coefficients of `v`. -/
def remainderLinearization : Matrix (Fin 2) (Fin 2) R :=
!![1, -2; 0, -1]
@[simp] theorem remainderLinearization_det :
(remainderLinearization : Matrix (Fin 2) (Fin 2) R).det = -1 := by
rw [Matrix.det_fin_two]
simp [remainderLinearization]
/-- The linearization is its own inverse. -/
theorem remainderLinearization_mul_self :
(remainderLinearization : Matrix (Fin 2) (Fin 2) R) *
remainderLinearization = 1 := by
ext i j
fin_cases i <;> fin_cases j <;>
simp [remainderLinearization, Matrix.mul_apply, Fin.sum_univ_two]
theorem remainderLinearization_isUnit :
IsUnit
(remainderLinearization :
Matrix (Fin 2) (Fin 2) R) :=
⟨⟨remainderLinearization, remainderLinearization,
remainderLinearization_mul_self,
remainderLinearization_mul_self⟩, rfl⟩
/-! ## The Abel differential -/
/-- The differential of the degree-two Abel map at
`(0,0)+(-1,0)`, in the differential basis
`dx/(2y+h), x dx/(2y+h)`.
The two rows are evaluation at `(0,0)` and `(-1,0)`. The vertical
derivatives there are `1` and `-1`, so the matrix is triangular with unit
diagonal. This is the actual nonspecial Abel-map Jacobian; it is logically
separate from `remainderLinearization`, which only solves the curve
equations for the graph coefficients. -/
def abelDifferentialMatrix : Matrix (Fin 2) (Fin 2) R :=
!![1, 0; -1, 1]
@[simp] theorem abelDifferentialMatrix_det :
(abelDifferentialMatrix : Matrix (Fin 2) (Fin 2) R).det = 1 := by
rw [Matrix.det_fin_two]
simp [abelDifferentialMatrix]
theorem abelDifferentialMatrix_det_isUnit :
IsUnit
(abelDifferentialMatrix :
Matrix (Fin 2) (Fin 2) R).det := by
rw [abelDifferentialMatrix_det]
exact isUnit_one
/-- Evaluation at the two base points is an integral linear equivalence.
This is the tangent-space form of nonspeciality used by the local Abel
chart. -/
def abelDifferentialEquiv :
(Fin 2 → R) ≃ₗ[R] (Fin 2 → R) where
toFun z := ![z 0, -z 0 + z 1]
invFun z := ![z 0, z 0 + z 1]
left_inv z := by
funext i
fin_cases i <;> simp
right_inv z := by
funext i
fin_cases i <;> simp
map_add' z w := by
funext i
fin_cases i <;> simp [add_assoc, add_left_comm, add_comm]
map_smul' a z := by
funext i
fin_cases i <;> simp [mul_add, mul_neg]
end
end MazurProof.N13FormalAbelLinearization
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13AbelChartBase
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# The nonspecial base divisor for the N13 Abel chart
The integral divisor
`(0,0) + (-1,0)`
has generalized Mumford pair `u = X² + X`, `v = 0`. Its reduction is the
unordered pair of the sheet-zero points over the distinct affine base
coordinates `0` and `1`. A canonical hyperelliptic fibre contains one
point on each sheet, so this reduced divisor is noncanonical.
The same base pair satisfies a short Bézout identity. Hence its graph ideal
is one of the smooth integral Mumford ideals already shown to commute with
reduction.
-/
open Polynomial
namespace MazurProof.N13AbelChartBase
noncomputable section
open N13AbelFiberTwoModel
open N13SymmetricSquareTwo
local instance instFactPrimeOfNatNat_fLT : Fact (Nat.Prime 2) :=
⟨Nat.prime_two⟩
abbrev R₂ : Type :=
ℤ_[2]
abbrev K : Type :=
N13AbelFiberTwoModel.K
/-- The special-fibre point `(0,0)`. -/
def p00 : N13AbelFiberTwoModel.CurvePoint :=
curvePointEquiv.symm (Sum.inl 0, 0)
/-- The special-fibre point `(1,0)`, which is the reduction of `(-1,0)`. -/
def p10 : N13AbelFiberTwoModel.CurvePoint :=
curvePointEquiv.symm (Sum.inl 1, 0)
/-- Reduction of the selected integral degree-two divisor. -/
def specialBaseDivisor :
N13SymmetricSquareTwo.EffectiveDivisorTwo :=
s(p00, p10)
private def sheet
(P : N13AbelFiberTwoModel.CurvePoint) : K :=
(curvePointEquiv P).2
@[simp] private theorem sheet_p00 :
sheet p00 = 0 := by
simp [sheet, p00]
@[simp] private theorem sheet_p10 :
sheet p10 = 0 := by
simp [sheet, p10]
@[simp] private theorem sheet_canonical_zero
(b : BasePoint) :
sheet (curvePointEquiv.symm (b, 0)) = 0 := by
simp [sheet]
@[simp] private theorem sheet_canonical_one
(b : BasePoint) :
sheet (curvePointEquiv.symm (b, 1)) = 1 := by
simp [sheet]
/-- The base divisor is outside the canonical hyperelliptic pencil. The
proof only compares sheet coordinates; it does not enumerate curve points. -/
theorem specialBaseDivisor_not_canonical :
¬IsCanonical specialBaseDivisor := by
rintro ⟨b, hb⟩
change
s(curvePointEquiv.symm (b, 0),
curvePointEquiv.symm (b, 1)) =
s(p00, p10) at hb
rw [Sym2.eq_iff] at hb
rcases hb with hb | hb
· have hs := congrArg sheet hb.2
simp at hs
· have hs := congrArg sheet hb.2
simp at hs
/-- Consequently its class in the nineteen-element Abel set is regular. -/
theorem abel_specialBaseDivisor_ne_canonicalClass :
abel specialBaseDivisor ≠ canonicalClass := by
intro h
exact specialBaseDivisor_not_canonical
((abel_eq_canonicalClass_iff specialBaseDivisor).1 h)
/-- The smooth integral generalized Mumford datum of the selected base
divisor. The Bézout certificate is
`(X-1)u + h + 2w = 1`.
-/
def baseSmoothMumford :
N13GeneralizedMumfordReduction.SmoothMumford₂ where
u := N13FormalAbelLinearization.uBase
v := 0
w := -X ^ 3
u_monic := N13FormalAbelLinearization.uBase_monic
curve_eq := by
simp only [N13GeneralizedMumfordIntegral.hPoly,
N13GeneralizedMumfordIntegral.rhsPoly,
N13FormalAbelLinearization.uBase]
ring
bezout := by
refine ⟨X - 1, 1, 2, ?_⟩
simp only [N13FormalAbelLinearization.uBase,
N13GeneralizedMumfordIntegral.hPoly]
ring
@[simp] theorem baseSmoothMumford_u :
baseSmoothMumford.u =
N13FormalAbelLinearization.uBase := rfl
@[simp] theorem baseSmoothMumford_v :
baseSmoothMumford.v = 0 := rfl
/-- The integral base graph reduces to the same polynomial pair
`(X²+X,0)` in characteristic two. -/
theorem reduce_baseSmoothMumford_u :
(N13GeneralizedMumfordReduction.reduceSmoothMumford
baseSmoothMumford).u =
(X ^ 2 + X :
N13GoodCoordinateRingTwo.K[X]) := by
simp [baseSmoothMumford,
N13FormalAbelLinearization.uBase,
N13GeneralizedMumfordReduction.reducePoly,
N13GeneralizedMumfordReduction.reduceBase]
@[simp] theorem reduce_baseSmoothMumford_v :
(N13GeneralizedMumfordReduction.reduceSmoothMumford
baseSmoothMumford).v = 0 := by
simp [baseSmoothMumford,
N13GeneralizedMumfordReduction.reducePoly]
end
end MazurProof.N13AbelChartBase
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13SpecialDualFrame
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# The explicit special-fibre dual frame
For the selected nonspecial graph ideal `(X²+X,Y)`, three explicit primal
and multiplier-dual elements have evaluation sum one. The only
denominator is `(Y+h)/(X²+X)`; its inverse-ideal membership follows
directly from the curve equation.
This is a symbolic certificate in the special affine coordinate ring. It
does not use invertibility of the graph ideal and is therefore suitable as
the input relation for the two-chart lifting argument.
-/
open Polynomial
open scoped nonZeroDivisors
namespace MazurProof.N13SpecialDualFrame
noncomputable section
abbrev k : Type := N13GoodCoordinateRingTwo.K
abbrev A : Type := N13GoodCoordinateRingTwo.CoordinateRing
abbrev F : Type := N13GoodCoordinateRingTwo.FunctionField
abbrev Frac : Type := FractionalIdeal A⁰ F
def u : k[X] := X ^ 2 + X
def c : k[X] := X ^ 2 + X + 1
theorem u_monic : u.Monic := by
unfold u
(monicity; norm_num)
def I : Ideal A :=
N13GoodCoordinateRingTwo.mumfordIdeal u 0
def IFrac : Frac :=
(I : Frac)
def uF : F :=
algebraMap A F (N13GoodCoordinateRingTwo.xClass u)
def cF : F :=
algebraMap A F (N13GoodCoordinateRingTwo.xClass c)
def x3F : F :=
algebraMap A F (N13GoodCoordinateRingTwo.xClass (X ^ 3))
def yF : F :=
algebraMap A F N13GoodCoordinateRingTwo.yClass
def hF : F :=
algebraMap A F
(N13GoodCoordinateRingTwo.xClass
N13GoodCoordinateRingTwo.hPoly)
def quotientDual : F :=
(yF + hF) / uF
theorem u_ne_zero : uF ≠ 0 := by
change
algebraMap A F (N13GoodCoordinateRingTwo.xClass u) ≠ 0
simpa only [map_zero] using
(IsFractionRing.injective A F).ne
(N13GoodCoordinateRingTwo.xClass_ne_zero
(p := u) u_monic.ne_zero)
theorem polynomial_identity :
u * X ^ 3 + c * N13GoodCoordinateRingTwo.hPoly = 1 := by
simp [u, c, N13GoodCoordinateRingTwo.hPoly]
ring_nf
rw [show (2 : k[X]) = 0 by
exact CharP.cast_eq_zero (k[X]) 2]
simp
theorem coordinate_identity :
N13GoodCoordinateRingTwo.xClass u *
N13GoodCoordinateRingTwo.xClass (X ^ 3) +
N13GoodCoordinateRingTwo.xClass c *
(N13GoodCoordinateRingTwo.yClass +
N13GoodCoordinateRingTwo.xClass
N13GoodCoordinateRingTwo.hPoly) +
N13GoodCoordinateRingTwo.yClass *
N13GoodCoordinateRingTwo.xClass c =
1 := by
have htwoPoly : (2 : k[X]) = 0 :=
CharP.cast_eq_zero (k[X]) 2
have htwoCoord : (2 : A) = 0 := by
calc
(2 : A) =
N13GoodCoordinateRingTwo.xClass (2 : k[X]) :=
(N13GoodCoordinateRingTwo.xClass_natCast 2).symm
_ = N13GoodCoordinateRingTwo.xClass 0 := by
rw [htwoPoly]
_ = 0 :=
N13GoodCoordinateRingTwo.xClass_zero
have htwo :
N13GoodCoordinateRingTwo.yClass *
N13GoodCoordinateRingTwo.xClass c +
N13GoodCoordinateRingTwo.yClass *
N13GoodCoordinateRingTwo.xClass c = 0 := by
rw [← two_mul, htwoCoord, zero_mul]
calc
N13GoodCoordinateRingTwo.xClass u *
N13GoodCoordinateRingTwo.xClass (X ^ 3) +
N13GoodCoordinateRingTwo.xClass c *
(N13GoodCoordinateRingTwo.yClass +
N13GoodCoordinateRingTwo.xClass
N13GoodCoordinateRingTwo.hPoly) +
N13GoodCoordinateRingTwo.yClass *
N13GoodCoordinateRingTwo.xClass c =
N13GoodCoordinateRingTwo.xClass u *
N13GoodCoordinateRingTwo.xClass (X ^ 3) +
N13GoodCoordinateRingTwo.xClass c *
N13GoodCoordinateRingTwo.xClass
N13GoodCoordinateRingTwo.hPoly +
(N13GoodCoordinateRingTwo.yClass *
N13GoodCoordinateRingTwo.xClass c +
N13GoodCoordinateRingTwo.yClass *
N13GoodCoordinateRingTwo.xClass c) := by
ring
_ =
N13GoodCoordinateRingTwo.xClass u *
N13GoodCoordinateRingTwo.xClass (X ^ 3) +
N13GoodCoordinateRingTwo.xClass c *
N13GoodCoordinateRingTwo.xClass
N13GoodCoordinateRingTwo.hPoly := by
rw [htwo, add_zero]
_ =
N13GoodCoordinateRingTwo.xClass
(u * X ^ 3 +
c * N13GoodCoordinateRingTwo.hPoly) := by
rw [N13GoodCoordinateRingTwo.xClass_add,
N13GoodCoordinateRingTwo.xClass_mul,
N13GoodCoordinateRingTwo.xClass_mul]
_ = 1 := by
rw [polynomial_identity,
N13GoodCoordinateRingTwo.xClass_one]
theorem rhs_eq_u_mul_x3 :
N13GoodCoordinateRingTwo.rhsPoly = u * X ^ 3 := by
simp [N13GoodCoordinateRingTwo.rhsPoly, u]
ring
theorem y_mul_y_add_h :
N13GoodCoordinateRingTwo.yClass *
(N13GoodCoordinateRingTwo.yClass +
N13GoodCoordinateRingTwo.xClass
N13GoodCoordinateRingTwo.hPoly) =
N13GoodCoordinateRingTwo.xClass u *
N13GoodCoordinateRingTwo.xClass (X ^ 3) := by
calc
N13GoodCoordinateRingTwo.yClass *
(N13GoodCoordinateRingTwo.yClass +
N13GoodCoordinateRingTwo.xClass
N13GoodCoordinateRingTwo.hPoly) =
N13GoodCoordinateRingTwo.yClass ^ 2 +
N13GoodCoordinateRingTwo.xClass
N13GoodCoordinateRingTwo.hPoly *
N13GoodCoordinateRingTwo.yClass := by
ring
_ =
N13GoodCoordinateRingTwo.xClass
N13GoodCoordinateRingTwo.rhsPoly :=
N13GoodCoordinateRingTwo.yClass_relation
_ =
N13GoodCoordinateRingTwo.xClass (u * X ^ 3) := by
rw [rhs_eq_u_mul_x3]
_ =
N13GoodCoordinateRingTwo.xClass u *
N13GoodCoordinateRingTwo.xClass (X ^ 3) :=
N13GoodCoordinateRingTwo.xClass_mul _ _
theorem algebraMap_mem_IFrac
{z : A} (hz : z ∈ I) :
algebraMap A F z ∈ IFrac := by
exact
(FractionalIdeal.mem_coeIdeal
(nonZeroDivisors A)).2
⟨z, hz, rfl⟩
theorem uF_mem : uF ∈ IFrac := by
apply algebraMap_mem_IFrac
exact
N13GoodCoordinateRingTwo.xClass_mem_mumfordIdeal u 0
theorem cF_mul_uF_mem : cF * uF ∈ IFrac := by
change
algebraMap A F (N13GoodCoordinateRingTwo.xClass c) *
algebraMap A F (N13GoodCoordinateRingTwo.xClass u) ∈
IFrac
rw [← map_mul]
apply algebraMap_mem_IFrac
exact
Ideal.mul_mem_left I
(N13GoodCoordinateRingTwo.xClass c)
(N13GoodCoordinateRingTwo.xClass_mem_mumfordIdeal u 0)
theorem yF_mem : yF ∈ IFrac := by
change algebraMap A F N13GoodCoordinateRingTwo.yClass ∈ IFrac
apply algebraMap_mem_IFrac
change
N13GoodCoordinateRingTwo.yClass ∈
N13GoodCoordinateRingTwo.mumfordIdeal u 0
simpa [N13GoodCoordinateRingTwo.ySubClass] using
(N13GoodCoordinateRingTwo.ySubClass_mem_mumfordIdeal u 0)
theorem IFrac_ne_zero : IFrac ≠ 0 := by
intro hzero
have hu := uF_mem
rw [hzero] at hu
exact u_ne_zero (by simpa using hu)
theorem integral_mem_inv (z : A) :
algebraMap A F z ∈ IFrac⁻¹ := by
rw [FractionalIdeal.mem_inv_iff IFrac_ne_zero]
intro y hy
obtain ⟨y₀, hy₀, rfl⟩ :=
(FractionalIdeal.mem_coeIdeal
(nonZeroDivisors A)).1 hy
rw [FractionalIdeal.mem_one_iff]
exact ⟨z * y₀, by simp⟩
theorem x3F_mem_inv : x3F ∈ IFrac⁻¹ :=
integral_mem_inv _
theorem cF_mem_inv : cF ∈ IFrac⁻¹ :=
integral_mem_inv _
theorem quotientDual_mul_combination
(a b : A) :
quotientDual *
algebraMap A F
(a * N13GoodCoordinateRingTwo.xClass u +
b * N13GoodCoordinateRingTwo.yClass) =
algebraMap A F
(a *
(N13GoodCoordinateRingTwo.yClass +
N13GoodCoordinateRingTwo.xClass
N13GoodCoordinateRingTwo.hPoly) +
b * N13GoodCoordinateRingTwo.xClass (X ^ 3)) := by
have hrelation :
(yF + hF) * yF = uF * x3F := by
simpa [yF, hF, uF, x3F, mul_comm] using
congrArg (algebraMap A F) y_mul_y_add_h
calc
quotientDual *
algebraMap A F
(a * N13GoodCoordinateRingTwo.xClass u +
b * N13GoodCoordinateRingTwo.yClass) =
algebraMap A F a * (yF + hF) * (uF⁻¹ * uF) +
algebraMap A F b * uF⁻¹ * ((yF + hF) * yF) := by
simp only [quotientDual, div_eq_mul_inv,
map_add, map_mul, uF, yF]
ring
_ =
algebraMap A F a * (yF + hF) +
algebraMap A F b * uF⁻¹ * (uF * x3F) := by
rw [inv_mul_cancel₀ u_ne_zero, hrelation, mul_one]
_ =
algebraMap A F a * (yF + hF) +
algebraMap A F b * x3F := by
rw [show
algebraMap A F b * uF⁻¹ * (uF * x3F) =
algebraMap A F b * x3F by
calc
algebraMap A F b * uF⁻¹ * (uF * x3F) =
algebraMap A F b * (uF⁻¹ * uF) * x3F := by
ring
_ = algebraMap A F b * x3F := by
rw [inv_mul_cancel₀ u_ne_zero, mul_one]]
_ =
algebraMap A F
(a *
(N13GoodCoordinateRingTwo.yClass +
N13GoodCoordinateRingTwo.xClass
N13GoodCoordinateRingTwo.hPoly) +
b * N13GoodCoordinateRingTwo.xClass (X ^ 3)) := by
simp [yF, hF, x3F]
theorem quotientDual_mem_inv :
quotientDual ∈ IFrac⁻¹ := by
rw [FractionalIdeal.mem_inv_iff IFrac_ne_zero]
intro z hz
obtain ⟨z₀, hz₀, rfl⟩ :=
(FractionalIdeal.mem_coeIdeal
(nonZeroDivisors A)).1 hz
obtain ⟨a, b, hab⟩ :=
Ideal.mem_span_pair.mp hz₀
rw [← hab]
simp only [N13GoodCoordinateRingTwo.ySubClass,
N13GoodCoordinateRingTwo.xClass_zero, sub_zero]
rw [quotientDual_mul_combination]
rw [FractionalIdeal.mem_one_iff]
exact
⟨a *
(N13GoodCoordinateRingTwo.yClass +
N13GoodCoordinateRingTwo.xClass
N13GoodCoordinateRingTwo.hPoly) +
b * N13GoodCoordinateRingTwo.xClass (X ^ 3),
rfl⟩
theorem trace_relation :
uF * x3F + (cF * uF) * quotientDual + yF * cF = 1 := by
have hcancel : uF * uF⁻¹ = 1 :=
mul_inv_cancel₀ u_ne_zero
rw [quotientDual, div_eq_mul_inv]
calc
uF * x3F +
(cF * uF) * ((yF + hF) * uF⁻¹) +
yF * cF =
uF * x3F + cF * (yF + hF) + yF * cF := by
rw [show
(cF * uF) * ((yF + hF) * uF⁻¹) =
cF * (yF + hF) by
calc
(cF * uF) * ((yF + hF) * uF⁻¹) =
cF * (yF + hF) * (uF * uF⁻¹) := by
ring
_ = cF * (yF + hF) := by rw [hcancel, mul_one]]
_ =
algebraMap A F
(N13GoodCoordinateRingTwo.xClass u *
N13GoodCoordinateRingTwo.xClass (X ^ 3) +
N13GoodCoordinateRingTwo.xClass c *
(N13GoodCoordinateRingTwo.yClass +
N13GoodCoordinateRingTwo.xClass
N13GoodCoordinateRingTwo.hPoly) +
N13GoodCoordinateRingTwo.yClass *
N13GoodCoordinateRingTwo.xClass c) := by
simp [uF, x3F, cF, yF, hF]
_ = 1 := by rw [coordinate_identity, map_one]
/-- The three evaluations already lie in the special affine coordinate
ring, despite the denominator in the middle dual factor. -/
def product : Fin 3 → A :=
![
N13GoodCoordinateRingTwo.xClass u *
N13GoodCoordinateRingTwo.xClass (X ^ 3),
N13GoodCoordinateRingTwo.xClass c *
(N13GoodCoordinateRingTwo.yClass +
N13GoodCoordinateRingTwo.xClass
N13GoodCoordinateRingTwo.hPoly),
N13GoodCoordinateRingTwo.yClass *
N13GoodCoordinateRingTwo.xClass c
]
/-- The three primal factors in the special graph ideal. -/
def primal : Fin 3 → F :=
![uF, cF * uF, yF]
/-- The corresponding multiplier-dual factors. -/
def dual : Fin 3 → F :=
![x3F, quotientDual, cF]
theorem primal_mem (i : Fin 3) :
primal i ∈ IFrac := by
fin_cases i
· exact uF_mem
· exact cF_mul_uF_mem
· exact yF_mem
theorem dual_mem (i : Fin 3) :
dual i ∈ IFrac⁻¹ := by
fin_cases i
· exact x3F_mem_inv
· exact quotientDual_mem_inv
· exact cF_mem_inv
/-- Each special product is the evaluation of the corresponding primal and
multiplier-dual factors. -/
theorem algebraMap_product (i : Fin 3) :
algebraMap A F (product i) =
primal i * dual i := by
fin_cases i
· change
algebraMap A F
(N13GoodCoordinateRingTwo.xClass u *
N13GoodCoordinateRingTwo.xClass (X ^ 3)) =
uF * x3F
rw [map_mul]
rfl
· change
algebraMap A F
(N13GoodCoordinateRingTwo.xClass c *
(N13GoodCoordinateRingTwo.yClass +
N13GoodCoordinateRingTwo.xClass
N13GoodCoordinateRingTwo.hPoly)) =
(cF * uF) * quotientDual
rw [map_mul, map_add]
change
cF * (yF + hF) =
(cF * uF) * quotientDual
rw [quotientDual, div_eq_mul_inv]
calc
cF * (yF + hF) =
cF * (yF + hF) * (uF * uF⁻¹) := by
rw [mul_inv_cancel₀ u_ne_zero, mul_one]
_ = (cF * uF) * ((yF + hF) * uF⁻¹) := by
ring
· change
algebraMap A F
(N13GoodCoordinateRingTwo.yClass *
N13GoodCoordinateRingTwo.xClass c) =
yF * cF
rw [map_mul]
rfl
/-- The three affine product representatives sum to one before passage to
the special function field. -/
theorem sum_product :
∑ i, product i = 1 := by
rw [Fin.sum_univ_three]
exact coordinate_identity
/-- The explicit finite multiplier evaluation is the identity. -/
theorem sum_primal_mul_dual :
∑ i, primal i * dual i = 1 := by
rw [Fin.sum_univ_three]
exact trace_relation
end
end MazurProof.N13SpecialDualFrame
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13SpecialQuotientBasis
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# The literal basis of the fixed N13 special quotient
The selected special divisor has graph ideal `(X²+X,Y)`. Evaluation on
that graph identifies its affine quotient with
`𝔽₂[X]/(X²+X)`. The canonical monic power basis on the latter transports
back to the literal quotient basis `{1,x}`.
This file is only the fixed special-fibre endpoint. It does not assert
that the contraction of an arbitrary generic Picard representative reduces
to this ideal.
-/
open Module
open Polynomial
namespace MazurProof.N13SpecialQuotientBasis
noncomputable section
abbrev k : Type :=
N13GoodCoordinateRingTwo.K
abbrev A : Type :=
N13GoodCoordinateRingTwo.CoordinateRing
/-- The fixed reduced smooth Mumford datum. -/
def specialData :
N13GoodCoordinateRingTwo.SemiMumford :=
N13GeneralizedMumfordReduction.reduceSmoothMumford
N13AbelChartBase.baseSmoothMumford
@[simp] theorem specialData_u :
specialData.u = (X ^ 2 + X : k[X]) :=
N13AbelChartBase.reduce_baseSmoothMumford_u
@[simp] theorem specialData_v :
specialData.v = 0 :=
N13AbelChartBase.reduce_baseSmoothMumford_v
@[simp] theorem specialData_u_natDegree :
specialData.u.natDegree = 2 := by
rw [specialData_u]
(compute_degree; norm_num)
/-- The fixed special graph ideal. -/
abbrev specialIdeal : Ideal A :=
N13GoodCoordinateRingTwo.mumfordIdeal
specialData.u specialData.v
theorem specialIdeal_eq_dualFrame :
specialIdeal = N13SpecialDualFrame.I := by
simp [specialIdeal, N13SpecialDualFrame.I,
N13SpecialDualFrame.u]
/-- The monic quotient `k[X]/(u)` has its canonical power basis. -/
def residueBasis :
Basis (Fin 2) k (AdjoinRoot specialData.u) :=
(AdjoinRoot.powerBasis' specialData.u_monic).basis.reindex
(finCongr (by
change specialData.u.natDegree = 2
exact specialData_u_natDegree))
theorem residueBasis_apply (i : Fin 2) :
residueBasis i =
AdjoinRoot.root specialData.u ^ (i : ℕ) := by
change
((AdjoinRoot.powerBasis' specialData.u_monic).basis.reindex
(finCongr specialData_u_natDegree)) i =
AdjoinRoot.root specialData.u ^ (i : ℕ)
rw [Basis.reindex_apply, PowerBasis.basis_eq_pow,
AdjoinRoot.powerBasis'_gen]
rfl
@[simp] theorem residueBasis_zero :
residueBasis (0 : Fin 2) = 1 := by
simp [residueBasis_apply]
@[simp] theorem residueBasis_one :
residueBasis (1 : Fin 2) =
AdjoinRoot.root specialData.u := by
simp [residueBasis_apply]
/-- The graph-quotient equivalence respects the coefficient field. -/
def quotientAlgEquiv :
(A ⧸ specialIdeal) ≃ₐ[k]
N13GoodCoordinateRingTwo.MumfordResidue specialData :=
by
simpa only [A, k, specialIdeal] using
N13GoodCoordinateRingTwo.mumfordQuotientAlgEquiv specialData
/-- Transport the polynomial quotient basis to the affine graph quotient. -/
def quotientBasis :
Basis (Fin 2) k (A ⧸ specialIdeal) :=
residueBasis.map
quotientAlgEquiv.symm.toLinearEquiv
@[simp] theorem quotientBasis_zero :
quotientBasis (0 : Fin 2) = 1 := by
change quotientAlgEquiv.symm (residueBasis 0) = 1
rw [residueBasis_zero]
exact map_one quotientAlgEquiv.symm
set_option backward.isDefEq.respectTransparency.types false in
@[simp] theorem quotientBasis_one :
quotientBasis (1 : Fin 2) =
Ideal.Quotient.mk specialIdeal
(N13GoodCoordinateRingTwo.xClass X) := by
change
quotientAlgEquiv.symm (residueBasis 1) =
Ideal.Quotient.mk specialIdeal
(N13GoodCoordinateRingTwo.xClass X)
rw [residueBasis_one]
apply quotientAlgEquiv.injective
rw [quotientAlgEquiv.apply_symm_apply]
simp only [quotientAlgEquiv]
change
AdjoinRoot.root specialData.u =
N13GoodCoordinateRingTwo.mumfordEval specialData
(N13GoodCoordinateRingTwo.xClass X)
rw [N13GoodCoordinateRingTwo.mumfordEval_xClass]
rfl
/-- The basis family is literally `{1,x}`. -/
theorem coe_quotientBasis :
(quotientBasis : Fin 2 → A ⧸ specialIdeal) =
![1,
Ideal.Quotient.mk specialIdeal
(N13GoodCoordinateRingTwo.xClass X)] := by
funext i
fin_cases i <;> simp
end
end MazurProof.N13SpecialQuotientBasis
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13TwoFiberNoEscape
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Excluding denominator escape from two literal fibres
Let `B` be a torsion-free algebra over a domain `R`, with uniformizer
`π`. Suppose two elements `e₀,e₁` reduce to a basis of a quotient over
`k = R/(π)`. If every element of `B` can be brought into the span of
`e₀,e₁` after multiplication by some power of `π`, then it was already
in that span.
The proof removes one factor of `π` at a time. Reduction modulo `π`
forces both coefficients to be divisible by `π`, and torsion-freeness
cancels the common factor. This is the algebraic two-fibre no-escape
argument; it uses neither a finite presentation nor a valuation table.
-/
open Module
namespace MazurProof.N13TwoFiberNoEscape
noncomputable section
universe uR uk uB uC
variable {R : Type uR} {k : Type uk}
variable {B : Type uB} {C : Type uC}
variable [CommRing R] [IsDomain R]
variable [Field k]
variable [CommRing B] [CommRing C]
variable [Algebra R k] [Algebra R B] [Algebra R C]
variable [Algebra k C] [IsScalarTower R k C]
variable [Module.IsTorsionFree R B]
/-- The literal ordered pair used on both fibres. -/
def pairFamily (e₀ e₁ : B) : Fin 2 → B :=
![e₀, e₁]
@[simp] theorem pairFamily_zero (e₀ e₁ : B) :
pairFamily e₀ e₁ (0 : Fin 2) = e₀ := by
simp [pairFamily]
@[simp] theorem pairFamily_one (e₀ e₁ : B) :
pairFamily e₀ e₁ (1 : Fin 2) = e₁ := by
simp [pairFamily]
theorem range_pairFamily (e₀ e₁ : B) :
Set.range (pairFamily e₀ e₁) = {e₀, e₁} := by
ext z
constructor
· rintro ⟨i, rfl⟩
fin_cases i <;> simp
· intro hz
simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
rcases hz with rfl | rfl
· exact ⟨0, by simp⟩
· exact ⟨1, by simp⟩
/--
One factor of the uniformizer can be removed from a two-generator
relation whose reductions form a basis.
-/
theorem cancel_uniformizer_of_reduced_basis
(g : B →+* C)
(hfactor :
g.comp (algebraMap R B) =
(algebraMap k C).comp (algebraMap R k))
(π : R)
(hπ_ne : π ≠ 0)
(hπ_zero : algebraMap R k π = 0)
(hker :
RingHom.ker (algebraMap R k) =
Ideal.span ({π} : Set R))
(e₀ e₁ : B)
(bC : Basis (Fin 2) k C)
(he₀ : g e₀ = bC 0)
(he₁ : g e₁ = bC 1)
(z : B) (a₀ a₁ : R)
(hz :
π • z = a₀ • e₀ + a₁ • e₁) :
∃ c₀ c₁ : R,
z = c₀ • e₀ + c₁ • e₁ := by
have hgscalar (a : R) :
g (algebraMap R B a) = algebraMap R C a := by
calc
g (algebraMap R B a) =
algebraMap k C (algebraMap R k a) := by
simpa only [RingHom.comp_apply] using
DFunLike.congr_fun hfactor a
_ = algebraMap R C a :=
(IsScalarTower.algebraMap_apply R k C a).symm
have hred :
algebraMap R k a₀ • bC 0 +
algebraMap R k a₁ • bC 1 = 0 := by
calc
algebraMap R k a₀ • bC 0 +
algebraMap R k a₁ • bC 1 =
g (a₀ • e₀ + a₁ • e₁) := by
simp only [Algebra.smul_def, map_add, map_mul,
he₀, he₁]
rw [hgscalar a₀, hgscalar a₁]
simp only [← IsScalarTower.algebraMap_apply R k C]
_ = g (π • z) := congrArg g hz.symm
_ = 0 := by
simp only [Algebra.smul_def, map_mul]
have hscalar :
g (algebraMap R B π) =
algebraMap k C (algebraMap R k π) := by
simpa only [RingHom.comp_apply] using
DFunLike.congr_fun hfactor π
rw [hscalar, hπ_zero, map_zero, zero_mul]
have ha₀ : algebraMap R k a₀ = 0 := by
have hcoord :=
congrArg (bC.coord (0 : Fin 2)) hred
simp only [map_add, map_smul, map_zero,
Basis.coord_apply, Basis.repr_self_apply] at hcoord
simpa using hcoord
have ha₁ : algebraMap R k a₁ = 0 := by
have hcoord :=
congrArg (bC.coord (1 : Fin 2)) hred
simp only [map_add, map_smul, map_zero,
Basis.coord_apply, Basis.repr_self_apply] at hcoord
simpa using hcoord
have ha₀_mem : a₀ ∈ Ideal.span ({π} : Set R) := by
rw [← hker]
exact RingHom.mem_ker.mpr ha₀
have ha₁_mem : a₁ ∈ Ideal.span ({π} : Set R) := by
rw [← hker]
exact RingHom.mem_ker.mpr ha₁
obtain ⟨c₀, hc₀⟩ := Ideal.mem_span_singleton.mp ha₀_mem
obtain ⟨c₁, hc₁⟩ := Ideal.mem_span_singleton.mp ha₁_mem
refine ⟨c₀, c₁, ?_⟩
apply (smul_right_injective (M := B) hπ_ne)
change π • z = π • (c₀ • e₀ + c₁ • e₁)
rw [hz, hc₀, hc₁]
simp only [mul_smul, smul_add]
/--
Iterating the one-step cancellation removes every power of `π`.
-/
theorem exists_pair_of_power_relation
(g : B →+* C)
(hfactor :
g.comp (algebraMap R B) =
(algebraMap k C).comp (algebraMap R k))
(π : R)
(hπ_ne : π ≠ 0)
(hπ_zero : algebraMap R k π = 0)
(hker :
RingHom.ker (algebraMap R k) =
Ideal.span ({π} : Set R))
(e₀ e₁ : B)
(bC : Basis (Fin 2) k C)
(he₀ : g e₀ = bC 0)
(he₁ : g e₁ = bC 1)
(z : B)
(hclear :
∃ n : ℕ, ∃ a₀ a₁ : R,
(π ^ n) • z = a₀ • e₀ + a₁ • e₁) :
∃ a₀ a₁ : R,
z = a₀ • e₀ + a₁ • e₁ := by
obtain ⟨n, a₀, a₁, hz⟩ := hclear
induction n generalizing z a₀ a₁ with
| zero =>
exact ⟨a₀, a₁, by simpa using hz⟩
| succ n ih =>
have hstep :
π • ((π ^ n) • z) =
a₀ • e₀ + a₁ • e₁ := by
simpa only [pow_succ', mul_smul] using hz
obtain ⟨c₀, c₁, hc⟩ :=
cancel_uniformizer_of_reduced_basis
g hfactor π hπ_ne hπ_zero hker
e₀ e₁ bC he₀ he₁
((π ^ n) • z) a₀ a₁ hstep
exact ih (z := z) (a₀ := c₀) (a₁ := c₁) hc
/--
The power-clearing hypothesis and a basis on the reduced fibre force the
two elements to span the entire integral algebra.
-/
theorem span_pair_eq_top
(g : B →+* C)
(hfactor :
g.comp (algebraMap R B) =
(algebraMap k C).comp (algebraMap R k))
(π : R)
(hπ_ne : π ≠ 0)
(hπ_zero : algebraMap R k π = 0)
(hker :
RingHom.ker (algebraMap R k) =
Ideal.span ({π} : Set R))
(e₀ e₁ : B)
(bC : Basis (Fin 2) k C)
(he₀ : g e₀ = bC 0)
(he₁ : g e₁ = bC 1)
(hclear :
∀ z : B, ∃ n : ℕ, ∃ a₀ a₁ : R,
(π ^ n) • z = a₀ • e₀ + a₁ • e₁) :
Submodule.span R ({e₀, e₁} : Set B) = ⊤ := by
rw [eq_top_iff]
intro z
intro _
obtain ⟨a₀, a₁, hz⟩ :=
exists_pair_of_power_relation
g hfactor π hπ_ne hπ_zero hker
e₀ e₁ bC he₀ he₁ z (hclear z)
rw [hz]
exact Submodule.add_mem _
(Submodule.smul_mem _
a₀ (Submodule.subset_span (Set.mem_insert e₀ {e₁})))
(Submodule.smul_mem _
a₁ (Submodule.subset_span
(Set.mem_insert_iff.mpr
(Or.inr (Set.mem_singleton e₁)))))
section FractionFieldClearing
universe uK uG
variable {K : Type uK} {G : Type uG}
variable [Field K] [CommRing G]
variable [Algebra R K] [IsFractionRing R K]
variable [Algebra R G] [Algebra K G]
variable [IsScalarTower R K G]
/--
Two coefficients in the fraction field admit one common nonzero
denominator.
-/
theorem exists_common_denominator
(α₀ α₁ : K) :
∃ r : R, r ≠ 0 ∧
∃ a₀ a₁ : R,
algebraMap R K r * α₀ = algebraMap R K a₀ ∧
algebraMap R K r * α₁ = algebraMap R K a₁ := by
obtain ⟨b₀, d₀, hd₀, hα₀⟩ :=
IsFractionRing.div_surjective R α₀
obtain ⟨b₁, d₁, hd₁, hα₁⟩ :=
IsFractionRing.div_surjective R α₁
have hd₀_ne : d₀ ≠ 0 :=
mem_nonZeroDivisors_iff_ne_zero.mp hd₀
have hd₁_ne : d₁ ≠ 0 :=
mem_nonZeroDivisors_iff_ne_zero.mp hd₁
have hmapd₀ : algebraMap R K d₀ ≠ 0 :=
by simpa using (IsFractionRing.injective R K).ne hd₀_ne
have hmapd₁ : algebraMap R K d₁ ≠ 0 :=
by simpa using (IsFractionRing.injective R K).ne hd₁_ne
refine ⟨d₀ * d₁, mul_ne_zero hd₀_ne hd₁_ne,
b₀ * d₁, b₁ * d₀, ?_, ?_⟩
· rw [← hα₀]
push_cast
field_simp
· rw [← hα₁]
push_cast
field_simp
/--
A two-generator generic-fibre presentation clears to one integral
relation with an arbitrary nonzero scalar denominator.
-/
theorem exists_scalar_relation_of_fraction_pair
(q : B →+* G)
(hfactor :
q.comp (algebraMap R B) = algebraMap R G)
(hq : Function.Injective q)
(e₀ e₁ z : B)
(hgeneric :
∃ α₀ α₁ : K,
q z = α₀ • q e₀ + α₁ • q e₁) :
∃ r : R, r ≠ 0 ∧
∃ a₀ a₁ : R,
r • z = a₀ • e₀ + a₁ • e₁ := by
obtain ⟨α₀, α₁, hz⟩ := hgeneric
obtain ⟨r, hr, a₀, a₁, ha₀, ha₁⟩ :=
exists_common_denominator (R := R) α₀ α₁
refine ⟨r, hr, a₀, a₁, hq ?_⟩
have hqscalar (a : R) :
q (algebraMap R B a) = algebraMap R G a := by
simpa only [RingHom.comp_apply] using
DFunLike.congr_fun hfactor a
calc
q (r • z) =
algebraMap R G r * q z := by
simp only [Algebra.smul_def, map_mul, hqscalar]
_ =
algebraMap K G (algebraMap R K r) *
(α₀ • q e₀ + α₁ • q e₁) := by
rw [hz, IsScalarTower.algebraMap_apply R K G]
_ =
(algebraMap R K r * α₀) • q e₀ +
(algebraMap R K r * α₁) • q e₁ := by
simp only [Algebra.smul_def, mul_add, map_mul]
ring
_ =
algebraMap R K a₀ • q e₀ +
algebraMap R K a₁ • q e₁ := by
rw [ha₀, ha₁]
_ =
q (a₀ • e₀ + a₁ • e₁) := by
simp only [Algebra.smul_def, map_add, map_mul, hqscalar,
IsScalarTower.algebraMap_apply R K G]
/--
Over a discrete valuation ring, the arbitrary denominator can be replaced
by a power of any chosen uniformizer.
-/
theorem exists_power_relation_of_fraction_pair
[IsDiscreteValuationRing R]
(π : R)
(hπ : Irreducible π)
(q : B →+* G)
(hfactor :
q.comp (algebraMap R B) = algebraMap R G)
(hq : Function.Injective q)
(e₀ e₁ z : B)
(hgeneric :
∃ α₀ α₁ : K,
q z = α₀ • q e₀ + α₁ • q e₁) :
∃ n : ℕ, ∃ a₀ a₁ : R,
(π ^ n) • z = a₀ • e₀ + a₁ • e₁ := by
obtain ⟨r, hr, a₀, a₁, hz⟩ :=
exists_scalar_relation_of_fraction_pair
(R := R) (K := K) q hfactor hq e₀ e₁ z hgeneric
obtain ⟨n, u, hu⟩ :=
IsDiscreteValuationRing.eq_unit_mul_pow_irreducible
hr hπ
refine
⟨n, (↑(u⁻¹) : R) * a₀, (↑(u⁻¹) : R) * a₁, ?_⟩
apply (smul_right_injective (M := B) u.ne_zero)
change
(u : R) • ((π ^ n) • z) =
(u : R) •
(((↑(u⁻¹) : R) * a₀) • e₀ +
((↑(u⁻¹) : R) * a₁) • e₁)
rw [← mul_smul, ← hu, hz]
simp only [smul_add, ← mul_smul]
norm_num
/--
The generic basis gives the required two-coefficient presentation of every
generic image.
-/
theorem exists_generic_pair_of_basis
(q : B →+* G)
(e₀ e₁ z : B)
(bG : Basis (Fin 2) K G)
(he₀ : q e₀ = bG 0)
(he₁ : q e₁ = bG 1) :
∃ α₀ α₁ : K,
q z = α₀ • q e₀ + α₁ • q e₁ := by
refine
⟨bG.repr (q z) 0, bG.repr (q z) 1, ?_⟩
have hsum := bG.sum_repr (q z)
rw [Fin.sum_univ_two] at hsum
rw [he₀, he₁]
exact hsum.symm
/--
An injective generic-fibre map carrying the pair to a basis proves
integral linear independence of the same pair.
-/
theorem pair_linearIndependent_of_fraction_basis
(q : B →+* G)
(hfactor :
q.comp (algebraMap R B) = algebraMap R G)
(hq : Function.Injective q)
(e₀ e₁ : B)
(bG : Basis (Fin 2) K G)
(he₀ : q e₀ = bG 0)
(he₁ : q e₁ = bG 1) :
LinearIndependent R (pairFamily e₀ e₁) := by
let qAlg : B →ₐ[R] G :=
{ toRingHom := q
commutes' := fun a => by
change q (algebraMap R B a) = algebraMap R G a
simpa only [RingHom.comp_apply] using
DFunLike.congr_fun hfactor a }
have hmap :
qAlg.toLinearMap ∘ pairFamily e₀ e₁ =
(bG : Fin 2 → G) := by
funext i
fin_cases i
· exact he₀
· exact he₁
have hliMap :
LinearIndependent R
(qAlg.toLinearMap ∘ pairFamily e₀ e₁) := by
rw [hmap]
exact bG.linearIndependent.restrict_scalars' R
exact
(qAlg.toLinearMap.linearIndependent_iff
(LinearMap.ker_eq_bot.mpr hq)).mp hliMap
/--
The two-fibre argument in one statement: a generic basis clears
denominators, the reduced basis removes them, and generic injectivity gives
linear independence. Hence the same literal pair is an integral basis.
-/
theorem exists_basis_of_two_fibres
[IsDiscreteValuationRing R]
(π : R)
(hπ : Irreducible π)
(g : B →+* C)
(hfactorSpecial :
g.comp (algebraMap R B) =
(algebraMap k C).comp (algebraMap R k))
(hπ_zero : algebraMap R k π = 0)
(hkerSpecial :
RingHom.ker (algebraMap R k) =
Ideal.span ({π} : Set R))
(q : B →+* G)
(hfactorGeneric :
q.comp (algebraMap R B) = algebraMap R G)
(hq : Function.Injective q)
(e₀ e₁ : B)
(bC : Basis (Fin 2) k C)
(hg₀ : g e₀ = bC 0)
(hg₁ : g e₁ = bC 1)
(bG : Basis (Fin 2) K G)
(hq₀ : q e₀ = bG 0)
(hq₁ : q e₁ = bG 1) :
∃ b : Basis (Fin 2) R B,
(b : Fin 2 → B) = pairFamily e₀ e₁ := by
have hπ_ne : π ≠ 0 := hπ.ne_zero
have hclear :
∀ z : B, ∃ n : ℕ, ∃ a₀ a₁ : R,
(π ^ n) • z = a₀ • e₀ + a₁ • e₁ := by
intro z
exact
exists_power_relation_of_fraction_pair
(R := R) (K := K) π hπ q hfactorGeneric hq
e₀ e₁ z
(exists_generic_pair_of_basis q e₀ e₁ z
bG hq₀ hq₁)
have hspanPair :
Submodule.span R ({e₀, e₁} : Set B) = ⊤ :=
span_pair_eq_top
g hfactorSpecial π hπ_ne hπ_zero hkerSpecial
e₀ e₁ bC hg₀ hg₁ hclear
have hspan :
Submodule.span R
(Set.range (pairFamily e₀ e₁)) = ⊤ := by
rw [range_pairFamily]
exact hspanPair
have hli :
LinearIndependent R (pairFamily e₀ e₁) :=
pair_linearIndependent_of_fraction_basis
(R := R) (K := K)
q hfactorGeneric hq e₀ e₁ bG hq₀ hq₁
exact
⟨Basis.mk hli hspan.ge, Basis.coe_mk hli hspan.ge⟩
end FractionFieldClearing
end
end MazurProof.N13TwoFiberNoEscape
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13TwoFiberConcreteBasis
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# The concrete two-fibre basis for an N13 contraction
Assume only the remaining representative-level statement that the canonical
contraction reduces to the fixed special graph ideal. The generic and special
quotient frames are then both literally `{1,x}`. The two-fibre no-escape
theorem therefore makes the same pair an integral basis, without any prior
finiteness assumption.
-/
open Polynomial
open Module
open scoped TensorProduct
namespace MazurProof.N13TwoFiberConcreteBasis
noncomputable section
local instance instFactPrimeOfNatNat_fLT : Fact (Nat.Prime 2) :=
⟨Nat.prime_two⟩
abbrev R₂ : Type :=
N13IntegralModelContraction.R₂
abbrev Q₂ : Type :=
N13IntegralModelContraction.Q₂
abbrev k : Type :=
N13GoodCoordinateRingTwo.K
abbrev IntegralRing : Type :=
N13IntegralModelContraction.IntegralRing
abbrev RationalRing : Type :=
N13IntegralModelContraction.RationalRing
abbrev SpecialRing : Type :=
N13GeneralizedMumfordReduction.SpecialRing
abbrev Model : SexticMumford.Model Q₂ :=
N13GoodSexticCoordinateEquiv.M (K := Q₂)
abbrev SpecialQuotient : Type :=
SpecialRing ⧸ N13SpecialQuotientBasis.specialIdeal
abbrev κ : Type :=
IsLocalRing.ResidueField R₂
local instance integralRationalAlgebra :
Algebra IntegralRing RationalRing :=
N13TwoAdicCoordinateBaseChange.integralToSextic.toAlgebra
local instance baseSpecialAlgebra : Algebra R₂ k :=
N13GeneralizedMumfordReduction.reduceBase.toAlgebra
local instance baseSpecialQuotientTower :
IsScalarTower R₂ k SpecialQuotient :=
IsScalarTower.of_algebraMap_eq
(R := R₂) (S := k) (A := SpecialQuotient)
fun _ => rfl
theorem ker_baseSpecial :
RingHom.ker (algebraMap R₂ k) =
Ideal.span ({(2 : R₂)} : Set R₂) := by
change RingHom.ker PadicInt.toZMod =
Ideal.span ({(2 : R₂)} : Set R₂)
rw [PadicInt.ker_toZMod,
PadicInt.maximalIdeal_eq_span_p]
congr 2
@[simp] theorem baseSpecial_two :
algebraMap R₂ k (2 : R₂) = 0 :=
N13GeneralizedMumfordReduction.reduceBase_two
/-- The descended reduction map respects the chosen composite
`R₂ → k → SpecialQuotient` scalar structure. -/
theorem specialQuotientMap_comp_algebraMap
(I : Ideal IntegralRing)
(hmap :
Ideal.map
N13GeneralizedMumfordReduction.reduceCoordinate I =
N13SpecialQuotientBasis.specialIdeal) :
(N13QuotientReduction.reduceCoordinateQuotient
I N13SpecialQuotientBasis.specialIdeal hmap).comp
(algebraMap R₂ (IntegralRing ⧸ I)) =
(algebraMap k SpecialQuotient).comp
(algebraMap R₂ k) := by
ext r
change
Ideal.Quotient.mk N13SpecialQuotientBasis.specialIdeal
(N13GeneralizedMumfordReduction.reduceCoordinate
(algebraMap R₂ IntegralRing r)) =
Ideal.Quotient.mk N13SpecialQuotientBasis.specialIdeal
(algebraMap k SpecialRing
(N13GeneralizedMumfordReduction.reduceBase r))
congr 1
change
N13GeneralizedMumfordReduction.reduceCoordinate
(N13GeneralizedMumfordIntegral.xClass (C r)) =
N13GoodCoordinateRingTwo.xClass
(C (N13GeneralizedMumfordReduction.reduceBase r))
rw [N13GeneralizedMumfordReduction.reduce_xClass]
simp [N13GeneralizedMumfordReduction.reducePoly]
/-- Reduction sends the integral class of `x` to the first fixed special
basis vector. -/
theorem specialQuotientMap_x_eq_basis_one
(I : Ideal IntegralRing)
(hmap :
Ideal.map
N13GeneralizedMumfordReduction.reduceCoordinate I =
N13SpecialQuotientBasis.specialIdeal) :
N13QuotientReduction.reduceCoordinateQuotient
I N13SpecialQuotientBasis.specialIdeal hmap
(Ideal.Quotient.mk I
N13CanonicalContractionQuotient.integralX) =
N13SpecialQuotientBasis.quotientBasis 1 := by
rw [N13QuotientReduction.reduceCoordinateQuotient_mk,
N13CanonicalContractionQuotient.integralX,
N13GeneralizedMumfordReduction.reduce_xClass,
N13SpecialQuotientBasis.quotientBasis_one]
simp [N13GeneralizedMumfordReduction.reducePoly,
N13GeneralizedMumfordReduction.reduceBase]
/-- A literal fixed special fibre forces the integral classes `{1,x}` in
the contracted quotient to be linearly independent. Flatness lifts the
independence from the residue-field tensor product; no generic degree
hypothesis is used. -/
theorem integralPair_linearIndependent
(D : SexticMumford.SemiMumford Model)
(hmap :
Ideal.map
N13GeneralizedMumfordReduction.reduceCoordinate
(N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)) =
N13SpecialQuotientBasis.specialIdeal) :
LinearIndependent R₂
(N13TwoFiberNoEscape.pairFamily
(1 :
IntegralRing ⧸
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D))
(Ideal.Quotient.mk
(N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D))
N13CanonicalContractionQuotient.integralX)) := by
let I :=
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)
let B := IntegralRing ⧸ I
let g :=
N13QuotientReduction.reduceCoordinateQuotient
I N13SpecialQuotientBasis.specialIdeal hmap
let e₀ : B := 1
let e₁ : B :=
Ideal.Quotient.mk I
N13CanonicalContractionQuotient.integralX
have hfactor :
g.comp (algebraMap R₂ B) =
(algebraMap κ SpecialQuotient).comp
(IsLocalRing.residue R₂) := by
ext r
calc
g (algebraMap R₂ B r) =
algebraMap k SpecialQuotient
(algebraMap R₂ k r) := by
simpa only [RingHom.comp_apply, g, B] using
DFunLike.congr_fun
(specialQuotientMap_comp_algebraMap I hmap) r
_ = algebraMap R₂ SpecialQuotient r :=
(IsScalarTower.algebraMap_apply
R₂ k SpecialQuotient r).symm
_ = algebraMap κ SpecialQuotient
(algebraMap R₂ κ r) :=
IsScalarTower.algebraMap_apply
R₂ κ SpecialQuotient r
_ = algebraMap κ SpecialQuotient
(IsLocalRing.residue R₂ r) := by
rfl
have htwo :
(2 : R₂) ∈ IsLocalRing.maximalIdeal R₂ := by
rw [PadicInt.maximalIdeal_eq_span_p]
exact Ideal.subset_span (Set.mem_singleton (2 : R₂))
let hg :
Function.Surjective g :=
N13QuotientReduction.reduceCoordinateQuotient_surjective
I N13SpecialQuotientBasis.specialIdeal hmap
let hker :
RingHom.ker g =
Ideal.span ({algebraMap R₂ B (2 : R₂)} : Set B) :=
N13QuotientReduction.ker_reduceCoordinateQuotient_eq_span_two
I N13SpecialQuotientBasis.specialIdeal hmap
let e :
κ ⊗[R₂] B ≃ₗ[κ] SpecialQuotient :=
N13TensorSpecialFiber.residueLinearEquiv
g hfactor (2 : R₂) htwo hg hker
have hliSpecial :
LinearIndependent κ
(N13SpecialQuotientBasis.quotientBasis :
Fin 2 → SpecialQuotient) :=
N13SpecialQuotientBasis.quotientBasis.linearIndependent
|>.restrict_scalars' κ
have e_tmul_one (b : B) :
e (TensorProduct.mk R₂ κ B 1 b) = g b := by
change
(N13TensorSpecialFiber.residueLinearEquiv
g hfactor (2 : R₂) htwo hg hker)
((1 : κ) ⊗ₜ[R₂] b) = g b
simpa only [one_smul] using
(N13TensorSpecialFiber.residueLinearEquiv_tmul
(g := g) (hfactor := hfactor)
(π := (2 : R₂)) (hπ := htwo)
(hg := hg) (hker := hker)
(1 : κ) b)
have heval (i : Fin 2) :
e
(TensorProduct.mk R₂ κ B 1
(N13TwoFiberNoEscape.pairFamily e₀ e₁ i)) =
N13SpecialQuotientBasis.quotientBasis i := by
rw [e_tmul_one]
fin_cases i
· simp [e₀, g]
· simpa [e₁, g] using
specialQuotientMap_x_eq_basis_one I hmap
have hliTensor :
LinearIndependent κ
(TensorProduct.mk R₂ κ B 1 ∘
N13TwoFiberNoEscape.pairFamily e₀ e₁) := by
apply LinearIndependent.of_comp e.toLinearMap
convert hliSpecial using 1
funext i
exact heval i
letI : Module.Flat R₂ B :=
N13QuotientVerticalFlatness.contractQuotient_flat
(N13CanonicalContractionQuotient.graphIdeal D)
exact
IsLocalRing.linearIndependent_of_flat
(N13TwoFiberNoEscape.pairFamily e₀ e₁) hliTensor
universe uR uK uB uG uι
/-- Clear one common denominator in a finite generic relation and descend
it through an injective integral algebra map. -/
theorem linearIndependent_map_to_fractionField
{R : Type uR} {K : Type uK}
[CommRing R] [Field K] [Algebra R K]
{B : Type uB} [CommRing B] [Algebra R B]
{G : Type uG} [CommRing G]
[Algebra R G] [Algebra K G] [IsScalarTower R K G]
{ι : Type uι} [Fintype ι]
(hRK : Function.Injective (algebraMap R K))
(q : B →ₐ[R] G) (hq : Function.Injective q)
(v : ι → B)
(hden :
∀ c : ι → K,
∃ d : R, d ≠ 0 ∧ ∃ a : ι → R,
∀ i,
algebraMap R K (a i) =
algebraMap R K d * c i)
(hv : LinearIndependent R v) :
LinearIndependent K (fun i => q (v i)) := by
rw [Fintype.linearIndependent_iff] at hv ⊢
intro c hc i
obtain ⟨d, hd, a, ha⟩ := hden c
have hdK : algebraMap R K d ≠ 0 := by
simpa using hRK.ne hd
have hscaled :
∑ j, algebraMap R K (a j) • q (v j) = 0 := by
calc
∑ j, algebraMap R K (a j) • q (v j) =
∑ j, (algebraMap R K d * c j) • q (v j) := by
apply Finset.sum_congr rfl
intro j _
rw [ha j]
_ = ∑ j, algebraMap R K d •
(c j • q (v j)) := by
apply Finset.sum_congr rfl
intro j _
rw [smul_smul]
_ = algebraMap R K d •
∑ j, c j • q (v j) := by
rw [Finset.smul_sum]
_ = 0 := by rw [hc, smul_zero]
have hqsum :
q (∑ j, a j • v j) = 0 := by
calc
q (∑ j, a j • v j) =
∑ j, q (a j • v j) := by simp
_ = ∑ j, a j • q (v j) := by simp
_ = ∑ j, algebraMap R K (a j) •
q (v j) := by
apply Finset.sum_congr rfl
intro j _
rw [Algebra.smul_def, Algebra.smul_def,
IsScalarTower.algebraMap_apply R K G]
_ = 0 := hscaled
have hint : ∑ j, a j • v j = 0 := by
apply hq
simpa only [map_zero] using hqsum
have hai : a i = 0 := hv a hint i
have hprod : algebraMap R K d * c i = 0 := by
rw [← ha i, hai, map_zero]
exact (mul_eq_zero.mp hprod).resolve_left hdK
/-- A linearly independent pair in an algebra linearly equivalent to a
monic polynomial quotient forces polynomial degree at least two. -/
theorem natDegree_ge_two_of_linearIndependent_fin_two
{K : Type uK} [Field K]
(u : K[X]) (hu : u.Monic)
{B : Type uB} [AddCommGroup B] [Module K B]
(e : B ≃ₗ[K] AdjoinRoot u)
{v : Fin 2 → B}
(hv : LinearIndependent K v) :
2 ≤ u.natDegree := by
letI : Module.Finite K (AdjoinRoot u) :=
hu.finite_adjoinRoot
have hv' :
LinearIndependent K (fun i => e (v i)) := by
change LinearIndependent K (e ∘ v)
exact
hv.map' e.toLinearMap
(LinearMap.ker_eq_bot_of_injective e.injective)
calc
2 = Fintype.card (Fin 2) := by simp
_ ≤ Module.finrank K (AdjoinRoot u) :=
hv'.fintype_card_le_finrank
_ = u.natDegree :=
(AdjoinRoot.powerBasis' hu).finrank
/-- The literal two-dimensional special fibre itself forces the generic
Mumford polynomial to have degree two, provided only the balanced upper
bound. -/
theorem degree_eq_two_of_map_contractIdeal_eq_special
(D : SexticMumford.SemiMumford Model)
(hdeg_le : D.u.natDegree ≤ 2)
(hmap :
Ideal.map
N13GeneralizedMumfordReduction.reduceCoordinate
(N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)) =
N13SpecialQuotientBasis.specialIdeal) :
D.u.natDegree = 2 := by
let J :=
N13CanonicalContractionQuotient.graphIdeal D
let I :=
N13IntegralModelContraction.contractIdeal J
let B := IntegralRing ⧸ I
let G := RationalRing ⧸ J
let v : Fin 2 → B :=
N13TwoFiberNoEscape.pairFamily
1
(Ideal.Quotient.mk I
N13CanonicalContractionQuotient.integralX)
let q : B →ₐ[R₂] G :=
{ toRingHom :=
N13CanonicalContractionQuotient.genericQuotientMap J
commutes' := fun r => by
change
N13CanonicalContractionQuotient.genericQuotientMap J
(algebraMap R₂
(IntegralRing ⧸
N13IntegralModelContraction.contractIdeal J) r) =
algebraMap R₂ (RationalRing ⧸ J) r
simpa only [RingHom.comp_apply] using
DFunLike.congr_fun
(N13CanonicalContractionQuotient.genericQuotientMap_comp_algebraMap
J) r }
have hvR : LinearIndependent R₂ v := by
simpa only [J, I, B, v] using
integralPair_linearIndependent D hmap
have hden :
∀ c : Fin 2 → Q₂,
∃ d : R₂, d ≠ 0 ∧ ∃ a : Fin 2 → R₂,
∀ i,
algebraMap R₂ Q₂ (a i) =
algebraMap R₂ Q₂ d * c i := by
intro c
obtain ⟨d, hd, a₀, a₁, ha₀, ha₁⟩ :=
N13TwoFiberNoEscape.exists_common_denominator
(R := R₂) (K := Q₂) (c 0) (c 1)
refine ⟨d, hd,
N13TwoFiberNoEscape.pairFamily a₀ a₁, ?_⟩
intro i
fin_cases i
· simpa using ha₀.symm
· simpa using ha₁.symm
have hvQ :
LinearIndependent Q₂ (fun i => q (v i)) := by
exact
linearIndependent_map_to_fractionField
(hRK := IsFractionRing.injective R₂ Q₂)
q
(N13CanonicalContractionQuotient.genericQuotientMap_injective J)
v hden hvR
have hge : 2 ≤ D.u.natDegree :=
natDegree_ge_two_of_linearIndependent_fin_two
D.u D.u_monic
(SexticMumford.mumfordQuotientAlgEquiv
Model D).toLinearEquiv
hvQ
exact le_antisymm hdeg_le hge
/-- Once the canonical contraction has the fixed literal special fibre, the
integral quotient has the literal basis `{1,x}`. -/
theorem exists_contractQuotient_basis
(D : SexticMumford.SemiMumford Model)
(hdeg : D.u.natDegree = 2)
(hmap :
Ideal.map
N13GeneralizedMumfordReduction.reduceCoordinate
(N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)) =
N13SpecialQuotientBasis.specialIdeal) :
∃ b : Basis (Fin 2) R₂
(IntegralRing ⧸
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)),
(b : Fin 2 →
IntegralRing ⧸
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)) =
N13TwoFiberNoEscape.pairFamily
1
(Ideal.Quotient.mk
(N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D))
N13CanonicalContractionQuotient.integralX) := by
let I :=
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)
let B := IntegralRing ⧸ I
let G :=
RationalRing ⧸
N13CanonicalContractionQuotient.graphIdeal D
letI : Module.IsTorsionFree R₂ B :=
N13QuotientVerticalFlatness.contractQuotient_isTorsionFree
(N13CanonicalContractionQuotient.graphIdeal D)
exact
N13TwoFiberNoEscape.exists_basis_of_two_fibres
(R := R₂) (k := k) (K := Q₂)
(B := B) (C := SpecialQuotient) (G := G)
(π := (2 : R₂))
(hπ := PadicInt.irreducible_p)
(g := N13QuotientReduction.reduceCoordinateQuotient
I N13SpecialQuotientBasis.specialIdeal hmap)
(hfactorSpecial :=
specialQuotientMap_comp_algebraMap I hmap)
(hπ_zero := baseSpecial_two)
(hkerSpecial := ker_baseSpecial)
(q := N13CanonicalContractionQuotient.genericQuotientMap
(N13CanonicalContractionQuotient.graphIdeal D))
(hfactorGeneric :=
N13CanonicalContractionQuotient.genericQuotientMap_comp_algebraMap
(N13CanonicalContractionQuotient.graphIdeal D))
(hq :=
N13CanonicalContractionQuotient.genericQuotientMap_injective
(N13CanonicalContractionQuotient.graphIdeal D))
(e₀ := 1)
(e₁ := Ideal.Quotient.mk I
N13CanonicalContractionQuotient.integralX)
(bC := N13SpecialQuotientBasis.quotientBasis)
(hg₀ := by simp)
(hg₁ := specialQuotientMap_x_eq_basis_one I hmap)
(bG := SexticMumfordQuotientBasis.quotientBasis
Model D hdeg)
(hq₀ :=
N13CanonicalContractionQuotient.genericQuotientMap_one_eq_basis_zero
D hdeg)
(hq₁ :=
N13CanonicalContractionQuotient.genericQuotientMap_x_eq_basis_one
D hdeg)
end
end MazurProof.N13TwoFiberConcreteBasis
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13IntegralFractionalHull
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Divisorial hulls on the N13 integral model
The N13 generic affine ring is the vertical localization of its integral
good-model ring. This file proves that the common function field is also the
fraction field of the integral model and that vertical extension commutes with
inverse fractional ideals.
The reverse inclusion is the substantive point: a fractional ideal over the
Noetherian integral model has finitely many generators, so one vertical scalar
clears all denominators of their products with a generic inverse section.
Consequently the divisorial double inverse of a contracted invertible generic
ideal has exactly the original generic fibre. No affine generator or
principality assumption is used.
-/
open scoped nonZeroDivisors
namespace MazurProof.N13IntegralFractionalHull
noncomputable section
local instance instFactPrimeOfNatNat_fLT : Fact (Nat.Prime 2) :=
⟨Nat.prime_two⟩
abbrev IntegralRing : Type :=
N13IntegralModelContraction.IntegralRing
abbrev RationalRing : Type :=
N13IntegralModelContraction.RationalRing
abbrev FunctionField : Type :=
N13Mumford.FunctionField
N13IntegralModelContraction.Q₂
def integralToRational : IntegralRing →+* RationalRing :=
N13TwoAdicCoordinateBaseChange.integralToSextic
local instance integralRationalAlgebra :
Algebra IntegralRing RationalRing :=
integralToRational.toAlgebra
theorem integralToRational_injective :
Function.Injective integralToRational := by
exact
(N13GoodSexticCoordinateEquiv.coordinateRingEquiv
(K := N13IntegralModelContraction.Q₂)).injective.comp
N13TwoAdicCoordinateBaseChange.extendCoordinate_injective
local instance integralRingDomain : IsDomain IntegralRing :=
integralToRational_injective.isDomain integralToRational
local instance rationalRingLocalization :
IsLocalization
N13IntegralModelContraction.verticalScalars
RationalRing :=
N13IntegralModelContraction.rationalRing_isLocalization
/-- The function field of the generic fibre is also the fraction field of
the integral model. -/
theorem functionField_isFractionRing :
IsFractionRing IntegralRing FunctionField := by
let M := N13IntegralModelContraction.verticalScalars
let N := nonZeroDivisors RationalRing
have hloc :
IsLocalization
(N.comap (algebraMap IntegralRing RationalRing))
FunctionField :=
IsLocalization.localization_localization_isLocalization_of_has_all_units
M N FunctionField (fun x hx => by
change x ∈ nonZeroDivisors RationalRing
rw [mem_nonZeroDivisors_iff_ne_zero]
exact hx.ne_zero)
have hsub :
N.comap (algebraMap IntegralRing RationalRing) =
nonZeroDivisors IntegralRing := by
ext a
change
integralToRational a ∈ nonZeroDivisors RationalRing ↔
a ∈ nonZeroDivisors IntegralRing
simp only [mem_nonZeroDivisors_iff_ne_zero]
simpa only [map_zero] using
(integralToRational_injective.ne_iff
(x := a) (y := 0))
rw [hsub] at hloc
exact hloc
local instance integralFunctionFieldFractionRing :
IsFractionRing IntegralRing FunctionField :=
functionField_isFractionRing
abbrev IntegralFractionalIdeal : Type :=
FractionalIdeal IntegralRing⁰ FunctionField
abbrev RationalFractionalIdeal : Type :=
FractionalIdeal RationalRing⁰ FunctionField
def nonZeroDivisors_le_comap :
IntegralRing⁰ ≤
RationalRing⁰.comap integralToRational :=
nonZeroDivisors_le_comap_nonZeroDivisors_of_injective
integralToRational integralToRational_injective
/-- Extension of fractional ideals from the integral model to its generic
affine coordinate ring. -/
def extendFractional :
IntegralFractionalIdeal →+* RationalFractionalIdeal :=
FractionalIdeal.extendedHom'
FunctionField nonZeroDivisors_le_comap
/-- The induced self-map of the common function field is the identity. -/
theorem fractionFieldMap_eq_id :
IsLocalization.map
FunctionField integralToRational
nonZeroDivisors_le_comap =
RingHom.id FunctionField := by
apply IsLocalization.ringHom_ext IntegralRing⁰
apply DFunLike.ext _ _
intro a
change
IsLocalization.map
FunctionField integralToRational
nonZeroDivisors_le_comap
(algebraMap IntegralRing FunctionField a) =
algebraMap IntegralRing FunctionField a
rw [IsLocalization.map_eq]
rfl
/-- The contracted generic ideal, regarded inside the common function
field. -/
def contractedFractional
(J : Ideal RationalRing) :
IntegralFractionalIdeal :=
(N13IntegralModelContraction.contractIdeal J :
IntegralFractionalIdeal)
/-- Extending the contracted fractional ideal recovers the original generic
ideal exactly. -/
theorem extendFractional_contracted
(J : Ideal RationalRing) :
extendFractional (contractedFractional J) =
(J : RationalFractionalIdeal) := by
rw [extendFractional, contractedFractional,
FractionalIdeal.extendedHom'_apply,
FractionalIdeal.extended_coeIdeal_eq_map]
unfold integralToRational
rw [N13IntegralModelContraction.map_contractIdeal]
theorem mem_extendFractional_of_mem
{I : IntegralFractionalIdeal} {x : FunctionField}
(hx : x ∈ I) :
x ∈ extendFractional I := by
change
x ∈ FractionalIdeal.extended
FunctionField nonZeroDivisors_le_comap
I
rw [FractionalIdeal.mem_extended_iff]
apply Submodule.subset_span
refine ⟨x, hx, ?_⟩
rw [fractionFieldMap_eq_id]
rfl
theorem mem_generic_of_mem_contracted
(J : Ideal RationalRing) {x : FunctionField}
(hx : x ∈ contractedFractional J) :
x ∈ (J : RationalFractionalIdeal) := by
rw [← extendFractional_contracted J]
exact mem_extendFractional_of_mem hx
theorem mem_rational_one_of_mem_integral_one
{x : FunctionField}
(hx : x ∈ (1 : IntegralFractionalIdeal)) :
x ∈ (1 : RationalFractionalIdeal) := by
obtain ⟨a, ha⟩ :=
(FractionalIdeal.mem_one_iff IntegralRing⁰).mp hx
apply (FractionalIdeal.mem_one_iff RationalRing⁰).mpr
refine ⟨integralToRational a, ?_⟩
change
algebraMap RationalRing FunctionField
(algebraMap IntegralRing RationalRing a) = x
rw [← IsScalarTower.algebraMap_apply
IntegralRing RationalRing FunctionField]
exact ha
theorem contractedFractional_ne_zero
{J : Ideal RationalRing} (hJ : J ≠ ⊥) :
contractedFractional J ≠ 0 := by
rw [contractedFractional,
FractionalIdeal.coeIdeal_ne_zero]
exact
N13IntegralModelContraction.contractIdeal_ne_bot hJ
theorem contractedFractional_fg
(J : Ideal RationalRing) :
(contractedFractional J).coeToSubmodule.FG := by
change
(((N13IntegralModelContraction.contractIdeal J :
Ideal IntegralRing) :
IntegralFractionalIdeal).coeToSubmodule).FG
rw [FractionalIdeal.coeIdeal_fg IntegralRing⁰
(IsFractionRing.injective IntegralRing FunctionField)]
exact IsNoetherian.noetherian _
theorem fractional_fg
(I : IntegralFractionalIdeal) :
I.coeToSubmodule.FG :=
FractionalIdeal.fg_of_isNoetherianRing (le_refl IntegralRing⁰) I
/-- Extension of an inverse is contained in the inverse of the extension.
This direction does not use finite generation. -/
theorem extendFractional_inv_le
{I : IntegralFractionalIdeal} (hI : I ≠ 0) :
extendFractional I⁻¹ ≤
(extendFractional I)⁻¹ := by
have hExtended : extendFractional I ≠ 0 :=
FractionalIdeal.extended_ne_zero
FunctionField nonZeroDivisors_le_comap
integralToRational_injective hI (by simp)
intro z hz
change
z ∈ FractionalIdeal.extended
FunctionField nonZeroDivisors_le_comap I⁻¹ at hz
rw [FractionalIdeal.mem_extended_iff] at hz
refine Submodule.span_induction
(p := fun z _ => z ∈
(extendFractional I)⁻¹)
?_ ?_ ?_ ?_ hz
· rintro _ ⟨y, hy, rfl⟩
rw [fractionFieldMap_eq_id]
rw [FractionalIdeal.mem_inv_iff hExtended]
intro x hx
change
x ∈ FractionalIdeal.extended
FunctionField nonZeroDivisors_le_comap I at hx
rw [FractionalIdeal.mem_extended_iff] at hx
refine Submodule.span_induction
(p := fun x _ => y * x ∈
(1 : RationalFractionalIdeal))
?_ ?_ ?_ ?_ hx
· rintro _ ⟨a, ha, rfl⟩
rw [fractionFieldMap_eq_id]
apply mem_rational_one_of_mem_integral_one
exact
(FractionalIdeal.mem_inv_iff hI).mp hy a ha
· simp
· intro a b _ _ ha hb
rw [mul_add]
exact
((1 : RationalFractionalIdeal) :
Submodule RationalRing FunctionField).add_mem ha hb
· intro a b _ hb
have hsmul :=
((1 : RationalFractionalIdeal) :
Submodule RationalRing FunctionField).smul_mem a hb
simpa [Algebra.smul_def, mul_assoc,
mul_left_comm, mul_comm] using hsmul
· exact FractionalIdeal.zero_mem _
· intro a b _ _ ha hb
exact
(((extendFractional I)⁻¹ :
RationalFractionalIdeal) :
Submodule RationalRing FunctionField).add_mem ha hb
· intro a b _ hb
exact
(((extendFractional I)⁻¹ :
RationalFractionalIdeal) :
Submodule RationalRing FunctionField).smul_mem a hb
set_option maxHeartbeats 800000 in
/-- Finite generation supplies one common vertical denominator, giving the
reverse inclusion for inverse fractional ideals. -/
theorem inv_extendFractional_le
{I : IntegralFractionalIdeal} (hI : I ≠ 0) :
(extendFractional I)⁻¹ ≤
extendFractional I⁻¹ := by
have hExtended : extendFractional I ≠ 0 :=
FractionalIdeal.extended_ne_zero
FunctionField nonZeroDivisors_le_comap
integralToRational_injective hI (by simp)
obtain ⟨n, g, hspan⟩ :=
Submodule.fg_iff_exists_fin_generating_family.mp
(fractional_fg I)
intro z hz
have hgI (i : Fin n) : g i ∈ I := by
change g i ∈ I.coeToSubmodule
rw [← hspan]
exact Submodule.subset_span (Set.mem_range_self i)
have hzg (i : Fin n) :
z * g i ∈ (1 : RationalFractionalIdeal) := by
exact
(FractionalIdeal.mem_inv_iff hExtended).mp hz
(g i) (mem_extendFractional_of_mem (hgI i))
choose b hb using fun i =>
(FractionalIdeal.mem_one_iff RationalRing⁰).mp (hzg i)
obtain ⟨s, hs⟩ :=
IsLocalization.exist_integer_multiples_of_finite
N13IntegralModelContraction.verticalScalars b
choose a ha using fun i => hs i
have hszInv :
(s : IntegralRing) • z ∈ I⁻¹ := by
rw [FractionalIdeal.mem_inv_iff hI]
intro x hx
change x ∈ I.coeToSubmodule at hx
rw [← hspan] at hx
refine Submodule.span_induction
(p := fun x _ =>
((s : IntegralRing) • z) * x ∈
(1 : IntegralFractionalIdeal))
?_ ?_ ?_ ?_ hx
· rintro _ ⟨i, rfl⟩
apply (FractionalIdeal.mem_one_iff IntegralRing⁰).mpr
refine ⟨a i, ?_⟩
calc
algebraMap IntegralRing FunctionField (a i) =
algebraMap RationalRing FunctionField
(algebraMap IntegralRing RationalRing (a i)) := by
rw [IsScalarTower.algebraMap_apply
IntegralRing RationalRing FunctionField]
_ = algebraMap RationalRing FunctionField
((s : IntegralRing) • b i) := by rw [ha i]
_ = (s : IntegralRing) •
algebraMap RationalRing FunctionField (b i) := by
simp only [Algebra.smul_def]
rw [map_mul,
IsScalarTower.algebraMap_apply
IntegralRing RationalRing FunctionField]
_ = (s : IntegralRing) • (z * g i) := by rw [hb i]
_ = ((s : IntegralRing) • z) * g i := by
simp [Algebra.smul_def, mul_assoc]
· simp
· intro x y _ _ hx hy
rw [mul_add]
exact
((1 : IntegralFractionalIdeal) :
Submodule IntegralRing FunctionField).add_mem hx hy
· intro r x _ hx
have hrx :=
((1 : IntegralFractionalIdeal) :
Submodule IntegralRing FunctionField).smul_mem r hx
simpa [Algebra.smul_def, mul_assoc,
mul_left_comm, mul_comm] using hrx
have hszExtended :
(s : IntegralRing) • z ∈
extendFractional I⁻¹ := by
change
(s : IntegralRing) • z ∈
FractionalIdeal.extended
FunctionField nonZeroDivisors_le_comap I⁻¹
rw [FractionalIdeal.mem_extended_iff]
apply Submodule.subset_span
refine ⟨(s : IntegralRing) • z, hszInv, ?_⟩
rw [fractionFieldMap_eq_id]
rfl
exact
(IsLocalization.smul_mem_iff
(R := IntegralRing) (R' := RationalRing)
(N' :=
(extendFractional I⁻¹ :
Submodule RationalRing FunctionField))
(s := s)).mp hszExtended
/-- Extension along the vertical localization commutes with inverse for every
nonzero fractional ideal of the Noetherian integral model. -/
theorem extendFractional_inv
{I : IntegralFractionalIdeal} (hI : I ≠ 0) :
extendFractional I⁻¹ =
(extendFractional I)⁻¹ :=
le_antisymm
(extendFractional_inv_le hI)
(inv_extendFractional_le hI)
theorem extendFractional_inv_contracted
{J : Ideal RationalRing} (hJ : J ≠ ⊥) :
extendFractional (contractedFractional J)⁻¹ =
(J : RationalFractionalIdeal)⁻¹ := by
rw [extendFractional_inv
(contractedFractional_ne_zero hJ),
extendFractional_contracted]
/-- The inverse of a nonzero fractional ideal is nonzero. -/
theorem fractional_inv_ne_zero
{I : IntegralFractionalIdeal} (hI : I ≠ 0) :
I⁻¹ ≠ 0 := by
intro hzero
have hden := FractionalIdeal.den_mem_inv hI
rw [hzero, FractionalIdeal.mem_zero_iff] at hden
exact
(IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors
I.den.prop) hden
/-- The vertical generic-fibre functor preserves the divisorial double
inverse. -/
theorem extendFractional_inv_inv
{I : IntegralFractionalIdeal} (hI : I ≠ 0) :
extendFractional I⁻¹⁻¹ =
(extendFractional I)⁻¹⁻¹ := by
rw [extendFractional_inv (fractional_inv_ne_zero hI),
extendFractional_inv hI]
/-- Every nonzero fractional ideal maps into its divisorial double inverse.
This is the algebraic evaluation map into the double dual. -/
theorem le_inv_inv
{I : IntegralFractionalIdeal} (hI : I ≠ 0) :
I ≤ I⁻¹⁻¹ := by
have hInv : I⁻¹ ≠ 0 :=
fractional_inv_ne_zero hI
intro x hx
rw [FractionalIdeal.mem_inv_iff hInv]
intro y hy
rw [mul_comm]
exact
(FractionalIdeal.mem_inv_iff hI).mp hy x hx
/-- Multiplier inverse is unchanged by taking the divisorial double inverse.
Equivalently, triple inverse equals single inverse for every nonzero
fractional ideal. -/
theorem inv_inv_inv
{I : IntegralFractionalIdeal} (hI : I ≠ 0) :
I⁻¹⁻¹⁻¹ = I⁻¹ := by
have hInv : I⁻¹ ≠ 0 :=
fractional_inv_ne_zero hI
have hInvInv : I⁻¹⁻¹ ≠ 0 :=
fractional_inv_ne_zero hInv
apply le_antisymm
· exact
FractionalIdeal.inv_anti_mono
hI hInvInv (le_inv_inv hI)
· exact le_inv_inv hInv
/-- Divisorial/reflexive hull of the contracted ideal. -/
def divisorialHull
(J : Ideal RationalRing) :
IntegralFractionalIdeal :=
(contractedFractional J)⁻¹⁻¹
/-- The multiplier inverse of the divisorial hull is already the multiplier
inverse of the original contracted ideal. -/
theorem divisorialHull_inv
{J : Ideal RationalRing} (hJ : J ≠ ⊥) :
(divisorialHull J)⁻¹ =
(contractedFractional J)⁻¹ := by
rw [divisorialHull,
inv_inv_inv (contractedFractional_ne_zero hJ)]
theorem extendFractional_divisorialHull
{J : Ideal RationalRing} (hJ : J ≠ ⊥) :
extendFractional (divisorialHull J) =
(J : RationalFractionalIdeal)⁻¹⁻¹ := by
rw [divisorialHull,
extendFractional_inv_inv
(contractedFractional_ne_zero hJ),
extendFractional_contracted]
/-- Double inverse fixes every invertible fractional ideal. -/
theorem inv_inv_eq_of_isUnit
{I : RationalFractionalIdeal} (hI : IsUnit I) :
I⁻¹⁻¹ = I := by
have hmul : I * I⁻¹ = 1 :=
(FractionalIdeal.mul_inv_cancel_iff_isUnit
FunctionField).mpr hI
exact
(FractionalIdeal.right_inverse_eq
FunctionField I⁻¹ I (by simpa [mul_comm] using hmul)).symm
theorem extendFractional_divisorialHull_eq
{J : Ideal RationalRing} (hJ : J ≠ ⊥)
(hUnit : IsUnit (J : RationalFractionalIdeal)) :
extendFractional (divisorialHull J) =
(J : RationalFractionalIdeal) := by
rw [extendFractional_divisorialHull hJ,
inv_inv_eq_of_isUnit hUnit]
/-- The divisorial hull attached to an integral oriented Mumford
representative has exactly the same generic finite ideal. -/
theorem orientedRep_divisorialHull_genericFiber
(R : N13IntegralModelContraction.IntegralOrientedRep) :
extendFractional (divisorialHull R.ideal) =
(R.ideal : RationalFractionalIdeal) :=
extendFractional_divisorialHull_eq
(R.ideal_ne_bot (N13Mumford.model
N13IntegralModelContraction.Q₂))
(R.ideal_isUnit (N13Mumford.model
N13IntegralModelContraction.Q₂))
theorem contractedFractional_le_divisorialHull
{J : Ideal RationalRing} (hJ : J ≠ ⊥) :
contractedFractional J ≤ divisorialHull J :=
le_inv_inv (contractedFractional_ne_zero hJ)
theorem extended_mono
{I L : IntegralFractionalIdeal} (hIL : I ≤ L) :
extendFractional I ≤ extendFractional L := by
intro x hx
change
x ∈ FractionalIdeal.extended
FunctionField nonZeroDivisors_le_comap I at hx
change
x ∈ FractionalIdeal.extended
FunctionField nonZeroDivisors_le_comap L
rw [FractionalIdeal.mem_extended_iff] at hx ⊢
exact Submodule.span_mono (Set.image_mono hIL) hx
/-- The evaluation map into the divisorial hull gives the easy generic-fibre
containment directly. -/
theorem genericIdeal_le_extended_divisorialHull
{J : Ideal RationalRing} (hJ : J ≠ ⊥) :
(J : RationalFractionalIdeal) ≤
extendFractional (divisorialHull J) := by
rw [← extendFractional_contracted J]
exact
extended_mono
(contractedFractional_le_divisorialHull hJ)
/-- The integral defect ideal attached to a fractional ideal. Its
fractional extension is the evaluation product `H * H⁻¹`, which lies in the
unit fractional ideal by definition of inverse. -/
def defectIdeal
(H : IntegralFractionalIdeal) :
Ideal IntegralRing :=
Classical.choose
(FractionalIdeal.le_one_iff_exists_coeIdeal.mp
(by
simpa only [FractionalIdeal.inv_eq] using
(FractionalIdeal.mul_one_div_le_one
(I := H))))
theorem coe_defectIdeal
(H : IntegralFractionalIdeal) :
(defectIdeal H : IntegralFractionalIdeal) =
H * H⁻¹ :=
Classical.choose_spec
(FractionalIdeal.le_one_iff_exists_coeIdeal.mp
(by
simpa only [FractionalIdeal.inv_eq] using
(FractionalIdeal.mul_one_div_le_one
(I := H))))
/-- Generic-fibre invertibility forces the defect ideal to be generically
the unit ideal. -/
theorem map_defectIdeal_eq_top
{H : IntegralFractionalIdeal}
(hH : H ≠ 0)
(hGeneric :
IsUnit (extendFractional H)) :
Ideal.map integralToRational (defectIdeal H) = ⊤ := by
rw [← Ideal.one_eq_top]
apply
(FractionalIdeal.coeIdeal_eq_one
(K := FunctionField)).mp
change
((Ideal.map integralToRational (defectIdeal H) :
Ideal RationalRing) : RationalFractionalIdeal) = 1
calc
((Ideal.map integralToRational (defectIdeal H) :
Ideal RationalRing) : RationalFractionalIdeal) =
extendFractional
(defectIdeal H : IntegralFractionalIdeal) := by
rw [extendFractional,
FractionalIdeal.extendedHom'_apply,
FractionalIdeal.extended_coeIdeal_eq_map]
_ = 1 := by
rw [coe_defectIdeal, map_mul,
extendFractional_inv hH]
exact
(FractionalIdeal.mul_inv_cancel_iff_isUnit
FunctionField).mpr hGeneric
/-- Equality of the defect ideal with the unit ideal is exactly the desired
invertibility conclusion. -/
theorem isUnit_of_defectIdeal_eq_top
{H : IntegralFractionalIdeal}
(hDefect : defectIdeal H = ⊤) :
IsUnit H := by
apply
(FractionalIdeal.mul_inv_cancel_iff_isUnit
FunctionField).mp
rw [← coe_defectIdeal H, hDefect]
show
((⊤ : Ideal IntegralRing) :
IntegralFractionalIdeal) = 1
exact FractionalIdeal.coeIdeal_top IntegralRing⁰
end
end MazurProof.N13IntegralFractionalHull
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13IntegralGraphContraction
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Exact contraction of integral N13 graph ideals
Coefficient extension and contraction already fix a smooth integral
generalized Mumford graph ideal. Completion of the square is a coordinate
ring equivalence, so it cancels formally from a further extension and
contraction. Hence the standard sextic graph contracts to the original
integral graph exactly.
This is a representative-level equality. It does not construct an
integral graph from a generic Picard class.
-/
open scoped nonZeroDivisors
namespace MazurProof.N13IntegralGraphContraction
noncomputable section
abbrev R₂ : Type :=
N13IntegralModelContraction.R₂
abbrev IntegralRing : Type :=
N13IntegralModelContraction.IntegralRing
abbrev RationalRing : Type :=
N13IntegralModelContraction.RationalRing
abbrev FunctionField : Type :=
N13IntegralFractionalHull.FunctionField
local instance integralRationalAlgebra :
Algebra IntegralRing RationalRing :=
N13TwoAdicCoordinateBaseChange.integralToSextic.toAlgebra
local instance integralRingDomain : IsDomain IntegralRing :=
N13IntegralFractionalHull.integralToRational_injective.isDomain
N13IntegralFractionalHull.integralToRational
local instance integralFunctionFieldFractionRing :
IsFractionRing IntegralRing FunctionField :=
N13IntegralFractionalHull.functionField_isFractionRing
abbrev SmoothMumford₂ : Type :=
N13GeneralizedMumfordReduction.SmoothMumford₂
abbrev SemiMumford₂ : Type :=
N13GeneralizedMumfordIntegral.TwoAdic.SemiMumford₂
/-- The integral graph ideal attached to generalized Mumford data. -/
def graphIdeal (D : SmoothMumford₂) : Ideal IntegralRing :=
N13GeneralizedMumfordIntegral.mumfordIdeal D.u D.v
/-- The integral graph ideal attached to arbitrary generalized Mumford
data. -/
def semiGraphIdeal (D : SemiMumford₂) : Ideal IntegralRing :=
N13GeneralizedMumfordIntegral.mumfordIdeal D.u D.v
/-- A bijective second coordinate change cancels from extension followed by
contraction. -/
private theorem comap_map_comp_of_bijective
{A B C : Type*}
[CommRing A] [CommRing B] [CommRing C]
(f : A →+* B) (g : B →+* C)
(hg : Function.Bijective g)
(I : Ideal A)
(hI : (I.map f).comap f = I) :
(I.map (g.comp f)).comap (g.comp f) = I := by
calc
(I.map (g.comp f)).comap (g.comp f) =
(((I.map f).map g).comap g).comap f := by
rw [Ideal.map_map, Ideal.comap_comap]
_ = (I.map f).comap f := by
rw [(I.map f).comap_map_of_bijective g hg]
_ = I := hI
/-- Extension followed by contraction fixes an integral graph ideal. -/
theorem contractIdeal_map_graphIdeal
(D : SmoothMumford₂) :
N13IntegralModelContraction.contractIdeal
(Ideal.map
N13TwoAdicCoordinateBaseChange.integralToSextic
(graphIdeal D)) =
graphIdeal D := by
change
(Ideal.map
(N13GoodSexticCoordinateEquiv.toSextic.comp
N13TwoAdicCoordinateBaseChange.extendCoordinate)
(graphIdeal D)).comap
(N13GoodSexticCoordinateEquiv.toSextic.comp
N13TwoAdicCoordinateBaseChange.extendCoordinate) =
graphIdeal D
exact comap_map_comp_of_bijective
N13TwoAdicCoordinateBaseChange.extendCoordinate
N13GoodSexticCoordinateEquiv.toSextic
(by
change Function.Bijective
(N13GoodSexticCoordinateEquiv.coordinateRingEquiv
(K := N13IntegralModelContraction.Q₂))
exact
(N13GoodSexticCoordinateEquiv.coordinateRingEquiv
(K := N13IntegralModelContraction.Q₂)).bijective)
(graphIdeal D)
(by
simpa [graphIdeal] using
N13TwoAdicCoordinateBaseChange.comap_map_mumfordIdeal D)
/-- Exact contraction already holds for an arbitrary integral semigraph.
Only monicity is used in the coefficient-descent argument. -/
theorem contractIdeal_map_semiGraphIdeal
(D : SemiMumford₂) :
N13IntegralModelContraction.contractIdeal
(Ideal.map
N13TwoAdicCoordinateBaseChange.integralToSextic
(semiGraphIdeal D)) =
semiGraphIdeal D := by
change
(Ideal.map
(N13GoodSexticCoordinateEquiv.toSextic.comp
N13TwoAdicCoordinateBaseChange.extendCoordinate)
(semiGraphIdeal D)).comap
(N13GoodSexticCoordinateEquiv.toSextic.comp
N13TwoAdicCoordinateBaseChange.extendCoordinate) =
semiGraphIdeal D
exact comap_map_comp_of_bijective
N13TwoAdicCoordinateBaseChange.extendCoordinate
N13GoodSexticCoordinateEquiv.toSextic
(by
change Function.Bijective
(N13GoodSexticCoordinateEquiv.coordinateRingEquiv
(K := N13IntegralModelContraction.Q₂))
exact
(N13GoodSexticCoordinateEquiv.coordinateRingEquiv
(K := N13IntegralModelContraction.Q₂)).bijective)
(semiGraphIdeal D)
(by
simpa [semiGraphIdeal] using
N13TwoAdicCoordinateBaseChange.comap_map_mumfordIdeal_semi D)
/-- The standard sextic graph ideal of smooth integral data. -/
def sexticIdeal
(D : SmoothMumford₂) (nInf : ℤ) :
Ideal RationalRing :=
SexticMumford.mumfordIdeal
(N13GoodSexticCoordinateEquiv.M
(K := N13IntegralModelContraction.Q₂))
(N13TwoAdicMumfordTransport.sexticSemi D nInf).u
(N13TwoAdicMumfordTransport.sexticSemi D nInf).v
/-- The standard sextic generic graph attached to arbitrary integral
generalized Mumford data. -/
def sexticSemiIdeal
(D : SemiMumford₂) (nInf : ℤ) :
Ideal RationalRing :=
SexticMumford.mumfordIdeal
(N13GoodSexticCoordinateEquiv.M
(K := N13IntegralModelContraction.Q₂))
(N13TwoAdicMumfordTransport.sexticSemiOfSemi D nInf).u
(N13TwoAdicMumfordTransport.sexticSemiOfSemi D nInf).v
/-- The canonical contraction of the actual sextic graph is the original
integral graph ideal, not merely an ideal in the same Picard class. -/
theorem contractIdeal_sexticIdeal
(D : SmoothMumford₂) (nInf : ℤ) :
N13IntegralModelContraction.contractIdeal
(sexticIdeal D nInf) =
graphIdeal D := by
unfold sexticIdeal
rw [←
N13TwoAdicCoordinateBaseChange.map_mumfordIdeal_sexticSemi
D nInf]
simpa [graphIdeal] using contractIdeal_map_graphIdeal D
/-- Canonical contraction of an arbitrary transported integral semigraph
recovers the original integral graph ideal exactly. -/
theorem contractIdeal_sexticSemiIdeal
(D : SemiMumford₂) (nInf : ℤ) :
N13IntegralModelContraction.contractIdeal
(sexticSemiIdeal D nInf) =
semiGraphIdeal D := by
unfold sexticSemiIdeal
rw [←
N13TwoAdicCoordinateBaseChange.map_mumfordIdeal_sexticSemiOfSemi
D nInf]
simpa [semiGraphIdeal] using
contractIdeal_map_semiGraphIdeal D
/-- Fractional-ideal form of exact contraction. -/
theorem contractedFractional_sexticIdeal
(D : SmoothMumford₂) (nInf : ℤ) :
N13IntegralFractionalHull.contractedFractional
(sexticIdeal D nInf) =
(graphIdeal D :
FractionalIdeal IntegralRing⁰ FunctionField) := by
exact congrArg
(fun I : Ideal IntegralRing ↦
(I : FractionalIdeal IntegralRing⁰ FunctionField))
(contractIdeal_sexticIdeal D nInf)
/-- Fractional-ideal form of exact semigraph contraction. -/
theorem contractedFractional_sexticSemiIdeal
(D : SemiMumford₂) (nInf : ℤ) :
N13IntegralFractionalHull.contractedFractional
(sexticSemiIdeal D nInf) =
(semiGraphIdeal D :
FractionalIdeal IntegralRing⁰ FunctionField) := by
exact congrArg
(fun I : Ideal IntegralRing ↦
(I : FractionalIdeal IntegralRing⁰ FunctionField))
(contractIdeal_sexticSemiIdeal D nInf)
end
end MazurProof.N13IntegralGraphContraction
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13SpecialGraphDivisor
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Degree-two Mumford graphs as effective divisors on the N13 special fibre
A monic quadratic generalized Mumford graph on the good characteristic-two
model splits over `F₂`. Indeed, an irreducible quadratic would produce an
affine point over its quadratic root field, while the structural Frobenius
classification forces that root back into `F₂`.
The two roots, with their graph values, therefore define an effective
degree-two divisor. If that divisor is the selected nonspecial base divisor,
its two distinct points force `u = X² + X` and `u ∣ v`; hence its graph ideal
is literally the fixed special ideal. No finite table or representative
enumeration is used.
-/
open Polynomial
open scoped Sym2
namespace MazurProof.N13SpecialGraphDivisor
noncomputable section
open MazurProof.N13GoodCoordinateRingTwo
local instance instFactPrimeOfNatNat_fLT : Fact (Nat.Prime 2) := ⟨Nat.prime_two⟩
theorem degreeTwo_splits
(D : SemiMumford) (hdeg : D.u.natDegree = 2) :
D.u.Splits := by
by_contra hnot
have hnoRoot (a : K) : D.u.eval a ≠ 0 := by
intro ha
exact hnot (Polynomial.Splits.of_natDegree_eq_two hdeg ha)
have hroots : D.u.roots = 0 := by
apply Multiset.eq_zero_of_forall_notMem
intro a ha
exact hnoRoot a ((Polynomial.mem_roots D.u_monic.ne_zero).mp ha)
have hirr : Irreducible D.u := by
apply (D.u_monic.irreducible_iff_roots_eq_zero_of_degree_le_three
(by omega) (by omega)).mpr
exact hroots
letI : Fact (Irreducible D.u) := ⟨hirr⟩
letI : Module.Finite K (AdjoinRoot D.u) :=
(AdjoinRoot.powerBasis hirr.ne_zero).finite
letI : Finite (AdjoinRoot D.u) :=
Module.finite_of_finite K
letI : Fintype (AdjoinRoot D.u) :=
Fintype.ofFinite (AdjoinRoot D.u)
letI : CharP (AdjoinRoot D.u) 2 :=
charP_of_injective_algebraMap
(algebraMap K (AdjoinRoot D.u)).injective 2
have hcard : Fintype.card (AdjoinRoot D.u) = 4 := by
rw [Module.card_eq_pow_finrank (K := K) (V := AdjoinRoot D.u),
(AdjoinRoot.powerBasis hirr.ne_zero).finrank,
ZMod.card, AdjoinRoot.powerBasis_dim, hdeg]
norm_num
let alpha : AdjoinRoot D.u := AdjoinRoot.root D.u
let beta : AdjoinRoot D.u := Polynomial.aeval alpha D.v
have hfour (z : AdjoinRoot D.u) : z ^ 4 = z := by
rw [← hcard]
exact FiniteField.pow_card z
have hroot : Polynomial.aeval alpha D.u = 0 := by
simp [alpha, Polynomial.aeval_def, AdjoinRoot.eval₂_root]
have hcurve :
N13GoodModelTwo.AffineEquation alpha beta := by
have hc := congrArg (Polynomial.aeval alpha) D.curve_eq
simp only [map_sub, map_add, map_pow, map_mul] at hc
rw [hroot, zero_mul] at hc
change
beta ^ 2 + N13GoodModelTwo.h alpha * beta =
N13GoodModelTwo.rhs alpha
simpa [beta, N13GoodModelTwo.h, N13GoodModelTwo.rhs,
hPoly, rhsPoly, Polynomial.aeval_def] using sub_eq_zero.mp hc
have halpha : alpha ^ 2 = alpha :=
((N13GoodModelTwo.affineEquation_iff_fixed hfour alpha beta).mp hcurve).1
rcases N13GoodModelTwo.fixedTwo_eq_zero_or_one alpha halpha with ha | ha
· have hz : D.u.eval 0 = 0 := by
apply (algebraMap K (AdjoinRoot D.u)).injective
have hzmap :
algebraMap K (AdjoinRoot D.u) (D.u.eval 0) = 0 := by
calc
algebraMap K (AdjoinRoot D.u) (D.u.eval 0) =
eval₂ (algebraMap K (AdjoinRoot D.u))
(algebraMap K (AdjoinRoot D.u) 0) D.u := by
rw [Polynomial.eval₂_at_apply]
_ = eval₂ (algebraMap K (AdjoinRoot D.u)) alpha D.u := by
rw [ha]
simp
_ = 0 := AdjoinRoot.eval₂_root D.u
simpa using hzmap
exact hnoRoot 0 hz
· have ho : D.u.eval 1 = 0 := by
apply (algebraMap K (AdjoinRoot D.u)).injective
have homap :
algebraMap K (AdjoinRoot D.u) (D.u.eval 1) = 0 := by
calc
algebraMap K (AdjoinRoot D.u) (D.u.eval 1) =
eval₂ (algebraMap K (AdjoinRoot D.u))
(algebraMap K (AdjoinRoot D.u) 1) D.u := by
rw [Polynomial.eval₂_at_apply]
_ = eval₂ (algebraMap K (AdjoinRoot D.u)) alpha D.u := by
rw [ha]
simp
_ = 0 := AdjoinRoot.eval₂_root D.u
simpa using homap
exact hnoRoot 1 ho
theorem exists_rootPair
(D : SemiMumford) (hdeg : D.u.natDegree = 2) :
∃ z : Sym2 K, z.toMultiset = D.u.roots := by
have hcard : D.u.roots.card = 2 := by
rw [← (degreeTwo_splits D hdeg).natDegree_eq_card_roots]
exact hdeg
obtain ⟨a, b, hab⟩ := Multiset.card_eq_two.mp hcard
refine ⟨s(a, b), ?_⟩
change ({a, b} : Multiset K) = D.u.roots
exact hab.symm
noncomputable def rootPair
(D : SemiMumford) (hdeg : D.u.natDegree = 2) :
Sym2 K :=
Classical.choose (exists_rootPair D hdeg)
theorem rootPair_toMultiset
(D : SemiMumford) (hdeg : D.u.natDegree = 2) :
(rootPair D hdeg).toMultiset = D.u.roots := by
exact Classical.choose_spec (exists_rootPair D hdeg)
theorem mem_rootPair_iff_isRoot
(D : SemiMumford) (hdeg : D.u.natDegree = 2) (a : K) :
a ∈ rootPair D hdeg ↔ D.u.IsRoot a := by
rw [← Sym2.mem_toMultiset, rootPair_toMultiset,
Polynomial.mem_roots D.u_monic.ne_zero]
theorem curveEquationAtRoot
(D : SemiMumford) {a : K} (ha : D.u.IsRoot a) :
N13GoodModelTwo.AffineEquation a (D.v.eval a) := by
have hc := congrArg (Polynomial.eval a) D.curve_eq
simp only [eval_sub, eval_add, eval_pow, eval_mul] at hc
rw [ha, zero_mul] at hc
change
D.v.eval a ^ 2 +
N13GoodModelTwo.h a * D.v.eval a =
N13GoodModelTwo.rhs a
simpa [N13GoodModelTwo.h, N13GoodModelTwo.rhs,
hPoly, rhsPoly] using sub_eq_zero.mp hc
noncomputable def rootPoint
(D : SemiMumford) (hdeg : D.u.natDegree = 2)
(a : K) (ha : a ∈ rootPair D hdeg) :
N13AbelFiberTwoModel.CurvePoint :=
Sum.inl
⟨(a, D.v.eval a),
curveEquationAtRoot D ((mem_rootPair_iff_isRoot D hdeg a).mp ha)⟩
noncomputable def graphDivisor
(D : SemiMumford) (hdeg : D.u.natDegree = 2) :
N13SymmetricSquareTwo.EffectiveDivisorTwo :=
Sym2.pmap (rootPoint D hdeg) (rootPair D hdeg)
(fun _ ha => ha)
/-- Abel equality with the selected nonspecial divisor already forces
literal equality of effective divisors. The only other degree-two Abel
fibre is the canonical pencil, and the selected base divisor is not in it. -/
theorem graphDivisor_eq_special_of_abel_eq
{J : Type*}
(G : N13AbelFiberTwoModel.GeometricAbelCriterion J)
(D : SemiMumford) (hdeg : D.u.natDegree = 2)
(habel :
G.abel (graphDivisor D hdeg) =
G.abel N13AbelChartBase.specialBaseDivisor) :
graphDivisor D hdeg =
N13AbelChartBase.specialBaseDivisor := by
rcases
(G.eq_iff
(graphDivisor D hdeg)
N13AbelChartBase.specialBaseDivisor).mp habel with
h | ⟨_, hbase⟩
· exact h
· exact
(N13AbelChartBase.specialBaseDivisor_not_canonical hbase).elim
/-- The same rigidity statement in the canonical nineteen-element
set-valued Abel quotient. -/
theorem graphDivisor_eq_special_of_setAbel_eq
(D : SemiMumford) (hdeg : D.u.natDegree = 2)
(habel :
N13AbelFiberTwoModel.abel (graphDivisor D hdeg) =
N13AbelFiberTwoModel.abel
N13AbelChartBase.specialBaseDivisor) :
graphDivisor D hdeg =
N13AbelChartBase.specialBaseDivisor :=
graphDivisor_eq_special_of_abel_eq
N13AbelFiberTwoModel.picTwoSetModelCriterion D hdeg habel
theorem zero_one_roots_and_values_of_graphDivisor_eq
(D : SemiMumford) (hdeg : D.u.natDegree = 2)
(hgraph :
graphDivisor D hdeg =
N13AbelChartBase.specialBaseDivisor) :
D.u.IsRoot 0 ∧ D.u.IsRoot 1 ∧
D.v.eval 0 = 0 ∧ D.v.eval 1 = 0 := by
have hp00 :
N13AbelChartBase.p00 ∈ graphDivisor D hdeg := by
rw [hgraph]
exact Sym2.mem_mk_left _ _
have hp10 :
N13AbelChartBase.p10 ∈ graphDivisor D hdeg := by
rw [hgraph]
exact Sym2.mem_mk_right _ _
rw [graphDivisor, Sym2.mem_pmap_iff] at hp00 hp10
obtain ⟨a, ha, hpa⟩ := hp00
obtain ⟨b, hb, hpb⟩ := hp10
have hca := congrArg N13AbelFiberTwoModel.curvePointEquiv hpa
have hcb := congrArg N13AbelFiberTwoModel.curvePointEquiv hpb
have ha0 : a = 0 := by
symm
simpa [N13AbelChartBase.p00, rootPoint,
N13AbelFiberTwoModel.curvePointEquiv] using congrArg Prod.fst hca
have hva0 : D.v.eval a = 0 := by
symm
simpa [N13AbelChartBase.p00, rootPoint,
N13AbelFiberTwoModel.curvePointEquiv] using congrArg Prod.snd hca
have hb1 : b = 1 := by
symm
simpa [N13AbelChartBase.p10, rootPoint,
N13AbelFiberTwoModel.curvePointEquiv] using congrArg Prod.fst hcb
have hvb0 : D.v.eval b = 0 := by
symm
simpa [N13AbelChartBase.p10, rootPoint,
N13AbelFiberTwoModel.curvePointEquiv] using congrArg Prod.snd hcb
subst a
subst b
exact
⟨(mem_rootPair_iff_isRoot D hdeg 0).mp ha,
(mem_rootPair_iff_isRoot D hdeg 1).mp hb,
hva0, hvb0⟩
theorem u_eq_base_and_dvd_v_of_graphDivisor_eq
(D : SemiMumford) (hdeg : D.u.natDegree = 2)
(hgraph :
graphDivisor D hdeg =
N13AbelChartBase.specialBaseDivisor) :
D.u = (X ^ 2 + X : K[X]) ∧ D.u ∣ D.v := by
obtain ⟨hu0, hu1, hv0, hv1⟩ :=
zero_one_roots_and_values_of_graphDivisor_eq D hdeg hgraph
have htwo : (2 : K) = 0 :=
CharP.cast_eq_zero K 2
have hunit : IsUnit ((0 : K) - 1) := by
have hnegOne : (-1 : K) = 1 := by
change (-1 : ZMod 2) = 1
decide
rw [zero_sub, hnegOne]
exact isUnit_one
have hcop :
IsCoprime (X - C (0 : K)) (X - C (1 : K)) :=
isCoprime_X_sub_C_of_isUnit_sub hunit
have hfactor :
(X - C (0 : K)) * (X - C (1 : K)) =
(X ^ 2 + X : K[X]) := by
simp only [map_zero, sub_zero, map_one]
have htwoPoly : (2 : K[X]) = 0 :=
CharP.cast_eq_zero (K[X]) 2
have hsum : (X : K[X]) + X = 0 := by
calc
(X : K[X]) + X = 2 * X := by ring
_ = 0 := by rw [htwoPoly, zero_mul]
have hnegX : -(X : K[X]) = X := by
calc
-(X : K[X]) = -X + (X + X) := by rw [hsum, add_zero]
_ = X := by ring
calc
(X : K[X]) * (X - 1) = X ^ 2 - X := by ring
_ = X ^ 2 + X := by simp [sub_eq_add_neg, hnegX]
have hprod_u :
(X - C (0 : K)) * (X - C (1 : K)) ∣ D.u :=
hcop.mul_dvd
(Polynomial.dvd_iff_isRoot.mpr hu0)
(Polynomial.dvd_iff_isRoot.mpr hu1)
have hu :
(X - C (0 : K)) * (X - C (1 : K)) = D.u := by
have hpdeg :
((X - C (0 : K)) * (X - C (1 : K))).natDegree = 2 := by
rw [natDegree_mul
(monic_X_sub_C (0 : K)).ne_zero
(monic_X_sub_C (1 : K)).ne_zero]
rw [natDegree_X_sub_C, natDegree_X_sub_C]
apply Polynomial.eq_of_dvd_of_natDegree_le_of_leadingCoeff hprod_u
· rw [hdeg, hpdeg]
· rw [((monic_X_sub_C (0 : K)).mul
(monic_X_sub_C (1 : K))).leadingCoeff,
D.u_monic.leadingCoeff]
have hprod_v :
(X - C (0 : K)) * (X - C (1 : K)) ∣ D.v :=
hcop.mul_dvd
(Polynomial.dvd_iff_isRoot.mpr hv0)
(Polynomial.dvd_iff_isRoot.mpr hv1)
constructor
· rw [← hu]
exact hfactor
· rw [← hu]
exact hprod_v
/-- Literal equality with the selected special graph ideal already recovers
the monic quadratic and the graph value modulo it. This is the converse
representative statement to `mumfordIdeal_eq_special_of_graphDivisor_eq`. -/
theorem u_eq_base_and_dvd_v_of_mumfordIdeal_eq
(D : SemiMumford) (hdeg : D.u.natDegree = 2)
(hideal :
mumfordIdeal D.u D.v =
N13SpecialQuotientBasis.specialIdeal) :
D.u = (X ^ 2 + X : K[X]) ∧ D.u ∣ D.v := by
have hxmem :
xClass N13SpecialQuotientBasis.specialData.u ∈
mumfordIdeal D.u D.v := by
rw [hideal]
exact
xClass_mem_mumfordIdeal
N13SpecialQuotientBasis.specialData.u
N13SpecialQuotientBasis.specialData.v
have hxker :
xClass N13SpecialQuotientBasis.specialData.u ∈
RingHom.ker (mumfordEval D) := by
rw [ker_mumfordEval D]
exact hxmem
have hxzero :=
RingHom.mem_ker.mp hxker
rw [mumfordEval_xClass,
Ideal.Quotient.eq_zero_iff_mem,
Ideal.mem_span_singleton] at hxzero
have hueq :
D.u = (X ^ 2 + X : K[X]) := by
have hspecial :
N13SpecialQuotientBasis.specialData.u = D.u :=
Polynomial.eq_of_monic_of_dvd_of_natDegree_le
D.u_monic
N13SpecialQuotientBasis.specialData.u_monic
hxzero
(by
rw [hdeg,
N13SpecialQuotientBasis.specialData_u_natDegree])
simpa only [N13SpecialQuotientBasis.specialData_u] using hspecial.symm
have hymem :
yClass ∈ mumfordIdeal D.u D.v := by
rw [hideal]
change
yClass ∈
mumfordIdeal
N13SpecialQuotientBasis.specialData.u
N13SpecialQuotientBasis.specialData.v
simpa only [N13SpecialQuotientBasis.specialData_v,
ySubClass, xClass_zero, sub_zero] using
ySubClass_mem_mumfordIdeal
N13SpecialQuotientBasis.specialData.u
N13SpecialQuotientBasis.specialData.v
have hyker :
yClass ∈ RingHom.ker (mumfordEval D) := by
rw [ker_mumfordEval D]
exact hymem
have hyzero :=
RingHom.mem_ker.mp hyker
rw [mumfordEval_yClass,
Ideal.Quotient.eq_zero_iff_mem,
Ideal.mem_span_singleton] at hyzero
exact ⟨hueq, hyzero⟩
/-- The literal special graph ideal determines the selected effective
divisor. The proof recovers the two roots and evaluates the graph there;
it does not enumerate the special curve. -/
theorem graphDivisor_eq_special_of_mumfordIdeal_eq
(D : SemiMumford) (hdeg : D.u.natDegree = 2)
(hideal :
mumfordIdeal D.u D.v =
N13SpecialQuotientBasis.specialIdeal) :
graphDivisor D hdeg =
N13AbelChartBase.specialBaseDivisor := by
obtain ⟨hu, hv⟩ :=
u_eq_base_and_dvd_v_of_mumfordIdeal_eq D hdeg hideal
have hr0 : D.u.IsRoot 0 := by
simp [hu]
have hr1 : D.u.IsRoot 1 := by
change D.u.eval 1 = 0
rw [hu]
norm_num
exact CharP.cast_eq_zero K 2
have hmem0 :
(0 : K) ∈ rootPair D hdeg :=
(mem_rootPair_iff_isRoot D hdeg 0).2 hr0
have hmem1 :
(1 : K) ∈ rootPair D hdeg :=
(mem_rootPair_iff_isRoot D hdeg 1).2 hr1
obtain ⟨q, hq⟩ := hv
have hv0 : D.v.eval 0 = 0 := by
rw [hq, eval_mul, hr0, zero_mul]
have hv1 : D.v.eval 1 = 0 := by
rw [hq, eval_mul, hr1, zero_mul]
have hp00 :
N13AbelChartBase.p00 ∈ graphDivisor D hdeg := by
rw [graphDivisor, Sym2.mem_pmap_iff]
refine ⟨0, hmem0, ?_⟩
simp [rootPoint, N13AbelChartBase.p00,
N13AbelFiberTwoModel.curvePointEquiv, hv0]
have hp10 :
N13AbelChartBase.p10 ∈ graphDivisor D hdeg := by
rw [graphDivisor, Sym2.mem_pmap_iff]
refine ⟨1, hmem1, ?_⟩
simp [rootPoint, N13AbelChartBase.p10,
N13AbelFiberTwoModel.curvePointEquiv, hv1]
have hpne :
N13AbelChartBase.p00 ≠ N13AbelChartBase.p10 := by
intro h
have h' :=
congrArg N13AbelFiberTwoModel.curvePointEquiv h
simp [N13AbelChartBase.p00,
N13AbelChartBase.p10] at h'
simpa [N13AbelChartBase.specialBaseDivisor] using
(Sym2.mem_and_mem_iff hpne).mp ⟨hp00, hp10⟩
theorem mumfordIdeal_eq_zero_of_dvd
(u v : K[X]) (h : u ∣ v) :
mumfordIdeal u v = mumfordIdeal u 0 := by
obtain ⟨q, hq⟩ := h
have hmultiple :
xClass v ∈ mumfordIdeal u 0 := by
rw [hq, xClass_mul, mul_comm]
exact Ideal.mul_mem_left _ (xClass q)
(xClass_mem_mumfordIdeal u 0)
have hmultiple' :
xClass v ∈ mumfordIdeal u v := by
have hx : xClass v = xClass u * xClass q := by
rw [hq, xClass_mul]
rw [hx]
simpa only [mul_comm] using
Ideal.mul_mem_left _ (xClass q)
(xClass_mem_mumfordIdeal u v)
apply le_antisymm
· apply Ideal.span_le.2
intro z hz
simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
rcases hz with rfl | rfl
· exact xClass_mem_mumfordIdeal u 0
· have heq : ySubClass v = ySubClass 0 - xClass v := by
simp [ySubClass]
rw [heq]
exact Ideal.sub_mem _
(ySubClass_mem_mumfordIdeal u 0) hmultiple
· apply Ideal.span_le.2
intro z hz
simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
rcases hz with rfl | rfl
· exact xClass_mem_mumfordIdeal u v
· have heq : ySubClass 0 = ySubClass v + xClass v := by
simp [ySubClass]
rw [heq]
exact Ideal.add_mem _
(ySubClass_mem_mumfordIdeal u v) hmultiple'
theorem mumfordIdeal_eq_special_of_graphDivisor_eq
(D : SemiMumford) (hdeg : D.u.natDegree = 2)
(hgraph :
graphDivisor D hdeg =
N13AbelChartBase.specialBaseDivisor) :
mumfordIdeal D.u D.v =
N13SpecialQuotientBasis.specialIdeal := by
obtain ⟨hu, hv⟩ :=
u_eq_base_and_dvd_v_of_graphDivisor_eq D hdeg hgraph
calc
mumfordIdeal D.u D.v = mumfordIdeal D.u 0 :=
mumfordIdeal_eq_zero_of_dvd D.u D.v hv
_ = N13SpecialQuotientBasis.specialIdeal := by
simp [N13SpecialQuotientBasis.specialIdeal,
N13SpecialQuotientBasis.specialData_u,
N13SpecialQuotientBasis.specialData_v, hu]
/-- The complete special-fibre bridge: an Abel-compatible quadratic
Mumford graph has the fixed literal graph ideal. -/
theorem mumfordIdeal_eq_special_of_abel_eq
{J : Type*}
(G : N13AbelFiberTwoModel.GeometricAbelCriterion J)
(D : SemiMumford) (hdeg : D.u.natDegree = 2)
(habel :
G.abel (graphDivisor D hdeg) =
G.abel N13AbelChartBase.specialBaseDivisor) :
mumfordIdeal D.u D.v =
N13SpecialQuotientBasis.specialIdeal :=
mumfordIdeal_eq_special_of_graphDivisor_eq D hdeg
(graphDivisor_eq_special_of_abel_eq G D hdeg habel)
/-- Set-valued Abel compatibility is already enough to identify the fixed
special graph ideal. -/
theorem mumfordIdeal_eq_special_of_setAbel_eq
(D : SemiMumford) (hdeg : D.u.natDegree = 2)
(habel :
N13AbelFiberTwoModel.abel (graphDivisor D hdeg) =
N13AbelFiberTwoModel.abel
N13AbelChartBase.specialBaseDivisor) :
mumfordIdeal D.u D.v =
N13SpecialQuotientBasis.specialIdeal :=
mumfordIdeal_eq_special_of_abel_eq
N13AbelFiberTwoModel.picTwoSetModelCriterion D hdeg habel
/-- For quadratic special graphs, the intrinsic Abel class and the literal
graph ideal carry exactly the same information at the selected regular
class. -/
theorem setAbel_eq_iff_mumfordIdeal_eq_special
(D : SemiMumford) (hdeg : D.u.natDegree = 2) :
N13AbelFiberTwoModel.abel (graphDivisor D hdeg) =
N13AbelFiberTwoModel.abel
N13AbelChartBase.specialBaseDivisor ↔
mumfordIdeal D.u D.v =
N13SpecialQuotientBasis.specialIdeal := by
constructor
· exact mumfordIdeal_eq_special_of_setAbel_eq D hdeg
· intro hideal
exact congrArg N13AbelFiberTwoModel.abel
(graphDivisor_eq_special_of_mumfordIdeal_eq
D hdeg hideal)
end
end MazurProof.N13SpecialGraphDivisor
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13SpecialGraphReduction
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Abel-compatible reduction of integral N13 Mumford graphs
Coefficientwise reduction of a smooth integral generalized Mumford graph is
again a special-fibre Mumford graph. If its effective degree-two divisor
has the selected set-valued Abel class, special Abel rigidity identifies the
literal reduced graph ideal with `(X²+X,Y)`.
Combining this with exact contraction of integral sextic graphs gives the
representative-level special-ideal equality required by the two-fibre graph
recovery theorem. The remaining geometric input is now only the existence
of an integral representative and its Abel compatibility.
-/
open Polynomial
namespace MazurProof.N13SpecialGraphReduction
noncomputable section
local instance instFactPrimeOfNatNat_fLT : Fact (Nat.Prime 2) :=
⟨Nat.prime_two⟩
abbrev SmoothMumford₂ : Type :=
N13GeneralizedMumfordReduction.SmoothMumford₂
/-- Monic degree is preserved by coefficientwise reduction. -/
theorem reduceSmoothMumford_u_natDegree
(D : SmoothMumford₂)
(hdeg : D.u.natDegree = 2) :
(N13GeneralizedMumfordReduction.reduceSmoothMumford D).u.natDegree =
2 := by
change
(D.u.map
N13GeneralizedMumfordReduction.reduceBase).natDegree = 2
calc
(D.u.map
N13GeneralizedMumfordReduction.reduceBase).natDegree =
D.u.natDegree :=
D.u_monic.natDegree_map
N13GeneralizedMumfordReduction.reduceBase
_ = 2 := hdeg
/-- An integral graph whose reduced divisor has the selected Abel class
maps to the fixed special graph ideal. -/
theorem map_mumfordIdeal_eq_special_of_setAbel_eq
(D : SmoothMumford₂)
(hdeg : D.u.natDegree = 2)
(habel :
N13AbelFiberTwoModel.abel
(N13SpecialGraphDivisor.graphDivisor
(N13GeneralizedMumfordReduction.reduceSmoothMumford D)
(reduceSmoothMumford_u_natDegree D hdeg)) =
N13AbelFiberTwoModel.abel
N13AbelChartBase.specialBaseDivisor) :
Ideal.map N13GeneralizedMumfordReduction.reduceCoordinate
(N13GeneralizedMumfordIntegral.mumfordIdeal
(R := N13GeneralizedMumfordReduction.R₂) D.u D.v) =
N13SpecialQuotientBasis.specialIdeal := by
rw [N13GeneralizedMumfordReduction.map_smoothMumfordIdeal]
exact
N13SpecialGraphDivisor.mumfordIdeal_eq_special_of_setAbel_eq
(N13GeneralizedMumfordReduction.reduceSmoothMumford D)
(reduceSmoothMumford_u_natDegree D hdeg) habel
/-- For an integral quadratic graph, mapped-ideal equality is equivalent to
the intrinsic special-fibre Abel equality. -/
theorem setAbel_eq_iff_map_mumfordIdeal_eq_special
(D : SmoothMumford₂)
(hdeg : D.u.natDegree = 2) :
N13AbelFiberTwoModel.abel
(N13SpecialGraphDivisor.graphDivisor
(N13GeneralizedMumfordReduction.reduceSmoothMumford D)
(reduceSmoothMumford_u_natDegree D hdeg)) =
N13AbelFiberTwoModel.abel
N13AbelChartBase.specialBaseDivisor ↔
Ideal.map N13GeneralizedMumfordReduction.reduceCoordinate
(N13GeneralizedMumfordIntegral.mumfordIdeal
(R := N13GeneralizedMumfordReduction.R₂) D.u D.v) =
N13SpecialQuotientBasis.specialIdeal := by
rw [N13GeneralizedMumfordReduction.map_smoothMumfordIdeal]
exact
N13SpecialGraphDivisor.setAbel_eq_iff_mumfordIdeal_eq_special
(N13GeneralizedMumfordReduction.reduceSmoothMumford D)
(reduceSmoothMumford_u_natDegree D hdeg)
/-- Exact contraction turns the preceding Abel statement into precisely the
special-ideal equality consumed by the concrete two-fibre recovery layer. -/
theorem map_contractIdeal_sexticIdeal_eq_special_of_setAbel_eq
(D : SmoothMumford₂)
(nInf : ℤ)
(hdeg : D.u.natDegree = 2)
(habel :
N13AbelFiberTwoModel.abel
(N13SpecialGraphDivisor.graphDivisor
(N13GeneralizedMumfordReduction.reduceSmoothMumford D)
(reduceSmoothMumford_u_natDegree D hdeg)) =
N13AbelFiberTwoModel.abel
N13AbelChartBase.specialBaseDivisor) :
Ideal.map N13GeneralizedMumfordReduction.reduceCoordinate
(N13IntegralModelContraction.contractIdeal
(N13IntegralGraphContraction.sexticIdeal D nInf)) =
N13SpecialQuotientBasis.specialIdeal := by
rw [N13IntegralGraphContraction.contractIdeal_sexticIdeal]
exact map_mumfordIdeal_eq_special_of_setAbel_eq D hdeg habel
end
end MazurProof.N13SpecialGraphReduction
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13TwoAdicDisks
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# The two integral residue disks used by the N13 Abel chart
For the good equation
`y² + (x³ + x + 1)y = x⁵ + x⁴`
over the two-adic integers, the fibres above the residue disks of `0` and
`-1` have a unique point whose `y`-coordinate lies in the maximal ideal.
Existence is one-variable Hensel lifting in the `y` coordinate. Uniqueness
is the elementary factorization of the difference of two roots.
This is the local-curve part of the nonspecial Abel chart; it uses neither a
Picard scheme nor finite congruence tables.
-/
open Polynomial
namespace MazurProof.N13TwoAdicDisks
noncomputable section
local instance instFactPrimeOfNatNat_fLT : Fact (Nat.Prime 2) :=
⟨Nat.prime_two⟩
abbrev R₂ : Type :=
ℤ_[2]
/-- The maximal ideal `(2)` of the two-adic integers. -/
abbrev maximal : Ideal R₂ :=
IsLocalRing.maximalIdeal R₂
/-- A useful local-ring form of the fact that being congruent to a unit
modulo the maximal ideal implies being a unit. -/
theorem isUnit_of_sub_mem_maximal
{a u : R₂} (hu : IsUnit u)
(hau : a - u ∈ maximal) :
IsUnit a := by
by_contra ha
have ha_mem : a ∈ maximal := by
simpa only [maximal, IsLocalRing.mem_maximalIdeal,
mem_nonunits_iff] using ha
have hu_mem : u ∈ maximal := by
have hsub := maximal.sub_mem ha_mem hau
convert hsub using 1
ring
have hnot : ¬IsUnit u := by
simpa only [maximal, IsLocalRing.mem_maximalIdeal,
mem_nonunits_iff] using hu_mem
exact hnot hu
/-- The good equation, viewed as a monic polynomial in `Y`. -/
abbrev yFiber (x : R₂) : R₂[X] :=
N13GoodModelTwo.affineFiber x
theorem yFiber_monic (x : R₂) :
(yFiber x).Monic := by
unfold yFiber N13GoodModelTwo.affineFiber
monicity <;> norm_num
@[simp] theorem yFiber_eval (x y : R₂) :
(yFiber x).eval y =
N13GoodModelTwo.affineResidual x y :=
N13GoodModelTwo.affineFiber_eval x y
@[simp] theorem yFiber_derivative_eval_zero (x : R₂) :
(yFiber x).derivative.eval 0 =
N13GoodModelTwo.h x := by
rw [N13GoodModelTwo.affineFiber_derivative_eval]
simp [N13GoodModelTwo.affineDerivativeY]
/-- Hensel lifting in the `Y` coordinate under the exact two hypotheses
needed at a residue disk. -/
theorem exists_y_mem_maximal
(x : R₂)
(hh : IsUnit (N13GoodModelTwo.h x))
(hrhs : N13GoodModelTwo.rhs x ∈ maximal) :
∃ y : R₂,
N13GoodModelTwo.AffineEquation x y ∧
y ∈ maximal := by
have heval :
(yFiber x).eval 0 ∈ maximal := by
have hneg := maximal.neg_mem hrhs
simpa [yFiber_eval, N13GoodModelTwo.affineResidual] using hneg
have hderiv :
IsUnit
(Ideal.Quotient.mk maximal
((yFiber x).derivative.eval 0)) := by
rw [yFiber_derivative_eval_zero]
exact hh.map (Ideal.Quotient.mk maximal)
obtain ⟨y, hy, hymem⟩ :=
HenselianRing.is_henselian
(R := R₂) (I := maximal)
(yFiber x) (yFiber_monic x) 0 heval hderiv
refine ⟨y, ?_, by simpa using hymem⟩
rw [N13GoodModelTwo.affineEquation_iff_residual,
← yFiber_eval]
exact hy
/-- Two roots in the same selected `Y` residue disk coincide. -/
theorem y_eq_of_mem_maximal
(x y z : R₂)
(hh : IsUnit (N13GoodModelTwo.h x))
(hy : N13GoodModelTwo.AffineEquation x y)
(hz : N13GoodModelTwo.AffineEquation x z)
(hymem : y ∈ maximal)
(hzmem : z ∈ maximal) :
y = z := by
have hyzero :
y ^ 2 + N13GoodModelTwo.h x * y -
N13GoodModelTwo.rhs x = 0 :=
sub_eq_zero.mpr hy
have hzzero :
z ^ 2 + N13GoodModelTwo.h x * z -
N13GoodModelTwo.rhs x = 0 :=
sub_eq_zero.mpr hz
have hsum_mem : y + z ∈ maximal :=
maximal.add_mem hymem hzmem
have hunit :
IsUnit (y + z + N13GoodModelTwo.h x) := by
apply isUnit_of_sub_mem_maximal hh
convert hsum_mem using 1
ring
have hprod :
(y - z) *
(y + z + N13GoodModelTwo.h x) = 0 := by
calc
(y - z) *
(y + z + N13GoodModelTwo.h x) =
(y ^ 2 + N13GoodModelTwo.h x * y -
N13GoodModelTwo.rhs x) -
(z ^ 2 + N13GoodModelTwo.h x * z -
N13GoodModelTwo.rhs x) := by ring
_ = 0 := by rw [hyzero, hzzero, sub_self]
exact sub_eq_zero.mp
((mul_eq_zero.mp hprod).resolve_right hunit.ne_zero)
/-- The selected `Y` lift is unique whenever the fibre has unit derivative
and its constant term lies in the maximal ideal. -/
theorem existsUnique_y_mem_maximal
(x : R₂)
(hh : IsUnit (N13GoodModelTwo.h x))
(hrhs : N13GoodModelTwo.rhs x ∈ maximal) :
∃! y : R₂,
N13GoodModelTwo.AffineEquation x y ∧
y ∈ maximal := by
obtain ⟨y, hy, hymem⟩ :=
exists_y_mem_maximal x hh hrhs
refine ⟨y, ⟨hy, hymem⟩, ?_⟩
intro z hz
exact y_eq_of_mem_maximal x z y hh hz.1 hy hz.2 hymem
/-! ## The disk above `(0,0)` -/
theorem h_isUnit_of_mem_zeroDisk
{x : R₂} (hx : x ∈ maximal) :
IsUnit (N13GoodModelTwo.h x) := by
apply isUnit_of_sub_mem_maximal isUnit_one
have hm :=
maximal.mul_mem_left (x ^ 2 + 1) hx
convert hm using 1
simp only [N13GoodModelTwo.h]
ring
theorem rhs_mem_of_mem_zeroDisk
{x : R₂} (hx : x ∈ maximal) :
N13GoodModelTwo.rhs x ∈ maximal := by
have hm :=
maximal.mul_mem_left (x ^ 3 * (x + 1)) hx
convert hm using 1
simp only [N13GoodModelTwo.rhs]
ring
theorem existsUnique_zeroDisk_y
(x : R₂) (hx : x ∈ maximal) :
∃! y : R₂,
N13GoodModelTwo.AffineEquation x y ∧
y ∈ maximal :=
existsUnique_y_mem_maximal x
(h_isUnit_of_mem_zeroDisk hx)
(rhs_mem_of_mem_zeroDisk hx)
/-- The unique `Y` coordinate above an `X` in the residue disk of zero. -/
def zeroDiskY (x : R₂) (hx : x ∈ maximal) : R₂ :=
Classical.choose (existsUnique_zeroDisk_y x hx).exists
theorem zeroDiskY_spec
(x : R₂) (hx : x ∈ maximal) :
N13GoodModelTwo.AffineEquation x (zeroDiskY x hx) ∧
zeroDiskY x hx ∈ maximal :=
Classical.choose_spec (existsUnique_zeroDisk_y x hx).exists
theorem y_eq_zeroDiskY
(x : R₂) (hx : x ∈ maximal)
{y : R₂}
(hy : N13GoodModelTwo.AffineEquation x y)
(hymem : y ∈ maximal) :
y = zeroDiskY x hx :=
y_eq_of_mem_maximal x y (zeroDiskY x hx)
(h_isUnit_of_mem_zeroDisk hx)
hy (zeroDiskY_spec x hx).1 hymem
(zeroDiskY_spec x hx).2
@[simp] theorem zeroDiskY_zero :
zeroDiskY 0 maximal.zero_mem = 0 := by
symm
apply y_eq_zeroDiskY 0 maximal.zero_mem
· simp [N13GoodModelTwo.AffineEquation,
N13GoodModelTwo.h, N13GoodModelTwo.rhs]
· exact maximal.zero_mem
/-! ## The disk above `(-1,0)` -/
theorem h_isUnit_of_mem_negOneDisk
{x : R₂} (hx : x + 1 ∈ maximal) :
IsUnit (N13GoodModelTwo.h x) := by
apply isUnit_of_sub_mem_maximal isUnit_neg_one
have hm :=
maximal.mul_mem_left (x ^ 2 - x + 2) hx
convert hm using 1
simp only [N13GoodModelTwo.h]
ring
theorem rhs_mem_of_mem_negOneDisk
{x : R₂} (hx : x + 1 ∈ maximal) :
N13GoodModelTwo.rhs x ∈ maximal := by
have hm :=
maximal.mul_mem_left (x ^ 4) hx
convert hm using 1
simp only [N13GoodModelTwo.rhs]
ring
theorem existsUnique_negOneDisk_y
(x : R₂) (hx : x + 1 ∈ maximal) :
∃! y : R₂,
N13GoodModelTwo.AffineEquation x y ∧
y ∈ maximal :=
existsUnique_y_mem_maximal x
(h_isUnit_of_mem_negOneDisk hx)
(rhs_mem_of_mem_negOneDisk hx)
/-- The unique `Y` coordinate above an `X` in the residue disk of `-1`. -/
def negOneDiskY (x : R₂) (hx : x + 1 ∈ maximal) : R₂ :=
Classical.choose (existsUnique_negOneDisk_y x hx).exists
theorem negOneDiskY_spec
(x : R₂) (hx : x + 1 ∈ maximal) :
N13GoodModelTwo.AffineEquation x (negOneDiskY x hx) ∧
negOneDiskY x hx ∈ maximal :=
Classical.choose_spec (existsUnique_negOneDisk_y x hx).exists
theorem y_eq_negOneDiskY
(x : R₂) (hx : x + 1 ∈ maximal)
{y : R₂}
(hy : N13GoodModelTwo.AffineEquation x y)
(hymem : y ∈ maximal) :
y = negOneDiskY x hx :=
y_eq_of_mem_maximal x y (negOneDiskY x hx)
(h_isUnit_of_mem_negOneDisk hx)
hy (negOneDiskY_spec x hx).1 hymem
(negOneDiskY_spec x hx).2
@[simp] theorem negOneDiskY_negOne :
negOneDiskY (-1) (by simp) = 0 := by
symm
apply y_eq_negOneDiskY (-1) (by simp)
· simp [N13GoodModelTwo.AffineEquation,
N13GoodModelTwo.h, N13GoodModelTwo.rhs]
ring
· exact maximal.zero_mem
end
end MazurProof.N13TwoAdicDisks
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N18RouteC_PushPull
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Generic push-pull algebra for N18 Route C
All geometry is concentrated in four identities in `PushPullData`. The
hyperelliptic sign, `Ψ ∘ Φ = [2]`, and the two-torsion kernel bound are then
formal consequences in additive commutative groups.
-/
namespace MazurProof.N18RouteC
noncomputable section
section Transport
variable {M A : Type*} [AddCommGroup M] [AddCommGroup A]
def transportEnd (e : M ≃+ A) (α : M →+ M) : A →+ A :=
e.toAddMonoidHom.comp (α.comp e.symm.toAddMonoidHom)
@[simp] theorem transportEnd_apply (e : M ≃+ A) (α : M →+ M) (x : A) :
transportEnd e α x = e (α (e.symm x)) := rfl
theorem transportEnd_comp (e : M ≃+ A) (α β : M →+ M) :
transportEnd e (α.comp β) =
(transportEnd e α).comp (transportEnd e β) := by
ext x
simp [transportEnd]
theorem transportEnd_eq_neg_id (e : M ≃+ A) (α : M →+ M)
(hα : ∀ x : M, α x = -x) :
transportEnd e α = -(AddMonoidHom.id A) := by
ext x
simp [transportEnd, hα]
end Transport
section Generic
variable {J EPlus EMinus : Type*}
variable [AddCommGroup J] [AddCommGroup EPlus] [AddCommGroup EMinus]
def twoTorsion (A : Type*) [AddCommGroup A] : AddSubgroup A :=
(((2 : ℕ) • AddMonoidHom.id A)).ker
@[simp] theorem mem_twoTorsion_iff (x : J) :
x ∈ twoTorsion J ↔ (2 : ℕ) • x = 0 := by
simp [twoTorsion]
structure PushPullData
(J EPlus EMinus : Type*)
[AddCommGroup J] [AddCommGroup EPlus] [AddCommGroup EMinus] where
hStar : J →+ J
sigmaStar : J →+ J
tauStar : J →+ J
pushPlus : J →+ EPlus
pushMinus : J →+ EMinus
pullPlus : EPlus →+ J
pullMinus : EMinus →+ J
h_add : ∀ D : J, D + hStar D = 0
tau_comp : tauStar = hStar.comp sigmaStar
plus_push_pull :
pullPlus.comp pushPlus = AddMonoidHom.id J + sigmaStar
minus_push_pull :
pullMinus.comp pushMinus = AddMonoidHom.id J + tauStar
namespace PushPullData
variable (d : PushPullData J EPlus EMinus)
theorem hStar_apply_eq_neg (D : J) : d.hStar D = -D := by
calc
d.hStar D = -D + (D + d.hStar D) := by abel
_ = -D := by rw [d.h_add D]; simp
theorem hStar_eq_neg_id :
d.hStar = -(AddMonoidHom.id J) := by
ext D
exact d.hStar_apply_eq_neg D
theorem tauStar_apply_eq_neg_sigmaStar (D : J) :
d.tauStar D = -d.sigmaStar D := by
calc
d.tauStar D = d.hStar (d.sigmaStar D) := by
have h := congrArg (fun f : J →+ J ↦ f D) d.tau_comp
simpa using h
_ = -d.sigmaStar D := d.hStar_apply_eq_neg (d.sigmaStar D)
theorem tauStar_eq_neg_sigmaStar : d.tauStar = -d.sigmaStar := by
ext D
exact d.tauStar_apply_eq_neg_sigmaStar D
theorem pullPlus_pushPlus_apply (D : J) :
d.pullPlus (d.pushPlus D) = D + d.sigmaStar D := by
have h := congrArg (fun f : J →+ J ↦ f D) d.plus_push_pull
simpa using h
theorem pullMinus_pushMinus_apply (D : J) :
d.pullMinus (d.pushMinus D) = D + d.tauStar D := by
have h := congrArg (fun f : J →+ J ↦ f D) d.minus_push_pull
simpa using h
def Phi : J →+ EPlus × EMinus where
toFun D := (d.pushPlus D, d.pushMinus D)
map_zero' := by simp
map_add' x y := by simp
def Psi : EPlus × EMinus →+ J where
toFun P := d.pullPlus P.1 + d.pullMinus P.2
map_zero' := by simp
map_add' x y := by
change d.pullPlus (x.1 + y.1) + d.pullMinus (x.2 + y.2) =
(d.pullPlus x.1 + d.pullMinus x.2) +
(d.pullPlus y.1 + d.pullMinus y.2)
rw [map_add, map_add]
abel
theorem PsiPhi_apply (D : J) : d.Psi (d.Phi D) = (2 : ℕ) • D := by
change d.pullPlus (d.pushPlus D) + d.pullMinus (d.pushMinus D) =
(2 : ℕ) • D
rw [d.pullPlus_pushPlus_apply D, d.pullMinus_pushMinus_apply D,
d.tauStar_apply_eq_neg_sigmaStar D]
simp only [two_nsmul]
abel
theorem Psi_comp_Phi :
d.Psi.comp d.Phi = (2 : ℕ) • AddMonoidHom.id J := by
ext D
exact d.PsiPhi_apply D
theorem ker_Phi_le_twoTorsion : d.Phi.ker ≤ twoTorsion J := by
intro D hD
rw [mem_twoTorsion_iff]
change d.Phi D = 0 at hD
calc
(2 : ℕ) • D = d.Psi (d.Phi D) := (d.PsiPhi_apply D).symm
_ = d.Psi 0 := by rw [hD]
_ = 0 := by simp
theorem Phi_injective_of_no_twoTorsion
(h2 : ∀ D : J, (2 : ℕ) • D = 0 → D = 0) :
Function.Injective d.Phi := by
intro x y hxy
have hsub : d.Phi (x - y) = 0 := by
rw [map_sub, hxy, sub_self]
have hmem : x - y ∈ d.Phi.ker := hsub
have htwo : (2 : ℕ) • (x - y) = 0 :=
(mem_twoTorsion_iff (x - y)).mp (d.ker_Phi_le_twoTorsion hmem)
exact sub_eq_zero.mp (h2 (x - y) htwo)
theorem Phi_injOn_of_no_twoTorsion
(H : AddSubgroup J)
(hH : ∀ D : J, D ∈ H → (2 : ℕ) • D = 0 → D = 0) :
Set.InjOn d.Phi (H : Set J) := by
intro x hx y hy hxy
have hsub : d.Phi (x - y) = 0 := by
rw [map_sub, hxy, sub_self]
have hmem : x - y ∈ d.Phi.ker := hsub
have htwo : (2 : ℕ) • (x - y) = 0 :=
(mem_twoTorsion_iff (x - y)).mp (d.ker_Phi_le_twoTorsion hmem)
exact sub_eq_zero.mp (hH (x - y) (H.sub_mem hx hy) htwo)
end PushPullData
end Generic
end
end MazurProof.N18RouteC
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N18RouteC_Separated
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Weak descent and formal-kernel separatedness for N18 Route C
This file is independent of any Mordell--Weil finite-generation theorem. It
turns a weak `3`-descent, a seven-torsion reduction group, and strict growth in
the formal kernel into the uniform annihilator `[21]`.
-/
namespace MazurProof.N18RouteC.Separated
noncomputable section
def InfinitelyNSmulDivisible
{G : Type*} [AddCommGroup G] (n : ℕ) (x : G) : Prop :=
∀ k : ℕ, ∃ y : G, (n ^ k) • y = x
def NSeparated (G : Type*) [AddCommGroup G] (n : ℕ) : Prop :=
∀ x : G, InfinitelyNSmulDivisible n x → x = 0
def WeakDescentWitness
(G : Type*) [AddCommGroup G] (n a : ℕ) : Prop :=
∀ x : G, ∃ h y : G, a • h = 0 ∧ x = h + n • y
theorem nsmul_nsmul_comm
{G : Type*} [AddCommGroup G]
(m n : ℕ) (x : G) :
m • (n • x) = n • (m • x) := by
calc
m • (n • x) = (n * m) • x := (mul_nsmul x n m).symm
_ = (m * n) • x := by rw [Nat.mul_comm]
_ = n • (m • x) := mul_nsmul x m n
theorem nsmul_eq_zero_of_dvd
{G : Type*} [AddCommGroup G]
{a e : ℕ} (hae : a ∣ e) {x : G}
(hx : a • x = 0) : e • x = 0 := by
rcases hae with ⟨c, rfl⟩
calc
(a * c) • x = (c * a) • x := by rw [Nat.mul_comm]
_ = (a * c) • x := by rw [Nat.mul_comm]
_ = c • (a • x) := mul_nsmul x a c
_ = 0 := by rw [hx, nsmul_zero]
theorem weakDescent_iter_commonMultiple
{G : Type*} [AddCommGroup G]
{n a e : ℕ}
(weak : WeakDescentWitness G n a)
(hae : a ∣ e) :
∀ k : ℕ, ∀ x : G,
∃ y : G, e • x = (n ^ k) • (e • y) := by
intro k
induction k with
| zero =>
intro x
exact ⟨x, by simp⟩
| succ k ih =>
intro x
obtain ⟨y, hy⟩ := ih x
obtain ⟨h, z, hh, hz⟩ := weak y
have heh : e • h = 0 := nsmul_eq_zero_of_dvd hae hh
refine ⟨z, ?_⟩
calc
e • x = (n ^ k) • (e • y) := hy
_ = (n ^ k) • (e • (h + n • z)) := by rw [hz]
_ = (n ^ k) • (n • (e • z)) := by
congr 1
rw [nsmul_add, heh, zero_add]
exact nsmul_nsmul_comm e n z
_ = (n ^ (k + 1)) • (e • z) := by
calc
(n ^ k) • (n • (e • z)) =
(n * n ^ k) • (e • z) :=
(mul_nsmul (e • z) n (n ^ k)).symm
_ = (n ^ k * n) • (e • z) := by rw [Nat.mul_comm]
_ = (n ^ (k + 1)) • (e • z) := by rw [pow_succ]
theorem annihilated_of_commonMultiple
{G A R : Type*}
[AddCommGroup G] [AddCommGroup A] [AddCommGroup R]
(loc : G →+ A)
(hloc : Function.Injective loc)
(red : A →+ R)
(n a b e : ℕ)
(weak : WeakDescentWitness G n a)
(killRed : ∀ r : R, b • r = 0)
(hae : a ∣ e)
(hbe : b ∣ e)
(separated : NSeparated red.ker n) :
∀ x : G, e • x = 0 := by
have killRedE : ∀ r : R, e • r = 0 := by
intro r
exact nsmul_eq_zero_of_dvd hbe (killRed r)
have hiter := weakDescent_iter_commonMultiple weak hae
intro x
let P : red.ker :=
⟨loc (e • x), by
change red (loc (e • x)) = 0
simpa only [map_nsmul] using killRedE (red (loc x))⟩
have hdiv : InfinitelyNSmulDivisible n P := by
intro k
obtain ⟨y, hy⟩ := hiter k x
let Q : red.ker :=
⟨loc (e • y), by
change red (loc (e • y)) = 0
simpa only [map_nsmul] using killRedE (red (loc y))⟩
refine ⟨Q, ?_⟩
apply Subtype.ext
simpa [P, Q] using congrArg loc hy.symm
have hP0 : P = 0 := separated P hdiv
apply hloc
simpa [P] using congrArg Subtype.val hP0
theorem annihilated_of_weakDescent_and_separated
{G A R : Type*}
[AddCommGroup G] [AddCommGroup A] [AddCommGroup R]
(loc : G →+ A)
(hloc : Function.Injective loc)
(red : A →+ R)
(n a b : ℕ)
(weak : WeakDescentWitness G n a)
(killRed : ∀ r : R, b • r = 0)
(separated : NSeparated red.ker n) :
∀ x : G, Nat.lcm a b • x = 0 := by
exact annihilated_of_commonMultiple loc hloc red n a b (Nat.lcm a b)
weak killRed (Nat.dvd_lcm_left a b) (Nat.dvd_lcm_right a b) separated
structure StrictNSmulFiltration
(K : Type*) [AddCommGroup K] (n : ℕ) where
level : K → ℕ
step : ∀ {x : K},
x ≠ 0 → n • x ≠ 0 → level x + 1 ≤ level (n • x)
theorem StrictNSmulFiltration.iterate
{K : Type*} [AddCommGroup K]
{n : ℕ}
(D : StrictNSmulFiltration K n)
{x : K} :
∀ k : ℕ,
(n ^ k) • x ≠ 0 →
D.level x + k ≤ D.level ((n ^ k) • x) := by
intro k
induction k with
| zero =>
intro _
simp
| succ k ih =>
intro hfinal
have hpow :
(n ^ (k + 1)) • x = n • ((n ^ k) • x) := by
calc
(n ^ (k + 1)) • x = (n ^ k * n) • x := by rw [pow_succ]
_ = (n * n ^ k) • x := by rw [Nat.mul_comm]
_ = (n ^ k) • (n • x) := mul_nsmul x n (n ^ k)
_ = n • ((n ^ k) • x) := nsmul_nsmul_comm (n ^ k) n x
have hprev : (n ^ k) • x ≠ 0 := by
intro hz
apply hfinal
rw [hpow, hz, nsmul_zero]
have hstepNe : n • ((n ^ k) • x) ≠ 0 := by
rw [← hpow]
exact hfinal
have hi := ih hprev
have hs := D.step hprev hstepNe
calc
D.level x + (k + 1) = (D.level x + k) + 1 := by omega
_ ≤ D.level ((n ^ k) • x) + 1 := Nat.add_le_add_right hi 1
_ ≤ D.level (n • ((n ^ k) • x)) := hs
_ = D.level ((n ^ (k + 1)) • x) := by
rw [hpow]
theorem StrictNSmulFiltration.separated
{K : Type*} [AddCommGroup K]
{n : ℕ}
(D : StrictNSmulFiltration K n) :
NSeparated K n := by
intro P hdiv
by_contra hP
let N : ℕ := D.level P + 1
obtain ⟨Q, hQ⟩ := hdiv N
have hfinal : (n ^ N) • Q ≠ 0 := by
rw [hQ]
exact hP
have hi := D.iterate N hfinal
rw [hQ] at hi
dsimp [N] at hi
omega
theorem e0_killed_by_21
{E0Point LocalPoint RedPoint : Type*}
[AddCommGroup E0Point]
[AddCommGroup LocalPoint]
[AddCommGroup RedPoint]
(loc : E0Point →+ LocalPoint)
(hloc : Function.Injective loc)
(red : LocalPoint →+ RedPoint)
(weakBlock4 : ∀ P : E0Point,
∃ h : E0Point, 3 • h = 0 ∧
∃ Q : E0Point, P = h + 3 • Q)
(reductionExponentSeven : ∀ r : RedPoint, 7 • r = 0)
(formalFiltration : StrictNSmulFiltration red.ker 3) :
∀ P : E0Point, 21 • P = 0 := by
have weak : WeakDescentWitness E0Point 3 3 := by
intro P
obtain ⟨h, hh, Q, hPQ⟩ := weakBlock4 P
exact ⟨h, Q, hh, hPQ⟩
have h := annihilated_of_weakDescent_and_separated
loc hloc red 3 3 7 weak reductionExponentSeven
formalFiltration.separated
intro P
simpa [show Nat.lcm 3 7 = 21 by decide] using h P
theorem annihilator_transfer_injective
{A B : Type*} [AddCommGroup A] [AddCommGroup B]
(f : A →+ B)
(hf : Function.Injective f)
(m : ℕ)
(killB : ∀ b : B, m • b = 0) :
∀ a : A, m • a = 0 := by
intro a
apply hf
simpa only [map_nsmul, map_zero] using killB (f a)
theorem pushPull_annihilator
{J A B : Type*}
[AddCommGroup J] [AddCommGroup A] [AddCommGroup B]
(Phi : J →+ A × B)
(Psi : A × B →+ J)
(m : ℕ)
(killA : ∀ a : A, m • a = 0)
(killB : ∀ b : B, m • b = 0)
(pushPull : ∀ D : J, Psi (Phi D) = 2 • D) :
∀ D : J, (2 * m) • D = 0 := by
intro D
have hpair : m • Phi D = 0 := by
apply Prod.ext
· simpa using killA (Phi D).1
· simpa using killB (Phi D).2
calc
(2 * m) • D = m • (2 • D) := by
calc
(2 * m) • D = (m * 2) • D := by rw [Nat.mul_comm]
_ = (2 * m) • D := by rw [Nat.mul_comm]
_ = m • (2 • D) := mul_nsmul D 2 m
_ = m • Psi (Phi D) := by rw [← pushPull D]
_ = Psi (m • Phi D) := by rw [map_nsmul]
_ = 0 := by rw [hpair, map_zero]
end
end MazurProof.N18RouteC.Separated
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13TwoAdicKernelChart
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# A structural two-adic kernel chart
This file isolates the elementary formal-group argument needed for N13.
Suppose an additive group has two coordinates in `ℤ₂`, every coordinate is
divisible by two, and addition differs from coordinatewise addition by an
element of the product of the two coordinate ideals. Then doubling raises
coordinate depth by at least one. Infinite two-divisibility is therefore
incompatible with the separated two-adic filtration.
No formal power series, point table, or explicit genus-two addition formula
is used below. The eventual curve-specific input is only the
cross-quadratic error statement.
-/
namespace MazurProof.N13TwoAdicKernelChart
noncomputable section
open N18RouteC.Separated
local instance instFactPrimeOfNatNat_fLT : Fact (Nat.Prime 2) :=
⟨Nat.prime_two⟩
abbrev R₂ : Type :=
ℤ_[2]
/-- The principal ideal `(2^n)` in the two-adic integers. -/
def powTwoIdeal (n : ℕ) : Ideal R₂ :=
Ideal.span ({(2 : R₂) ^ n} : Set R₂)
theorem powTwoIdeal_mul (r s : ℕ) :
powTwoIdeal r * powTwoIdeal s =
powTwoIdeal (r + s) := by
simp only [powTwoIdeal,
Ideal.span_singleton_mul_span_singleton, ← pow_add]
theorem powTwoIdeal_antitone
{r s : ℕ} (hrs : r ≤ s) :
powTwoIdeal s ≤ powTwoIdeal r := by
rw [powTwoIdeal, powTwoIdeal,
Ideal.span_singleton_le_iff_mem,
Ideal.mem_span_singleton]
exact pow_dvd_pow (2 : R₂) hrs
universe u
variable {K : Type u} [AddCommGroup K]
/-- The ideal generated by the two coordinates of `z`. -/
def coordIdeal
(coord : K → Fin 2 → R₂) (z : K) :
Ideal R₂ :=
Ideal.span (Set.range (coord z))
/-- A two-coordinate chart whose transported addition law has only mixed
quadratic and higher error terms. -/
structure Chart (K : Type u) [AddCommGroup K] where
coord : K → Fin 2 → R₂
coord_zero : coord 0 = 0
coord_injective : Function.Injective coord
coord_mem_two :
∀ z i, coord z i ∈ powTwoIdeal 1
add_error_mem :
∀ z w i,
coord (z + w) i - (coord z i + coord w i) ∈
coordIdeal coord z * coordIdeal coord w
namespace Chart
variable (C : Chart K)
/-- All chart coordinates have depth at least `n`. -/
def CoordDepth (n : ℕ) (z : K) : Prop :=
∀ i, C.coord z i ∈ powTwoIdeal n
theorem coordIdeal_le_powTwoIdeal
{n : ℕ} {z : K}
(hz : C.CoordDepth n z) :
coordIdeal C.coord z ≤ powTwoIdeal n := by
rw [coordIdeal, Ideal.span_le]
intro a ha
obtain ⟨i, rfl⟩ := ha
exact hz i
theorem add_error_mem_powTwoIdeal
{r s : ℕ} {z w : K}
(hz : C.CoordDepth r z)
(hw : C.CoordDepth s w)
(i : Fin 2) :
C.coord (z + w) i -
(C.coord z i + C.coord w i) ∈
powTwoIdeal (r + s) := by
rw [← powTwoIdeal_mul]
exact
(Ideal.mul_mono
(C.coordIdeal_le_powTwoIdeal hz)
(C.coordIdeal_le_powTwoIdeal hw))
(C.add_error_mem z w i)
private theorem two_mul_mem_next
{n : ℕ} {a : R₂}
(ha : a ∈ powTwoIdeal n) :
a + a ∈ powTwoIdeal (n + 1) := by
rw [powTwoIdeal, Ideal.mem_span_singleton] at ha ⊢
obtain ⟨b, hb⟩ := ha
refine ⟨b, ?_⟩
rw [hb, pow_succ]
ring
/-- Doubling raises the two-adic coordinate depth by at least one. -/
theorem two_nsmul_depth
{n : ℕ} (hn : 1 ≤ n) {z : K}
(hz : C.CoordDepth n z) :
C.CoordDepth (n + 1) (2 • z) := by
intro i
have herr :
C.coord (z + z) i -
(C.coord z i + C.coord z i) ∈
powTwoIdeal (n + n) :=
C.add_error_mem_powTwoIdeal hz hz i
have herr' :
C.coord (z + z) i -
(C.coord z i + C.coord z i) ∈
powTwoIdeal (n + 1) :=
powTwoIdeal_antitone (by omega) herr
have hlinear :
C.coord z i + C.coord z i ∈
powTwoIdeal (n + 1) :=
two_mul_mem_next (hz i)
have hsum :=
Ideal.add_mem (powTwoIdeal (n + 1)) herr' hlinear
simpa [two_nsmul] using hsum
/-- Iterated doubling starts at depth one and gains one level per step. -/
theorem twoPow_depth
(z : K) :
∀ k : ℕ,
C.CoordDepth (k + 1) ((2 ^ k) • z) := by
intro k
induction k with
| zero =>
intro i
simpa only [pow_zero, one_nsmul, zero_add] using
C.coord_mem_two z i
| succ k ih =>
have hstep :
C.CoordDepth (k + 1 + 1)
(2 • ((2 ^ k) • z)) :=
C.two_nsmul_depth (n := k + 1) (by omega) ih
simpa [pow_succ, mul_nsmul] using hstep
theorem coord_eq_zero_of_all_depth
{z : K}
(hz : ∀ n : ℕ, C.CoordDepth n z) :
C.coord z = 0 := by
funext i
by_contra hi
have hmem :
C.coord z i ∈
Ideal.span
({(2 : R₂) ^
(C.coord z i).valuation.succ} : Set R₂) := by
simpa only [powTwoIdeal] using
hz (C.coord z i).valuation.succ i
have hle :
(C.coord z i).valuation.succ ≤
(C.coord z i).valuation :=
(PadicInt.mem_span_pow_iff_le_valuation
(C.coord z i) hi
(C.coord z i).valuation.succ).mp hmem
omega
include C
/-- The cross-quadratic two-adic chart is separated: no nonzero element is
divisible by every power of two. -/
theorem separated :
NSeparated K 2 := by
intro z hdiv
have hall : ∀ n : ℕ, C.CoordDepth n z := by
intro n
cases n with
| zero =>
intro i
simp [powTwoIdeal]
| succ k =>
obtain ⟨y, hy⟩ := hdiv k
have hdepth := C.twoPow_depth y k
rw [hy] at hdepth
simpa [Nat.succ_eq_add_one] using hdepth
apply C.coord_injective
rw [C.coord_zero]
exact C.coord_eq_zero_of_all_depth hall
end Chart
/-! ## The unary doubling interface
Separatedness only iterates multiplication by two. The binary addition
estimate above is therefore stronger than necessary: it is enough to know
the same quadratic error estimate on the diagonal. -/
/-- A two-coordinate chart with only the diagonal doubling estimate needed
for two-adic separatedness. -/
structure DoublingChart (K : Type u) [AddCommGroup K] where
coord : K → Fin 2 → R₂
coord_zero : coord 0 = 0
coord_injective : Function.Injective coord
coord_mem_two :
∀ z i, coord z i ∈ powTwoIdeal 1
double_error_mem :
∀ z i,
coord (2 • z) i - (coord z i + coord z i) ∈
coordIdeal coord z * coordIdeal coord z
namespace DoublingChart
variable (C : DoublingChart K)
/-- All unary-chart coordinates have depth at least `n`. -/
def CoordDepth (n : ℕ) (z : K) : Prop :=
∀ i, C.coord z i ∈ powTwoIdeal n
theorem coordIdeal_le_powTwoIdeal
{n : ℕ} {z : K}
(hz : C.CoordDepth n z) :
coordIdeal C.coord z ≤ powTwoIdeal n := by
rw [coordIdeal, Ideal.span_le]
intro a ha
obtain ⟨i, rfl⟩ := ha
exact hz i
private theorem two_mul_mem_next
{n : ℕ} {a : R₂}
(ha : a ∈ powTwoIdeal n) :
a + a ∈ powTwoIdeal (n + 1) := by
rw [powTwoIdeal, Ideal.mem_span_singleton] at ha ⊢
obtain ⟨b, hb⟩ := ha
refine ⟨b, ?_⟩
rw [hb, pow_succ]
ring
/-- The diagonal quadratic estimate raises coordinate depth under
doubling. -/
theorem two_nsmul_depth
{n : ℕ} (hn : 1 ≤ n) {z : K}
(hz : C.CoordDepth n z) :
C.CoordDepth (n + 1) (2 • z) := by
intro i
have herr :
C.coord (2 • z) i -
(C.coord z i + C.coord z i) ∈
powTwoIdeal (n + n) := by
rw [← powTwoIdeal_mul]
exact
(Ideal.mul_mono
(C.coordIdeal_le_powTwoIdeal hz)
(C.coordIdeal_le_powTwoIdeal hz))
(C.double_error_mem z i)
have herr' :
C.coord (2 • z) i -
(C.coord z i + C.coord z i) ∈
powTwoIdeal (n + 1) :=
powTwoIdeal_antitone (by omega) herr
have hlinear :
C.coord z i + C.coord z i ∈
powTwoIdeal (n + 1) :=
two_mul_mem_next (hz i)
have hsum :=
Ideal.add_mem (powTwoIdeal (n + 1)) herr' hlinear
simpa using hsum
/-- Iterated doubling gains one level of depth at every step. -/
theorem twoPow_depth
(z : K) :
∀ k : ℕ,
C.CoordDepth (k + 1) ((2 ^ k) • z) := by
intro k
induction k with
| zero =>
intro i
simpa only [pow_zero, one_nsmul, zero_add] using
C.coord_mem_two z i
| succ k ih =>
have hstep :
C.CoordDepth (k + 1 + 1)
(2 • ((2 ^ k) • z)) :=
C.two_nsmul_depth (n := k + 1) (by omega) ih
simpa [pow_succ, mul_nsmul] using hstep
theorem coord_eq_zero_of_all_depth
{z : K}
(hz : ∀ n : ℕ, C.CoordDepth n z) :
C.coord z = 0 := by
funext i
by_contra hi
have hmem :
C.coord z i ∈
Ideal.span
({(2 : R₂) ^
(C.coord z i).valuation.succ} : Set R₂) := by
simpa only [powTwoIdeal] using
hz (C.coord z i).valuation.succ i
have hle :
(C.coord z i).valuation.succ ≤
(C.coord z i).valuation :=
(PadicInt.mem_span_pow_iff_le_valuation
(C.coord z i) hi
(C.coord z i).valuation.succ).mp hmem
omega
include C
/-- The unary doubling chart is already sufficient for two-adic
separatedness. -/
theorem separated :
NSeparated K 2 := by
intro z hdiv
have hall : ∀ n : ℕ, C.CoordDepth n z := by
intro n
cases n with
| zero =>
intro i
simp [powTwoIdeal]
| succ k =>
obtain ⟨y, hy⟩ := hdiv k
have hdepth := C.twoPow_depth y k
rw [hy] at hdepth
simpa [Nat.succ_eq_add_one] using hdepth
apply C.coord_injective
rw [C.coord_zero]
exact C.coord_eq_zero_of_all_depth hall
end DoublingChart
end
end MazurProof.N13TwoAdicKernelChart
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13TwoAdicAbelChartData
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Integral Mumford data on the nonspecial N13 two-adic Abel chart
A point in the residue disk of `(0,0)` and a point in the residue disk of
`(-1,0)` have distinct `x`-coordinates by a unit. Lagrange interpolation
therefore gives an integral graph polynomial through the two points.
The product of the two linear factors divides the curve residual. The same
interpolation argument, applied to the inverses of the two vertical
derivatives, gives the smoothness Bezout identity. Thus every such pair
defines smooth generalized Mumford data over `ℤ₂`, without a search through
congruence classes.
-/
open Polynomial
namespace MazurProof.N13TwoAdicAbelChartData
noncomputable section
local instance instFactPrimeOfNatNat_fLT : Fact (Nat.Prime 2) :=
⟨Nat.prime_two⟩
abbrev R₂ : Type :=
ℤ_[2]
abbrev maximal : Ideal R₂ :=
N13TwoAdicDisks.maximal
/-- A pair of points in the two residue disks used by the nonspecial chart.
The `y`-coordinates are the canonical Hensel lifts and are therefore not
stored separately. -/
structure DiskPair where
x₀ : R₂
x₁ : R₂
x₀_mem : x₀ ∈ maximal
x₁_add_one_mem : x₁ + 1 ∈ maximal
/-- The distinguished pair `(0,0)+(-1,0)`. -/
def basePair : DiskPair where
x₀ := 0
x₁ := -1
x₀_mem := maximal.zero_mem
x₁_add_one_mem := by simp
namespace DiskPair
variable (P : DiskPair)
theorem reduceBase_eq_zero_of_mem
{a : R₂} (ha : a ∈ maximal) :
N13GeneralizedMumfordReduction.reduceBase a = 0 := by
apply RingHom.mem_ker.mp
rw [N13GeneralizedMumfordReduction.reduceBase,
PadicInt.ker_toZMod]
exact ha
@[simp] theorem reduceBase_x₀ :
N13GeneralizedMumfordReduction.reduceBase P.x₀ = 0 :=
reduceBase_eq_zero_of_mem P.x₀_mem
@[simp] theorem reduceBase_x₁ :
N13GeneralizedMumfordReduction.reduceBase P.x₁ = 1 := by
have hsum :
N13GeneralizedMumfordReduction.reduceBase P.x₁ + 1 = 0 := by
simpa only [map_add, map_one] using
reduceBase_eq_zero_of_mem P.x₁_add_one_mem
simpa only [CharTwo.neg_eq] using
eq_neg_of_add_eq_zero_left hsum
def y₀ : R₂ :=
N13TwoAdicDisks.zeroDiskY P.x₀ P.x₀_mem
def y₁ : R₂ :=
N13TwoAdicDisks.negOneDiskY P.x₁ P.x₁_add_one_mem
@[simp] theorem basePair_y₀ :
basePair.y₀ = 0 :=
N13TwoAdicDisks.zeroDiskY_zero
@[simp] theorem basePair_y₁ :
basePair.y₁ = 0 :=
N13TwoAdicDisks.negOneDiskY_negOne
theorem y₀_spec :
N13GoodModelTwo.AffineEquation P.x₀ P.y₀ ∧
P.y₀ ∈ maximal :=
N13TwoAdicDisks.zeroDiskY_spec P.x₀ P.x₀_mem
theorem y₁_spec :
N13GoodModelTwo.AffineEquation P.x₁ P.y₁ ∧
P.y₁ ∈ maximal :=
N13TwoAdicDisks.negOneDiskY_spec P.x₁ P.x₁_add_one_mem
@[simp] theorem reduceBase_y₀ :
N13GeneralizedMumfordReduction.reduceBase P.y₀ = 0 :=
reduceBase_eq_zero_of_mem P.y₀_spec.2
@[simp] theorem reduceBase_y₁ :
N13GeneralizedMumfordReduction.reduceBase P.y₁ = 0 :=
reduceBase_eq_zero_of_mem P.y₁_spec.2
theorem x₁_sub_x₀_isUnit :
IsUnit (P.x₁ - P.x₀) := by
apply N13TwoAdicDisks.isUnit_of_sub_mem_maximal isUnit_neg_one
have h :=
maximal.sub_mem P.x₁_add_one_mem P.x₀_mem
convert h using 1
ring
theorem cross_x₁_sub_x₀_isUnit (Q : DiskPair) :
IsUnit (P.x₁ - Q.x₀) := by
apply N13TwoAdicDisks.isUnit_of_sub_mem_maximal isUnit_neg_one
have h :=
maximal.sub_mem P.x₁_add_one_mem Q.x₀_mem
convert h using 1
ring
/-- The inverse of the unit separating the two `x`-coordinates. -/
def deltaInv : R₂ :=
↑((P.x₁_sub_x₀_isUnit).unit⁻¹)
theorem deltaInv_mul_delta :
P.deltaInv * (P.x₁ - P.x₀) = 1 := by
rw [← (P.x₁_sub_x₀_isUnit).unit_spec]
exact Units.inv_mul _
/-- The integral linear interpolant taking values `a₀,a₁` at the two
selected `x`-coordinates. -/
def interpolate (a₀ a₁ : R₂) : R₂[X] :=
C a₀ +
C (P.deltaInv * (a₁ - a₀)) * (X - C P.x₀)
@[simp] theorem interpolate_eval_x₀ (a₀ a₁ : R₂) :
(P.interpolate a₀ a₁).eval P.x₀ = a₀ := by
simp [interpolate]
@[simp] theorem interpolate_eval_x₁ (a₀ a₁ : R₂) :
(P.interpolate a₀ a₁).eval P.x₁ = a₁ := by
simp only [interpolate, eval_add, eval_C, eval_mul, eval_sub,
eval_X]
calc
a₀ + P.deltaInv * (a₁ - a₀) * (P.x₁ - P.x₀) =
a₀ + (a₁ - a₀) *
(P.deltaInv * (P.x₁ - P.x₀)) := by ring
_ = a₁ := by rw [P.deltaInv_mul_delta]; ring
/-- The monic polynomial cutting out the two selected affine points. -/
def u : R₂[X] :=
(X - C P.x₀) * (X - C P.x₁)
/-- The graph polynomial through the two selected affine points. -/
def v : R₂[X] :=
P.interpolate P.y₀ P.y₁
@[simp] theorem basePair_u :
basePair.u =
N13FormalAbelLinearization.uBase := by
simp [u, basePair, N13FormalAbelLinearization.uBase]
ring
@[simp] theorem basePair_v :
basePair.v = 0 := by
change basePair.interpolate basePair.y₀ basePair.y₁ = 0
rw [basePair_y₀, basePair_y₁]
simp [interpolate]
theorem u_monic : P.u.Monic := by
exact (monic_X_sub_C P.x₀).mul (monic_X_sub_C P.x₁)
@[simp] theorem u_eval_x₀ :
P.u.eval P.x₀ = 0 := by
simp [u]
@[simp] theorem u_eval_x₁ :
P.u.eval P.x₁ = 0 := by
simp [u]
@[simp] theorem v_eval_x₀ :
P.v.eval P.x₀ = P.y₀ :=
P.interpolate_eval_x₀ P.y₀ P.y₁
@[simp] theorem v_eval_x₁ :
P.v.eval P.x₁ = P.y₁ :=
P.interpolate_eval_x₁ P.y₀ P.y₁
/-- The generalized-hyperelliptic residual after restriction to the graph
`Y=v(X)`. -/
def curveError : R₂[X] :=
P.v ^ 2 +
N13GeneralizedMumfordIntegral.hPoly * P.v -
N13GeneralizedMumfordIntegral.rhsPoly
@[simp] theorem curveError_eval_x₀ :
P.curveError.eval P.x₀ = 0 := by
have hcurve := P.y₀_spec.1
rw [N13GoodModelTwo.affineEquation_iff_residual] at hcurve
simpa [curveError, N13GoodModelTwo.affineResidual,
N13GoodModelTwo.h, N13GoodModelTwo.rhs,
N13GeneralizedMumfordIntegral.hPoly,
N13GeneralizedMumfordIntegral.rhsPoly] using hcurve
@[simp] theorem curveError_eval_x₁ :
P.curveError.eval P.x₁ = 0 := by
have hcurve := P.y₁_spec.1
rw [N13GoodModelTwo.affineEquation_iff_residual] at hcurve
simpa [curveError, N13GoodModelTwo.affineResidual,
N13GoodModelTwo.h, N13GoodModelTwo.rhs,
N13GeneralizedMumfordIntegral.hPoly,
N13GeneralizedMumfordIntegral.rhsPoly] using hcurve
theorem u_dvd_curveError :
P.u ∣ P.curveError := by
have h₀ : X - C P.x₀ ∣ P.curveError := by
rw [dvd_iff_isRoot, IsRoot]
exact P.curveError_eval_x₀
have h₁ : X - C P.x₁ ∣ P.curveError := by
rw [dvd_iff_isRoot, IsRoot]
exact P.curveError_eval_x₁
have hprod :=
(isCoprime_X_sub_C_of_isUnit_sub
P.x₁_sub_x₀_isUnit).mul_dvd h₁ h₀
simpa [u, mul_comm] using hprod
def w : R₂[X] :=
Classical.choose P.u_dvd_curveError
theorem curve_eq :
P.v ^ 2 +
N13GeneralizedMumfordIntegral.hPoly * P.v -
N13GeneralizedMumfordIntegral.rhsPoly =
P.u * P.w :=
Classical.choose_spec P.u_dvd_curveError
/-- The vertical derivative `2v+h` restricted to the graph. -/
def verticalDerivative : R₂[X] :=
2 * P.v + N13GeneralizedMumfordIntegral.hPoly
@[simp] theorem verticalDerivative_eval_x₀ :
P.verticalDerivative.eval P.x₀ =
2 * P.y₀ + N13GoodModelTwo.h P.x₀ := by
simp [verticalDerivative, N13GeneralizedMumfordIntegral.hPoly,
N13GoodModelTwo.h]
@[simp] theorem verticalDerivative_eval_x₁ :
P.verticalDerivative.eval P.x₁ =
2 * P.y₁ + N13GoodModelTwo.h P.x₁ := by
simp [verticalDerivative, N13GeneralizedMumfordIntegral.hPoly,
N13GoodModelTwo.h]
theorem verticalDerivative_eval_x₀_isUnit :
IsUnit (P.verticalDerivative.eval P.x₀) := by
rw [P.verticalDerivative_eval_x₀]
apply N13TwoAdicDisks.isUnit_of_sub_mem_maximal
(N13TwoAdicDisks.h_isUnit_of_mem_zeroDisk P.x₀_mem)
have h := maximal.mul_mem_left (2 : R₂) P.y₀_spec.2
convert h using 1
ring
theorem verticalDerivative_eval_x₁_isUnit :
IsUnit (P.verticalDerivative.eval P.x₁) := by
rw [P.verticalDerivative_eval_x₁]
apply N13TwoAdicDisks.isUnit_of_sub_mem_maximal
(N13TwoAdicDisks.h_isUnit_of_mem_negOneDisk
P.x₁_add_one_mem)
have h := maximal.mul_mem_left (2 : R₂) P.y₁_spec.2
convert h using 1
ring
def derivativeInv₀ : R₂ :=
↑((P.verticalDerivative_eval_x₀_isUnit).unit⁻¹)
def derivativeInv₁ : R₂ :=
↑((P.verticalDerivative_eval_x₁_isUnit).unit⁻¹)
@[simp] theorem derivativeInv₀_mul :
P.derivativeInv₀ * P.verticalDerivative.eval P.x₀ = 1 := by
rw [← (P.verticalDerivative_eval_x₀_isUnit).unit_spec]
exact Units.inv_mul _
@[simp] theorem derivativeInv₁_mul :
P.derivativeInv₁ * P.verticalDerivative.eval P.x₁ = 1 := by
rw [← (P.verticalDerivative_eval_x₁_isUnit).unit_spec]
exact Units.inv_mul _
/-- Interpolate the inverses of the two vertical derivatives. -/
def derivativeInverse : R₂[X] :=
P.interpolate P.derivativeInv₀ P.derivativeInv₁
@[simp] theorem derivativeInverse_mul_eval_x₀ :
(P.derivativeInverse * P.verticalDerivative).eval P.x₀ = 1 := by
rw [eval_mul, derivativeInverse, P.interpolate_eval_x₀,
P.derivativeInv₀_mul]
@[simp] theorem derivativeInverse_mul_eval_x₁ :
(P.derivativeInverse * P.verticalDerivative).eval P.x₁ = 1 := by
rw [eval_mul, derivativeInverse, P.interpolate_eval_x₁,
P.derivativeInv₁_mul]
theorem u_dvd_derivativeInverse_mul_sub_one :
P.u ∣ P.derivativeInverse * P.verticalDerivative - 1 := by
have h₀ :
X - C P.x₀ ∣
P.derivativeInverse * P.verticalDerivative - 1 := by
rw [dvd_iff_isRoot, IsRoot]
rw [eval_sub, P.derivativeInverse_mul_eval_x₀, eval_one,
sub_self]
have h₁ :
X - C P.x₁ ∣
P.derivativeInverse * P.verticalDerivative - 1 := by
rw [dvd_iff_isRoot, IsRoot]
rw [eval_sub, P.derivativeInverse_mul_eval_x₁, eval_one,
sub_self]
have hprod :=
(isCoprime_X_sub_C_of_isUnit_sub
P.x₁_sub_x₀_isUnit).mul_dvd h₁ h₀
simpa [u, mul_comm] using hprod
def bezoutQuotient : R₂[X] :=
Classical.choose P.u_dvd_derivativeInverse_mul_sub_one
theorem bezoutQuotient_spec :
P.derivativeInverse * P.verticalDerivative - 1 =
P.u * P.bezoutQuotient :=
Classical.choose_spec P.u_dvd_derivativeInverse_mul_sub_one
/-- The two-disk divisor supplies smooth integral generalized Mumford data. -/
def smoothMumford :
N13GeneralizedMumfordReduction.SmoothMumford₂ where
u := P.u
v := P.v
w := P.w
u_monic := P.u_monic
curve_eq := P.curve_eq
bezout := by
refine
⟨-P.bezoutQuotient, P.derivativeInverse, 0, ?_⟩
rw [show
2 * P.v +
N13GeneralizedMumfordIntegral.hPoly =
P.verticalDerivative by rfl]
have h := P.bezoutQuotient_spec
have hb :
P.derivativeInverse * P.verticalDerivative =
P.u * P.bezoutQuotient + 1 :=
sub_eq_iff_eq_add.mp h
rw [hb]
ring
@[simp] theorem smoothMumford_u :
P.smoothMumford.u = P.u := rfl
@[simp] theorem smoothMumford_v :
P.smoothMumford.v = P.v := rfl
@[simp] theorem reducePoly_u :
N13GeneralizedMumfordReduction.reducePoly P.u =
(X ^ 2 + X :
N13GoodCoordinateRingTwo.K[X]) := by
rw [N13GeneralizedMumfordReduction.reducePoly_apply]
simp only [u, Polynomial.map_mul, Polynomial.map_sub,
Polynomial.map_X, Polynomial.map_C,
P.reduceBase_x₀, P.reduceBase_x₁, C_0, C_1, sub_zero]
rw [CharTwo.sub_eq_add]
ring
@[simp] theorem reducePoly_v :
N13GeneralizedMumfordReduction.reducePoly P.v = 0 := by
rw [N13GeneralizedMumfordReduction.reducePoly_apply]
simp [v, interpolate]
/-- Every divisor in the two-disk chart reduces to the fixed nonspecial
Mumford pair `(X²+X,0)`. -/
theorem reduce_smoothMumford :
(N13GeneralizedMumfordReduction.reduceSmoothMumford
P.smoothMumford).u =
(X ^ 2 + X :
N13GoodCoordinateRingTwo.K[X]) ∧
(N13GeneralizedMumfordReduction.reduceSmoothMumford
P.smoothMumford).v = 0 := by
exact ⟨P.reducePoly_u, P.reducePoly_v⟩
/-- The monic divisor polynomial remembers the ordered pair because the two
roots lie in disjoint residue disks. -/
theorem u_injective :
Function.Injective DiskPair.u := by
intro P Q hPQ
have hQ₀ : Q.u.eval P.x₀ = 0 := by
rw [← hPQ]
exact P.u_eval_x₀
have hprod₀ :
(P.x₀ - Q.x₀) * (P.x₀ - Q.x₁) = 0 := by
simpa [u] using hQ₀
have hright : P.x₀ - Q.x₁ ≠ 0 := by
intro hzero
apply (Q.cross_x₁_sub_x₀_isUnit P).ne_zero
calc
Q.x₁ - P.x₀ = -(P.x₀ - Q.x₁) := by ring
_ = 0 := by rw [hzero]; simp
have hx₀ : P.x₀ = Q.x₀ :=
sub_eq_zero.mp
((mul_eq_zero.mp hprod₀).resolve_right hright)
have hQ₁ : Q.u.eval P.x₁ = 0 := by
rw [← hPQ]
exact P.u_eval_x₁
have hprod₁ :
(P.x₁ - Q.x₀) * (P.x₁ - Q.x₁) = 0 := by
simpa [u] using hQ₁
have hleft : P.x₁ - Q.x₀ ≠ 0 :=
(P.cross_x₁_sub_x₀_isUnit Q).ne_zero
have hx₁ : P.x₁ = Q.x₁ :=
sub_eq_zero.mp
((mul_eq_zero.mp hprod₁).resolve_left hleft)
cases P
cases Q
simp_all
theorem smoothMumford_injective :
Function.Injective DiskPair.smoothMumford := by
intro P Q hPQ
apply u_injective
exact congrArg
(fun D : N13GeneralizedMumfordReduction.SmoothMumford₂ => D.u)
hPQ
/-- Coordinates centered at the distinguished pair. -/
def coord : DiskPair → Fin 2 → R₂ :=
fun Q => ![Q.x₀, Q.x₁ + 1]
@[simp] theorem coord_zero (Q : DiskPair) :
coord Q 0 = Q.x₀ := rfl
@[simp] theorem coord_one (Q : DiskPair) :
coord Q 1 = Q.x₁ + 1 := rfl
@[simp] theorem coord_basePair :
coord basePair = 0 := by
funext i
fin_cases i <;> simp [coord, basePair]
theorem coord_mem_maximal
(Q : DiskPair) (i : Fin 2) :
coord Q i ∈ maximal := by
fin_cases i
· exact Q.x₀_mem
· exact Q.x₁_add_one_mem
theorem maximal_eq_powTwoIdeal_one :
maximal =
N13TwoAdicKernelChart.powTwoIdeal 1 := by
change IsLocalRing.maximalIdeal R₂ = _
rw [PadicInt.maximalIdeal_eq_span_p,
N13TwoAdicKernelChart.powTwoIdeal, pow_one]
norm_num
theorem coord_mem_two
(Q : DiskPair) (i : Fin 2) :
coord Q i ∈
N13TwoAdicKernelChart.powTwoIdeal 1 := by
rw [← maximal_eq_powTwoIdeal_one]
exact coord_mem_maximal Q i
theorem coord_injective :
Function.Injective coord := by
intro P Q hPQ
have hx₀ := congrFun hPQ (0 : Fin 2)
have hx₁ := congrFun hPQ (1 : Fin 2)
cases P
cases Q
simp_all [coord]
end DiskPair
end
end MazurProof.N13TwoAdicAbelChartData
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13FactorRigidity
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Small-factor rigidity on the `X₁(13)` sextic
Suppose two affine functions multiply to a polynomial of degree at most two
and neither has more than a simple pole at the positive infinity. Then both
functions lie in the polynomial subring and have degree at most one.
The proof does not compare coefficients. It uses the quadratic norm and both
infinity branches. A nonzero `Y`-part forces pole degree at least three; the
two norm-degree inequalities then contradict the degree of the product.
-/
open Polynomial
open scoped LaurentSeries
namespace MazurProof.N13FactorRigidity
noncomputable section
universe u
variable (K : Type u) [Field K] [CharZero K]
private theorem three_le_normDegree_add_positiveOrder
(p q : K[X])
(hz : N13BranchNorm.linearFunction K p q ≠ 0)
(hq : q ≠ 0)
(hnorm : N13BranchNorm.normNumerator K p q ≠ 0)
(hplus : (-1 : ℤ) ≤
(N13Infinity.coordinateToLaurent K
(N13BranchNorm.linearFunction K p q)).order) :
(3 : ℤ) ≤
((N13BranchNorm.normNumerator K p q).natDegree : ℤ) +
(N13Infinity.coordinateToLaurent K
(N13BranchNorm.linearFunction K p q)).order := by
let op : ℤ :=
(N13Infinity.coordinateToLaurent K
(N13BranchNorm.linearFunction K p q)).order
let om : ℤ :=
(N13InfinityMinus.coordinateToLaurentMinus K
(N13BranchNorm.linearFunction K p q)).order
let d : ℕ := (N13BranchNorm.normNumerator K p q).natDegree
let e : ℕ := N13BranchLeading.poleDegree K p q
have he : 3 ≤ e := by
simp only [e, N13BranchLeading.poleDegree, hq, if_false]
omega
have hmin : min op om = -(e : ℤ) := by
exact N13BranchLeading.branch_min_order K p q hz
have hsum : op + om = -(d : ℤ) := by
exact N13BranchNorm.branch_orders_add K p q hnorm
have hop : (-1 : ℤ) ≤ op := hplus
have hminus : om = -(e : ℤ) := by
rcases min_choice op om with hleft | hright
· have : op = -(e : ℤ) := hleft.symm.trans hmin
omega
· exact hright.symm.trans hmin
change (3 : ℤ) ≤ (d : ℤ) + op
omega
private theorem zero_le_normDegree_add_positiveOrder
(p q : K[X])
(hz : N13BranchNorm.linearFunction K p q ≠ 0)
(hnorm : N13BranchNorm.normNumerator K p q ≠ 0)
(hplus : (-1 : ℤ) ≤
(N13Infinity.coordinateToLaurent K
(N13BranchNorm.linearFunction K p q)).order) :
(0 : ℤ) ≤
((N13BranchNorm.normNumerator K p q).natDegree : ℤ) +
(N13Infinity.coordinateToLaurent K
(N13BranchNorm.linearFunction K p q)).order := by
by_cases hq : q = 0
· subst q
have hp : p ≠ 0 := by
intro hp
apply hz
simp [N13BranchNorm.linearFunction, hp]
rw [N13BranchNorm.coordinateToLaurent_linearFunction]
simp only [map_zero, zero_mul, add_zero,
N13BranchNorm.normNumerator]
norm_num only [zero_pow, zero_mul, sub_zero]
rw [N13BranchNorm.evalPoly_order K p hp,
Polynomial.natDegree_pow]
omega
· exact le_trans (by norm_num)
(three_le_normDegree_add_positiveOrder K p q hz hq hnorm hplus)
theorem factor_pair_rigidity
(z w : N13Mumford.CoordinateRing K) (P : K[X])
(hP : P ≠ 0) (hdeg : P.natDegree ≤ 2)
(hprod :
z * w = SexticMumford.xClass (N13Mumford.model K) P)
(hzplus : (-1 : ℤ) ≤
(N13Infinity.coordinateToLaurent K z).order)
(hwplus : (-1 : ℤ) ≤
(N13Infinity.coordinateToLaurent K w).order) :
SexticMumford.coeffY (N13Mumford.model K) z = 0 ∧
SexticMumford.coeffY (N13Mumford.model K) w = 0 ∧
(SexticMumford.coeff0
(N13Mumford.model K) z).natDegree ≤ 1 ∧
(SexticMumford.coeff0
(N13Mumford.model K) w).natDegree ≤ 1 := by
let M := N13Mumford.model K
let pz := SexticMumford.coeff0 M z
let qz := SexticMumford.coeffY M z
let pw := SexticMumford.coeff0 M w
let qw := SexticMumford.coeffY M w
let Nz := N13BranchNorm.normNumerator K pz qz
let Nw := N13BranchNorm.normNumerator K pw qw
have hzlin : N13BranchNorm.linearFunction K pz qz = z := by
exact SexticMumford.recompose M z
have hwlin : N13BranchNorm.linearFunction K pw qw = w := by
exact SexticMumford.recompose M w
have hxP :
SexticMumford.xClass M P ≠ 0 :=
SexticMumford.xClass_ne_zero M hP
have hzw : z * w ≠ 0 := by rw [hprod]; exact hxP
have hz : z ≠ 0 := left_ne_zero_of_mul hzw
have hw : w ≠ 0 := right_ne_zero_of_mul hzw
have hNzEq :
SexticMumford.norm M z = SexticMumford.xClass M Nz := by
simpa [Nz, pz, qz, M, N13BranchNorm.normNumerator] using
SexticMumford.norm_eq_xClass_coeff M z
have hNwEq :
SexticMumford.norm M w = SexticMumford.xClass M Nw := by
simpa [Nw, pw, qw, M, N13BranchNorm.normNumerator] using
SexticMumford.norm_eq_xClass_coeff M w
have hnormProd := congrArg (SexticMumford.norm M) hprod
have hpoly : Nz * Nw = P ^ 2 := by
apply SexticMumford.xClass_injective M
rw [SexticMumford.xClass_mul]
calc
SexticMumford.xClass M Nz * SexticMumford.xClass M Nw =
SexticMumford.norm M z * SexticMumford.norm M w := by
rw [hNzEq, hNwEq]
_ = SexticMumford.norm M (z * w) :=
(SexticMumford.norm_mul M z w).symm
_ = SexticMumford.norm M (SexticMumford.xClass M P) := hnormProd
_ = SexticMumford.xClass M (P ^ 2) :=
SexticMumford.norm_xClass M P
have hNN : Nz * Nw ≠ 0 := by
rw [hpoly]
exact pow_ne_zero 2 hP
have hNz : Nz ≠ 0 := left_ne_zero_of_mul hNN
have hNw : Nw ≠ 0 := right_ne_zero_of_mul hNN
have hdegree :
Nz.natDegree + Nw.natDegree = 2 * P.natDegree := by
calc
Nz.natDegree + Nw.natDegree = (Nz * Nw).natDegree :=
(Polynomial.natDegree_mul hNz hNw).symm
_ = (P ^ 2).natDegree := by rw [hpoly]
_ = 2 * P.natDegree := Polynomial.natDegree_pow P 2
have hplusSum :
(N13Infinity.coordinateToLaurent K z).order +
(N13Infinity.coordinateToLaurent K w).order =
-(P.natDegree : ℤ) := by
have hzL :
N13Infinity.coordinateToLaurent K z ≠ 0 :=
by simpa using (N13Infinity.coordinateToLaurent_injective K).ne hz
have hwL :
N13Infinity.coordinateToLaurent K w ≠ 0 :=
by simpa using (N13Infinity.coordinateToLaurent_injective K).ne hw
have hmapped := congrArg (N13Infinity.coordinateToLaurent K) hprod
rw [map_mul, N13Infinity.coordinateToLaurent_xClass] at hmapped
calc
(N13Infinity.coordinateToLaurent K z).order +
(N13Infinity.coordinateToLaurent K w).order =
(N13Infinity.coordinateToLaurent K z *
N13Infinity.coordinateToLaurent K w).order :=
(HahnSeries.order_mul hzL hwL).symm
_ = (N13BranchNorm.evalPoly K P).order := by
rw [hmapped]
rfl
_ = -(P.natDegree : ℤ) :=
N13BranchNorm.evalPoly_order K P hP
have hqz : qz = 0 := by
by_contra hqz
have hstrong :=
three_le_normDegree_add_positiveOrder K pz qz
(hzlin.trans_ne hz) hqz hNz (by simpa only [hzlin] using hzplus)
have hweak :=
zero_le_normDegree_add_positiveOrder K pw qw
(hwlin.trans_ne hw) hNw (by simpa only [hwlin] using hwplus)
have hdegreeZ :
(Nz.natDegree : ℤ) + (Nw.natDegree : ℤ) =
2 * (P.natDegree : ℤ) := by
exact_mod_cast hdegree
rw [hzlin] at hstrong
rw [hwlin] at hweak
change (3 : ℤ) ≤ (Nz.natDegree : ℤ) +
(N13Infinity.coordinateToLaurent K z).order at hstrong
change (0 : ℤ) ≤ (Nw.natDegree : ℤ) +
(N13Infinity.coordinateToLaurent K w).order at hweak
omega
have hqw : qw = 0 := by
by_contra hqw
have hweak :=
zero_le_normDegree_add_positiveOrder K pz qz
(hzlin.trans_ne hz) hNz (by simpa only [hzlin] using hzplus)
have hstrong :=
three_le_normDegree_add_positiveOrder K pw qw
(hwlin.trans_ne hw) hqw hNw (by simpa only [hwlin] using hwplus)
have hdegreeZ :
(Nz.natDegree : ℤ) + (Nw.natDegree : ℤ) =
2 * (P.natDegree : ℤ) := by
exact_mod_cast hdegree
rw [hzlin] at hweak
rw [hwlin] at hstrong
change (0 : ℤ) ≤ (Nz.natDegree : ℤ) +
(N13Infinity.coordinateToLaurent K z).order at hweak
change (3 : ℤ) ≤ (Nw.natDegree : ℤ) +
(N13Infinity.coordinateToLaurent K w).order at hstrong
omega
have hpz : pz ≠ 0 := by
intro hpz
apply hz
rw [← hzlin]
simp [N13BranchNorm.linearFunction, hpz, hqz]
have hpw : pw ≠ 0 := by
intro hpw
apply hw
rw [← hwlin]
simp [N13BranchNorm.linearFunction, hpw, hqw]
have hdegz : pz.natDegree ≤ 1 := by
have hzorder := N13BranchNorm.evalPoly_order K pz hpz
rw [← hzlin, N13BranchNorm.coordinateToLaurent_linearFunction] at hzplus
simp only [hqz, map_zero, zero_mul, add_zero] at hzplus
omega
have hdegw : pw.natDegree ≤ 1 := by
have hworder := N13BranchNorm.evalPoly_order K pw hpw
rw [← hwlin, N13BranchNorm.coordinateToLaurent_linearFunction] at hwplus
simp only [hqw, map_zero, zero_mul, add_zero] at hwplus
omega
exact ⟨hqz, hqw, hdegz, hdegw⟩
private theorem minus_order_le_neg_three_of_coeffY_ne_zero
(p q : K[X])
(hz : N13BranchNorm.linearFunction K p q ≠ 0)
(hq : q ≠ 0)
(hplus : (-2 : ℤ) ≤
(N13Infinity.coordinateToLaurent K
(N13BranchNorm.linearFunction K p q)).order) :
(N13InfinityMinus.coordinateToLaurentMinus K
(N13BranchNorm.linearFunction K p q)).order ≤ -3 := by
have hmin :=
N13BranchLeading.branch_min_order K p q hz
have hpole :
3 ≤ N13BranchLeading.poleDegree K p q := by
simp only [N13BranchLeading.poleDegree, hq, if_false]
omega
omega
/-- If two affine functions with at most double poles at the positive
infinity multiply to a polynomial of degree at most four, neither function
has a `Y`-part. If both had a `Y`-part, both negative-branch pole orders
would be at most `-3`, whereas their product has pole order at least `-4`.
Once one `Y`-part vanishes, the rank-two coefficient decomposition forces
the other to vanish as well. -/
theorem factor_pair_coeffY_eq_zero
(z w : N13Mumford.CoordinateRing K) (P : K[X])
(hP : P ≠ 0) (hdeg : P.natDegree ≤ 4)
(hprod :
z * w = SexticMumford.xClass (N13Mumford.model K) P)
(hzplus : (-2 : ℤ) ≤
(N13Infinity.coordinateToLaurent K z).order)
(hwplus : (-2 : ℤ) ≤
(N13Infinity.coordinateToLaurent K w).order) :
SexticMumford.coeffY (N13Mumford.model K) z = 0 ∧
SexticMumford.coeffY (N13Mumford.model K) w = 0 := by
let M := N13Mumford.model K
let pz := SexticMumford.coeff0 M z
let qz := SexticMumford.coeffY M z
let pw := SexticMumford.coeff0 M w
let qw := SexticMumford.coeffY M w
have hzlin : N13BranchNorm.linearFunction K pz qz = z :=
SexticMumford.recompose M z
have hwlin : N13BranchNorm.linearFunction K pw qw = w :=
SexticMumford.recompose M w
have hxP :
SexticMumford.xClass M P ≠ 0 :=
SexticMumford.xClass_ne_zero M hP
have hzw : z * w ≠ 0 := by
rw [hprod]
exact hxP
have hz : z ≠ 0 := left_ne_zero_of_mul hzw
have hw : w ≠ 0 := right_ne_zero_of_mul hzw
have hzMinus :
N13InfinityMinus.coordinateToLaurentMinus K z ≠ 0 :=
by simpa using
(N13InfinityMinus.coordinateToLaurentMinus_injective K).ne hz
have hwMinus :
N13InfinityMinus.coordinateToLaurentMinus K w ≠ 0 :=
by simpa using
(N13InfinityMinus.coordinateToLaurentMinus_injective K).ne hw
have hminusSum :
(N13InfinityMinus.coordinateToLaurentMinus K z).order +
(N13InfinityMinus.coordinateToLaurentMinus K w).order =
-(P.natDegree : ℤ) := by
have hmapped :=
congrArg
(N13InfinityMinus.coordinateToLaurentMinus K) hprod
rw [map_mul,
N13InfinityMinus.coordinateToLaurentMinus_xClass] at hmapped
calc
(N13InfinityMinus.coordinateToLaurentMinus K z).order +
(N13InfinityMinus.coordinateToLaurentMinus K w).order =
(N13InfinityMinus.coordinateToLaurentMinus K z *
N13InfinityMinus.coordinateToLaurentMinus K w).order :=
(HahnSeries.order_mul hzMinus hwMinus).symm
_ = (N13BranchNorm.evalPoly K P).order := by
rw [hmapped]
rfl
_ = -(P.natDegree : ℤ) :=
N13BranchNorm.evalPoly_order K P hP
have hone : qz = 0 ∨ qw = 0 := by
by_contra hboth
push Not at hboth
have hzBound :=
minus_order_le_neg_three_of_coeffY_ne_zero
K pz qz (hzlin.trans_ne hz) hboth.1
(by simpa only [hzlin] using hzplus)
have hwBound :=
minus_order_le_neg_three_of_coeffY_ne_zero
K pw qw (hwlin.trans_ne hw) hboth.2
(by simpa only [hwlin] using hwplus)
rw [hzlin] at hzBound
rw [hwlin] at hwBound
have hdegZ : (P.natDegree : ℤ) ≤ 4 := by
exact_mod_cast hdeg
omega
rcases hone with hqz | hqw
· have hzpoly : z = SexticMumford.xClass M pz := by
simpa [M, N13BranchNorm.linearFunction, hqz] using hzlin.symm
have hpz : pz ≠ 0 := by
intro hpz
apply hz
rw [hzpoly, hpz, SexticMumford.xClass_zero]
have hcoeff : pz * qw = 0 := by
have hcoeff' := congrArg (SexticMumford.coeffY M) hprod
rw [hzpoly, SexticMumford.coeffY_xClass_mul] at hcoeff'
simpa [M, qw] using hcoeff'
exact ⟨hqz, (mul_eq_zero.mp hcoeff).resolve_left hpz⟩
· have hwpoly : w = SexticMumford.xClass M pw := by
simpa [M, N13BranchNorm.linearFunction, hqw] using hwlin.symm
have hpw : pw ≠ 0 := by
intro hpw
apply hw
rw [hwpoly, hpw, SexticMumford.xClass_zero]
have hprod' :
w * z = SexticMumford.xClass (N13Mumford.model K) P := by
simpa [mul_comm] using hprod
have hcoeff : pw * qz = 0 := by
have hcoeff' := congrArg (SexticMumford.coeffY M) hprod'
rw [hwpoly, SexticMumford.coeffY_xClass_mul] at hcoeff'
simpa [M, qz] using hcoeff'
exact ⟨(mul_eq_zero.mp hcoeff).resolve_left hpw, hqw⟩
end
end MazurProof.N13FactorRigidity
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.SexticMumfordPrincipalNumerator
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Integral numerators from principal relations
For a principal relation between two Mumford ideals, multiplying the
principal generator by the first `u`-polynomial clears all affine
denominator. The proof is ideal-theoretic: the first Mumford ideal times its
hyperelliptic conjugate is the principal ideal `(u)`.
-/
open scoped nonZeroDivisors
namespace MazurProof.SexticMumford
noncomputable section
universe u
variable {K : Type u} [Field K]
theorem exists_numerator_mem_of_principal_relation
(M : Model K) (D₁ D₂ : SemiMumford M)
(α : (FunctionField M)ˣ)
(h :
mumfordIdealUnit M D₁ *
toPrincipalIdeal (CoordinateRing M) (FunctionField M) α =
mumfordIdealUnit M D₂) :
∃ z : CoordinateRing M,
z ∈ mumfordIdeal M D₂.u D₂.v ∧
algebraMap (CoordinateRing M) (FunctionField M) z =
(α : FunctionField M) *
algebraMap (CoordinateRing M) (FunctionField M)
(xClass M D₁.u) := by
have hx :
algebraMap (CoordinateRing M) (FunctionField M) (xClass M D₁.u) ∈
(mumfordIdealUnit M D₁ :
FractionalIdeal (CoordinateRing M)⁰ (FunctionField M)) := by
rw [coe_mumfordIdealUnit]
exact FractionalIdeal.mem_coeIdeal_of_mem (CoordinateRing M)⁰
(xClass_mem_mumfordIdeal M D₁.u D₁.v)
have hα :
(α : FunctionField M) ∈
(toPrincipalIdeal (CoordinateRing M) (FunctionField M) α :
FractionalIdeal (CoordinateRing M)⁰ (FunctionField M)) := by
rw [coe_toPrincipalIdeal]
exact FractionalIdeal.mem_spanSingleton_self _ _
have hprod := FractionalIdeal.mul_mem_mul hx hα
have hfrac := congrArg
(fun U : InvFrac M =>
(U : FractionalIdeal (CoordinateRing M)⁰ (FunctionField M))) h
rw [Units.val_mul, coe_toPrincipalIdeal, coe_mumfordIdealUnit,
coe_mumfordIdealUnit] at hfrac
rw [coe_mumfordIdealUnit, coe_toPrincipalIdeal] at hprod
rw [hfrac] at hprod
obtain ⟨z, hzmem, hzeq⟩ :=
(FractionalIdeal.mem_coeIdeal (CoordinateRing M)⁰).mp hprod
exact ⟨z, hzmem, by simpa [mul_comm] using hzeq⟩
theorem exists_integral_numerator_of_principal_relation
(M : Model K) (D₁ D₂ : SemiMumford M)
(α : (FunctionField M)ˣ)
(h :
mumfordIdealUnit M D₁ *
toPrincipalIdeal (CoordinateRing M) (FunctionField M) α =
mumfordIdealUnit M D₂) :
∃ z : CoordinateRing M,
algebraMap (CoordinateRing M) (FunctionField M) z =
(α : FunctionField M) *
algebraMap (CoordinateRing M) (FunctionField M)
(xClass M D₁.u) := by
obtain ⟨z, -, hz⟩ :=
exists_numerator_mem_of_principal_relation M D₁ D₂ α h
exact ⟨z, hz⟩
theorem reverse_principal_relation
(M : Model K) (D₁ D₂ : SemiMumford M)
(α : (FunctionField M)ˣ)
(h :
mumfordIdealUnit M D₁ *
toPrincipalIdeal (CoordinateRing M) (FunctionField M) α =
mumfordIdealUnit M D₂) :
mumfordIdealUnit M D₂ *
toPrincipalIdeal (CoordinateRing M) (FunctionField M) α⁻¹ =
mumfordIdealUnit M D₁ := by
rw [← h]
simp only [mul_assoc, map_inv, mul_inv_cancel, mul_one]
theorem exists_integral_conumerator_of_principal_relation
(M : Model K) (D₁ D₂ : SemiMumford M)
(α : (FunctionField M)ˣ)
(h :
mumfordIdealUnit M D₁ *
toPrincipalIdeal (CoordinateRing M) (FunctionField M) α =
mumfordIdealUnit M D₂) :
∃ w : CoordinateRing M,
algebraMap (CoordinateRing M) (FunctionField M) w =
(↑α⁻¹ : FunctionField M) *
algebraMap (CoordinateRing M) (FunctionField M)
(xClass M D₂.u) := by
exact exists_integral_numerator_of_principal_relation M D₂ D₁ α⁻¹
(reverse_principal_relation M D₁ D₂ α h)
theorem exists_integral_factor_pair_of_principal_relation
(M : Model K) (D₁ D₂ : SemiMumford M)
(α : (FunctionField M)ˣ)
(h :
mumfordIdealUnit M D₁ *
toPrincipalIdeal (CoordinateRing M) (FunctionField M) α =
mumfordIdealUnit M D₂) :
∃ z w : CoordinateRing M,
z ∈ mumfordIdeal M D₂.u D₂.v ∧
w ∈ mumfordIdeal M D₁.u D₁.v ∧
z * w = xClass M (D₁.u * D₂.u) ∧
algebraMap (CoordinateRing M) (FunctionField M) z =
(α : FunctionField M) *
algebraMap (CoordinateRing M) (FunctionField M)
(xClass M D₁.u) ∧
algebraMap (CoordinateRing M) (FunctionField M) w =
(↑α⁻¹ : FunctionField M) *
algebraMap (CoordinateRing M) (FunctionField M)
(xClass M D₂.u) := by
obtain ⟨z, hzmem, hzeq⟩ :=
exists_numerator_mem_of_principal_relation M D₁ D₂ α h
obtain ⟨w, hwmem, hweq⟩ :=
exists_numerator_mem_of_principal_relation M D₂ D₁ α⁻¹
(reverse_principal_relation M D₁ D₂ α h)
refine ⟨z, w, hzmem, hwmem, ?_, hzeq, hweq⟩
apply IsFractionRing.injective (CoordinateRing M) (FunctionField M)
rw [map_mul, hzeq, hweq, xClass_mul, map_mul]
change
((α : FunctionField M) *
algebraMap (CoordinateRing M) (FunctionField M) (xClass M D₁.u)) *
((↑α⁻¹ : FunctionField M) *
algebraMap (CoordinateRing M) (FunctionField M) (xClass M D₂.u)) =
algebraMap (CoordinateRing M) (FunctionField M) (xClass M D₁.u) *
algebraMap (CoordinateRing M) (FunctionField M) (xClass M D₂.u)
rw [Units.val_inv_eq_inv_val]
field_simp
end
end MazurProof.SexticMumford
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.SexticMumfordPrincipalScale
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Cancelling a principal scale between Mumford ideals
If a principal fractional-ideal relation scales the first polynomial
generator to a unit multiple of the second, the associated integral
Mumford ideals satisfy the cross-multiplied equality. Contracting that
equality to the polynomial subring recovers equality of the monic
`u`-polynomials.
-/
open scoped nonZeroDivisors
namespace MazurProof.SexticMumford
noncomputable section
universe u v
theorem scaled_ideal_eq_of_principal_scale
{R : Type u} [CommRing R]
{L : Type v} [Field L] [Algebra R L] [IsFractionRing R L]
(I₁ I₂ : Ideal R) (α : Lˣ) (u₁ u₂ c d : R)
(hIdeal :
(I₁ : FractionalIdeal R⁰ L) *
FractionalIdeal.spanSingleton R⁰ (α : L) = I₂)
(hscale : (α : L) * algebraMap R L u₁ =
algebraMap R L u₂ * algebraMap R L c)
(hunit : c * d = 1) :
I₁ * Ideal.span ({u₂} : Set R) =
I₂ * Ideal.span ({u₁} : Set R) := by
apply (FractionalIdeal.coeIdeal_inj (K := L)).mp
have hc : IsUnit c := IsUnit.of_mul_eq_one d hunit
have hspan_c :
FractionalIdeal.spanSingleton R⁰ (algebraMap R L c) = 1 := by
calc
FractionalIdeal.spanSingleton R⁰ (algebraMap R L c) =
(Ideal.span ({c} : Set R) : FractionalIdeal R⁰ L) :=
(FractionalIdeal.coeIdeal_span_singleton c).symm
_ = (⊤ : Ideal R) := by
rw [Ideal.span_singleton_eq_top.mpr hc]
_ = 1 := by simp
calc
((I₁ * Ideal.span ({u₂} : Set R) : Ideal R) :
FractionalIdeal R⁰ L) =
(I₁ : FractionalIdeal R⁰ L) *
(Ideal.span ({u₂} : Set R) : FractionalIdeal R⁰ L) :=
FractionalIdeal.coeIdeal_mul I₁ (Ideal.span ({u₂} : Set R))
_ =
(I₁ : FractionalIdeal R⁰ L) *
FractionalIdeal.spanSingleton R⁰ (algebraMap R L u₂) := by
rw [FractionalIdeal.coeIdeal_span_singleton]
_ =
(I₁ : FractionalIdeal R⁰ L) *
FractionalIdeal.spanSingleton R⁰ (algebraMap R L u₂) *
FractionalIdeal.spanSingleton R⁰ (algebraMap R L c) := by
rw [hspan_c, mul_one]
_ =
(I₁ : FractionalIdeal R⁰ L) *
FractionalIdeal.spanSingleton R⁰
(algebraMap R L u₂ * algebraMap R L c) := by
rw [mul_assoc, FractionalIdeal.spanSingleton_mul_spanSingleton]
_ =
(I₁ : FractionalIdeal R⁰ L) *
FractionalIdeal.spanSingleton R⁰
((α : L) * algebraMap R L u₁) := by
rw [hscale]
_ =
(I₁ : FractionalIdeal R⁰ L) *
(FractionalIdeal.spanSingleton R⁰ (α : L) *
FractionalIdeal.spanSingleton R⁰ (algebraMap R L u₁)) := by
rw [FractionalIdeal.spanSingleton_mul_spanSingleton]
_ =
((I₁ : FractionalIdeal R⁰ L) *
FractionalIdeal.spanSingleton R⁰ (α : L)) *
FractionalIdeal.spanSingleton R⁰ (algebraMap R L u₁) := by
rw [mul_assoc]
_ =
(I₂ : FractionalIdeal R⁰ L) *
FractionalIdeal.spanSingleton R⁰ (algebraMap R L u₁) := by
rw [hIdeal]
_ =
(I₂ : FractionalIdeal R⁰ L) *
(Ideal.span ({u₁} : Set R) : FractionalIdeal R⁰ L) := by
rw [FractionalIdeal.coeIdeal_span_singleton]
_ =
((I₂ * Ideal.span ({u₁} : Set R) : Ideal R) :
FractionalIdeal R⁰ L) := by
exact
(FractionalIdeal.coeIdeal_mul I₂
(Ideal.span ({u₁} : Set R))).symm
theorem mumford_u_eq_of_principal_scale
{K : Type u} [Field K] (M : Model K)
(D₁ D₂ : SemiMumford M) (α : (FunctionField M)ˣ)
(c d : CoordinateRing M)
(hIdeal :
mumfordIdealUnit M D₁ *
toPrincipalIdeal (CoordinateRing M) (FunctionField M) α =
mumfordIdealUnit M D₂)
(hscale :
(α : FunctionField M) *
algebraMap (CoordinateRing M) (FunctionField M) (xClass M D₁.u) =
algebraMap (CoordinateRing M) (FunctionField M) (xClass M D₂.u) *
algebraMap (CoordinateRing M) (FunctionField M) c)
(hunit : c * d = 1) :
D₁.u = D₂.u := by
have hfrac := congrArg
(fun U : InvFrac M =>
(U : FractionalIdeal (CoordinateRing M)⁰ (FunctionField M))) hIdeal
rw [Units.val_mul, coe_toPrincipalIdeal,
coe_mumfordIdealUnit, coe_mumfordIdealUnit] at hfrac
have hscaled := scaled_ideal_eq_of_principal_scale
(mumfordIdeal M D₁.u D₁.v)
(mumfordIdeal M D₂.u D₂.v)
α (xClass M D₁.u) (xClass M D₂.u) c d
hfrac hscale hunit
have h₁₂ := u_dvd_of_scaled_mumfordIdeal_eq
M D₁.u D₁.v D₂.u D₂.v hscaled
have h₂₁ := u_dvd_of_scaled_mumfordIdeal_eq
M D₂.u D₂.v D₁.u D₁.v hscaled.symm
exact Polynomial.eq_of_monic_of_associated D₁.u_monic D₂.u_monic
(associated_of_dvd_dvd h₁₂ h₂₁)
end
end MazurProof.SexticMumford
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.SexticMumfordRecover
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Recovering Mumford polynomials from their ideals
Contraction to the polynomial subring recovers the monic polynomial `u` from
the ideal `(u, Y - v)`, and the canonical remainder condition then recovers
`v`.
-/
open Polynomial
namespace MazurProof.SexticMumford
noncomputable section
universe u
variable {K : Type u} [Field K]
variable (M : Model K)
theorem u_eq_of_mumfordIdeal_eq {D₁ D₂ : SemiMumford M}
(h : mumfordIdeal M D₁.u D₁.v = mumfordIdeal M D₂.u D₂.v) :
D₁.u = D₂.u := by
have hc := congrArg (fun I : Ideal (CoordinateRing M) ↦
I.comap (xClassHom M)) h
rw [mumfordIdeal_comap_base M D₁, mumfordIdeal_comap_base M D₂] at hc
exact eq_of_monic_of_associated D₁.u_monic D₂.u_monic
(Ideal.span_singleton_eq_span_singleton.mp hc)
theorem v_eq_of_mumfordIdeal_eq_of_u_eq {D₁ D₂ : SemiMumford M}
(hu : D₁.u = D₂.u)
(h : mumfordIdeal M D₁.u D₁.v = mumfordIdeal M D₂.u D₂.v) :
D₁.v = D₂.v := by
have hy₂ : ySubClass M D₂.v ∈ mumfordIdeal M D₁.u D₁.v := by
rw [h]
exact Ideal.subset_span (by simp)
have hker : ySubClass M D₂.v ∈ RingHom.ker (mumfordEval M D₁) := by
rw [ker_mumfordEval M D₁]
exact hy₂
have heval : mumfordEval M D₁ (ySubClass M D₂.v) = 0 :=
RingHom.mem_ker.mp hker
have hquot : Ideal.Quotient.mk (Ideal.span ({D₁.u} : Set K[X]))
(D₁.v - D₂.v) = 0 := by
simpa only [ySubClass, map_sub, mumfordEval_yClass,
mumfordEval_xClass, sub_eq_zero] using heval
have hdvd : D₁.u ∣ D₁.v - D₂.v :=
Ideal.mem_span_singleton.mp
(Ideal.Quotient.eq_zero_iff_mem.mp hquot)
have hmod : D₁.v % D₁.u = D₂.v % D₁.u :=
mod_eq_of_dvd_sub hdvd
rw [D₁.v_reduced, hu, D₂.v_reduced] at hmod
exact hmod
theorem uv_eq_of_mumfordIdeal_eq {D₁ D₂ : SemiMumford M}
(h : mumfordIdeal M D₁.u D₁.v = mumfordIdeal M D₂.u D₂.v) :
D₁.u = D₂.u ∧ D₁.v = D₂.v := by
have hu := u_eq_of_mumfordIdeal_eq M h
exact ⟨hu, v_eq_of_mumfordIdeal_eq_of_u_eq M hu h⟩
theorem mumford_eq_of_ideal_eq_of_nInf_eq {D₁ D₂ : Mumford M}
(hIdeal : mumfordIdeal M D₁.u D₁.v = mumfordIdeal M D₂.u D₂.v)
(hInf : D₁.nInf = D₂.nInf) : D₁ = D₂ := by
obtain ⟨hu, hv⟩ := uv_eq_of_mumfordIdeal_eq M
(D₁ := D₁.toSemi) (D₂ := D₂.toSemi) hIdeal
cases D₁
cases D₂
simp_all
end
end MazurProof.SexticMumford
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13MumfordRigidity
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Constant-principal rigidity for balanced `X₁(13)` Mumford data
Once a principal multiplier between two balanced representatives is known to
be constant, its fractional ideal and its order at the positive infinity are
both trivial. The generic ideal-kernel calculation then recovers `u`, `v`,
and the infinity coordinate.
The remaining normal-form uniqueness problem is therefore geometric: prove
that a function with the relevant small pole bounds is constant.
-/
open scoped nonZeroDivisors
namespace MazurProof.N13Mumford
open SexticMumford
noncomputable section
universe u
variable (K : Type u) [Field K] [CharZero K]
theorem principal_between_balanced_of_constant
{D₁ D₂ : Mumford K} {α : (FunctionField K)ˣ}
(c : Kˣ)
(hα : α = N13Infinity.functionConstUnit K c)
(hIdeal :
mumfordIdealUnit (model K) D₁.toSemi *
toPrincipalIdeal (CoordinateRing K) (FunctionField K) α =
mumfordIdealUnit (model K) D₂.toSemi)
(hInf :
Multiplicative.ofAdd ((D₁.nInf : ℤ) - 1) *
(N13Infinity.positiveInfinityOrder K).ordPlus α =
Multiplicative.ofAdd ((D₂.nInf : ℤ) - 1)) :
D₁ = D₂ := by
subst α
have hUnits :
mumfordIdealUnit (model K) D₁.toSemi =
mumfordIdealUnit (model K) D₂.toSemi := by
simpa only [N13Infinity.principalIdeal_functionConstUnit, mul_one] using
hIdeal
have hFrac := congrArg
(fun I : InvFrac (model K) ↦
(I : FractionalIdeal (CoordinateRing K)⁰ (FunctionField K))) hUnits
simp only [coe_mumfordIdealUnit] at hFrac
have hIdeal' :
mumfordIdeal (model K) D₁.u D₁.v =
mumfordIdeal (model K) D₂.u D₂.v :=
FractionalIdeal.coeIdeal_inj.mp hFrac
have hInf' :
Multiplicative.ofAdd ((D₁.nInf : ℤ) - 1) =
Multiplicative.ofAdd ((D₂.nInf : ℤ) - 1) := by
simpa only [N13Infinity.ordPlus_functionConstUnit, mul_one] using hInf
have hz : ((D₁.nInf : ℤ) - 1) = ((D₂.nInf : ℤ) - 1) :=
Multiplicative.ofAdd.injective hInf'
have hn : D₁.nInf = D₂.nInf := by omega
exact mumford_eq_of_ideal_eq_of_nInf_eq (model K) hIdeal' hn
end
end MazurProof.N13Mumford
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.SexticMumfordGroup
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# The Mumford group law from oriented Picard normal forms
Given unique balanced Mumford representatives of the oriented Picard classes,
transport the ambient abelian group structure to those representatives.
-/
namespace MazurProof.SexticMumford
noncomputable section
universe u
variable {K : Type u} [Field K]
variable (M : Model K) (O : InfinityOrder M)
class NormalFormData (O : outParam (InfinityOrder M)) : Prop where
existsUnique : ∀ c : ConcretePic M O,
∃! D : Mumford M, classOf M O D = c
def normalize [NormalFormData M O] (c : ConcretePic M O) : Mumford M :=
Classical.choose (NormalFormData.existsUnique c)
@[simp]
theorem classOf_normalize [NormalFormData M O] (c : ConcretePic M O) :
classOf M O (normalize M O c) = c :=
(Classical.choose_spec (NormalFormData.existsUnique c)).1
theorem normalize_eq_of_class [NormalFormData M O]
(c : ConcretePic M O) (D : Mumford M) (hD : classOf M O D = c) :
normalize M O c = D := by
exact ((Classical.choose_spec (NormalFormData.existsUnique c)).2 D hD).symm
theorem classOf_injective [NormalFormData M O] :
Function.Injective (classOf M O) := by
intro D E hDE
have hD : normalize M O (classOf M O E) = D :=
normalize_eq_of_class M O (classOf M O E) D hDE
have hE : normalize M O (classOf M O E) = E :=
normalize_eq_of_class M O (classOf M O E) E rfl
exact hD.symm.trans hE
def normalFormEquiv [NormalFormData M O] : Mumford M ≃ ConcretePic M O where
toFun := classOf M O
invFun := normalize M O
left_inv D := by
exact normalize_eq_of_class M O (classOf M O D) D rfl
right_inv := classOf_normalize M O
/-- The group law is inherited from the oriented Picard group. The
orientation in `NormalFormData` is an output parameter, so this instance is
selected only after the oriented normal-form data have been fixed. -/
noncomputable instance instAddCommGroupMumford [NormalFormData M O] :
AddCommGroup (Mumford M) :=
Equiv.addCommGroup (normalFormEquiv M O)
def classEquiv [NormalFormData M O] : Mumford M ≃+ ConcretePic M O :=
Equiv.addEquiv (normalFormEquiv M O)
@[simp]
theorem classEquiv_apply [NormalFormData M O] (D : Mumford M) :
classEquiv M O D = classOf M O D := by
rfl
@[simp]
theorem classOf_add [NormalFormData M O] (D E : Mumford M) :
classOf M O (D + E) = classOf M O D + classOf M O E := by
simpa only [classEquiv_apply] using (classEquiv M O).map_add D E
@[simp]
theorem classOf_neg [NormalFormData M O] (D : Mumford M) :
classOf M O (-D) = -classOf M O D := by
simpa only [classEquiv_apply] using (classEquiv M O).map_neg D
@[simp]
theorem classOf_nsmul [NormalFormData M O] (n : ℕ) (D : Mumford M) :
classOf M O (n • D) = n • classOf M O D := by
simpa only [classEquiv_apply] using map_nsmul (classEquiv M O) n D
theorem group_zero_eq_balanced_zero [NormalFormData M O] :
(0 : Mumford M) = zero M := by
apply classOf_injective M O
calc
classOf M O 0 = classEquiv M O 0 := (classEquiv_apply M O 0).symm
_ = 0 := map_zero (classEquiv M O)
_ = classOf M O (zero M) := (classOf_zero M O).symm
end
end MazurProof.SexticMumford
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13SmallMumfordRigidity
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Rigidity of balanced Mumford representatives on `X₁(13)`
For balanced representatives, a principal relation clears to two affine
factors whose product has degree at most four. The two-infinity pole-order
argument forces both factors into the polynomial subring. Ideal
contraction then identifies the monic `u`-polynomials, so the principal
function is constant and the balanced representatives agree.
Together with structural infinity balancing, this gives the full unique
Mumford normal form and hence the Abel--Jacobi embedding of the curve,
without coefficient enumeration.
-/
open Polynomial
open scoped LaurentSeries nonZeroDivisors
namespace MazurProof.N13SmallMumfordRigidity
noncomputable section
universe u
variable (K : Type u) [Field K] [CharZero K]
open SexticMumford
private theorem numerator_order
(α : (N13Mumford.FunctionField K)ˣ)
(u : K[X]) (z : N13Mumford.CoordinateRing K)
(hu : u ≠ 0)
(hz :
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) z =
(α : N13Mumford.FunctionField K) *
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K)
(xClass (N13Mumford.model K) u)) :
(N13Infinity.coordinateToLaurent K z).order =
(N13Infinity.functionFieldToLaurent K
(α : N13Mumford.FunctionField K)).order -
(u.natDegree : ℤ) := by
have hα :
N13Infinity.functionFieldToLaurent K
(α : N13Mumford.FunctionField K) ≠ 0 :=
by simpa only [map_zero] using
(N13Infinity.functionFieldToLaurent_injective K).ne α.ne_zero
have huL : N13BranchNorm.evalPoly K u ≠ 0 :=
N13BranchNorm.evalPoly_ne_zero K hu
have hmapped := congrArg (N13Infinity.functionFieldToLaurent K) hz
rw [map_mul, N13Infinity.functionFieldToLaurent_algebraMap,
N13Infinity.functionFieldToLaurent_algebraMap,
N13Infinity.coordinateToLaurent_xClass] at hmapped
change
N13Infinity.coordinateToLaurent K z =
N13Infinity.functionFieldToLaurent K
(α : N13Mumford.FunctionField K) *
N13BranchNorm.evalPoly K u at hmapped
calc
(N13Infinity.coordinateToLaurent K z).order =
(N13Infinity.functionFieldToLaurent K
(α : N13Mumford.FunctionField K) *
N13BranchNorm.evalPoly K u).order := by rw [hmapped]
_ =
(N13Infinity.functionFieldToLaurent K
(α : N13Mumford.FunctionField K)).order +
(N13BranchNorm.evalPoly K u).order :=
HahnSeries.order_mul hα huL
_ = _ := by
rw [N13BranchNorm.evalPoly_order K u hu]
omega
private theorem inverse_order
(α : (N13Mumford.FunctionField K)ˣ) :
(N13Infinity.functionFieldToLaurent K
(↑α⁻¹ : N13Mumford.FunctionField K)).order =
-(N13Infinity.functionFieldToLaurent K
(α : N13Mumford.FunctionField K)).order := by
let a :=
N13Infinity.functionFieldToLaurent K
(α : N13Mumford.FunctionField K)
let b :=
N13Infinity.functionFieldToLaurent K
(↑α⁻¹ : N13Mumford.FunctionField K)
have ha : a ≠ 0 :=
by simpa only [a, map_zero] using
(N13Infinity.functionFieldToLaurent_injective K).ne α.ne_zero
have hb : b ≠ 0 := by
simpa only [b, map_zero] using
(N13Infinity.functionFieldToLaurent_injective K).ne
(Units.ne_zero α⁻¹)
have hab : a * b = 1 := by
simp [a, b]
have hord := HahnSeries.order_mul ha hb
rw [hab, HahnSeries.order_one] at hord
change b.order = -a.order
omega
private theorem orientation_order
(D₁ D₂ : Mumford (N13Mumford.model K))
(α : (N13Mumford.FunctionField K)ˣ)
(hInf :
Multiplicative.ofAdd ((D₁.nInf : ℤ) - 1) *
(N13Infinity.positiveInfinityOrder K).ordPlus α =
Multiplicative.ofAdd ((D₂.nInf : ℤ) - 1)) :
(N13Infinity.functionFieldToLaurent K
(α : N13Mumford.FunctionField K)).order =
(D₂.nInf : ℤ) - D₁.nInf := by
change
Multiplicative.ofAdd
(((D₁.nInf : ℤ) - 1) +
(N13Infinity.functionFieldToLaurent K
(α : N13Mumford.FunctionField K)).order) =
Multiplicative.ofAdd ((D₂.nInf : ℤ) - 1) at hInf
have h := Multiplicative.ofAdd.injective hInf
omega
private theorem principal_is_constant
(D₁ D₂ : Mumford (N13Mumford.model K))
(α : (N13Mumford.FunctionField K)ˣ)
(hIdeal :
mumfordIdealUnit (N13Mumford.model K) D₁.toSemi *
toPrincipalIdeal (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) α =
mumfordIdealUnit (N13Mumford.model K) D₂.toSemi)
(hInf :
Multiplicative.ofAdd ((D₁.nInf : ℤ) - 1) *
(N13Infinity.positiveInfinityOrder K).ordPlus α =
Multiplicative.ofAdd ((D₂.nInf : ℤ) - 1)) :
∃ c : Kˣ, α = N13Infinity.functionConstUnit K c := by
let M := N13Mumford.model K
obtain ⟨z, w, hzmem, hwmem, hprod, hzeq, hweq⟩ :=
exists_integral_factor_pair_of_principal_relation
M D₁.toSemi D₂.toSemi α hIdeal
change z ∈ mumfordIdeal M D₂.u D₂.v at hzmem
change w ∈ mumfordIdeal M D₁.u D₁.v at hwmem
change z * w = xClass M (D₁.u * D₂.u) at hprod
change
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) z =
(α : N13Mumford.FunctionField K) *
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) (xClass M D₁.u) at hzeq
change
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) w =
(↑α⁻¹ : N13Mumford.FunctionField K) *
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) (xClass M D₂.u) at hweq
have hu₁ : D₁.u ≠ 0 := D₁.u_monic.ne_zero
have hu₂ : D₂.u ≠ 0 := D₂.u_monic.ne_zero
have hαorder := orientation_order K D₁ D₂ α hInf
have hzorder := numerator_order K α D₁.u z hu₁ hzeq
have hworder := numerator_order K α⁻¹ D₂.u w hu₂ hweq
have hαinv := inverse_order K α
have hzplus :
(-2 : ℤ) ≤ (N13Infinity.coordinateToLaurent K z).order := by
rw [hzorder, hαorder]
have hbound := D₁.infinity_bound
omega
have hwplus :
(-2 : ℤ) ≤ (N13Infinity.coordinateToLaurent K w).order := by
rw [hworder, hαinv, hαorder]
have hbound := D₂.infinity_bound
omega
have hP : D₁.u * D₂.u ≠ 0 := mul_ne_zero hu₁ hu₂
have hPdeg : (D₁.u * D₂.u).natDegree ≤ 4 := by
rw [Polynomial.natDegree_mul hu₁ hu₂]
have hdeg₁ := D₁.deg_u
have hdeg₂ := D₂.deg_u
omega
obtain ⟨hzY, hwY⟩ :=
N13FactorRigidity.factor_pair_coeffY_eq_zero K z w
(D₁.u * D₂.u) hP hPdeg hprod hzplus hwplus
let pz := coeff0 M z
let pw := coeff0 M w
have hzpoly : z = xClass M pz := by
have hzY' : coeffY M z = 0 := by simpa [M] using hzY
rw [← recompose M z]
rw [hzY']
simp [pz]
have hwpoly : w = xClass M pw := by
have hwY' : coeffY M w = 0 := by simpa [M] using hwY
rw [← recompose M w]
rw [hwY']
simp [pw]
have hpoly : pz * pw = D₁.u * D₂.u := by
apply xClass_injective M
rw [xClass_mul, ← hzpoly, ← hwpoly, hprod]
have hu₂pz : D₂.u ∣ pz := by
have hm :
pz ∈
(mumfordIdeal M D₂.u D₂.v).comap (xClassHom M) := by
change xClass M pz ∈ mumfordIdeal M D₂.u D₂.v
rw [← hzpoly]
exact hzmem
have hbase :
(mumfordIdeal M D₂.u D₂.v).comap (xClassHom M) =
Ideal.span ({D₂.u} : Set K[X]) := by
simpa only [toSemi_u, toSemi_v] using
mumfordIdeal_comap_base M D₂.toSemi
rw [hbase, Ideal.mem_span_singleton] at hm
exact hm
have hu₁pw : D₁.u ∣ pw := by
have hm :
pw ∈
(mumfordIdeal M D₁.u D₁.v).comap (xClassHom M) := by
change xClass M pw ∈ mumfordIdeal M D₁.u D₁.v
rw [← hwpoly]
exact hwmem
have hbase :
(mumfordIdeal M D₁.u D₁.v).comap (xClassHom M) =
Ideal.span ({D₁.u} : Set K[X]) := by
simpa only [toSemi_u, toSemi_v] using
mumfordIdeal_comap_base M D₁.toSemi
rw [hbase, Ideal.mem_span_singleton] at hm
exact hm
obtain ⟨c, hpc⟩ := hu₂pz
obtain ⟨d, hpd⟩ := hu₁pw
have hcd : c * d = 1 := by
apply mul_left_cancel₀ hP
calc
(D₁.u * D₂.u) * (c * d) =
(D₂.u * c) * (D₁.u * d) := by ring
_ = pz * pw := by rw [← hpc, ← hpd]
_ = D₁.u * D₂.u := hpoly
_ = (D₁.u * D₂.u) * 1 := by rw [mul_one]
have hcunit : IsUnit c :=
isUnit_iff_exists_inv.mpr ⟨d, hcd⟩
have hpzfield :
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) (xClass M pz) =
(α : N13Mumford.FunctionField K) *
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) (xClass M D₁.u) := by
rw [← hzpoly]
exact hzeq
have hscale :
(α : N13Mumford.FunctionField K) *
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) (xClass M D₁.u) =
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) (xClass M D₂.u) *
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) (xClass M c) := by
calc
_ = algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) (xClass M pz) :=
hpzfield.symm
_ = algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) (xClass M (D₂.u * c)) := by
rw [hpc]
_ = _ := by rw [xClass_mul, map_mul]
have hunitX : xClass M c * xClass M d = 1 := by
rw [← xClass_mul, hcd, xClass_one]
have huEq : D₁.u = D₂.u :=
mumford_u_eq_of_principal_scale M D₁.toSemi D₂.toSemi α
(xClass M c) (xClass M d) hIdeal hscale hunitX
have hpc' : pz = D₁.u * c := by
rw [huEq]
exact hpc
have huField :
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) (xClass M D₁.u) ≠ 0 := by
simpa using
(IsFractionRing.injective
(N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K)).ne
(xClass_ne_zero M hu₁)
have hαfield :
(α : N13Mumford.FunctionField K) =
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) (xClass M c) := by
apply mul_right_cancel₀ huField
calc
(α : N13Mumford.FunctionField K) *
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) (xClass M D₁.u) =
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) (xClass M pz) :=
hpzfield.symm
_ = algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K)
(xClass M (D₁.u * c)) := by rw [hpc']
_ = algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K)
(xClass M D₁.u * xClass M c) := by rw [xClass_mul]
_ = algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) (xClass M c) *
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K) (xClass M D₁.u) := by
rw [map_mul]
ring
obtain ⟨r, hrunit, hCr⟩ := Polynomial.isUnit_iff.mp hcunit
let cr : Kˣ := hrunit.unit
refine ⟨cr, ?_⟩
apply Units.ext
change
(α : N13Mumford.FunctionField K) =
algebraMap (N13Mumford.CoordinateRing K)
(N13Mumford.FunctionField K)
(algebraMap K (N13Mumford.CoordinateRing K) (cr : K))
rw [hαfield, ← hCr]
rfl
theorem eq_of_class_eq
(D₁ D₂ : Mumford (N13Mumford.model K))
(hclass :
classOf (N13Mumford.model K)
(N13Infinity.positiveInfinityOrder K) D₁ =
classOf (N13Mumford.model K)
(N13Infinity.positiveInfinityOrder K) D₂) :
D₁ = D₂ := by
obtain ⟨α, hIdeal, hInf⟩ :=
(classOf_eq_iff (N13Mumford.model K)
(N13Infinity.positiveInfinityOrder K) D₁ D₂).mp hclass
obtain ⟨c, hα⟩ :=
principal_is_constant K D₁ D₂ α hIdeal hInf
exact N13Mumford.principal_between_balanced_of_constant
K c hα hIdeal hInf
theorem eq_of_class_eq_of_small
(D₁ D₂ : Mumford (N13Mumford.model K))
(_hsmall₁ : D₁.u.natDegree + D₁.nInf ≤ 1)
(_hsmall₂ : D₂.u.natDegree + D₂.nInf ≤ 1)
(hclass :
classOf (N13Mumford.model K)
(N13Infinity.positiveInfinityOrder K) D₁ =
classOf (N13Mumford.model K)
(N13Infinity.positiveInfinityOrder K) D₂) :
D₁ = D₂ :=
eq_of_class_eq K D₁ D₂ hclass
theorem classOf_injective :
Function.Injective
(classOf (N13Mumford.model K)
(N13Infinity.positiveInfinityOrder K)) := by
intro D₁ D₂
exact eq_of_class_eq K D₁ D₂
theorem existsUnique_classOf
(c : ConcretePic (N13Mumford.model K)
(N13Infinity.positiveInfinityOrder K)) :
∃! D : Mumford (N13Mumford.model K),
classOf (N13Mumford.model K)
(N13Infinity.positiveInfinityOrder K) D = c := by
obtain ⟨D, hD⟩ :=
N13MumfordInfinityBalance.classOf_surjective c
refine ⟨D, hD, ?_⟩
intro E hE
exact classOf_injective K (hE.trans hD.symm)
instance instNormalFormData :
NormalFormData (N13Mumford.model K)
(N13Infinity.positiveInfinityOrder K) where
existsUnique := existsUnique_classOf K
theorem pointMumford_small
(P : CurvePoint (N13Mumford.model K)) :
(pointMumford (N13Mumford.model K) P).u.natDegree +
(pointMumford (N13Mumford.model K) P).nInf ≤ 1 := by
cases P with
| infinityPlus =>
simp [pointMumford, zero]
| infinityMinus =>
simp [pointMumford, infinityMinusMumford]
| affine x y h =>
simp [pointMumford, affinePointMumford]
theorem point_class_injective :
Function.Injective
(fun P : CurvePoint (N13Mumford.model K) =>
classOf (N13Mumford.model K)
(N13Infinity.positiveInfinityOrder K)
(pointMumford (N13Mumford.model K) P)) := by
intro P Q hPQ
apply pointMumford_injective (N13Mumford.model K)
exact eq_of_class_eq_of_small K _ _
(pointMumford_small K P) (pointMumford_small K Q) hPQ
end
end MazurProof.N13SmallMumfordRigidity
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13TwoAdicAbelChartPic
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# The N13 two-adic Abel chart inside the oriented Picard group
Every pair in the two distinguished residue disks gives smooth integral
generalized Mumford data. After extending coefficients and completing the
square, the resulting standard sextic semirepresentative already has degree
two and infinity balance zero. It is therefore a balanced Mumford
representative over `ℚ₂`.
Unique balanced normal forms make the resulting map to the oriented Picard
group injective. Translating by the distinguished base pair gives the
faithful chart centred at the identity. Thus the remaining geometric input
for the formal-kernel argument is existence of representatives in this
chart, not their uniqueness.
-/
open Polynomial
namespace MazurProof.N13TwoAdicAbelChartPic
noncomputable section
local instance instFactPrimeOfNatNat_fLT : Fact (Nat.Prime 2) :=
⟨Nat.prime_two⟩
abbrev Q₂ : Type :=
ℚ_[2]
abbrev DiskPair : Type :=
N13TwoAdicAbelChartData.DiskPair
abbrev Pic : Type :=
SexticMumford.ConcretePic
(N13Mumford.model Q₂)
(N13Infinity.positiveInfinityOrder Q₂)
namespace DiskPair
variable (P : DiskPair)
theorem u_natDegree :
P.u.natDegree = 2 := by
rw [N13TwoAdicAbelChartData.DiskPair.u,
Polynomial.natDegree_mul
(monic_X_sub_C P.x₀).ne_zero
(monic_X_sub_C P.x₁).ne_zero]
simp
theorem sexticSemi_u_natDegree :
(N13TwoAdicMumfordTransport.sexticSemi
P.smoothMumford 0).u.natDegree = 2 := by
rw [N13TwoAdicMumfordTransport.sexticSemi_u,
N13TwoAdicAbelChartData.DiskPair.smoothMumford_u,
N13TwoAdicMumfordTransport.mapPoly_apply,
P.u_monic.natDegree_map]
exact P.u_natDegree
/-- The standard sextic representative of a two-disk divisor is already
balanced: its affine degree is two and its infinity multiplicity is zero. -/
def mumford :
N13Mumford.Mumford Q₂ := by
let D :=
N13TwoAdicMumfordTransport.sexticSemi
P.smoothMumford 0
exact
{ u := D.u
v := D.v
nInf := 0
u_monic := D.u_monic
deg_u := by
rw [P.sexticSemi_u_natDegree]
v_reduced := D.v_reduced
curve_dvd := D.curve_dvd
infinity_bound := by
rw [P.sexticSemi_u_natDegree] }
@[simp] theorem mumford_u :
P.mumford.u =
N13TwoAdicMumfordTransport.mapPoly P.u := rfl
@[simp] theorem mumford_v :
P.mumford.v =
(N13TwoAdicMumfordTransport.sexticSemi
P.smoothMumford 0).v := rfl
@[simp] theorem mumford_nInf :
P.mumford.nInf = 0 := rfl
/-- The oriented Picard class of the two-disk divisor. -/
def pic : Pic :=
SexticMumford.classOf
(N13Mumford.model Q₂)
(N13Infinity.positiveInfinityOrder Q₂)
P.mumford
/-- Distinct pairs in the two residue disks give distinct Picard classes.
The proof is global normal-form rigidity followed by faithfulness of
coefficient extension. -/
theorem pic_injective :
Function.Injective DiskPair.pic := by
intro P Q hPQ
have hM : P.mumford = Q.mumford :=
N13SmallMumfordRigidity.classOf_injective Q₂ hPQ
apply N13TwoAdicAbelChartData.DiskPair.u_injective
apply Polynomial.map_injective
N13TwoAdicMumfordTransport.coeffMap
(IsFractionRing.injective
N13TwoAdicMumfordTransport.R₂ Q₂)
simpa only [mumford_u,
N13TwoAdicMumfordTransport.mapPoly_apply] using
congrArg SexticMumford.Mumford.u hM
/-- Translate the chart so that the distinguished divisor is the identity. -/
def centeredPic : DiskPair → Pic :=
fun P => P.pic -
pic N13TwoAdicAbelChartData.basePair
@[simp] theorem centeredPic_basePair :
centeredPic N13TwoAdicAbelChartData.basePair = 0 := by
simp [centeredPic]
theorem centeredPic_injective :
Function.Injective centeredPic := by
intro P Q hPQ
apply pic_injective
exact sub_left_injective hPQ
end DiskPair
end
end MazurProof.N13TwoAdicAbelChartPic
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13TwoAdicAbelChartRecover
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Recovering the N13 two-disk divisor from an integral Mumford graph
Suppose a smooth integral generalized Mumford graph reduces to the fixed
nonspecial graph `(X² + X, 0)`. Hensel lifting splits its monic quadratic
into one root in each of the residue disks of `0` and `-1`. Evaluating the
curve relation at those roots and using uniqueness in the vertical Hensel
fibres identifies the graph values with the canonical disk lifts.
Consequently every such integral graph comes from a unique `DiskPair`, up
to the harmless operation of changing its graph polynomial by a multiple
of `u`. This is the algebraic reverse of
`N13TwoAdicAbelChartData.DiskPair.smoothMumford`; no divisor enumeration or
properness shortcut is used.
-/
open Polynomial
open scoped nonZeroDivisors
namespace MazurProof.N13TwoAdicAbelChartRecover
noncomputable section
local instance instFactPrimeOfNatNat_fLT : Fact (Nat.Prime 2) :=
⟨Nat.prime_two⟩
abbrev R₂ : Type :=
ℤ_[2]
abbrev K : Type :=
N13GoodCoordinateRingTwo.K
abbrev Q₂ : Type :=
ℚ_[2]
abbrev Pic : Type :=
N13TwoAdicAbelChartPic.Pic
abbrev maximal : Ideal R₂ :=
IsLocalRing.maximalIdeal R₂
/-- Smooth integral Mumford data whose graph has the selected nonspecial
special fibre. -/
structure NearBaseMumford
extends N13GeneralizedMumfordReduction.SmoothMumford₂ where
reduce_u :
N13GeneralizedMumfordReduction.reducePoly u =
(X ^ 2 + X : K[X])
reduce_v :
N13GeneralizedMumfordReduction.reducePoly v = 0
namespace NearBaseMumford
variable (D : NearBaseMumford)
/-- Every two-disk divisor gives near-base integral data. -/
def ofDiskPair
(P : N13TwoAdicAbelChartData.DiskPair) :
NearBaseMumford where
toSmoothMumford₂ := P.smoothMumford
reduce_u := P.reducePoly_u
reduce_v := P.reducePoly_v
@[simp] theorem ofDiskPair_u
(P : N13TwoAdicAbelChartData.DiskPair) :
(ofDiskPair P).u = P.u := rfl
@[simp] theorem ofDiskPair_v
(P : N13TwoAdicAbelChartData.DiskPair) :
(ofDiskPair P).v = P.v := rfl
theorem mem_maximal_iff_reduceBase_eq_zero
(a : R₂) :
a ∈ maximal ↔
N13GeneralizedMumfordReduction.reduceBase a = 0 := by
constructor
· intro ha
have hker :
a ∈ RingHom.ker (PadicInt.toZMod : R₂ →+* K) := by
rw [PadicInt.ker_toZMod]
exact ha
exact RingHom.mem_ker.mp hker
· intro ha
have hker :
a ∈ RingHom.ker (PadicInt.toZMod : R₂ →+* K) :=
RingHom.mem_ker.mpr ha
rw [PadicInt.ker_toZMod] at hker
exact hker
theorem isUnit_of_reduceBase_eq_one
{a : R₂}
(ha :
N13GeneralizedMumfordReduction.reduceBase a = 1) :
IsUnit a := by
apply N13TwoAdicDisks.isUnit_of_sub_mem_maximal isUnit_one
apply (mem_maximal_iff_reduceBase_eq_zero (a - 1)).2
rw [map_sub, ha, map_one, sub_self]
theorem reduceBase_eval
(p : R₂[X]) (a : R₂) :
N13GeneralizedMumfordReduction.reduceBase (p.eval a) =
(N13GeneralizedMumfordReduction.reducePoly p).eval
(N13GeneralizedMumfordReduction.reduceBase a) := by
rw [N13GeneralizedMumfordReduction.reducePoly_apply,
Polynomial.eval_map_apply]
theorem reduceBase_derivative_eval
(p : R₂[X]) (a : R₂) :
N13GeneralizedMumfordReduction.reduceBase
(p.derivative.eval a) =
(N13GeneralizedMumfordReduction.reducePoly p).derivative.eval
(N13GeneralizedMumfordReduction.reduceBase a) := by
rw [N13GeneralizedMumfordReduction.reducePoly_apply,
Polynomial.derivative_map, Polynomial.eval_map_apply]
theorem u_eval_zero_mem :
D.u.eval 0 ∈ maximal := by
apply (mem_maximal_iff_reduceBase_eq_zero _).2
rw [reduceBase_eval, D.reduce_u]
have htwo : (2 : K) = 0 := CharP.cast_eq_zero K 2
norm_num [N13GeneralizedMumfordReduction.reduceBase, htwo]
theorem u_eval_negOne_mem :
D.u.eval (-1) ∈ maximal := by
apply (mem_maximal_iff_reduceBase_eq_zero _).2
rw [reduceBase_eval, D.reduce_u]
have htwo : (2 : K) = 0 := CharP.cast_eq_zero K 2
norm_num [N13GeneralizedMumfordReduction.reduceBase, htwo]
exact htwo
theorem derivative_eval_zero_isUnit :
IsUnit (D.u.derivative.eval 0) := by
apply isUnit_of_reduceBase_eq_one
rw [reduceBase_derivative_eval, D.reduce_u]
have htwo : (2 : K) = 0 := CharP.cast_eq_zero K 2
norm_num [N13GeneralizedMumfordReduction.reduceBase, htwo]
theorem derivative_eval_negOne_isUnit :
IsUnit (D.u.derivative.eval (-1)) := by
apply isUnit_of_reduceBase_eq_one
rw [reduceBase_derivative_eval, D.reduce_u]
have htwo : (2 : K) = 0 := CharP.cast_eq_zero K 2
norm_num [N13GeneralizedMumfordReduction.reduceBase, htwo]
linear_combination htwo
/-- The root of `u` in the residue disk of zero. -/
theorem exists_root_zeroDisk :
∃ x : R₂, D.u.eval x = 0 ∧ x ∈ maximal := by
obtain ⟨x, hx, hxmem⟩ :=
HenselianRing.is_henselian
D.u D.u_monic 0 D.u_eval_zero_mem
(D.derivative_eval_zero_isUnit.map
(Ideal.Quotient.mk maximal))
refine ⟨x, ?_, by simpa using hxmem⟩
exact hx
/-- The root of `u` in the residue disk of `-1`. -/
theorem exists_root_negOneDisk :
∃ x : R₂, D.u.eval x = 0 ∧ x + 1 ∈ maximal := by
obtain ⟨x, hx, hxmem⟩ :=
HenselianRing.is_henselian
D.u D.u_monic (-1) D.u_eval_negOne_mem
(D.derivative_eval_negOne_isUnit.map
(Ideal.Quotient.mk maximal))
refine ⟨x, ?_, by simpa using hxmem⟩
exact hx
/-- The two Hensel roots, selected in their distinct residue disks. -/
def x₀ : R₂ :=
Classical.choose D.exists_root_zeroDisk
def x₁ : R₂ :=
Classical.choose D.exists_root_negOneDisk
theorem x₀_spec :
D.u.eval D.x₀ = 0 ∧ D.x₀ ∈ maximal :=
Classical.choose_spec D.exists_root_zeroDisk
theorem x₁_spec :
D.u.eval D.x₁ = 0 ∧ D.x₁ + 1 ∈ maximal :=
Classical.choose_spec D.exists_root_negOneDisk
/-- The disk pair cut out by the two Hensel factors of `u`. -/
def diskPair :
N13TwoAdicAbelChartData.DiskPair where
x₀ := D.x₀
x₁ := D.x₁
x₀_mem := D.x₀_spec.2
x₁_add_one_mem := D.x₁_spec.2
@[simp] theorem diskPair_x₀ :
D.diskPair.x₀ = D.x₀ := rfl
@[simp] theorem diskPair_x₁ :
D.diskPair.x₁ = D.x₁ := rfl
theorem u_natDegree :
D.u.natDegree = 2 := by
calc
D.u.natDegree =
(D.u.map
N13GeneralizedMumfordReduction.reduceBase).natDegree :=
(D.u_monic.natDegree_map
N13GeneralizedMumfordReduction.reduceBase).symm
_ =
(N13GeneralizedMumfordReduction.reducePoly D.u).natDegree := rfl
_ = (X ^ 2 + X : K[X]).natDegree := by rw [D.reduce_u]
_ = 2 := by
compute_degree
norm_num [K, N13GoodCoordinateRingTwo.K,
N13GoodModelTwo.F2]
theorem diskPair_u_natDegree :
D.diskPair.u.natDegree = 2 := by
rw [N13TwoAdicAbelChartData.DiskPair.u,
Polynomial.natDegree_mul
(monic_X_sub_C D.diskPair.x₀).ne_zero
(monic_X_sub_C D.diskPair.x₁).ne_zero]
simp
theorem diskPair_u_dvd :
D.diskPair.u ∣ D.u := by
have h₀ : X - C D.diskPair.x₀ ∣ D.u := by
rw [dvd_iff_isRoot, IsRoot, D.diskPair_x₀]
exact D.x₀_spec.1
have h₁ : X - C D.diskPair.x₁ ∣ D.u := by
rw [dvd_iff_isRoot, IsRoot, D.diskPair_x₁]
exact D.x₁_spec.1
have hprod :=
(isCoprime_X_sub_C_of_isUnit_sub
D.diskPair.x₁_sub_x₀_isUnit).mul_dvd h₁ h₀
simpa [N13TwoAdicAbelChartData.DiskPair.u, mul_comm] using hprod
/-- The recovered disk pair has exactly the original monic quadratic. -/
theorem diskPair_u :
D.diskPair.u = D.u := by
exact
(Polynomial.eq_of_monic_of_dvd_of_natDegree_le
D.diskPair.u_monic D.u_monic D.diskPair_u_dvd
(by rw [D.u_natDegree, D.diskPair_u_natDegree])).symm
theorem v_eval_mem_maximal
(x : R₂) :
D.v.eval x ∈ maximal := by
apply (mem_maximal_iff_reduceBase_eq_zero _).2
rw [reduceBase_eval, D.reduce_v]
simp
theorem v_eval_on_curve
{x : R₂} (hx : D.u.eval x = 0) :
N13GoodModelTwo.AffineEquation x (D.v.eval x) := by
have h :=
congrArg (fun p : R₂[X] => p.eval x) D.curve_eq
simp only [eval_sub, eval_add, eval_pow, eval_mul] at h
rw [hx, zero_mul] at h
rw [N13GoodModelTwo.affineEquation_iff_residual]
simpa [N13GoodModelTwo.affineResidual,
N13GoodModelTwo.h, N13GoodModelTwo.rhs,
N13GeneralizedMumfordIntegral.hPoly,
N13GeneralizedMumfordIntegral.rhsPoly] using h
theorem v_eval_x₀ :
D.v.eval D.diskPair.x₀ = D.diskPair.y₀ := by
exact
N13TwoAdicDisks.y_eq_zeroDiskY
D.diskPair.x₀ D.diskPair.x₀_mem
(D.v_eval_on_curve (by
rw [D.diskPair_x₀]
exact D.x₀_spec.1))
(D.v_eval_mem_maximal D.diskPair.x₀)
theorem v_eval_x₁ :
D.v.eval D.diskPair.x₁ = D.diskPair.y₁ := by
exact
N13TwoAdicDisks.y_eq_negOneDiskY
D.diskPair.x₁ D.diskPair.x₁_add_one_mem
(D.v_eval_on_curve (by
rw [D.diskPair_x₁]
exact D.x₁_spec.1))
(D.v_eval_mem_maximal D.diskPair.x₁)
/-- The original graph polynomial and the recovered interpolant agree
modulo the recovered quadratic. -/
theorem diskPair_u_dvd_v_sub :
D.diskPair.u ∣ D.v - D.diskPair.v := by
have h₀ :
X - C D.diskPair.x₀ ∣ D.v - D.diskPair.v := by
rw [dvd_iff_isRoot, IsRoot, eval_sub,
D.v_eval_x₀,
N13TwoAdicAbelChartData.DiskPair.v_eval_x₀,
sub_self]
have h₁ :
X - C D.diskPair.x₁ ∣ D.v - D.diskPair.v := by
rw [dvd_iff_isRoot, IsRoot, eval_sub,
D.v_eval_x₁,
N13TwoAdicAbelChartData.DiskPair.v_eval_x₁,
sub_self]
have hprod :=
(isCoprime_X_sub_C_of_isUnit_sub
D.diskPair.x₁_sub_x₀_isUnit).mul_dvd h₁ h₀
simpa [N13TwoAdicAbelChartData.DiskPair.u, mul_comm] using hprod
theorem u_dvd_v_sub_diskPair_v :
D.u ∣ D.v - D.diskPair.v := by
rw [← D.diskPair_u]
exact D.diskPair_u_dvd_v_sub
/-- Generalized Mumford graph ideals only depend on `v` modulo `u`. -/
theorem mumfordIdeal_eq_of_dvd_sub
(u v w : R₂[X]) (hvw : u ∣ v - w) :
N13GeneralizedMumfordIntegral.mumfordIdeal u v =
N13GeneralizedMumfordIntegral.mumfordIdeal u w := by
obtain ⟨q, hq⟩ := hvw
have hmultiple :
N13GeneralizedMumfordIntegral.xClass (v - w) =
N13GeneralizedMumfordIntegral.xClass u *
N13GeneralizedMumfordIntegral.xClass q := by
rw [hq, N13GeneralizedMumfordIntegral.xClass_mul]
have hyw :
N13GeneralizedMumfordIntegral.ySubClass w =
N13GeneralizedMumfordIntegral.ySubClass v +
N13GeneralizedMumfordIntegral.xClass (v - w) := by
simp [N13GeneralizedMumfordIntegral.ySubClass]
have hyv :
N13GeneralizedMumfordIntegral.ySubClass v =
N13GeneralizedMumfordIntegral.ySubClass w -
N13GeneralizedMumfordIntegral.xClass (v - w) := by
rw [hyw]
ring
apply le_antisymm
· apply Ideal.span_le.2
intro z hz
simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
rcases hz with rfl | rfl
· exact
N13GeneralizedMumfordIntegral.xClass_mem_mumfordIdeal u w
· rw [hyv, hmultiple]
exact Ideal.sub_mem _
(N13GeneralizedMumfordIntegral.ySubClass_mem_mumfordIdeal u w)
(by
simpa only [mul_comm] using
Ideal.mul_mem_left
(N13GeneralizedMumfordIntegral.mumfordIdeal u w)
(N13GeneralizedMumfordIntegral.xClass q)
(N13GeneralizedMumfordIntegral.xClass_mem_mumfordIdeal u w))
· apply Ideal.span_le.2
intro z hz
simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
rcases hz with rfl | rfl
· exact
N13GeneralizedMumfordIntegral.xClass_mem_mumfordIdeal u v
· rw [hyw, hmultiple]
exact Ideal.add_mem _
(N13GeneralizedMumfordIntegral.ySubClass_mem_mumfordIdeal u v)
(by
simpa only [mul_comm] using
Ideal.mul_mem_left
(N13GeneralizedMumfordIntegral.mumfordIdeal u v)
(N13GeneralizedMumfordIntegral.xClass q)
(N13GeneralizedMumfordIntegral.xClass_mem_mumfordIdeal u v))
/-- The recovered disk pair cuts out exactly the original integral graph
ideal. -/
theorem mumfordIdeal_diskPair :
N13GeneralizedMumfordIntegral.mumfordIdeal D.u D.v =
N13GeneralizedMumfordIntegral.mumfordIdeal
D.diskPair.u D.diskPair.v := by
rw [D.diskPair_u]
exact mumfordIdeal_eq_of_dvd_sub
D.u D.v D.diskPair.v D.u_dvd_v_sub_diskPair_v
/-- Completion of the square carries the original graph and the recovered
disk graph to the same standard sextic Mumford ideal. -/
theorem sextic_mumfordIdeal_diskPair :
SexticMumford.mumfordIdeal
(N13Mumford.model Q₂)
(N13TwoAdicMumfordTransport.sexticSemi
D.toSmoothMumford₂ 0).u
(N13TwoAdicMumfordTransport.sexticSemi
D.toSmoothMumford₂ 0).v =
SexticMumford.mumfordIdeal
(N13Mumford.model Q₂)
(N13TwoAdicMumfordTransport.sexticSemi
D.diskPair.smoothMumford 0).u
(N13TwoAdicMumfordTransport.sexticSemi
D.diskPair.smoothMumford 0).v := by
rw [
← N13TwoAdicCoordinateBaseChange.map_mumfordIdeal_sexticSemi
D.toSmoothMumford₂ 0,
← N13TwoAdicCoordinateBaseChange.map_mumfordIdeal_sexticSemi
D.diskPair.smoothMumford 0]
exact congrArg
(Ideal.map N13TwoAdicCoordinateBaseChange.integralToSextic)
D.mumfordIdeal_diskPair
theorem sextic_mumfordIdealUnit_diskPair :
SexticMumford.mumfordIdealUnit
(N13Mumford.model Q₂)
(N13TwoAdicMumfordTransport.sexticSemi
D.toSmoothMumford₂ 0) =
SexticMumford.mumfordIdealUnit
(N13Mumford.model Q₂)
(N13TwoAdicMumfordTransport.sexticSemi
D.diskPair.smoothMumford 0) := by
apply Units.ext
change
(SexticMumford.mumfordIdeal
(N13Mumford.model Q₂)
(N13TwoAdicMumfordTransport.sexticSemi
D.toSmoothMumford₂ 0).u
(N13TwoAdicMumfordTransport.sexticSemi
D.toSmoothMumford₂ 0).v :
FractionalIdeal
(N13Mumford.CoordinateRing Q₂)⁰
(N13Mumford.FunctionField Q₂)) =
SexticMumford.mumfordIdeal
(N13Mumford.model Q₂)
(N13TwoAdicMumfordTransport.sexticSemi
D.diskPair.smoothMumford 0).u
(N13TwoAdicMumfordTransport.sexticSemi
D.diskPair.smoothMumford 0).v
rw [D.sextic_mumfordIdeal_diskPair]
/-- The oriented two-adic Picard class carried by a near-base integral
graph. -/
def pic : Pic :=
SexticMumford.semiMumfordClass
(N13Mumford.model Q₂)
(N13Infinity.positiveInfinityOrder Q₂)
(N13TwoAdicMumfordTransport.sexticSemi
D.toSmoothMumford₂ 0)
/-- Recovery is compatible with the actual oriented Picard class. -/
theorem pic_eq_diskPair_pic :
D.pic =
N13TwoAdicAbelChartPic.DiskPair.pic D.diskPair := by
change
SexticMumford.semiMumfordClass
(N13Mumford.model Q₂)
(N13Infinity.positiveInfinityOrder Q₂)
(N13TwoAdicMumfordTransport.sexticSemi
D.toSmoothMumford₂ 0) =
SexticMumford.classOf
(N13Mumford.model Q₂)
(N13Infinity.positiveInfinityOrder Q₂)
(N13TwoAdicAbelChartPic.DiskPair.mumford D.diskPair)
rw [← SexticMumford.semiMumfordClass_toSemi]
change
SexticMumford.semiMumfordClass
(N13Mumford.model Q₂)
(N13Infinity.positiveInfinityOrder Q₂)
(N13TwoAdicMumfordTransport.sexticSemi
D.toSmoothMumford₂ 0) =
SexticMumford.semiMumfordClass
(N13Mumford.model Q₂)
(N13Infinity.positiveInfinityOrder Q₂)
(N13TwoAdicMumfordTransport.sexticSemi
D.diskPair.smoothMumford 0)
unfold SexticMumford.semiMumfordClass
congr 2
apply Prod.ext
· exact D.sextic_mumfordIdealUnit_diskPair
· rfl
/-- Centre the integral graph class at the selected base divisor. -/
def centeredPic : Pic :=
D.pic -
N13TwoAdicAbelChartPic.DiskPair.pic
N13TwoAdicAbelChartData.basePair
theorem centeredPic_eq_diskPair_centeredPic :
D.centeredPic =
N13TwoAdicAbelChartPic.DiskPair.centeredPic D.diskPair := by
rw [centeredPic,
N13TwoAdicAbelChartPic.DiskPair.centeredPic,
D.pic_eq_diskPair_pic]
/-- The disk pair associated with a near-base graph is unique. -/
theorem existsUnique_diskPair :
∃! P : N13TwoAdicAbelChartData.DiskPair,
P.u = D.u ∧ D.u ∣ D.v - P.v := by
refine
⟨D.diskPair,
⟨D.diskPair_u, D.u_dvd_v_sub_diskPair_v⟩, ?_⟩
intro P hP
apply N13TwoAdicAbelChartData.DiskPair.u_injective
exact hP.1.trans D.diskPair_u.symm
@[simp] theorem diskPair_ofDiskPair
(P : N13TwoAdicAbelChartData.DiskPair) :
(ofDiskPair P).diskPair = P := by
apply N13TwoAdicAbelChartData.DiskPair.u_injective
rw [(ofDiskPair P).diskPair_u]
rfl
@[simp] theorem pic_ofDiskPair
(P : N13TwoAdicAbelChartData.DiskPair) :
(ofDiskPair P).pic =
N13TwoAdicAbelChartPic.DiskPair.pic P := by
rw [(ofDiskPair P).pic_eq_diskPair_pic, diskPair_ofDiskPair]
@[simp] theorem centeredPic_ofDiskPair
(P : N13TwoAdicAbelChartData.DiskPair) :
(ofDiskPair P).centeredPic =
N13TwoAdicAbelChartPic.DiskPair.centeredPic P := by
rw [(ofDiskPair P).centeredPic_eq_diskPair_centeredPic,
diskPair_ofDiskPair]
end NearBaseMumford
end
end MazurProof.N13TwoAdicAbelChartRecover
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13AbelCompatibleGraphRecover
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Recovering an N13 disk pair from an Abel-compatible integral graph
A special-fibre Abel equality identifies the reduced quadratic graph with
the selected divisor. Its graph polynomial is therefore zero modulo the
reduced quadratic, but need not itself reduce coefficientwise to zero.
This file removes that harmless choice of representative. Replacing `v`
by its monic remainder modulo `u`, and changing `w` by the resulting exact
algebraic formula, preserves the generalized Mumford equation, smoothness,
and graph ideal. The normalized graph then satisfies the literal hypotheses
of the two-adic Hensel recovery theorem.
-/
open Polynomial
namespace MazurProof.N13AbelCompatibleGraphRecover
noncomputable section
local instance instFactPrimeOfNatNat_fLT : Fact (Nat.Prime 2) :=
⟨Nat.prime_two⟩
abbrev R₂ : Type :=
N13GeneralizedMumfordReduction.R₂
abbrev K : Type :=
N13GeneralizedMumfordReduction.K
abbrev SmoothMumford₂ : Type :=
N13GeneralizedMumfordReduction.SmoothMumford₂
/-- The quotient removed from the graph polynomial. -/
def graphQuotient (D : SmoothMumford₂) : R₂[X] :=
D.v /ₘ D.u
/-- The canonical graph polynomial of degree strictly below `u`. -/
def normalizedV (D : SmoothMumford₂) : R₂[X] :=
D.v %ₘ D.u
/-- The quotient in the generalized Mumford equation after replacing
`v` by its monic remainder modulo `u`. -/
def normalizedW (D : SmoothMumford₂) : R₂[X] :=
D.w -
graphQuotient D *
(2 * D.v +
N13GeneralizedMumfordIntegral.hPoly (R := R₂)) +
D.u * graphQuotient D ^ 2
theorem normalizedV_add_mul_graphQuotient
(D : SmoothMumford₂) :
normalizedV D + D.u * graphQuotient D = D.v :=
Polynomial.modByMonic_add_div D.v D.u
/-- Monic-remainder normalization preserves both the generalized curve
equation and its smoothness Bezout identity. -/
def normalizeSmoothMumford
(D : SmoothMumford₂) : SmoothMumford₂ where
u := D.u
v := normalizedV D
w := normalizedW D
u_monic := D.u_monic
curve_eq := by
have hv :
normalizedV D =
D.v - D.u * graphQuotient D := by
linear_combination normalizedV_add_mul_graphQuotient D
rw [hv]
unfold normalizedW
calc
(D.v - D.u * graphQuotient D) ^ 2 +
N13GeneralizedMumfordIntegral.hPoly *
(D.v - D.u * graphQuotient D) -
N13GeneralizedMumfordIntegral.rhsPoly =
(D.v ^ 2 +
N13GeneralizedMumfordIntegral.hPoly * D.v -
N13GeneralizedMumfordIntegral.rhsPoly) -
D.u * graphQuotient D *
(2 * D.v +
N13GeneralizedMumfordIntegral.hPoly) +
D.u ^ 2 * graphQuotient D ^ 2 := by ring
_ =
D.u *
(D.w -
graphQuotient D *
(2 * D.v +
N13GeneralizedMumfordIntegral.hPoly) +
D.u * graphQuotient D ^ 2) := by
rw [D.curve_eq]
ring
bezout := by
obtain ⟨a, b, c, habc⟩ := D.bezout
refine
⟨a + 2 * b * graphQuotient D +
c * graphQuotient D ^ 2,
b + c * graphQuotient D, c, ?_⟩
have hv :
normalizedV D =
D.v - D.u * graphQuotient D := by
linear_combination normalizedV_add_mul_graphQuotient D
rw [hv]
unfold normalizedW
calc
(a + 2 * b * graphQuotient D +
c * graphQuotient D ^ 2) * D.u +
(b + c * graphQuotient D) *
(2 * (D.v - D.u * graphQuotient D) +
N13GeneralizedMumfordIntegral.hPoly (R := R₂)) +
c *
(D.w -
graphQuotient D *
(2 * D.v +
N13GeneralizedMumfordIntegral.hPoly (R := R₂)) +
D.u * graphQuotient D ^ 2) =
a * D.u +
b *
(2 * D.v +
N13GeneralizedMumfordIntegral.hPoly (R := R₂)) +
c * D.w := by ring
_ = 1 := habc
@[simp] theorem normalizeSmoothMumford_u
(D : SmoothMumford₂) :
(normalizeSmoothMumford D).u = D.u := rfl
@[simp] theorem normalizeSmoothMumford_v
(D : SmoothMumford₂) :
(normalizeSmoothMumford D).v = normalizedV D := rfl
/-- Normalization does not change the integral graph ideal. -/
theorem normalizeSmoothMumford_mumfordIdeal
(D : SmoothMumford₂) :
N13GeneralizedMumfordIntegral.mumfordIdeal
(normalizeSmoothMumford D).u
(normalizeSmoothMumford D).v =
N13GeneralizedMumfordIntegral.mumfordIdeal D.u D.v := by
exact
N13TwoAdicAbelChartRecover.NearBaseMumford.mumfordIdeal_eq_of_dvd_sub
D.u (normalizedV D) D.v
(Polynomial.dvd_modByMonic_sub D.v D.u)
/-- Abel compatibility of the special fibre makes the normalized integral
graph a literal near-base graph. -/
def normalizedNearBase
(D : SmoothMumford₂)
(hdeg : D.u.natDegree = 2)
(habel :
N13AbelFiberTwoModel.abel
(N13SpecialGraphDivisor.graphDivisor
(N13GeneralizedMumfordReduction.reduceSmoothMumford D)
(N13SpecialGraphReduction.reduceSmoothMumford_u_natDegree
D hdeg)) =
N13AbelFiberTwoModel.abel
N13AbelChartBase.specialBaseDivisor) :
N13TwoAdicAbelChartRecover.NearBaseMumford where
toSmoothMumford₂ := normalizeSmoothMumford D
reduce_u := by
have hgraph :=
N13SpecialGraphDivisor.graphDivisor_eq_special_of_setAbel_eq
(N13GeneralizedMumfordReduction.reduceSmoothMumford D)
(N13SpecialGraphReduction.reduceSmoothMumford_u_natDegree D hdeg)
habel
exact
(N13SpecialGraphDivisor.u_eq_base_and_dvd_v_of_graphDivisor_eq
(N13GeneralizedMumfordReduction.reduceSmoothMumford D)
(N13SpecialGraphReduction.reduceSmoothMumford_u_natDegree D hdeg)
hgraph).1
reduce_v := by
have hgraph :=
N13SpecialGraphDivisor.graphDivisor_eq_special_of_setAbel_eq
(N13GeneralizedMumfordReduction.reduceSmoothMumford D)
(N13SpecialGraphReduction.reduceSmoothMumford_u_natDegree D hdeg)
habel
have hdvd :
N13GeneralizedMumfordReduction.reducePoly D.u ∣
N13GeneralizedMumfordReduction.reducePoly D.v :=
(N13SpecialGraphDivisor.u_eq_base_and_dvd_v_of_graphDivisor_eq
(N13GeneralizedMumfordReduction.reduceSmoothMumford D)
(N13SpecialGraphReduction.reduceSmoothMumford_u_natDegree D hdeg)
hgraph).2
change
N13GeneralizedMumfordReduction.reducePoly
(D.v %ₘ D.u) = 0
rw [N13GeneralizedMumfordReduction.reducePoly_apply,
Polynomial.map_modByMonic
N13GeneralizedMumfordReduction.reduceBase D.u_monic]
exact
(Polynomial.modByMonic_eq_zero_iff_dvd
(D.u_monic.map
N13GeneralizedMumfordReduction.reduceBase)).2 hdvd
/-- The representative-level mapped-ideal equality is an equivalent and
often more convenient input than the set-valued Abel equality. -/
def normalizedNearBaseOfMappedSpecial
(D : SmoothMumford₂)
(hdeg : D.u.natDegree = 2)
(hmap :
Ideal.map N13GeneralizedMumfordReduction.reduceCoordinate
(N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) D.u D.v) =
N13SpecialQuotientBasis.specialIdeal) :
N13TwoAdicAbelChartRecover.NearBaseMumford :=
normalizedNearBase D hdeg
((N13SpecialGraphReduction.setAbel_eq_iff_map_mumfordIdeal_eq_special
D hdeg).2 hmap)
/-- The disk pair recovered by Hensel lifting from an Abel-compatible
integral graph. -/
def recoveredDiskPair
(D : SmoothMumford₂)
(hdeg : D.u.natDegree = 2)
(habel :
N13AbelFiberTwoModel.abel
(N13SpecialGraphDivisor.graphDivisor
(N13GeneralizedMumfordReduction.reduceSmoothMumford D)
(N13SpecialGraphReduction.reduceSmoothMumford_u_natDegree
D hdeg)) =
N13AbelFiberTwoModel.abel
N13AbelChartBase.specialBaseDivisor) :
N13TwoAdicAbelChartData.DiskPair :=
(normalizedNearBase D hdeg habel).diskPair
/-- Hensel recovery directly from the literal mapped special ideal. -/
def recoveredDiskPairOfMappedSpecial
(D : SmoothMumford₂)
(hdeg : D.u.natDegree = 2)
(hmap :
Ideal.map N13GeneralizedMumfordReduction.reduceCoordinate
(N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) D.u D.v) =
N13SpecialQuotientBasis.specialIdeal) :
N13TwoAdicAbelChartData.DiskPair :=
(normalizedNearBaseOfMappedSpecial D hdeg hmap).diskPair
/-- Recovery is exact at the level of integral graph ideals. -/
theorem mumfordIdeal_eq_recoveredDiskPair
(D : SmoothMumford₂)
(hdeg : D.u.natDegree = 2)
(habel :
N13AbelFiberTwoModel.abel
(N13SpecialGraphDivisor.graphDivisor
(N13GeneralizedMumfordReduction.reduceSmoothMumford D)
(N13SpecialGraphReduction.reduceSmoothMumford_u_natDegree
D hdeg)) =
N13AbelFiberTwoModel.abel
N13AbelChartBase.specialBaseDivisor) :
N13GeneralizedMumfordIntegral.mumfordIdeal D.u D.v =
N13GeneralizedMumfordIntegral.mumfordIdeal
(recoveredDiskPair D hdeg habel).u
(recoveredDiskPair D hdeg habel).v := by
unfold recoveredDiskPair
rw [←
(normalizedNearBase D hdeg habel).mumfordIdeal_diskPair]
exact (normalizeSmoothMumford_mumfordIdeal D).symm
/-- Literal special reduction is therefore exactly enough to recover a
two-disk graph with the same integral ideal. -/
theorem mumfordIdeal_eq_recoveredDiskPairOfMappedSpecial
(D : SmoothMumford₂)
(hdeg : D.u.natDegree = 2)
(hmap :
Ideal.map N13GeneralizedMumfordReduction.reduceCoordinate
(N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) D.u D.v) =
N13SpecialQuotientBasis.specialIdeal) :
N13GeneralizedMumfordIntegral.mumfordIdeal D.u D.v =
N13GeneralizedMumfordIntegral.mumfordIdeal
(recoveredDiskPairOfMappedSpecial D hdeg hmap).u
(recoveredDiskPairOfMappedSpecial D hdeg hmap).v := by
unfold recoveredDiskPairOfMappedSpecial
have hpair :=
N13TwoAdicAbelChartRecover.NearBaseMumford.mumfordIdeal_diskPair
(normalizedNearBaseOfMappedSpecial D hdeg hmap)
rw [← hpair]
exact (normalizeSmoothMumford_mumfordIdeal D).symm
end
end MazurProof.N13AbelCompatibleGraphRecover
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13ConcreteGraphRecovery
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Recovering the integral N13 graph from the concrete two-fibre basis
The literal basis `{1,x}` turns multiplication by `x` into a monic
characteristic polynomial of degree two. Expressing the quotient class of
`y` in that basis then recovers the canonical contraction literally as a
generalized Mumford graph ideal.
-/
open Module
open Polynomial
open scoped nonZeroDivisors
namespace MazurProof.N13ConcreteGraphRecovery
noncomputable section
local instance instFactPrimeOfNatNat_fLT : Fact (Nat.Prime 2) :=
⟨Nat.prime_two⟩
abbrev R₂ : Type :=
N13IntegralModelContraction.R₂
abbrev Q₂ : Type :=
N13IntegralModelContraction.Q₂
abbrev IntegralRing : Type :=
N13IntegralModelContraction.IntegralRing
abbrev Model : SexticMumford.Model Q₂ :=
N13GoodSexticCoordinateEquiv.M (K := Q₂)
abbrev SmoothMumford₂ : Type :=
N13GeneralizedMumfordReduction.SmoothMumford₂
/-- Equal graph ideals with equal infinity multiplicity define the same
oriented Picard class. This is the literal representative-level form of
the separatedness used below. -/
theorem semiMumfordClass_eq_of_graphIdeal_eq
(D₁ D₂ : SexticMumford.SemiMumford Model)
(hideal :
N13CanonicalContractionQuotient.graphIdeal D₁ =
N13CanonicalContractionQuotient.graphIdeal D₂)
(hnInf : D₁.nInf = D₂.nInf) :
SexticMumford.semiMumfordClass
Model (N13Infinity.positiveInfinityOrder Q₂) D₁ =
SexticMumford.semiMumfordClass
Model (N13Infinity.positiveInfinityOrder Q₂) D₂ := by
unfold SexticMumford.semiMumfordClass
congr 2
apply Prod.ext
· apply Units.ext
change
(N13CanonicalContractionQuotient.graphIdeal D₁ :
FractionalIdeal
(SexticMumford.CoordinateRing Model)⁰
(SexticMumford.FunctionField Model)) =
(N13CanonicalContractionQuotient.graphIdeal D₂ :
FractionalIdeal
(SexticMumford.CoordinateRing Model)⁰
(SexticMumford.FunctionField Model))
exact congrArg
(fun I : Ideal
(SexticMumford.CoordinateRing Model) ↦
(I :
FractionalIdeal
(SexticMumford.CoordinateRing Model)⁰
(SexticMumford.FunctionField Model)))
hideal
· unfold SexticMumford.semiMumfordRaw
rw [hnInf]
/-- The integral affine `y` coordinate. -/
def integralY : IntegralRing :=
N13GeneralizedMumfordIntegral.yClass (R := R₂)
/-- Evaluation at the integral affine `x` coordinate is the coordinate
embedding of the polynomial subring. -/
@[simp] theorem aeval_integralX (p : R₂[X]) :
aeval N13CanonicalContractionQuotient.integralX p =
N13GeneralizedMumfordIntegral.xClass (R := R₂) p := by
change
aeval
(algebraMap R₂[X] IntegralRing X) p =
algebraMap R₂[X] IntegralRing p
simpa using
aeval_algebraMap_apply IntegralRing
(X : R₂[X]) p
/-- Polynomial evaluation commutes with passage to any quotient of the
integral affine ring. -/
theorem quotient_aeval_integralX
(I : Ideal IntegralRing) (p : R₂[X]) :
aeval
(Ideal.Quotient.mk I
N13CanonicalContractionQuotient.integralX) p =
Ideal.Quotient.mk I
(N13GeneralizedMumfordIntegral.xClass (R := R₂) p) := by
rw [← aeval_integralX]
simpa using
(Polynomial.map_aeval_eq_aeval_map
(R := R₂) (S := IntegralRing) (T := R₂)
(U := IntegralRing ⧸ I)
(φ := RingHom.id R₂)
(ψ := Ideal.Quotient.mk I)
(by ext; simp) p
N13CanonicalContractionQuotient.integralX).symm
/-- The integral affine ring has polynomial normal form in `x,y`. -/
theorem integral_rankTwoPolynomialNormalForm :
N13RankTwoIdealRecovery.HasRankTwoPolynomialNormalForm
(R := R₂)
N13CanonicalContractionQuotient.integralX integralY := by
intro z
refine
⟨N13GeneralizedMumfordIntegral.coeff0 z,
N13GeneralizedMumfordIntegral.coeffY z, ?_⟩
rw [aeval_integralX, aeval_integralX]
exact
(N13GeneralizedMumfordIntegral.recompose z).symm
/-- The remaining special-ideal equality forces the canonical contraction
to be a literal monic quadratic graph ideal. -/
theorem exists_integral_smoothGraph
(D : SexticMumford.SemiMumford Model)
(hdeg : D.u.natDegree = 2)
(hmap :
Ideal.map
N13GeneralizedMumfordReduction.reduceCoordinate
(N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)) =
N13SpecialQuotientBasis.specialIdeal) :
∃ E : SmoothMumford₂,
E.u.natDegree = 2 ∧
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D) =
N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) E.u E.v := by
let I :=
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)
let B := IntegralRing ⧸ I
let xbar : B :=
Ideal.Quotient.mk I
N13CanonicalContractionQuotient.integralX
let ybar : B :=
Ideal.Quotient.mk I integralY
obtain ⟨b, hb⟩ :=
N13TwoFiberConcreteBasis.exists_contractQuotient_basis
D hdeg hmap
have hb0 : b 0 = 1 := by
have h := congrFun hb (0 : Fin 2)
simpa [N13TwoFiberNoEscape.pairFamily] using h
have hb1 : b 1 = xbar := by
have h := congrFun hb (1 : Fin 2)
simpa [N13TwoFiberNoEscape.pairFamily, xbar, I] using h
letI : Module.Free R₂ B :=
Module.Free.of_basis b
letI : Module.Finite R₂ B :=
Module.Finite.of_basis b
letI : Nontrivial B :=
⟨⟨1, 0, by
rw [← hb0]
exact b.ne_zero 0⟩⟩
obtain ⟨a, c, hy⟩ :=
N13RankTwoQuotientAlgebra.exists_eq_algebraMap_add_algebraMap_mul
xbar ybar b hb0 hb1
let u : R₂[X] :=
(Algebra.lmul R₂ B xbar).charpoly
let v : R₂[X] :=
C a + C c * X
have huMonic : u.Monic :=
N13RankTwoQuotientAlgebra.charpoly_lmul_monic_of_one_x xbar
have huDegree : u.natDegree = 2 :=
N13RankTwoQuotientAlgebra.charpoly_lmul_natDegree_of_one_x
xbar b hb0 hb1
have hker :
RingHom.ker
((aeval xbar : R₂[X] →ₐ[R₂] B).toRingHom) =
Ideal.span ({u} : Set R₂[X]) := by
exact
N13RankTwoQuotientAlgebra.ker_aeval_eq_span_charpoly_of_one_x
xbar b hb0 hb1
have hyv : ybar = aeval xbar v := by
calc
ybar =
algebraMap R₂ B a +
algebraMap R₂ B c * xbar := hy
_ = aeval xbar v := by
simp [v]
have hI :=
N13RankTwoIdealRecovery.ideal_eq_span_aeval_y_sub
(R := R₂)
N13CanonicalContractionQuotient.integralX
integralY I u v
integral_rankTwoPolynomialNormalForm hker hyv
have hIgraph :
I =
N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) u v := by
simpa [N13GeneralizedMumfordIntegral.mumfordIdeal,
N13GeneralizedMumfordIntegral.ySubClass,
integralY,
aeval_integralX] using hI
have hvDegree : v.natDegree ≤ 1 := by
unfold v
compute_degree
let residual : R₂[X] :=
v ^ 2 +
N13GeneralizedMumfordIntegral.hPoly (R := R₂) * v -
N13GeneralizedMumfordIntegral.rhsPoly (R := R₂)
have hresGraph :
N13GeneralizedMumfordIntegral.xClass (R := R₂) residual ∈
N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) u v := by
have hy :
N13GeneralizedMumfordIntegral.ySubClass (R := R₂) v ∈
N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) u v :=
N13GeneralizedMumfordIntegral.ySubClass_mem_mumfordIdeal u v
have hprod :
N13GeneralizedMumfordIntegral.ySubClass (R := R₂) v *
N13GeneralizedMumfordIntegral.ySubClass
(R := R₂)
(N13GeneralizedMumfordIntegral.conjugateV v) ∈
N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) u v :=
Ideal.mul_mem_right _ _ hy
rw [N13GeneralizedMumfordIntegral.ySubClass_mul_conjugateV_raw]
at hprod
have hneg :=
(N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) u v).neg_mem hprod
simpa [residual] using hneg
have hresI :
N13GeneralizedMumfordIntegral.xClass (R := R₂) residual ∈ I := by
rw [hIgraph]
exact hresGraph
have hresEval :
aeval xbar residual = 0 := by
rw [quotient_aeval_integralX]
exact Ideal.Quotient.eq_zero_iff_mem.mpr hresI
have hresKer :
residual ∈
RingHom.ker
((aeval xbar : R₂[X] →ₐ[R₂] B).toRingHom) :=
RingHom.mem_ker.mpr hresEval
rw [hker, Ideal.mem_span_singleton] at hresKer
obtain ⟨w, hw⟩ := hresKer
have hcurve :
v ^ 2 +
N13GeneralizedMumfordIntegral.hPoly (R := R₂) * v -
N13GeneralizedMumfordIntegral.rhsPoly (R := R₂) =
u * w := by
simpa [residual] using hw
have hmapGraph :
Ideal.map N13GeneralizedMumfordReduction.reduceCoordinate
(N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) u v) =
N13SpecialQuotientBasis.specialIdeal := by
rw [← hIgraph]
exact hmap
have hspecialGraph :
N13GoodCoordinateRingTwo.mumfordIdeal
(N13GeneralizedMumfordReduction.reducePoly u)
(N13GeneralizedMumfordReduction.reducePoly v) =
N13SpecialQuotientBasis.specialIdeal := by
rw [← N13GeneralizedMumfordReduction.map_mumfordIdeal]
exact hmapGraph
have hxmem :
N13GoodCoordinateRingTwo.xClass
(N13GeneralizedMumfordReduction.reducePoly u) ∈
N13SpecialQuotientBasis.specialIdeal := by
rw [← hspecialGraph]
exact
N13GoodCoordinateRingTwo.xClass_mem_mumfordIdeal
(N13GeneralizedMumfordReduction.reducePoly u)
(N13GeneralizedMumfordReduction.reducePoly v)
have hxker :
N13GoodCoordinateRingTwo.xClass
(N13GeneralizedMumfordReduction.reducePoly u) ∈
RingHom.ker
(N13GoodCoordinateRingTwo.mumfordEval
N13SpecialQuotientBasis.specialData) := by
rw [N13GoodCoordinateRingTwo.ker_mumfordEval]
exact hxmem
have hbaseDvdU :=
RingHom.mem_ker.mp hxker
rw [N13GoodCoordinateRingTwo.mumfordEval_xClass,
Ideal.Quotient.eq_zero_iff_mem,
Ideal.mem_span_singleton] at hbaseDvdU
have hreduceU :
N13GeneralizedMumfordReduction.reducePoly u =
(X ^ 2 + X : N13GeneralizedMumfordReduction.K[X]) := by
have huReduceMonic :
(N13GeneralizedMumfordReduction.reducePoly u).Monic :=
huMonic.map N13GeneralizedMumfordReduction.reduceBase
have huReduceDegree :
(N13GeneralizedMumfordReduction.reducePoly u).natDegree = 2 := by
change
(u.map N13GeneralizedMumfordReduction.reduceBase).natDegree = 2
rw [huMonic.natDegree_map, huDegree]
have heq :
N13GeneralizedMumfordReduction.reducePoly u =
N13SpecialQuotientBasis.specialData.u :=
Polynomial.eq_of_monic_of_dvd_of_natDegree_le
N13SpecialQuotientBasis.specialData.u_monic
huReduceMonic hbaseDvdU
(by
rw [huReduceDegree,
N13SpecialQuotientBasis.specialData_u_natDegree])
simpa only [N13SpecialQuotientBasis.specialData_u] using heq
have hymem :
N13GoodCoordinateRingTwo.ySubClass
(N13GeneralizedMumfordReduction.reducePoly v) ∈
N13SpecialQuotientBasis.specialIdeal := by
rw [← hspecialGraph]
exact
N13GoodCoordinateRingTwo.ySubClass_mem_mumfordIdeal
(N13GeneralizedMumfordReduction.reducePoly u)
(N13GeneralizedMumfordReduction.reducePoly v)
have hyker :
N13GoodCoordinateRingTwo.ySubClass
(N13GeneralizedMumfordReduction.reducePoly v) ∈
RingHom.ker
(N13GoodCoordinateRingTwo.mumfordEval
N13SpecialQuotientBasis.specialData) := by
rw [N13GoodCoordinateRingTwo.ker_mumfordEval]
exact hymem
have hyzero :=
RingHom.mem_ker.mp hyker
have hbaseDvdNegV :
N13SpecialQuotientBasis.specialData.u ∣
-N13GeneralizedMumfordReduction.reducePoly v := by
simp only [N13GoodCoordinateRingTwo.ySubClass, map_sub,
N13GoodCoordinateRingTwo.mumfordEval_yClass,
N13GoodCoordinateRingTwo.mumfordEval_xClass,
N13SpecialQuotientBasis.specialData_v, map_zero,
zero_sub] at hyzero
change
Ideal.Quotient.mk
(Ideal.span
({N13SpecialQuotientBasis.specialData.u} :
Set N13GeneralizedMumfordReduction.K[X]))
(-N13GeneralizedMumfordReduction.reducePoly v) =
0 at hyzero
exact Ideal.mem_span_singleton.mp
(Ideal.Quotient.eq_zero_iff_mem.mp hyzero)
have hbaseDvdV :
N13SpecialQuotientBasis.specialData.u ∣
N13GeneralizedMumfordReduction.reducePoly v := by
simpa only [dvd_neg] using hbaseDvdNegV
have hreduceV :
N13GeneralizedMumfordReduction.reducePoly v = 0 := by
apply Polynomial.eq_zero_of_dvd_of_natDegree_lt hbaseDvdV
calc
(N13GeneralizedMumfordReduction.reducePoly v).natDegree ≤
v.natDegree :=
Polynomial.natDegree_map_le
_ ≤ 1 := hvDegree
_ < 2 := by omega
_ =
N13SpecialQuotientBasis.specialData.u.natDegree :=
N13SpecialQuotientBasis.specialData_u_natDegree.symm
let g : R₂[X] :=
2 * v +
N13GeneralizedMumfordIntegral.hPoly (R := R₂)
have hgMonic : g.Monic := by
unfold g v N13GeneralizedMumfordIntegral.hPoly
monicity <;> norm_num
have hreduceG :
N13GeneralizedMumfordReduction.reducePoly g =
N13GoodCoordinateRingTwo.hPoly := by
change
g.map N13GeneralizedMumfordReduction.reduceBase =
N13GoodCoordinateRingTwo.hPoly
unfold g
rw [Polynomial.map_add, Polynomial.map_mul]
have htwoPoly :
(2 : N13GeneralizedMumfordReduction.K[X]) = 0 :=
CharP.cast_eq_zero
(N13GeneralizedMumfordReduction.K[X]) 2
rw [show
(2 : R₂[X]).map
N13GeneralizedMumfordReduction.reduceBase =
(2 : N13GeneralizedMumfordReduction.K[X]) by simp,
htwoPoly, zero_mul, zero_add]
exact N13GeneralizedMumfordReduction.reduce_hPoly
have hcoprimeSpecial :
IsCoprime
(N13GeneralizedMumfordReduction.reducePoly u)
(N13GeneralizedMumfordReduction.reducePoly g) := by
rw [hreduceU, hreduceG]
refine ⟨X - 1, 1, ?_⟩
have htwoPoly :
(2 : N13GeneralizedMumfordReduction.K[X]) = 0 :=
CharP.cast_eq_zero
(N13GeneralizedMumfordReduction.K[X]) 2
calc
(X - 1) * (X ^ 2 + X) +
1 * N13GoodCoordinateRingTwo.hPoly =
2 * X ^ 3 + 1 := by
simp only [N13GoodCoordinateRingTwo.hPoly]
ring
_ = 1 := by rw [htwoPoly, zero_mul, zero_add]
have hresultantSpecialUnit :
IsUnit
((N13GeneralizedMumfordReduction.reducePoly u).resultant
(N13GeneralizedMumfordReduction.reducePoly g)) :=
(Polynomial.isUnit_resultant_iff_isCoprime
(huMonic.map
N13GeneralizedMumfordReduction.reduceBase)).2
hcoprimeSpecial
have hresultantMap :
(N13GeneralizedMumfordReduction.reducePoly u).resultant
(N13GeneralizedMumfordReduction.reducePoly g) =
N13GeneralizedMumfordReduction.reduceBase
(u.resultant g) := by
change
(u.map N13GeneralizedMumfordReduction.reduceBase).resultant
(g.map N13GeneralizedMumfordReduction.reduceBase) =
N13GeneralizedMumfordReduction.reduceBase
(u.resultant g)
simpa only [
huMonic.natDegree_map
N13GeneralizedMumfordReduction.reduceBase,
hgMonic.natDegree_map
N13GeneralizedMumfordReduction.reduceBase] using
Polynomial.resultant_map_map
(f := u) (g := g)
(m := u.natDegree) (n := g.natDegree)
N13GeneralizedMumfordReduction.reduceBase
have hresultantReduceUnit :
IsUnit
(N13GeneralizedMumfordReduction.reduceBase
(u.resultant g)) := by
rw [← hresultantMap]
exact hresultantSpecialUnit
have hresultantReduceOne :
N13GeneralizedMumfordReduction.reduceBase
(u.resultant g) = 1 := by
let z :=
N13GeneralizedMumfordReduction.reduceBase
(u.resultant g)
have hzFixed : z ^ 2 = z :=
ZMod.pow_card z
rcases
N13GoodModelTwo.fixedTwo_eq_zero_or_one z hzFixed with
hz | hz
· exact
(hresultantReduceUnit.ne_zero hz).elim
· exact hz
have hresultantUnit :
IsUnit (u.resultant g) :=
N13TwoAdicAbelChartRecover.NearBaseMumford.isUnit_of_reduceBase_eq_one
hresultantReduceOne
have hcoprime :
IsCoprime u g :=
(Polynomial.isUnit_resultant_iff_isCoprime huMonic).1
hresultantUnit
obtain ⟨a', b', hab⟩ := hcoprime
let E : SmoothMumford₂ :=
{ u := u
v := v
w := w
u_monic := huMonic
curve_eq := hcurve
bezout := ⟨a', b', 0, by simpa [g] using hab⟩ }
refine ⟨E, huDegree, ?_⟩
exact hIgraph
/-- The strengthened recovery already lands in the two-disk chart. It also
recovers the original generic sextic graph after coefficient extension, so
no separate representative-existence hypothesis remains after the mapped
special-ideal equality. -/
theorem exists_integral_diskGraph
(D : SexticMumford.SemiMumford Model)
(hdeg : D.u.natDegree = 2)
(hmap :
Ideal.map
N13GeneralizedMumfordReduction.reduceCoordinate
(N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)) =
N13SpecialQuotientBasis.specialIdeal) :
∃ E : SmoothMumford₂,
∃ P : N13TwoAdicAbelChartData.DiskPair,
E.u.natDegree = 2 ∧
N13CanonicalContractionQuotient.graphIdeal D =
N13IntegralGraphContraction.sexticIdeal E D.nInf ∧
N13GeneralizedMumfordIntegral.mumfordIdeal E.u E.v =
N13GeneralizedMumfordIntegral.mumfordIdeal P.u P.v := by
obtain ⟨E, hEdeg, hE⟩ :=
exists_integral_smoothGraph D hdeg hmap
have hmapE :
Ideal.map N13GeneralizedMumfordReduction.reduceCoordinate
(N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) E.u E.v) =
N13SpecialQuotientBasis.specialIdeal := by
rw [← hE]
exact hmap
let P :=
N13AbelCompatibleGraphRecover.recoveredDiskPairOfMappedSpecial
E hEdeg hmapE
have hEP :
N13GeneralizedMumfordIntegral.mumfordIdeal E.u E.v =
N13GeneralizedMumfordIntegral.mumfordIdeal P.u P.v :=
N13AbelCompatibleGraphRecover.mumfordIdeal_eq_recoveredDiskPairOfMappedSpecial
E hEdeg hmapE
refine ⟨E, P, hEdeg, ?_, hEP⟩
calc
N13CanonicalContractionQuotient.graphIdeal D =
Ideal.map
N13TwoAdicCoordinateBaseChange.integralToSextic
(N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)) :=
(N13IntegralModelContraction.map_contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)).symm
_ =
Ideal.map
N13TwoAdicCoordinateBaseChange.integralToSextic
(N13GeneralizedMumfordIntegral.mumfordIdeal E.u E.v) := by
rw [hE]
_ = N13IntegralGraphContraction.sexticIdeal E D.nInf :=
N13TwoAdicCoordinateBaseChange.map_mumfordIdeal_sexticSemi
E D.nInf
/-- A balanced quadratic representative whose canonical contraction has the
selected special graph is represented by an actual pair in the two
distinguished residue disks. -/
theorem exists_diskPair_class_eq
(D : SexticMumford.Mumford Model)
(hmap :
Ideal.map
N13GeneralizedMumfordReduction.reduceCoordinate
(N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D.toSemi)) =
N13SpecialQuotientBasis.specialIdeal) :
∃ P : N13TwoAdicAbelChartData.DiskPair,
SexticMumford.classOf
Model (N13Infinity.positiveInfinityOrder Q₂) D =
N13TwoAdicAbelChartPic.DiskPair.pic P := by
have hdeg : D.u.natDegree = 2 :=
N13TwoFiberConcreteBasis.degree_eq_two_of_map_contractIdeal_eq_special
D.toSemi (by simpa using D.deg_u) hmap
have hnInfNat : D.nInf = 0 := by
have hbound := D.infinity_bound
omega
have hnInf : D.toSemi.nInf = 0 := by
simp [hnInfNat]
obtain ⟨E, P, _hEdeg, hgraph, hEP⟩ :=
exists_integral_diskGraph D.toSemi (by simpa using hdeg) hmap
have hEPsextic :
N13CanonicalContractionQuotient.graphIdeal
(N13TwoAdicMumfordTransport.sexticSemi E 0) =
N13CanonicalContractionQuotient.graphIdeal
(N13TwoAdicMumfordTransport.sexticSemi
P.smoothMumford 0) := by
change
SexticMumford.mumfordIdeal Model
(N13TwoAdicMumfordTransport.sexticSemi E 0).u
(N13TwoAdicMumfordTransport.sexticSemi E 0).v =
SexticMumford.mumfordIdeal Model
(N13TwoAdicMumfordTransport.sexticSemi
P.smoothMumford 0).u
(N13TwoAdicMumfordTransport.sexticSemi
P.smoothMumford 0).v
rw [
← N13TwoAdicCoordinateBaseChange.map_mumfordIdeal_sexticSemi
E 0,
← N13TwoAdicCoordinateBaseChange.map_mumfordIdeal_sexticSemi
P.smoothMumford 0]
exact congrArg
(Ideal.map N13TwoAdicCoordinateBaseChange.integralToSextic)
hEP
have hgraphDP :
N13CanonicalContractionQuotient.graphIdeal D.toSemi =
N13CanonicalContractionQuotient.graphIdeal
(N13TwoAdicAbelChartPic.DiskPair.mumford P).toSemi := by
calc
N13CanonicalContractionQuotient.graphIdeal D.toSemi =
N13IntegralGraphContraction.sexticIdeal
E D.toSemi.nInf := hgraph
_ = N13CanonicalContractionQuotient.graphIdeal
(N13TwoAdicMumfordTransport.sexticSemi E 0) := by
rw [hnInf]
rfl
_ = N13CanonicalContractionQuotient.graphIdeal
(N13TwoAdicMumfordTransport.sexticSemi
P.smoothMumford 0) := hEPsextic
_ = N13CanonicalContractionQuotient.graphIdeal
(N13TwoAdicAbelChartPic.DiskPair.mumford P).toSemi := rfl
refine ⟨P, ?_⟩
rw [← SexticMumford.semiMumfordClass_toSemi]
change
SexticMumford.semiMumfordClass
Model (N13Infinity.positiveInfinityOrder Q₂) D.toSemi =
SexticMumford.classOf
Model (N13Infinity.positiveInfinityOrder Q₂)
(N13TwoAdicAbelChartPic.DiskPair.mumford P)
rw [← SexticMumford.semiMumfordClass_toSemi]
apply semiMumfordClass_eq_of_graphIdeal_eq
D.toSemi
(N13TwoAdicAbelChartPic.DiskPair.mumford P).toSemi
hgraphDP
simp [hnInfNat]
/-- Compatibility wrapper retaining the earlier polynomial-level output. -/
theorem exists_integral_graph
(D : SexticMumford.SemiMumford Model)
(hdeg : D.u.natDegree = 2)
(hmap :
Ideal.map
N13GeneralizedMumfordReduction.reduceCoordinate
(N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)) =
N13SpecialQuotientBasis.specialIdeal) :
∃ u v : R₂[X],
u.Monic ∧
u.natDegree = 2 ∧
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D) =
N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) u v := by
obtain ⟨E, hEdeg, hE⟩ :=
exists_integral_smoothGraph D hdeg hmap
exact ⟨E.u, E.v, E.u_monic, hEdeg, hE⟩
end
end MazurProof.N13ConcreteGraphRecovery
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.GraphJacobianDualFrame
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# A Jacobian dual frame for a graph ideal
For a graph ideal `(U,G)`, the factorization
`G * Gbar = -(U * W)`
places `-Gbar/U` in the multiplier inverse. If two Jacobian rows generate
one, their graph decompositions then give an explicit two-term dual frame.
This proves invertibility without Noetherian, regular-local, divisor-class,
or special-fibre arguments.
-/
open scoped nonZeroDivisors
namespace MazurProof.GraphJacobianDualFrame
noncomputable section
variable {A K : Type*}
variable [CommRing A] [IsDomain A]
variable [Field K] [Algebra A K] [IsFractionRing A K]
/-- A graph factorization and a global Jacobian Bézout identity produce an
explicit dual frame, hence an invertible graph fractional ideal. -/
theorem graphJacobian_isUnit
(U G Gbar W Fy Fx Ux Wx Vx hx a b : A)
(hU : U ≠ 0)
(hGGbar : G * Gbar = -(U * W))
(hFy : Fy = G + Gbar)
(hFx :
Fx =
Ux * W + U * Wx - Vx * Gbar +
(hx + Vx) * G)
(hBez : a * Fx + b * Fy = 1) :
IsUnit
((Ideal.span ({U, G} : Set A) : Ideal A) :
FractionalIdeal A⁰ K) := by
let M : Ideal A :=
Ideal.span ({U, G} : Set A)
let I : FractionalIdeal A⁰ K :=
(M : FractionalIdeal A⁰ K)
have hU_M : U ∈ M := by
dsimp only [M]
exact Ideal.subset_span (by simp)
have hG_M : G ∈ M := by
dsimp only [M]
exact Ideal.subset_span (by simp)
have hU_I : algebraMap A K U ∈ I := by
simpa only [I] using
(FractionalIdeal.mem_coeIdeal_of_mem A⁰ hU_M)
have hG_I : algebraMap A K G ∈ I := by
simpa only [I] using
(FractionalIdeal.mem_coeIdeal_of_mem A⁰ hG_M)
have hI_le_one : I ≤ 1 := by
dsimp only [I]
exact FractionalIdeal.coeIdeal_le_one
have hI_ne : I ≠ 0 := by
intro hI0
have hmapU0 : algebraMap A K U = 0 :=
(FractionalIdeal.eq_zero_iff.mp hI0)
(algebraMap A K U) hU_I
exact hU
(IsFractionRing.to_map_eq_zero_iff.mp hmapU0)
have hmapU_ne : algebraMap A K U ≠ 0 := by
intro hmapU0
exact hU
(IsFractionRing.to_map_eq_zero_iff.mp hmapU0)
have hGGbarK :
algebraMap A K G * algebraMap A K Gbar =
-(algebraMap A K U * algebraMap A K W) := by
simpa only [map_mul, map_neg] using
congrArg (algebraMap A K) hGGbar
let z : K :=
-algebraMap A K Gbar / algebraMap A K U
have hzU :
z * algebraMap A K U =
-algebraMap A K Gbar := by
dsimp only [z]
field_simp [hmapU_ne]
have hzG :
z * algebraMap A K G =
algebraMap A K W := by
calc
z * algebraMap A K G =
-(algebraMap A K Gbar *
algebraMap A K G) /
algebraMap A K U := by
dsimp only [z]
ring
_ =
-(algebraMap A K G *
algebraMap A K Gbar) /
algebraMap A K U := by
ring
_ =
-(-(algebraMap A K U *
algebraMap A K W)) /
algebraMap A K U := by
rw [hGGbarK]
_ = algebraMap A K W := by
field_simp [hmapU_ne]
have hz_mem : z ∈ I⁻¹ := by
rw [FractionalIdeal.mem_inv_iff hI_ne]
intro y hy
change
y ∈ (M : FractionalIdeal A⁰ K) at hy
rw [FractionalIdeal.mem_coeIdeal A⁰] at hy
obtain ⟨yA, hyA, hyEq⟩ := hy
subst y
obtain ⟨c, d, hcd⟩ :=
Ideal.mem_span_pair.mp
(by simpa only [M] using hyA)
rw [FractionalIdeal.mem_one_iff A⁰]
refine ⟨-c * Gbar + d * W, ?_⟩
calc
algebraMap A K (-c * Gbar + d * W) =
algebraMap A K c *
(-algebraMap A K Gbar) +
algebraMap A K d *
algebraMap A K W := by
simp only [map_add, map_mul, map_neg]
ring
_ =
algebraMap A K c *
(z * algebraMap A K U) +
algebraMap A K d *
(z * algebraMap A K G) := by
rw [← hzU, ← hzG]
_ =
z * algebraMap A K
(c * U + d * G) := by
simp only [map_add, map_mul]
ring
_ = z * algebraMap A K yA := by
rw [hcd]
have hone_inv : (1 : K) ∈ I⁻¹ := by
rw [FractionalIdeal.mem_inv_iff hI_ne]
intro y hy
simpa only [one_mul] using hI_le_one hy
have hIntegral (r : A) :
algebraMap A K r ∈ I⁻¹ := by
have hr :=
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).smul_mem r hone_inv)
simpa only [FractionalIdeal.mem_coe,
Algebra.smul_def, mul_one] using hr
have hScalarZ (r : A) :
algebraMap A K r * z ∈ I⁻¹ := by
have hr :=
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).smul_mem r hz_mem)
simpa only [FractionalIdeal.mem_coe,
Algebra.smul_def] using hr
let tU : K :=
algebraMap A K a *
(algebraMap A K Wx +
algebraMap A K Vx * z) -
algebraMap A K b * z
let tG : K :=
algebraMap A K a *
(algebraMap A K Ux * z +
algebraMap A K hx +
algebraMap A K Vx) +
algebraMap A K b
have htU : tU ∈ I⁻¹ := by
have hinner :
algebraMap A K Wx +
algebraMap A K Vx * z ∈ I⁻¹ :=
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).add_mem
(hIntegral Wx) (hScalarZ Vx))
have hscaled :
algebraMap A K a *
(algebraMap A K Wx +
algebraMap A K Vx * z) ∈ I⁻¹ := by
simpa only [FractionalIdeal.mem_coe,
Algebra.smul_def] using
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).smul_mem a hinner)
simpa only [FractionalIdeal.mem_coe, tU] using
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).sub_mem
hscaled (hScalarZ b))
have htG : tG ∈ I⁻¹ := by
have hinner :
algebraMap A K Ux * z +
algebraMap A K hx +
algebraMap A K Vx ∈ I⁻¹ :=
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).add_mem
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).add_mem
(hScalarZ Ux) (hIntegral hx))
(hIntegral Vx))
have hscaled :
algebraMap A K a *
(algebraMap A K Ux * z +
algebraMap A K hx +
algebraMap A K Vx) ∈ I⁻¹ := by
simpa only [FractionalIdeal.mem_coe,
Algebra.smul_def] using
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).smul_mem a hinner)
simpa only [FractionalIdeal.mem_coe, tG] using
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).add_mem
hscaled (hIntegral b))
have hGbarK :
algebraMap A K Gbar =
-(z * algebraMap A K U) := by
rw [hzU]
ring
have hWK :
algebraMap A K W =
z * algebraMap A K G :=
hzG.symm
have hFxK :
algebraMap A K Fx =
algebraMap A K Ux * algebraMap A K W +
algebraMap A K U * algebraMap A K Wx -
algebraMap A K Vx *
algebraMap A K Gbar +
(algebraMap A K hx +
algebraMap A K Vx) *
algebraMap A K G := by
simpa only [map_add, map_sub, map_mul] using
congrArg (algebraMap A K) hFx
have hFx_decomp :
algebraMap A K Fx =
algebraMap A K U *
(algebraMap A K Wx +
algebraMap A K Vx * z) +
algebraMap A K G *
(algebraMap A K Ux * z +
algebraMap A K hx +
algebraMap A K Vx) := by
calc
algebraMap A K Fx =
algebraMap A K Ux *
algebraMap A K W +
algebraMap A K U *
algebraMap A K Wx -
algebraMap A K Vx *
algebraMap A K Gbar +
(algebraMap A K hx +
algebraMap A K Vx) *
algebraMap A K G :=
hFxK
_ =
algebraMap A K U *
(algebraMap A K Wx +
algebraMap A K Vx * z) +
algebraMap A K G *
(algebraMap A K Ux * z +
algebraMap A K hx +
algebraMap A K Vx) := by
rw [hWK, hGbarK]
ring
have hFyK :
algebraMap A K Fy =
algebraMap A K G +
algebraMap A K Gbar := by
simpa only [map_add] using
congrArg (algebraMap A K) hFy
have hFy_decomp :
algebraMap A K Fy =
algebraMap A K U * (-z) +
algebraMap A K G := by
calc
algebraMap A K Fy =
algebraMap A K G +
algebraMap A K Gbar :=
hFyK
_ =
algebraMap A K U * (-z) +
algebraMap A K G := by
rw [hGbarK]
ring
have hBezK :
algebraMap A K a *
algebraMap A K Fx +
algebraMap A K b *
algebraMap A K Fy = 1 := by
simpa only [map_add, map_mul, map_one] using
congrArg (algebraMap A K) hBez
have hframe :
algebraMap A K U * tU +
algebraMap A K G * tG = 1 := by
calc
algebraMap A K U * tU +
algebraMap A K G * tG =
algebraMap A K a *
(algebraMap A K U *
(algebraMap A K Wx +
algebraMap A K Vx * z) +
algebraMap A K G *
(algebraMap A K Ux * z +
algebraMap A K hx +
algebraMap A K Vx)) +
algebraMap A K b *
(algebraMap A K U * (-z) +
algebraMap A K G) := by
dsimp only [tU, tG]
ring
_ =
algebraMap A K a *
algebraMap A K Fx +
algebraMap A K b *
algebraMap A K Fy := by
rw [← hFx_decomp, ← hFy_decomp]
_ = 1 := hBezK
have hmul_le : I * I⁻¹ ≤ 1 := by
rw [FractionalIdeal.mul_le]
intro x hx y hy
have hxy :=
(FractionalIdeal.mem_inv_iff hI_ne).mp
hy x hx
simpa only [mul_comm] using hxy
have hone_le : 1 ≤ I * I⁻¹ := by
rw [FractionalIdeal.one_le, ← hframe]
simpa only [FractionalIdeal.mem_coe] using
(((I * I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).add_mem
(FractionalIdeal.mul_mem_mul hU_I htU)
(FractionalIdeal.mul_mem_mul hG_I htG))
have hmul_eq : I * I⁻¹ = 1 :=
le_antisymm hmul_le hone_le
have hunitI : IsUnit I :=
(FractionalIdeal.mul_inv_cancel_iff_isUnit K).mp
hmul_eq
simpa only [I, M] using hunitI
end
end MazurProof.GraphJacobianDualFrame
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.GeneralizedGraphIdealCore
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Graph ideals on a generalized quadratic curve
Let `A` be an algebra generated by a horizontal coordinate map
`R[X] → A` and an ordinate `y` satisfying
`y² + h(x)y = rhs(x)`.
For a polynomial graph `y = v(x)` whose residual curve equation is
`v² + hv - rhs = uw`, the graph ideal and its hyperelliptic conjugate
multiply to the principal ideal `(u)`, provided the displayed generalized
Jacobian admits a Bézout identity. The proof is purely ring-theoretic and
works over an arbitrary commutative base ring.
-/
open Polynomial
namespace MazurProof.GeneralizedGraphIdealCore
noncomputable section
universe u v
variable {R : Type u} {A : Type v} [CommRing R] [CommRing A]
/-- Polynomial graph data on `y² + hy = rhs`. -/
structure SemiGraph (h rhs : R[X]) where
u : R[X]
v : R[X]
w : R[X]
curve_eq : v ^ 2 + h * v - rhs = u * w
/-- Hyperelliptic conjugation on graph ordinates. -/
def conjugateV (h v : R[X]) : R[X] :=
-h - v
def ySubClass
(xClass : R[X] →+* A) (yClass : A) (v : R[X]) : A :=
yClass - xClass v
def graphIdeal
(xClass : R[X] →+* A) (yClass : A) (u v : R[X]) :
Ideal A :=
Ideal.span {xClass u, ySubClass xClass yClass v}
theorem xClass_mem_graphIdeal
(xClass : R[X] →+* A) (yClass : A) (u v : R[X]) :
xClass u ∈ graphIdeal xClass yClass u v :=
Ideal.subset_span (by simp)
theorem ySubClass_mem_graphIdeal
(xClass : R[X] →+* A) (yClass : A) (u v : R[X]) :
ySubClass xClass yClass v ∈ graphIdeal xClass yClass u v :=
Ideal.subset_span (by simp)
/-- Multiplying the horizontal equation by a factor whose image is a unit
does not change the graph ideal. -/
theorem graphIdeal_mul_left_eq_of_isUnit
(xClass : R[X] →+* A) (yClass : A)
(c u v : R[X]) (hc : IsUnit (xClass c)) :
graphIdeal xClass yClass (c * u) v =
graphIdeal xClass yClass u v := by
apply le_antisymm
· apply Ideal.span_le.mpr
intro z hz
simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
rcases hz with rfl | rfl
· rw [map_mul]
exact Ideal.mul_mem_left _
(xClass c) (xClass_mem_graphIdeal xClass yClass u v)
· exact ySubClass_mem_graphIdeal xClass yClass u v
· apply Ideal.span_le.mpr
intro z hz
simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
rcases hz with rfl | rfl
· obtain ⟨d, hdc⟩ := isUnit_iff_exists_inv.mp hc
have hdc' : d * xClass c = 1 := by
simpa [mul_comm] using hdc
have hcu :
xClass (c * u) ∈
graphIdeal xClass yClass (c * u) v :=
xClass_mem_graphIdeal xClass yClass (c * u) v
have hdcu :=
Ideal.mul_mem_left
(graphIdeal xClass yClass (c * u) v) d hcu
rw [map_mul] at hdcu
simpa [← mul_assoc, hdc'] using hdcu
· exact ySubClass_mem_graphIdeal xClass yClass (c * u) v
/-- Replacing the graph ordinate by a congruent polynomial modulo the
horizontal equation does not change the graph ideal. -/
theorem graphIdeal_eq_of_dvd_sub
(xClass : R[X] →+* A) (yClass : A)
(u v V : R[X]) (h : u ∣ V - v) :
graphIdeal xClass yClass u V =
graphIdeal xClass yClass u v := by
obtain ⟨t, ht⟩ := h
apply le_antisymm
· apply Ideal.span_le.mpr
intro z hz
simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
rcases hz with rfl | rfl
· exact xClass_mem_graphIdeal xClass yClass u v
· have hmultiple :
xClass (V - v) ∈ graphIdeal xClass yClass u v := by
rw [ht, map_mul, mul_comm]
exact Ideal.mul_mem_left _
(xClass t) (xClass_mem_graphIdeal xClass yClass u v)
have heq :
ySubClass xClass yClass V =
ySubClass xClass yClass v - xClass (V - v) := by
simp [ySubClass, map_sub]
rw [heq]
exact Ideal.sub_mem _
(ySubClass_mem_graphIdeal xClass yClass u v) hmultiple
· apply Ideal.span_le.mpr
intro z hz
simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
rcases hz with rfl | rfl
· exact xClass_mem_graphIdeal xClass yClass u V
· have hmultiple :
xClass (V - v) ∈ graphIdeal xClass yClass u V := by
rw [ht, map_mul, mul_comm]
exact Ideal.mul_mem_left _
(xClass t) (xClass_mem_graphIdeal xClass yClass u V)
have heq :
ySubClass xClass yClass v =
ySubClass xClass yClass V + xClass (V - v) := by
simp [ySubClass, map_sub]
rw [heq]
exact Ideal.add_mem _
(ySubClass_mem_graphIdeal xClass yClass u V) hmultiple
/-- Two graph ideals with coprime horizontal equations multiply to the
graph ideal of the product. The common ordinate is only required modulo
the two factors, so this is the ideal-theoretic Chinese remainder theorem
for a split divisor. -/
theorem graphIdeal_mul_of_coprime
(xClass : R[X] →+* A) (yClass : A)
(u₁ u₂ v₁ v₂ V : R[X])
(h₁ : u₁ ∣ V - v₁)
(h₂ : u₂ ∣ V - v₂)
(hcoprime :
∃ a b : R[X], a * u₁ + b * u₂ = 1) :
graphIdeal xClass yClass u₁ v₁ *
graphIdeal xClass yClass u₂ v₂ =
graphIdeal xClass yClass (u₁ * u₂) V := by
rw [← graphIdeal_eq_of_dvd_sub xClass yClass u₁ v₁ V h₁,
← graphIdeal_eq_of_dvd_sub xClass yClass u₂ v₂ V h₂]
let I₁ := graphIdeal xClass yClass u₁ V
let I₂ := graphIdeal xClass yClass u₂ V
let I := graphIdeal xClass yClass (u₁ * u₂) V
let g := ySubClass xClass yClass V
apply le_antisymm
· rw [graphIdeal, graphIdeal, graphIdeal,
Ideal.span_pair_mul_span_pair]
apply Ideal.span_le.mpr
intro z hz
simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
rcases hz with rfl | rfl | rfl | rfl
· exact Ideal.subset_span (by simp [map_mul])
· exact Ideal.mul_mem_left I (xClass u₁)
(ySubClass_mem_graphIdeal xClass yClass (u₁ * u₂) V)
· exact Ideal.mul_mem_right (xClass u₂) _
(Ideal.subset_span
(Set.mem_insert_iff.mpr
(Or.inr (Set.mem_singleton _))))
· exact Ideal.mul_mem_left I g
(ySubClass_mem_graphIdeal xClass yClass (u₁ * u₂) V)
· apply Ideal.span_le.mpr
intro z hz
simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
rcases hz with rfl | rfl
· rw [map_mul]
exact Ideal.mul_mem_mul
(xClass_mem_graphIdeal xClass yClass u₁ V)
(xClass_mem_graphIdeal xClass yClass u₂ V)
· obtain ⟨a, b, hab⟩ := hcoprime
have h₁g :
xClass u₁ * g ∈ I₁ * I₂ :=
Ideal.mul_mem_mul
(xClass_mem_graphIdeal xClass yClass u₁ V)
(ySubClass_mem_graphIdeal xClass yClass u₂ V)
have hg₂ :
g * xClass u₂ ∈ I₁ * I₂ :=
Ideal.mul_mem_mul
(ySubClass_mem_graphIdeal xClass yClass u₁ V)
(xClass_mem_graphIdeal xClass yClass u₂ V)
have ha :
xClass a * (xClass u₁ * g) ∈ I₁ * I₂ :=
Ideal.mul_mem_left _ (xClass a) h₁g
have hb :
xClass b * (g * xClass u₂) ∈ I₁ * I₂ :=
Ideal.mul_mem_left _ (xClass b) hg₂
have hsum := Ideal.add_mem (I₁ * I₂) ha hb
have heq :
xClass a * (xClass u₁ * g) +
xClass b * (g * xClass u₂) = g := by
calc
_ = xClass (a * u₁ + b * u₂) * g := by
simp only [map_add, map_mul]
ring
_ = g := by rw [hab, map_one, one_mul]
rw [heq] at hsum
exact hsum
/-- The product of the two raw graph functions is the negative substituted
curve equation. -/
theorem ySubClass_mul_conjugateV_raw
(xClass : R[X] →+* A) (yClass : A) (h rhs v : R[X])
(hy : yClass ^ 2 + xClass h * yClass = xClass rhs) :
ySubClass xClass yClass v *
ySubClass xClass yClass (conjugateV h v) =
-xClass (v ^ 2 + h * v - rhs) := by
calc
ySubClass xClass yClass v *
ySubClass xClass yClass (conjugateV h v) =
yClass ^ 2 + xClass h * yClass -
(xClass v ^ 2 + xClass h * xClass v) := by
simp only [ySubClass, conjugateV, map_neg, map_sub]
ring
_ = xClass rhs - xClass (v ^ 2 + h * v) := by
rw [hy, map_add, map_mul, map_pow]
_ = -xClass (v ^ 2 + h * v - rhs) := by
rw [map_sub]
ring
theorem ySubClass_mul_conjugate
(xClass : R[X] →+* A) (yClass : A) (h rhs : R[X])
(D : SemiGraph h rhs)
(hy : yClass ^ 2 + xClass h * yClass = xClass rhs) :
ySubClass xClass yClass D.v *
ySubClass xClass yClass (conjugateV h D.v) =
-(xClass D.u * xClass D.w) := by
calc
ySubClass xClass yClass D.v *
ySubClass xClass yClass (conjugateV h D.v) =
-xClass (D.v ^ 2 + h * D.v - rhs) :=
ySubClass_mul_conjugateV_raw xClass yClass h rhs D.v hy
_ = -xClass (D.u * D.w) := by rw [D.curve_eq]
_ = -(xClass D.u * xClass D.w) := by rw [map_mul]
/-- A generalized graph and its hyperelliptic conjugate multiply to `(u)`.
The only regularity input is the explicit Bézout identity for
`u`, `2v+h`, and `w`. -/
theorem graphIdeal_mul_conj
(xClass : R[X] →+* A) (yClass : A) (h rhs : R[X])
(D : SemiGraph h rhs)
(hy : yClass ^ 2 + xClass h * yClass = xClass rhs)
(hbez :
∃ a b c : R[X],
a * D.u + b * (2 * D.v + h) + c * D.w = 1) :
graphIdeal xClass yClass D.u D.v *
graphIdeal xClass yClass D.u (conjugateV h D.v) =
Ideal.span ({xClass D.u} : Set A) := by
let I := graphIdeal xClass yClass D.u D.v
let J :=
graphIdeal xClass yClass D.u (conjugateV h D.v)
apply le_antisymm
· apply Ideal.mul_le.mpr
intro p hp q hq
rw [Ideal.mem_span_singleton]
obtain ⟨p₀, pY, hpEq⟩ := Ideal.mem_span_pair.mp hp
obtain ⟨q₀, qY, hqEq⟩ := Ideal.mem_span_pair.mp hq
refine
⟨p₀ * q₀ * xClass D.u +
p₀ * qY *
ySubClass xClass yClass (conjugateV h D.v) +
pY * q₀ * ySubClass xClass yClass D.v -
pY * qY * xClass D.w,
?_⟩
rw [← hpEq, ← hqEq]
linear_combination
pY * qY *
ySubClass_mul_conjugate xClass yClass h rhs D hy
· rw [Ideal.span_singleton_le_iff_mem]
obtain ⟨a, b, c, habc⟩ := hbez
have huI : xClass D.u ∈ I :=
xClass_mem_graphIdeal xClass yClass D.u D.v
have huJ : xClass D.u ∈ J :=
xClass_mem_graphIdeal xClass yClass D.u
(conjugateV h D.v)
have hvI : ySubClass xClass yClass D.v ∈ I :=
ySubClass_mem_graphIdeal xClass yClass D.u D.v
have hvJ :
ySubClass xClass yClass (conjugateV h D.v) ∈ J :=
ySubClass_mem_graphIdeal xClass yClass D.u
(conjugateV h D.v)
have hu2 : xClass D.u * xClass D.u ∈ I * J :=
Ideal.mul_mem_mul huI huJ
have huv : xClass D.u * xClass (2 * D.v + h) ∈ I * J := by
have hp :
xClass D.u *
ySubClass xClass yClass (conjugateV h D.v) ∈ I * J :=
Ideal.mul_mem_mul huI hvJ
have hm :
ySubClass xClass yClass D.v * xClass D.u ∈ I * J :=
Ideal.mul_mem_mul hvI huJ
have hd := Ideal.sub_mem (I * J) hp hm
convert hd using 1
simp only [two_mul, ySubClass, conjugateV, map_neg, map_sub,
map_add]
ring
have huw : xClass D.u * xClass D.w ∈ I * J := by
have hg :
ySubClass xClass yClass D.v *
ySubClass xClass yClass (conjugateV h D.v) ∈ I * J :=
Ideal.mul_mem_mul hvI hvJ
have hneg := (I * J).neg_mem hg
rw [ySubClass_mul_conjugate xClass yClass h rhs D hy] at hneg
simpa using hneg
have ha :
xClass a * (xClass D.u * xClass D.u) ∈ I * J :=
Ideal.mul_mem_left (I * J) (xClass a) hu2
have hb :
xClass b * (xClass D.u * xClass (2 * D.v + h)) ∈ I * J :=
Ideal.mul_mem_left (I * J) (xClass b) huv
have hc :
xClass c * (xClass D.u * xClass D.w) ∈ I * J :=
Ideal.mul_mem_left (I * J) (xClass c) huw
have hsum :=
Ideal.add_mem (I * J) (Ideal.add_mem (I * J) ha hb) hc
have heq :
xClass a * (xClass D.u * xClass D.u) +
xClass b * (xClass D.u * xClass (2 * D.v + h)) +
xClass c * (xClass D.u * xClass D.w) =
xClass D.u := by
calc
_ = xClass D.u *
xClass
(a * D.u + b * (2 * D.v + h) + c * D.w) := by
simp only [two_mul, map_add, map_mul]
ring
_ = xClass D.u * 1 := by rw [habc, map_one]
_ = xClass D.u := mul_one _
rw [heq] at hsum
exact hsum
end
end MazurProof.GeneralizedGraphIdealCore
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13IntegralGraphJacobian
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Integral N13 graph ideals and the affine Jacobian
This file instantiates the generic graph-Jacobian dual frame for the good
integral N13 equation. A short resultant certificate proves that the two
relative Jacobian rows generate one globally, so every integral Mumford
graph ideal is invertible. No fixed special graph or point classification
is used.
-/
open Polynomial
open scoped nonZeroDivisors
namespace MazurProof.N13IntegralGraphJacobian
noncomputable section
local instance instFactPrimeOfNatNat_fLT : Fact (Nat.Prime 2) :=
⟨Nat.prime_two⟩
abbrev R₂ : Type :=
N13IntegralModelContraction.R₂
abbrev IntegralRing : Type :=
N13IntegralFractionalHull.IntegralRing
abbrev RationalRing : Type :=
N13IntegralFractionalHull.RationalRing
abbrev FunctionField : Type :=
N13IntegralFractionalHull.FunctionField
abbrev IntegralFractionalIdeal : Type :=
N13IntegralFractionalHull.IntegralFractionalIdeal
abbrev SemiMumford₂ : Type :=
N13GeneralizedMumfordIntegral.SemiMumford
(R := R₂)
local instance integralRingDomain :
IsDomain IntegralRing :=
N13IntegralFractionalHull.integralToRational_injective.isDomain
N13IntegralFractionalHull.integralToRational
local instance integralRationalAlgebra :
Algebra IntegralRing RationalRing :=
N13IntegralFractionalHull.integralToRational.toAlgebra
local instance integralFunctionFieldFractionRing :
IsFractionRing IntegralRing FunctionField :=
N13IntegralFractionalHull.functionField_isFractionRing
open N13GeneralizedMumfordIntegral
/-- The relative `Y`-Jacobian row of
`Y² + h(X)Y - rhs(X)`. -/
def jacobianY : IntegralRing :=
2 * yClass +
xClass (hPoly (R := R₂))
/-- The relative `X`-Jacobian row of
`Y² + h(X)Y - rhs(X)`. -/
def jacobianX : IntegralRing :=
xClass (derivative (hPoly (R := R₂))) *
yClass -
xClass (derivative (rhsPoly (R := R₂)))
private theorem derivative_hPoly_explicit :
derivative (hPoly (R := R₂)) =
(3 : R₂[X]) * X ^ 2 + 1 := by
simp [hPoly, derivative_add, derivative_pow]
exact map_natCast C 3
private theorem derivative_rhsPoly_explicit :
derivative (rhsPoly (R := R₂)) =
(5 : R₂[X]) * X ^ 4 +
(4 : R₂[X]) * X ^ 3 := by
simp [rhsPoly, derivative_add, derivative_pow]
congr 1
private theorem derivative_curve_eq
(D : SemiMumford₂) :
(C (2 : R₂) * D.v + hPoly) *
derivative D.v +
derivative hPoly * D.v -
derivative rhsPoly =
derivative D.u * D.w +
D.u * derivative D.w := by
have h := congrArg derivative D.curve_eq
simp only [derivative_sub, derivative_add,
derivative_mul, derivative_pow] at h
norm_num only [Nat.reduceSub, pow_one] at h
linear_combination h
/-- The `Y`-Jacobian row is the sum of the graph function and its
hyperelliptic conjugate. -/
theorem jacobianY_eq_graph_add_conjugate
(D : SemiMumford₂) :
jacobianY =
ySubClass D.v +
ySubClass (conjugateV D.v) := by
simp only [jacobianY, ySubClass, conjugateV,
xClass_neg, xClass_sub]
ring
/-- Differentiating the integral Mumford equation decomposes the
`X`-Jacobian row along the two graph generators. -/
theorem jacobianX_eq_graph_decomposition
(D : SemiMumford₂) :
jacobianX =
xClass (derivative D.u) * xClass D.w +
xClass D.u * xClass (derivative D.w) -
xClass (derivative D.v) *
ySubClass (conjugateV D.v) +
(xClass (derivative hPoly) +
xClass (derivative D.v)) *
ySubClass D.v := by
have h :=
congrArg
(xClass (R := R₂))
(derivative_curve_eq D)
have htwo :
xClass (R := R₂) (C (2 : R₂)) =
(2 : IntegralRing) := by
rw [show C (2 : R₂) = (2 : R₂[X]) by
exact map_natCast C 2]
exact xClass_natCast 2
simp only [jacobianX, ySubClass, conjugateV,
xClass_add, xClass_sub, xClass_neg,
xClass_mul] at h ⊢
rw [htwo] at h
linear_combination h
/-- The first coordinate-ring coefficient of the Jacobian Bézout
certificate. -/
def bezoutA : IntegralRing :=
(30 * xClass X ^ 5 + 97 * xClass X ^ 4 +
92 * xClass X ^ 3 + 50 * xClass X + 31) +
(10 * xClass X ^ 2 + 30 * xClass X - 3) *
yClass
/-- The second coordinate-ring coefficient of the Jacobian Bézout
certificate. -/
def bezoutB : IntegralRing :=
(63 * xClass X ^ 5 + 153 * xClass X ^ 4 +
98 * xClass X ^ 3 + 13 * xClass X ^ 2 -
13 * xClass X + 13) +
(60 * xClass X ^ 4 + 151 * xClass X ^ 3 +
151 * xClass X ^ 2 - 63 * xClass X + 60) *
yClass
/-- The integral resultant certificate for the two relative Jacobian
rows. It comes from the univariate Euclidean identity between
`h² + 4 * rhs` and `h' * h + 2 * rhs'`; its right-hand side is the
optimal odd scalar `13`. -/
theorem scaled_jacobian_bezout :
bezoutA * jacobianX + bezoutB * jacobianY =
(13 : IntegralRing) := by
have hcurve :=
yClass_relation (R := R₂)
simp only [jacobianX, derivative_hPoly_explicit,
derivative_rhsPoly_explicit, xClass_add,
xClass_mul, xClass_pow]
have h3 :
xClass (R := R₂) (3 : R₂[X]) =
(3 : IntegralRing) :=
xClass_natCast 3
have h4 :
xClass (R := R₂) (4 : R₂[X]) =
(4 : IntegralRing) :=
xClass_natCast 4
have h5 :
xClass (R := R₂) (5 : R₂[X]) =
(5 : IntegralRing) :=
xClass_natCast 5
rw [h3, h4, h5]
simp [bezoutA, bezoutB, jacobianY,
hPoly, rhsPoly] at hcurve ⊢
linear_combination
(150 * xClass (R := R₂) X ^ 4 +
392 * xClass (R := R₂) X ^ 3 +
303 * xClass (R := R₂) X ^ 2 -
96 * xClass (R := R₂) X + 117) * hcurve
/-- The odd resultant scalar in the Jacobian certificate is a unit in the
integral coordinate ring. -/
theorem thirteen_isUnit :
IsUnit (13 : IntegralRing) := by
have h : IsUnit (13 : R₂) := by
rw [PadicInt.isUnit_iff]
exact
PadicInt.norm_natCast_eq_one_iff.mpr
(by norm_num)
convert h.map (algebraMap R₂ IntegralRing) using 1
exact
(map_natCast (algebraMap R₂ IntegralRing) 13).symm
/-- The two relative Jacobian rows generate the unit ideal globally over
the integral N13 model. -/
theorem exists_jacobian_bezout :
∃ a b : IntegralRing,
a * jacobianX + b * jacobianY = 1 := by
let u : IntegralRingˣ :=
thirteen_isUnit.unit
refine
⟨(u⁻¹ : IntegralRingˣ) * bezoutA,
(u⁻¹ : IntegralRingˣ) * bezoutB, ?_⟩
calc
(((u⁻¹ : IntegralRingˣ) : IntegralRing) *
bezoutA) * jacobianX +
(((u⁻¹ : IntegralRingˣ) : IntegralRing) *
bezoutB) * jacobianY =
((u⁻¹ : IntegralRingˣ) : IntegralRing) *
(bezoutA * jacobianX +
bezoutB * jacobianY) := by ring
_ =
((u⁻¹ : IntegralRingˣ) : IntegralRing) * 13 := by
rw [scaled_jacobian_bezout]
_ =
((u⁻¹ : IntegralRingˣ) : IntegralRing) *
(u : IntegralRing) := by
rw [thirteen_isUnit.unit_spec]
_ = 1 := by simp
/-! ## Graphs without a monicity hypothesis
Monicity is needed by the quotient-basis and contraction arguments, but not
by the Jacobian dual frame. The following version isolates the exact
regularity input here: the horizontal graph equation is merely nonzero.
-/
abbrev GraphData : Type :=
GeneralizedGraphIdealCore.SemiGraph
(hPoly (R := R₂)) (rhsPoly (R := R₂))
private theorem derivative_graphData_curve_eq
(D : GraphData) :
(C (2 : R₂) * D.v + hPoly) *
derivative D.v +
derivative hPoly * D.v -
derivative rhsPoly =
derivative D.u * D.w +
D.u * derivative D.w := by
have h := congrArg derivative D.curve_eq
simp only [derivative_sub, derivative_add,
derivative_mul, derivative_pow] at h
norm_num only [Nat.reduceSub, pow_one] at h
linear_combination h
private theorem jacobianY_eq_graphData
(D : GraphData) :
jacobianY =
GeneralizedGraphIdealCore.ySubClass
xClassHom yClass D.v +
GeneralizedGraphIdealCore.ySubClass
xClassHom yClass
(GeneralizedGraphIdealCore.conjugateV hPoly D.v) := by
simp only [jacobianY, GeneralizedGraphIdealCore.ySubClass,
GeneralizedGraphIdealCore.conjugateV,
xClassHom_apply, xClass_neg, xClass_sub]
ring
private theorem jacobianX_eq_graphData
(D : GraphData) :
jacobianX =
xClass (derivative D.u) * xClass D.w +
xClass D.u * xClass (derivative D.w) -
xClass (derivative D.v) *
GeneralizedGraphIdealCore.ySubClass
xClassHom yClass
(GeneralizedGraphIdealCore.conjugateV hPoly D.v) +
(xClass (derivative hPoly) +
xClass (derivative D.v)) *
GeneralizedGraphIdealCore.ySubClass
xClassHom yClass D.v := by
have h :=
congrArg
(xClass (R := R₂))
(derivative_graphData_curve_eq D)
have htwo :
xClass (R := R₂) (C (2 : R₂)) =
(2 : IntegralRing) := by
rw [show C (2 : R₂) = (2 : R₂[X]) by
exact map_natCast C 2]
exact xClass_natCast 2
simp only [jacobianX,
GeneralizedGraphIdealCore.ySubClass,
GeneralizedGraphIdealCore.conjugateV,
xClassHom_apply, xClass_add, xClass_sub, xClass_neg,
xClass_mul] at h ⊢
rw [htwo] at h
linear_combination h
/-- Every nondegenerate integral polynomial graph on the affine good model
is invertible. Its horizontal equation need not be monic. -/
theorem graphIdeal_isUnit
(D : GraphData)
(hu : D.u ≠ 0) :
IsUnit
((GeneralizedGraphIdealCore.graphIdeal
xClassHom yClass D.u D.v :
Ideal IntegralRing) :
IntegralFractionalIdeal) := by
obtain ⟨a, b, hBez⟩ := exists_jacobian_bezout
apply
GraphJacobianDualFrame.graphJacobian_isUnit
(K := FunctionField)
(U := xClass D.u)
(G :=
GeneralizedGraphIdealCore.ySubClass
xClassHom yClass D.v)
(Gbar :=
GeneralizedGraphIdealCore.ySubClass
xClassHom yClass
(GeneralizedGraphIdealCore.conjugateV hPoly D.v))
(W := xClass D.w)
(Fy := jacobianY)
(Fx := jacobianX)
(Ux := xClass (derivative D.u))
(Wx := xClass (derivative D.w))
(Vx := xClass (derivative D.v))
(hx := xClass (derivative hPoly))
(a := a) (b := b)
· intro hzero
apply hu
have hcoeff :=
congrArg (coeff0 (R := R₂)) hzero
simpa only [coeff0_xClass, map_zero] using hcoeff
· exact
GeneralizedGraphIdealCore.ySubClass_mul_conjugate
xClassHom yClass hPoly rhsPoly D
(yClass_relation (R := R₂))
· exact jacobianY_eq_graphData D
· exact jacobianX_eq_graphData D
· exact hBez
/-- A global relative-Jacobian Bézout pair makes every integral smooth
Mumford graph invertible by the explicit graph dual frame. -/
theorem mumfordIdeal_isUnit_of_jacobianBezout
(D : SemiMumford₂)
(a b : IntegralRing)
(hBez :
a * jacobianX + b * jacobianY = 1) :
IsUnit
((mumfordIdeal D.u D.v :
Ideal IntegralRing) :
IntegralFractionalIdeal) := by
apply
GraphJacobianDualFrame.graphJacobian_isUnit
(K := FunctionField)
(U := xClass D.u)
(G := ySubClass D.v)
(Gbar := ySubClass (conjugateV D.v))
(W := xClass D.w)
(Fy := jacobianY)
(Fx := jacobianX)
(Ux := xClass (derivative D.u))
(Wx := xClass (derivative D.w))
(Vx := xClass (derivative D.v))
(hx := xClass (derivative hPoly))
(a := a) (b := b)
· intro hzero
apply D.u_monic.ne_zero
have hcoeff :=
congrArg (coeff0 (R := R₂)) hzero
simpa only [coeff0_xClass, map_zero] using hcoeff
· exact ySubClass_mul_conjugate D
· exact jacobianY_eq_graph_add_conjugate D
· exact jacobianX_eq_graph_decomposition D
· exact hBez
/-- Every integral N13 Mumford graph ideal is invertible. The proof is
the explicit graph dual frame together with the global Jacobian
certificate above. -/
theorem mumfordIdeal_isUnit
(D : SemiMumford₂) :
IsUnit
((mumfordIdeal D.u D.v :
Ideal IntegralRing) :
IntegralFractionalIdeal) := by
obtain ⟨a, b, hBez⟩ :=
exists_jacobian_bezout
exact
mumfordIdeal_isUnit_of_jacobianBezout
D a b hBez
end
end MazurProof.N13IntegralGraphJacobian
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13RankTwoSemiGraphRecovery
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
/-!
# Recovering an integral semigraph from a rank-two quotient basis
The graph-recovery algebra does not need a selected special divisor until
one asks for a particular vertical smoothness certificate. A literal
integral quotient basis `{1,x}` already recovers a monic quadratic
generalized Mumford semigraph and identifies its graph ideal with the
canonical contraction.
This is the special-class-independent core needed for arbitrary proper
specialization.
-/
open Module
open Polynomial
namespace MazurProof.N13RankTwoSemiGraphRecovery
noncomputable section
abbrev R₂ : Type :=
N13ConcreteGraphRecovery.R₂
abbrev IntegralRing : Type :=
N13ConcreteGraphRecovery.IntegralRing
abbrev Model : SexticMumford.Model
N13IntegralModelContraction.Q₂ :=
N13ConcreteGraphRecovery.Model
abbrev SemiMumford₂ : Type :=
N13GeneralizedMumfordIntegral.TwoAdic.SemiMumford₂
/-- A quotient basis `{1,x}` recovers the canonical contraction as a
literal integral monic quadratic graph ideal. -/
theorem exists_integral_semiGraph_of_basis
(D : SexticMumford.SemiMumford Model)
(b : Basis (Fin 2) R₂
(IntegralRing ⧸
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)))
(hb :
(b : Fin 2 →
IntegralRing ⧸
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)) =
N13TwoFiberNoEscape.pairFamily
1
(Ideal.Quotient.mk
(N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D))
N13CanonicalContractionQuotient.integralX)) :
∃ E : SemiMumford₂,
E.u.natDegree = 2 ∧
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D) =
N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) E.u E.v := by
let I :=
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)
let B := IntegralRing ⧸ I
let xbar : B :=
Ideal.Quotient.mk I
N13CanonicalContractionQuotient.integralX
let ybar : B :=
Ideal.Quotient.mk I
N13ConcreteGraphRecovery.integralY
have hb0 : b 0 = 1 := by
have h := congrFun hb (0 : Fin 2)
simpa [N13TwoFiberNoEscape.pairFamily] using h
have hb1 : b 1 = xbar := by
have h := congrFun hb (1 : Fin 2)
simpa [N13TwoFiberNoEscape.pairFamily, xbar, I] using h
letI : Module.Free R₂ B :=
Module.Free.of_basis b
letI : Module.Finite R₂ B :=
Module.Finite.of_basis b
letI : Nontrivial B :=
⟨⟨1, 0, by
rw [← hb0]
exact b.ne_zero 0⟩⟩
obtain ⟨a, c, hy⟩ :=
N13RankTwoQuotientAlgebra.exists_eq_algebraMap_add_algebraMap_mul
xbar ybar b hb0 hb1
let u : R₂[X] :=
(Algebra.lmul R₂ B xbar).charpoly
let v : R₂[X] :=
C a + C c * X
have huMonic : u.Monic :=
N13RankTwoQuotientAlgebra.charpoly_lmul_monic_of_one_x xbar
have huDegree : u.natDegree = 2 :=
N13RankTwoQuotientAlgebra.charpoly_lmul_natDegree_of_one_x
xbar b hb0 hb1
have hker :
RingHom.ker
((aeval xbar : R₂[X] →ₐ[R₂] B).toRingHom) =
Ideal.span ({u} : Set R₂[X]) := by
exact
N13RankTwoQuotientAlgebra.ker_aeval_eq_span_charpoly_of_one_x
xbar b hb0 hb1
have hyv : ybar = aeval xbar v := by
calc
ybar =
algebraMap R₂ B a +
algebraMap R₂ B c * xbar := hy
_ = aeval xbar v := by
simp [v]
have hI :=
N13RankTwoIdealRecovery.ideal_eq_span_aeval_y_sub
(R := R₂)
N13CanonicalContractionQuotient.integralX
N13ConcreteGraphRecovery.integralY I u v
N13ConcreteGraphRecovery.integral_rankTwoPolynomialNormalForm
hker hyv
have hIgraph :
I =
N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) u v := by
simpa [N13GeneralizedMumfordIntegral.mumfordIdeal,
N13GeneralizedMumfordIntegral.ySubClass,
N13ConcreteGraphRecovery.integralY,
N13ConcreteGraphRecovery.aeval_integralX] using hI
let residual : R₂[X] :=
v ^ 2 +
N13GeneralizedMumfordIntegral.hPoly (R := R₂) * v -
N13GeneralizedMumfordIntegral.rhsPoly (R := R₂)
have hresGraph :
N13GeneralizedMumfordIntegral.xClass (R := R₂) residual ∈
N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) u v := by
have hyMem :
N13GeneralizedMumfordIntegral.ySubClass (R := R₂) v ∈
N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) u v :=
N13GeneralizedMumfordIntegral.ySubClass_mem_mumfordIdeal u v
have hprod :
N13GeneralizedMumfordIntegral.ySubClass (R := R₂) v *
N13GeneralizedMumfordIntegral.ySubClass
(R := R₂)
(N13GeneralizedMumfordIntegral.conjugateV v) ∈
N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) u v :=
Ideal.mul_mem_right _ _ hyMem
rw [N13GeneralizedMumfordIntegral.ySubClass_mul_conjugateV_raw]
at hprod
have hneg :=
(N13GeneralizedMumfordIntegral.mumfordIdeal
(R := R₂) u v).neg_mem hprod
simpa [residual] using hneg
have hresI :
N13GeneralizedMumfordIntegral.xClass (R := R₂) residual ∈ I := by
rw [hIgraph]
exact hresGraph
have hresEval :
aeval xbar residual = 0 := by
rw [N13ConcreteGraphRecovery.quotient_aeval_integralX]
exact Ideal.Quotient.eq_zero_iff_mem.mpr hresI
have hresKer :
residual ∈
RingHom.ker
((aeval xbar : R₂[X] →ₐ[R₂] B).toRingHom) :=
RingHom.mem_ker.mpr hresEval
rw [hker, Ideal.mem_span_singleton] at hresKer
obtain ⟨w, hw⟩ := hresKer
have hcurve :
v ^ 2 +
N13GeneralizedMumfordIntegral.hPoly (R := R₂) * v -
N13GeneralizedMumfordIntegral.rhsPoly (R := R₂) =
u * w := by
simpa [residual] using hw
let E : SemiMumford₂ :=
{ u := u
v := v
w := w
u_monic := huMonic
curve_eq := hcurve }
refine ⟨E, huDegree, ?_⟩
exact hIgraph
end
end MazurProof.N13RankTwoSemiGraphRecovery
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.GraphJacobianDecompositionFrame
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
open scoped nonZeroDivisors
/-!
# A decomposition form of the graph-Jacobian dual frame
For a two-generated ideal `(U,G)`, a complementary factorization
`G H = -U W` puts both integral scalars and integral multiples of
`-H/U` in the inverse ideal. Arbitrary decompositions of two Jacobian
rows in the four elements `U,G,H,W`, together with a global Bézout
identity, therefore give an explicit dual frame.
-/
namespace MazurProof.GraphJacobianDecompositionFrame
noncomputable section
variable {A K : Type*}
variable [CommRing A] [IsDomain A]
variable [Field K] [Algebra A K] [IsFractionRing A K]
theorem graphJacobian_isUnit_of_decompositions
(U G H W Fx Fy
αx βx γx δx αy βy γy δy a b : A)
(hU : U ≠ 0)
(hGH : G * H = -(U * W))
(hFx :
Fx = U * αx + G * βx + H * γx + W * δx)
(hFy :
Fy = U * αy + G * βy + H * γy + W * δy)
(hBez : a * Fx + b * Fy = 1) :
IsUnit
((Ideal.span ({U, G} : Set A) : Ideal A) :
FractionalIdeal A⁰ K) := by
let M : Ideal A :=
Ideal.span ({U, G} : Set A)
let I : FractionalIdeal A⁰ K :=
(M : FractionalIdeal A⁰ K)
have hU_M : U ∈ M := by
exact Ideal.subset_span (by simp)
have hG_M : G ∈ M := by
exact Ideal.subset_span (by simp)
have hU_I : algebraMap A K U ∈ I := by
simpa only [I] using
(FractionalIdeal.mem_coeIdeal_of_mem A⁰ hU_M)
have hG_I : algebraMap A K G ∈ I := by
simpa only [I] using
(FractionalIdeal.mem_coeIdeal_of_mem A⁰ hG_M)
have hI_le_one : I ≤ 1 := by
exact FractionalIdeal.coeIdeal_le_one
have hI_ne : I ≠ 0 := by
intro hI0
have hmapU0 : algebraMap A K U = 0 :=
(FractionalIdeal.eq_zero_iff.mp hI0)
(algebraMap A K U) hU_I
exact hU
(IsFractionRing.to_map_eq_zero_iff.mp hmapU0)
have hmapU_ne : algebraMap A K U ≠ 0 := by
simpa only [map_zero] using
(IsFractionRing.injective A K).ne hU
have hGHK :
algebraMap A K G * algebraMap A K H =
-(algebraMap A K U * algebraMap A K W) := by
simpa only [map_mul, map_neg] using
congrArg (algebraMap A K) hGH
let z : K :=
-algebraMap A K H / algebraMap A K U
have hzU :
z * algebraMap A K U =
-algebraMap A K H := by
dsimp only [z]
field_simp [hmapU_ne]
have hzG :
z * algebraMap A K G =
algebraMap A K W := by
calc
z * algebraMap A K G =
-(algebraMap A K H *
algebraMap A K G) /
algebraMap A K U := by
dsimp only [z]
ring
_ =
-(algebraMap A K G *
algebraMap A K H) /
algebraMap A K U := by ring
_ =
-(-(algebraMap A K U *
algebraMap A K W)) /
algebraMap A K U := by rw [hGHK]
_ = algebraMap A K W := by
field_simp [hmapU_ne]
have hz_mem : z ∈ I⁻¹ := by
rw [FractionalIdeal.mem_inv_iff hI_ne]
intro y hy
change y ∈ (M : FractionalIdeal A⁰ K) at hy
rw [FractionalIdeal.mem_coeIdeal A⁰] at hy
obtain ⟨yA, hyA, hyEq⟩ := hy
subst y
obtain ⟨c, d, hcd⟩ :=
Ideal.mem_span_pair.mp
(by simpa only [M] using hyA)
rw [FractionalIdeal.mem_one_iff A⁰]
refine ⟨-c * H + d * W, ?_⟩
calc
algebraMap A K (-c * H + d * W) =
algebraMap A K c *
(-algebraMap A K H) +
algebraMap A K d *
algebraMap A K W := by
simp only [map_add, map_mul, map_neg]
ring
_ =
algebraMap A K c *
(z * algebraMap A K U) +
algebraMap A K d *
(z * algebraMap A K G) := by
rw [← hzU, ← hzG]
_ =
z * algebraMap A K
(c * U + d * G) := by
simp only [map_add, map_mul]
ring
_ = z * algebraMap A K yA := by rw [hcd]
have hone_inv : (1 : K) ∈ I⁻¹ := by
rw [FractionalIdeal.mem_inv_iff hI_ne]
intro y hy
simpa only [one_mul] using hI_le_one hy
have hIntegral (r : A) :
algebraMap A K r ∈ I⁻¹ := by
have hr :=
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).smul_mem r hone_inv)
simpa only [FractionalIdeal.mem_coe,
Algebra.smul_def, mul_one] using hr
have hScalarZ (r : A) :
algebraMap A K r * z ∈ I⁻¹ := by
have hr :=
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).smul_mem r hz_mem)
simpa only [FractionalIdeal.mem_coe,
Algebra.smul_def] using hr
let ux : K :=
algebraMap A K αx - algebraMap A K γx * z
let gx : K :=
algebraMap A K βx + algebraMap A K δx * z
let uy : K :=
algebraMap A K αy - algebraMap A K γy * z
let gy : K :=
algebraMap A K βy + algebraMap A K δy * z
have hux : ux ∈ I⁻¹ := by
exact
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).sub_mem
(hIntegral αx) (hScalarZ γx))
have hgx : gx ∈ I⁻¹ := by
exact
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).add_mem
(hIntegral βx) (hScalarZ δx))
have huy : uy ∈ I⁻¹ := by
exact
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).sub_mem
(hIntegral αy) (hScalarZ γy))
have hgy : gy ∈ I⁻¹ := by
exact
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).add_mem
(hIntegral βy) (hScalarZ δy))
have hHK :
algebraMap A K H =
-(z * algebraMap A K U) := by
rw [hzU]
ring
have hWK :
algebraMap A K W =
z * algebraMap A K G :=
hzG.symm
have hFxK :
algebraMap A K Fx =
algebraMap A K U * ux +
algebraMap A K G * gx := by
rw [hFx]
simp only [map_add, map_mul, ux, gx]
rw [hHK, hWK]
ring
have hFyK :
algebraMap A K Fy =
algebraMap A K U * uy +
algebraMap A K G * gy := by
rw [hFy]
simp only [map_add, map_mul, uy, gy]
rw [hHK, hWK]
ring
let tU : K :=
algebraMap A K a * ux +
algebraMap A K b * uy
let tG : K :=
algebraMap A K a * gx +
algebraMap A K b * gy
have htU : tU ∈ I⁻¹ := by
simpa only [FractionalIdeal.mem_coe,
Algebra.smul_def, tU] using
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).add_mem
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).smul_mem a hux)
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).smul_mem b huy))
have htG : tG ∈ I⁻¹ := by
simpa only [FractionalIdeal.mem_coe,
Algebra.smul_def, tG] using
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).add_mem
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).smul_mem a hgx)
(((I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).smul_mem b hgy))
have hBezK :
algebraMap A K a *
algebraMap A K Fx +
algebraMap A K b *
algebraMap A K Fy = 1 := by
simpa only [map_add, map_mul, map_one] using
congrArg (algebraMap A K) hBez
have hframe :
algebraMap A K U * tU +
algebraMap A K G * tG = 1 := by
calc
algebraMap A K U * tU +
algebraMap A K G * tG =
algebraMap A K a *
(algebraMap A K U * ux +
algebraMap A K G * gx) +
algebraMap A K b *
(algebraMap A K U * uy +
algebraMap A K G * gy) := by
dsimp only [tU, tG]
ring
_ =
algebraMap A K a * algebraMap A K Fx +
algebraMap A K b * algebraMap A K Fy := by
rw [← hFxK, ← hFyK]
_ = 1 := hBezK
have hmul_le : I * I⁻¹ ≤ 1 := by
rw [FractionalIdeal.mul_le]
intro x hx y hy
have hxy :=
(FractionalIdeal.mem_inv_iff hI_ne).mp
hy x hx
simpa only [mul_comm] using hxy
have hone_le : 1 ≤ I * I⁻¹ := by
rw [FractionalIdeal.one_le, ← hframe]
simpa only [FractionalIdeal.mem_coe] using
(((I * I⁻¹ : FractionalIdeal A⁰ K) :
Submodule A K).add_mem
(FractionalIdeal.mul_mem_mul hU_I htU)
(FractionalIdeal.mul_mem_mul hG_I htG))
have hmul_eq : I * I⁻¹ = 1 :=
le_antisymm hmul_le hone_le
exact
(FractionalIdeal.mul_inv_cancel_iff_isUnit K).mp hmul_eq
end
end MazurProof.GraphJacobianDecompositionFrame
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13RankTwoVerticalIdealRecovery
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
open Polynomial
/-!
# Recovering a vertical graph from a rank-two quotient
If a quotient has basis `{1,y}`, multiplication by `y` supplies its monic
quadratic relation, while `x` is linear in `y`. This file gives the
ideal-correspondence argument recovering the ambient ideal as
`(m(y), x-s(y))`.
-/
namespace MazurProof.N13RankTwoVerticalIdealRecovery
noncomputable section
universe uR uA
variable {R : Type uR} {A : Type uA}
variable [CommRing R] [CommRing A] [Algebra R A]
def HasVerticalPolynomialNormalForm
(y x : A) (s : R[X]) : Prop :=
∀ z : A, ∃ p : R[X], ∃ q : A,
z = aeval y p + q * (x - aeval y s)
theorem verticalNormalForm_of_rankTwoPolynomialNormalForm
(x y : A)
(hnormal :
N13RankTwoIdealRecovery.HasRankTwoPolynomialNormalForm
(R := R) x y)
(s : R[X]) :
HasVerticalPolynomialNormalForm (R := R) y x s := by
intro z
obtain ⟨p, q, hz⟩ := hnormal z
obtain ⟨cp, hcp⟩ :=
sub_dvd_eval_sub x (aeval y s)
(p.map (algebraMap R A))
obtain ⟨cq, hcq⟩ :=
sub_dvd_eval_sub x (aeval y s)
(q.map (algebraMap R A))
refine
⟨p.comp s + (q.comp s) * X,
cp + cq * y, ?_⟩
have hp :
aeval x p - aeval y (p.comp s) =
(x - aeval y s) * cp := by
simpa [aeval_def, aeval_comp] using hcp
have hq :
aeval x q - aeval y (q.comp s) =
(x - aeval y s) * cq := by
simpa [aeval_def, aeval_comp] using hcq
calc
z =
aeval x p + aeval x q * y := hz
_ =
aeval y (p.comp s + (q.comp s) * X) +
(cp + cq * y) * (x - aeval y s) := by
simp only [map_add, map_mul, aeval_X]
linear_combination hp + hq * y
theorem ideal_eq_span_vertical
(y x : A)
(I : Ideal A)
(m s : R[X])
(hnormal :
HasVerticalPolynomialNormalForm (R := R) y x s)
(hker :
RingHom.ker
((aeval (Ideal.Quotient.mk I y) :
R[X] →ₐ[R] A ⧸ I).toRingHom) =
Ideal.span ({m} : Set R[X]))
(hx :
Ideal.Quotient.mk I x =
aeval (Ideal.Quotient.mk I y) s) :
I =
Ideal.span
({aeval y m, x - aeval y s} : Set A) := by
let π : A →ₐ[R] A ⧸ I := Ideal.Quotient.mkₐ R I
have hker' :
RingHom.ker
((aeval (π y) : R[X] →ₐ[R] A ⧸ I).toRingHom) =
Ideal.span ({m} : Set R[X]) := by
simpa [π] using hker
have hx' : π x = aeval (π y) s := by
simpa [π] using hx
have hgraphZero :
π (x - aeval y s) = 0 := by
calc
π (x - aeval y s) =
π x - π (aeval y s) := map_sub π _ _
_ = π x - aeval (π y) s := by
rw [← Polynomial.aeval_algHom_apply π y s]
_ = 0 := by rw [hx', sub_self]
apply le_antisymm
· intro z hz
obtain ⟨p, q, hform⟩ := hnormal z
have hz0 : π z = 0 := by
exact Ideal.Quotient.eq_zero_iff_mem.mpr hz
have hp0 : aeval (π y) p = 0 := by
calc
aeval (π y) p =
π (aeval y p) := by
rw [Polynomial.aeval_algHom_apply]
_ =
π (aeval y p) +
π q * π (x - aeval y s) := by
rw [hgraphZero, mul_zero, add_zero]
_ =
π (aeval y p +
q * (x - aeval y s)) := by
rw [map_add, map_mul]
_ = π z := by rw [← hform]
_ = 0 := hz0
have hpSpan :
p ∈ Ideal.span ({m} : Set R[X]) := by
rw [← hker']
exact RingHom.mem_ker.mpr hp0
obtain ⟨w, hw⟩ :=
Ideal.mem_span_singleton.mp hpSpan
refine
(Ideal.mem_span_pair).2
⟨aeval y w, q, ?_⟩
calc
aeval y w * aeval y m +
q * (x - aeval y s) =
aeval y (m * w) +
q * (x - aeval y s) := by
simp only [map_mul]
ring
_ =
aeval y p +
q * (x - aeval y s) := by rw [← hw]
_ = z := hform.symm
· rw [Ideal.span_le]
intro z hz
simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
rcases hz with rfl | rfl
· have hmKer :
m ∈
RingHom.ker
((aeval (π y) :
R[X] →ₐ[R] A ⧸ I).toRingHom) := by
rw [hker']
exact Ideal.mem_span_singleton_self m
have hzero : π (aeval y m) = 0 := by
calc
π (aeval y m) =
aeval (π y) m :=
(Polynomial.aeval_algHom_apply π y m).symm
_ = 0 := RingHom.mem_ker.mp hmKer
exact Ideal.Quotient.eq_zero_iff_mem.mp
(by simpa [π] using hzero)
· exact Ideal.Quotient.eq_zero_iff_mem.mp
(by simpa [π] using hgraphZero)
end
end MazurProof.N13RankTwoVerticalIdealRecovery
end
section
/- Port source: https://github.com/xiangyazi24/FLT @ 51bbb4f191ad0d3753b87123635c100a638ae580
Module: FLT.Assumptions.MazurProof.N13RankTwoVerticalGraphRecovery
Original leading source comments and nonproject imports are retained below. -/
set_option autoImplicit false
open Module
open Polynomial
/-!
# Vertical graph recovery from a `{1,y}` basis
A rank-two quotient basis `{1,y}` recovers a monic quadratic relation
`m(y)` and a linear equation `x=a+cy`. Substituting the latter into the
integral curve equation shows that the vertical curve polynomial factors
as `m*w`.
-/
namespace MazurProof.N13RankTwoVerticalGraphRecovery
noncomputable section
abbrev R₂ : Type := N13ConcreteGraphRecovery.R₂
abbrev IntegralRing : Type :=
N13ConcreteGraphRecovery.IntegralRing
abbrev Model : SexticMumford.Model
N13IntegralModelContraction.Q₂ :=
N13ConcreteGraphRecovery.Model
def verticalCurve (s : R₂[X]) : R₂[X] :=
X ^ 2 +
(N13GeneralizedMumfordIntegral.hPoly (R := R₂)).comp s * X -
(N13GeneralizedMumfordIntegral.rhsPoly (R := R₂)).comp s
structure VerticalGraph where
m : R₂[X]
a : R₂
c : R₂
w : R₂[X]
m_monic : m.Monic
curve_eq :
verticalCurve (C a + C c * X) = m * w
namespace VerticalGraph
def s (E : VerticalGraph) : R₂[X] :=
C E.a + C E.c * X
def ideal (E : VerticalGraph) : Ideal IntegralRing :=
Ideal.span
({aeval N13ConcreteGraphRecovery.integralY E.m,
N13CanonicalContractionQuotient.integralX -
aeval N13ConcreteGraphRecovery.integralY E.s} :
Set IntegralRing)
end VerticalGraph
theorem quotient_aeval_integralY
(I : Ideal IntegralRing) (p : R₂[X]) :
aeval
(Ideal.Quotient.mk I
N13ConcreteGraphRecovery.integralY) p =
Ideal.Quotient.mk I
(aeval N13ConcreteGraphRecovery.integralY p) := by
simpa using
(Polynomial.map_aeval_eq_aeval_map
(R := R₂) (S := IntegralRing) (T := R₂)
(U := IntegralRing ⧸ I)
(φ := RingHom.id R₂)
(ψ := Ideal.Quotient.mk I)
(by ext; simp) p
N13ConcreteGraphRecovery.integralY).symm
theorem exists_verticalGraph_of_basis
(D : SexticMumford.SemiMumford Model)
(b : Basis (Fin 2) R₂
(IntegralRing ⧸
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)))
(hb :
(b : Fin 2 →
IntegralRing ⧸
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)) =
N13FiniteFlatBasisLift.oneX
(Ideal.Quotient.mk
(N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D))
N13ConcreteGraphRecovery.integralY)) :
∃ E : VerticalGraph,
E.m.natDegree = 2 ∧
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D) =
E.ideal := by
let I :=
N13IntegralModelContraction.contractIdeal
(N13CanonicalContractionQuotient.graphIdeal D)
let B := IntegralRing ⧸ I
let xbar : B :=
Ideal.Quotient.mk I
N13CanonicalContractionQuotient.integralX
let ybar : B :=
Ideal.Quotient.mk I
N13ConcreteGraphRecovery.integralY
have hb0 : b 0 = 1 := by
have h := congrFun hb (0 : Fin 2)
simpa [N13FiniteFlatBasisLift.oneX] using h
have hb1 : b 1 = ybar := by
have h := congrFun hb (1 : Fin 2)
simpa [N13FiniteFlatBasisLift.oneX, ybar, I] using h
letI : Module.Free R₂ B :=
Module.Free.of_basis b
letI : Module.Finite R₂ B :=
Module.Finite.of_basis b
letI : Nontrivial B :=
⟨⟨1, 0, by
rw [← hb0]
exact b.ne_zero 0⟩⟩
obtain ⟨a, c, hx⟩ :=
N13RankTwoQuotientAlgebra.exists_eq_algebraMap_add_algebraMap_mul
ybar xbar b hb0 hb1
let m : R₂[X] :=
(Algebra.lmul R₂ B ybar).charpoly
let s : R₂[X] :=
C a + C c * X
have hmMonic : m.Monic :=
N13RankTwoQuotientAlgebra.charpoly_lmul_monic_of_one_x ybar
have hmDegree : m.natDegree = 2 :=
N13RankTwoQuotientAlgebra.charpoly_lmul_natDegree_of_one_x
ybar b hb0 hb1
have hker :
RingHom.ker
((aeval ybar : R₂[X] →ₐ[R₂] B).toRingHom) =
Ideal.span ({m} : Set R₂[X]) := by
exact
N13RankTwoQuotientAlgebra.ker_aeval_eq_span_charpoly_of_one_x
ybar b hb0 hb1
have hxs : xbar = aeval ybar s := by
calc
xbar =
algebraMap R₂ B a +
algebraMap R₂ B c * ybar := hx
_ = aeval ybar s := by simp [s]
have hnormal :
N13RankTwoVerticalIdealRecovery.HasVerticalPolynomialNormalForm
(R := R₂)
N13ConcreteGraphRecovery.integralY
N13CanonicalContractionQuotient.integralX s :=
N13RankTwoVerticalIdealRecovery.verticalNormalForm_of_rankTwoPolynomialNormalForm
N13CanonicalContractionQuotient.integralX
N13ConcreteGraphRecovery.integralY
N13ConcreteGraphRecovery.integral_rankTwoPolynomialNormalForm
s
have hI :=
N13RankTwoVerticalIdealRecovery.ideal_eq_span_vertical
(R := R₂)
N13ConcreteGraphRecovery.integralY
N13CanonicalContractionQuotient.integralX
I m s hnormal hker hxs
have hverticalEval :
aeval ybar (verticalCurve s) = 0 := by
simp only [verticalCurve, map_sub, map_add, map_mul,
map_pow, aeval_X, aeval_comp]
rw [← hxs,
N13ConcreteGraphRecovery.quotient_aeval_integralX,
N13ConcreteGraphRecovery.quotient_aeval_integralX]
change
Ideal.Quotient.mk I
(N13ConcreteGraphRecovery.integralY ^ 2) +
Ideal.Quotient.mk I
(N13GeneralizedMumfordIntegral.xClass
(N13GeneralizedMumfordIntegral.hPoly (R := R₂))) *
Ideal.Quotient.mk I
N13ConcreteGraphRecovery.integralY -
Ideal.Quotient.mk I
(N13GeneralizedMumfordIntegral.xClass
(N13GeneralizedMumfordIntegral.rhsPoly (R := R₂))) =
0
have hcurve :=
N13GeneralizedMumfordIntegral.yClass_relation (R := R₂)
have hcurveQ :
Ideal.Quotient.mk I
((N13GeneralizedMumfordIntegral.yClass (R := R₂)) ^ 2) +
Ideal.Quotient.mk I
(N13GeneralizedMumfordIntegral.xClass
(N13GeneralizedMumfordIntegral.hPoly (R := R₂))) *
Ideal.Quotient.mk I
(N13GeneralizedMumfordIntegral.yClass (R := R₂)) =
Ideal.Quotient.mk I
(N13GeneralizedMumfordIntegral.xClass
(N13GeneralizedMumfordIntegral.rhsPoly (R := R₂))) := by
simpa only [map_add, map_mul] using
congrArg (Ideal.Quotient.mk I) hcurve
exact sub_eq_zero.mpr
(by
simpa only [N13ConcreteGraphRecovery.integralY] using
hcurveQ)
have hverticalKer :
verticalCurve s ∈
RingHom.ker
((aeval ybar : R₂[X] →ₐ[R₂] B).toRingHom) :=
RingHom.mem_ker.mpr hverticalEval
rw [hker, Ideal.mem_span_singleton] at hverticalKer
obtain ⟨w, hw⟩ := hverticalKer
have hcurve :
verticalCurve s = m * w := hw
let E : VerticalGraph :=
{ m := m
a := a
c := c
w := w
m_monic := hmMonic
curve_eq := by simpa [s] using hcurve }
refine ⟨E, hmDegree, ?_⟩
simpa [VerticalGraph.ideal, VerticalGraph.s, E, s] using hI
end
end MazurProof.N13RankTwoVerticalGraphRecovery
end
Source