Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Zero-free cell using a larger error radius

Proved
H1000Oct.cell_zeta_ne_zero_R

by Johan Mercedes · Oct 28, 2026 · Mathlib 0df444a (Lean v4.33.1)

arda-rh65k-transfernumber-theoryriemann-zeta

Let c,oc,oc,o be configurations with center sc=σc+itcs_c=\sigma_c+it_csc​=σc​+itc​ given by σc=(o.a−o.b)/o.q\sigma_c=(o.a-o.b)/o.qσc​=(o.a−o.b)/o.q, tc=c.tn/2c.tqt_c=c.t_n/2^{c.t_q}tc​=c.tn​/2c.tq​. Let K≥1K\ge1K≥1, N≥2N\ge2N≥2, and let states x1,x2x_1,x_2x1​,x2​ satisfy the defined off-line invariants after N−1N-1N−1 and NNN terms. Suppose checkCell⁡\operatorname{checkCell}checkCell succeeds for radius r=rn/rdr=r_n/r_dr=rn​/rd​, budget F=Fn/FdF=F_n/F_dF=Fn​/Fd​, and order ppp. Let R,L,a,U,B,Q∈RR,L,a,U,B,Q\in\mathbb RR,L,a,U,B,Q∈R and r0∈Nr_0\in\mathbb Nr0​∈N satisfy

r≤R,x2.lhi≤2c.PL,RL≤1,0<a≤tc,σc≥0,U≥0,(σc+2K−1)2+tc2≤U2,r\le R,\quad x_2.\mathrm{lhi}\le2^{c.P}L,\quad RL\le1,\quad 0<a\le t_c,\quad \sigma_c\ge0,\quad U\ge0,\quad (\sigma_c+2K-1)^2+t_c^2\le U^2,r≤R,x2​.lhi≤2c.PL,RL≤1,0<a≤tc​,σc​≥0,U≥0,(σc​+2K−1)2+tc2​≤U2, Q≥0,pochNormSq⁡(1,B,2K+1)≤Q2,r0>0,r02≤N,Q\ge0,\quad \operatorname{pochNormSq}(1,B,2K+1)\le Q^2,\quad r_0>0,\quad r_0^2\le N,Q≥0,pochNormSq(1,B,2K+1)≤Q2,r0​>0,r02​≤N,

and, using the defined CpC_pCp​, emcB⁡\operatorname{emcB}emcB, corrVar⁡\operatorname{corrVar}corrVar, and CKC_KCK​,

Cp(RL)p+1(N−1+emcB⁡(K,N,a,U))+3corrVar⁡(K,N,R,a,U)+CKQN2Kr0(2K+1/2)≤F.C_p(RL)^{p+1}(N-1+\operatorname{emcB}(K,N,a,U)) +3\operatorname{corrVar}(K,N,R,a,U) +\frac{C_KQ}{N^{2K}r_0(2K+1/2)}\le F.Cp​(RL)p+1(N−1+emcB(K,N,a,U))+3corrVar(K,N,R,a,U)+N2Kr0​(2K+1/2)CK​Q​≤F.

Then ζ(s)≠0\zeta(s)\ne0ζ(s)=0 whenever ∣s−sc∣≤r|s-s_c|\le r∣s−sc​∣≤r, a≤Im⁡s≤Ba\le\operatorname{Im}s\le Ba≤Ims≤B, and 1/2≤Re⁡s≤11/2\le\operatorname{Re}s\le11/2≤Res≤1. Real division is totalized as in Lean.

