Bounded integer specialization for elliptic interpolation
OpenWeierstrassEllipticZeta.bounded_subset_integer_specialization_obstructionRetain all hypotheses of the finite evaluation frontier, including its geometric, contact-quotient, formal-series, common-denominator, and valid-detector data. Write R=C[T], L for the algebraic closure of Frac(R), N=3U+1, and d_*=2N|Z|, where Z is the finite set of nonlattice chart points.
The conclusion still constructs p,F,a,b,s with F in R[Y], positive degree e in Y, coefficient degrees in T at most a, and the same relation and quantitative estimate:
For s<d_*, retain the original certificate over L[Y]:
where phi is the canonical embedding of R into L and delta is natural degree, with delta(0)=0.
For s>=d_*, require a single nonnegative integer t in the finite range
Let F_t(Y)=F(t,Y) in C[Y]. For every r in Z, require
and
Here alpha_r evaluates p at the chart point indexed by r, and beta_r evaluates p at that point after negating only its derivative coordinate. The same t must work for both conditions at every chart point. Repeated values are allowed.
The original relation, coefficient bound, degree e, and quantitative estimate continue to use F. Specialization is used only in the long-branch evaluation conditions; no preservation of degree in Y or new relation involving F_t is asserted. The complete bounded-specialization theorem proves this frontier equivalent to the previous one. Constructing the geometric witnesses and establishing the estimate remain open.
import Mathlib.Data.Matrix.ColumnRowPartitioned import Mathlib.Tactic.Ring import Mathlib.RingTheory.Ideal.Span import Mathlib.Algebra.Polynomial.Reverse import Mathlib.Algebra.Polynomial.BigOperators import Mathlib.Algebra.Polynomial.Eval.Degree import Mathlib.Algebra.Polynomial.Div import Mathlib.Tactic.ComputeDegree import Mathlib.RingTheory.PowerSeries.Inverse import Mathlib.Algebra.MvPolynomial.PDeriv import Mathlib.Tactic.LinearCombination import Mathlib.Tactic.Choose import Mathlib.RingTheory.PowerSeries.Derivative import Mathlib.Tactic.FinCases import Mathlib.RingTheory.PowerSeries.Basic import Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure import Mathlib.RingTheory.Polynomial.Resultant.Basic import Mathlib.LinearAlgebra.Matrix.Rank import Mathlib.RingTheory.Adjoin.Basic import Mathlib.Algebra.Polynomial.Roots import Mathlib.Algebra.Order.Archimedean.Real.Basic import Mathlib.Data.Finsupp.Interval import Mathlib.Order.Interval.Finset.Nat import Mathlib.RingTheory.MvPolynomial.Basic import Definitions.Def_WeierstrassEllipticZeta_InterfaceGeometry import Mathlib.Analysis.Analytic.Polynomial open WeierstrassEllipticZeta open scoped Pointwise Classical Topology
theorem WeierstrassEllipticZeta.bounded_subset_integer_specialization_obstruction (G : Frontier.Geometry) :
∃ C : ℝ, 0 < C ∧ ∀ m n : ℕ, ∀ U : Fin ((G.B (m + 2 * n) - 2) / 3 + 1),
1 ≤ m → 1 ≤ n → 1 ≤ (U : ℕ) → ∀ X : Finset ℂ,
0 ∈ X → ∀ Q : MvPolynomial (Fin 7) ℂ,
(∀ d ∈ Q.support, d 0 + d 1 = m ∧
d 2 + d 3 + d 4 + d 5 + d 6 = n) →
(∀ (c : Fin 2) (z : ℂ), G.S (extensionChartDenominator c) z ≠ 0 →
let f := fun w => MvPolynomial.eval (extensionChartCoordinates G.S c w)
(extensionChartNormalize c Q)
∃! k : ℕ, k < G.B (m + 2 * n) ∧
(z ∈ X + X + X → 3 * (U : ℕ) + 1 ≤ k) ∧
(∀ j < k, iteratedDeriv j f z = 0) ∧ iteratedDeriv k f z ≠ 0 ∧
∃ g : ℂ → ℂ, AnalyticAt ℂ g z ∧ g z ≠ 0 ∧
f =ᶠ[𝓝 z] (fun w => (w - z) ^ k * g w)) →
(∀ (c : Fin 2) (k : ℕ),
((extensionChartDerivation G.L.g₂ G.L.g₃ c)^[k] (extensionChartNormalize c Q)).totalDegree ≤
m + 2 * n + k) →
Frontier.HasChartCertificates G m n (U : ℕ) X Q →
∀ Y : Finset ℂ, Y ⊆ X → 0 ∈ Y →
Y.card = ⌊(C * (m : ℝ) * (n : ℝ) ^ 2) /
(((U : ℕ) + 1 : ℕ) : ℝ)⌋₊ + 1 →
let Z := Y.filter (fun z => z ∉ G.L.lattice)
let N := 3 * (U : ℕ) + 1
let I : Ideal (MvPolynomial (Fin 4) ℂ) :=
⨅ z : Z, extensionChartContactIdeal G.L.g₂ G.L.g₃ 0
(extensionChartCoordinates G.S 0 z.val) N
(Ideal.span ({extensionChartCubic G.L.g₂ G.L.g₃ 0} :
Set (MvPolynomial (Fin 4) ℂ)) ≤ I) →
let x := Ideal.Quotient.mk I (MvPolynomial.X (1 : Fin 4))
let L := AlgebraicClosure (FractionRing (Polynomial ℂ))
let φ : Polynomial ℂ →+* L :=
(algebraMap (FractionRing (Polynomial ℂ)) L).comp
(algebraMap (Polynomial ℂ) (FractionRing (Polynomial ℂ)))
let v : Z → Fin 4 → ℂ := fun r => extensionChartCoordinates G.S 0 r.val
∀ P : Z → PowerSeries ℂ,
(∀ r, PowerSeries.coeff 0 (P r) = v r 1 ∧
PowerSeries.coeff 1 (P r) = v r 2) →
(∀ r, PowerSeries.derivative ℂ (PowerSeries.derivative ℂ (P r)) =
PowerSeries.C 6 * (P r) ^ 2 - PowerSeries.C (G.L.g₂ / 2)) →
(∀ r, (PowerSeries.derivative ℂ (P r)) ^ 2 =
PowerSeries.C 4 * (P r) ^ 3 - PowerSeries.C G.L.g₂ * P r -
PowerSeries.C G.L.g₃) →
let J : Z → Fin 4 → PowerSeries ℂ := fun r =>
![PowerSeries.C (v r 0) + PowerSeries.X, P r, PowerSeries.derivative ℂ (P r),
PowerSeries.mk fun k =>
if k = 0 then v r 3 else -PowerSeries.coeff (k - 1) (P r) / (k : ℂ)]
∀ ρ : MvPolynomial (Fin 4) ℂ → MvPolynomial (Fin 4) ℂ,
(∀ p, (ρ p).degreeOf (2 : Fin 4) ≤ 1 ∧ p - ρ p ∈
Ideal.span ({extensionChartCubic G.L.g₂ G.L.g₃ 0} :
Set (MvPolynomial (Fin 4) ℂ))) →
let D : Z → PowerSeries ℂ := fun r =>
PowerSeries.C 4 * (P r) ^ 3 - PowerSeries.C G.L.g₂ * P r -
PowerSeries.C G.L.g₃
let A : MvPolynomial (Fin 4) ℂ → Z → PowerSeries ℂ := fun p r =>
MvPolynomial.aeval (Function.update (J r) (2 : Fin 4) 0) (ρ p)
let B : MvPolynomial (Fin 4) ℂ → Z → PowerSeries ℂ := fun p r =>
MvPolynomial.aeval (Function.update (J r) (2 : Fin 4) 0)
(MvPolynomial.pderiv (2 : Fin 4) (ρ p))
let T : MvPolynomial (Fin 4) ℂ → Z → ℕ → PowerSeries ℂ × PowerSeries ℂ :=
fun p r => Nat.rec (1, 0)
(fun _ t => (A p r * t.1 + D r * B p r * t.2,
B p r * t.1 + A p r * t.2))
(∀ p r i, (T p r i).1 ^ 2 - D r * (T p r i).2 ^ 2 =
(A p r ^ 2 - D r * B p r ^ 2) ^ i) →
let H : MvPolynomial (Fin 4) ℂ → Z → PowerSeries (PowerSeries ℂ) := fun p r =>
PowerSeries.invOfUnit
(1 - PowerSeries.C (2 * A p r) * PowerSeries.X +
PowerSeries.C (A p r ^ 2 - D r * B p r ^ 2) * PowerSeries.X ^ 2)
(1 : (PowerSeries ℂ)ˣ)
∀ τ : PowerSeries (PowerSeries ℂ) ≃+* PowerSeries (PowerSeries ℂ),
(∀ (f : PowerSeries (PowerSeries ℂ)) (i k : ℕ),
PowerSeries.coeff i (PowerSeries.coeff k (τ f)) =
PowerSeries.coeff k (PowerSeries.coeff i f)) →
let ψ : PowerSeries ℂ →+* PowerSeries (PowerSeries ℂ) :=
PowerSeries.map (PowerSeries.C : ℂ →+* PowerSeries ℂ)
let W : PowerSeries (PowerSeries ℂ) := PowerSeries.C (PowerSeries.X : PowerSeries ℂ)
let K : MvPolynomial (Fin 4) ℂ → Z → PowerSeries (PowerSeries ℂ) := fun p r => τ (H p r)
(∀ p r, (1 - ψ (2 * A p r) * W +
ψ (A p r ^ 2 - D r * B p r ^ 2) * W ^ 2) * K p r = 1) →
let E : MvPolynomial (Fin 4) ℂ → Z → ℕ → PowerSeries (PowerSeries ℂ) :=
fun p r j => ψ ((J r (1 : Fin 4)) ^ j) *
((1 - ψ (A p r) * W) * K p r +
ψ (J r (2 : Fin 4)) * (ψ (B p r) * W * K p r))
let q : MvPolynomial (Fin 4) ℂ → Z → Polynomial ℂ := fun p r =>
1 - Polynomial.C (PowerSeries.coeff 0 (2 * A p r)) * Polynomial.X +
Polynomial.C (PowerSeries.coeff 0 (A p r ^ 2 - D r * B p r ^ 2)) * Polynomial.X ^ 2
let H₀ : MvPolynomial (Fin 4) ℂ → Z → PowerSeries ℂ := fun p r =>
PowerSeries.invOfUnit (q p r : PowerSeries ℂ) (1 : ℂˣ)
∀ M : MvPolynomial (Fin 4) ℂ → Z → ℕ → ℕ → Polynomial ℂ,
(∀ p r j k, (M p r j k).natDegree ≤ 2 * k + 1 ∧
PowerSeries.coeff k (E p r j) =
(M p r j k : PowerSeries ℂ) * H₀ p r ^ (k + 1)) →
let Ω : MvPolynomial (Fin 4) ℂ → Polynomial ℂ := fun p => ∏ r : Z, q p r ^ N
let H₁ : MvPolynomial (Fin 4) ℂ → PowerSeries ℂ := fun p => ∏ r : Z, H₀ p r ^ N
(∀ p, (Ω p).natDegree ≤ 2 * N * Z.card ∧ (Ω p : PowerSeries ℂ) * H₁ p = 1) →
∀ V : MvPolynomial (Fin 4) ℂ → Z → ℕ → Fin N → Polynomial ℂ,
(∀ p r j k, (V p r j k).natDegree < 2 * N * Z.card ∧
(M p r j k.val : PowerSeries ℂ) * H₀ p r ^ (k.val + 1) =
(V p r j k : PowerSeries ℂ) * H₁ p) →
∀ Ds : MvPolynomial (Fin 4) ℂ → ℕ → ℕ → Polynomial L,
(∀ p b s, (Ds p b s).natDegree ≤ s ∧ ∀ z : L,
let Ac : Matrix (Fin (b + 1) × Fin (s + 1)) (Z × Fin N) L :=
fun e q => ((V p q.1 e.1.val q.2).map (algebraMap ℂ L)).coeff e.2.val
let Rz : Polynomial L := ∑ k ∈ Finset.range (s + 1),
(Polynomial.C z * Polynomial.X) ^ k
let Bc : Matrix (Fin (b + 1) × Fin (s + 1)) Unit L :=
fun e _ => (Rz * (Polynomial.C ((φ Polynomial.X) ^ e.1.val) *
(Ω p).map (algebraMap ℂ L))).coeff e.2.val
(Ac.rank < (Matrix.fromCols Ac Bc).rank) ↔ (Ds p b s).eval z ≠ 0) →
∀ Dl : MvPolynomial (Fin 4) ℂ → ℕ → Polynomial ℂ,
(∀ p b, (Dl p b).natDegree ≤ 2 * N * Z.card ∧ ∀ c : ℂ,
let Ac : Matrix (Fin (b + 1) × Fin (2 * N * Z.card + 1))
(Z × Fin N) ℂ := fun e q => (V p q.1 e.1.val q.2).coeff e.2.val
let Rc : Polynomial ℂ := ∑ k ∈ Finset.range (2 * N * Z.card + 1),
(Polynomial.C c * Polynomial.X) ^ k
let Bc : Matrix (Fin (b + 1) × Fin (2 * N * Z.card + 1))
(Fin (b + 1)) ℂ := fun e k =>
(Rc * (if k.val = e.1.val then Ω p else 0)).coeff e.2.val
(Ac.rank < (Matrix.fromCols Ac Bc).rank) ↔ (Dl p b).eval c ≠ 0) →
∃ (p : MvPolynomial (Fin 4) ℂ)
(F : Polynomial (Polynomial ℂ)) (a b s : ℕ),
F.natDegree ≠ 0 ∧
(∀ i, (F.coeff i).natDegree ≤ a) ∧
F.eval₂ (Polynomial.aeval x).toRingHom (Ideal.Quotient.mk I (ρ p)) = 0 ∧
(if s < 2 * N * Z.card then
∃ u w : Polynomial L,
u * F.map φ + w * Ds p b s = 1 ∧
w.natDegree < F.natDegree ∧ u.natDegree ≤ (Ds p b s).natDegree
else
∃ t : Fin (2 * Z.card * a + 1),
let Ft : Polynomial ℂ :=
F.map (Polynomial.evalRingHom (t.val : ℂ))
∀ r : Z,
((Dl p b).eval (MvPolynomial.aeval (v r) p) = 0 →
Ft.eval (MvPolynomial.aeval (v r) p) ≠ 0) ∧
((Dl p b).eval (MvPolynomial.aeval
(Function.update (v r) (2 : Fin 4) (-v r 2)) p) = 0 →
Ft.eval (MvPolynomial.aeval
(Function.update (v r) (2 : Fin 4) (-v r 2)) p) ≠ 0)) ∧
((2 * (F.natDegree * b + s * a) + ((U : ℕ) + 1) : ℕ) : ℝ) ≤
C * (n : ℝ) ^ 2 := by sorry