Finite evaluation obstruction for elliptic interpolation
OpenWeierstrassEllipticZeta.bounded_subset_finite_evaluation_obstructionRetain every geometric, contact-quotient, formal-series, common-denominator, and valid-detector hypothesis of the polynomial Bézout frontier. 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 valid detectors D_s(p,b,s) in L[Y] and D_l(p,b) in C[Y] keep their original degree bounds and meanings in terms of interpolation matrix rank.
Construct the original witnesses p,F,a,b,s, where F is in R[Y], has positive degree e in Y, has coefficient degrees in T at most a, and satisfies the original relation and estimate
For s<d_*, retain the original certificate over L[Y]:
where phi is the canonical embedding R into L and delta denotes natural degree with delta(0)=0.
For s>=d_*, let alpha_r be p evaluated at the chart point indexed by r, and beta_r be p evaluated at that point after negating only its derivative coordinate. Require, for every r in Z,
and
Thus the long branch consists of two polynomial nonzero tests per chart point, conditional on the detector vanishing at that value. Repeated chart values are permitted. The nonzero evaluation polynomials may have roots in T; pointwise nonvanishing in T is not required.
The short branch, geometric hypotheses, witnesses, and numerical estimate are unchanged. A complete algebraic equivalence recovers the original long-branch polynomial certificate with all its coefficient degree bounds from these finite conditions. The construction of the geometric witnesses remains 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_finite_evaluation_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
∀ r : Z,
((Dl p b).eval (MvPolynomial.aeval (v r) p) = 0 →
F.eval (Polynomial.C (MvPolynomial.aeval (v r) p)) ≠ 0) ∧
((Dl p b).eval (MvPolynomial.aeval
(Function.update (v r) (2 : Fin 4) (-v r 2)) p) = 0 →
F.eval (Polynomial.C (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