Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Horizontal zeta argument bounds from endpoint boxes

Proved
ArgHoriz.hAH_of_octCert_boxes

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

arda-rh65k-transfernumber-theoryriemann-zeta

Let T≠0T\ne0T=0 and let an octant certificate with at least one piece run from 222 to −1-1−1, satisfying its step and zeta no-crossing conditions. Suppose boxes containing ζ(2+iT)\zeta(2+iT)ζ(2+iT) and ζ(−1+iT)\zeta(-1+iT)ζ(−1+iT) satisfy the certificate's positive-octant and slope inequalities at every corner. Let the resulting endpoint slope brackets be [q0,lo,q0,hi][q_{0,\rm lo},q_{0,\rm hi}][q0,lo​,q0,hi​] and [q1,lo,q1,hi][q_{1,\rm lo},q_{1,\rm hi}][q1,lo​,q1,hi​], and put d=(km−1−k0)π/4d=(k_{m-1}-k_0)\pi/4d=(km−1​−k0​)π/4. If

L≤d+arctan⁡q1,lo−arctan⁡q0,hi,d+arctan⁡q1,hi−arctan⁡q0,lo≤H,L\le d+\arctan q_{1,\rm lo}-\arctan q_{0,\rm hi},\qquad d+\arctan q_{1,\rm hi}-\arctan q_{0,\rm lo}\le H,L≤d+arctanq1,lo​−arctanq0,hi​,d+arctanq1,hi​−arctanq0,lo​≤H,

then Δ[2,−1]+iTarg⁡ζ∈[L,H]\Delta_{[2,-1]+iT}\arg\zeta\in[L,H]Δ[2,−1]+iT​argζ∈[L,H].

Preamble
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_RHInBoxAnalytic
import Definitions.Def_ArdaRH65K_Turing121_StripRepr
import Definitions.Def_ArdaRH65K_Turing121_StripReprR1
import Mathlib
import Mathlib.Algebra.Ring.GeomSum
import Mathlib.Analysis.Calculus.Deriv.MeanValue
import Mathlib.Analysis.SpecialFunctions.Complex.Arg
import Mathlib.Analysis.SpecialFunctions.Gamma.Beta
import Mathlib.Analysis.SpecialFunctions.Integrals.Basic
import Mathlib.Analysis.SpecialFunctions.Trigonometric.ArctanDeriv
import Theorems.Thm_ArgHoriz_argChangeHoriz_eq_of_octCert
import Theorems.Thm_ArgHoriz_octAngle_mem_of_box
/-  ArgHoriz.lean -- brick K6c of the ANDURIL Arb discharge: piecewise half-plane tracking of the
    horizontal argument change (telperion/docs/ANDURIL_ARB_DISCHARGE_2026-09-23.md, inventory row
    H2e, brick K6c).

    THE BINDERS IT REDUCES.  Conjuncts 6 and 7 of the `hArbT` binder of every emitted Turing band
    (`TuringBand.BandStatement`, `BandGlue.BandData.EnclHyp`) are

        hAHt : DiffractionCore.argChangeHoriz riemannZeta T1 2 (-1) ∈ Set.Icc L2 H2,
        hAHb : DiffractionCore.argChangeHoriz riemannZeta T0 2 (-1) ∈ Set.Icc L3 H3,

    the argument change of ζ along the horizontal edges `[2, -1] + i T` of the RvM rectangle
    (20,758 binders at h280000, 13,235 distinct heights).  Unlike K6a/K6b these are NOT generic:
    they need values of ζ off the line.  This file proves the reduction theorem that turns them
    into a finite, kernel-checkable certificate, so that only ENCLOSURES remain.

    THE CERTIFICATE (`OctCert`).  Breakpoints `2 = p 0, p 1, ..., p m = -1` and one integer label
    `k j` per piece `[p j, p (j+1)]`, the octant direction `k j · π/4`.  It is valid when
      * `StepOK`   : consecutive labels differ by at most 3 (a decidable check on integers);
      * `NoCross`  : on piece `j`, ζ never crosses the line through 0 orthogonal to the octant
                     direction: `0 < α Re ζ(x + i T) + β Im ζ(x + i T)` for all `x` in the piece,
                     `(α, β) ∈ {(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)}` the integer
                     octant vector (`octX`).  One strict sign condition per piece: a range
                     enclosure of ζ over the piece that avoids the octant boundary discharges it
                     (`octX_pos_of_box`, bundled per certificate as `OctCert.noCross_of_boxes`).
    Then (`argChangeHoriz_eq_of_octCert`, EXACT, no approximation):

        argChangeHoriz ζ T 2 (-1) = octAngle (k (m-1)) ζ(-1 + i T) - octAngle (k 0) ζ(2 + i T),
        octAngle k w = k π/4 + arctan ((α Im w - β Re w)/(α Re w + β Im w)).

    Every interior breakpoint cancels exactly: the chart angles of the two pieces meeting there
    agree (`chartAngle_eq`), because both charts contain the point and their directions differ by
    less than π.  So the only numerics left are TWO POINT ENCLOSURES, of ζ(2 + i T) and ζ(-1 + i T),
    turned into an arctan interval by `octAngle_mem_of_box` and the rational arctan brackets
    `atanLo ≤ arctan ≤ atanHi` (the emitter may use the sharper `ArctanTaylor.arctan_bracket`).
    `hAH_of_octCert_boxes` is the end-to-end binder-form statement.

    THE GENERAL THEOREM behind it (`argChangeHoriz_chain`): for any `f` analytic along the segment
    and any real chart directions `θ j` with `|θ (j+1) - θ j| < π` and `0 < Re (e^{-i θ j} f)` on
    piece `j`, the horizontal argument change is `chartAngle (θ (m-1)) f(end) - chartAngle (θ 0)
    f(start)`, `chartAngle θ w = θ + arg (e^{-i θ} w)` (FTC for `log (e^{-i θ} f)` on each piece).

    WHAT IS NOT HERE.  The off-line ζ evaluator (memo brick B6) that produces the `NoCross` range
    enclosures and the two endpoint point enclosures, and the functional-equation fold K6d.

    Trust: no hypotheses beyond those stated; axioms [propext, Classical.choice, Quot.sound]
    (see AxiomGuardArgChange.lean).  No `sorry`.

    conjecture1_proved = False.  A reduction of one edge of a finite zero count to finitely many
    enclosures; nothing here bears on the Riemann Hypothesis. -/





