Polynomial root avoidance for elliptic interpolation obstructions
OpenWeierstrassEllipticZeta.bounded_subset_polynomial_avoidance_obstructionRetain all original geometric hypotheses and data of the fixed-matrix frontier, including the finite subset, contact quotient, formal flows, numerator polynomials V, and common denominator . Put .
Supply any two families of valid polynomial detectors for these fixed-matrix tests:
- For each auxiliary polynomial p, equation cutoff b, and coefficient cutoff q, a polynomial of degree at most q whose nonvanishing at every is equivalent to the short-branch augmented-rank inequality at cutoff q.
- For each p and b, a polynomial of degree at most d whose nonvanishing at every is equivalent to the long-branch augmented-rank inequality at cutoff d.
The matrix tests in these specifications are exactly those of the parent frontier. The completed detector theorem supplies such families for every instance of the original data. Detectors may be zero; their defining equivalences are required, so an arbitrary constant polynomial cannot be substituted.
For every such pair of valid families, the assertion supplies the original witnesses , with the same nonconstant relation in the contact quotient, coefficient-degree bound for F, and cost
For every root z covered by the parent's chart-spectrum applicability condition, require
This expresses the remaining geometric task as avoidance of the zeros of polynomials with explicit degree bounds. The detector families are supplied algebraic data, and their existence is proved separately. Forward and converse reductions establish equivalence with the parent frontier. The geometric witness construction 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_polynomial_avoidance_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 ∧
(∀ z ∈ (F.map φ).roots,
(s < 2 * N * Z.card ∨ ∃ r : Z,
z = algebraMap ℂ L (MvPolynomial.aeval (v r) p) ∨
z = algebraMap ℂ L
(MvPolynomial.aeval
(Function.update (v r) (2 : Fin 4) (-v r 2)) p)) →
if s < 2 * N * Z.card then
(Ds p b s).eval z ≠ 0
else
∀ c : ℂ, z = algebraMap ℂ L c → (Dl p b).eval c ≠ 0) ∧
((2 * (F.natDegree * b + s * a) + ((U : ℕ) + 1) : ℕ) : ℝ) ≤
C * (n : ℝ) ^ 2 := by sorry