Preamble
import Definitions.Def_ArdaRH65K_Probes_ArbEconomics_Sound
import Definitions.Def_ArdaRH65K_ThetaValue
import Definitions.Def_ArdaRH65K_Turing121_ArctanTaylor
import Definitions.Def_ArdaRH65K_Turing121_ArgHoriz
import Definitions.Def_ArdaRH65K_Turing121_DiffractionCore
import Definitions.Def_ArdaRH65K_Turing121_DlvpTheta
import Definitions.Def_ArdaRH65K_Turing121_DlvpZetaRateEffective
import Definitions.Def_ArdaRH65K_Turing121_EMZeta
import Definitions.Def_ArdaRH65K_Turing121_EMZetaComplex
import Definitions.Def_ArdaRH65K_Turing121_EMZetaHigh
import Definitions.Def_ArdaRH65K_Turing121_EMZetaHighCheck
import Definitions.Def_ArdaRH65K_Turing121_EMZetaOfflineCheck
import Definitions.Def_ArdaRH65K_Turing121_EMZetaOfflineCore
import Definitions.Def_ArdaRH65K_Turing121_EMZetaOfflineEval
import Definitions.Def_ArdaRH65K_Turing121_EMZetaOfflineSlab
import Definitions.Def_ArdaRH65K_Turing121_EMZetaOfflineSlabCheck
import Definitions.Def_ArdaRH65K_Turing121_EMZetaOfflineSlabClear
import Definitions.Def_ArdaRH65K_Turing121_EMZetaOfflineSound
import Definitions.Def_ArdaRH65K_Turing121_EMZetaTail
import Definitions.Def_ArdaRH65K_Turing121_EdgeClearGlue
import Definitions.Def_ArdaRH65K_Turing121_H1000Octant
import Definitions.Def_ArdaRH65K_Turing121_Probes_ArbEconomics_Zeta
import Definitions.Def_ArdaRH65K_Turing121_RHInBoxAnalytic
import Definitions.Def_ArdaRH65K_Turing121_StripRepr
import Definitions.Def_ArdaRH65K_Turing121_StripReprR1
import Definitions.Def_ArdaRH65K_Turing121_TuringBand
import Definitions.Def_ArdaRH65K_XiLineZeros
import Definitions.Def_ArdaRS_Arithmetic
import Definitions.Def_ArdaRS_Config64
import Mathlib
import Mathlib.Algebra.Ring.GeomSum
import Mathlib.Analysis.Analytic.Uniqueness
import Mathlib.Analysis.Calculus.Deriv.MeanValue
import Mathlib.Analysis.Complex.Exponential
import Mathlib.Analysis.Complex.ExponentialBounds
import Mathlib.Analysis.Real.Pi.Bounds
import Mathlib.Analysis.SpecialFunctions.Complex.Arg
import Mathlib.Analysis.SpecialFunctions.Gamma.Beta
import Mathlib.Analysis.SpecialFunctions.ImproperIntegrals
import Mathlib.Analysis.SpecialFunctions.Integrals.Basic
import Mathlib.Analysis.SpecialFunctions.Log.Deriv
import Mathlib.Analysis.SpecialFunctions.Pow.Deriv
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Analysis.SpecialFunctions.Sqrt
import Mathlib.Analysis.SpecialFunctions.Trigonometric.ArctanDeriv
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Bounds
import Mathlib.MeasureTheory.Function.Floor
import Mathlib.MeasureTheory.Integral.IntegralEqImproper
import Mathlib.MeasureTheory.Integral.IntervalIntegral.IntegrationByParts
import Mathlib.NumberTheory.LSeries.RiemannZeta
import Mathlib.NumberTheory.ZetaValues
import Mathlib.Tactic.IntervalCases
import Theorems.Thm_ArbEcon_Off_cell_zeta_ne_zero
import Theorems.Thm_H1000Oct_corrVar_mono
namespace ArbEcon
end ArbEcon
namespace ArbEcon.Off
end ArbEcon.Off
namespace ZetaReflection
end ZetaReflection
namespace ZetaReflection.EMHigh
end ZetaReflection.EMHigh
/-  H1000Octant.lean -- lane h1000-integrate: the kernel-checked OCTANT PIECE, the evaluator side of
    brick K6c (`ArgHoriz`) for the horizontal edges `[2, -1] + i T` of the RvM rectangles.

    `ArgHoriz.hAH_of_octCert_boxes` reduces `argChangeHoriz ζ T 2 (-1) ∈ [L, H]` to an octant
    certificate: breakpoints `2 = p 0 > p 1 > … > p m = -1`, one octant label `k j` per piece, and
    the no-crossing facts `0 < octX (k j) ζ(x + i T)` for every `x` of piece `j`, plus two point
    enclosures at `x = 2` and `x = -1`.  This file proves the no-crossing fact of ONE piece from ONE
    run of the off-line evaluator (`EMZetaOfflineEval`, `p + 1` accumulators) at the piece center
    `c = σc + i tc` and ONE Boolean check run by `decide +kernel`:

      A1. `emCorr_sub_le_norm`, `norm_emCorr_le_norm` -- the correction-factor bounds of
          `EMZetaOfflineSlab` with `a ≤ ‖c - 1‖` in place of `a ≤ Im c` (so they hold near `s = 1`
          at small heights);
      A2. `emFinite_taylor_le_G` -- the Taylor model of the EM finite part for ANY real part of the
          center: `‖n^(-c)‖ ≤ G` for `n ≤ N` (`G = 1` for `σc ≥ 0`, `N^(-σc)` for `σc < 0`);
      B.  `pochNormSq_mono_abs`, `em_remainder_horiz` -- the order-(2K+1) remainder uniformly on a
          horizontal segment `xlo ≤ x ≤ xhi` (negative `x` allowed, `x > -2K`);
          `natCpow_norm_le_of_pow` -- the `G` certificate `Gd^q N^b ≤ Gn^q N^a`;
      C.  `octLo`, `octUp`, `sumOct`, `checkOct`, `checkOct_sound` -- the kernel check
          `Σ_{k=1}^p |octX (W_k)| r^k/k! + (|α| + |β|) F < octX (W_0)` on the evaluator balls;
      D.  `piece_octX_pos` -- THE PIECE: for every real `x` with `|x - σc| ≤ r`,
          `0 < ArgHoriz.octX kk (ζ(x + i tc))`.  Along a horizontal piece `h = x - σc` is REAL, so
          the octant projection of the Taylor polynomial is a real polynomial in `h` and only the
          projections `octX (W_k)` enter;
      E.  `abs_sub_le_of_mem_uIcc`, `budget_mono` -- small helpers for the generated certificates.

    Trust: every theorem is proved from its stated hypotheses; axioms [propext, Classical.choice,
    Quot.sound] (AxiomGuardAllZerosKernel_h1000).  No `sorry`.
    conjecture1_proved = False.  Finite interval arithmetic along finitely many segments; nothing
    here bears on the Riemann Hypothesis.
