Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

TuringBand certificate definitions

Definition
ArdaRH65K_Turing121_TuringBand

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

arda-rh65k-transfernumber-theoryriemann-zeta

This bundle defines the zero-count statement for a bounded vertical band. Let D\mathcal DD be the set of declarations it provides. Among its named definitions are

D⊇{TuringBand.BandStatement}.\mathcal D\supseteq\{\mathtt{TuringBand.BandStatement}\}.D⊇{TuringBand.BandStatement}.

The accompanying theorems establish the mathematical properties of these definitions.

Definition code
import Definitions.Def_ArdaRH65K_Turing121_DiffractionCore
import Definitions.Def_ArdaRH65K_Turing121_DlvpTheta
import Definitions.Def_ArdaRH65K_Turing121_DlvpZetaRateEffective
import Definitions.Def_ArdaRH65K_Turing121_RHInBoxAnalytic
import Definitions.Def_ArdaRH65K_Turing121_StripRepr
import Definitions.Def_ArdaRH65K_Turing121_StripReprR1
import Definitions.Def_ArdaRH65K_XiLineZeros
import Mathlib
/-  THE TURING BAND TEMPLATE (T5): per-band total zero count from the RvM edge
    decomposition -- the drop-in replacement for the four-edge winding certificate.

    `DiffractionCore.zero_count_band_edge_decomp` (brick 15, #374) expresses the
    band zero count as five EDGE argument-changes:

      2π·N_band = 2·AV(ζ,2) + AH(ζ,T1,2,-1) - AH(ζ,T0,2,-1) + AV(Γℝ,-1) + AV(Γℝ,2)

    Here we consume it with ARB-ENCLOSED edge values: the five argument-change
    quantities carry rational interval enclosures as documented non-kernel
    hypotheses (the SAME trust class as the previous route's `hwind` boundary
    integral value), and the kernel pins the integer count by interval
    arithmetic + rational π bounds (`Real.pi_gt_d2` / `Real.pi_lt_d4`).

    What this ELIMINATES vs the winding route: the two in-strip vertical edge
    integrals (the √T-expensive Arb input) and the 17-conjunct `hArb`
    integrability game -- the count now needs no interior contour data at all.
    The on-line half (`hLine` sign-change zeros) is unchanged; the conclusion
    shape is IDENTICAL to `rh_in_box_of_certificate`, so the height-chain glue
    consumes T5 bands with no changes.

    Trust boundary: KERNEL = the RvM edge decomposition + Blaschke split +
    interval/π arithmetic + the count-exhaustion core; ARB NON-KERNEL INPUT =
    the five edge enclosures, edge non-vanishing, zero confinement, and the
    on-line zeros.  conjecture1_proved = False. -/




open Complex MeasureTheory intervalIntegral

namespace TuringBand

/-- **The canonical T5 band statement** — the single, hand-audited Prop that every
    emitted `RHInBoxT_*` band theorem must state, up to kernel definitional
    equality, at its own parameters.

    Each emitted band file carries
    `theorem statement_match : BandStatement σ0 σ1 T0 T1 n L1 … H5 cPB RPB hs1PB := rh_in_box_<tag>`,
    which elaborates iff the band theorem's Π-type is DEFEQ to this definition's
    body — a kernel-enforced statement-match gate.  The statement SHAPE therefore
    comes from this reviewed definition, not from the emitter: an over-quantified,
    weakened, or truncated emitted statement fails the build (the exact bug class
    of the 2026-09-12 winding-route `hArb` finding).  The emitter can only vary
    the PARAMETERS, and those are cross-checked numerically by the driver
    (RvM edge sum pins `n`; the Platt inventory checks the poke slivers).

    conjecture1_proved = False. -/
def BandStatement (sigma0 sigma1 T0 T1 : ℝ) (n : ℕ)
    (L1 H1 L2 H2 L3 H3 L4 H4 L5 H5 : ℝ) (c : ℂ) (R : ℝ)
    (hs1 : (1 : ℂ) ∉ Metric.ball c R) : Prop :=
  (∃ xs : List ℝ, xs.length = n ∧ xs.IsChain (· < ·) ∧
    (∀ t ∈ xs, T0 ≤ t ∧ t ≤ T1) ∧
    (∀ t ∈ xs, completedRiemannZeta (1 / 2 + (t : ℂ) * Complex.I) = 0)) →
  ((∀ x ∈ Set.uIcc (-1 : ℝ) 2, riemannZeta (↑x + (T0 : ℂ) * I) ≠ 0) ∧
   (∀ x ∈ Set.uIcc (-1 : ℝ) 2, riemannZeta (↑x + (T1 : ℂ) * I) ≠ 0) ∧
   (∀ y ∈ Set.uIcc T0 T1, riemannZeta (((-1 : ℝ) : ℂ) + ↑y * I) ≠ 0) ∧
   (∀ ρ ∈ RHInBoxAnalytic.zeroFinset c R hs1,
     (-1 : ℝ) < ρ.re ∧ ρ.re < 2 ∧ T0 < ρ.im ∧ ρ.im < T1) ∧
   DiffractionCore.argChangeVert riemannZeta 2 T0 T1 ∈ Set.Icc L1 H1 ∧
   DiffractionCore.argChangeHoriz riemannZeta T1 2 (-1) ∈ Set.Icc L2 H2 ∧
   DiffractionCore.argChangeHoriz riemannZeta T0 2 (-1) ∈ Set.Icc L3 H3 ∧
   DiffractionCore.argChangeVert Gammaℝ (-1) T0 T1 ∈ Set.Icc L4 H4 ∧
   DiffractionCore.argChangeVert Gammaℝ 2 T0 T1 ∈ Set.Icc L5 H5) →
  ∀ ρ, (sigma0 ≤ ρ.re ∧ ρ.re ≤ sigma1) → (T0 ≤ ρ.im ∧ ρ.im ≤ T1) →
    riemannZeta ρ = 0 → ρ.re = 1 / 2





end TuringBand


def ArdaRH65K_Turing121_TuringBand : Nat := 0
Source
https://github.com/DrMurphyIsIn/Arda/blob/af4fde8972eb6d4e78c7d9a95933b18b81adf52d/telperion/examples/zeta_zero_localization/lean/TuringBand.lean

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