Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Natural-number root count in the elliptic certificate

Open
WeierstrassEllipticZeta.bounded_subset_natural_root_obstruction

by tomasz · Sep 20, 2026 · Mathlib 0df444a (Lean v4.33.1)

algebraelliptic-functionspolynomials

Retain every hypothesis of the actual-degree frontier, including the geometric, contact-quotient, formal-series, common-denominator and valid-detector data. Construct the same p,F,a,b,s, with positive Y-degree e for F, coefficient T-degrees at most a, and

F(x,ρ(p))=0,2(eb+sa)+(U+1)≤Cn2.F(x,\rho(p))=0,\qquad 2(eb+sa)+(U+1)\le Cn^2.F(x,ρ(p))=0,2(eb+sa)+(U+1)≤Cn2.

The short branch retains its existing bounded certificate when

s<2(3U+1)∣Z∣.s<2(3U+1)|Z|.s<2(3U+1)∣Z∣.

In the long branch, let S be the finite set of distinct values of p at the chart points and at those points with only the derivative coordinate negated. Put

fc(T)=F(T,c),dc=Dl(p,b)(c),f_c(T)=F(T,c),\qquad d_c=D_l(p,b)(c),fc​(T)=F(T,c),dc​=Dl​(p,b)(c),

and retain the previous exponent parameter

δ=max⁡({deg⁡fc:c∈S, dc≠0}∪{0}),\delta=\max\bigl(\{\deg f_c:c\in S,\ d_c\ne0\}\cup\{0\}\bigr),δ=max({degfc​:c∈S, dc​=0}∪{0}),

using natural degrees. Define the certificate polynomial

Q(T)=∏c∈S(fc(T)+dcTδ+1).Q(T)=\prod_{c\in S}\bigl(f_c(T)+d_cT^{\delta+1}\bigr).Q(T)=c∈S∏​(fc​(T)+dc​Tδ+1).

Let B be the finite set obtained by pulling the distinct complex roots of Q back to nonnegative integers. For nonzero Q this is exactly its set of natural-number roots; if Q is zero, use B empty as in Lean's stored-root convention. Require a nonnegative integer

0≤r≤∣B∣0\le r\le |B|0≤r≤∣B∣

with the same nonvanishing certificate

∏c∈S(F(r,c)+rδ+1Dl(p,b)(c))≠0.\prod_{c\in S}\bigl(F(r,c)+r^{\delta+1}D_l(p,b)(c)\bigr)\ne0.c∈S∏​(F(r,c)+rδ+1Dl​(p,b)(c))=0.

The zero polynomial Q cannot satisfy this requirement. The complete supporting theorem proves that the new limit is no larger than the parent's degree-based limit and that the certificates are equivalent. Only the allowed integer range changes. The exponent, polynomial factors, short branch, original witnesses, contact data and cost estimate are retained. The geometric construction and its uniform estimate remain open.

Preamble
import Mathlib.Algebra.Polynomial.Roots
import Mathlib.Data.Finset.Preimage
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
Formal statement
theorem WeierstrassEllipticZeta.bounded_subset_natural_root_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
                  let c : Z ⊕ Z → ℂ := Sum.elim
                    (fun r => MvPolynomial.aeval (v r) p)
                    (fun r => MvPolynomial.aeval
                      (Function.update (v r) (2 : Fin 4) (-v r 2)) p)
                  let S : Finset ℂ := Finset.univ.image c
                  let f : S → Polynomial ℂ := fun z => F.eval (Polynomial.C z.val)
                  let δ : ℕ := Finset.univ.sup
                    (fun z : {z : S // (Dl p b).eval z.val ≠ 0} => (f z.val).natDegree)
                  let Qr : Polynomial ℂ := ∏ z : S,
                    (f z + Polynomial.X ^ (δ + 1) * Polynomial.C ((Dl p b).eval z.val))
                  let Bnat : Finset ℕ := Qr.roots.toFinset.preimage
                    (Nat.cast : ℕ → ℂ) Nat.cast_injective.injOn
                  ∃ r : Fin (Bnat.card + 1),
                      let Fr : Polynomial ℂ :=
                        F.map (Polynomial.evalRingHom (r.val : ℂ))
                      let Hr : Polynomial ℂ :=
                        Fr + Polynomial.C ((r.val : ℂ) ^ (δ + 1)) * Dl p b
                      (∏ z : S, Hr.eval z.val) ≠ 0) ∧
                ((2 * (F.natDegree * b + s * a) + ((U : ℕ) + 1) : ℕ) : ℝ) ≤
                  C * (n : ℝ) ^ 2 := by sorry
Source
Derived natural-number root-count refinement of bounded polynomial nonvanishing, and equivalent reduction of https://prove2.me/theorems/0d340837-597c-43dc-9b2d-47f625bc1fb3. Primary Mathlib source at revision 0df444a360eaa60ab8c11dca51a86af692955474: Polynomial.card_roots', https://github.com/leanprover-community/mathlib4/blob/0df444a360eaa60ab8c11dca51a86af692955474/Mathlib/Algebra/Polynomial/Roots.lean#L80, Finset.exists_mem_notMem_of_card_lt_card in Data/Finset/Card.lean, line 614, and Finset.card_preimage in Data/Finset/Preimage.lean, line 103. Mission context: Senthil Kumar K (2026), Algebraic independence of values of Weierstrass elliptic and zeta functions, Appendix A.2, Theorem A.3 and Proposition A.1, https://doi.org/10.1017/S001309152610145X. This refinement is derived here, not a verbatim theorem from the paper.

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me