-/



open Complex ZetaReflection ZetaReflection.EMHigh
open scoped Nat Real

section
namespace H1000Oct
end H1000Oct
open H1000Oct

open ArbEcon ArbEcon.Off

/-! ## A1. The correction factor, with `a ≤ ‖c - 1‖`. -/





/-! ## A2. The Taylor model for any real part of the center. -/



/-! ## B. The remainder along a horizontal segment, and the `G` certificate. -/









/-! ## C. The kernel check of a piece. -/

































/-! ## D. The piece. -/





/-! ## E. Helpers for the generated certificates. -/







/-! ## F. Closed forms for the generated budgets (K ≤ 6), and the slab-cell wrapper. -/









Formal statement

theorem H1000Oct.cell_zeta_ne_zero_R (c : Cfg) (o : OCfg) (σc tc : ℝ) (hσ : σc = ((o.a : ℝ) - o.b) / o.q)
    (ht : tc = (c.tn : ℝ) / 2 ^ c.tq) (K N p : ℕ) (hK : 1 ≤ K) (hN : 2 ≤ N) (s1 s2 : StO)
    (h1 : InvO c σc tc (N - 1) s1) (h2 : InvO c σc tc N s2) (rn rd FN FD : ℕ)
    (hchk : checkCell c o K N p s1.acc s2.acc rn rd FN FD = true)
    (R L a U B Qr : ℝ) (r0 : ℕ) (hrR : (rn : ℝ) / rd ≤ R) (hL : (s2.lhi : ℝ) ≤ L * 2 ^ c.P)
    (hRL : R * L ≤ 1) (ha : 0 < a) (hta : a ≤ tc) (hσc : 0 ≤ σc) (hU0 : 0 ≤ U)
    (hU : (σc + (2 * K - 1 : ℝ)) ^ 2 + tc ^ 2 ≤ U ^ 2) (hQr0 : 0 ≤ Qr)
    (hQ : pochNormSq 1 B (2 * K + 1) ≤ Qr ^ 2) (hr0 : 0 < r0) (hr0N : r0 ^ 2 ≤ N)
    (hbudget : Cp p * (R * L) ^ (p + 1) * (((N : ℝ) - 1) + emcB K N a U)
        + 3 * corrVar K N R a U
        + CK K * Qr / ((N : ℝ) ^ (2 * K) * r0) / (((2 * K : ℕ) : ℝ) + 1 / 2) ≤ (FN : ℝ) / FD) :
    ∀ s : ℂ, ‖s - sOfG σc tc‖ ≤ (rn : ℝ) / rd → a ≤ s.im → s.im ≤ B → 1 / 2 ≤ s.re → s.re ≤ 1 →
      riemannZeta s ≠ 0 := by sorry
Source
https://github.com/DrMurphyIsIn/Arda/blob/af4fde8972eb6d4e78c7d9a95933b18b81adf52d/telperion/examples/zeta_reflection/lean/H1000Octant.lean#L879-L913

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