open Complex

section
namespace ArgHoriz
end ArgHoriz
open ArgHoriz

/-! ## 1. Charts: rotated principal arguments -/















/-! ## 2. One piece: FTC for `log (e^{-iθ} f)` -/



/-! ## 3. The chain of pieces -/



/-! ## 4. Octant charts: integer directions -/































/-! ## 5. The octant certificate -/



section
namespace ArgHoriz.OctCert
end ArgHoriz.OctCert
open ArgHoriz.OctCert





end





/-! ## 6. Endpoint enclosures -/





















/-! ## 7. The ζ edge in binder form -/





Formal statement

theorem ArgHoriz.hAH_of_octCert_boxes {T L H : ℝ} (hT : T ≠ 0) (c : OctCert) (hm : 1 ≤ c.m)
    (hp0 : c.p 0 = 2) (hpm : c.p c.m = -1) (hstep : c.StepOK) (hnc : c.NoCross riemannZeta T)
    {a0 a1 b0 b1 qlo0 qhi0 : ℝ}
    (hw0 : InBox (riemannZeta (((2 : ℝ) : ℂ) + (T : ℂ) * I)) a0 a1 b0 b1)
    (hS0 : ∀ a ∈ ({a0, a1} : Set ℝ), ∀ b ∈ ({b0, b1} : Set ℝ),
      0 < (octA (c.k 0) : ℝ) * a + octB (c.k 0) * b ∧
      qlo0 * ((octA (c.k 0) : ℝ) * a + octB (c.k 0) * b) ≤ (octA (c.k 0) : ℝ) * b - octB (c.k 0) * a ∧
      (octA (c.k 0) : ℝ) * b - octB (c.k 0) * a ≤ qhi0 * ((octA (c.k 0) : ℝ) * a + octB (c.k 0) * b))
    {c0 c1 d0 d1 qlo1 qhi1 : ℝ}
    (hw1 : InBox (riemannZeta (((-1 : ℝ) : ℂ) + (T : ℂ) * I)) c0 c1 d0 d1)
    (hS1 : ∀ a ∈ ({c0, c1} : Set ℝ), ∀ b ∈ ({d0, d1} : Set ℝ),
      0 < (octA (c.k (c.m - 1)) : ℝ) * a + octB (c.k (c.m - 1)) * b ∧
      qlo1 * ((octA (c.k (c.m - 1)) : ℝ) * a + octB (c.k (c.m - 1)) * b)
        ≤ (octA (c.k (c.m - 1)) : ℝ) * b - octB (c.k (c.m - 1)) * a ∧
      (octA (c.k (c.m - 1)) : ℝ) * b - octB (c.k (c.m - 1)) * a
        ≤ qhi1 * ((octA (c.k (c.m - 1)) : ℝ) * a + octB (c.k (c.m - 1)) * b))
    (hL : L ≤ ((c.k (c.m - 1) : ℝ) - c.k 0) * Real.pi / 4 + Real.arctan qlo1 - Real.arctan qhi0)
    (hH : ((c.k (c.m - 1) : ℝ) - c.k 0) * Real.pi / 4 + Real.arctan qhi1 - Real.arctan qlo0 ≤ H) :
    DiffractionCore.argChangeHoriz riemannZeta T 2 (-1) ∈ Set.Icc L H := by sorry
Source
https://github.com/DrMurphyIsIn/Arda/blob/af4fde8972eb6d4e78c7d9a95933b18b81adf52d/telperion/examples/zeta_reflection/lean/ArgHoriz.lean#L552-L600

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