RH.lean

/-
  A Geometric Proof of the Riemann Hypothesis
  ==========================
  A Lean 4 / Mathlib formalization of the multiplicative framework:
  unit-circle observation μ, source B, medium C, metallic ratios,
  coherence ↔ sech, and the forced σ = 1/2.

  Formal Reduction = ACHIEVED
  Unconditional Closure = Pending

  Build:   lake env lean Framework.lean
  Project: lakefile.lean depending on `mathlib`
  Honest accounting at top:
    * The geometric framework, canonical factorization, coherence identities,
      prime-wise decomposition, finite-window refinement identities, and the
      endpoint packaging theorem all have explicit proofs and no `sorry`.
    * The RH closure is conditional on explicitly named analytic boundary
      axioms (xi/log-derivative identities, convergence tails, and
      Hurwitz-style window-zero transfer).
    * The final RH-style step is isolated as a 2-D defect-to-rigidity
      interface (`phase_lock_rigidity_from_2D_defect_boundary`), with theorem-level
      routing through `phase_lock_defect_argument_2D`/`phase_lock_rigidity`.
      The rest of the file is an explicit formal reduction to that interface plus
      the stated analytic continuation/convergence axioms.
    * The theorem `rh_endpoint_master` is the single packaged endpoint for
      this file.
-/

import Mathlib.Analysis.SpecialFunctions.Complex.Log
import Mathlib.Analysis.SpecialFunctions.Complex.Arg
import Mathlib.Analysis.SpecialFunctions.Gamma.Basic
import Mathlib.Analysis.SpecialFunctions.Gamma.Deligne
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Analysis.Complex.Norm
import Mathlib.Analysis.Complex.Trigonometric
import Mathlib.Data.Complex.Basic
import Mathlib.Data.Real.Sqrt
import Mathlib.NumberTheory.LSeries.RiemannZeta
import Mathlib.NumberTheory.LSeries.HurwitzZetaValues
import Mathlib.NumberTheory.LSeries.Dirichlet
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
-- import Mathlib.Analysis.SpecialFunctions.Hyperbolic
import Mathlib.Tactic
import Mathlib.Analysis.Calculus.Deriv.Add
import Mathlib.Analysis.Calculus.Deriv.Mul
import Mathlib.Analysis.Calculus.Deriv.Comp
import Mathlib.Analysis.SpecialFunctions.ExpDeriv
import Mathlib.Analysis.SpecialFunctions.Gamma.Deriv
import Mathlib.Analysis.Calculus.LogDeriv

open Real Complex RingHom HurwitzZeta
open scoped ComplexOrder ComplexConjugate
open Classical

namespace Real

/-- Compatibility alias for older snippets: logarithm base `b`. -/
noncomputable def logb (b x : ℝ) : ℝ := Real.log x / Real.log b

/-- Compatibility helper: strict hyperbolic inequality away from `0`. -/
theorem one_lt_cosh {x : ℝ} (hx : x ≠ 0) : 1 < Real.cosh x :=
  _root_.Real.one_lt_cosh.mpr hx

end Real

theorem one_div_lt_one {x : ℝ} (hx : 1 < x) : 1 / x < 1 := by
  have hx0 : 0 < x := by linarith [zero_lt_one, hx]
  rw [div_lt_iff₀ hx0, one_mul]
  exact hx

/-! ### Complex modulus: Mathlib exposes `‖z‖`; keep `Complex.abs` as an alias for older snippets. -/

namespace Complex

noncomputable abbrev abs (z : ℂ) : ℝ := ‖z‖

@[simp]
theorem abs_def (z : ℂ) : abs z = Real.sqrt (normSq z) :=
  norm_def z

@[simp]
theorem abs_mul (z w : ℂ) : abs (z * w) = abs z * abs w := by
  simpa [abs] using norm_mul z w

@[simp]
theorem abs_exp (z : ℂ) : abs (exp z) = Real.exp z.re := by
  simpa [abs] using (norm_exp z)

/-!
### Geometry in the Gaussian plane (ℝ²)

* **Reflection in the real axis** is exactly complex conjugation: `conj ⟨x, y⟩ = ⟨x, -y⟩`.
* **Rotation by \(π / 2\)** counterclockwise about `0` is multiplication by `I`.
* **Conjugation** is exactly that real-axis reflection; **multiplication by `I`** is the π/2 rotation,
  so all point symmetries of the plane are repeatedly “reflection ∘ rotation ∘ …” bookkeeping.
  The standard intertwining law is `conj (I * z) = -I * conj z`: reflect-then-rotate and
  rotate-then-reflect differ by that sign (the same obstruction to complex-linearity: conjugation is
  anti-linear for the complex vector space structure).

### “Solving for `conj`” (algebra)

`conj` denotes `starRingEnd ℂ`, a commutative `RingHom`. So peeling conjugation uses the same lemmas
as for any ring map (see **`Complex.Conj`** below): **`map_mul`**, **`map_add`**, **`map_sub`**, negatives,
powers, naturals/integers/rationals, and Mathlib’s **`conj_ofReal`**, **`conj_I`** (plus inversion via
Mathlib **`conj_inv`**).

For products involving **`I`**, compose with **`conj_mul_I`** and shuffle with **`mul_comm`** / **`ring`**.

**Tactics (defined after `Complex`):** `simp_conj`, `simp_conj!`, `simp_conj_plus`, `ring_conj`, `field_conj`,
`simp_log`, `simp_arg`, `push_div`, `simp_polar`, `grind_cplx`,
`cplx_ext`, `cplx_re_im`, `simp_abs`.
Baseline `simp_only` burst (for copy-paste / customization):
`simp only [map_mul, map_add, map_sub, map_neg, map_pow, map_one, map_zero, conj_ofReal, conj_I,
  conj_natCast, conj_ofNat, div_eq_mul_inv, conj_inv]`.
-/

/-- Multiplying by `I` is the linear “90° CCW” map `(x, y) ↦ (-y, x)` on `(re, im)`. -/
lemma I_mul_rotate (z : ℂ) : (I * z).re = -z.im ∧ (I * z).im = z.re := by
  simp [mul_re, mul_im, I_re, I_im]

/-- Conjugation is reflection in the real axis: imaginary part negated. -/
lemma conj_eq_reflect_real_axis (z : ℂ) : conj z = ⟨z.re, -z.im⟩ := by
  refine Complex.ext ?_ ?_ <;> simp

/-- Conjugation sends `I` to `-I`, so `conj` anticommutes with rotation by `I`. -/
lemma conj_mul_I (z : ℂ) : conj (I * z) = -I * conj z := by
  refine Complex.ext ?_ ?_
  · simp [Complex.mul_re, Complex.mul_im, Complex.I_re, Complex.I_im]
  · simp [Complex.mul_re, Complex.mul_im, Complex.I_re, Complex.I_im]

/-- Reflection in the **imaginary** axis is `z ↦ -conj z` (negate `re`, keep `im`). -/
lemma neg_conj_eq_reflect_imaginary_axis (z : ℂ) : -conj z = ⟨-z.re, z.im⟩ := by
  refine Complex.ext ?_ ?_ <;> simp

/-! ### Structural lemmas for peeling `conj` (`starRingEnd ℂ`) -/

namespace Conj

variable {z w : ℂ}

theorem map_mul : conj (z * w) = conj z * conj w := RingHom.map_mul (starRingEnd ℂ) z w

theorem map_add : conj (z + w) = conj z + conj w := RingHom.map_add (starRingEnd ℂ) z w

theorem map_sub : conj (z - w) = conj z - conj w := RingHom.map_sub (starRingEnd ℂ) z w

theorem map_neg : conj (-z) = -conj z := RingHom.map_neg (starRingEnd ℂ) z

theorem map_one : conj (1 : ℂ) = 1 := RingHom.map_one (starRingEnd ℂ)

theorem map_zero : conj (0 : ℂ) = 0 := RingHom.map_zero (starRingEnd ℂ)

theorem map_pow (n : ℕ) : conj (z ^ n) = conj z ^ n := RingHom.map_pow (starRingEnd ℂ) z n

/-- Conjugation commutes with division (write `z / w` as `z * w⁻¹` and use `conj_inv`). -/
theorem map_div : conj (z / w) = conj z / conj w := by
  simp_rw [div_eq_mul_inv, RingHom.map_mul (starRingEnd ℂ), conj_inv]

end Conj

end Complex

/-!
### Tactic macros (this file)

`conj` scope: `scoped[ComplexConjugate]` (opened above).

* `simp_conj` — peel `conj` via `starRingEnd` / `Complex.Conj`-style lemmas.
* `simp_conj!` — also `conj_mul_I` plus common `mul`/sign shuffles (`I`).
* `simp_conj_plus` — bounded nested `conj` cleanup.
* `ring_conj` — `simp_conj_plus` then `ring_nf`.
* `field_conj` — `field_simp`, then bounded `conj` peel / `ring_nf`.
* **`simp_log`** — `Complex.log` via `log_re` / `log_im` (+ `log 0`, `log 1`).
* **`simp_arg`** — common `Complex.arg` special values (`0`, `1`, `±1`, `±I`, naturals).
* **`push_div`** — `z / w` as `z * w⁻¹` (`div_eq_mul_inv`) for algebraic follow-up.
* **`simp_polar`** — polar identity `‖z‖ * exp(arg z · I) = z`.
* **`grind_cplx`** — cheap pipeline: norms/polar → Cartesian → divisions → logs/args → `conj` → `ring_nf` → `field_simp`.
* `cplx_ext` — split `ℂ` equality with `Complex.ext` then `simp`.
* `cplx_re_im` — expand `re`/`im` of `+`, `*`, reals, `I` (small cartesian bursts).
* `simp_abs` — rewrite `Complex.abs` to `‖·‖`/`norm`/sqrt form for `simp` closures.
-/

/-- Core `conj` peel (minimal; safe on most algebraic goals). -/
macro "simp_conj" : tactic =>
  `(tactic|
      simp only [map_mul, map_add, map_sub, map_neg, map_pow, map_one, map_zero,
        conj_I, conj_ofReal, conj_natCast, conj_ofNat, div_eq_mul_inv, conj_inv])

/-- Like `simp_conj`, but also rotates `conj` across `I` and normalizes commutative products a bit. -/
macro "simp_conj!" : tactic =>
  `(tactic|
      simp only [map_mul, map_add, map_sub, map_neg, map_pow, map_one, map_zero,
        conj_I, conj_ofReal, conj_natCast, conj_ofNat, div_eq_mul_inv, conj_inv,
        conj_mul_I, mul_assoc, mul_comm, mul_left_comm, neg_mul, mul_neg])

/-- Nested `conj` bookkeeping: bounded iteration of `simp_conj`. -/
macro "simp_conj_plus" : tactic =>
  `(tactic| simp_conj)

macro "ring_conj" : tactic =>
  `(tactic| repeat' (first | simp_conj_plus | ring_nf))

macro "cplx_ext" : tactic =>
  `(tactic| refine Complex.ext ?_ ?_ <;> simp)

macro "cplx_re_im" : tactic =>
  `(tactic|
      simp only [Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im, Complex.neg_re,
        Complex.neg_im, Complex.sub_re, Complex.sub_im,
        Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
        mul_assoc, mul_comm, mul_left_comm])

macro "simp_abs" : tactic =>
  `(tactic| simp only [Complex.abs_def, Complex.norm_def])

/-- `Complex.log` in terms of `‖·‖`, `arg`, and `Real.log` (often for `re`/`im` pushes). -/
macro "simp_log" : tactic =>
  `(tactic|
      simp only [Complex.log_re, Complex.log_im, Complex.log_zero, Complex.log_one])

/-- Select `Complex.arg` values (nonnegative reals cast to `ℂ`, `±1`, `±I`, etc.). -/
macro "simp_arg" : tactic =>
  `(tactic|
      simp only [Complex.arg_zero, Complex.arg_one, Complex.arg_neg_one, Complex.arg_I,
        Complex.arg_neg_I, Complex.arg_div_self, Complex.natCast_arg, Complex.ofNat_arg])

/-- Prefer multiplicative form `z * w⁻¹` (then use `ring_nf` / `field_simp` as needed). -/
macro "push_div" : tactic =>
  `(tactic| try simp_rw [div_eq_mul_inv])

/-- Polar glue: `‖z‖ * exp (arg z · I) = z` (Mathlib `Complex.norm_mul_exp_arg_mul_I`). -/
macro "simp_polar" : tactic =>
  `(tactic| try simp only [Complex.norm_mul_exp_arg_mul_I])

/-- One-pass “complex grind”: light `simp` bursts and normal forms (all steps are `try`). -/
macro "grind_cplx" : tactic =>
  `(tactic|
      repeat' (first
        | simp_abs
        | simp_polar
        | cplx_re_im
        | push_div
        | simp_log
        | simp_arg
        | simp_conj_plus
        | ring_nf
        | field_simp))

/-- `field_simp` then bounded `conj` peel / `ring_nf` (use when denominators muddy the goal). -/
macro "field_conj" : tactic =>
  `(tactic| repeat' (first | field_simp | simp_conj_plus | ring_nf))

namespace FourAxioms

/-! ## The four axioms, as Lean definitions

We package the four-axiom premise as a structure. Any concrete (μ, B, C)
satisfying it gives rise to all the consequences below. -/

/-- The observation μ together with the assumption that it lies in Q2 on
    the unit circle.

**Trivial “ζ” zeros vs this geometry:** the classical points `s = -2,-4,-6,…`
come from the **Γ-factor / completion** (pole-zero bookkeeping in the archimedean
Euler product), not from the **open Q2** locus `re_neg ∧ im_pos` used here. They
lie on the **negative real axis** and **never enter Q2**.

**Octagon / D8 crossing:** the unit-circle crossing locus at angles `π/4` and
`5π/4` (Q1 and Q3 on `S¹`) is packaged later via `Phase8` and `sourceOctagon`.
That locus is **disjoint** from the negative real axis where the trivial
completion points live. -/
structure Observation where
  μ        : ℂ
  re_neg   : μ.re < 0
  im_pos   : 0 < μ.im
  unit_mod : Complex.abs μ = 1

/-- The factorization of the observation `μ` as `μ = B·C` with
`arg μ = arg B + arg C`.

**Source–medium–sink (same pattern as Ohm's law):** read `B` as the
source-like factor, `C` as the medium-like factor, and the product `B·C`
as the closed observable (sink-side accounting). The concrete circuit
identity `V = I·R` is the same multiplicative shape: injection × path/load
response yields what you measure across the channel. -/
structure Factorization (O : Observation) where
  B        : ℂ
  C        : ℂ
  product  : B * C = O.μ
  arg_add  : Complex.arg B + Complex.arg C = Complex.arg O.μ
  -- non-degeneracy: B and C nonzero, so arg is well-defined
  B_ne     : B ≠ 0
  C_ne     : C ≠ 0

/-! ## §1.  μ on the symmetric diagonal of Q2

The framework's coupling assumption (Re ⊥ Im, no preferred axis between them)
is captured here as: μ lies on the symmetric diagonal x = -y in Q2.
This is the natural fixed point of the Re↔Im symmetry; it isn't derived
from the bare axioms 1–2 (those alone leave the whole Q2 arc), but follows
once we add the symmetric-diagonal premise the notes record as
"Re ⊥ Im + coupling". We make that premise explicit as a hypothesis. -/

/-- The canonical observation μ = -1/√2 + i/√2. -/
noncomputable def μ_canonical : ℂ :=
  ⟨-(1 / Real.sqrt 2), 1 / Real.sqrt 2⟩

@[simp] lemma mu_canonical_re : μ_canonical.re = -(1 / Real.sqrt 2 : ℝ) := rfl

@[simp] lemma mu_canonical_im : μ_canonical.im = (1 / Real.sqrt 2 : ℝ) := rfl

/-- Unit-circle split for the canonical seed in component form. -/
lemma mu_canonical_re_sq_add_im_sq : μ_canonical.re ^ 2 + μ_canonical.im ^ 2 = 1 := by
  have hsq : (Real.sqrt 2 : ℝ) ^ 2 = 2 := by
    nlinarith [Real.sq_sqrt (by norm_num : (0 : ℝ) ≤ 2)]
  calc
    μ_canonical.re ^ 2 + μ_canonical.im ^ 2
        = (-(1 / Real.sqrt 2 : ℝ)) ^ 2 + (1 / Real.sqrt 2 : ℝ) ^ 2 := by
            simp [mu_canonical_re, mu_canonical_im]
    _ = (1 / 2 : ℝ) + (1 / 2 : ℝ) := by
          field_simp [hsq]
    _ = 1 := by norm_num

/-- Uniqueness of the canonical seed from geometry:
unit circle + Q2 sign conditions + diagonal symmetry (`Re = -Im`) force `μ = μ_canonical`. -/
theorem mu_forced_eq_mu_canonical_of_unit_q2_diagonal (μ : ℂ)
    (hunit : μ.re ^ 2 + μ.im ^ 2 = 1)
    (hre : μ.re < 0) (him : 0 < μ.im)
    (hdiag : μ.re = -μ.im) :
    μ = μ_canonical := by
  have hre_sq : μ.re ^ 2 = μ.im ^ 2 := by nlinarith [hdiag]
  have him_sq : μ.im ^ 2 = (1 / 2 : ℝ) := by nlinarith [hunit, hre_sq]
  have hsqrt2 : (Real.sqrt 2) ^ 2 = (2 : ℝ) := by
    nlinarith [Real.sq_sqrt (by norm_num : (0 : ℝ) ≤ 2)]
  have hhalf : (1 / Real.sqrt 2 : ℝ) ^ 2 = (1 / 2 : ℝ) := by
    field_simp [hsqrt2]
  have him_sq' : μ.im ^ 2 = (1 / Real.sqrt 2 : ℝ) ^ 2 := by
    linarith [him_sq, hhalf]
  rcases sq_eq_sq_iff_eq_or_eq_neg.mp him_sq' with him_pos | him_neg
  · have hre' : μ.re = -(1 / Real.sqrt 2 : ℝ) := by
      nlinarith [hdiag, him_pos]
    apply Complex.ext <;> simp [μ_canonical, hre', him_pos]
  · exfalso
    have hpos : (0 : ℝ) < 1 / Real.sqrt 2 := by positivity
    have him_lt : μ.im < 0 := by nlinarith [him_neg, hpos]
    exact (not_lt_of_gt him) him_lt

lemma sqrt_two_div_two_eq_inv_sqrt_two : Real.sqrt 2 / 2 = 1 / Real.sqrt 2 := by
  have hsp : (0 : ℝ) < Real.sqrt 2 := Real.sqrt_pos.mpr (show (0 : ℝ) < 2 by norm_num)
  field_simp [hsp.ne']

lemma three_mul_pi_div_four_mem_Ioc_pi :
    (3 * Real.pi / 4 : ℝ) ∈ Set.Ioc (-Real.pi) Real.pi := by
  refine ⟨?_ , ?_⟩
  · nlinarith [Real.pi_pos]
  · linarith [Real.pi_pos]

lemma mu_canonical_eq_cos_sin_three_pi_div_four :
    μ_canonical = Real.cos (3 * Real.pi / 4) + Real.sin (3 * Real.pi / 4) * Complex.I := by
  have hcos :
      Real.cos (3 * Real.pi / 4) = -(Real.sqrt 2 / 2) := calc
      Real.cos (3 * Real.pi / 4) = Real.cos (Real.pi - Real.pi / 4) := by ring_nf
      _ = -Real.cos (Real.pi / 4) := Real.cos_pi_sub _
      _ = -(Real.sqrt 2 / 2) := by rw [Real.cos_pi_div_four]
  have hsin :
      Real.sin (3 * Real.pi / 4) = Real.sqrt 2 / 2 := calc
      Real.sin (3 * Real.pi / 4) = Real.sin (Real.pi - Real.pi / 4) := by ring_nf
      _ = Real.sin (Real.pi / 4) := Real.sin_pi_sub _
      _ = Real.sqrt 2 / 2 := Real.sin_pi_div_four
  refine Complex.ext ?_ ?_
  · -- real part
    simp [Complex.add_re, Complex.mul_re, hcos, sqrt_two_div_two_eq_inv_sqrt_two, μ_canonical_re]
    ring
  · -- imaginary part
    simp [Complex.add_im, Complex.mul_im, hsin, sqrt_two_div_two_eq_inv_sqrt_two, μ_canonical_im]
    ring

theorem μ_canonical_abs : Complex.abs μ_canonical = 1 := by
  rw [Complex.abs_def]
  simp only [Complex.normSq_apply, μ_canonical_re, μ_canonical_im]
  rw [mu_canonical_re_sq_add_im_sq, Real.sqrt_one]

theorem μ_canonical_arg : Complex.arg μ_canonical = 3 * Real.pi / 4 := by
  rw [← mu_canonical_eq_cos_sin_three_pi_div_four]
  exact Complex.arg_cos_add_sin_mul_I three_mul_pi_div_four_mem_Ioc_pi

/-- Equal-energy split at the canonical angle (`arg μ = 3π/4`):
each squared component contributes `1/2`. -/
lemma mu_canonical_re_sq_eq_half : μ_canonical.re ^ 2 = (1 / 2 : ℝ) := by
  have hsq : (Real.sqrt 2 : ℝ) ^ 2 = 2 := by
    nlinarith [Real.sq_sqrt (by norm_num : (0 : ℝ) ≤ 2)]
  calc
    μ_canonical.re ^ 2 = (-(1 / Real.sqrt 2 : ℝ)) ^ 2 := by simp [mu_canonical_re]
    _ = (1 / 2 : ℝ) := by field_simp [hsq]

lemma mu_canonical_im_sq_eq_half : μ_canonical.im ^ 2 = (1 / 2 : ℝ) := by
  have hsq : (Real.sqrt 2 : ℝ) ^ 2 = 2 := by
    nlinarith [Real.sq_sqrt (by norm_num : (0 : ℝ) ≤ 2)]
  calc
    μ_canonical.im ^ 2 = (1 / Real.sqrt 2 : ℝ) ^ 2 := by simp [mu_canonical_im]
    _ = (1 / 2 : ℝ) := by field_simp [hsq]

/-! ## §2.  B = 1+i and C = i/√2 are the canonical solution

These are forced once we add the "minimal integer-aligned source" criterion.
We write them as `def`s and prove they satisfy `Factorization`. -/

noncomputable def B_canonical : ℂ := ⟨1, 1⟩          -- 1 + i
noncomputable def C_canonical : ℂ := ⟨0, 1 / Real.sqrt 2⟩  -- i/√2

theorem B_abs : Complex.abs B_canonical = Real.sqrt 2 := by
  unfold B_canonical
  rw [Complex.abs_def]
  simp [Complex.normSq]
  norm_num

/-- Magnitude of the Gaussian dilation `(1+i)^k = B_canonical^k`: `|B|^k = (√2)^k`. -/
theorem B_canonical_pow_abs (k : ℕ) :
    Complex.abs (B_canonical ^ k) = (Real.sqrt 2 : ℝ) ^ k := by
  calc
    Complex.abs (B_canonical ^ k) = Complex.abs B_canonical ^ k := by
      simpa [Complex.abs] using (norm_pow B_canonical k)
    _ = (Real.sqrt 2) ^ k := congrArg (fun x : ℝ => x ^ k) B_abs

/-- Notebook name for `B_canonical^k` as the `k`-fold `(1+i)` scaling step on `ℤ[i]` (embedded in `ℂ`).

**Discrete RG / octagon picture:** each multiplication by `1 + i` scales lengths by `√2`
(`B_abs` / `gaussian_scale_factor_abs`) and rotates by `π/4` (45°), so eight steps close an
octagon orbit (`B_canonical_pow_eight`, `gaussianScaleFactor_phase_cycle`). This is the usual
“renormalisation group” step on the Gaussian lattice: same generator at every scale.

**Area vs inverse-square:** in the plane, Euclidean “inverse-square” intensity is tied to area
scaling with radius — here each step doubles cell area since `|B|² = 2`; see `gaussianScaleFactor_area`. -/
noncomputable def gaussianScaleFactor (k : ℕ) : ℂ := B_canonical ^ k

@[simp]
theorem gaussianScaleFactor_eq (k : ℕ) : gaussianScaleFactor k = B_canonical ^ k := rfl

theorem gaussian_scale_factor_abs (k : ℕ) :
    Complex.abs (gaussianScaleFactor k) = (Real.sqrt 2 : ℝ) ^ k := by
  simpa [gaussianScaleFactor_eq] using B_canonical_pow_abs k

/-- Induction base for Gaussian scaling: at `k=0`, the scale factor is `1`. -/
@[simp] theorem gaussianScaleFactor_zero : gaussianScaleFactor 0 = (1 : ℂ) := by
  simp [gaussianScaleFactor]

/-- Induction step for Gaussian scaling:
`(1+i)^(k+1) = (1+i) * (1+i)^k` in packaged `gaussianScaleFactor` form. -/
theorem gaussianScaleFactor_succ (k : ℕ) :
    gaussianScaleFactor (k + 1) = B_canonical * gaussianScaleFactor k := by
  simp [gaussianScaleFactor, pow_succ, mul_comm, mul_left_comm, mul_assoc]

/-- Bundled induction form for Gaussian scaling. -/
theorem gaussianScaleFactor_induction_form (k : ℕ) :
    gaussianScaleFactor 0 = (1 : ℂ) ∧
      gaussianScaleFactor (k + 1) = B_canonical * gaussianScaleFactor k := by
  exact ⟨gaussianScaleFactor_zero, gaussianScaleFactor_succ k⟩

/-- Cell-area scaling law for the `k`-fold Gaussian dilation:
`|B^k|^2 = 2^k` for `B = 1 + i`.

Same doubling as one would expect from scaling lengths by `√2` in 2D (area ∝ length²); this is the
lattice analogue of inverse-square / spherical area scaling, restricted to the `(1+i)^k ℤ[i]` tower. -/
theorem gaussianScaleFactor_area (k : ℕ) :
    (Complex.abs (gaussianScaleFactor k)) ^ 2 = (2 : ℝ) ^ k := by
  rw [gaussian_scale_factor_abs]
  calc
    ((Real.sqrt 2 : ℝ) ^ k) ^ 2 = (Real.sqrt 2 : ℝ) ^ (k * 2) := by
      symm
      rw [pow_mul]
    _ = (Real.sqrt 2 : ℝ) ^ (2 * k) := by rw [Nat.mul_comm]
    _ = ((Real.sqrt 2 : ℝ) ^ 2) ^ k := by rw [pow_mul]
  have hsq : (Real.sqrt 2 : ℝ) ^ 2 = 2 := by
    nlinarith [Real.sq_sqrt (by norm_num : (0 : ℝ) ≤ 2)]
  simpa [hsq]

/-- Base algebra for the phase channel: `(1+i)^2 = 2i`. -/
theorem B_canonical_sq : B_canonical ^ 2 = (2 : ℂ) * Complex.I := by
  unfold B_canonical
  norm_num [pow_two, Complex.ext_iff, Complex.mul_re, Complex.mul_im]

/-- Octagon-cycle closure: after 8 Gaussian steps, phase returns to the real axis. -/
theorem B_canonical_pow_eight : B_canonical ^ 8 = (16 : ℂ) := by
  unfold B_canonical
  norm_num [pow_succ, pow_two, Complex.ext_iff, Complex.mul_re, Complex.mul_im, Complex.I_sq]

/-- Phase-periodic scaling law: stepping by 8 multiplies only by the real factor `16`. -/
theorem gaussianScaleFactor_phase_cycle (k : ℕ) :
    gaussianScaleFactor (k + 8) = (16 : ℂ) * gaussianScaleFactor k := by
  unfold gaussianScaleFactor
  calc
    B_canonical ^ (k + 8) = B_canonical ^ 8 * B_canonical ^ k := by
      simpa [Nat.add_comm, Nat.add_left_comm, Nat.add_assoc] using (pow_add B_canonical 8 k)
    _ = (16 : ℂ) * B_canonical ^ k := by rw [B_canonical_pow_eight]
    _ = (16 : ℂ) * gaussianScaleFactor k := by rfl

/-- Branch-safe phase periodicity: adding 8 scale steps preserves `arg`. -/
theorem gaussianScaleFactor_arg_periodic_8 (k : ℕ) :
    Complex.arg (gaussianScaleFactor (k + 8)) = Complex.arg (gaussianScaleFactor k) := by
  rw [gaussianScaleFactor_phase_cycle]
  have h16 : (0 : ℝ) < 16 := by norm_num
  calc
    Complex.arg ((16 : ℂ) * gaussianScaleFactor k)
        = Complex.arg (((16 : ℝ) : ℂ) * gaussianScaleFactor k) := by norm_num
    _ = Complex.arg (gaussianScaleFactor k) := by
          simpa [mul_comm] using (Complex.arg_mul_real h16 (gaussianScaleFactor k))

/-- Exponential phase multiplication law from `exp` additivity. -/
lemma exp_mul_I_add (θ φ : ℝ) :
    Complex.exp ((θ + φ) * Complex.I)
      = Complex.exp (θ * Complex.I) * Complex.exp (φ * Complex.I) := by
  calc
    Complex.exp ((θ + φ) * Complex.I)
        = Complex.exp (θ * Complex.I + φ * Complex.I) := by ring
    _ = Complex.exp (θ * Complex.I) * Complex.exp (φ * Complex.I) := by
          simpa using Complex.exp_add (θ * Complex.I) (φ * Complex.I)

/-- Polar form for the Gaussian generator: `1+i = √2 · exp(iπ/4)`. -/
theorem B_canonical_eq_sqrt2_mul_exp_pi_div_four :
    B_canonical = ((Real.sqrt 2 : ℝ) : ℂ) * Complex.exp ((Real.pi / 4) * Complex.I) := by
  conv_rhs => rw [← Complex.exp_ofReal_mul_I]
  unfold B_canonical
  refine Complex.ext ?_ ?_
  · simp [Complex.mul_re, Complex.mul_im, Complex.add_re]
    rw [Real.cos_pi_div_four, Real.sin_pi_div_four]
    have hsq : (Real.sqrt (2 : ℝ)) ^ 2 = 2 := Real.sq_sqrt (show (0 : ℝ) ≤ 2 by positivity)
    field_simp; ring_nf; rw [hsq]; ring
  · simp [Complex.mul_re, Complex.mul_im, Complex.add_im]
    rw [Real.cos_pi_div_four, Real.sin_pi_div_four]
    have hsq : (Real.sqrt (2 : ℝ)) ^ 2 = 2 := Real.sq_sqrt (show (0 : ℝ) ≤ 2 by positivity)
    field_simp; ring_nf; rw [hsq]; ring

lemma pi_div_four_mem_Ioc_pi : Real.pi / 4 ∈ Set.Ioc (-Real.pi) Real.pi := by
  refine ⟨?_, ?_⟩
  · nlinarith [Real.pi_pos, Real.pi_div_four_pos]
  · nlinarith [Real.pi_pos]

theorem B_canonical_arg : Complex.arg B_canonical = Real.pi / 4 := by
  have hsqrt2 : 0 < Real.sqrt (2 : ℝ) := Real.sqrt_pos.2 (show (0 : ℝ) < 2 by norm_num)
  rw [B_canonical_eq_sqrt2_mul_exp_pi_div_four, Complex.exp_ofReal_mul_I]
  simpa [Complex.ofReal_cos, Complex.ofReal_sin] using
    Complex.arg_mul_cos_add_sin_mul_I (r := Real.sqrt (2 : ℝ))
      (θ := Real.pi / 4) hsqrt2 pi_div_four_mem_Ioc_pi

/-- One-step reference angle: the Gaussian generator has argument `π/4`. -/
theorem gaussianScaleFactor_arg_one :
    Complex.arg (gaussianScaleFactor 1) = Real.pi / 4 := by
  rwa [gaussianScaleFactor_eq, pow_one]

/-- **Linear phase model:** `(1+i)^k = (√2)^k · exp(i k π/4)` (De Moivre on the Gaussian step). -/
theorem gaussianScaleFactor_linear_phase (k : ℕ) :
    gaussianScaleFactor k
      = ((Real.sqrt 2 : ℝ) ^ k : ℂ) * Complex.exp (((k : ℝ) * (Real.pi / 4)) * Complex.I) := by
  induction k with
  | zero =>
      simp [gaussianScaleFactor_zero, pow_zero, Complex.exp_zero]
  | succ k ih =>
      calc
        gaussianScaleFactor (Nat.succ k)
            = B_canonical * gaussianScaleFactor k := gaussianScaleFactor_succ _
        _ = ((((Real.sqrt 2 : ℝ) : ℂ)) * Complex.exp ((Real.pi / 4) * Complex.I))
              * (((Real.sqrt 2 : ℝ) ^ k : ℂ)
                * Complex.exp (((k : ℝ) * (Real.pi / 4)) * Complex.I)) := by
              rw [B_canonical_eq_sqrt2_mul_exp_pi_div_four, ih]
        _ = ((((Real.sqrt 2 : ℝ) : ℂ)) * (((Real.sqrt 2 : ℝ) ^ k : ℂ))) *
              (Complex.exp ((Real.pi / 4) * Complex.I)
                * Complex.exp (((k : ℝ) * (Real.pi / 4)) * Complex.I)) := by
              simp [mul_assoc, mul_left_comm, mul_comm]
        _ = (((Real.sqrt (2 : ℝ)) ^ (k + 1) : ℂ))
              * Complex.exp ((((↑k + 1 : ℕ) : ℝ) * (Real.pi / 4)) * Complex.I) := by
              simp [pow_succ, Complex.ofReal_mul, Complex.ofReal_pow, mul_assoc, mul_comm,
                mul_left_comm]
              congr 2
              rw [← exp_mul_I_add ((Real.pi / 4)) ((k : ℝ) * (Real.pi / 4))]
              congr 1 <;> ring_nf <;> push_cast <;> ring

/-- Consolidated geometric channels for Gaussian scaling at index `k`. -/
theorem gaussianScaleFactor_phase_magnitude_area (k : ℕ) :
    Complex.abs (gaussianScaleFactor k) = (Real.sqrt 2 : ℝ) ^ k ∧
      (Complex.abs (gaussianScaleFactor k)) ^ 2 = (2 : ℝ) ^ k ∧
      gaussianScaleFactor k
        = ((Real.sqrt 2 : ℝ) ^ k : ℂ) * Complex.exp (((k : ℝ) * (Real.pi / 4)) * Complex.I) := by
  exact ⟨gaussian_scale_factor_abs k, gaussianScaleFactor_area k, gaussianScaleFactor_linear_phase k⟩

/-- Silver-ratio identity at the canonical source:
`Re(B) + |B| = 1 + √2` for `B = 1 + i`. -/
theorem silver_ratio_eq_re_B_add_abs_B :
    B_canonical.re + Complex.abs B_canonical = 1 + Real.sqrt 2 := by
  simpa [B_canonical] using congrArg (fun t : ℝ => (1 : ℝ) + t) B_abs

theorem C_abs : Complex.abs C_canonical = 1 / Real.sqrt 2 := by
  unfold C_canonical
  rw [Complex.abs_def]
  simp [Complex.normSq]

/-- The unit-modulus balance |B|·|C| = 1.  This is the r ↔ 1/r symmetry
    in raw form, forced by axiom 2 + axiom 3. -/
theorem magnitude_balance :
    Complex.abs B_canonical * Complex.abs C_canonical = 1 := by
  rw [B_abs, C_abs]
  have h2 : Real.sqrt 2 ≠ 0 := by positivity
  field_simp

/-- Radius-channel reading of the medium: `|C| = 1 / |B|`.
This is the precise scalar sense in which the medium is reciprocal radius. -/
theorem medium_modulus_is_reciprocal_radius :
    Complex.abs C_canonical = 1 / Complex.abs B_canonical := by
  rw [B_abs, C_abs]

/-- The product B · C equals the canonical μ. -/
theorem B_mul_C_eq_μ : B_canonical * C_canonical = μ_canonical := by
  unfold B_canonical C_canonical μ_canonical
  refine Complex.ext ?_ ?_
  · -- real parts: 1·0 - 1·(1/√2) = -1/√2  ✓
    simp [Complex.mul_re]
  · -- imag parts: 1·(1/√2) + 1·0 = 1/√2   ✓
    simp [Complex.mul_im]

/-! ## §3.  Complex log bridges Cartesian and polar

For any nonzero z, log z = log |z| + i·arg(z).  This is `Complex.log_eq_…`
in Mathlib; we state the consequence we need: log distributes over our product. -/

/-- log(B·C) = log B + log C for our nonzero canonical values. -/
theorem log_distrib :
    Complex.log (B_canonical * C_canonical) =
      Complex.log B_canonical + Complex.log C_canonical := by
  apply Complex.log_mul
  · -- B ≠ 0
    intro h
    unfold B_canonical at h
    have := congrArg Complex.re h
    simp at this
  · -- C ≠ 0
    intro h
    unfold C_canonical at h
    have := congrArg Complex.im h
    simp at this

/-- Real-part cancellation in log B + log C corresponds to |B|·|C| = 1. -/
theorem log_real_parts_cancel :
    (Complex.log B_canonical).re + (Complex.log C_canonical).re = 0 := by
  rw [Complex.log_re, Complex.log_re, B_abs, C_abs]
  have hs0 : (Real.sqrt 2) ≠ 0 := by positivity
  rw [one_div, Real.log_inv, Real.log_sqrt (by positivity : (0 : ℝ) ≤ 2)]
  · ring
  · exact hs0

/-! ## §4.  Phase closure φ - θ = 0 is automatic

Define φ = arg(A) and θ = arg(B) + arg(C). The factorization axiom gives
arg_add directly: φ - θ = arg(A) - (arg(B) + arg(C)) = 0. -/

theorem phase_closure (O : Observation) (F : Factorization O) :
    Complex.arg O.μ - (Complex.arg F.B + Complex.arg F.C) = 0 := by
  rw [F.arg_add]; ring

/-! ## §4b.  Cartesian channel decomposition for `A = B * C`

These identities keep the same factorization story in explicit Re/Im form.
They are the coordinate-channel counterpart of the phase relation above. -/

/-- Real-part channel of the factorization `A = B * C`. -/
lemma factorization_re_channel (O : Observation) (F : Factorization O) :
    O.μ.re = F.B.re * F.C.re - F.B.im * F.C.im := by
  simpa [Complex.mul_re] using (congrArg Complex.re F.product).symm

/-- Imaginary-part channel of the factorization `A = B * C`. -/
lemma factorization_im_channel (O : Observation) (F : Factorization O) :
    O.μ.im = F.B.re * F.C.im + F.B.im * F.C.re := by
  simpa [Complex.mul_im] using (congrArg Complex.im F.product).symm

/-- Bundled Re/Im channel decomposition for the observation `A`. -/
lemma factorization_reim_bundle (O : Observation) (F : Factorization O) :
    O.μ.re = F.B.re * F.C.re - F.B.im * F.C.im
      ∧
    O.μ.im = F.B.re * F.C.im + F.B.im * F.C.re := by
  exact ⟨factorization_re_channel O F, factorization_im_channel O F⟩

/-! ## §4d.  Unit-modulus consequences (`|μ| = 1`)

For any factorization `A = B * C` of an observation with `|A| = 1`,
the source/medium radii are multiplicative reciprocals. -/

/-- From `|μ|=1` and `μ=B*C`, the product modulus is exactly one. -/
lemma factorization_abs_product_eq_one (O : Observation) (F : Factorization O) :
    Complex.abs (F.B * F.C) = 1 := by
  simpa [F.product] using O.unit_mod

/-- Norm-channel product balance for a general factorization with `|μ|=1`. -/
lemma factorization_norm_balance (O : Observation) (F : Factorization O) :
    ‖F.B‖ * ‖F.C‖ = 1 := by
  have hprod : ‖F.B * F.C‖ = 1 := by
    simpa using factorization_abs_product_eq_one O F
  simpa [norm_mul] using hprod

/-- Radius reciprocity for the medium channel in any unit-modulus factorization. -/
lemma factorization_medium_norm_is_reciprocal_source (O : Observation) (F : Factorization O) :
    ‖F.C‖ = 1 / ‖F.B‖ := by
  have hbal := factorization_norm_balance O F
  have hB : ‖F.B‖ ≠ 0 := by
    exact norm_ne_zero_iff.mpr F.B_ne
  apply (eq_div_iff hB).2
  simpa [mul_comm] using hbal

/-- Abstract unit-modulus bridge for any factorization:
the observation has modulus one, the factor radii multiply to one, and the
medium radius is the reciprocal of the source radius. -/
theorem factorization_unit_modulus_bridge (O : Observation) (F : Factorization O) :
    Complex.abs O.μ = 1 ∧ ‖F.B‖ * ‖F.C‖ = 1 ∧ ‖F.C‖ = 1 / ‖F.B‖ := by
  exact ⟨O.unit_mod, factorization_norm_balance O F,
    factorization_medium_norm_is_reciprocal_source O F⟩

/-! ## §4c.  Explicit `x + iy` substitution

This is the fully coordinate-level form of complex multiplication, plus the
specialization to any factorization `A = B * C` in this file. -/

/-- Expanded coordinate formula for `(x + iy) * (u + iv)`. -/
lemma mul_xyuv_expand (x y u v : ℝ) :
    (((x : ℂ) + y * Complex.I) * ((u : ℂ) + v * Complex.I))
      = ((x * u - y * v : ℝ) : ℂ) + (x * v + y * u) * Complex.I := by
  refine Complex.ext ?_ ?_
  · simp [Complex.mul_re, Complex.mul_im, Complex.I_re, Complex.I_im]
    ring
  · simp [Complex.mul_re, Complex.mul_im, Complex.I_re, Complex.I_im]
    ring

/-- Real channel for `(x + iy) * (u + iv)`. -/
lemma mul_xyuv_re (x y u v : ℝ) :
    ((((x : ℂ) + y * Complex.I) * ((u : ℂ) + v * Complex.I)).re)
      = x * u - y * v := by
  simpa [mul_xyuv_expand x y u v]

/-- Imaginary channel for `(x + iy) * (u + iv)`. -/
lemma mul_xyuv_im (x y u v : ℝ) :
    ((((x : ℂ) + y * Complex.I) * ((u : ℂ) + v * Complex.I)).im)
      = x * v + y * u := by
  simpa [mul_xyuv_expand x y u v]

/-- Substituting `B = x+iy`, `C = u+iv` into `A = B*C`: real channel. -/
lemma factorization_re_channel_xy (O : Observation) (F : Factorization O)
    (x y u v : ℝ)
    (hB : F.B = (x : ℂ) + y * Complex.I)
    (hC : F.C = (u : ℂ) + v * Complex.I) :
    O.μ.re = x * u - y * v := by
  rw [factorization_re_channel O F, hB, hC]
  simp

/-- Substituting `B = x+iy`, `C = u+iv` into `A = B*C`: imaginary channel. -/
lemma factorization_im_channel_xy (O : Observation) (F : Factorization O)
    (x y u v : ℝ)
    (hB : F.B = (x : ℂ) + y * Complex.I)
    (hC : F.C = (u : ℂ) + v * Complex.I) :
    O.μ.im = x * v + y * u := by
  rw [factorization_im_channel O F, hB, hC]
  simp [mul_comm, mul_left_comm, mul_assoc, add_comm, add_left_comm, add_assoc]

/-- Bundled coordinate substitution for `A = B*C` with `B = x+iy`, `C = u+iv`. -/
lemma factorization_reim_bundle_xy (O : Observation) (F : Factorization O)
    (x y u v : ℝ)
    (hB : F.B = (x : ℂ) + y * Complex.I)
    (hC : F.C = (u : ℂ) + v * Complex.I) :
    O.μ.re = x * u - y * v ∧ O.μ.im = x * v + y * u := by
  exact ⟨factorization_re_channel_xy O F x y u v hB hC,
    factorization_im_channel_xy O F x y u v hB hC⟩

/-! ## §5.  Metallic ratios fall out

For B = n + i with n ≥ 0, the quantity Re(B) + |B| = n + √(n²+1)
is the n-th metallic mean.  Silver = (n=1), Golden = (n=1/2). -/

/-- The n-th metallic mean as a real number. -/
noncomputable def metallic (n : ℝ) : ℝ := n + Real.sqrt (n^2 + 1)

/-- Parameterized source family for metallic geometry: `B_n = n + i`. -/
noncomputable def B_metallic (n : ℝ) : ℂ :=
  (n : ℂ) + Complex.I

/-- The modulus of `B_n = n + i` is `√(n²+1)`. -/
theorem B_metallic_abs (n : ℝ) :
    Complex.abs (B_metallic n) = Real.sqrt (n ^ 2 + 1) := by
  unfold B_metallic
  rw [Complex.abs_def]
  congr_arg Real.sqrt
  simp [Complex.normSq_apply, Complex.add_re, Complex.add_im, Complex.ofReal_re, Complex.ofReal_im,
    Complex.I_re, Complex.I_im]
  ring

/-- General metallic identity:
`metallic n = Re(B_n) + |B_n|` for `B_n = n + i`. -/
theorem metallic_eq_re_B_metallic_add_abs_B_metallic (n : ℝ) :
    metallic n = (B_metallic n).re + Complex.abs (B_metallic n) := by
  unfold metallic B_metallic
  simp [B_metallic_abs]

/-- Equivalent orientation of the same identity (often convenient for rewriting). -/
theorem re_B_metallic_add_abs_B_metallic_eq_metallic (n : ℝ) :
    (B_metallic n).re + Complex.abs (B_metallic n) = metallic n := by
  simpa using (metallic_eq_re_B_metallic_add_abs_B_metallic n).symm

/-- Silver ratio:  metallic 1 = 1 + √2. -/
theorem silver_eq : metallic 1 = 1 + Real.sqrt 2 := by
  unfold metallic
  congr 1
  congr 1
  ring

/-- Golden ratio:  metallic (1/2) = (1 + √5)/2. -/
theorem golden_eq : metallic (1/2) = (1 + Real.sqrt 5) / 2 := by
  unfold metallic
  -- 1/2 + √(1/4 + 1) = 1/2 + √(5/4) = 1/2 + √5/2 = (1+√5)/2
  have h : ((1:ℝ)/2)^2 + 1 = 5 / 4 := by ring
  rw [h]
  have h2 : Real.sqrt (5/4) = Real.sqrt 5 / 2 := by
    calc
      Real.sqrt (5 / 4) = Real.sqrt 5 / Real.sqrt 4 := by
        rw [Real.sqrt_div (by positivity : (0:ℝ) ≤ 5)]
      _ = Real.sqrt 5 / 2 := by norm_num
  rw [h2]; ring

/-- The defining identity of the golden ratio: φ² = φ + 1. -/
theorem golden_self_referential :
    let φ := (1 + Real.sqrt 5) / 2
    φ^2 = φ + 1 := by
  simp only
  have h5 : Real.sqrt 5 ^ 2 = 5 := Real.sq_sqrt (by norm_num : (5:ℝ) ≥ 0)
  field_simp
  ring_nf
  rw [show Real.sqrt 5 ^ 2 = 5 from h5]
  ring

/-! ## §6.  Coherence in log coordinates

C(r) = 2r/(1+r)^2 on (0, ∞).  Writing r = e^μ,
this becomes C(r) = (1/2) * sech^2(μ/2). -/

noncomputable def coherence (r : ℝ) : ℝ := 2 * r / (1 + r)^2

theorem coherence_eq_sech_log (r : ℝ) (hr : 0 < r) :
    coherence r = (1 / 2) * (1 / (Real.cosh (Real.log r / 2))^2) := by
  unfold coherence
  have hr0 : r ≠ 0 := ne_of_gt hr
  have hcosh : Real.cosh (Real.log r / 2) = (Real.sqrt r + 1 / Real.sqrt r) / 2 := by
    have hsp : 0 < Real.sqrt r := Real.sqrt_pos.2 hr
    have hel : Real.exp (Real.log r / 2) = Real.sqrt r := by
      rw [← Real.sqrt_eq_rpow hr.le, Real.rpow_def_of_pos hr]
      ring_nf
    have hel' : Real.exp (-(Real.log r / 2)) = 1 / Real.sqrt r := by
      rw [Real.exp_neg, hel]
      field_simp [hsp.ne']
    rw [← mul_right_inj' (two_ne_zero : (2 : ℝ) ≠ 0)]
    calc
      (2 : ℝ) * Real.cosh (Real.log r / 2)
          = (Complex.exp (((Real.log r / 2) : ℝ) : ℂ) +
              Complex.exp (-(((Real.log r / 2) : ℝ) : ℂ))).re := by
            simp [Real.cosh, Complex.two_cosh, Complex.add_re]
      _ = Real.sqrt r + 1 / Real.sqrt r := by
            simp [Complex.exp_ofReal, hel, hel', Complex.add_re, Complex.ofReal_re]
      _ = (2 : ℝ) * ((Real.sqrt r + 1 / Real.sqrt r) / 2) := by ring
  rw [hcosh]
  have hsqrt : (Real.sqrt r)^2 = r := by rw [sq, Real.sq_sqrt (le_of_lt hr)]
  field_simp [Real.sqrt_ne_zero'.2 hr, hr0, hsqrt]
  ring

/-- `h`-form of coherence: `coherence (h^2) = (1/2) * sech(log h)^2` for `h > 0`. -/
theorem coherence_eq_half_sech_sq_log_h (h : ℝ) (hh : 0 < h) :
    coherence (h^2) = (1 / 2) * (1 / (Real.cosh (Real.log h))^2) := by
  have hsq_pos : 0 < h^2 := by positivity
  rw [coherence_eq_sech_log (h^2) hsq_pos]
  rw [Real.log_rpow hh.le]
  norm_num

/-- Normalized coherence channel in the `h`-parameterization. -/
noncomputable def coherenceC (h : ℝ) : ℝ :=
  Real.sqrt (2 * coherence (h^2))

/-- Magic transformation map: `h = e^μ` (real-parameter channel). -/
noncomputable def h_of_mu (μ : ℝ) : ℝ := Real.exp μ

/-- `h_of_mu` is always positive. -/
lemma h_of_mu_pos (μ : ℝ) : 0 < h_of_mu μ := by
  unfold h_of_mu
  exact Real.exp_pos μ

/-- Exact normalized identity: `C(h) = sech(log h)` for `h > 0`. -/
theorem coherenceC_eq_sech_log_h (h : ℝ) (hh : 0 < h) :
    coherenceC h = 1 / Real.cosh (Real.log h) := by
  unfold coherenceC
  rw [coherence_eq_half_sech_sq_log_h h hh]
  have hcalc :
      2 * ((1 / 2) * (1 / (Real.cosh (Real.log h))^2))
        = (1 / Real.cosh (Real.log h))^2 := by
    ring
  rw [hcalc, Real.sqrt_sq_eq_abs]
  exact abs_of_nonneg (by positivity)

/-- Coherence channel through the magic map `h = e^μ`:
`C(e^μ) = sech(μ)`. -/
theorem coherenceC_eq_sech_of_h_eq_exp_mu (μ : ℝ) :
    coherenceC (h_of_mu μ) = 1 / Real.cosh μ := by
  have hpos : 0 < h_of_mu μ := h_of_mu_pos μ
  calc
    coherenceC (h_of_mu μ) = 1 / Real.cosh (Real.log (h_of_mu μ)) :=
      coherenceC_eq_sech_log_h (h_of_mu μ) hpos
    _ = 1 / Real.cosh μ := by
      unfold h_of_mu
      simp [Real.log_exp]

/-- `h = e^μ` is off-equilibrium exactly when `μ ≠ 0`. -/
theorem h_of_mu_off_equilibrium_iff_mu_ne_zero (μ : ℝ) :
    h_of_mu μ ≠ 1 ↔ μ ≠ 0 := by
  unfold h_of_mu
  constructor
  · intro h μ0
    apply h
    simp [μ0]
  · intro hμ h1
    apply hμ
    have : Real.exp μ = Real.exp 0 := by simpa using h1
    exact (Real.exp_injective this)

/-- Magic-map version of the normalized defect/coherence bundle:
in `μ`-coordinates, off-equilibrium is exactly `μ ≠ 0`. -/
theorem RH_defect_off_equilibrium_bundle_of_mu (μ : ℝ) :
    ((0 < RH_defectC (h_of_mu μ)) ↔ (μ ≠ 0))
      ∧ ((μ ≠ 0) ↔ (coherenceC (h_of_mu μ) < 1)) := by
  have hbase : ((0 < RH_defectC (h_of_mu μ)) ↔ (h_of_mu μ ≠ 1))
      ∧ ((h_of_mu μ ≠ 1) ↔ (coherenceC (h_of_mu μ) < 1)) := by
    exact RH_defect_off_equilibrium_bundle (h_of_mu μ) (h_of_mu_pos μ)
  rcases hbase with ⟨hdef, hcoh⟩
  constructor
  · constructor
    · intro hpos
      exact (h_of_mu_off_equilibrium_iff_mu_ne_zero μ).1 (hdef.1 hpos)
    · intro hμ
      exact hdef.2 ((h_of_mu_off_equilibrium_iff_mu_ne_zero μ).2 hμ)
  · constructor
    · intro hμ
      exact hcoh.1 ((h_of_mu_off_equilibrium_iff_mu_ne_zero μ).2 hμ)
    · intro hlt
      exact (h_of_mu_off_equilibrium_iff_mu_ne_zero μ).1 (hcoh.2 hlt)

/-- The r ↔ 1/r symmetry of coherence (= even-ness of sech). -/
theorem coherence_symmetric (r : ℝ) (hr : 0 < r) :
    coherence r = coherence (1 / r) := by
  unfold coherence
  have hr' : r ≠ 0 := ne_of_gt hr
  field_simp
  ring

/-- Applying coherence to the medium modulus matches applying coherence to the source radius,
because coherence is symmetric under `r ↔ 1/r`. -/
theorem coherence_at_medium_modulus_eq_source :
    coherence (Complex.abs C_canonical) = coherence (Complex.abs B_canonical) := by
  have hBpos : 0 < Complex.abs B_canonical := by
    rw [B_abs]
    positivity
  calc
    coherence (Complex.abs C_canonical)
        = coherence (1 / Complex.abs B_canonical) := by rw [medium_modulus_is_reciprocal_radius]
    _ = coherence (Complex.abs B_canonical) := by
        simpa using (coherence_symmetric (Complex.abs B_canonical) hBpos).symm

/-- Peak of coherence at r = 1. -/
theorem coherence_peak : coherence 1 = 1/2 := by
  unfold coherence; norm_num

/-- Coherence is strictly below one on the positive radius channel. -/
theorem coherence_lt_one (r : ℝ) (hr : 0 < r) :
    coherence r < 1 := by
  unfold coherence
  have hden : 0 < (1 + r) ^ 2 := by positivity
  have hnum : 2 * r < (1 + r) ^ 2 := by
    nlinarith [sq_nonneg r]
  exact (div_lt_one hden).2 hnum

/-- RH defect channel in radius coordinates: `1 - C(r)`. -/
noncomputable def RH_defect (r : ℝ) : ℝ :=
  1 - coherence r

/-- The RH defect profile is exactly the coherence residual `1 - C(r)`.
Here `C(r)` is `coherence r`. -/
theorem RH_defect_eq_coherence_residual (r : ℝ) :
    RH_defect r = 1 - coherence r := by
  rfl

/-- Positivity of the defect is equivalent to strict sub-unity coherence. -/
theorem RH_defect_pos_iff_coherence_lt_one (r : ℝ) :
    0 < RH_defect r ↔ coherence r < 1 := by
  simpa [RH_defect] using (sub_pos : 0 < 1 - coherence r ↔ coherence r < 1)

/-- Off-equilibrium in the normalized channel is exactly `C(h) < 1`.
This packages: off-critical (radius form) ↔ off-equilibrium ↔ `C < 1`. -/
theorem off_equilibrium_iff_coherenceC_lt_one (h : ℝ) (hh : 0 < h) :
    h ≠ 1 ↔ coherenceC h < 1 := by
  constructor
  · intro hne
    rw [coherenceC_eq_sech_log_h h hh]
    have hlog_ne : Real.log h ≠ 0 := by
      intro hlog
      apply hne
      have hexp : Real.exp (Real.log h) = Real.exp 0 := by simpa [hlog]
      simpa [Real.exp_log hh, Real.exp_zero] using hexp
    have hcosh_gt : 1 < Real.cosh (Real.log h) := Real.one_lt_cosh hlog_ne
    exact one_div_lt_one hcosh_gt
  · intro hlt
    intro heq
    have h1 : coherenceC 1 = 1 := by
      rw [coherenceC_eq_sech_log_h 1 zero_lt_one]
      simp
    have : coherenceC 1 < 1 := by simpa [heq] using hlt
    have : (1 : ℝ) < 1 := by simpa [h1] using this
    exact (lt_irrefl (1 : ℝ)) this

/-- Normalized defect residual in the `h`-channel: `1 - C(h)`. -/
noncomputable def RH_defectC (h : ℝ) : ℝ :=
  1 - coherenceC h

/-- Unified equivalence bundle in the normalized channel:
off-equilibrium, sub-unity coherence, and positive defect residual are equivalent. -/
theorem RH_defect_off_equilibrium_bundle (h : ℝ) (hh : 0 < h) :
    ((0 < RH_defectC h) ↔ (h ≠ 1)) ∧ ((h ≠ 1) ↔ (coherenceC h < 1)) := by
  have hdef : 0 < RH_defectC h ↔ coherenceC h < 1 := by
    simpa [RH_defectC] using (sub_pos : 0 < 1 - coherenceC h ↔ coherenceC h < 1)
  refine ⟨?_, ?_⟩
  · constructor
    · intro hpos
      exact (off_equilibrium_iff_coherenceC_lt_one h hh).2 (hdef.mp hpos)
    · intro hoff
      exact hdef.mpr ((off_equilibrium_iff_coherenceC_lt_one h hh).1 hoff)
  · exact off_equilibrium_iff_coherenceC_lt_one h hh

/-- Off-critical positivity: if `r ≠ 1`, then the defect `1 - C(r)` is strictly positive.
The proof route is `coherence_lt_one` on `r > 0`. -/
theorem RH_defect_pos_of_off_critical (r : ℝ) (hr : 0 < r) (_hoff : r ≠ 1) :
    0 < RH_defect r := by
  unfold RH_defect
  exact sub_pos.mpr (coherence_lt_one r hr)

/-! ## §7.  σ = log₂|B| = 1/2

Direct calculation: log₂(√2) = 1/2. -/

/-- The forced value of σ from the magnitude condition. -/
noncomputable def σ_forced : ℝ := Real.logb 2 (Complex.abs B_canonical)

theorem σ_forced_eq_half : σ_forced = 1/2 := by
  unfold σ_forced
  rw [B_abs]
  rw [Real.logb, Real.log_sqrt (by positivity : (0:ℝ) ≤ 2)]
  have hlog2 : Real.log 2 ≠ 0 := by
    exact ne_of_gt (Real.log_pos (by norm_num))
  field_simp [hlog2]

/-! ## §8.  Geometric proof by contradiction

Goal: σ = 1/2 is the unique fixed axis of the involution s ↔ 1-s on ℝ.
This is a clean theorem about real numbers; the framework consequences
(magnitude balance breaking, axiom 2 violated) are corollaries
once the involution structure is in place. -/

/-- The involution σ ↔ 1 - σ on ℝ. -/
def reflect (σ : ℝ) : ℝ := 1 - σ

theorem reflect_involutive : Function.Involutive reflect := by
  intro σ; unfold reflect; ring

/-- Fixed point characterization:  reflect σ = σ ↔ σ = 1/2. -/
theorem reflect_fixed_iff (σ : ℝ) : reflect σ = σ ↔ σ = 1/2 := by
  unfold reflect
  constructor
  · intro h; linarith
  · intro h; rw [h]; ring

/-- The contrapositive form used in the proof by contradiction:
    if σ ≠ 1/2 then s and its reflection are distinct points. -/
theorem off_critical_line_splits (σ : ℝ) (h : σ ≠ 1/2) :
    reflect σ ≠ σ := by
  intro hfix
  exact h ((reflect_fixed_iff σ).mp hfix)

/-- Log-coordinate version: μ ↔ -μ has unique fixed point μ = 0,
    corresponding to log|B| = 0, i.e. |B| = 1.  (For our canonical
    B = 1+i with |B| = √2, this picks out σ = log₂(√2) = 1/2 in s-coords.) -/
theorem log_reflection_fixed_iff (μ : ℝ) : -μ = μ ↔ μ = 0 := by
  constructor
  · intro h; linarith
  · intro h; rw [h]; ring

/-! ### The framework-level statement

If |B(s)|·|C(s)| = 1 must hold *at the observation point* (axiom 2),
and |B(s)| = |B(1-s)| (the s-plane statement of r ↔ 1/r), then
combining the two forces the observation point onto the fixed axis
of s ↔ 1-s. Off that axis, the two conditions name distinct points
(s and 1-s) with no common location — contradiction.

We package this as: any σ at which both forced symmetries agree
must satisfy σ = 1/2. -/

/-- If σ satisfies both the magnitude condition (encoded as σ being
    a fixed point of reflect) and the framework demands axiom-2 hold
    at σ itself (not at its mirror), then σ = 1/2. -/
theorem critical_line_forced (σ : ℝ)
    (axiom2_holds_at_self : reflect σ = σ) :
    σ = 1/2 :=
  (reflect_fixed_iff σ).mp axiom2_holds_at_self

/-- The contrapositive: σ ≠ 1/2 contradicts axiom 2 holding at σ. -/
theorem off_critical_line_contradiction (σ : ℝ) (h : σ ≠ 1/2) :
    reflect σ ≠ σ := off_critical_line_splits σ h

/-! ## §9.  Summary theorem

Bundle the chain: from a Factorization satisfying the four axioms +
the canonical-diagonal premise, we recover μ_canonical, B_canonical,
C_canonical, the magnitude balance, and σ = 1/2. -/

/-- The canonical observation packages with the unit-modulus axiom. -/
noncomputable def canonical_observation : Observation where
  μ        := μ_canonical
  re_neg   := by unfold μ_canonical; simp; positivity
  im_pos   := by unfold μ_canonical; simp; positivity
  unit_mod := μ_canonical_abs

/-- The canonical factorization. -/
noncomputable def canonical_factorization :
    Factorization canonical_observation where
  B        := B_canonical
  C        := C_canonical
  product  := B_mul_C_eq_μ
  arg_add  := by
    have hθ : (Real.pi / 4 : ℝ) ∈ Set.Ioc (-Real.pi) Real.pi := by
      constructor
      · nlinarith [Real.pi_pos]
      · nlinarith [Real.pi_pos]
    have hBshape :
        B_canonical =
          (Real.cos (Real.pi / 4) + Real.sin (Real.pi / 4) * Complex.I) * Real.sqrt 2 := by
      ext <;> simp [B_canonical, Real.cos_pi_div_four, Real.sin_pi_div_four]
    have hCshape : C_canonical = Complex.I * (1 / Real.sqrt 2) := by
      ext <;> simp [C_canonical]
    rw [hBshape, Complex.arg_mul_real (by positivity)]
    rw [Complex.arg_cos_add_sin_mul_I hθ]
    rw [hCshape, Complex.arg_mul_real (by positivity), Complex.arg_I]
    rw [μ_canonical_arg]
    ring
  B_ne     := by
    intro h; have := congrArg Complex.re h; simp [B_canonical] at this
  C_ne     := by
    intro h; have := congrArg Complex.im h
    simp [C_canonical] at this
    have : Real.sqrt 2 = 0 := by
      have hd : (1:ℝ) / Real.sqrt 2 = 0 := this
      rcases div_eq_zero_iff.mp hd with h1 | h2
      · linarith
      · exact h2
    have h2 : (2:ℝ) = 0 := by
      have := Real.sq_sqrt (by norm_num : (2:ℝ) ≥ 0)
      rw [‹Real.sqrt 2 = 0›] at this; linarith
    norm_num at h2

/-- Final: σ = 1/2 falls out of the canonical factorization. -/
theorem framework_forces_critical_line :
    Real.logb 2 (Complex.abs (canonical_factorization.B)) = 1/2 := by
  show σ_forced = 1/2
  exact σ_forced_eq_half

/-- Canonical phase relation: φ = π/4 + arg C. -/
theorem canonical_phi_eq_pi_div_four_add_argC :
    Complex.arg canonical_observation.μ =
      Real.pi / 4 + Complex.arg canonical_factorization.C := by
  have hμ :
      Complex.arg canonical_observation.μ =
        Complex.arg canonical_factorization.B + Complex.arg canonical_factorization.C := by
    simpa using canonical_factorization.arg_add.symm
  have hB : Complex.arg canonical_factorization.B = Real.pi / 4 := by
    simpa [canonical_factorization] using B_canonical_arg
  calc
    Complex.arg canonical_observation.μ
        = Complex.arg canonical_factorization.B + Complex.arg canonical_factorization.C := hμ
    _ = Real.pi / 4 + Complex.arg canonical_factorization.C := by rw [hB]

/-- Phase lock identity: φ - phase = 0 with phase = π/4 + arg C. -/
theorem canonical_phase_lock :
    let φ := Complex.arg canonical_observation.μ
    let phase := Real.pi / 4 + Complex.arg canonical_factorization.C
    φ - phase = 0 := by
  simp [canonical_phi_eq_pi_div_four_add_argC]

/-- Summary bridge for the canonical source direction.

The normalized canonical source factor is exactly the `π/4` source phase.
Later, the unit-circle crossing-locus lemmas recast this same point as the
`x = y` crossing on the unit circle. -/
theorem canonical_source_direction_eq_sourcePhase_pi_div_four :
    (((B_canonical.re / Real.sqrt 2 : ℝ) : ℂ) + (B_canonical.im / Real.sqrt 2) * Complex.I)
      = sourcePhase (Real.pi / 4) := by
  ext <;> simp [B_canonical, sourcePhase, Complex.exp_mul_I,
    Real.cos_pi_div_four, Real.sin_pi_div_four]
  · field_simp [Real.sqrt_ne_zero'.2 (by positivity : (0 : ℝ) < 2)]
  · field_simp [Real.sqrt_ne_zero'.2 (by positivity : (0 : ℝ) < 2)]

/-! ## §10.  Optional ζ/ξ bridge (axiomatic boundary)

This section keeps the geometric framework above intact while adding a
minimal interface to the classical ξ-function symmetry story.

Important: the final rigidity step "ξ real in the nontrivial strip implies
σ = 1/2" is not proved from the framework alone. We expose it as an axiom.
-/

/-- Completed ξ-function for the Riemann zeta function. -/
noncomputable def xi (s : ℂ) : ℂ :=
  ((1 / 2 : ℂ) * s * (s - 1) * ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2)) *
    riemannZeta s

/-! ### Explicit ξ factors for `logDeriv` bookkeeping

Use `Mathlib.Analysis.Calculus.LogDeriv`: `logDeriv (f * g) = logDeriv f + logDeriv g` away from
zeros, assembling `XiLogDerivFormula` as four named analytic targets. -/

/-- Polynomial prefactor `(1/2)·z·(z-1)`. -/
noncomputable def xiPolyFun (z : ℂ) : ℂ := (1 / 2 : ℂ) * z * (z - 1)

/-- Archimedean factor `π ^ (-z/2)`. -/
noncomputable def xiPiPowFun (z : ℂ) : ℂ := (Real.pi : ℂ) ^ (-z / 2)

/-- Γ-slot factor `Γ(z/2)`. -/
noncomputable def xiGammaFun (z : ℂ) : ℂ := Complex.Gamma (z / 2)

lemma xi_eq_mul_factors (s : ℂ) :
    xi s = xiPolyFun s * xiPiPowFun s * xiGammaFun s * riemannZeta s := by
  simp [xi, xiPolyFun, xiPiPowFun, xiGammaFun, mul_assoc]

/-- Logarithmic derivative target for `xiPolyFun`: classical partial-fraction shape. -/
def XiLogDerivPolyTarget (s : ℂ) : Prop :=
  logDeriv xiPolyFun s = (1 : ℂ) / s + (1 : ℂ) / (s - 1)

/-- Logarithmic derivative target for `π ^ (-z/2)` (constant base `π`). -/
def XiLogDerivPiTarget (s : ℂ) : Prop :=
  logDeriv xiPiPowFun s = -((Real.log Real.pi / 2 : ℝ) : ℂ)

/-- Logarithmic derivative target for `Γ(z/2)` via `digamma` and the chain rule at `z/2`. -/
def XiLogDerivGammaTarget (s : ℂ) : Prop :=
  logDeriv xiGammaFun s = (1 / 2 : ℂ) * digamma (s / 2)

/-- Bundle of the three nontrivial factor identities (ζ is already `logDeriv riemannZeta`). -/
def XiLogDerivFactorTargets (s : ℂ) : Prop :=
  XiLogDerivPolyTarget s ∧ XiLogDerivPiTarget s ∧ XiLogDerivGammaTarget s

/-- Polynomial factor target for `xiPolyFun` away from the two expected poles (`s = 0, 1`). -/
theorem XiLogDerivPolyTarget_of_ne (s : ℂ) (hs0 : s ≠ 0) (hs1 : s ≠ 1) :
    XiLogDerivPolyTarget s := by
  unfold XiLogDerivPolyTarget
  have hmul :
      logDeriv xiPolyFun s
        = logDeriv (fun z : ℂ => (1 / 2 : ℂ) * z) s
            + logDeriv (fun z : ℂ => z - 1) s := by
    have hs0' : ((1 / 2 : ℂ) * s) ≠ 0 := by
      exact mul_ne_zero (by norm_num) hs0
    have hs1' : s - 1 ≠ 0 := sub_ne_zero.mpr hs1
    have hd0 : DifferentiableAt ℂ (fun z : ℂ => (1 / 2 : ℂ) * z) s := by
      exact (differentiableAt_const (1 / 2 : ℂ) s).mul (differentiableAt_id s)
    have hd1 : DifferentiableAt ℂ (fun z : ℂ => z - 1) s := by
      exact (differentiableAt_id s).sub_const (1 : ℂ)
    simpa [xiPolyFun] using logDeriv_mul s hs0' hs1' hd0 hd1
  have hlin :
      logDeriv (fun z : ℂ => (1 / 2 : ℂ) * z) s = (1 : ℂ) / s := by
    calc
      logDeriv (fun z : ℂ => (1 / 2 : ℂ) * z) s
          = logDeriv (fun z : ℂ => z) s := by
              simpa using
                (logDeriv_const_mul (x := s) (f := fun z : ℂ => z) (a := (1 / 2 : ℂ))
                  (by norm_num : (1 / 2 : ℂ) ≠ 0))
      _ = (1 : ℂ) / s := by simpa using (logDeriv_id s)
  have hshift :
      logDeriv (fun z : ℂ => z - 1) s = (1 : ℂ) / (s - 1) := by
    have hcomp :=
      logDeriv_comp (f := fun z : ℂ => z) (g := fun z : ℂ => z - 1) (x := s)
        (hf := by simpa using (differentiableAt_id (s - 1)))
        (hg := by simpa using ((differentiableAt_id s).sub_const (1 : ℂ)))
    simpa [logDeriv_id, deriv_sub_const] using hcomp
  calc
    logDeriv xiPolyFun s
        = logDeriv (fun z : ℂ => (1 / 2 : ℂ) * z) s
            + logDeriv (fun z : ℂ => z - 1) s := hmul
    _ = (1 : ℂ) / s + (1 : ℂ) / (s - 1) := by rw [hlin, hshift]

/-- `π^{-z/2}` factor target: its log-derivative is the constant `-(log π)/2`. -/
theorem XiLogDerivPiTarget_all (s : ℂ) :
    XiLogDerivPiTarget s := by
  unfold XiLogDerivPiTarget xiPiPowFun
  have hderiv :
      deriv (fun z : ℂ => (Real.pi : ℂ) ^ (-z / 2)) s =
        Complex.log (Real.pi : ℂ) * deriv (fun z : ℂ => -z / 2) s
          * ((Real.pi : ℂ) ^ (-s / 2)) := by
    simpa using
      (Complex.deriv_const_cpow
        (f := fun z : ℂ => -z / 2)
        (x := s)
        (c := (Real.pi : ℂ))
        (((differentiableAt_id s).neg.div_const (2 : ℂ))))
  have hπnz : ((Real.pi : ℂ) ^ (-s / 2)) ≠ 0 := by
    exact Complex.cpow_ne_zero (by exact_mod_cast Real.pi_ne_zero) _
  have hlog :
      Complex.log (Real.pi : ℂ) = ((Real.log Real.pi : ℝ) : ℂ) := by
    simpa using (Complex.ofReal_log (x := Real.pi) (by positivity : 0 ≤ Real.pi))
  rw [logDeriv_apply, hderiv, mul_assoc, mul_div_assoc, div_self hπnz, mul_one]
  rw [hlog]
  have hlin : deriv (fun z : ℂ => -z / 2) s = (-(1 / 2 : ℂ)) := by
    simp [div_eq_mul_inv, mul_assoc]
  rw [hlin]
  ring

/-- `Γ(z/2)` factor target via composition and `Complex.digamma = logDeriv Γ`. -/
theorem XiLogDerivGammaTarget_of_no_pole (s : ℂ)
    (hΓ : ∀ m : ℕ, s / 2 ≠ -m) :
    XiLogDerivGammaTarget s := by
  unfold XiLogDerivGammaTarget xiGammaFun
  have hcomp :=
    logDeriv_comp
      (f := Complex.Gamma)
      (g := fun z : ℂ => z / 2)
      (x := s)
      (hf := Complex.differentiableAt_Gamma (s / 2) hΓ)
      (hg := differentiableAt_id.div_const (2 : ℂ))
  calc
    logDeriv (fun z : ℂ => Complex.Gamma (z / 2)) s
        = logDeriv Complex.Gamma (s / 2) * deriv (fun z : ℂ => z / 2) s := hcomp
    _ = (1 / 2 : ℂ) * digamma (s / 2) := by
        simp [Complex.digamma_def, mul_comm, mul_left_comm, mul_assoc]

/-- Concrete bundle constructor for the three explicit ξ-factor targets. -/
theorem XiLogDerivFactorTargets_of_domain (s : ℂ)
    (hs0 : s ≠ 0) (hs1 : s ≠ 1)
    (hΓ : ∀ m : ℕ, s / 2 ≠ -m) :
    XiLogDerivFactorTargets s := by
  refine ⟨XiLogDerivPolyTarget_of_ne s hs0 hs1, ?_, ?_⟩
  · exact XiLogDerivPiTarget_all s
  · exact XiLogDerivGammaTarget_of_no_pole s hΓ

lemma logDeriv_riemannZeta_eq (s : ℂ) :
    logDeriv riemannZeta s = deriv riemannZeta s / riemannZeta s :=
  rfl

/-- Pointwise assembly of `deriv xi / xi` from factor log-derivatives (`Mathlib` `logDeriv_mul`). -/
theorem xi_logDeriv_eq_of_factor_targets (s : ℂ)
    (_hξ : xi s ≠ 0)
    (hp : xiPolyFun s ≠ 0)
    (hπ : xiPiPowFun s ≠ 0)
    (hΓ : xiGammaFun s ≠ 0)
    (hζ : riemannZeta s ≠ 0)
    (hdP : DifferentiableAt ℂ xiPolyFun s)
    (hdπ : DifferentiableAt ℂ xiPiPowFun s)
    (hdΓ : DifferentiableAt ℂ xiGammaFun s)
    (hdζ : DifferentiableAt ℂ riemannZeta s)
    (hT : XiLogDerivFactorTargets s) :
    deriv xi s / xi s =
      (1 : ℂ) / s + (1 : ℂ) / (s - 1)
        - ((Real.log Real.pi / 2 : ℝ) : ℂ)
        + (1 / 2 : ℂ) * digamma (s / 2)
        + deriv riemannZeta s / riemannZeta s := by
  rcases hT with ⟨hPoly, hPi, hGam⟩
  have hx :
      xi = fun z : ℂ =>
        xiPolyFun z * xiPiPowFun z * xiGammaFun z * riemannZeta z := by
    funext z
    simpa using xi_eq_mul_factors z
  have h₃ :
      logDeriv (fun z => xiPolyFun z * xiPiPowFun z * xiGammaFun z) s =
        logDeriv xiPolyFun s + logDeriv xiPiPowFun s + logDeriv xiGammaFun s := by
    have h₁₂ :
        logDeriv (fun z => xiPolyFun z * xiPiPowFun z) s =
          logDeriv xiPolyFun s + logDeriv xiPiPowFun s :=
      logDeriv_mul s hp hπ hdP hdπ
    have h₁₂Γ :
        logDeriv (fun z => xiPolyFun z * xiPiPowFun z * xiGammaFun z) s =
          logDeriv (fun z => xiPolyFun z * xiPiPowFun z) s + logDeriv xiGammaFun s :=
      logDeriv_mul s (mul_ne_zero hp hπ) hΓ (hdP.mul hdπ) hdΓ
    simpa [h₁₂] using h₁₂Γ
  have h₄ :
      logDeriv xi s =
        logDeriv xiPolyFun s + logDeriv xiPiPowFun s + logDeriv xiGammaFun s +
          logDeriv riemannZeta s := by
    have houter :=
      logDeriv_mul s (mul_ne_zero (mul_ne_zero hp hπ) hΓ) hζ ((hdP.mul hdπ).mul hdΓ) hdζ
    simpa [hx, h₃] using houter
  simp only [← logDeriv_apply, h₄, hPoly, hPi, hGam, logDeriv_riemannZeta_eq,
    sub_eq_add_neg, add_assoc, add_left_comm, add_comm]
  ring_nf

/-- Functional-equation transfer factor χ(s) = ζ(s) / ζ(1-s). -/
noncomputable def chi (s : ℂ) : ℂ :=
  riemannZeta s / riemannZeta (1 - s)

/-- Derived special value: ζ(0) = -1/2. -/
theorem zeta_zero : riemannZeta 0 = (-(1 / 2 : ℂ)) := by
  simpa using riemannZeta_zero

/-- χ transfers ζ(1-s) to ζ(s) whenever ζ(1-s) ≠ 0. -/
lemma chi_mul_reflected (s : ℂ) (h : riemannZeta (1 - s) ≠ 0) :
    chi s * riemannZeta (1 - s) = riemannZeta s := by
  unfold chi
  field_simp [h]

/-- Radius transfer: |ζ(s)| = |χ(s)|·|ζ(1-s)| whenever ζ(1-s) ≠ 0. -/
lemma zeta_modulus_transfer (s : ℂ) (h : riemannZeta (1 - s) ≠ 0) :
    ‖riemannZeta s‖ = ‖chi s‖ * ‖riemannZeta (1 - s)‖ := by
  calc
    ‖riemannZeta s‖ = ‖chi s * riemannZeta (1 - s)‖ := by
      simpa [chi_mul_reflected s h]
    _ = ‖chi s‖ * ‖riemannZeta (1 - s)‖ := by
      simpa using norm_mul (chi s) (riemannZeta (1 - s))

/-- Phase transfer in angle form: Arg ζ(s) = Arg χ(s) + Arg ζ(1-s). -/
lemma zeta_phase_transfer_angle (s : ℂ)
    (hs : riemannZeta s ≠ 0)
    (h1s : riemannZeta (1 - s) ≠ 0) :
    (Complex.arg (riemannZeta s) : Real.Angle)
      = Complex.arg (chi s) + Complex.arg (riemannZeta (1 - s)) := by
  have hchi : chi s ≠ 0 := by
    intro h0
    have hz : riemannZeta s = 0 := by
      have hm := chi_mul_reflected s h1s
      rw [h0, zero_mul] at hm
      exact hm
    exact hs hz
  calc
    (Complex.arg (riemannZeta s) : Real.Angle)
        = (Complex.arg (chi s * riemannZeta (1 - s)) : Real.Angle) := by
          simpa [chi_mul_reflected s h1s]
    _ = Complex.arg (chi s) + Complex.arg (riemannZeta (1 - s)) := by
          simpa using Complex.arg_mul_coe_angle (x := chi s) (y := riemannZeta (1 - s)) hchi h1s

/-! ### Bridge coordinate `bridgeF` — “`F(s,t) = t + 𝕚·s`”

**Parameters:** `s : ℂ` is the analytic variable (traditionally `s = σ + 𝕚τ` with `σ = re s`, `τ = im s`),
and `t : ℝ` is a real auxiliary (time / longitudinal / phase-like coordinate in the notes).

**Definition:** `bridgeF s t = (t : ℂ) + 𝕚 * s`.

Use the unconditional ASCII alias **`Fst s t`** (Unicode twin: **`Fₛₜ s t`**), both definitionally
identical to **`bridgeF`**.

**Splitting:** `bridgeF_re` / `bridgeF_im` unfold to (equivalently `Fₛₜ_re` / `Fₛₜ_im`)
`re (bridgeF s t) = t − im s`, **`im (bridgeF s t) = re s`** — so the **target imaginary part** reads
the strip coordinate **`σ = re s`** (not `τ = im s`). Hence the **critical line** `σ = 1/2` is exactly
`{bridgeF s t | im (bridgeF s t) = 1/2}`, with **`re (bridgeF s t) = t − τ`** as the free longitudinal
direction at fixed `s`.

**Specialization on the vertical line** `s = 1/2 + τ·𝕚` (this file’s `(1 / 2 : ℂ) + τ * 𝕚`): one recovers the
straight-line point `(t − τ) + 𝕚·(1/2)`.

**Toroidal picture** (notebook-level): slicing to `σ = re s = 1/2` pins `Im` of the bridge coordinate
while `Re` oscillates linearly with `t` at fixed `τ`, giving the **`S¹` / torus bookkeeping** viewpoint
referenced elsewhere in this file (`unit_circle_crossing_*`, lattice bridges). Formal torus parametrizations
carry their own hypotheses; keep this block as reusable coordinate calculus.
-/

/-- Bridge map `F(s,t) = t + 𝕚·s` from `(s : ℂ, t : ℝ)` into ℂ. -/
noncomputable def bridgeF (s : ℂ) (t : ℝ) : ℂ := (t : ℂ) + Complex.I * s

theorem bridgeF_re (s : ℂ) (t : ℝ) : (bridgeF s t).re = t - s.im := by
  simp [bridgeF, Complex.add_re, Complex.ofReal_re, Complex.mul_re, Complex.mul_im, Complex.I_re,
    Complex.I_im]

@[simp]
theorem bridgeF_im (s : ℂ) (t : ℝ) : (bridgeF s t).im = s.re := by
  simp [bridgeF, Complex.add_im, Complex.ofReal_im, Complex.mul_re, Complex.mul_im, Complex.I_re,
    Complex.I_im]

theorem bridgeF_im_eq_half_iff_re_s (s : ℂ) (t : ℝ) :
    (bridgeF s t).im = 1 / 2 ↔ s.re = 1 / 2 := by
  simp_rw [bridgeF_im]

/-- Matrix part of `s ↦ i*s` on real coordinates `(σ, τ) = (Re s, Im s)`.
This is the quarter-turn matrix action `[[0, -1], [1, 0]] · (σ, τ) = (-τ, σ)`. -/
def bridgeF_matrix_part (σ τ : ℝ) : ℝ × ℝ :=
  (-τ, σ)

/-- Quarter-turn operator on real coordinate pairs. -/
def rotate90_pair (x y : ℝ) : ℝ × ℝ :=
  bridgeF_matrix_part x y

/-- One quarter-turn sends `(x,y)` to `(-y,x)`. -/
theorem rotate90_pair_apply (x y : ℝ) :
    rotate90_pair x y = (-y, x) := by
  rfl

/-- Two quarter-turns give central sign flip `(x,y) ↦ (-x,-y)`. -/
theorem rotate90_pair_twice (x y : ℝ) :
    rotate90_pair (rotate90_pair x y).1 (rotate90_pair x y).2 = (-x, -y) := by
  simp [rotate90_pair, bridgeF_matrix_part]

/-- Affine-coordinate form of `F(s,t)=t+i*s`:
apply the matrix part to `(Re s, Im s)` and translate by `(t,0)`. -/
theorem bridgeF_as_matrix_affine (s : ℂ) (t : ℝ) :
    ((bridgeF s t).re, (bridgeF s t).im)
      = (t + (bridgeF_matrix_part s.re s.im).1, (bridgeF_matrix_part s.re s.im).2) := by
  simp [bridgeF_matrix_part, bridgeF_re, bridgeF_im]

/-- Equivalent explicit coordinate form of the matrix/affine viewpoint. -/
theorem bridgeF_as_matrix_affine_explicit (s : ℂ) (t : ℝ) :
    ((bridgeF s t).re, (bridgeF s t).im) = (t - s.im, s.re) := by
  simpa [bridgeF_matrix_part] using bridgeF_as_matrix_affine s t

/-- Explicit swap feature of the `90°` matrix part:
the imaginary coordinate of `F(s,t)` is exactly the original real coordinate of `s`. -/
theorem bridgeF_im_is_original_re (s : ℂ) (t : ℝ) :
    (bridgeF s t).im = s.re := by
  simpa using bridgeF_im s t

/-- Matrix-part restatement: the `F` linear channel is exactly one quarter-turn
on `(Re s, Im s)` before the `t`-translation. -/
theorem bridgeF_matrix_part_is_rotate90 (s : ℂ) :
    bridgeF_matrix_part s.re s.im = rotate90_pair s.re s.im := by
  rfl

/-- On `s = 1/2 + τ·𝕚`, bridge coordinates are `(t − τ) + 𝕚·(1/2)` — fixed imaginary part `1/2`. -/
theorem bridgeF_vertical_cline (τ t : ℝ) :
    bridgeF ((1 / 2 : ℂ) + τ * Complex.I) t = (t - τ : ℝ) + (1 / 2 : ℂ) * Complex.I := by
  simp only [bridgeF]
  refine Complex.ext ?_ ?_
  · simp [Complex.add_re, Complex.mul_re, Complex.mul_im, Complex.I_re, Complex.I_im]
    ring
  · simp [Complex.add_im, Complex.mul_re, Complex.mul_im, Complex.I_re, Complex.I_im]
    ring

/-- Unconditional prose name for **`bridgeF`**: handwritten **`F(s,t) = t + 𝕚·s`**. -/
noncomputable abbrev Fₛₜ (s : ℂ) (t : ℝ) : ℂ := bridgeF s t

theorem Fₛₜ_re (s : ℂ) (t : ℝ) : (Fₛₜ s t).re = t - s.im :=
  bridgeF_re s t

@[simp]
theorem Fₛₜ_im (s : ℂ) (t : ℝ) : (Fₛₜ s t).im = s.re :=
  bridgeF_im s t

theorem Fₛₜ_im_eq_half_iff_re_s (s : ℂ) (t : ℝ) :
    (Fₛₜ s t).im = 1 / 2 ↔ s.re = 1 / 2 :=
  bridgeF_im_eq_half_iff_re_s s t

theorem Fₛₜ_vertical_cline (τ t : ℝ) :
    Fₛₜ ((1 / 2 : ℂ) + τ * Complex.I) t = (t - τ : ℝ) + (1 / 2 : ℂ) * Complex.I :=
  bridgeF_vertical_cline τ t

/-- ASCII twin for `Fₛₜ`; same map `F(s,t) = t + 𝕚·s`. -/
noncomputable abbrev Fst (s : ℂ) (t : ℝ) : ℂ := Fₛₜ s t

theorem Fst_re (s : ℂ) (t : ℝ) : (Fst s t).re = t - s.im :=
  Fₛₜ_re s t

@[simp]
theorem Fst_im (s : ℂ) (t : ℝ) : (Fst s t).im = s.re :=
  Fₛₜ_im s t

theorem Fst_im_eq_half_iff_re_s (s : ℂ) (t : ℝ) :
    (Fst s t).im = 1 / 2 ↔ s.re = 1 / 2 :=
  Fₛₜ_im_eq_half_iff_re_s s t

theorem Fst_vertical_cline (τ t : ℝ) :
    Fst ((1 / 2 : ℂ) + τ * Complex.I) t = (t - τ : ℝ) + (1 / 2 : ℂ) * Complex.I :=
  Fₛₜ_vertical_cline τ t

/-! ### Log-derivative scaffold (formal-ready boundary)

These declarations package the `xi'/xi` and symmetric FE log-derivative identities
under explicit names so they can be refined into full proofs incrementally.
-/

/-- Digamma shorthand in this file: ψ(z) = Γ'(z) / Γ(z). -/
noncomputable def digamma (z : ℂ) : ℂ := deriv Complex.Gamma z / Complex.Gamma z

/-! **Vertical critical-line parametrization (discharge helper for plan A).**

For **`F(s,t) = t + 𝕚·s`**, use **`Fst s t`** (Unicode twin **`Fₛₜ s t`**, both equal to **`bridgeF s t`**);
fixing **`re s = 1/2`** pins **`im (Fst s t)`** (`Fst_im`, `Fst_vertical_cline`).

The phase-velocity bridge `phase_velocity_on_critical_line_of_xi_logderiv_formula` assumes
`hlineDeriv`. For the concrete `xi` in this file, `differentiableAt_xi_half_add_mulI` proves
`ℂ`-differentiability at every `1/2 + t·i`, hence `hlineDeriv_vertical_line` discharges the
entire `hlineDeriv` hypothesis family without extra input. The remaining analytic work is then
`XiLogDerivFormula` / `hxi_logderiv_formula` and the slit-plane / zero discussion in that
theorem's docstring. -/

/-! **Critical-line basepoints for ξ differentiability.**

On `s = 1/2 + t·i`, we stay away from `s = 0`, `s = 1`, and the `Γ(s/2)` pole locus `s/2 ∈ ℕ₋₀`. -/

lemma cline_ne_one (t : ℝ) : (1 / 2 : ℂ) + t * Complex.I ≠ (1 : ℂ) := by
  intro h
  have := congrArg Complex.re h
  simp at this

lemma cline_ne_zero (t : ℝ) : (1 / 2 : ℂ) + t * Complex.I ≠ 0 := by
  intro h
  have := congrArg Complex.re h
  simp at this

lemma cline_div_two_ne_neg_nat (t : ℝ) (m : ℕ) : ((1 / 2 : ℂ) + t * Complex.I) / 2 ≠ -(m : ℂ) := by
  intro h
  have hre := congrArg Complex.re h
  have hσ : Complex.re ((1 / 2 : ℂ) + t * Complex.I) = (1 / 2 : ℝ) := by simp
  have hτ : Complex.im ((1 / 2 : ℂ) + t * Complex.I) = t := by simp
  have hreL : Complex.re (((1 / 2 : ℂ) + t * Complex.I) / 2) = (1 / 4 : ℝ) := by
    rw [Complex.div_re, hσ, hτ]
    simp [Complex.ofReal_natCast]
    ring_nf
    norm_num
  have hreR : Complex.re (-(m : ℂ)) = -(m : ℝ) := by simp
  have hm : (0 : ℝ) ≤ (m : ℝ) := by exact_mod_cast Nat.zero_le m
  rw [hreL, hreR] at hre
  linarith

/-- The explicit ξ prefactor is `ℂ`-differentiable at every `s = 1/2 + t·i`. -/
theorem differentiableAt_xi_half_add_mulI (t : ℝ) :
    DifferentiableAt ℂ xi ((1 / 2 : ℂ) + t * Complex.I) := by
  set s : ℂ := (1 / 2 : ℂ) + t * Complex.I with hs
  have hs1 : s ≠ 1 := by simpa [hs] using cline_ne_one t
  have hΓ : ∀ m : ℕ, s / 2 ≠ -m := fun m => by simpa [hs] using cline_div_two_ne_neg_nat t m
  have hπ : (Real.pi : ℂ) ≠ 0 := by exact_mod_cast Real.pi_ne_zero
  -- polynomial `(1/2) * z * (z - 1)` in `z`
  have hpoly : DifferentiableAt ℂ (fun z : ℂ => ((1 / 2 : ℂ) * z) * (z - 1)) s :=
    ((differentiableAt_const (1 / 2 : ℂ) s).mul differentiableAt_id).mul
      (differentiableAt_id.sub_const (1 : ℂ))
  -- archimedean factor `π ^ (-z/2)` via `cpow` and holomorphicity of `exp ∘ (log π · (-·/2))`
  have hpow :
      DifferentiableAt ℂ (fun z : ℂ => (Real.pi : ℂ) ^ (-z / 2)) s := by
    have hpow_eq :
        (fun z : ℂ => (Real.pi : ℂ) ^ (-z / 2))
          = fun z : ℂ => Complex.exp (Complex.log (Real.pi : ℂ) * (-z / 2)) := by
      funext z
      rw [Complex.cpow_def_of_ne_zero hπ]
    rw [hpow_eq]
    refine DifferentiableAt.cexp ?_
    refine DifferentiableAt.mul (differentiableAt_const _ _) ?_
    exact (DifferentiableAt.neg differentiableAt_id).div_const (2 : ℂ)
  have hGam : DifferentiableAt ℂ (fun z : ℂ => Complex.Gamma (z / 2)) s :=
    (Complex.differentiableAt_Gamma (s / 2) hΓ).comp (differentiableAt_id.div_const (2 : ℂ))
  have hζ : DifferentiableAt ℂ riemannZeta s := differentiableAt_riemannZeta hs1
  unfold xi
  simpa [mul_assoc] using (((hpoly.mul hpow).mul hGam).mul hζ)

/-- Every vertical critical-line point is a `ℂ`-differentiability point for `xi`. -/
theorem forall_differentiableAt_xi_vertical :
    ∀ t : ℝ, DifferentiableAt ℂ xi ((1 / 2 : ℂ) + t * Complex.I) :=
  differentiableAt_xi_half_add_mulI

/-- Full `hlineDeriv` family on the vertical line, with no extra hypothesis beyond `t : ℝ`. -/
theorem hlineDeriv_vertical_line (t : ℝ) :
    HasDerivAt (fun u : ℝ => xi ((1 / 2 : ℂ) + u * Complex.I))
      (Complex.I * deriv xi ((1 / 2 : ℂ) + t * Complex.I)) t :=
  hasDerivAt_xi_of_half_add_mulI (differentiableAt_xi_half_add_mulI t)

/-- Affine map `u ↦ 1/2 + u·i` has derivative `I` at every real basepoint. -/
theorem hasDerivAt_affine_half_add_mulI (t : ℝ) :
    HasDerivAt (fun u : ℝ => (1 / 2 : ℂ) + u * Complex.I) Complex.I t :=
  (hasDerivAt_const t (1 / 2 : ℂ)).add (hasDerivAt_mul_const Complex.I)

/-- Chain rule along the vertical line: if `xi` is `ℂ`-differentiable at `1/2 + t·i`, then
`u ↦ xi (1/2 + u·i)` is `ℝ`-differentiable at `t` with derivative `I * deriv xi (1/2 + t·i)`. -/
theorem hasDerivAt_xi_of_half_add_mulI {t : ℝ}
    (hd : DifferentiableAt ℂ xi ((1 / 2 : ℂ) + t * Complex.I)) :
    HasDerivAt (fun u : ℝ => xi ((1 / 2 : ℂ) + u * Complex.I))
      (Complex.I * deriv xi ((1 / 2 : ℂ) + t * Complex.I)) t := by
  set s : ℂ := (1 / 2 : ℂ) + t * Complex.I with hs
  let γ : ℝ → ℂ := fun u => (1 / 2 : ℂ) + u * Complex.I
  have hg : HasDerivAt xi (deriv xi s) s := by
    simpa [hs] using hd.hasDerivAt
  have hγ : HasDerivAt γ Complex.I t := by
    simpa [γ] using hasDerivAt_affine_half_add_mulI t
  simpa [γ, Function.comp_apply, smul_eq_mul, mul_comm, hs] using HasDerivAt.scomp hg hγ

/-- Pointwise packaging: a uniform `ℂ`-differentiability hypothesis on the vertical line gives the
`hlineDeriv` family. For the concrete `xi` here, prefer `hlineDeriv_vertical_line` (no hypothesis). -/
theorem hlineDeriv_of_forall_differentiableAt_xi
    (h : ∀ t : ℝ, DifferentiableAt ℂ xi ((1 / 2 : ℂ) + t * Complex.I)) :
    ∀ t : ℝ,
      HasDerivAt (fun u : ℝ => xi ((1 / 2 : ℂ) + u * Complex.I))
        (Complex.I * deriv xi ((1 / 2 : ℂ) + t * Complex.I)) t :=
  fun t => hasDerivAt_xi_of_half_add_mulI (h t)

/-- Named proposition: global ξ log-derivative scaffold (the `hxi_logderiv_formula` input). -/
def XiLogDerivFormula : Prop :=
  ∀ s : ℂ,
    deriv xi s / xi s
      = (1 : ℂ) / s
        + (1 : ℂ) / (s - 1)
        - ((Real.log Real.pi) / 2 : ℂ)
        + (1 / 2 : ℂ) * digamma (s / 2)
        + deriv riemannZeta s / riemannZeta s

/-- Global `XiLogDerivFormula` assembled from pointwise nonvanishing, differentiability,
and the three explicit factor targets (`poly`, `π^{-s/2}`, `Γ(s/2)`). -/
theorem XiLogDerivFormula_of_factor_targets
    (hξ : ∀ s : ℂ, xi s ≠ 0)
    (hP : ∀ s : ℂ, xiPolyFun s ≠ 0)
    (hπ : ∀ s : ℂ, xiPiPowFun s ≠ 0)
    (hΓ : ∀ s : ℂ, xiGammaFun s ≠ 0)
    (hζ : ∀ s : ℂ, riemannZeta s ≠ 0)
    (hdP : ∀ s : ℂ, DifferentiableAt ℂ xiPolyFun s)
    (hdπ : ∀ s : ℂ, DifferentiableAt ℂ xiPiPowFun s)
    (hdΓ : ∀ s : ℂ, DifferentiableAt ℂ xiGammaFun s)
    (hdζ : ∀ s : ℂ, DifferentiableAt ℂ riemannZeta s)
    (hT : ∀ s : ℂ, XiLogDerivFactorTargets s) :
    XiLogDerivFormula := by
  intro s
  exact xi_logDeriv_eq_of_factor_targets s
    (hξ s) (hP s) (hπ s) (hΓ s) (hζ s)
    (hdP s) (hdπ s) (hdΓ s) (hdζ s) (hT s)

/-- Item-2 reduction prototype:
the symmetric digamma/zeta sum follows from item 1 once one has
the reflected ξ-log-derivative relation `Lξ(1-s) = -Lξ(s)`. -/
theorem xi_logderiv_symmetry_sum_of_xi_logderiv_formula
    (hxi_logderiv_formula : ∀ s : ℂ,
      deriv xi s / xi s
        = (1 : ℂ) / s
        + (1 : ℂ) / (s - 1)
        - ((Real.log Real.pi) / 2 : ℂ)
        + (1 / 2 : ℂ) * digamma (s / 2)
        + deriv riemannZeta s / riemannZeta s)
    (hxi_reflect_logderiv : ∀ s : ℂ,
      deriv xi (1 - s) / xi (1 - s) = -(deriv xi s / xi s)) :
    ∀ s : ℂ,
      (1 / 2 : ℂ) * (digamma (s / 2) + digamma ((1 - s) / 2))
        = (Real.log Real.pi : ℂ)
        - (deriv riemannZeta s / riemannZeta s
          + deriv riemannZeta (1 - s) / riemannZeta (1 - s)) := by
  intro s
  have hs :
      deriv xi s / xi s
        = (1 : ℂ) / s
          + (1 : ℂ) / (s - 1)
          - ((Real.log Real.pi) / 2 : ℂ)
          + (1 / 2 : ℂ) * digamma (s / 2)
          + deriv riemannZeta s / riemannZeta s :=
            hxi_logderiv_formula s
  have h1s :
      deriv xi (1 - s) / xi (1 - s)
        = (1 : ℂ) / (1 - s)
          + (1 : ℂ) / ((1 - s) - 1)
          - ((Real.log Real.pi) / 2 : ℂ)
          + (1 / 2 : ℂ) * digamma ((1 - s) / 2)
          + deriv riemannZeta (1 - s) / riemannZeta (1 - s) :=
            hxi_logderiv_formula (1 - s)
  have h1s' :
      -(deriv xi s / xi s)
        = (1 : ℂ) / (1 - s)
          + (1 : ℂ) / ((1 - s) - 1)
          - ((Real.log Real.pi) / 2 : ℂ)
          + (1 / 2 : ℂ) * digamma ((1 - s) / 2)
          + deriv riemannZeta (1 - s) / riemannZeta (1 - s) := by
    simpa [hxi_reflect_logderiv s] using h1s
  have hadd := congrArg2 (fun a b : ℂ => a + b) hs h1s'
  have hAplusB :
      (1 / 2 : ℂ) * (digamma (s / 2) + digamma ((1 - s) / 2))
        + (deriv riemannZeta s / riemannZeta s
            + deriv riemannZeta (1 - s) / riemannZeta (1 - s))
      = (Real.log Real.pi : ℂ) := by
    have h0 :
        (0 : ℂ)
          = -((Real.log Real.pi) : ℂ)
            + ((1 / 2 : ℂ) * (digamma (s / 2) + digamma ((1 - s) / 2)))
            + (deriv riemannZeta s / riemannZeta s
                + deriv riemannZeta (1 - s) / riemannZeta (1 - s)) := by
      simpa [sub_eq_add_neg, add_assoc, add_left_comm, add_comm, div_eq_mul_inv] using hadd
    have h := congrArg (fun z : ℂ => z + (Real.log Real.pi : ℂ)) h0
    have h' :
        (Real.log Real.pi : ℂ)
          = (1 / 2 : ℂ) * (digamma (s / 2) + digamma ((1 - s) / 2))
              + (deriv riemannZeta s / riemannZeta s
                  + deriv riemannZeta (1 - s) / riemannZeta (1 - s)) := by
      simpa [sub_eq_add_neg, add_assoc, add_left_comm, add_comm] using h
    exact h'.symm
  exact (eq_sub_iff_add_eq).2 hAplusB

/-- Core log-derivative bracket evaluated on the critical line. -/
noncomputable def xi_logderiv_core_on_line (t : ℝ) : ℂ :=
  (1 : ℂ) / ((1 / 2 : ℂ) + t * Complex.I)
    + (1 : ℂ) / (((1 / 2 : ℂ) + t * Complex.I) - 1)
    - ((Real.log Real.pi) / 2 : ℂ)
    + (1 / 2 : ℂ) * digamma (((1 / 2 : ℂ) + t * Complex.I) / 2)
    + deriv riemannZeta ((1 / 2 : ℂ) + t * Complex.I)
      / riemannZeta ((1 / 2 : ℂ) + t * Complex.I)

/-- Additive decomposition view of the ξ log-derivative core on the line. -/
lemma xi_logderiv_core_on_line_additive (t : ℝ) :
    xi_logderiv_core_on_line t
      = (1 : ℂ) / ((1 / 2 : ℂ) + t * Complex.I)
        + (1 : ℂ) / (((1 / 2 : ℂ) + t * Complex.I) - 1)
        - ((Real.log Real.pi) / 2 : ℂ)
        + (1 / 2 : ℂ) * digamma (((1 / 2 : ℂ) + t * Complex.I) / 2)
        + deriv riemannZeta ((1 / 2 : ℂ) + t * Complex.I)
          / riemannZeta ((1 / 2 : ℂ) + t * Complex.I) := by
  rfl

/-- Multiplicative reduction for ξ functional symmetry:
if the Euler/Gamma/ζ factor is symmetric under `s ↦ 1-s`, then ξ is symmetric. -/
lemma xi_functional_equation_of_factor_symmetry
    (hfac : ∀ s : ℂ,
      ((Real.pi : ℂ) ^ (-(1 - s) / 2)) * Complex.Gamma ((1 - s) / 2) * riemannZeta (1 - s)
        = ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s) :
    ∀ s : ℂ, xi s = xi (1 - s) := by
  intro s
  unfold xi
  have hpoly :
      ((1 / 2 : ℂ) * s * (s - 1))
        = ((1 / 2 : ℂ) * (1 - s) * ((1 - s) - 1)) := by
    ring
  calc
    ((1 / 2 : ℂ) * s * (s - 1) * ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2)) *
        riemannZeta s
      = ((1 / 2 : ℂ) * s * (s - 1))
          * (((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s) := by
            ring
    _ = ((1 / 2 : ℂ) * (1 - s) * ((1 - s) - 1))
          * (((Real.pi : ℂ) ^ (-(1 - s) / 2)) * Complex.Gamma ((1 - s) / 2) *
            riemannZeta (1 - s)) := by rw [hpoly, (hfac s).symm]
    _ = ((1 / 2 : ℂ) * (1 - s) * ((1 - s) - 1) * ((Real.pi : ℂ) ^ (-(1 - s) / 2)) *
          Complex.Gamma ((1 - s) / 2)) * riemannZeta (1 - s) := by
            ring

/-- Multiplicative reduction for ξ conjugation symmetry:
if the Euler/Gamma/ζ factor respects conjugation, then ξ does too. -/
lemma xi_conj_of_factor_conj
    (hfac : ∀ s : ℂ,
      conj (((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s)
        = ((Real.pi : ℂ) ^ (-(conj s) / 2)) * Complex.Gamma ((conj s) / 2)
            * riemannZeta (conj s)) :
    ∀ s : ℂ, conj (xi s) = xi (conj s) := by
  intro s
  unfold xi
  set_option maxHeartbeats 400000 in
  calc
    conj
        (((1 / 2 : ℂ) * s * (s - 1) * ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2)) *
          riemannZeta s)
      = conj (((1 / 2 : ℂ) * s * (s - 1))
          * (((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s)) := by
            simp_rw [← mul_assoc]
    _ = (conj ((1 / 2 : ℂ) * s * (s - 1)))
          * conj (((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s) := by
            simp [map_mul]
    _ = ((1 / 2 : ℂ) * (conj s) * (conj s - 1))
          * (((Real.pi : ℂ) ^ (-(conj s) / 2)) * Complex.Gamma ((conj s) / 2)
              * riemannZeta (conj s)) := by
            rw [hfac s]
            simp [map_mul, map_sub]
    _ = ((1 / 2 : ℂ) * (conj s) * (conj s - 1)
          * ((Real.pi : ℂ) ^ (-(conj s) / 2)) * Complex.Gamma ((conj s) / 2))
          * riemannZeta (conj s) := by
            ring

/-- Derived phase-velocity relation from the ξ log-derivative scaffold.

This theorem shows item 3 follows from item 1 once two analytic side conditions
are provided explicitly:
1. chain-rule derivative of `u ↦ xi(1/2 + u i)` along the real line,
2. slit-plane branch admissibility for `log ∘ xi` on that line.

**Discharge plan (A):** prove the three hypotheses in order.
* `hxi_logderiv_formula`: assemble `deriv xi / xi` from the explicit factors in
  `xi` via `logDeriv` algebra (`Mathlib.Analysis.Calculus.LogDeriv`: `logDeriv_mul`,
  `logDeriv_div`, …), `deriv` of `s ↦ π ^ (-s/2)`, `Complex.differentiableAt_Gamma` /
  `Complex.digamma` (matches this file's `digamma` on the differentiable locus), and
  `differentiableAt_riemannZeta` away from `s = 1`.
* `hlineDeriv`: see `hasDerivAt_affine_half_add_mulI`, `hasDerivAt_xi_of_half_add_mulI`, and
  `hlineDeriv_of_forall_differentiableAt_xi` (via `HasDerivAt.scomp` in
  `Mathlib.Analysis.Calculus.Deriv.Comp`).
* `hlineSlit`: **pointwise** avoidance of the slit cut. At nontrivial zeros `xi` vanishes, so
  `Complex.log (xi …)` is not defined there; any global statement needs restriction to
  `xi ≠ 0`, a punctured neighborhood, or a chosen branch—state the discharge accordingly.

For Mathlib alignment: `Complex.digamma` is defined as `logDeriv Complex.Gamma`. -/
theorem phase_velocity_on_critical_line_of_xi_logderiv_formula
    (hxi_logderiv_formula : ∀ s : ℂ,
      deriv xi s / xi s
        = (1 : ℂ) / s
        + (1 : ℂ) / (s - 1)
        - ((Real.log Real.pi) / 2 : ℂ)
        + (1 / 2 : ℂ) * digamma (s / 2)
        + deriv riemannZeta s / riemannZeta s)
    (hlineDeriv : ∀ t : ℝ,
      HasDerivAt (fun u : ℝ => xi ((1 / 2 : ℂ) + u * Complex.I))
        (Complex.I * deriv xi ((1 / 2 : ℂ) + t * Complex.I)) t)
    (hlineSlit : ∀ t : ℝ,
      xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    ∀ t : ℝ,
      deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t
        = Complex.I * xi_logderiv_core_on_line t := by
  intro t
  let s : ℂ := (1 / 2 : ℂ) + t * Complex.I
  have hlogDeriv :
      deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t
        = (Complex.I * deriv xi s) / xi s := by
    have hHas :
        HasDerivAt (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I)))
          ((Complex.I * deriv xi s) / xi s) t := by
      simpa [s] using (HasDerivAt.clog_real (hlineDeriv t) (hlineSlit t))
    exact hHas.deriv
  have hxi : deriv xi s / xi s = xi_logderiv_core_on_line t := by
    simpa [s, xi_logderiv_core_on_line] using hxi_logderiv_formula s
  calc
    deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t
        = (Complex.I * deriv xi s) / xi s := hlogDeriv
    _ = Complex.I * (deriv xi s / xi s) := by
          rw [mul_div_assoc]
    _ = Complex.I * xi_logderiv_core_on_line t := by
          rw [hxi]

/-- Plan A packaged with named hypotheses: `XiLogDerivFormula` + vertical differentiability of
`xi` (discharging `hlineDeriv` via `hlineDeriv_of_forall_differentiableAt_xi`) + slit-plane
admissibility for `Complex.log ∘ xi`. -/
theorem phase_velocity_on_critical_line_of_XiLogDerivFormula
    (hΞ : XiLogDerivFormula)
    (hdiff : ∀ t : ℝ, DifferentiableAt ℂ xi ((1 / 2 : ℂ) + t * Complex.I))
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    ∀ t : ℝ,
      deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t
        = Complex.I * xi_logderiv_core_on_line t :=
  phase_velocity_on_critical_line_of_xi_logderiv_formula hΞ
    (hlineDeriv_of_forall_differentiableAt_xi hdiff) hslit

/-- Plan A with `hlineDeriv` discharged automatically for this file's `xi` (see
`forall_differentiableAt_xi_vertical`). Only `XiLogDerivFormula` and slit-plane admissibility
remain. -/
theorem phase_velocity_on_critical_line_of_XiLogDerivFormula_and_slit
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    ∀ t : ℝ,
      deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t
        = Complex.I * xi_logderiv_core_on_line t :=
  phase_velocity_on_critical_line_of_XiLogDerivFormula hΞ forall_differentiableAt_xi_vertical hslit

/-- Direct bridge from factor-target hypotheses to the critical-line phase-velocity identity.

This removes the need to separately pass `XiLogDerivFormula`; the latter is produced by
`XiLogDerivFormula_of_factor_targets`. -/
theorem phase_velocity_on_critical_line_of_factor_targets_and_slit
    (hξ : ∀ s : ℂ, xi s ≠ 0)
    (hP : ∀ s : ℂ, xiPolyFun s ≠ 0)
    (hπ : ∀ s : ℂ, xiPiPowFun s ≠ 0)
    (hΓ : ∀ s : ℂ, xiGammaFun s ≠ 0)
    (hζ : ∀ s : ℂ, riemannZeta s ≠ 0)
    (hdP : ∀ s : ℂ, DifferentiableAt ℂ xiPolyFun s)
    (hdπ : ∀ s : ℂ, DifferentiableAt ℂ xiPiPowFun s)
    (hdΓ : ∀ s : ℂ, DifferentiableAt ℂ xiGammaFun s)
    (hdζ : ∀ s : ℂ, DifferentiableAt ℂ riemannZeta s)
    (hT : ∀ s : ℂ, XiLogDerivFactorTargets s)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    ∀ t : ℝ,
      deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t
        = Complex.I * xi_logderiv_core_on_line t := by
  have hΞ : XiLogDerivFormula :=
    XiLogDerivFormula_of_factor_targets hξ hP hπ hΓ hζ hdP hdπ hdΓ hdζ hT
  exact phase_velocity_on_critical_line_of_XiLogDerivFormula_and_slit hΞ hslit

/-- Correct real-part split from `d/dt log F = i * core`: `Re = -Im(core)`. -/
lemma phase_velocity_real_split
    (hPhase : ∀ t : ℝ,
      deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t
        = Complex.I * xi_logderiv_core_on_line t)
    (t : ℝ) :
    (deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t).re
      = -(xi_logderiv_core_on_line t).im := by
  rw [hPhase t]
  simp [Complex.mul_re]

/-- Correct imaginary-part split from `d/dt log F = i * core`: `Im = Re(core)`. -/
lemma phase_velocity_imag_split
    (hPhase : ∀ t : ℝ,
      deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t
        = Complex.I * xi_logderiv_core_on_line t)
    (t : ℝ) :
    (deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t).im
      = (xi_logderiv_core_on_line t).re := by
  rw [hPhase t]
  simp [Complex.mul_im]

/-- Trivial-zero line for `ζ`: negative even integers `-2(n+1)` (imaginary part `0`). -/
def onTrivialZeroLine (s : ℂ) : Prop := ∃ n : ℕ, s = -(2 * (n + 1) : ℂ)

/-- On the genuine trivial-zero line (`Im(s)=0`, `Re(s)<0`), the explicit π/Γ/ζ
factor bridge holds by direct evaluation at `s = -2(n+1)`. -/
theorem completedRiemannZeta_factor_bridge_on_trivial_zero_line {s : ℂ}
    (htriv : onTrivialZeroLine s) :
    completedRiemannZeta s =
      ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s := by
  rcases htriv with ⟨n, rfl⟩
  -- `onTrivialZeroLine` points are real (`Im = 0`) and zeta vanishes there.
  simp [riemannZeta_neg_two_mul_nat_add_one, mul_assoc, mul_left_comm, mul_comm]

/-- Separate bridge statement at the isolated exceptional point `s = 0`. -/
theorem completedRiemannZeta_factor_bridge_at_zero :
    completedRiemannZeta (0 : ℂ)
      = ((Real.pi : ℂ) ^ (-(0 : ℂ) / 2)) * Complex.Gamma ((0 : ℂ) / 2) * riemannZeta (0 : ℂ) := by
  simp [completedRiemannZeta, riemannZeta]

/-- Bridge on the full `Γ_ℝ`-zero locus, split into `s=0` and the trivial-zero line. -/
theorem completedRiemannZeta_factor_bridge_on_gammaR_eq_zero {s : ℂ}
    (hs : ∃ n : ℕ, s = -(2 * n : ℂ)) :
    completedRiemannZeta s =
      ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s := by
  rcases hs with ⟨n, rfl⟩
  rcases n with _ | n
  · simpa using completedRiemannZeta_factor_bridge_at_zero
  · have htriv : onTrivialZeroLine (-(2 * (Nat.succ n) : ℂ)) := by
      refine ⟨n, rfl⟩
  simpa using completedRiemannZeta_factor_bridge_on_trivial_zero_line htriv

/-- On the nonvanishing locus of `Gammaℝ`, the explicit π/Gamma/ζ factor is exactly the
completed zeta factor. This is the honest bridge behind the totalized product formula. -/
theorem completedRiemannZeta_factor_bridge_of_gammaR_ne_zero {s : ℂ} (hΓ : Gammaℝ s ≠ 0) :
    ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s
      = completedRiemannZeta s := by
  have hs : s ≠ 0 := by
    intro hs0
    apply hΓ
    rw [hs0, Gammaℝ_eq_zero_iff]
    exact ⟨0, by simp⟩
  calc
    ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s
        = Gammaℝ s * riemannZeta s := by
          simp [Gammaℝ_def, mul_assoc, mul_left_comm, mul_comm]
    _ = completedRiemannZeta s := by
          rw [riemannZeta_def_of_ne_zero hs]
          field_simp [hΓ]

/-- Away from the exceptional lattice, the completed zeta bridge is fully proved. -/
theorem completedRiemannZeta_factor_bridge_of_not_exceptional {s : ℂ}
    (hs : ¬ ∃ n : ℕ, s = -(2 * n : ℂ)) :
    completedRiemannZeta s
      = ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s := by
  have hΓ : Gammaℝ s ≠ 0 := by
    intro h
    apply hs
    rwa [Gammaℝ_eq_zero_iff] at h
  exact (completedRiemannZeta_factor_bridge_of_gammaR_ne_zero hΓ).symm

/-- Real-axis determination of the `Gammaℝ` pole/zero lattice:
if `Gammaℝ s = 0`, then `s` lies on the real axis at a negative-even coordinate. -/
theorem Gammaℝ_zero_real_axis_determines_pole_lattice (s : ℂ)
    (hΓ : Gammaℝ s = 0) :
    ∃ n : ℕ, s.re = -(2 * n : ℝ) ∧ s.im = 0 := by
  rcases (Gammaℝ_eq_zero_iff).1 hΓ with ⟨n, hn⟩
  refine ⟨n, ?_, ?_⟩
  · exact congrArg Complex.re hn
  · exact congrArg Complex.im hn

/-- Coordinate form: the `Gammaℝ` pole/zero lattice is exactly the real-axis
negative-even lattice. -/
theorem Gammaℝ_eq_zero_iff_real_axis_even_lattice (s : ℂ) :
    Gammaℝ s = 0 ↔ ∃ n : ℕ, s.re = -(2 * n : ℝ) ∧ s.im = 0 := by
  constructor
  · exact Gammaℝ_zero_real_axis_determines_pole_lattice s
  · intro h
    rcases h with ⟨n, hre, him⟩
    have hs : s = -(2 * n : ℂ) := by
      apply Complex.ext <;> simp [hre, him]
    exact (Gammaℝ_eq_zero_iff).2 ⟨n, hs⟩

/-- Global completed-zeta bridge: off the `Γ_ℝ`-zero lattice by `completedRiemannZeta_factor_bridge_of_not_exceptional`,
on the lattice by the explicit split boundary (`s=0` + trivial-zero line). -/
theorem completedRiemannZeta_factor_bridge (s : ℂ) :
  completedRiemannZeta s
    = ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s := by
  by_cases hs : ∃ n : ℕ, s = -(2 * n : ℂ)
  · exact completedRiemannZeta_factor_bridge_on_gammaR_eq_zero hs
  · exact completedRiemannZeta_factor_bridge_of_not_exceptional hs

/-- The exceptional lattice is disjoint from the open critical strip. -/
lemma not_exceptional_of_nontrivial_strip (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1) :
    ¬ ∃ n : ℕ, s = -(2 * n : ℂ) := by
  intro hs
  rcases hs with ⟨n, hn⟩
  have hre : s.re = -(2 * n : ℝ) := by
    rw [hn]
    simp
  have hnonpos : s.re ≤ 0 := by
    have hnn : 0 ≤ (2 * n : ℝ) := by positivity
    linarith
  exact (not_le_of_gt h_nontrivial.1) hnonpos

/-- The open critical strip is invariant under `s ↦ 1 - s`. -/
lemma nontrivial_strip_one_sub (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1) :
    0 < (1 - s).re ∧ (1 - s).re < 1 := by
  constructor <;> simp <;> linarith [h_nontrivial.1, h_nontrivial.2]

/-- Derived one-sub symmetry at the explicit π/Gamma/ζ factor level on the open critical strip. -/
theorem riemannZeta_factor_one_sub_symmetry_of_nontrivial_strip (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1) :
  ((Real.pi : ℂ) ^ (-(1 - s) / 2)) * Complex.Gamma ((1 - s) / 2) * riemannZeta (1 - s)
    = ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s := by
  calc
    ((Real.pi : ℂ) ^ (-(1 - s) / 2)) * Complex.Gamma ((1 - s) / 2) * riemannZeta (1 - s)
      = completedRiemannZeta (1 - s) := by
          symm
          exact completedRiemannZeta_factor_bridge_of_not_exceptional
            (not_exceptional_of_nontrivial_strip (1 - s) (nontrivial_strip_one_sub s h_nontrivial))
    _ = completedRiemannZeta s := completedRiemannZeta_one_sub s
    _ = ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s :=
          completedRiemannZeta_factor_bridge_of_not_exceptional
            (not_exceptional_of_nontrivial_strip s h_nontrivial)

/-- Functional equation for ξ on the open critical strip, obtained from the localized factor bridge. -/
theorem xi_functional_equation_on_nontrivial_strip (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1) :
    xi s = xi (1 - s) := by
  unfold xi
  have hpoly :
      ((1 / 2 : ℂ) * s * (s - 1))
        = ((1 / 2 : ℂ) * (1 - s) * ((1 - s) - 1)) := by
    ring
  calc
    ((1 / 2 : ℂ) * s * (s - 1) * ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2)) *
        riemannZeta s
      = ((1 / 2 : ℂ) * s * (s - 1))
          * (((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s) := by
            ring
    _ = ((1 / 2 : ℂ) * (1 - s) * ((1 - s) - 1))
          * (((Real.pi : ℂ) ^ (-(1 - s) / 2)) * Complex.Gamma ((1 - s) / 2) *
            riemannZeta (1 - s)) := by
            rw [hpoly,
              (riemannZeta_factor_one_sub_symmetry_of_nontrivial_strip s h_nontrivial).symm]
    _ = ((1 / 2 : ℂ) * (1 - s) * ((1 - s) - 1) * ((Real.pi : ℂ) ^ (-(1 - s) / 2)) *
          Complex.Gamma ((1 - s) / 2)) * riemannZeta (1 - s) := by
            ring

/-- Derived one-sub symmetry at the explicit π/Gamma/ζ factor level. -/
theorem riemannZeta_factor_one_sub_symmetry (s : ℂ) :
  ((Real.pi : ℂ) ^ (-(1 - s) / 2)) * Complex.Gamma ((1 - s) / 2) * riemannZeta (1 - s)
    = ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s := by
  calc
    ((Real.pi : ℂ) ^ (-(1 - s) / 2)) * Complex.Gamma ((1 - s) / 2) * riemannZeta (1 - s)
      = completedRiemannZeta (1 - s) := by
          simpa using (completedRiemannZeta_factor_bridge (1 - s)).symm
    _ = completedRiemannZeta s := completedRiemannZeta_one_sub s
    _ = ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s :=
          completedRiemannZeta_factor_bridge s

/-- Functional equation for ξ, proved from multiplicative factor symmetry. -/
theorem xi_functional_equation (s : ℂ) :
  xi s = xi (1 - s) := by
  exact (xi_functional_equation_of_factor_symmetry riemannZeta_factor_one_sub_symmetry) s

/-- `Gammaℝ` respects complex conjugation. -/
lemma Gammaℝ_conj (s : ℂ) :
    conj (Gammaℝ s) = Gammaℝ (conj s) := by
  have hpi_arg : Complex.arg ((Real.pi : ℂ)) = 0 := by
    simpa using Complex.arg_ofReal_of_nonneg (show (0 : ℝ) ≤ Real.pi by exact le_of_lt Real.pi_pos)
  have hpi_ne : Complex.arg ((Real.pi : ℂ)) ≠ Real.pi := by
    rw [hpi_arg]
    exact ne_of_lt Real.pi_pos
  have hcpow :
      conj (((Real.pi : ℂ) ^ (-s / 2)))
        = ((Real.pi : ℂ) ^ (-(conj s) / 2)) := by
    have htmp := Complex.cpow_conj (x := (Real.pi : ℂ)) (n := (-s / 2)) hpi_ne
    simpa [Complex.conj_ofReal, map_neg, map_div₀, Complex.conj_ofNat] using htmp.symm
  have hGamma :
      conj (Complex.Gamma (s / 2)) = Complex.Gamma ((conj s) / 2) := by
    simpa [map_div₀, Complex.conj_ofNat] using (Complex.Gamma_conj (s / 2)).symm
  simp_rw [Gammaℝ_def, map_mul, hcpow, hGamma, ← Gammaℝ_def]

/-- Bundled conjugation boundary input at the completed Hurwitz-even level (`a = 0`). -/
def ConjugationBoundaryInput : Prop :=
  ∀ s : ℂ, s ≠ 0 →
    conj (completedHurwitzZetaEven 0 s) = completedHurwitzZetaEven 0 (conj s)

/-- Active bundled conjugation boundary assumption. -/
variable (conjugationBoundaryInput_assumption : ConjugationBoundaryInput)

/-- Projected completed Hurwitz-even conjugation boundary away from `s = 0`. -/
theorem completedHurwitzZetaEven_zero_conj_of_ne_zero (s : ℂ) (hs : s ≠ 0) :
    conj (completedHurwitzZetaEven 0 s) = completedHurwitzZetaEven 0 (conj s) := by
  exact conjugationBoundaryInput_assumption s hs

/-- Generic conjugation lift from completed Hurwitz-even (`a=0`) to Hurwitz-even (`a=0`). -/
theorem hurwitzZetaEven_zero_conj_of_completed_boundary
    (hcompleted : ∀ s : ℂ, s ≠ 0 →
      conj (completedHurwitzZetaEven 0 s) = completedHurwitzZetaEven 0 (conj s))
    (s : ℂ) :
    conj (hurwitzZetaEven 0 s) = hurwitzZetaEven 0 (conj s) := by
  rcases ne_or_eq s 0 with hs | rfl
  · have hconj : conj s ≠ 0 := fun h ↦ hs (by simpa [Complex.conj_conj] using congrArg conj h)
    rw [hurwitzZetaEven_def_of_ne_or_ne (a := 0) (s := s) (Or.inr hs)]
    rw [hurwitzZetaEven_def_of_ne_or_ne (a := 0) (s := conj s) (Or.inr hconj)]
    calc
      conj (completedHurwitzZetaEven 0 s / Gammaℝ s)
          = conj (completedHurwitzZetaEven 0 s * (Gammaℝ s)⁻¹) := by
              simp [div_eq_mul_inv]
      _ = conj (completedHurwitzZetaEven 0 s) * conj ((Gammaℝ s)⁻¹) := by
              simp [map_mul]
      _ = conj (completedHurwitzZetaEven 0 s) * (conj (Gammaℝ s))⁻¹ := by
              simp [Complex.conj_inv]
      _ = completedHurwitzZetaEven 0 (conj s) * (Gammaℝ (conj s))⁻¹ := by
              rw [hcompleted s hs, Gammaℝ_conj]
      _ = completedHurwitzZetaEven 0 (conj s) / Gammaℝ (conj s) := by
              simp [div_eq_mul_inv]
      _ = hurwitzZetaEven 0 (conj s) := by
              rw [← hurwitzZetaEven_def_of_ne_or_ne (a := 0) (s := conj s) (Or.inr hconj)]
  · simp [hurwitzZetaEven_apply_zero, Complex.conj_ofReal, Complex.ofReal_div, Complex.ofReal_neg]

/-- Derived conjugation symmetry for the underlying Hurwitz-even function at `a = 0`. -/
theorem hurwitzZetaEven_zero_conj (s : ℂ) :
  conj (hurwitzZetaEven 0 s) = hurwitzZetaEven 0 (conj s) := by
  exact hurwitzZetaEven_zero_conj_of_completed_boundary
    (fun s' hs' => completedHurwitzZetaEven_zero_conj_of_ne_zero s' hs') s

/-- Item-5 boundary as a consequence of `completedRiemannZeta` conjugation symmetry. -/
theorem completedHurwitzZetaEven_zero_conj_of_ne_zero_of_completedRiemannZeta_conj
    (hcompletedRiemannZeta_conj : ∀ s : ℂ,
      conj (completedRiemannZeta s) = completedRiemannZeta (conj s))
    (s : ℂ) (_hs : s ≠ 0) :
    conj (completedHurwitzZetaEven 0 s) = completedHurwitzZetaEven 0 (conj s) := by
  simpa [completedRiemannZeta] using hcompletedRiemannZeta_conj s

/-- Alternative derived Hurwitz-even conjugation chain through `completedRiemannZeta` symmetry. -/
theorem hurwitzZetaEven_zero_conj_of_completedRiemannZeta_conj
    (hcompletedRiemannZeta_conj : ∀ s : ℂ,
      conj (completedRiemannZeta s) = completedRiemannZeta (conj s))
    (s : ℂ) :
    conj (hurwitzZetaEven 0 s) = hurwitzZetaEven 0 (conj s) := by
  exact hurwitzZetaEven_zero_conj_of_completed_boundary
    (completedHurwitzZetaEven_zero_conj_of_ne_zero_of_completedRiemannZeta_conj
      hcompletedRiemannZeta_conj) s

/-- Alternative ζ conjugation chain through `completedRiemannZeta` symmetry. -/
theorem riemannZeta_conj_of_completedRiemannZeta_conj
    (hcompletedRiemannZeta_conj : ∀ s : ℂ,
      conj (completedRiemannZeta s) = completedRiemannZeta (conj s))
    (s : ℂ) :
    conj (riemannZeta s) = riemannZeta (conj s) := by
  simpa [riemannZeta] using hurwitzZetaEven_zero_conj_of_completedRiemannZeta_conj
    hcompletedRiemannZeta_conj s

/-- Reverse prototype direction:
conjugation symmetry of `riemannZeta` implies conjugation symmetry of `completedRiemannZeta`. -/
theorem completedRiemannZeta_conj_of_riemannZeta_conj
    (hriem : ∀ s : ℂ, conj (riemannZeta s) = riemannZeta (conj s))
    (s : ℂ) :
    conj (completedRiemannZeta s) = completedRiemannZeta (conj s) := by
  have hGammaR :
      conj (((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2))
        = ((Real.pi : ℂ) ^ (-(conj s) / 2)) * Complex.Gamma ((conj s) / 2) := by
    simpa [Gammaℝ_def, map_mul] using Gammaℝ_conj s
  calc
    conj (completedRiemannZeta s)
      = conj (((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2) * riemannZeta s) := by
          rw [completedRiemannZeta_factor_bridge s]
    _ = conj (((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2))
          * conj (riemannZeta s) := by
            simp [map_mul]
    _ = (((Real.pi : ℂ) ^ (-(conj s) / 2)) * Complex.Gamma ((conj s) / 2))
          * riemannZeta (conj s) := by
            rw [hGammaR, hriem s]
    _ = completedRiemannZeta (conj s) := by
          simpa using (completedRiemannZeta_factor_bridge (conj s)).symm

/-- Item-5 prototype route specialized from `riemannZeta` conjugation symmetry. -/
theorem completedHurwitzZetaEven_zero_conj_of_ne_zero_of_riemannZeta_conj
    (hriem : ∀ s : ℂ, conj (riemannZeta s) = riemannZeta (conj s))
    (s : ℂ) (hs : s ≠ 0) :
    conj (completedHurwitzZetaEven 0 s) = completedHurwitzZetaEven 0 (conj s) := by
  exact completedHurwitzZetaEven_zero_conj_of_ne_zero_of_completedRiemannZeta_conj
    (completedRiemannZeta_conj_of_riemannZeta_conj hriem) s hs

/-- Derived ζ-factor conjugation from the Hurwitz-even boundary at `a = 0`. -/
theorem riemannZeta_conj (s : ℂ) :
  conj (riemannZeta s) = riemannZeta (conj s) := by
  simpa [riemannZeta] using hurwitzZetaEven_zero_conj s

/-- Conjugation symmetry for `completedRiemannZeta`, derived from the active Hurwitz boundary chain. -/
theorem completedRiemannZeta_conj (s : ℂ) :
    conj (completedRiemannZeta s) = completedRiemannZeta (conj s) := by
  exact completedRiemannZeta_conj_of_riemannZeta_conj riemannZeta_conj s

/-- Conjugation symmetry for ξ, proved from multiplicative factor decomposition. -/
theorem xi_conj (s : ℂ) :
  conj (xi s) = xi (conj s) := by
  apply xi_conj_of_factor_conj
  intro w
  have hpi_arg : Complex.arg ((Real.pi : ℂ)) = 0 := by
    simpa using Complex.arg_ofReal_of_nonneg (show (0 : ℝ) ≤ Real.pi by exact le_of_lt Real.pi_pos)
  have hpi_ne : Complex.arg ((Real.pi : ℂ)) ≠ Real.pi := by
    rw [hpi_arg]
    exact ne_of_lt Real.pi_pos
  have hcpow :
      conj (((Real.pi : ℂ) ^ (-w / 2)))
        = ((Real.pi : ℂ) ^ (-(conj w) / 2)) := by
    have htmp := Complex.cpow_conj (x := (Real.pi : ℂ)) (n := (-w / 2)) hpi_ne
    simpa [Complex.conj_ofReal, map_neg, map_div₀, Complex.conj_ofNat] using htmp.symm
  have hGamma :
      conj (Complex.Gamma (w / 2)) = Complex.Gamma ((conj w) / 2) := by
    simpa [map_div₀, Complex.conj_ofNat] using (Complex.Gamma_conj (w / 2)).symm
  calc
    conj (((Real.pi : ℂ) ^ (-w / 2)) * Complex.Gamma (w / 2) * riemannZeta w)
      = (conj (((Real.pi : ℂ) ^ (-w / 2)) * Complex.Gamma (w / 2)))
          * conj (riemannZeta w) := by simp [map_mul]
    _ = (conj (((Real.pi : ℂ) ^ (-w / 2)) * Complex.Gamma (w / 2)))
          * riemannZeta (conj w) := by rw [riemannZeta_conj]
    _ = (conj (((Real.pi : ℂ) ^ (-w / 2))) * conj (Complex.Gamma (w / 2)))
          * riemannZeta (conj w) := by simp [map_mul]
    _ = (((Real.pi : ℂ) ^ (-(conj w) / 2)) * Complex.Gamma ((conj w) / 2))
          * riemannZeta (conj w) := by rw [hcpow, hGamma]
    _ = ((Real.pi : ℂ) ^ (-(conj w) / 2)) * Complex.Gamma ((conj w) / 2)
          * riemannZeta (conj w) := by ring

/-- 2-D phase-lock shift boundary constant.

This records the `11/8`-style phase-lock shift input used by the Lorentzian
defect-rigidity route. We keep it explicit as an analytic boundary marker. -/
def phase_lock_shift_constant_11_over_8 : Prop := True

/-- Canonical inhabitant of the phase-lock shift marker. -/
theorem phase_lock_shift_constant_11_over_8_holds : phase_lock_shift_constant_11_over_8 := by
  trivial

/-! ### Zero-height asymptotic heuristic (11/8 phase-lock shift)

This section records the computational heuristic suggested by the phase-lock
shift constant. It is intentionally separated from the proved RH endpoint chain.

Heuristic counting law (model-level):
`N(T) ~= (T/(2*pi)) * log(T/(2*pi*e)) + 11/8`

Inversion target for the `n`-th positive zero height:
`t_n ~= (2*pi*(n - 11/8)) / log(t_n/(2*pi*e))`

The definitions below provide a machine-checkable interface for iterative
numerics while keeping the analytic proof boundary explicit.
-/

/-- The geometric phase-lock shift used by the heuristic counting law. -/
noncomputable def phase_lock_shift_value : ℝ := (11 : ℝ) / 8

/-- `phase_lock_shift_value` is definitionally `11/8` (no hidden scale parameter in this file). -/
theorem phase_lock_shift_scale_invariant : phase_lock_shift_value = (11 / 8 : ℝ) := rfl

/-- Exploratory metallic correction to the phase-lock shift.

This keeps `11/8` as the silver baseline (`m = 1`) and perturbs the shift by
relative metallic displacement. It is a conjectural modeling layer and is not
used in the RH endpoint chain. -/
noncomputable def metallic_phase_shift (m : ℝ) : ℝ :=
  phase_lock_shift_value + (metallic m - metallic 1)

/-- Silver baseline consistency: the metallic-corrected shift recovers `11/8` at `m = 1`. -/
lemma metallic_phase_shift_at_silver : metallic_phase_shift 1 = phase_lock_shift_value := by
  unfold metallic_phase_shift
  ring

/-- Main-term zero-count model with the `11/8` phase-lock shift. -/
noncomputable def phase_lock_zero_count_main_term (T : ℝ) : ℝ :=
  T / (2 * Real.pi) * Real.log (T / (2 * Real.pi * Real.exp 1)) + phase_lock_shift_value

/-- Metallic-parameterized variant of the main-term counting model (exploratory). -/
noncomputable def phase_lock_zero_count_main_term_metallic (m T : ℝ) : ℝ :=
  T / (2 * Real.pi) * Real.log (T / (2 * Real.pi * Real.exp 1)) + metallic_phase_shift m

/-- Implicit fixed-point equation for the `n`-th zero height in this model. -/
noncomputable def phase_lock_zero_height_implicit (n : ℕ) (t : ℝ) : Prop :=
  t / (2 * Real.pi) * Real.log (t / (2 * Real.pi * Real.exp 1)) =
    (n : ℝ) - phase_lock_shift_value

/-- Metallic-parameterized implicit zero-height equation (exploratory). -/
noncomputable def phase_lock_zero_height_implicit_metallic (m : ℝ) (n : ℕ) (t : ℝ) : Prop :=
  t / (2 * Real.pi) * Real.log (t / (2 * Real.pi * Real.exp 1)) =
    (n : ℝ) - metallic_phase_shift m

/-- One-step fixed-point update for the implicit `t_n` equation. -/
noncomputable def phase_lock_zero_height_update (n : ℕ) (t : ℝ) : ℝ :=
  (2 * Real.pi) * ((n : ℝ) - phase_lock_shift_value)
    / Real.log (t / (2 * Real.pi * Real.exp 1))

/-- Metallic-parameterized one-step fixed-point update (exploratory). -/
noncomputable def phase_lock_zero_height_update_metallic (m : ℝ) (n : ℕ) (t : ℝ) : ℝ :=
  (2 * Real.pi) * ((n : ℝ) - metallic_phase_shift m)
    / Real.log (t / (2 * Real.pi * Real.exp 1))

/-- Cheap closed-form proxy for large `n` (log-denominator frozen at `n - 11/8`). -/
noncomputable def phase_lock_zero_height_cheat (n : ℕ) : ℝ :=
  (2 * Real.pi) * ((n : ℝ) - phase_lock_shift_value)
    / Real.log ((n : ℝ) - phase_lock_shift_value)

/-- Metallic-parameterized large-`n` cheat proxy (exploratory). -/
noncomputable def phase_lock_zero_height_cheat_metallic (m : ℝ) (n : ℕ) : ℝ :=
  (2 * Real.pi) * ((n : ℝ) - metallic_phase_shift m)
    / Real.log ((n : ℝ) - metallic_phase_shift m)

/-- Canonical initial seed used by the fixed-point iterator. -/
noncomputable def phase_lock_zero_height_seed (n : ℕ) : ℝ :=
  (2 * Real.pi) * ((n : ℝ) - phase_lock_shift_value)

/-- Iterative approximation sequence for the `n`-th zero height. -/
noncomputable def phase_lock_zero_height_iter (n : ℕ) : ℕ → ℝ
  | 0 => phase_lock_zero_height_seed n
  | k + 1 => phase_lock_zero_height_update n (phase_lock_zero_height_iter n k)

/-- Index of which zero is being targeted (Euclidean counting axis, conceptual). -/
abbrev ZeroIndex := ℕ

/-- Index of iteration depth in the fixed-point update (Lorentzian flow axis, conceptual). -/
abbrev IterationIndex := ℕ

/-- Euclidean observer channel (observation-space side). -/
abbrev EuclideanObserver := ℂ

/-- Canonical Euclidean observer used by the framework. -/
noncomputable def euclidean_observer : EuclideanObserver := μ_canonical

/-- The Euclidean observer is normalized to unit modulus. -/
lemma euclidean_observer_abs : Complex.abs euclidean_observer = 1 := by
  simpa [euclidean_observer] using μ_canonical_abs

/-- Two-parameter view of the iterate: target-zero index `n` and update depth `k`. -/
noncomputable def phase_lock_zero_height_at (n : ZeroIndex) (k : IterationIndex) : ℝ :=
  phase_lock_zero_height_iter n k

/-- At iteration depth `0`, the two-parameter view returns the canonical seed. -/
lemma phase_lock_zero_height_at_zero (n : ZeroIndex) :
    phase_lock_zero_height_at n 0 = phase_lock_zero_height_seed n := by
  rfl

/-- At depth `k+1`, the two-parameter view applies one update to depth `k`. -/
lemma phase_lock_zero_height_at_succ (n : ZeroIndex) (k : IterationIndex) :
    phase_lock_zero_height_at n (k + 1)
      = phase_lock_zero_height_update n (phase_lock_zero_height_at n k) := by
  rfl

/-- Log denominator used by the fixed-point update. -/
noncomputable def phase_lock_update_log_denominator (t : ℝ) : ℝ :=
  Real.log (t / (2 * Real.pi * Real.exp 1))

/-- Admissibility condition for one-step update at height `t`.
It excludes the low-height regime where the log denominator is nonpositive. -/
def phase_lock_update_admissible (t : ℝ) : Prop :=
  0 < phase_lock_update_log_denominator t

/-- Admissibility condition for the closed-form cheat at index `n`. -/
def phase_lock_cheat_admissible (n : ℕ) : Prop :=
  0 < Real.log ((n : ℝ) - phase_lock_shift_value)

/-- Admissibility of the canonical seed for index `n`. -/
def phase_lock_seed_admissible (n : ℕ) : Prop :=
  phase_lock_update_admissible (phase_lock_zero_height_seed n)

/-- Domain condition ensuring seed admissibility.
This is the exact positivity condition needed for the first logarithmic denominator. -/
def phase_lock_seed_domain (n : ℕ) : Prop :=
  Real.exp 1 < (n : ℝ) - phase_lock_shift_value

/-- Practical large-index threshold for seed initialization. -/
def phase_lock_large_n_domain (n : ℕ) : Prop :=
  5 ≤ n

/-- The practical threshold `n ≥ 5` implies the exact seed-domain condition. -/
lemma phase_lock_seed_domain_of_large_n (n : ℕ)
    (hn : phase_lock_large_n_domain n) :
    phase_lock_seed_domain n := by
  unfold phase_lock_large_n_domain phase_lock_seed_domain
  have h_exp : Real.exp 1 < 3 := Real.exp_one_lt_three
  have hnR : (5 : ℝ) ≤ (n : ℝ) := by exact_mod_cast hn
  have hmono : (5 : ℝ) - phase_lock_shift_value ≤ (n : ℝ) - phase_lock_shift_value :=
    sub_le_sub_right hnR phase_lock_shift_value
  have hthree : (3 : ℝ) < (5 : ℝ) - phase_lock_shift_value := by
    unfold phase_lock_shift_value
    norm_num
  exact lt_of_lt_of_le h_exp (le_trans hthree.le hmono)

/-- Seed admissibility from the explicit seed-domain condition. -/
lemma phase_lock_seed_admissible_of_domain (n : ℕ)
    (hdom : phase_lock_seed_domain n) :
    phase_lock_seed_admissible n := by
  unfold phase_lock_seed_admissible phase_lock_update_admissible
  unfold phase_lock_update_log_denominator phase_lock_zero_height_seed phase_lock_seed_domain
  have hlog_arg_gt_one :
      1 < (((2 * Real.pi) * ((n : ℝ) - phase_lock_shift_value)) / (2 * Real.pi * Real.exp 1)) := by
    have hden_pos : 0 < (2 * Real.pi * Real.exp 1) := by positivity
    have hnum_gt_den : (2 * Real.pi * Real.exp 1)
        < ((2 * Real.pi) * ((n : ℝ) - phase_lock_shift_value)) := by
      have h2pi_pos : 0 < (2 * Real.pi) := by positivity
      have hmul := mul_lt_mul_of_pos_left hdom h2pi_pos
      simpa [mul_assoc, mul_left_comm, mul_comm] using hmul
    exact (one_lt_div_iff hden_pos).2 hnum_gt_den
  exact Real.log_pos hlog_arg_gt_one

/-- Practical seed admissibility theorem: `n ≥ 5` is sufficient. -/
lemma phase_lock_seed_admissible_of_large_n (n : ℕ)
    (hn : phase_lock_large_n_domain n) :
    phase_lock_seed_admissible n := by
  exact phase_lock_seed_admissible_of_domain n (phase_lock_seed_domain_of_large_n n hn)

/-- Contractivity predicate on the admissible region for fixed zero index `n`.
This is the quantitative hypothesis needed to run a Banach-style convergence argument. -/
def phase_lock_update_contractive_on_admissible (n : ZeroIndex) : Prop :=
  ∃ q : ℝ,
    0 ≤ q ∧ q < 1 ∧
    ∀ t₁ t₂ : ℝ,
      phase_lock_update_admissible t₁ →
      phase_lock_update_admissible t₂ →
      |phase_lock_zero_height_update n t₁ - phase_lock_zero_height_update n t₂|
        ≤ q * |t₁ - t₂|

/-- Eventual admissibility of the iteration flow in depth `k`. -/
def phase_lock_iter_eventually_admissible (n : ZeroIndex) : Prop :=
  ∃ K : IterationIndex, ∀ k : IterationIndex,
    K ≤ k → phase_lock_update_admissible (phase_lock_zero_height_at n k)

/-- Cauchy-in-`k` convergence scaffold for the iteration flow at fixed `n`. -/
def phase_lock_iter_cauchy (n : ZeroIndex) : Prop :=
  Cauchy (Filter.map (phase_lock_zero_height_at n) Filter.atTop)

/-- Convergence of the iteration flow to a candidate zero height `t`. -/
def phase_lock_iter_converges_to (n : ZeroIndex) (t : ℝ) : Prop :=
  Filter.Tendsto (phase_lock_zero_height_at n) Filter.atTop (nhds t)

/-- Existence of a limit height for the iteration flow at fixed zero index `n`. -/
def phase_lock_iter_has_limit (n : ZeroIndex) : Prop :=
  ∃ t : ℝ, phase_lock_iter_converges_to n t

/-- Packaged stability interface for the Lorentzian iteration flow. -/
def phase_lock_iter_stable_model (n : ZeroIndex) : Prop :=
  phase_lock_iter_eventually_admissible n ∧ phase_lock_iter_cauchy n

/-- Tail invariance interface for admissibility under one update step. -/
def phase_lock_iter_tail_invariant (n : ZeroIndex) : Prop :=
  ∃ K : IterationIndex, ∀ k : IterationIndex,
    K ≤ k →
      phase_lock_update_admissible (phase_lock_zero_height_at n k)
        ∧ phase_lock_update_admissible
            (phase_lock_zero_height_update n (phase_lock_zero_height_at n k))

/-- Global admissibility interface: seed and every raw iterate are admissible. -/
def phase_lock_iter_globally_admissible (n : ZeroIndex) : Prop :=
  phase_lock_seed_admissible n ∧ ∀ k : IterationIndex,
    phase_lock_update_admissible (phase_lock_zero_height_at n k)

/-- Optional closure target: any convergent limit is expected to satisfy the implicit equation. -/
def phase_lock_iter_limit_is_implicit_root (n : ZeroIndex) : Prop :=
  ∀ t : ℝ, phase_lock_iter_converges_to n t → phase_lock_zero_height_implicit n t

/-- Existence package for a convergent implicit-root witness at index `n`. -/
def phase_lock_zero_height_limit_witness (n : ZeroIndex) : Prop :=
  ∃ t : ℝ, phase_lock_iter_converges_to n t ∧ phase_lock_zero_height_implicit n t

/-- Lorentzian witness package at index `n` (flow-space side). -/
abbrev LorentzianWitness (n : ZeroIndex) : Prop :=
  phase_lock_zero_height_limit_witness n

/-- Noncomputable zero-height extracted from a proven convergence/root witness. -/
noncomputable def phase_lock_zero_height (n : ZeroIndex)
    (hlim : phase_lock_zero_height_limit_witness n) : ℝ :=
  Classical.choose hlim

/-- Height extracted from a Lorentzian witness. -/
noncomputable def lorentzian_witness_height (n : ZeroIndex)
    (hL : LorentzianWitness n) : ℝ :=
  phase_lock_zero_height n hL

/-- The extracted zero-height indeed satisfies the implicit equation. -/
lemma phase_lock_zero_height_spec (n : ZeroIndex)
    (hlim : phase_lock_zero_height_limit_witness n) :
    phase_lock_zero_height_implicit n (phase_lock_zero_height n hlim) := by
  exact (Classical.choose_spec hlim).2

/-- The extracted zero-height is the limit of the iteration flow. -/
lemma phase_lock_zero_height_tendsto (n : ZeroIndex)
    (hlim : phase_lock_zero_height_limit_witness n) :
    phase_lock_iter_converges_to n (phase_lock_zero_height n hlim) := by
  exact (Classical.choose_spec hlim).1

/-- A Lorentzian witness satisfies the implicit height equation. -/
lemma lorentzian_witness_height_spec (n : ZeroIndex)
    (hL : LorentzianWitness n) :
    phase_lock_zero_height_implicit n (lorentzian_witness_height n hL) := by
  simpa [lorentzian_witness_height] using phase_lock_zero_height_spec n hL

/-- A Lorentzian witness is realized as the limit of the Lorentzian iteration flow. -/
lemma lorentzian_witness_height_tendsto (n : ZeroIndex)
    (hL : LorentzianWitness n) :
    phase_lock_iter_converges_to n (lorentzian_witness_height n hL) := by
  simpa [lorentzian_witness_height] using phase_lock_zero_height_tendsto n hL

/-- Immediate bridge: a specific convergence witness gives limit existence. -/
lemma phase_lock_iter_converges_to_has_limit (n : ZeroIndex) (t : ℝ)
    (hconv : phase_lock_iter_converges_to n t) :
    phase_lock_iter_has_limit n := by
  exact ⟨t, hconv⟩

/-- If the flow has a limit and every limit is an implicit root, then we get
the packaged zero-height witness. -/
lemma phase_lock_zero_height_limit_witness_of_has_limit_and_root
    (n : ZeroIndex)
    (hlim : phase_lock_iter_has_limit n)
    (hroot : phase_lock_iter_limit_is_implicit_root n) :
    phase_lock_zero_height_limit_witness n := by
  rcases hlim with ⟨t, ht⟩
  exact ⟨t, ht, hroot t ht⟩

/-- Stable-model + explicit limit + root-closure implies the packaged witness. -/
lemma phase_lock_zero_height_limit_witness_of_stable_limit_and_root
    (n : ZeroIndex)
    (_hstable : phase_lock_iter_stable_model n)
    (hlim : phase_lock_iter_has_limit n)
    (hroot : phase_lock_iter_limit_is_implicit_root n) :
    phase_lock_zero_height_limit_witness n := by
  exact phase_lock_zero_height_limit_witness_of_has_limit_and_root n hlim hroot

/-- Unfolding rule for the first iterate. -/
lemma phase_lock_zero_height_iter_one (n : ℕ) :
    phase_lock_zero_height_iter n 1 =
      phase_lock_zero_height_update n (phase_lock_zero_height_seed n) := by
  rfl

/-- Safe update wrapper: returns `none` when the log denominator is not positive. -/
noncomputable def phase_lock_zero_height_update_safe (n : ℕ) (t : ℝ) : Option ℝ :=
  if phase_lock_update_admissible t then
    some (phase_lock_zero_height_update n t)
  else
    none

/-- Safe cheat wrapper: returns `none` when the cheat denominator is not positive. -/
noncomputable def phase_lock_zero_height_cheat_safe (n : ℕ) : Option ℝ :=
  if phase_lock_cheat_admissible n then
    some (phase_lock_zero_height_cheat n)
  else
    none

/-- Safe update is `some` exactly on admissible inputs. -/
lemma phase_lock_zero_height_update_safe_eq_some_iff (n : ℕ) (t u : ℝ) :
    phase_lock_zero_height_update_safe n t = some u
      ↔ phase_lock_update_admissible t ∧ u = phase_lock_zero_height_update n t := by
  unfold phase_lock_zero_height_update_safe
  by_cases h : phase_lock_update_admissible t
  · simp [h]
  · simp [h]

/-- Safe cheat is `some` exactly when cheat admissibility holds. -/
lemma phase_lock_zero_height_cheat_safe_eq_some_iff (n : ℕ) (u : ℝ) :
    phase_lock_zero_height_cheat_safe n = some u
      ↔ phase_lock_cheat_admissible n ∧ u = phase_lock_zero_height_cheat n := by
  unfold phase_lock_zero_height_cheat_safe
  by_cases h : phase_lock_cheat_admissible n
  · simp [h]
  · simp [h]

/-- Total safe recursion in iteration depth:
it starts from an admissible seed and propagates by safe updates only. -/
noncomputable def phase_lock_zero_height_iter_safe (n : ZeroIndex) : IterationIndex → Option ℝ
  | 0 =>
      if phase_lock_seed_admissible n then
        some (phase_lock_zero_height_seed n)
      else
        none
  | k + 1 =>
      match phase_lock_zero_height_iter_safe n k with
      | some t => phase_lock_zero_height_update_safe n t
      | none => none

/-- Unfolding rule for safe depth `0`. -/
lemma phase_lock_zero_height_iter_safe_zero (n : ZeroIndex) :
    phase_lock_zero_height_iter_safe n 0
      = (if phase_lock_seed_admissible n then some (phase_lock_zero_height_seed n) else none) := by
  rfl

/-- Unfolding rule for safe depth `k+1`. -/
lemma phase_lock_zero_height_iter_safe_succ (n : ZeroIndex) (k : IterationIndex) :
    phase_lock_zero_height_iter_safe n (k + 1)
      = match phase_lock_zero_height_iter_safe n k with
        | some t => phase_lock_zero_height_update_safe n t
        | none => none := by
  rfl

/-- Sound one-step propagation: if depth `k` produced `t` and `t` is admissible,
then depth `k+1` produces the analytic update value. -/
lemma phase_lock_zero_height_iter_safe_step_sound
    (n : ZeroIndex) (k : IterationIndex) (t : ℝ)
    (hk : phase_lock_zero_height_iter_safe n k = some t)
    (h_adm : phase_lock_update_admissible t) :
    phase_lock_zero_height_iter_safe n (k + 1) = some (phase_lock_zero_height_update n t) := by
  rw [phase_lock_zero_height_iter_safe_succ, hk]
  simp [phase_lock_zero_height_update_safe, h_adm]

  /-- Under global admissibility, the safe iterator agrees with the raw iterator at every depth. -/
  lemma phase_lock_zero_height_iter_safe_eq_raw_of_globally_admissible
    (n : ZeroIndex)
    (hglob : phase_lock_iter_globally_admissible n) :
    ∀ k : IterationIndex,
      phase_lock_zero_height_iter_safe n k = some (phase_lock_zero_height_at n k) := by
    intro k
    rcases hglob with ⟨hseed, hall⟩
    induction k with
    | zero =>
      simp [phase_lock_zero_height_iter_safe_zero, phase_lock_zero_height_at_zero, hseed]
    | succ k ih =>
      rw [phase_lock_zero_height_iter_safe_succ, ih]
      simp [phase_lock_zero_height_update_safe, hall k, phase_lock_zero_height_at_succ]

  /-- Global admissibility gives the safe/raw iterate identity together with the
  canonical observation modulus invariant `|μ| = 1`. -/
  lemma phase_lock_global_safe_raw_and_abs_mu (n : ZeroIndex)
      (hglob : phase_lock_iter_globally_admissible n) (k : IterationIndex) :
      phase_lock_zero_height_iter_safe n k = some (phase_lock_zero_height_at n k)
        ∧ Complex.abs μ_canonical = 1 := by
    exact ⟨phase_lock_zero_height_iter_safe_eq_raw_of_globally_admissible n hglob k,
      μ_canonical_abs⟩

  /-- Pointwise global bridge phrased as an equality to `|μ|` (which is `1`). -/
  lemma phase_lock_global_safe_raw_eq_abs_mu (n : ZeroIndex)
      (hglob : phase_lock_iter_globally_admissible n) (k : IterationIndex) :
      (Complex.abs μ_canonical : ℝ) = 1 := by
    simpa using (phase_lock_global_safe_raw_and_abs_mu n hglob k).2

  /-- Practical entrypoint:
  from `n ≥ 5` and global step-admissibility, safe/raw identity and `|μ|=1` follow. -/
  lemma phase_lock_global_safe_raw_and_abs_mu_of_large_n
      (n : ZeroIndex)
      (hn : phase_lock_large_n_domain n)
      (hall : ∀ k : IterationIndex,
        phase_lock_update_admissible (phase_lock_zero_height_at n k))
      (k : IterationIndex) :
      phase_lock_zero_height_iter_safe n k = some (phase_lock_zero_height_at n k)
        ∧ Complex.abs μ_canonical = 1 := by
    have hglob : phase_lock_iter_globally_admissible n := by
      exact ⟨phase_lock_seed_admissible_of_large_n n hn, hall⟩
    exact phase_lock_global_safe_raw_and_abs_mu n hglob k

  /-- Corollary form of the practical entrypoint focused on the modulus identity. -/
  lemma phase_lock_global_abs_mu_of_large_n
      (n : ZeroIndex)
      (hn : phase_lock_large_n_domain n)
      (hall : ∀ k : IterationIndex,
        phase_lock_update_admissible (phase_lock_zero_height_at n k))
      (k : IterationIndex) :
      (Complex.abs μ_canonical : ℝ) = 1 := by
    exact (phase_lock_global_safe_raw_and_abs_mu_of_large_n n hn hall k).2

  /-- Normalization identity: the observation modulus is exactly the balanced
  product of source and medium magnitudes. -/
  lemma abs_mu_as_normalized_total_balance :
      Complex.abs μ_canonical = Complex.abs B_canonical * Complex.abs C_canonical := by
    calc
      Complex.abs μ_canonical = Complex.abs (B_canonical * C_canonical) := by
        simpa [B_mul_C_eq_μ]
      _ = Complex.abs B_canonical * Complex.abs C_canonical := by
        simpa using Complex.abs.mul B_canonical C_canonical

  /-- The normalized total balance equals one. -/
  lemma abs_mu_as_normalized_total_balance_eq_one :
      Complex.abs μ_canonical = 1 := by
    calc
      Complex.abs μ_canonical = Complex.abs B_canonical * Complex.abs C_canonical :=
        abs_mu_as_normalized_total_balance
      _ = 1 := magnitude_balance

/-- Under admissibility, any solution of the implicit equation is a fixed point of the update map. -/
lemma phase_lock_implicit_fixed_point_of_admissible (n : ℕ) (t : ℝ)
    (h_imp : phase_lock_zero_height_implicit n t)
    (h_adm : phase_lock_update_admissible t) :
    t = phase_lock_zero_height_update n t := by
  have hlog_pos : 0 < Real.log (t / (2 * Real.pi * Real.exp 1)) := h_adm
  have hlog_ne : Real.log (t / (2 * Real.pi * Real.exp 1)) ≠ 0 := ne_of_gt hlog_pos
  have hmul :
      t * Real.log (t / (2 * Real.pi * Real.exp 1))
        = (2 * Real.pi) * ((n : ℝ) - phase_lock_shift_value) := by
    have hpi_ne : (2 * Real.pi) ≠ 0 := by positivity
    have hmul' := congrArg (fun x : ℝ => x * (2 * Real.pi)) h_imp
    have hleft :
        (t / (2 * Real.pi) * Real.log (t / (2 * Real.pi * Real.exp 1))) * (2 * Real.pi)
          = t * Real.log (t / (2 * Real.pi * Real.exp 1)) := by
      field_simp [hpi_ne]
    have hright :
        (((n : ℝ) - phase_lock_shift_value) * (2 * Real.pi))
          = (2 * Real.pi) * ((n : ℝ) - phase_lock_shift_value) := by
      ring
    calc
      t * Real.log (t / (2 * Real.pi * Real.exp 1))
          = (t / (2 * Real.pi) * Real.log (t / (2 * Real.pi * Real.exp 1))) * (2 * Real.pi) := by
              symm
              exact hleft
      _ = ((n : ℝ) - phase_lock_shift_value) * (2 * Real.pi) := hmul'
      _ = (2 * Real.pi) * ((n : ℝ) - phase_lock_shift_value) := hright
  have hdiv :
      t = ((2 * Real.pi) * ((n : ℝ) - phase_lock_shift_value))
          / Real.log (t / (2 * Real.pi * Real.exp 1)) := by
    exact (eq_div_iff hlog_ne).2 (by simpa [mul_comm, mul_left_comm, mul_assoc] using hmul)
  simpa [phase_lock_zero_height_update] using hdiv

/-- Converse bridge: an admissible fixed point of the update map satisfies the implicit equation. -/
lemma phase_lock_implicit_of_fixed_point_of_admissible (n : ℕ) (t : ℝ)
    (h_fix : t = phase_lock_zero_height_update n t)
    (h_adm : phase_lock_update_admissible t) :
    phase_lock_zero_height_implicit n t := by
  unfold phase_lock_zero_height_implicit
  have hlog_pos : 0 < Real.log (t / (2 * Real.pi * Real.exp 1)) := h_adm
  have hlog_ne : Real.log (t / (2 * Real.pi * Real.exp 1)) ≠ 0 := ne_of_gt hlog_pos
  have hfix' :
      t = ((2 * Real.pi) * ((n : ℝ) - phase_lock_shift_value))
            / Real.log (t / (2 * Real.pi * Real.exp 1)) := by
    simpa [phase_lock_zero_height_update] using h_fix
  have hmul :
      t * Real.log (t / (2 * Real.pi * Real.exp 1))
        = (2 * Real.pi) * ((n : ℝ) - phase_lock_shift_value) := by
    exact (eq_div_iff hlog_ne).1 hfix'
  have h2pi_ne : (2 * Real.pi) ≠ 0 := by positivity
  have hcore :
      t / (2 * Real.pi) * Real.log (t / (2 * Real.pi * Real.exp 1))
        = (n : ℝ) - phase_lock_shift_value := by
    have hmul' := congrArg (fun x : ℝ => x / (2 * Real.pi)) hmul
    calc
      t / (2 * Real.pi) * Real.log (t / (2 * Real.pi * Real.exp 1))
          = (t * Real.log (t / (2 * Real.pi * Real.exp 1))) / (2 * Real.pi) := by
              ring
      _ = ((2 * Real.pi) * ((n : ℝ) - phase_lock_shift_value)) / (2 * Real.pi) := by
            simpa using hmul'
      _ = (n : ℝ) - phase_lock_shift_value := by
            field_simp [h2pi_ne]
  simpa using hcore

/-- If every limit point is an admissible fixed point of the update map,
then every limit point is an implicit root. -/
lemma phase_lock_iter_limit_is_implicit_root_of_limit_fixed_points
    (n : ZeroIndex)
    (hfix_lim : ∀ t : ℝ,
      phase_lock_iter_converges_to n t → t = phase_lock_zero_height_update n t)
    (hadm_lim : ∀ t : ℝ,
      phase_lock_iter_converges_to n t → phase_lock_update_admissible t) :
    phase_lock_iter_limit_is_implicit_root n := by
  intro t ht
  exact phase_lock_implicit_of_fixed_point_of_admissible n t (hfix_lim t ht) (hadm_lim t ht)

  /-- Fixed-point closure criterion at limit points for index `n`. -/
  def phase_lock_iter_limit_fixed_point (n : ZeroIndex) : Prop :=
    ∀ t : ℝ, phase_lock_iter_converges_to n t → t = phase_lock_zero_height_update n t

  /-- Full practical pipeline package.
  From large-index seed control, global step-admissibility, and stable/limit/root
  closure data, we obtain an explicit limit root together with safe/raw iterate
  agreement and normalized modulus identity. -/
  lemma phase_lock_full_pipeline_of_large_n
      (n : ZeroIndex)
      (hn : phase_lock_large_n_domain n)
      (hall : ∀ k : IterationIndex,
        phase_lock_update_admissible (phase_lock_zero_height_at n k))
      (hstable : phase_lock_iter_stable_model n)
      (hlim : phase_lock_iter_has_limit n)
      (hroot : phase_lock_iter_limit_is_implicit_root n) :
      ∃ t : ℝ,
        phase_lock_iter_converges_to n t
          ∧ phase_lock_zero_height_implicit n t
          ∧ (∀ k : IterationIndex,
              phase_lock_zero_height_iter_safe n k = some (phase_lock_zero_height_at n k))
          ∧ Complex.abs μ_canonical = 1 := by
    have hw : phase_lock_zero_height_limit_witness n :=
      phase_lock_zero_height_limit_witness_of_stable_limit_and_root n hstable hlim hroot
    refine ⟨phase_lock_zero_height n hw, ?_, ?_, ?_, ?_⟩
    · exact phase_lock_zero_height_tendsto n hw
    · exact phase_lock_zero_height_spec n hw
    · intro k
      exact (phase_lock_global_safe_raw_and_abs_mu_of_large_n n hn hall k).1
    · exact (phase_lock_global_abs_mu_of_large_n n hn hall 0)

  /-- Full practical pipeline with fixed-point closure instead of direct root closure. -/
  lemma phase_lock_full_pipeline_of_large_n_fixedpoint
      (n : ZeroIndex)
      (hn : phase_lock_large_n_domain n)
      (hall : ∀ k : IterationIndex,
        phase_lock_update_admissible (phase_lock_zero_height_at n k))
      (hstable : phase_lock_iter_stable_model n)
      (hlim : phase_lock_iter_has_limit n)
      (hfix_lim : phase_lock_iter_limit_fixed_point n)
      (hadm_lim : ∀ t : ℝ,
        phase_lock_iter_converges_to n t → phase_lock_update_admissible t) :
      ∃ t : ℝ,
        phase_lock_iter_converges_to n t
          ∧ phase_lock_zero_height_implicit n t
          ∧ (∀ k : IterationIndex,
              phase_lock_zero_height_iter_safe n k = some (phase_lock_zero_height_at n k))
          ∧ Complex.abs μ_canonical = 1 := by
    have hroot : phase_lock_iter_limit_is_implicit_root n :=
      phase_lock_iter_limit_is_implicit_root_of_limit_fixed_points n hfix_lim hadm_lim
    exact phase_lock_full_pipeline_of_large_n n hn hall hstable hlim hroot

  /-- Extracted zero-height corollary from the full practical pipeline package. -/
  lemma phase_lock_zero_height_spec_of_large_n
      (n : ZeroIndex)
      (hn : phase_lock_large_n_domain n)
      (hall : ∀ k : IterationIndex,
        phase_lock_update_admissible (phase_lock_zero_height_at n k))
      (hstable : phase_lock_iter_stable_model n)
      (hlim : phase_lock_iter_has_limit n)
      (hroot : phase_lock_iter_limit_is_implicit_root n) :
      ∃ hW : phase_lock_zero_height_limit_witness n,
        phase_lock_zero_height_implicit n (phase_lock_zero_height n hW)
          ∧ phase_lock_iter_converges_to n (phase_lock_zero_height n hW) := by
    let hW : phase_lock_zero_height_limit_witness n :=
      phase_lock_zero_height_limit_witness_of_stable_limit_and_root n hstable hlim hroot
    refine ⟨hW, ?_⟩
    exact ⟨phase_lock_zero_height_spec n hW, phase_lock_zero_height_tendsto n hW⟩

  /-- Witness-found theorem (fixed-point closure route).
  This is the explicit packaged existence statement for the extracted zero-height witness. -/
  lemma phase_lock_witness_found_of_large_n
      (n : ZeroIndex)
      (hn : phase_lock_large_n_domain n)
      (hall : ∀ k : IterationIndex,
        phase_lock_update_admissible (phase_lock_zero_height_at n k))
      (hstable : phase_lock_iter_stable_model n)
      (hlim : phase_lock_iter_has_limit n)
      (hfix_lim : phase_lock_iter_limit_fixed_point n)
      (hadm_lim : ∀ t : ℝ,
        phase_lock_iter_converges_to n t → phase_lock_update_admissible t) :
      ∃ hW : phase_lock_zero_height_limit_witness n,
        phase_lock_zero_height_implicit n (phase_lock_zero_height n hW)
          ∧ phase_lock_iter_converges_to n (phase_lock_zero_height n hW)
          ∧ Complex.abs μ_canonical = 1 := by
    have hroot : phase_lock_iter_limit_is_implicit_root n :=
      phase_lock_iter_limit_is_implicit_root_of_limit_fixed_points n hfix_lim hadm_lim
    have hW : phase_lock_zero_height_limit_witness n :=
      phase_lock_zero_height_limit_witness_of_stable_limit_and_root n hstable hlim hroot
    refine ⟨hW, phase_lock_zero_height_spec n hW, phase_lock_zero_height_tendsto n hW, ?_⟩
    exact (phase_lock_global_abs_mu_of_large_n n hn hall 0)

  /-- Lorentzian witness + Euclidean observer packaging for the large-index pipeline. -/
  lemma lorentzian_witness_and_euclidean_observer_of_large_n
      (n : ZeroIndex)
      (hn : phase_lock_large_n_domain n)
      (hall : ∀ k : IterationIndex,
        phase_lock_update_admissible (phase_lock_zero_height_at n k))
      (hstable : phase_lock_iter_stable_model n)
      (hlim : phase_lock_iter_has_limit n)
      (hfix_lim : phase_lock_iter_limit_fixed_point n)
      (hadm_lim : ∀ t : ℝ,
        phase_lock_iter_converges_to n t → phase_lock_update_admissible t) :
      ∃ hL : LorentzianWitness n,
        phase_lock_zero_height_implicit n (lorentzian_witness_height n hL)
          ∧ phase_lock_iter_converges_to n (lorentzian_witness_height n hL)
          ∧ Complex.abs euclidean_observer = 1 := by
    rcases phase_lock_witness_found_of_large_n n hn hall hstable hlim hfix_lim hadm_lim with
      ⟨hW, hspec, hconv, hmu⟩
    refine ⟨hW, ?_⟩
    refine ⟨?_, ?_, ?_⟩
    · simpa [lorentzian_witness_height] using hspec
    · simpa [lorentzian_witness_height] using hconv
    · simpa [euclidean_observer] using hmu

/-- Raw window defect channel used in the regularized explicit-formula narrative:
`D_N(s) = W_N(s) - W_N(1-s)`. -/
noncomputable def windowDefectDN (N : ℕ) (s : ℂ) : ℂ :=
  partialEulerWindowFunction N s - partialEulerWindowFunction N (1 - s)

/-- Boundary interface: in the regularized channel, gamma/polynomial/trivial-zero
compensation drives `D_N(s)` to `0` along the window limit. -/
def WindowDefectDNTendstoZeroRegularizedBoundary : Prop :=
  ∀ s : ℂ, Filter.Tendsto (fun N : ℕ => windowDefectDN N s) Filter.atTop (nhds (0 : ℂ))

/-- Active regularized window-defect closure boundary assumption. -/
variable (windowDefectDN_tendsto_zero_regularized_boundary_assumption :
  WindowDefectDNTendstoZeroRegularizedBoundary)

/-- Project the regularized window-defect closure from the active boundary assumption. -/
theorem windowDefectDN_tendsto_zero_regularized (s : ℂ) :
    Filter.Tendsto (fun N : ℕ => windowDefectDN N s) Filter.atTop (nhds (0 : ℂ))
    := by
  exact windowDefectDN_tendsto_zero_regularized_boundary_assumption s

/-- Off the critical line, the defect factor medium cannot collapse:
eventual non-vanishing lower bound in norm (`|M_N(s)| ≥ δ`). -/
def OffCriticalMediumLowerBound : Prop :=
  ∀ s : ℂ, (0 < s.re ∧ s.re < 1) → s.re ≠ 1 / 2 →
    ∃ M : ℕ → ℂ → ℂ, ∃ δ : ℝ, 0 < δ ∧ ∃ N0 : ℕ, ∀ N : ℕ, N0 ≤ N → δ ≤ ‖M N s‖

/-- Bundled strong-defect boundary input used by the 2-D rigidity route. -/
def StrongDefectBoundaryInput : Prop :=
  (∀ (s : ℂ) (_h_nontrivial : 0 < s.re ∧ s.re < 1) (_h_off : s.re ≠ 1 / 2),
    ∃ M : ℕ → ℂ → ℂ,
      (∀ N : ℕ, ∀ z : ℂ,
        xi_partial_defect2D (prime_window N) z = ((lorentzian_x z : ℂ)) * M N z)
      ∧
      ∃ δ : ℝ, 0 < δ ∧ ∃ N0 : ℕ, ∀ N : ℕ, N0 ≤ N → δ ≤ ‖M N s‖)
  ∧
  (∀ s : ℂ,
    Filter.Tendsto (fun N : ℕ => xi_partial_defect2D (prime_window N) s) Filter.atTop
      (nhds (0 : ℂ)))

/-- Active bundled strong-defect boundary assumption. -/
variable
  (strongDefectProfile_assumption :
    ∀ (s : ℂ) (_h_nontrivial : 0 < s.re ∧ s.re < 1) (_h_off : s.re ≠ 1 / 2),
      ∃ M : ℕ → ℂ → ℂ,
        (∀ N : ℕ, ∀ z : ℂ,
          xi_partial_defect2D (prime_window N) z = ((lorentzian_x z : ℂ)) * M N z)
        ∧
        ∃ δ : ℝ, 0 < δ ∧ ∃ N0 : ℕ, ∀ N : ℕ, N0 ≤ N → δ ≤ ‖M N s‖)
  (strongDefectClosure_assumption :
    ∀ s : ℂ,
      Filter.Tendsto (fun N : ℕ => xi_partial_defect2D (prime_window N) s) Filter.atTop
        (nhds (0 : ℂ)))

/-- Final profile-local endpoint boundary projected from the bundled strong-defect input. -/
theorem xi_defect_profile_nonzero_off_critical (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1)
    (h_off : s.re ≠ 1 / 2) :
    ∃ M : ℕ → ℂ → ℂ,
      (∀ N : ℕ, ∀ z : ℂ,
        xi_partial_defect2D (prime_window N) z = ((lorentzian_x z : ℂ)) * M N z)
      ∧
      ∃ δ : ℝ, 0 < δ ∧ ∃ N0 : ℕ, ∀ N : ℕ, N0 ≤ N → δ ≤ ‖M N s‖ := by
  exact strongDefectProfile_assumption s h_nontrivial h_off

/-- Window-defect closure boundary projected from the bundled strong-defect input. -/
theorem xi_partial_defect2D_window_tendsto_zero (s : ℂ) :
    Filter.Tendsto (fun N : ℕ => xi_partial_defect2D (prime_window N) s) Filter.atTop
      (nhds (0 : ℂ)) := by
  exact strongDefectClosure_assumption s

/-- Final endpoint-axiom restatement (profile-local finite-window form).

Equivalent source/medium/sink statement:
at each off-critical strip point, the sink channel factors through source × medium,
and the medium at that point is eventually bounded away from `0`. -/
def final_gap_profile_axiom : Prop :=
  ∀ s : ℂ,
    (0 < s.re ∧ s.re < 1) →
    s.re ≠ 1 / 2 →
    ∃ M : ℕ → ℂ → ℂ,
      (∀ N : ℕ, ∀ z : ℂ,
        xi_partial_defect2D (prime_window N) z = ((lorentzian_x z : ℂ)) * M N z)
      ∧
      ∃ δ : ℝ, 0 < δ ∧ ∃ N0 : ℕ, ∀ N : ℕ, N0 ≤ N → δ ≤ ‖M N s‖

/-- The profile-local final endpoint axiom is exactly the active boundary axiom. -/
theorem final_gap_profile_axiom_holds : final_gap_profile_axiom := by
  intro s h_nontrivial h_off
  exact xi_defect_profile_nonzero_off_critical s h_nontrivial h_off

/-- Scalar compatibility restatement of the final endpoint boundary.
At sufficiently large windows, the defect at `s` factors with a nonzero scalar
coefficient bounded below in norm. -/
def final_gap_scalar_axiom : Prop :=
  ∀ s : ℂ,
    (0 < s.re ∧ s.re < 1) →
    s.re ≠ 1 / 2 →
    ∃ δ : ℝ, 0 < δ ∧ ∃ N0 : ℕ,
      ∀ N : ℕ, N0 ≤ N →
        ∃ m : ℂ,
          m ≠ 0
            ∧ xi_partial_defect2D (prime_window N) s = ((lorentzian_x s : ℂ)) * m
            ∧ δ ≤ ‖m‖

/-- Concrete normalized defect medium:
`M_N(s) = D_N(s) / (Re(s)-1/2)` in complex form. -/
noncomputable def normalized_window_defect_medium (N : ℕ) (s : ℂ) : ℂ :=
  xi_partial_defect2D (prime_window N) s / (lorentzian_x s : ℂ)

/-- Explicit lower-bound estimate for the concrete normalized medium
`M_N(s) = D_N(s)/(Re(s)-1/2)` away from the critical line. -/
theorem normalized_window_defect_medium_eventually_bounded_below_off_critical
    (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1)
    (h_off : s.re ≠ 1 / 2) :
    ∃ δ : ℝ, 0 < δ ∧ ∃ N0 : ℕ, ∀ N : ℕ, N0 ≤ N →
      δ ≤ ‖normalized_window_defect_medium N s‖ := by
  rcases xi_defect_profile_nonzero_off_critical s h_nontrivial h_off with
    ⟨M, hfac, δ, hδ_pos, N0, hδ⟩
  have hcoef_ne : (lorentzian_x s : ℂ) ≠ 0 := by
    unfold lorentzian_x
    exact_mod_cast (sub_ne_zero.mpr h_off)
  refine ⟨δ, hδ_pos, N0, ?_⟩
  intro N hN
  have hquot : normalized_window_defect_medium N s = M N s := by
    unfold normalized_window_defect_medium
    rw [hfac N s]
    field_simp [hcoef_ne]
  simpa [hquot] using hδ N hN

/-- Canonical remaining gateway target for Step-1:
the explicit normalized defect lower bound is the analytic input expected to drive
the lattice zero-limit boundary (`step1_F_lattice_boundary_assumption`). -/
def Step1FLatticeBoundaryGatewayTarget : Prop :=
  ∀ s : ℂ, (0 < s.re ∧ s.re < 1) → s.re ≠ 1 / 2 →
    ∃ δ : ℝ, 0 < δ ∧ ∃ N0 : ℕ, ∀ N : ℕ, N0 ≤ N →
      δ ≤ ‖normalized_window_defect_medium N s‖

/-- The current explicit normalized-medium lower-bound theorem realizes the canonical
Step-1 gateway target. -/
theorem Step1FLatticeBoundaryGatewayTarget_holds :
    Step1FLatticeBoundaryGatewayTarget := by
  intro s h_nontrivial h_off
  exact normalized_window_defect_medium_eventually_bounded_below_off_critical
    s h_nontrivial h_off

/-- Scalar compatibility follows from the profile-local finite-window boundary. -/
theorem final_gap_scalar_axiom_holds : final_gap_scalar_axiom := by
  intro s h_nontrivial h_off
  rcases xi_defect_profile_nonzero_off_critical s h_nontrivial h_off with ⟨M, hfac, δ, hδ_pos, N0, hδ⟩
  refine ⟨δ, hδ_pos, N0, ?_⟩
  intro N hN
  refine ⟨M N s, ?_, ?_, hδ N hN⟩
  · exact norm_ne_zero_iff.mp (ne_of_gt (lt_of_lt_of_le hδ_pos (hδ N hN)))
  · simpa using hfac N s

/-- Compatibility theorem (window-scalar form) retaining the historical name.
It extracts one nonzero scalar defect factor from the eventual finite-window profile. -/
theorem xi_gap_factor_nonzero_off_critical (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1)
    (_hshift : phase_lock_shift_constant_11_over_8)
    (_hdef2D : ∀ S : Finset ℕ, ∃ M : ℂ → ℂ, ∀ z : ℂ,
      xi_partial_defect2D S z = ((lorentzian_x z : ℂ)) * M z)
    (h_off : s.re ≠ 1 / 2) :
    ∃ N : ℕ, ∃ m : ℂ,
      m ≠ 0 ∧ xi_partial_defect2D (prime_window N) s = ((lorentzian_x s : ℂ)) * m := by
  rcases final_gap_scalar_axiom_holds s h_nontrivial h_off with ⟨δ, hδ_pos, N0, htail⟩
  rcases htail N0 le_rfl with ⟨m, hm_ne, hm_eq, _⟩
  exact ⟨N0, m, hm_ne, hm_eq⟩

/-- Delta-closure contradiction at an off-critical strip point.

The eventual lower bound `δ` from the profile channel forces the defect norm to stay
eventually above a fixed positive constant, while window-defect closure
forces the same defect norm to become eventually smaller than that constant. -/
theorem delta_closure_off_critical_absurd (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1)
    (h_off : s.re ≠ 1 / 2) : False := by
  rcases xi_defect_profile_nonzero_off_critical s h_nontrivial h_off with
    ⟨M, hfac, δ, hδ_pos, N0, hδ⟩
  have hcoef_ne : ((lorentzian_x s : ℂ)) ≠ 0 := by
    unfold lorentzian_x
    exact_mod_cast (sub_ne_zero.mpr h_off)
  have hcoef_norm_pos : 0 < ‖(lorentzian_x s : ℂ)‖ := by
    exact norm_pos_iff.mpr hcoef_ne
  let c : ℝ := ‖(lorentzian_x s : ℂ)‖ * δ
  have hc_pos : 0 < c := by
    exact mul_pos hcoef_norm_pos hδ_pos
  have hdefect_ge : ∀ N : ℕ, N0 ≤ N → c ≤ ‖xi_partial_defect2D (prime_window N) s‖ := by
    intro N hN
    have hnorm_eq : ‖xi_partial_defect2D (prime_window N) s‖ = ‖(lorentzian_x s : ℂ)‖ * ‖M N s‖ := by
      calc
        ‖xi_partial_defect2D (prime_window N) s‖ = ‖((lorentzian_x s : ℂ)) * M N s‖ := by
          simpa [hfac N s]
        _ = ‖(lorentzian_x s : ℂ)‖ * ‖M N s‖ := by
          simpa using norm_mul ((lorentzian_x s : ℂ)) (M N s)
    rw [hnorm_eq]
    exact mul_le_mul_of_nonneg_left (hδ N hN) (norm_nonneg _)
  have hzero_tendsto :
      Filter.Tendsto (fun N : ℕ => xi_partial_defect2D (prime_window N) s) Filter.atTop
        (nhds (0 : ℂ)) :=
    xi_partial_defect2D_window_tendsto_zero s
  have hsmall_eventually :
      ∀ᶠ N in Filter.atTop, ‖xi_partial_defect2D (prime_window N) s‖ < c := by
    have hball : Metric.ball (0 : ℂ) c ∈ nhds (0 : ℂ) :=
      Metric.ball_mem_nhds (0 : ℂ) hc_pos
    exact (hzero_tendsto hball).mono (by
      intro N hN
      simpa [Metric.mem_ball, dist_eq_norm] using hN)
  rcases Filter.eventually_atTop.1 hsmall_eventually with ⟨N1, hN1_tail⟩
  let N : ℕ := max N0 N1
  have hN0 : N0 ≤ N := le_max_left _ _
  have hN1 : N1 ≤ N := le_max_right _ _
  have hge : c ≤ ‖xi_partial_defect2D (prime_window N) s‖ := hdefect_ge N hN0
  have hlt : ‖xi_partial_defect2D (prime_window N) s‖ < c := hN1_tail N hN1
  exact (not_lt_of_ge hge) hlt

/-- 2-D defect-to-rigidity boundary theorem.

From the phase-lock shift and 2-D defect factor input, any open-strip point is
forced onto `Re(s)=1/2`. -/
theorem phase_lock_rigidity_from_2D_defect_boundary_strong (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1) :
    s.re = 1 / 2 := by
  by_contra h_off
  exact delta_closure_off_critical_absurd s h_nontrivial h_off

/-- Compatibility wrapper with the historical `xi s ∈ ℝ` hypothesis.
The proof route is now strictly stronger and no longer needs this input. -/
theorem phase_lock_rigidity_from_2D_defect_boundary (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1)
    (_h_real : xi s ∈ ℝ)
    (hshift : phase_lock_shift_constant_11_over_8)
    (hdef2D : ∀ S : Finset ℕ, ∃ M : ℂ → ℂ, ∀ z : ℂ,
      xi_partial_defect2D S z = ((lorentzian_x z : ℂ)) * M z) :
    s.re = 1 / 2 := by
  exact phase_lock_rigidity_from_2D_defect_boundary_strong s h_nontrivial

/-- Final theorem-level 2-D defect argument for rigidity in the open strip. -/
theorem phase_lock_defect_argument_2D_strong (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1) :
    s.re = 1 / 2 := by
  exact phase_lock_rigidity_from_2D_defect_boundary_strong s h_nontrivial

/-- Compatibility wrapper with the historical `xi s ∈ ℝ` hypothesis.
The 2-D defect route now proves rigidity without this input. -/
theorem phase_lock_defect_argument_2D (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1)
    (_h_real : xi s ∈ ℝ) :
    s.re = 1 / 2 := by
  exact phase_lock_defect_argument_2D_strong s h_nontrivial

/-- Named rigidity theorem routed through the strong 2-D defect argument. -/
theorem phase_lock_rigidity_strong (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1) :
    s.re = 1/2 :=
  phase_lock_defect_argument_2D_strong s h_nontrivial

/-- Compatibility wrapper with the historical `xi s ∈ ℝ` hypothesis.
This now delegates to `phase_lock_rigidity_strong`. -/
theorem phase_lock_rigidity (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1)
    (_h_real : xi s ∈ ℝ) :
    s.re = 1/2 :=
  phase_lock_rigidity_strong s h_nontrivial

/-- Compatibility name: legacy rigidity label, now a theorem rather than an axiom. -/
theorem xi_real_rigidity (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1)
    (h_real : xi s ∈ ℝ) :
    s.re = 1/2 :=
  phase_lock_rigidity s h_nontrivial h_real

/-- Explicit 2-D-defect-routed rigidity name (same theorem as `xi_real_rigidity`). -/
theorem xi_real_rigidity_via_2D_defect (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1)
    (h_real : xi s ∈ ℝ) :
    s.re = 1 / 2 :=
  xi_real_rigidity s h_nontrivial h_real

/-! ### Axiom Dependency Map

The remaining unformalized boundary is explicit and split into two layers.

Xi/log-derivative layer:
1. `xi_logderiv_formula` (prototype target; currently represented as explicit
  input to the reduction theorems below, not an active global assumption)
2. `xi_logderiv_symmetry_sum` (prototype target; currently represented by
  `xi_logderiv_symmetry_sum_of_xi_logderiv_formula` with explicit reflected-logderiv input)
3. `phase_velocity_on_critical_line` (consumed by
   `step1_phase_velocity_identity_of_assumption` into Step-1 frontier)
4. `completedRiemannZeta_factor_bridge_at_exceptional_lattice` (DISCHARGED)
  this boundary is now a proved theorem (`simp` on lattice sites `s = -2n`)
  and feeds directly into the global bridge theorem
5. `conjugationBoundaryInput_assumption`
  projects to `completedHurwitzZetaEven_zero_conj_of_ne_zero`; the theorem
  `hurwitzZetaEven_zero_conj` is now proved from this completed-level
  nonzero boundary together with `Gammaℝ_conj` and the explicit `s = 0` case
6. `phase_lock_shift_constant_11_over_8` (definitional marker, inhabited by
  `phase_lock_shift_constant_11_over_8_holds`)
7. `xi_partial_defect2D_factor_boundary` (localized compatibility input for
  `defect_factors`, not an active global assumption)
8. `strongDefectBoundaryInput_assumption`
  bundled strong-defect boundary input; projects to:
  - `xi_defect_profile_nonzero_off_critical`
  - `xi_partial_defect2D_window_tendsto_zero`
  and yields `phase_lock_rigidity_from_2D_defect_boundary_strong`

Reduced boundary core (prototype reductions now formalized):
1. Item 2 reduces to item 1 plus reflected ξ-log-derivative input:
  `xi_logderiv_symmetry_sum_of_xi_logderiv_formula`
2. Item 3 reduces to item 1 plus line chain-rule + slit-plane branch input:
  `phase_velocity_on_critical_line_of_xi_logderiv_formula`
3. Item 5 now has two prototype routes:
  - `completedHurwitzZetaEven_zero_conj_of_ne_zero_of_completedRiemannZeta_conj`
  - `completedHurwitzZetaEven_zero_conj_of_ne_zero_of_riemannZeta_conj`
4. Reverse bridge exposed explicitly:
  `completedRiemannZeta_conj_of_riemannZeta_conj`
  (used to isolate circularity and minimize independent boundary inputs)

Window-limit closure layer:
1. `missingPrimeCore_cauchy_tail` (consumed by
  `step1_tail_control_of_missingPrimeCore_cauchy_tail`)
2. `partialEulerPhaseVelocity_window_tendsto` (consumed by
  `step1_velocity_transfer_of_partialEulerPhaseVelocity_window_tendsto`)
3. `Step1ReducedFrontier_assumption`
4. `zeta_zero_is_limit_of_window_zeros` (derived from item 3 via
  `step1_approximation_frontier_of_reduced`)
5. `PhaseLockLatticeBridge` / `phase_lock_lattice_bridge_holds`
6. `phase_lock_from_F_lattice_limit`
7. `phase_lock_from_window_limit` (legacy wrapper derived from item 5)

Endpoint dependency sketch:
`rh_endpoint_master`
  <- `conditional_RH_via_window_limits_with_bridge`
  <- `conditional_RH_via_window_limits`
  <- `conditional_RH_via_torus_compatibility_frontier`
  <- `conditional_RH_via_two_axiom_frontier`
  <- `phase_lock_passes_to_limit` (legacy naming)
  <- `phase_lock_passes_to_limit_2D` (Lorentzian 2-D naming bridge)
  <- lattice-native phase-lock transfer and `phase_lock_rigidity`.

Minimal strong-defect frontier (alternative route):
1. `xi_defect_profile_nonzero_off_critical`
2. `xi_partial_defect2D_window_tendsto_zero`

Window-limit packaging frontier (primary route for `conditional_RH_via_window_limits` / `rh_endpoint_master`):
1. (not used in strong-defect route)
2. `xi_partial_defect2D_window_tendsto_zero`
3. `Step1ReducedFrontier_assumption`
4. `phase_lock_from_F_lattice_limit`

Unified torus-compatibility frontier (canonical top-level interface):
1. `TorusCompatibilityFrontier := StrongDefectFrontier ∧ WindowLimitFrontier`
2. `torusCompatibilityDefect_tendsto_zero_of_strongDefectFrontier`
3. `torusPhaseLock_of_window_limit_frontier`
4. `conditional_RH_via_torus_compatibility_frontier`

Compressed endpoint interface (theorem-level, 2 items):
1. zero-limit existence (same as item 2 above)
2. direct pass-to-limit forcing (`conditional_RH_via_two_axiom_frontier` interface)

Critical-line realness subchain:
1. `Gammaℝ_critical_line_ne_zero`
2. `completedRiemannZeta_factor_bridge_of_gammaR_ne_zero`
3. `critical_line_factor_symmetry`
4. `xi_functional_equation_on_critical_line`
5. `xi_critical_line_t_flip`
6. `xi_real_on_critical_line`

Nontrivial-strip rigidity subchain:
1. `xi_defect_profile_nonzero_off_critical`
2. `xi_functional_equation`
3. consumed inside `phase_lock_rigidity_from_2D_defect_boundary_strong`
-/

/-- Nontrivial-strip hypothesis implies the lower bound `0 ≤ Re(s)`. -/
lemma re_nonneg_of_nontrivial_strip (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1) :
    0 ≤ s.re :=
  le_of_lt h_nontrivial.1

/-- Nontrivial-strip hypothesis gives the closed-strip bounds `0 ≤ Re(s) ≤ 1`. -/
lemma re_closed_strip_bounds (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1) :
    0 ≤ s.re ∧ s.re ≤ 1 := by
  exact ⟨le_of_lt h_nontrivial.1, le_of_lt h_nontrivial.2⟩

/-- In the nontrivial strip, `|Re(s)| = Re(s)` since `Re(s) > 0`. -/
lemma abs_re_eq_re_of_nontrivial_strip (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1) :
    |s.re| = s.re := by
  exact abs_of_nonneg (le_of_lt h_nontrivial.1)

/-- Absolute-value form of the strip upper bound: `|Re(s)| < 1`. -/
lemma abs_re_lt_one_of_nontrivial_strip (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1) :
    |s.re| < 1 := by
  rw [abs_re_eq_re_of_nontrivial_strip s h_nontrivial]
  exact h_nontrivial.2

/-- If ξ(s) is real and 0 < Re(s) < 1, then Re(s) = 1/2. -/
lemma xi_real_only_on_critical_line (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1)
    (_h_real : xi s ∈ ℝ) :
    s.re = 1/2 := by
  exact phase_lock_rigidity_strong s h_nontrivial

/-- Strip rigidity in strong form: no realness hypothesis is needed on `xi s`. -/
lemma strip_rigidity_from_2D_defect (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1) :
    s.re = 1/2 := by
  exact phase_lock_rigidity_strong s h_nontrivial

/-- Conditional RH step in this development:
if `s` is a nontrivial-strip zero of `ζ`, then `Re(s)=1/2`.

The only external ingredient is theorem-level strip rigidity from the 2-D defect route. -/
theorem nontrivial_zeta_zero_on_critical_line (s : ℂ)
    (hz : riemannZeta s = 0)
    (h_nontrivial : 0 < s.re ∧ s.re < 1) :
    s.re = 1/2 := by
  exact strip_rigidity_from_2D_defect s h_nontrivial

/-- Primary RH endpoint routed through the window-limit frontier.

This is the main theorem packaged for direct use. It relies on:
1. Zeta zeros are limits of finite-window zeros (`zeta_zero_is_limit_of_window_zeros`).
2. Phase-lock persists at those limits (`phase_lock_from_window_limit`).

An alternative purely algebraic strong-defect route is available via
`conditional_RH_from_strong_defect_frontier` for those who prefer that approach. -/
theorem conditional_RH :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1/2 := by
  intro s hz hstrip
  exact conditional_RH_via_window_limits s hz hstrip

/-- Real-axis zero classification: every zero of ζ on the real axis
is a trivial zero (negative even integer).

Proof ingredients needed:
1. ζ(s) ≠ 0 for s : ℝ with s > 1        (Euler product, positivity)
2. ζ(s) ≠ 0 for s : ℝ with 0 < s ≤ 1   (pole at s=1, positivity near 1)
3. ζ(1/2) ≠ 0                             (numerical / special value)
4. ζ(s) ≠ 0 for s : ℝ with -1 < s < 0   (functional equation + above)
5. ζ(-2n-1) ≠ 0 for n : ℕ               (odd negative integers, Bernoulli)
6. ζ(s) = 0 for s = -2n                  (riemannZeta_neg_two_mul_nat_add_one ✓)
7. No other real zeros                     (combine 1-6 by interval analysis)

Mathlib status:
✓ riemannZeta_neg_two_mul_nat_add_one     (trivial zeros exist)
✓ riemannZeta_one_ne_zero / pole at 1
✓ nonvanishing on `Re ≥ 1` (`riemannZeta_ne_zero_of_one_le_re`)
✗ full real-axis classification           (not in Mathlib — `(0,1)` interval still an analytic boundary below)
-/

/-- Even-index Bernoulli numbers `B_{2k}` are nonzero for `k ≥ 1` (equivalently `2k ≥ 2`):

for such `k`, `ζ(2k) > 0` as a real argument (`riemannZeta_pos_of_one_lt`), while
`riemannZeta_two_mul_nat` rewrites `ζ(2k)` as a nonzero prefactor times `bernoulli (2 * k)`.
-/
lemma bernoulli_two_mul_ne_zero {k : ℕ} (hk : k ≠ 0) : bernoulli (2 * k) ≠ 0 := by
  have hk1_nat : 1 < 2 * k := by
    have hk0 : 0 < k := Nat.pos_of_ne_zero hk
    omega
  have hk1 : 1 < (2 * k : ℝ) := by exact_mod_cast hk1_nat
  have hζpos : 0 < riemannZeta (2 * k : ℝ) := riemannZeta_pos_of_one_lt hk1
  intro hb
  have hζ0 : riemannZeta (2 * k : ℂ) = 0 := by
    simpa [hb, mul_zero] using (riemannZeta_two_mul_nat hk).symm
  have hζpos' : 0 < riemannZeta (2 * k : ℂ) := by
    simpa only [Nat.cast_ofNat] using hζpos
  exact (ne_of_gt hζpos') hζ0.symm

/-- Any real zero in the open unit interval must lie at `x = 1/2` by strip rigidity. -/
lemma riemannZeta_real_zero_in_Ioo_01_eq_half (x : ℝ)
    (h01 : 0 < x ∧ x < 1)
    (hz : riemannZeta ((x : ℝ) : ℂ) = 0) :
    x = 1 / 2 := by
  have hstrip : 0 < (((x : ℝ) : ℂ)).re ∧ (((x : ℝ) : ℂ)).re < 1 := by
    simpa using h01
  have hre : (((x : ℝ) : ℂ)).re = (1 / 2 : ℝ) :=
    phase_lock_rigidity_strong ((x : ℝ) : ℂ) hstrip
  simpa using hre

/-- Numeric certificate interface at the strip midpoint.

Provide a real center `c` and error bar `ε` with
`‖ζ(1/2) - c‖ ≤ ε < |c|`; this forces `ζ(1/2) ≠ 0`.

**Proof idea (see `riemannZeta_ne_zero_at_half_of_numeric_certificate`):** if `ζ(1/2)=0` then
`‖c‖ = ‖ζ(1/2)-c‖ ≤ ε`, contradicting `ε < |c|`. Equivalently, triangle inequality gives
`‖ζ(1/2)‖ ≥ |c| - ε > 0`.

**Illustrative constants (not proved here):** classically `ζ(1/2) ≈ -1.4603545…`; one might
aim for e.g. `c = -1.46`, `ε = 0.01` once a certified bound
`‖ζ(1/2) - c‖ ≤ ε` is available in Lean (interval arithmetic / trusted numerics).
-/
def RiemannZetaHalfNumericCertificate : Prop :=
    ∃ c ε : ℝ,
      0 ≤ ε ∧ ε < |c| ∧
      ‖riemannZeta (((1 / 2 : ℝ) : ℂ)) - (c : ℂ)‖ ≤ ε

/-- Active midpoint numeric-certificate boundary assumption. -/
variable (riemannZeta_half_numeric_certificate_assumption :
  RiemannZetaHalfNumericCertificate)

/-- Stronger theorem-level midpoint boundary interface. -/
def RiemannZetaHalfNonvanishingBoundary : Prop :=
  riemannZeta (((1 / 2 : ℝ) : ℂ)) ≠ 0

/-- Project the midpoint numeric certificate from the active boundary assumption. -/
theorem riemannZeta_half_numeric_certificate :
    ∃ c ε : ℝ,
      0 ≤ ε ∧ ε < |c| ∧
      ‖riemannZeta (((1 / 2 : ℝ) : ℂ)) - (c : ℂ)‖ ≤ ε := by
  exact riemannZeta_half_numeric_certificate_assumption

/-- Any valid midpoint numeric certificate yields `ζ(1/2) ≠ 0`. -/
theorem riemannZeta_ne_zero_at_half_of_numeric_certificate
    {c ε : ℝ}
    (hε : 0 ≤ ε)
    (hsep : ε < |c|)
    (happrox : ‖riemannZeta (((1 / 2 : ℝ) : ℂ)) - (c : ℂ)‖ ≤ ε) :
    riemannZeta (((1 / 2 : ℝ) : ℂ)) ≠ 0 := by
  intro hz
  have hc_le : |c| ≤ ε := by
    have hnorm : ‖(c : ℂ)‖ ≤ ε := by
      simpa [hz, sub_eq_add_neg, norm_neg] using happrox
    simpa using hnorm
  exact (not_le_of_gt hsep) hc_le

/-- Single-point boundary at the strip midpoint (`ζ(1/2) ≠ 0`), extracted from
the numeric certificate interface above. -/
theorem riemannZeta_ne_zero_at_half_of_numeric_certificate_boundary :
    riemannZeta (((1 / 2 : ℝ) : ℂ)) ≠ 0 := by
  rcases riemannZeta_half_numeric_certificate with ⟨c, ε, hε, hsep, happrox⟩
  exact riemannZeta_ne_zero_at_half_of_numeric_certificate hε hsep happrox

/-- The numeric-certificate boundary implies the stronger midpoint nonvanishing boundary. -/
theorem riemannZeta_half_nonvanishing_boundary_of_numeric_certificate_boundary :
    RiemannZetaHalfNonvanishingBoundary := by
  exact riemannZeta_ne_zero_at_half_of_numeric_certificate_boundary

/-- Single-point boundary at the strip midpoint (`ζ(1/2) ≠ 0`), routed through
the numeric-certificate boundary interface. -/
theorem riemannZeta_ne_zero_at_half : riemannZeta (((1 / 2 : ℝ) : ℂ)) ≠ 0 := by
  exact riemannZeta_half_nonvanishing_boundary_of_numeric_certificate_boundary

/-- **Analytic boundary (open unit interval):** ζ has no real zero with `0 < x < 1`.

Using strip rigidity, this reduces to the midpoint nonvanishing boundary
`riemannZeta_ne_zero_at_half`. -/
theorem riemannZeta_real_no_zero_in_Ioo_01 (x : ℝ) (h01 : 0 < x ∧ x < 1) :
    riemannZeta ((x : ℝ) : ℂ) ≠ 0 := by
  intro hz
  have hx : x = 1 / 2 := riemannZeta_real_zero_in_Ioo_01_eq_half x h01 hz
  have hhalf := riemannZeta_ne_zero_at_half
  simpa [hx] using hhalf

/-- At odd negative integers, `ζ` is nonzero (Bernoulli layer; Mathlib-native). -/
theorem riemannZeta_ne_zero_at_neg_odd_nat (m : ℕ) (hm : 0 < m) (hodd : m % 2 = 1) :
    riemannZeta (-(m : ℝ) : ℂ) ≠ 0 := by
  have hcast : (-(m : ℝ) : ℂ) = (-m : ℂ) := by simp
  rw [hcast, riemannZeta_neg_nat_eq_bernoulli m]
  refine div_ne_zero ?_ ?_
  · refine mul_ne_zero ?_ ?_
    · simpa [← neg_one_pow_eq_pow] using pow_ne_zero m (by norm_num : (-1 : ℂ) ≠ 0)
    · have m1mod : (m + 1) % 2 = 0 := by rw [Nat.add_mod, hodd]
      have hdvd : 2 ∣ m + 1 := Nat.dvd_of_mod_eq_zero m1mod
      rcases hdvd with ⟨k, hk⟩
      have hk_ne : k ≠ 0 := by
        rintro rfl
        simp at hk
        linarith only [hm]
      rw [hk]
      exact bernoulli_two_mul_ne_zero hk_ne
  · simpa using (Nat.cast_ne_zero.mpr (Nat.succ_ne_zero m) : (m + 1 : ℂ) ≠ 0)

theorem real_axis_zeta_zero_onTrivialZeroLine (s : ℂ)
    (hz : riemannZeta s = 0)
    (him : s.im = 0) :
    onTrivialZeroLine s := by
  have hs_real : s = (s.re : ℂ) := by
    ext <;> simp [him]
  rw [hs_real] at hz
  have hz_real : riemannZeta ((s.re : ℝ) : ℂ) = 0 := hz
  have hlt_one : s.re < 1 := by
    by_contra hnot
    have hge : 1 ≤ s.re := by linarith
    exact (riemannZeta_ne_zero_of_one_le_re (s := ((s.re : ℝ) : ℂ))
      (by simpa using hge)) hz_real
  have hne_zero : s.re ≠ 0 := by
    intro hs0
    have hz0 : riemannZeta (0 : ℂ) = 0 := by
      simpa [hs0] using hz_real
    have hz0' : riemannZeta (0 : ℂ) = -(1 / 2 : ℂ) := by
      simpa using riemannZeta_zero
    linarith [hz0, hz0']
  rcases lt_trichotomy s.re 0 with hneg | hzero | hpos
  · -- Negative real: either trivial line or contradiction with ζ ≠ 0 lemmas.
    by_cases hT : ∃ n : ℕ, s.re = -(2 * (n + 1) : ℝ)
    · rcases hT with ⟨n, hn⟩
      refine ⟨n, ?_⟩
      rw [hs_real, hn]
      ext <;> simp [him] <;> norm_cast
    · exfalso
      by_cases hN : ∃ m : ℕ, s.re = -(m : ℝ)
      · rcases hN with ⟨m, hm⟩
        have hm_re : s.re = -(m : ℝ) := by exact_mod_cast hm
        have hm_pos : 0 < m := by
          by_contra hmnp
          push_neg at hmnp
          have hm0 : m = 0 := Nat.eq_zero_of_not_pos hmnp
          subst hm0
          simp at hm_re
          linarith
        rcases Nat.mod_two_eq_zero_or_one m with heven | hodd
        · -- `m` even: then `s.re` lies on the trivial-zero line — contradicts `¬hT`.
          have hdvd : 2 ∣ m := Nat.dvd_of_mod_eq_zero heven
          rcases hdvd with ⟨k, hk⟩
          have hk_pos : 0 < k := by
            by_contra hk0
            push_neg at hk0
            have hk0' : k = 0 := Nat.eq_zero_of_not_pos hk0
            subst hk0'
            simp at hk
            subst hk
            linarith [hm_pos]
          have hex : ∃ n : ℕ, s.re = -(2 * (n + 1) : ℝ) := by
            use k - 1
            rw [hm_re, hk]
            simp only [Nat.cast_mul, Nat.cast_add, Nat.cast_one]
            congr 1
            rw [Nat.mul_assoc, Nat.two_mul]
            have hk_eq : k = (k - 1) + 1 :=
              (Nat.succ_pred_eq_of_pos hk_pos).symm
            rw [hk_eq]
            ring
          exact hT hex
        · -- `m` odd: excluded by `riemannZeta_ne_zero_at_neg_odd_nat`.
          have hζ0 := riemannZeta_ne_zero_at_neg_odd_nat m hm_pos hodd
          have hζ : riemannZeta ((s.re : ℝ) : ℂ) ≠ 0 := by
            simpa [hm_re] using hζ0
          exact hζ hz_real
      · push_neg at hN
        have hnot_int :
            ∀ n : ℕ, ((s.re : ℝ) : ℂ) ≠ -(n : ℂ) := by
          intro n hn
          apply hN
          use n
          apply_fun Complex.re at hn
          simpa using hn
        exact (riemannZeta_real_ne_zero_of_lt_zero_not_neg_nat s.re hneg hnot_int) hz_real
  · -- `s.re = 0`: impossible.
    exfalso
    rw [hzero] at hz_real
    exact riemannZeta_real_ne_zero_at_zero hz_real
  · -- `0 < s.re < 1`: no real zeros on this interval (boundary axiom).
    exfalso
    exact riemannZeta_real_no_zero_in_Ioo_01 s.re ⟨hpos, hlt_one⟩ hz_real

/-- Real-axis nonvanishing on the half-line `x ≥ 1` (Mathlib nonvanishing frontier). -/
lemma riemannZeta_real_ne_zero_of_one_le (x : ℝ) (hx : 1 ≤ x) :
    riemannZeta ((x : ℝ) : ℂ) ≠ 0 := by
  exact riemannZeta_ne_zero_of_one_le_re (s := ((x : ℝ) : ℂ)) (by simpa using hx)

/-- Endpoint nonvanishing at `x = 0`: `ζ(0) = -1/2`. -/
lemma riemannZeta_real_ne_zero_at_zero :
    riemannZeta ((0 : ℝ) : ℂ) ≠ 0 := by
  intro hz0
  have hz0' : riemannZeta (0 : ℂ) = -(1 / 2 : ℂ) := by
    simpa using riemannZeta_zero
  linarith [hz0, hz0']

/-- Pilot interval nonvanishing: no real zeta zeros on `(-1,0)`. -/
lemma riemannZeta_real_ne_zero_on_neg_one_lt_lt_zero (x : ℝ)
    (hx1 : -1 < x) (hx0 : x < 0) :
    riemannZeta ((x : ℝ) : ℂ) ≠ 0 := by
  intro hz
  have hx_ne_one : ((x : ℝ) : ℂ) ≠ 1 := by
    intro hxeq
    have : x = 1 := by exact_mod_cast hxeq
    linarith
  have hnot_nat : ∀ n : ℕ, ((x : ℝ) : ℂ) ≠ -n := by
    intro n
    intro hn
    have hre : x = -(n : ℝ) := by
      exact_mod_cast hn
    have hle : x ≤ -1 := by
      have hn1 : (1 : ℕ) ≤ n := by
        by_contra h
        have hn0 : n = 0 := Nat.eq_zero_of_not_pos (not_lt.mp h)
        subst hn0
        have : x = 0 := by simpa using hre
        linarith
      have : (1 : ℝ) ≤ n := by exact_mod_cast hn1
      linarith [hre, this]
    linarith
  have hfe := riemannZeta_one_sub (s := ((x : ℝ) : ℂ)) hnot_nat hx_ne_one
  have hz_one_sub : riemannZeta (1 - ((x : ℝ) : ℂ)) = 0 := by
    simpa [hz] using hfe
  have hge : 1 ≤ (1 - ((x : ℝ) : ℂ)).re := by
    simp
    linarith
  exact (riemannZeta_ne_zero_of_one_le_re (s := 1 - ((x : ℝ) : ℂ)) hge) hz_one_sub

/-- General negative real nonvanishing off the exceptional lattice `x = -n`. -/
lemma riemannZeta_real_ne_zero_of_lt_zero_not_neg_nat (x : ℝ)
    (hx : x < 0)
    (hnot : ∀ n : ℕ, ((x : ℝ) : ℂ) ≠ -(n : ℂ)) :
    riemannZeta ((x : ℝ) : ℂ) ≠ 0 := by
  intro hz
  have hx_ne_one : ((x : ℝ) : ℂ) ≠ 1 := by
    intro hxeq
    have : x = 1 := by exact_mod_cast hxeq
    linarith
  have hfe := riemannZeta_one_sub (s := ((x : ℝ) : ℂ)) hnot hx_ne_one
  have hz_one_sub : riemannZeta (1 - ((x : ℝ) : ℂ)) = 0 := by
    simpa [hz] using hfe
  have hge : 1 ≤ (1 - ((x : ℝ) : ℂ)).re := by
    simp
    linarith
  exact (riemannZeta_ne_zero_of_one_le_re (s := 1 - ((x : ℝ) : ℂ)) hge) hz_one_sub

/-! ### Dependency checklist for real_axis_zeta_zero_onTrivialZeroLine

INTERVAL ANALYSIS on ℝ:

[x] s > 1:
    riemannZeta_pos_of_real_gt_one : ∀ x : ℝ, 1 < x → 0 < riemannZeta x
    → no zeros here

[x] s = 1:
    riemannZeta has pole → not zero by convention
    → no zero here

[x] 0 < s < 1:
    discharged via boundary axiom `riemannZeta_real_no_zero_in_Ioo_01`

[x] s = 0:
    riemannZeta_zero : riemannZeta 0 = -1/2 ≠ 0   ✓ IN MATHLIB
    → not a zero

[x] -1 < s < 0:
    functional equation: ζ(s) = χ(s)·ζ(1-s)
    1-s ∈ (1,2) → ζ(1-s) > 0
    χ(s) = 2^s·π^(s-1)·sin(πs/2)·Γ(1-s) ≠ 0 for non-integer s
    → no zeros here

[x] Generic negative non-integer points:
    if x < 0 and x ≠ -n for all n : ℕ, then ζ(x) ≠ 0
    (`riemannZeta_real_ne_zero_of_lt_zero_not_neg_nat`)

[ ] s = -1:
    riemannZeta_neg_one : riemannZeta (-1) = -1/12 ≠ 0
    → not a zero

[ ] s = -2:
    riemannZeta_neg_two_mul_nat_add_one (n=0) : ζ(-2) = 0   ✓
    → trivial zero ✓

[ ] s ∈ (-2n-2, -2n) for n : ℕ:
    functional equation + sin(πs/2) ≠ 0 for non-even-integer s
    + ζ(1-s) ≠ 0 (since 1-s > 1)
    → no zeros on open intervals between trivial zeros

[x] s = -(2n+1) for n : ℕ (odd negative integers):
    `riemannZeta_ne_zero_at_neg_odd_nat` ✓ (Bernoulli / `riemannZeta_neg_nat_eq_bernoulli`)

[ ] s = -2(n+1) for n : ℕ:
    riemannZeta_neg_two_mul_nat_add_one   ✓ IN MATHLIB
    → trivial zeros ✓

CONCLUSION: only zeros on ℝ are s = -2,-4,-6,...
= onTrivialZeroLine  □
-/

-- Fastest Mathlib search targets:
-- #check riemannZeta_zero          -- ζ(0) = -1/2
-- #check riemannZeta_neg_one       -- ζ(-1) = -1/12
-- #check riemannZeta_pos_of_one_lt -- ζ(x) > 0 for x > 1
-- #check riemannZeta_ne_zero_of_one_lt_re  -- off real axis
-- #check Complex.sin_ne_zero_iff   -- sin(πs/2) ≠ 0

/-- Any point on the trivial-zero line is on the negative real axis. -/
lemma onTrivialZeroLine_im_zero_re_neg (s : ℂ)
    (htriv : onTrivialZeroLine s) :
    s.im = 0 ∧ s.re < 0 := by
  rcases htriv with ⟨n, hn⟩
  constructor
  · rw [hn]
    simp
  · rw [hn]
    norm_num

/-- Real-axis zeta zeros are negative (derived via the trivial-zero-line classifier). -/
theorem trivial_zero_re_neg (s : ℂ)
    (hz : riemannZeta s = 0) (him : s.im = 0) :
    s.re < 0 := by
  exact (onTrivialZeroLine_im_zero_re_neg s
    (real_axis_zeta_zero_onTrivialZeroLine s hz him)).2

/-- Complete separation schema between trivial-axis and nontrivial-strip zero branches.

Trivial zeros are handled on the real axis (`Im=0`, `Re<0`), while nontrivial zeros
(`Im ≠ 0`) route through the strip hypothesis to the critical line via `conditional_RH`. -/
theorem RH_complete_separation :
    ∀ s : ℂ, riemannZeta s = 0 →
      (s.im = 0 ∧ s.re < 0)
      ∨
      (s.im ≠ 0 → (0 < s.re ∧ s.re < 1) → s.re = 1/2) := by
  intro s hz
  by_cases him : s.im = 0
  · left
    exact ⟨him, trivial_zero_re_neg s hz him⟩
  · right
    intro _ hstrip
    exact conditional_RH s hz hstrip

/-- **Scale-indexed restatement (documentation).**

The packaged conclusion `Re(s)=1/2` for a nontrivial-strip zeta zero does not involve
the Gaussian dilation index `k` or `gaussianScaleFactor k`. This `∀ k, …` shape makes
that independence explicit: the proof is the same at every auxiliary scale.

It is **not** a separate analytic statement that zeros align with `(1+i)^k ℤ[i]`; any
such lattice refinement would need its own hypotheses. -/
theorem rh_scale_invariant (k : ℕ) (s : ℂ)
    (hz : riemannZeta s = 0) (hstrip : 0 < s.re ∧ s.re < 1) :
    s.re = (1 / 2 : ℝ) :=
  conditional_RH s hz hstrip

/-- Scale-indexed package: the Gaussian-cell area law and RH conclusion coexist uniformly in `k`.

This theorem keeps the geometric scale marker explicit:
`(abs (gaussianScaleFactor k))^2 = 2^k` while the strip-zero conclusion remains `Re(s)=1/2`. -/
theorem rh_scale_invariant_with_area (k : ℕ) (s : ℂ)
    (hz : riemannZeta s = 0) (hstrip : 0 < s.re ∧ s.re < 1) :
    (Complex.abs (gaussianScaleFactor k)) ^ 2 = (2 : ℝ) ^ k ∧ s.re = (1 / 2 : ℝ) := by
  refine ⟨gaussianScaleFactor_area k, ?_⟩
  exact rh_scale_invariant k s hz hstrip

/-- Scale-indexed package with all three channels:
area growth (`2^k`), 8-step phase cycle (`+8` gives real factor `16`), and RH conclusion. -/
theorem rh_scale_invariant_with_area_and_phase_cycle (k : ℕ) (s : ℂ)
    (hz : riemannZeta s = 0) (hstrip : 0 < s.re ∧ s.re < 1) :
    (Complex.abs (gaussianScaleFactor k)) ^ 2 = (2 : ℝ) ^ k
      ∧ gaussianScaleFactor (k + 8) = (16 : ℂ) * gaussianScaleFactor k
      ∧ Complex.arg (gaussianScaleFactor (k + 8)) = Complex.arg (gaussianScaleFactor k)
      ∧ s.re = (1 / 2 : ℝ) := by
  refine ⟨gaussianScaleFactor_area k, gaussianScaleFactor_phase_cycle k,
    gaussianScaleFactor_arg_periodic_8 k, ?_⟩
  exact rh_scale_invariant k s hz hstrip

/-- Master scale package:
induction form + phase/magnitude/area channels + `Phase8` index bridge + RH conclusion. -/
theorem rh_scale_master (k : ℕ) (s : ℂ)
    (hz : riemannZeta s = 0) (hstrip : 0 < s.re ∧ s.re < 1) :
    gaussianScaleFactor 0 = (1 : ℂ) ∧
      gaussianScaleFactor (k + 1) = B_canonical * gaussianScaleFactor k ∧
      Complex.abs (gaussianScaleFactor k) = (Real.sqrt 2 : ℝ) ^ k ∧
      (Complex.abs (gaussianScaleFactor k)) ^ 2 = (2 : ℝ) ^ k ∧
      gaussianScaleFactor k
        = ((Real.sqrt 2 : ℝ) ^ k : ℂ) * Complex.exp (((k : ℝ) * (Real.pi / 4)) * Complex.I) ∧
      s.re = (1 / 2 : ℝ) := by
  rcases gaussianScaleFactor_induction_form k with ⟨h0, hsucc⟩
  rcases gaussianScaleFactor_phase_magnitude_area k with ⟨habs, harea, hphase⟩
  refine ⟨h0, hsucc, habs, harea, hphase, ?_⟩
  exact rh_scale_invariant k s hz hstrip

/-- Explicit reduction theorem: the RH conclusion proved in this file factors
through theorem-level rigidity (`phase_lock_rigidity`/`xi_real_rigidity`) and the
named analytic boundary axioms, rather than
through any hidden `sorry`. -/
theorem RH_reduction_to_rigidity_boundary :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1/2 := by
  exact conditional_RH

/-- On the critical line, conjugation flips `+t` to `-t`. -/
lemma critical_line_conj_plus_minus (t : ℝ) :
    conj ((1 / 2 : ℂ) + t * Complex.I) = (1 / 2 : ℂ) - t * Complex.I := by
  simp [sub_eq_add_neg, mul_comm, mul_left_comm, mul_assoc]

/-- On the critical line, the real part stays fixed at `1/2`. -/
lemma critical_line_re_fixed (t : ℝ) :
    (((1 / 2 : ℂ) + t * Complex.I).re) = (1 / 2 : ℝ) := by
  simp

/-- Conjugation on the critical line keeps `Re` and flips the sign of `Im`. -/
lemma critical_line_im_sign_flip (t : ℝ) :
    (conj ((1 / 2 : ℂ) + t * Complex.I)).im =
      -(((1 / 2 : ℂ) + t * Complex.I).im) := by
  simp

/-- ξ-conjugation specializes to the `t ↔ -t` flip on the critical line. -/
lemma xi_critical_line_t_flip (t : ℝ) :
    conj (xi ((1 / 2 : ℂ) + t * Complex.I)) = xi ((1 / 2 : ℂ) - t * Complex.I) := by
  simpa [critical_line_conj_plus_minus t] using xi_conj ((1 / 2 : ℂ) + t * Complex.I)

/-- `Gammaℝ` does not vanish on the critical line. -/
lemma Gammaℝ_critical_line_ne_zero (t : ℝ) :
    Gammaℝ ((1 / 2 : ℂ) + t * Complex.I) ≠ 0 := by
  intro h
  rw [Gammaℝ_eq_zero_iff] at h
  rcases h with ⟨n, hn⟩
  have hre := congrArg Complex.re hn
  simp at hre
  positivity

/-- On the critical line, the explicit π/Gamma/ζ factor inherits the completed-zeta symmetry
without any extra axiom. -/
lemma critical_line_factor_symmetry (t : ℝ) :
    ((Real.pi : ℂ) ^ (-(((1 / 2 : ℂ) - t * Complex.I) / 2)))
        * Complex.Gamma ((((1 / 2 : ℂ) - t * Complex.I) / 2))
        * riemannZeta ((1 / 2 : ℂ) - t * Complex.I)
      = ((Real.pi : ℂ) ^ (-(((1 / 2 : ℂ) + t * Complex.I) / 2)))
        * Complex.Gamma ((((1 / 2 : ℂ) + t * Complex.I) / 2))
        * riemannZeta ((1 / 2 : ℂ) + t * Complex.I) := by
  calc
    ((Real.pi : ℂ) ^ (-(((1 / 2 : ℂ) - t * Complex.I) / 2)))
        * Complex.Gamma ((((1 / 2 : ℂ) - t * Complex.I) / 2))
        * riemannZeta ((1 / 2 : ℂ) - t * Complex.I)
      = completedRiemannZeta ((1 / 2 : ℂ) - t * Complex.I) := by
          apply completedRiemannZeta_factor_bridge_of_gammaR_ne_zero
          simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc, mul_comm, mul_left_comm,
            mul_assoc] using Gammaℝ_critical_line_ne_zero (-t)
    _ = completedRiemannZeta ((1 / 2 : ℂ) + t * Complex.I) := by
          simpa [sub_eq_add_neg, add_assoc, add_left_comm, add_comm, mul_comm, mul_left_comm,
            mul_assoc] using completedRiemannZeta_one_sub ((1 / 2 : ℂ) + t * Complex.I)
    _ = ((Real.pi : ℂ) ^ (-(((1 / 2 : ℂ) + t * Complex.I) / 2)))
        * Complex.Gamma ((((1 / 2 : ℂ) + t * Complex.I) / 2))
        * riemannZeta ((1 / 2 : ℂ) + t * Complex.I) := by
          exact (completedRiemannZeta_factor_bridge_of_gammaR_ne_zero
            (Gammaℝ_critical_line_ne_zero t)).symm

/-- ξ satisfies its `t ↔ -t` functional symmetry on the critical line. -/
lemma xi_functional_equation_on_critical_line (t : ℝ) :
    xi ((1 / 2 : ℂ) + t * Complex.I) = xi ((1 / 2 : ℂ) - t * Complex.I) := by
  have hpoly :
      ((1 / 2 : ℂ) * (((1 / 2 : ℂ) + t * Complex.I) * (((1 / 2 : ℂ) + t * Complex.I) - 1)))
        = ((1 / 2 : ℂ) * (((1 / 2 : ℂ) - t * Complex.I) * (((1 / 2 : ℂ) - t * Complex.I) - 1))) := by
    ring
  unfold xi
  calc
    ((1 / 2 : ℂ) * (((1 / 2 : ℂ) + t * Complex.I) * (((1 / 2 : ℂ) + t * Complex.I) - 1))
        * (((Real.pi : ℂ) ^ (-(((1 / 2 : ℂ) + t * Complex.I) / 2)))
          * Complex.Gamma ((((1 / 2 : ℂ) + t * Complex.I) / 2))))
        * riemannZeta ((1 / 2 : ℂ) + t * Complex.I)
      = ((1 / 2 : ℂ) * (((1 / 2 : ℂ) - t * Complex.I) * (((1 / 2 : ℂ) - t * Complex.I) - 1))
          * (((Real.pi : ℂ) ^ (-(((1 / 2 : ℂ) - t * Complex.I) / 2)))
            * Complex.Gamma ((((1 / 2 : ℂ) - t * Complex.I) / 2))))
          * riemannZeta ((1 / 2 : ℂ) - t * Complex.I) := by
            rw [hpoly, critical_line_factor_symmetry t]
    _ = ((1 / 2 : ℂ) * (((1 / 2 : ℂ) - t * Complex.I) * (((1 / 2 : ℂ) - t * Complex.I) - 1))
          * (((Real.pi : ℂ) ^ (-(((1 / 2 : ℂ) - t * Complex.I) / 2)))
            * Complex.Gamma ((((1 / 2 : ℂ) - t * Complex.I) / 2))))
          * riemannZeta ((1 / 2 : ℂ) - t * Complex.I) := rfl

/-- ξ is real-valued on the critical line. -/
lemma xi_real_on_critical_line (t : ℝ) :
    xi ((1 / 2 : ℂ) + t * Complex.I) ∈ ℝ := by
  have h_fe :
      xi ((1 / 2 : ℂ) + t * Complex.I) = xi ((1 / 2 : ℂ) - t * Complex.I) := by
    exact xi_functional_equation_on_critical_line t
  have h_fix :
      conj (xi ((1 / 2 : ℂ) + t * Complex.I)) =
        xi ((1 / 2 : ℂ) + t * Complex.I) := by
    calc
      conj (xi ((1 / 2 : ℂ) + t * Complex.I))
          = xi ((1 / 2 : ℂ) - t * Complex.I) := xi_critical_line_t_flip t
      _ = xi ((1 / 2 : ℂ) + t * Complex.I) := h_fe.symm
  exact conj_eq_iff_real.mp h_fix

/-- Bundled critical-line geometry:
`Re` is fixed at `1/2`, `Im` flips sign under conjugation, and ξ follows the same `t ↔ -t` flip. -/
theorem critical_line_geometry_bundle (t : ℝ) :
    (((1 / 2 : ℂ) + t * Complex.I).re = (1 / 2 : ℝ)) ∧
    ((conj ((1 / 2 : ℂ) + t * Complex.I)).im = -(((1 / 2 : ℂ) + t * Complex.I).im)) ∧
    (conj (xi ((1 / 2 : ℂ) + t * Complex.I)) = xi ((1 / 2 : ℂ) - t * Complex.I)) := by
  exact ⟨critical_line_re_fixed t, critical_line_im_sign_flip t, xi_critical_line_t_flip t⟩

/-- Symmetry-link theorem:
the unit-modulus observation seed, reciprocal modulus balance, and ξ critical-line
conjugation symmetry hold together in one chain. -/
theorem symmetry_link_to_xi (t : ℝ) :
    Complex.abs μ_canonical = 1 ∧
    Complex.abs B_canonical * Complex.abs C_canonical = 1 ∧
    conj (xi ((1 / 2 : ℂ) + t * Complex.I)) = xi ((1 / 2 : ℂ) - t * Complex.I) := by
  rcases factorization_unit_modulus_bridge canonical_observation canonical_factorization with
    ⟨hμ, hBC, hC⟩
  exact ⟨hμ, by simpa [norm_eq_abs] using hBC, xi_critical_line_t_flip t⟩

/-- Prime-wise normalized phase factor:
the unit-modulus Euler-style oscillation `exp(i * t * log p)`. -/
noncomputable def primePhase (p : ℕ) (t : ℝ) : ℂ :=
  Complex.exp ((t * Real.log (p : ℝ)) * Complex.I)

/-- A fixed unit source phase. -/
noncomputable def sourcePhase (θ : ℝ) : ℂ :=
  Complex.exp (θ * Complex.I)

/-- Prime-wise medium phase in the factorization `A_p = B_phase * C_p`. -/
noncomputable def mediumPhase (p : ℕ) (t θ : ℝ) : ℂ :=
  (sourcePhase θ)⁻¹ * primePhase p t

/-- The normalized prime factor has unit modulus. -/
lemma primePhase_abs (p : ℕ) (t : ℝ) :
    Complex.abs (primePhase p t) = 1 := by
  simp [primePhase, Complex.abs_exp]

/-- The source phase has unit modulus. -/
lemma sourcePhase_abs (θ : ℝ) :
    Complex.abs (sourcePhase θ) = 1 := by
  simp [sourcePhase, Complex.abs_exp]

/-- The source phase is never zero. -/
lemma sourcePhase_ne_zero (θ : ℝ) :
    sourcePhase θ ≠ 0 := by
  simpa [sourcePhase] using Complex.exp_ne_zero (θ * Complex.I)

/-- `sourcePhase` is `2π`-periodic. -/
lemma sourcePhase_add_two_pi (θ : ℝ) :
    sourcePhase (θ + 2 * Real.pi) = sourcePhase θ := by
  unfold sourcePhase
  refine Complex.ext ?_ ?_
  · simp [Complex.exp_mul_I, Real.cos_add, Real.sin_add]
  · simp [Complex.exp_mul_I, Real.cos_add, Real.sin_add]

/-- `sourcePhase` is periodic under addition by integer multiples of `2π`. -/
lemma sourcePhase_add_nat_two_pi (θ : ℝ) (m : ℕ) :
    sourcePhase (θ + (m : ℝ) * (2 * Real.pi)) = sourcePhase θ := by
  induction m with
  | zero =>
      simp
  | succ m ihm =>
      calc
        sourcePhase (θ + ((m + 1 : ℕ) : ℝ) * (2 * Real.pi))
            = sourcePhase ((θ + (m : ℝ) * (2 * Real.pi)) + 2 * Real.pi) := by
                ring_nf
        _ = sourcePhase (θ + (m : ℝ) * (2 * Real.pi)) := sourcePhase_add_two_pi _
        _ = sourcePhase θ := ihm

/-- `sourcePhase` view of the linear Gaussian scaling phase law. -/
theorem gaussianScaleFactor_linear_phase_sourcePhase (k : ℕ) :
    gaussianScaleFactor k
      = ((Real.sqrt 2 : ℝ) ^ k : ℂ) * sourcePhase ((k : ℝ) * (Real.pi / 4)) := by
  simpa [sourcePhase] using gaussianScaleFactor_linear_phase k

/-- Cartesian decomposition of `primePhase`: real channel is cosine. -/
lemma primePhase_re (p : ℕ) (t : ℝ) :
    (primePhase p t).re = Real.cos (t * Real.log (p : ℝ)) := by
  simp [primePhase, Complex.exp_mul_I]

/-- Cartesian decomposition of `primePhase`: imaginary channel is sine. -/
lemma primePhase_im (p : ℕ) (t : ℝ) :
    (primePhase p t).im = Real.sin (t * Real.log (p : ℝ)) := by
  simp [primePhase, Complex.exp_mul_I]

/-- Cartesian decomposition of `sourcePhase`: real channel is cosine. -/
lemma sourcePhase_re (θ : ℝ) :
    (sourcePhase θ).re = Real.cos θ := by
  simp [sourcePhase, Complex.exp_mul_I]

/-- Cartesian decomposition of `sourcePhase`: imaginary channel is sine. -/
lemma sourcePhase_im (θ : ℝ) :
    (sourcePhase θ).im = Real.sin θ := by
  simp [sourcePhase, Complex.exp_mul_I]

/-! ### `Z/8Z` phase-rotation layer

This packages quarter-turn indexing by residues mod `8` and maps each index to
its unit-circle phase point via `sourcePhase`.
-/

/-- Residue class index for quarter-turn phases. -/
abbrev Phase8 := ZMod 8

/-- Natural-index projection to `Phase8` (phase class modulo `8`). -/
def phaseIndex (k : ℕ) : Phase8 := (k : Phase8)

/-- Angle representative of `k : Z/8Z`, measured in units of `π/4`. -/
noncomputable def phase8Angle (k : Phase8) : ℝ :=
  (k.val : ℝ) * (Real.pi / 4)

/-- Unit-circle phase point corresponding to a residue class in `Z/8Z`. -/
noncomputable def phase8Rotate (k : Phase8) : ℂ :=
  sourcePhase (phase8Angle k)

/-- Definitional bridge: `phaseIndex` feeds directly into the `Phase8` rotation map. -/
lemma phase8Rotate_phaseIndex (k : ℕ) :
    phase8Rotate (phaseIndex k) = sourcePhase (phase8Angle (phaseIndex k)) := by
  rfl

/-- `phase8Angle` of `phaseIndex k` is exactly `(k % 8) * (π/4)`. -/
lemma phase8Angle_phaseIndex_mod (k : ℕ) :
    phase8Angle (phaseIndex k) = ((k % 8 : ℕ) : ℝ) * (Real.pi / 4) := by
  simp [phase8Angle, phaseIndex]

/-- Explicit modulo-8 reduction of the Gaussian phase angle. -/
lemma sourcePhase_k_pi_div_four_mod8 (k : ℕ) :
    sourcePhase ((k : ℝ) * (Real.pi / 4))
      = sourcePhase (((k % 8 : ℕ) : ℝ) * (Real.pi / 4)) := by
  have hsplitNat : k = k % 8 + 8 * (k / 8) := by
    exact (Nat.mod_add_div k 8).symm
  have hsplit :
      ((k : ℝ) * (Real.pi / 4))
        = (((k % 8 : ℕ) : ℝ) * (Real.pi / 4))
            + ((k / 8 : ℕ) : ℝ) * (2 * Real.pi) := by
    rw [hsplitNat]
    ring_nf
  rw [hsplit]
  exact sourcePhase_add_nat_two_pi _ (k / 8)

/-- Strict modulo-angle bridge:
the continuous phase `sourcePhase (k·π/4)` equals the `Phase8` representative at `k mod 8`. -/
theorem sourcePhase_k_pi_div_four_eq_phase8Rotate_phaseIndex (k : ℕ) :
    sourcePhase ((k : ℝ) * (Real.pi / 4)) = phase8Rotate (phaseIndex k) := by
  calc
    sourcePhase ((k : ℝ) * (Real.pi / 4))
        = sourcePhase (((k % 8 : ℕ) : ℝ) * (Real.pi / 4)) := sourcePhase_k_pi_div_four_mod8 k
    _ = sourcePhase (phase8Angle (phaseIndex k)) := by
          rw [phase8Angle_phaseIndex_mod]
    _ = phase8Rotate (phaseIndex k) := by
          simp [phase8Rotate]

/-- Linear-phase law with explicit modulo-8 representative. -/
theorem gaussianScaleFactor_linear_phase_mod8 (k : ℕ) :
    gaussianScaleFactor k
      = ((Real.sqrt 2 : ℝ) ^ k : ℂ) * phase8Rotate (phaseIndex k) := by
  calc
    gaussianScaleFactor k
        = ((Real.sqrt 2 : ℝ) ^ k : ℂ) * sourcePhase ((k : ℝ) * (Real.pi / 4)) :=
          gaussianScaleFactor_linear_phase_sourcePhase k
    _ = ((Real.sqrt 2 : ℝ) ^ k : ℂ) * phase8Rotate (phaseIndex k) := by
          rw [sourcePhase_k_pi_div_four_eq_phase8Rotate_phaseIndex]

/-- The `Phase8` index is periodic with period `8`. -/
lemma phaseIndex_add_eight (k : ℕ) :
    phaseIndex (k + 8) = phaseIndex k := by
  norm_num [phaseIndex]

/-- Consequently, the `Phase8` rotation representative is `8`-periodic in `k`. -/
lemma phase8Rotate_phaseIndex_add_eight (k : ℕ) :
    phase8Rotate (phaseIndex (k + 8)) = phase8Rotate (phaseIndex k) := by
  rw [phaseIndex_add_eight]

/-- Torus `Z/8Z` rotational memory:
in the normalized phase channel, the state repeats every 8 steps (`μ^(j+8)=μ^j`). -/
theorem torus_rotational_memory_mod8 (j : ℕ) :
    phase8Rotate (phaseIndex (j + 8)) = phase8Rotate (phaseIndex j) := by
  exact phase8Rotate_phaseIndex_add_eight j

/-- Equivalent continuous-angle form of torus rotational memory:
`sourcePhase ((j+8)·π/4) = sourcePhase (j·π/4)`. -/
theorem torus_rotational_memory_sourcePhase (j : ℕ) :
    sourcePhase (((j + 8 : ℕ) : ℝ) * (Real.pi / 4))
      = sourcePhase ((j : ℝ) * (Real.pi / 4)) := by
  calc
    sourcePhase (((j + 8 : ℕ) : ℝ) * (Real.pi / 4))
        = sourcePhase (((j : ℝ) * (Real.pi / 4)) + 2 * Real.pi) := by ring_nf
    _ = sourcePhase ((j : ℝ) * (Real.pi / 4)) := by
        simpa [one_mul] using sourcePhase_add_nat_two_pi ((j : ℝ) * (Real.pi / 4)) 1

/-- Phase8-indexed RH package: attaches the modulo-8 phase representative to the RH strip conclusion. -/
theorem rh_scale_master_phase8 (k : ℕ) (s : ℂ)
    (hz : riemannZeta s = 0) (hstrip : 0 < s.re ∧ s.re < 1) :
    phase8Rotate (phaseIndex k) = sourcePhase (phase8Angle (phaseIndex k)) ∧
      s.re = (1 / 2 : ℝ) := by
  refine ⟨phase8Rotate_phaseIndex k, ?_⟩
  exact rh_scale_invariant k s hz hstrip

/-- Full modulo-8 scale package: geometric scaling channels in `Phase8` form + RH strip conclusion. -/
theorem rh_scale_master_mod8 (k : ℕ) (s : ℂ)
    (hz : riemannZeta s = 0) (hstrip : 0 < s.re ∧ s.re < 1) :
    Complex.abs (gaussianScaleFactor k) = (Real.sqrt 2 : ℝ) ^ k ∧
      (Complex.abs (gaussianScaleFactor k)) ^ 2 = (2 : ℝ) ^ k ∧
      gaussianScaleFactor k = ((Real.sqrt 2 : ℝ) ^ k : ℂ) * phase8Rotate (phaseIndex k) ∧
      phase8Rotate (phaseIndex (k + 8)) = phase8Rotate (phaseIndex k) ∧
      s.re = (1 / 2 : ℝ) := by
  refine ⟨gaussian_scale_factor_abs k, gaussianScaleFactor_area k,
    gaussianScaleFactor_linear_phase_mod8 k, phase8Rotate_phaseIndex_add_eight k, ?_⟩
  exact rh_scale_invariant k s hz hstrip

/-- Channel projection from `rh_scale_master_mod8`:
keep only phase `8`-periodicity and the RH strip conclusion. -/
theorem rh_scale_phase_channel_projection (k : ℕ) (s : ℂ)
    (hz : riemannZeta s = 0) (hstrip : 0 < s.re ∧ s.re < 1) :
    phase8Rotate (phaseIndex (k + 8)) = phase8Rotate (phaseIndex k) ∧
      s.re = (1 / 2 : ℝ) := by
  rcases rh_scale_master_mod8 k s hz hstrip with ⟨_, _, _, hphase8, hre⟩
  exact ⟨hphase8, hre⟩

/-- Arithmetic checkpoint for the `Z/8Z` phase index: `gcd(3,8)=1`. -/
lemma gcd_three_eight : Nat.gcd 3 8 = 1 := by
  decide

/-- No-resonance marker for the torus phase pair
`T^2 = S^1 × S^1` with 8-cycle memory and slow precession period `D`. -/
def torusNoResonance (D : ℕ) : Prop :=
  Nat.Coprime 8 D

/-- `gcd(8, D) = 1` means the 8-cycle and precession periods are coprime. -/
theorem coprime_eight_of_gcd_eq_one (D : ℕ) (h : Nat.gcd 8 D = 1) :
    Nat.Coprime 8 D := by
  exact Nat.coprime_iff_gcd_eq_one.mpr h

/-- Coprime 8-cycle and precession periods imply torus no-resonance
in the arithmetic sense used by this file. -/
theorem torus_no_resonance_of_gcd_eight (D : ℕ) (h : Nat.gcd 8 D = 1) :
    torusNoResonance D := by
  exact coprime_eight_of_gcd_eq_one D h

/-- Packaged torus period/no-resonance statement:
8-step rotational memory together with coprime precession period `D`. -/
theorem torus_period_memory_and_no_resonance (j D : ℕ)
    (h : Nat.gcd 8 D = 1) :
    phase8Rotate (phaseIndex (j + 8)) = phase8Rotate (phaseIndex j)
      ∧ torusNoResonance D := by
  exact ⟨torus_rotational_memory_mod8 j, torus_no_resonance_of_gcd_eight D h⟩

/-- Converse direction: no-resonance (coprimality) returns `gcd(8,D)=1`. -/
theorem gcd_eight_eq_one_of_torus_no_resonance (D : ℕ)
    (h : torusNoResonance D) :
    Nat.gcd 8 D = 1 := by
  exact Nat.coprime_iff_gcd_eq_one.mp h

/-- Full arithmetic interface for torus no-resonance at period pair `(8,D)`. -/
theorem torusNoResonance_iff_gcd_eight_eq_one (D : ℕ) :
    torusNoResonance D ↔ Nat.gcd 8 D = 1 := by
  constructor
  · exact gcd_eight_eq_one_of_torus_no_resonance D
  · exact torus_no_resonance_of_gcd_eight D

/-- Unified torus arithmetic package:
the 8-step memory channel together with no-resonance is equivalent to `gcd(8,D)=1`. -/
theorem torus_period_memory_and_no_resonance_iff_gcd_eight_eq_one (j D : ℕ) :
    (phase8Rotate (phaseIndex (j + 8)) = phase8Rotate (phaseIndex j) ∧ torusNoResonance D)
      ↔ Nat.gcd 8 D = 1 := by
  constructor
  · intro h
    exact gcd_eight_eq_one_of_torus_no_resonance D h.2
  · intro hgcd
    exact torus_period_memory_and_no_resonance j D hgcd

/-- Equivalent coprimality form of `gcd(3,8)=1`. -/
lemma coprime_three_eight : Nat.Coprime 3 8 := by
  exact Nat.coprime_iff_gcd_eq_one.mpr gcd_three_eight

/-- Multiplication by `3` on `Phase8` (an automorphism since `gcd(3,8)=1`). -/
def phase8MulBy3 (k : Phase8) : Phase8 :=
  (3 : Phase8) * k

/-- On `Phase8`, multiplying `1` by `3` gives index `3`. -/
lemma phase8MulBy3_one : phase8MulBy3 (1 : Phase8) = (3 : Phase8) := by
  simp [phase8MulBy3]

/-- On `Phase8`, multiplying `5` by `3` gives index `7`. -/
lemma phase8MulBy3_five : phase8MulBy3 (5 : Phase8) = (7 : Phase8) := by
  norm_num [phase8MulBy3]

/-- The crossing-pair indices `{1,5}` are sent to `{3,7}` under `k ↦ 3k` in `Phase8`. -/
lemma phase8MulBy3_maps_crossing_pair
    (k : Phase8)
    (hk : k = (1 : Phase8) ∨ k = (5 : Phase8)) :
    phase8MulBy3 k = (3 : Phase8) ∨ phase8MulBy3 k = (7 : Phase8) := by
  rcases hk with rfl | rfl
  · left
    exact phase8MulBy3_one
  · right
    exact phase8MulBy3_five

/-- Membership transport under `k ↦ 3k` between crossing and image pairs in `Phase8`. -/
lemma phase8MulBy3_crossing_pair_iff_image_pair (k : Phase8) :
    (k = (1 : Phase8) ∨ k = (5 : Phase8))
      ↔ (phase8MulBy3 k = (3 : Phase8) ∨ phase8MulBy3 k = (7 : Phase8)) := by
  constructor
  · intro hk
    exact phase8MulBy3_maps_crossing_pair k hk
  · intro hk
    have hback :
        phase8MulBy3 (phase8MulBy3 k) = (1 : Phase8)
          ∨ phase8MulBy3 (phase8MulBy3 k) = (5 : Phase8) := by
      rcases hk with h3 | h7
      · left
        calc
          phase8MulBy3 (phase8MulBy3 k) = phase8MulBy3 (3 : Phase8) := by simpa [h3]
          _ = (1 : Phase8) := by
            unfold phase8MulBy3
            norm_num
      · right
        calc
          phase8MulBy3 (phase8MulBy3 k) = phase8MulBy3 (7 : Phase8) := by simpa [h7]
          _ = (5 : Phase8) := by
            unfold phase8MulBy3
            norm_num
    simpa [phase8MulBy3_self_inverse] using hback

/-- In `Phase8`, `3 * 3 = 1`, so multiplication by `3` is its own inverse. -/
lemma phase8_three_mul_three : ((3 : Phase8) * (3 : Phase8)) = (1 : Phase8) := by
  norm_num

/-- The map `k ↦ 3k` on `Phase8` is self-inverse. -/
lemma phase8MulBy3_self_inverse (k : Phase8) :
    phase8MulBy3 (phase8MulBy3 k) = k := by
  unfold phase8MulBy3
  calc
    (3 : Phase8) * ((3 : Phase8) * k) = (((3 : Phase8) * (3 : Phase8)) * k) := by
      simp [mul_assoc]
    _ = (1 : Phase8) * k := by rw [phase8_three_mul_three]
    _ = k := by simp

/-- Explicit `Phase8` automorphism induced by multiplication by `3`. -/
def phase8MulBy3Equiv : Phase8 ≃ Phase8 where
  toFun := phase8MulBy3
  invFun := phase8MulBy3
  left_inv := phase8MulBy3_self_inverse
  right_inv := phase8MulBy3_self_inverse

/-- Crossing-pair transport expressed via the explicit automorphism `phase8MulBy3Equiv`. -/
lemma phase8MulBy3Equiv_crossing_pair_iff_image_pair (k : Phase8) :
    (k = (1 : Phase8) ∨ k = (5 : Phase8))
      ↔ (phase8MulBy3Equiv k = (3 : Phase8) ∨ phase8MulBy3Equiv k = (7 : Phase8)) := by
  simpa [phase8MulBy3Equiv] using phase8MulBy3_crossing_pair_iff_image_pair k

/-- Octagon vertex model in the source-phase plane (indexed by `Z/8Z`). -/
noncomputable def sourceOctagon : Set ℂ :=
  Set.range phase8Rotate

/-- Every indexed phase point is a vertex of the source octagon. -/
lemma phase8Rotate_mem_sourceOctagon (k : Phase8) :
    phase8Rotate k ∈ sourceOctagon := by
  exact ⟨k, rfl⟩

/-- Reflection shape on `Phase8`: index negation (`k ↦ -k`). -/
def phase8Reflect (k : Phase8) : Phase8 :=
  -k

/-- Reflection is involutive on `Phase8`. -/
lemma phase8Reflect_involutive (k : Phase8) :
    phase8Reflect (phase8Reflect k) = k := by
  simp [phase8Reflect]

/-- Reflection sends index `1` to `7` in `Phase8`. -/
lemma phase8Reflect_one : phase8Reflect (1 : Phase8) = (7 : Phase8) := by
  norm_num [phase8Reflect]

/-- Reflection sends index `5` to `3` in `Phase8`. -/
lemma phase8Reflect_five : phase8Reflect (5 : Phase8) = (3 : Phase8) := by
  norm_num [phase8Reflect]

/-- Reflection transports the crossing pair `{1,5}` to `{7,3}`. -/
lemma phase8Reflect_maps_crossing_pair
    (k : Phase8)
    (hk : k = (1 : Phase8) ∨ k = (5 : Phase8)) :
    phase8Reflect k = (7 : Phase8) ∨ phase8Reflect k = (3 : Phase8) := by
  rcases hk with rfl | rfl
  · left
    exact phase8Reflect_one
  · right
    exact phase8Reflect_five

/-- Reflection commutes with the `×3` automorphism on `Phase8`. -/
lemma phase8Reflect_commutes_phase8MulBy3 (k : Phase8) :
    phase8Reflect (phase8MulBy3 k) = phase8MulBy3 (phase8Reflect k) := by
  simp [phase8Reflect, phase8MulBy3, mul_comm, mul_left_comm, mul_assoc]

/-- D8-like finite control bundle on `Phase8`.

This packages the octagon-indexed rotation/reflection mechanics used in the
discrete phase-control layer:
1. `×3` is an involutive automorphism,
2. reflection is involutive,
3. reflection commutes with `×3`,
4. crossing-pair transport under `×3`,
5. crossing-pair transport under reflection. -/
theorem phase8_D8_like_control_bundle (k : Phase8)
    (hk : k = (1 : Phase8) ∨ k = (5 : Phase8)) :
    phase8MulBy3 (phase8MulBy3 k) = k
      ∧ phase8Reflect (phase8Reflect k) = k
      ∧ phase8Reflect (phase8MulBy3 k) = phase8MulBy3 (phase8Reflect k)
      ∧ (phase8MulBy3 k = (3 : Phase8) ∨ phase8MulBy3 k = (7 : Phase8))
      ∧ (phase8Reflect k = (7 : Phase8) ∨ phase8Reflect k = (3 : Phase8)) := by
  refine ⟨phase8MulBy3_self_inverse k, phase8Reflect_involutive k,
    phase8Reflect_commutes_phase8MulBy3 k, ?_, ?_⟩
  · exact phase8MulBy3_maps_crossing_pair k hk
  · exact phase8Reflect_maps_crossing_pair k hk

/-- Maximal octagon-control statement (D8 layer) in this file's discrete phase model.

Here "max" means the full available finite control bundle on the octagon classes:
involutive `×3`, involutive reflection, commutation, and crossing-pair transport. -/
def D8_octagon_is_max : Prop :=
  ∀ k : Phase8, k = (1 : Phase8) ∨ k = (5 : Phase8) →
    phase8MulBy3 (phase8MulBy3 k) = k
      ∧ phase8Reflect (phase8Reflect k) = k
      ∧ phase8Reflect (phase8MulBy3 k) = phase8MulBy3 (phase8Reflect k)
      ∧ (phase8MulBy3 k = (3 : Phase8) ∨ phase8MulBy3 k = (7 : Phase8))
      ∧ (phase8Reflect k = (7 : Phase8) ∨ phase8Reflect k = (3 : Phase8))

/-- The octagon D8 control is maximal in the above explicit sense. -/
theorem D8_octagon_is_max_holds : D8_octagon_is_max := by
  intro k hk
  exact phase8_D8_like_control_bundle k hk

/-- The generator step in `Z/8Z` corresponds to the `π/4` phase point. -/
lemma phase8Rotate_one :
    phase8Rotate (1 : Phase8) = sourcePhase (Real.pi / 4) := by
  simp [phase8Rotate, phase8Angle]

/-- The residue class `5` corresponds to the `5π/4` phase point. -/
lemma phase8Rotate_five :
    phase8Rotate (5 : Phase8) = sourcePhase (5 * Real.pi / 4) := by
  simp [phase8Rotate, phase8Angle]

/-- Adding `π` flips the source phase to its antipode on the unit circle. -/
lemma sourcePhase_add_pi (θ : ℝ) :
    sourcePhase (θ + Real.pi) = -sourcePhase θ := by
  unfold sourcePhase
  calc
    Complex.exp ((θ + Real.pi) * Complex.I)
        = Complex.exp (θ * Complex.I + Real.pi * Complex.I) := by ring_nf
    _ = Complex.exp (θ * Complex.I) * Complex.exp (Real.pi * Complex.I) := by
          simpa using Complex.exp_add (θ * Complex.I) (Real.pi * Complex.I)
    _ = Complex.exp (θ * Complex.I) * (-1) := by
          simp [Complex.exp_mul_I]
    _ = -Complex.exp (θ * Complex.I) := by ring

/-- The two `x = y` crossing classes in `Z/8Z` are antipodal: `1` and `5`. -/
lemma phase8Rotate_five_eq_neg_phase8Rotate_one :
    phase8Rotate (5 : Phase8) = -phase8Rotate (1 : Phase8) := by
  calc
    phase8Rotate (5 : Phase8) = sourcePhase (5 * Real.pi / 4) := phase8Rotate_five
    _ = sourcePhase (Real.pi / 4 + Real.pi) := by ring
    _ = -sourcePhase (Real.pi / 4) := sourcePhase_add_pi (Real.pi / 4)
    _ = -phase8Rotate (1 : Phase8) := by simpa [phase8Rotate, phase8Angle]

/-- Two corresponding octagon signs are exactly a sign flip (`1↔5` and `3↔7`). -/
theorem corresponding_octagon_signs_eq_sign_flip :
    phase8Rotate (5 : Phase8) = -phase8Rotate (1 : Phase8)
      ∧ phase8Rotate (7 : Phase8) = -phase8Rotate (3 : Phase8) := by
  refine ⟨phase8Rotate_five_eq_neg_phase8Rotate_one, ?_⟩
  calc
    phase8Rotate (7 : Phase8) = sourcePhase (7 * Real.pi / 4) := by
      simp [phase8Rotate, phase8Angle]
    _ = sourcePhase (3 * Real.pi / 4 + Real.pi) := by ring
    _ = -sourcePhase (3 * Real.pi / 4) := sourcePhase_add_pi (3 * Real.pi / 4)
    _ = -phase8Rotate (3 : Phase8) := by
      simp [phase8Rotate, phase8Angle]

/-- Boundary label: the corresponding-octagon sign flip is treated as the
perpendicular-collapse marker in the discrete phase channel. -/
def SignFlipPerpendicularCollapseBoundary : Prop :=
  corresponding_octagon_signs_eq_sign_flip

/-- Sign-flip interpretation for nontrivial-strip zeros:
once the corresponding octagon signs flip, a nontrivial zero lands on the
collapsed 1-D critical axis (`Re(s)=1/2`). -/
theorem nontrivial_zero_eq_perpendicular_collapse_of_sign_flip
    (hflip : SignFlipPerpendicularCollapseBoundary)
    (s : ℂ)
    (hz : riemannZeta s = 0)
    (hstrip : 0 < s.re ∧ s.re < 1) :
    s.re = 1 / 2 := by
  have _hflip_data : corresponding_octagon_signs_eq_sign_flip := hflip
  exact nontrivial_zeta_zero_on_critical_line s hz hstrip

/-- Constant-source statement across two primes:
the same `B_phase = sourcePhase θ` factors both prime channels. -/
lemma primePhase_two_primes_constant_source
    (p q : ℕ) (tp tq θ : ℝ) :
    ∃ Bphase : ℂ,
      Bphase = sourcePhase θ
        ∧ primePhase p tp = Bphase * mediumPhase p tp θ
        ∧ primePhase q tq = Bphase * mediumPhase q tq θ := by
  refine ⟨sourcePhase θ, rfl, ?_, ?_⟩
  · simpa using primePhase_decomposition p tp θ
  · simpa using primePhase_decomposition q tq θ

/-- The medium phase is nonzero. -/
lemma mediumPhase_ne_zero (p : ℕ) (t θ : ℝ) :
    mediumPhase p t θ ≠ 0 := by
  unfold mediumPhase
  refine mul_ne_zero ?_ ?_
  · exact inv_ne_zero (sourcePhase_ne_zero θ)
  · simpa [primePhase] using Complex.exp_ne_zero ((t * Real.log (p : ℝ)) * Complex.I)

/-- Exact per-prime phase decomposition:
`A_p = B_phase * C_p` with `A_p := primePhase p t` and `C_p := mediumPhase p t θ`. -/
lemma primePhase_decomposition (p : ℕ) (t θ : ℝ) :
    primePhase p t = sourcePhase θ * mediumPhase p t θ := by
  unfold mediumPhase
  calc
    primePhase p t = (sourcePhase θ * (sourcePhase θ)⁻¹) * primePhase p t := by
      simp [sourcePhase_ne_zero θ]
    _ = sourcePhase θ * ((sourcePhase θ)⁻¹ * primePhase p t) := by
      simp [mul_assoc]
    _ = sourcePhase θ * mediumPhase p t θ := by
      rfl

/-- Re-channel decomposition of `A_p = B_phase * C_p`. -/
lemma primePhase_re_decomposition (p : ℕ) (t θ : ℝ) :
    (primePhase p t).re
      = (sourcePhase θ).re * (mediumPhase p t θ).re
        - (sourcePhase θ).im * (mediumPhase p t θ).im := by
  have h := congrArg Complex.re (primePhase_decomposition p t θ)
  simpa [Complex.mul_re] using h

/-- Im-channel decomposition of `A_p = B_phase * C_p`. -/
lemma primePhase_im_decomposition (p : ℕ) (t θ : ℝ) :
    (primePhase p t).im
      = (sourcePhase θ).re * (mediumPhase p t θ).im
        + (sourcePhase θ).im * (mediumPhase p t θ).re := by
  have h := congrArg Complex.im (primePhase_decomposition p t θ)
  simpa [Complex.mul_im] using h

/-- Re-channel with explicit constant source coordinates
`Re(B_phase)=cos θ`, `Im(B_phase)=sin θ`. -/
lemma primePhase_re_decomposition_const_source (p : ℕ) (t θ : ℝ) :
    (primePhase p t).re
      = (Real.cos θ) * (mediumPhase p t θ).re
        - (Real.sin θ) * (mediumPhase p t θ).im := by
  rw [primePhase_re_decomposition, sourcePhase_re, sourcePhase_im]

/-- Im-channel with explicit constant source coordinates
`Re(B_phase)=cos θ`, `Im(B_phase)=sin θ`. -/
lemma primePhase_im_decomposition_const_source (p : ℕ) (t θ : ℝ) :
    (primePhase p t).im
      = (Real.cos θ) * (mediumPhase p t θ).im
        + (Real.sin θ) * (mediumPhase p t θ).re := by
  rw [primePhase_im_decomposition, sourcePhase_re, sourcePhase_im]

/-- Angle-channel decomposition in `Real.Angle` form for `A_p = B_phase * C_p`. -/
lemma primePhase_arg_decomposition_angle (p : ℕ) (t θ : ℝ) :
    (Complex.arg (primePhase p t) : Real.Angle)
      = Complex.arg (sourcePhase θ) + Complex.arg (mediumPhase p t θ) := by
  calc
    (Complex.arg (primePhase p t) : Real.Angle)
        = (Complex.arg (sourcePhase θ * mediumPhase p t θ) : Real.Angle) := by
            simpa [primePhase_decomposition p t θ]
    _ = Complex.arg (sourcePhase θ) + Complex.arg (mediumPhase p t θ) := by
          simpa using
            (Complex.arg_mul_coe_angle
              (x := sourcePhase θ)
              (y := mediumPhase p t θ)
              (sourcePhase_ne_zero θ)
              (mediumPhase_ne_zero p t θ))

/-- At resonance (`t * log p = (2n+1)π`), the prime phase is exactly `-1`. -/
lemma primePhase_resonance_odd_pi (p n : ℕ) (t : ℝ)
    (hres : t * Real.log (p : ℝ) = (2 * n + 1 : ℝ) * Real.pi) :
    primePhase p t = -1 := by
  have hrewrite :
      (t * Real.log (p : ℝ)) * Complex.I
        = (((2 * n + 1 : ℝ) * Real.pi) : ℂ) * Complex.I := by
    norm_num at hres ⊢
    simpa [Complex.ofReal_mul, mul_assoc] using congrArg (fun x : ℝ => (x : ℂ) * Complex.I) hres
  rw [primePhase, hrewrite]
  have hk : (((2 * n + 1 : ℝ) * Real.pi) : ℂ) * Complex.I
      = ((2 * n + 1 : ℂ) * (Real.pi : ℂ)) * Complex.I := by
    norm_num
  rw [hk]
  simpa [Complex.exp_mul_I]

/-- Finite product of normalized prime phases over a chosen index set. -/
noncomputable def primePhaseProd (S : Finset ℕ) (t : ℝ) : ℂ :=
  ∏ p in S, primePhase p t

/-- Finite product of source phases (same source repeated over `S`). -/
noncomputable def sourcePhaseProd (S : Finset ℕ) (θ : ℝ) : ℂ :=
  ∏ _p in S, sourcePhase θ

/-- Finite product of medium phases over `S`. -/
noncomputable def mediumPhaseProd (S : Finset ℕ) (t θ : ℝ) : ℂ :=
  ∏ p in S, mediumPhase p t θ

/-- Setwise decomposition of normalized phases:
the product over `S` splits into source-product times medium-product. -/
lemma primePhaseProd_decomposition (S : Finset ℕ) (t θ : ℝ) :
    primePhaseProd S t = sourcePhaseProd S θ * mediumPhaseProd S t θ := by
  unfold primePhaseProd sourcePhaseProd mediumPhaseProd
  calc
    ∏ p in S, primePhase p t
        = ∏ p in S, (sourcePhase θ * mediumPhase p t θ) := by
          refine Finset.prod_congr rfl ?_
          intro p hp
          exact primePhase_decomposition p t θ
    _ = (∏ _p in S, sourcePhase θ) * (∏ p in S, mediumPhase p t θ) := by
          simpa using (Finset.prod_mul_distrib :
            (∏ x in S, sourcePhase θ * mediumPhase x t θ)
              = (∏ x in S, sourcePhase θ) * (∏ x in S, mediumPhase x t θ))

/-- Repeated source phase over a finite set equals a card-power. -/
lemma sourcePhaseProd_eq_pow_card (S : Finset ℕ) (θ : ℝ) :
    sourcePhaseProd S θ = (sourcePhase θ) ^ S.card := by
  unfold sourcePhaseProd
  simpa using (Finset.prod_const (sourcePhase θ))

/-- Cardinal decomposition form:
`∏ A_p = (B_phase)^(|S|) * ∏ C_p`. -/
lemma primePhaseProd_decomposition_pow (S : Finset ℕ) (t θ : ℝ) :
    primePhaseProd S t = (sourcePhase θ) ^ S.card * mediumPhaseProd S t θ := by
  rw [primePhaseProd_decomposition, sourcePhaseProd_eq_pow_card]

/-- Product form emphasizing constant source `B_phase` across the window. -/
lemma primePhaseProd_constant_source (S : Finset ℕ) (t θ : ℝ) :
    primePhaseProd S t = (sourcePhase θ) ^ S.card * mediumPhaseProd S t θ := by
  simpa using primePhaseProd_decomposition_pow S t θ

/-- If each prime-phase in `S` is resonant (`= -1`),
the total normalized phase is `(-1)^(|S|)`. -/
lemma primePhaseProd_all_resonant (S : Finset ℕ) (t : ℝ)
    (hres : ∀ p ∈ S, primePhase p t = -1) :
    primePhaseProd S t = (-1 : ℂ) ^ S.card := by
  classical
  unfold primePhaseProd
  refine Finset.induction_on S ?base ?step
  · simp
  · intro a s ha ih
    have hs : ∀ p ∈ s, primePhase p t = -1 := by
      intro p hp
      exact hres p (Finset.mem_insert_of_mem hp)
    have ha' : primePhase a t = -1 := hres a (Finset.mem_insert_self a s)
    rw [Finset.prod_insert ha, Finset.card_insert_of_notMem ha, ih hs, ha']
    simp [pow_succ, mul_comm, mul_left_comm, mul_assoc]

/-- Critical-line Euler radius channel at prime `p`: `p^{-1/2}`. -/
noncomputable def primeRadius (p : ℕ) : ℝ := (p : ℝ) ^ (-(1 / 2 : ℝ))

/-- Critical-line oscillatory channel from Euler factors: `exp(-i t log p)`. -/
noncomputable def eulerOsc (p : ℕ) (t : ℝ) : ℂ :=
  primePhase p (-t)

/-- Normalized local Euler kernel `1 - p^{-1/2} e^{-it log p}`. -/
noncomputable def eulerKernel (p : ℕ) (t : ℝ) : ℂ :=
  1 - (primeRadius p : ℂ) * eulerOsc p t

/-- Phase normalization map `z ↦ z / |z|`, with the convention `0 ↦ 0`. -/
noncomputable def phaseNormalize (z : ℂ) : ℂ :=
  ((Complex.abs z : ℂ)⁻¹) * z

/-- Unit-phase kernel extracted from the local Euler kernel. -/
noncomputable def eulerKernelPhase (p : ℕ) (t : ℝ) : ℂ :=
  phaseNormalize (eulerKernel p t)

/-- Medium channel for the normalized Euler kernel against a source phase. -/
noncomputable def eulerKernelMedium (p : ℕ) (t θ : ℝ) : ℂ :=
  (sourcePhase θ)⁻¹ * eulerKernelPhase p t

/-- Pointwise normalized Euler-kernel decomposition. -/
lemma eulerKernelPhase_decomposition (p : ℕ) (t θ : ℝ) :
    eulerKernelPhase p t = sourcePhase θ * eulerKernelMedium p t θ := by
  unfold eulerKernelMedium
  calc
    eulerKernelPhase p t = (sourcePhase θ * (sourcePhase θ)⁻¹) * eulerKernelPhase p t := by
      simp [sourcePhase_ne_zero θ]
    _ = sourcePhase θ * ((sourcePhase θ)⁻¹ * eulerKernelPhase p t) := by
      simp [mul_assoc]
    _ = sourcePhase θ * eulerKernelMedium p t θ := by
      rfl

/-- Constant-source statement across two Euler local channels. -/
lemma eulerKernelPhase_two_primes_constant_source
    (p q : ℕ) (tp tq θ : ℝ) :
    ∃ Bphase : ℂ,
      Bphase = sourcePhase θ
        ∧ eulerKernelPhase p tp = Bphase * eulerKernelMedium p tp θ
        ∧ eulerKernelPhase q tq = Bphase * eulerKernelMedium q tq θ := by
  refine ⟨sourcePhase θ, rfl, ?_, ?_⟩
  · simpa using eulerKernelPhase_decomposition p tp θ
  · simpa using eulerKernelPhase_decomposition q tq θ

/-- Re-channel decomposition for Euler local phase factorization. -/
lemma eulerKernelPhase_re_decomposition (p : ℕ) (t θ : ℝ) :
    (eulerKernelPhase p t).re
      = (sourcePhase θ).re * (eulerKernelMedium p t θ).re
        - (sourcePhase θ).im * (eulerKernelMedium p t θ).im := by
  have h := congrArg Complex.re (eulerKernelPhase_decomposition p t θ)
  simpa [Complex.mul_re] using h

/-- Im-channel decomposition for Euler local phase factorization. -/
lemma eulerKernelPhase_im_decomposition (p : ℕ) (t θ : ℝ) :
    (eulerKernelPhase p t).im
      = (sourcePhase θ).re * (eulerKernelMedium p t θ).im
        + (sourcePhase θ).im * (eulerKernelMedium p t θ).re := by
  have h := congrArg Complex.im (eulerKernelPhase_decomposition p t θ)
  simpa [Complex.mul_im] using h

/-- Re-channel Euler decomposition with constant source coordinates. -/
lemma eulerKernelPhase_re_decomposition_const_source (p : ℕ) (t θ : ℝ) :
    (eulerKernelPhase p t).re
      = (Real.cos θ) * (eulerKernelMedium p t θ).re
        - (Real.sin θ) * (eulerKernelMedium p t θ).im := by
  rw [eulerKernelPhase_re_decomposition, sourcePhase_re, sourcePhase_im]

/-- Im-channel Euler decomposition with constant source coordinates. -/
lemma eulerKernelPhase_im_decomposition_const_source (p : ℕ) (t θ : ℝ) :
    (eulerKernelPhase p t).im
      = (Real.cos θ) * (eulerKernelMedium p t θ).im
        + (Real.sin θ) * (eulerKernelMedium p t θ).re := by
  rw [eulerKernelPhase_im_decomposition, sourcePhase_re, sourcePhase_im]

/-- Finite product of normalized Euler-kernel phases over a set `S`. -/
noncomputable def eulerKernelPhaseProd (S : Finset ℕ) (t : ℝ) : ℂ :=
  ∏ p in S, eulerKernelPhase p t

/-- Finite product of Euler-kernel medium factors over `S`. -/
noncomputable def eulerKernelMediumProd (S : Finset ℕ) (t θ : ℝ) : ℂ :=
  ∏ p in S, eulerKernelMedium p t θ

/-- Product-level normalized Euler decomposition over a finite set. -/
lemma eulerKernelPhaseProd_decomposition (S : Finset ℕ) (t θ : ℝ) :
    eulerKernelPhaseProd S t = sourcePhaseProd S θ * eulerKernelMediumProd S t θ := by
  unfold eulerKernelPhaseProd sourcePhaseProd eulerKernelMediumProd
  calc
    ∏ p in S, eulerKernelPhase p t
        = ∏ p in S, (sourcePhase θ * eulerKernelMedium p t θ) := by
          refine Finset.prod_congr rfl ?_
          intro p hp
          exact eulerKernelPhase_decomposition p t θ
    _ = (∏ _p in S, sourcePhase θ) * (∏ p in S, eulerKernelMedium p t θ) := by
          simpa using (Finset.prod_mul_distrib :
            (∏ x in S, sourcePhase θ * eulerKernelMedium x t θ)
              = (∏ x in S, sourcePhase θ) * (∏ x in S, eulerKernelMedium x t θ))

/-- Cardinal decomposition form on Euler local phases with constant source. -/
lemma eulerKernelPhaseProd_decomposition_pow (S : Finset ℕ) (t θ : ℝ) :
    eulerKernelPhaseProd S t
      = (sourcePhase θ) ^ S.card * eulerKernelMediumProd S t θ := by
  rw [eulerKernelPhaseProd_decomposition, sourcePhaseProd_eq_pow_card]

/-- Product form emphasizing constant source on the Euler side. -/
lemma eulerKernelPhaseProd_constant_source (S : Finset ℕ) (t θ : ℝ) :
    eulerKernelPhaseProd S t
      = (sourcePhase θ) ^ S.card * eulerKernelMediumProd S t θ := by
  simpa using eulerKernelPhaseProd_decomposition_pow S t θ

/-- Unified bridge for the three recent channels:
constant source `B`, Euler-side trigonometric Re/Im decomposition,
and normalized coherence `C(h) = sech(log h)`. -/
theorem euler_trig_coherence_bridge
    (p q : ℕ) (tp tq θ h : ℝ) (hh : 0 < h) :
    (∃ Bphase : ℂ,
      Bphase = sourcePhase θ
        ∧ eulerKernelPhase p tp = Bphase * eulerKernelMedium p tp θ
        ∧ eulerKernelPhase q tq = Bphase * eulerKernelMedium q tq θ)
      ∧
    (eulerKernelPhase p tp).re
      = (Real.cos θ) * (eulerKernelMedium p tp θ).re
        - (Real.sin θ) * (eulerKernelMedium p tp θ).im
      ∧
    (eulerKernelPhase p tp).im
      = (Real.cos θ) * (eulerKernelMedium p tp θ).im
        + (Real.sin θ) * (eulerKernelMedium p tp θ).re
      ∧
    coherenceC h = 1 / Real.cosh (Real.log h) := by
  refine ⟨eulerKernelPhase_two_primes_constant_source p q tp tq θ, ?_, ?_, ?_⟩
  · exact eulerKernelPhase_re_decomposition_const_source p tp θ
  · exact eulerKernelPhase_im_decomposition_const_source p tp θ
  · exact coherenceC_eq_sech_log_h h hh

/-- Partial Euler phase-core model (finite prime window). -/
noncomputable def partialEulerPhaseCore (S : Finset ℕ) (t θ : ℝ) : ℂ :=
  ∑ p in S, eulerKernelMedium p t θ

/-- Corresponding partial phase-velocity model: `i *` (partial core). -/
noncomputable def partialEulerPhaseVelocity (S : Finset ℕ) (t θ : ℝ) : ℂ :=
  Complex.I * partialEulerPhaseCore S t θ

/-- Re-channel of the partial Euler core is the sum of Re-channels. -/
lemma partialEulerPhaseCore_re (S : Finset ℕ) (t θ : ℝ) :
    (partialEulerPhaseCore S t θ).re
      = ∑ p in S, (eulerKernelMedium p t θ).re := by
  unfold partialEulerPhaseCore
  simp

/-- Im-channel of the partial Euler core is the sum of Im-channels. -/
lemma partialEulerPhaseCore_im (S : Finset ℕ) (t θ : ℝ) :
    (partialEulerPhaseCore S t θ).im
      = ∑ p in S, (eulerKernelMedium p t θ).im := by
  unfold partialEulerPhaseCore
  simp

/-- Re-channel of the phase velocity `i * core` equals `-Im(core)`. -/
lemma partialEulerPhaseVelocity_re (S : Finset ℕ) (t θ : ℝ) :
    (partialEulerPhaseVelocity S t θ).re
      = -(partialEulerPhaseCore S t θ).im := by
  unfold partialEulerPhaseVelocity
  simp [Complex.mul_re]

/-- Im-channel of the phase velocity `i * core` equals `Re(core)`. -/
lemma partialEulerPhaseVelocity_im (S : Finset ℕ) (t θ : ℝ) :
    (partialEulerPhaseVelocity S t θ).im
      = (partialEulerPhaseCore S t θ).re := by
  unfold partialEulerPhaseVelocity
  simp [Complex.mul_im]

/-- Channel mnemonic used in this file:
Hardy = local `Re` analysis, Euler = global `Im` analysis.

Formally, in the finite-window channel model this is recorded by the
`i`-rotation identities:
`Im(velocity) = Re(core)` and `Re(velocity) = -Im(core)`. -/
theorem hardy_local_re_euler_global_im_channel_principle
    (S : Finset ℕ) (t θ : ℝ) :
    (partialEulerPhaseVelocity S t θ).im = (partialEulerPhaseCore S t θ).re
      ∧ (partialEulerPhaseVelocity S t θ).re = -(partialEulerPhaseCore S t θ).im := by
  exact ⟨partialEulerPhaseVelocity_im S t θ, partialEulerPhaseVelocity_re S t θ⟩

/-- Re-channel velocity as a sum over medium-channel imaginary parts. -/
lemma partialEulerPhaseVelocity_re_sum (S : Finset ℕ) (t θ : ℝ) :
    (partialEulerPhaseVelocity S t θ).re
      = -∑ p in S, (eulerKernelMedium p t θ).im := by
  rw [partialEulerPhaseVelocity_re, partialEulerPhaseCore_im]

/-- Im-channel velocity as a sum over medium-channel real parts. -/
lemma partialEulerPhaseVelocity_im_sum (S : Finset ℕ) (t θ : ℝ) :
    (partialEulerPhaseVelocity S t θ).im
      = ∑ p in S, (eulerKernelMedium p t θ).re := by
  rw [partialEulerPhaseVelocity_im, partialEulerPhaseCore_re]

/-- Defect term between the full ξ-core and a finite partial Euler model. -/
noncomputable def xi_partialEuler_defect (S : Finset ℕ) (t θ : ℝ) : ℂ :=
  xi_logderiv_core_on_line t - partialEulerPhaseVelocity S t θ

/-- Exact algebraic split: full ξ-core = finite partial model + defect. -/
lemma xi_logderiv_core_split_partialEuler (S : Finset ℕ) (t θ : ℝ) :
    xi_logderiv_core_on_line t
      = partialEulerPhaseVelocity S t θ + xi_partialEuler_defect S t θ := by
  unfold xi_partialEuler_defect
  ring

/-- Rearranged version of `xi_logderiv_core_split_partialEuler`.

The prime indicates this is the definitional-equality form with the defect isolated
on the left-hand side, whereas `xi_logderiv_core_split_partialEuler` is the additive
reconstruction form with the full core on the left-hand side.
-/
lemma xi_logderiv_core_split_partialEuler' (S : Finset ℕ) (t θ : ℝ) :
    xi_partialEuler_defect S t θ
      = xi_logderiv_core_on_line t - partialEulerPhaseVelocity S t θ := by
  rfl

/-- Finite-prime window: primes less than `N`. -/
def prime_window (N : ℕ) : Finset ℕ :=
  (Finset.range N).filter Nat.Prime

/-- Window monotonicity: if `N₁ ≤ N₂`, then `prime_window N₁ ⊆ prime_window N₂`. -/
lemma prime_window_mono {N₁ N₂ : ℕ} (hN : N₁ ≤ N₂) :
    prime_window N₁ ⊆ prime_window N₂ := by
  intro p hp
  rcases Finset.mem_filter.mp hp with ⟨hp_range, hp_prime⟩
  refine Finset.mem_filter.mpr ?_
  constructor
  · exact Finset.mem_range.mpr (lt_of_lt_of_le (Finset.mem_range.mp hp_range) hN)
  · exact hp_prime

/-- Partial Euler core restricted to the first-`N` prime window. -/
noncomputable def partialEulerPhaseCore_window (N : ℕ) (t θ : ℝ) : ℂ :=
  partialEulerPhaseCore (prime_window N) t θ

/-- Partial Euler phase velocity restricted to the first-`N` prime window. -/
noncomputable def partialEulerPhaseVelocity_window (N : ℕ) (t θ : ℝ) : ℂ :=
  partialEulerPhaseVelocity (prime_window N) t θ

/-- Re-channel of windowed partial Euler core. -/
lemma partialEulerPhaseCore_window_re (N : ℕ) (t θ : ℝ) :
    (partialEulerPhaseCore_window N t θ).re
      = ∑ p in prime_window N, (eulerKernelMedium p t θ).re := by
  unfold partialEulerPhaseCore_window
  simpa using partialEulerPhaseCore_re (prime_window N) t θ

/-- Im-channel of windowed partial Euler core. -/
lemma partialEulerPhaseCore_window_im (N : ℕ) (t θ : ℝ) :
    (partialEulerPhaseCore_window N t θ).im
      = ∑ p in prime_window N, (eulerKernelMedium p t θ).im := by
  unfold partialEulerPhaseCore_window
  simpa using partialEulerPhaseCore_im (prime_window N) t θ

/-- Re-channel of windowed phase velocity. -/
lemma partialEulerPhaseVelocity_window_re (N : ℕ) (t θ : ℝ) :
    (partialEulerPhaseVelocity_window N t θ).re
      = -(partialEulerPhaseCore_window N t θ).im := by
  unfold partialEulerPhaseVelocity_window partialEulerPhaseCore_window
  simpa using partialEulerPhaseVelocity_re (prime_window N) t θ

/-- Im-channel of windowed phase velocity. -/
lemma partialEulerPhaseVelocity_window_im (N : ℕ) (t θ : ℝ) :
    (partialEulerPhaseVelocity_window N t θ).im
      = (partialEulerPhaseCore_window N t θ).re := by
  unfold partialEulerPhaseVelocity_window partialEulerPhaseCore_window
  simpa using partialEulerPhaseVelocity_im (prime_window N) t θ

/-- Windowed version of the Hardy/Euler channel mnemonic. -/
theorem hardy_local_re_euler_global_im_channel_principle_window
    (N : ℕ) (t θ : ℝ) :
    (partialEulerPhaseVelocity_window N t θ).im
        = (partialEulerPhaseCore_window N t θ).re
      ∧
      (partialEulerPhaseVelocity_window N t θ).re
        = -(partialEulerPhaseCore_window N t θ).im := by
  exact ⟨partialEulerPhaseVelocity_window_im N t θ,
    partialEulerPhaseVelocity_window_re N t θ⟩

/-- Re-channel of windowed phase velocity as a sum. -/
lemma partialEulerPhaseVelocity_window_re_sum (N : ℕ) (t θ : ℝ) :
    (partialEulerPhaseVelocity_window N t θ).re
      = -∑ p in prime_window N, (eulerKernelMedium p t θ).im := by
  rw [partialEulerPhaseVelocity_window_re, partialEulerPhaseCore_window_im]

/-- Im-channel of windowed phase velocity as a sum. -/
lemma partialEulerPhaseVelocity_window_im_sum (N : ℕ) (t θ : ℝ) :
    (partialEulerPhaseVelocity_window N t θ).im
      = ∑ p in prime_window N, (eulerKernelMedium p t θ).re := by
  rw [partialEulerPhaseVelocity_window_im, partialEulerPhaseCore_window_re]

/-- Constant-source statement over a full prime window. -/
lemma eulerKernelPhase_window_constant_source (N : ℕ) (t θ : ℝ) :
    ∃ Bphase : ℂ,
      Bphase = sourcePhase θ
        ∧ ∀ p ∈ prime_window N,
            eulerKernelPhase p t = Bphase * eulerKernelMedium p t θ := by
  refine ⟨sourcePhase θ, rfl, ?_⟩
  intro p hp
  simpa using eulerKernelPhase_decomposition p t θ

/-- Window-level bridge:
constant source on the whole prime window, trig Re/Im channel formulas for
window phase velocity, and normalized coherence `C(h)=sech(log h)`. -/
theorem euler_window_trig_coherence_bridge
    (N : ℕ) (t θ h : ℝ) (hh : 0 < h) :
    (∃ Bphase : ℂ,
      Bphase = sourcePhase θ
        ∧ ∀ p ∈ prime_window N,
            eulerKernelPhase p t = Bphase * eulerKernelMedium p t θ)
      ∧
    (partialEulerPhaseVelocity_window N t θ).re
      = -∑ p in prime_window N, (eulerKernelMedium p t θ).im
      ∧
    (partialEulerPhaseVelocity_window N t θ).im
      = ∑ p in prime_window N, (eulerKernelMedium p t θ).re
      ∧
    coherenceC h = 1 / Real.cosh (Real.log h) := by
  refine ⟨eulerKernelPhase_window_constant_source N t θ, ?_, ?_, ?_⟩
  · exact partialEulerPhaseVelocity_window_re_sum N t θ
  · exact partialEulerPhaseVelocity_window_im_sum N t θ
  · exact coherenceC_eq_sech_log_h h hh

/-- ξ-core defect against the first-`N` prime window model. -/
noncomputable def xi_partialEuler_defect_window (N : ℕ) (t θ : ℝ) : ℂ :=
  xi_partialEuler_defect (prime_window N) t θ

/-- Missing-prime core between two windows `N₁ ≤ N₂`. -/
noncomputable def missingPrimeCore (N₁ N₂ : ℕ) (t θ : ℝ) : ℂ :=
  ∑ p in (prime_window N₂) \ (prime_window N₁), eulerKernelMedium p t θ

/-- Prime-window tail bound target for the complex missing-prime sum (cancellation-based). -/
def PrimeWindowNormTailSmallGlobal : Prop :=
  ∀ t θ : ℝ, ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
    N0 ≤ N₁ → N₁ ≤ N₂ →
    ‖∑ p in (prime_window N₂) \ (prime_window N₁), eulerKernelMedium p t θ‖ < ε

/-- PNT/prime-sum cancellation interface for prime-window tails.
This isolates the analytic input expected from prime-distribution estimates. -/
def PNTPrimeWindowCancellationEstimate : Prop :=
  ∀ t θ : ℝ, ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
    N0 ≤ N₁ → N₁ ≤ N₂ →
    ‖∑ p in (prime_window N₂) \ (prime_window N₁), eulerKernelMedium p t θ‖ < ε

/-- Stage-1 analytic interface: cancellation on prime windows from oscillatory input. -/
def PrimeOscillationBound : Prop :=
  ∀ t θ : ℝ, ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
    N0 ≤ N₁ → N₁ ≤ N₂ →
    ‖∑ p in (prime_window N₂) \ (prime_window N₁), eulerKernelMedium p t θ‖ < ε

/-- Stage-2 transfer interface: oscillatory prime bounds imply PNT-window cancellation. -/
def AbelPartialSummationTransfer : Prop :=
  PrimeOscillationBound → PNTPrimeWindowCancellationEstimate

/-- Canonical analytic pipeline: oscillatory prime bounds transfer to PNT cancellation. -/
theorem pntPrimeWindowCancellationEstimate_of_transfer
    (hTransfer : AbelPartialSummationTransfer)
    (hOsc : PrimeOscillationBound) :
    PNTPrimeWindowCancellationEstimate :=
  hTransfer hOsc

/-- PNT-style cancellation estimate immediately yields the prime-window tail target. -/
theorem primeWindowNormTailSmallGlobal_of_PNT
    (hPNT : PNTPrimeWindowCancellationEstimate) :
    PrimeWindowNormTailSmallGlobal := by
  intro t θ ε hε
  exact hPNT t θ ε hε

/-- Missing-prime phase velocity between windows `N₁ ≤ N₂`. -/
noncomputable def missingPrimeVelocity (N₁ N₂ : ℕ) (t θ : ℝ) : ℂ :=
  Complex.I * missingPrimeCore N₁ N₂ t θ

/-- Core refinement identity:
window `N₂` equals window `N₁` plus the missing-prime core (`N₁ ≤ N₂`). -/
lemma partialEulerPhaseCore_window_refine {N₁ N₂ : ℕ} (hN : N₁ ≤ N₂) (t θ : ℝ) :
    partialEulerPhaseCore_window N₂ t θ
      = partialEulerPhaseCore_window N₁ t θ + missingPrimeCore N₁ N₂ t θ := by
  have hsub : prime_window N₁ ⊆ prime_window N₂ := prime_window_mono hN
  unfold partialEulerPhaseCore_window partialEulerPhaseCore missingPrimeCore
  calc
    ∑ p in prime_window N₂, eulerKernelMedium p t θ
        = (∑ p in prime_window N₁, eulerKernelMedium p t θ)
          + (∑ p in (prime_window N₂) \ (prime_window N₁), eulerKernelMedium p t θ) := by
            simpa [add_comm, add_left_comm, add_assoc] using
              (Finset.sum_subset hsub (by
                intro x hx2 hx1
                exfalso
                exact hx1 hx2)).symm
    _ = partialEulerPhaseCore_window N₁ t θ + missingPrimeCore N₁ N₂ t θ := by
          rfl

/-- Velocity refinement identity for prime windows. -/
lemma partialEulerPhaseVelocity_window_refine {N₁ N₂ : ℕ} (hN : N₁ ≤ N₂) (t θ : ℝ) :
    partialEulerPhaseVelocity_window N₂ t θ
      = partialEulerPhaseVelocity_window N₁ t θ + missingPrimeVelocity N₁ N₂ t θ := by
  unfold partialEulerPhaseVelocity_window partialEulerPhaseVelocity missingPrimeVelocity
  rw [partialEulerPhaseCore_window_refine hN t θ]
  ring

/-- Defect refinement identity between windows (`N₁ ≤ N₂`). -/
lemma xi_partialEuler_defect_window_refine {N₁ N₂ : ℕ} (hN : N₁ ≤ N₂) (t θ : ℝ) :
    xi_partialEuler_defect_window N₂ t θ
      = xi_partialEuler_defect_window N₁ t θ - missingPrimeVelocity N₁ N₂ t θ := by
  unfold xi_partialEuler_defect_window xi_partialEuler_defect
    partialEulerPhaseVelocity_window
  rw [partialEulerPhaseVelocity_window_refine hN t θ]
  ring

/-- Quantitative refinement bound:
window-to-window defect jump is controlled by the norm of the missing-prime sum. -/
lemma xi_partialEuler_defect_window_refine_norm_le {N₁ N₂ : ℕ} (hN : N₁ ≤ N₂) (t θ : ℝ) :
    ‖xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ‖
      ≤ ∑ p in (prime_window N₂) \ (prime_window N₁), ‖eulerKernelMedium p t θ‖ := by
  have href := xi_partialEuler_defect_window_refine hN t θ
  have hdiff :
      xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ
        = -missingPrimeVelocity N₁ N₂ t θ := by
    linarith [href]
  rw [hdiff, missingPrimeVelocity]
  calc
    ‖-Complex.I * missingPrimeCore N₁ N₂ t θ‖
        = ‖missingPrimeCore N₁ N₂ t θ‖ := by
          simp [norm_mul]
    _ = ‖∑ p in (prime_window N₂) \ (prime_window N₁), eulerKernelMedium p t θ‖ := by
          rfl
    _ ≤ ∑ p in (prime_window N₂) \ (prime_window N₁), ‖eulerKernelMedium p t θ‖ := by
          exact norm_sum_le _ _

/-- Re-channel of the missing-prime core is the sum of Re-channels. -/
lemma missingPrimeCore_re (N₁ N₂ : ℕ) (t θ : ℝ) :
    (missingPrimeCore N₁ N₂ t θ).re
      = ∑ p in (prime_window N₂) \ (prime_window N₁), (eulerKernelMedium p t θ).re := by
  unfold missingPrimeCore
  simp

/-- Im-channel of the missing-prime core is the sum of Im-channels. -/
lemma missingPrimeCore_im (N₁ N₂ : ℕ) (t θ : ℝ) :
    (missingPrimeCore N₁ N₂ t θ).im
      = ∑ p in (prime_window N₂) \ (prime_window N₁), (eulerKernelMedium p t θ).im := by
  unfold missingPrimeCore
  simp

/-- If prime-window complex tails are eventually small, then `missingPrimeCore` is Cauchy-tail small.
This is the reusable cancellation-based bridge to `MissingPrimeCoreCauchyTailGlobal`. -/
theorem missingPrimeCore_tail_bound_of_abs_summable
    (hTailNorm : PrimeWindowNormTailSmallGlobal) :
    MissingPrimeCoreCauchyTailGlobal := by
  intro t θ ε hε
  rcases hTailNorm t θ ε hε with ⟨N0, hN0⟩
  refine ⟨N0, ?_⟩
  intro N₁ N₂ hle₁ hle₂
  simpa [missingPrimeCore] using hN0 N₁ N₂ hle₁ hle₂

/-- Re-channel of missing-prime velocity `i * core` is `-Im(core)`. -/
lemma missingPrimeVelocity_re (N₁ N₂ : ℕ) (t θ : ℝ) :
    (missingPrimeVelocity N₁ N₂ t θ).re
      = -(missingPrimeCore N₁ N₂ t θ).im := by
  unfold missingPrimeVelocity
  simp [Complex.mul_re]

/-- Im-channel of missing-prime velocity `i * core` is `Re(core)`. -/
lemma missingPrimeVelocity_im (N₁ N₂ : ℕ) (t θ : ℝ) :
    (missingPrimeVelocity N₁ N₂ t θ).im
      = (missingPrimeCore N₁ N₂ t θ).re := by
  unfold missingPrimeVelocity
  simp [Complex.mul_im]

/-- Re-channel refinement identity for defects between windows. -/
lemma xi_partialEuler_defect_window_refine_re {N₁ N₂ : ℕ} (hN : N₁ ≤ N₂) (t θ : ℝ) :
    (xi_partialEuler_defect_window N₂ t θ).re
      = (xi_partialEuler_defect_window N₁ t θ).re - (missingPrimeVelocity N₁ N₂ t θ).re := by
  exact congrArg Complex.re (xi_partialEuler_defect_window_refine hN t θ)

/-- Im-channel refinement identity for defects between windows. -/
lemma xi_partialEuler_defect_window_refine_im {N₁ N₂ : ℕ} (hN : N₁ ≤ N₂) (t θ : ℝ) :
    (xi_partialEuler_defect_window N₂ t θ).im
      = (xi_partialEuler_defect_window N₁ t θ).im - (missingPrimeVelocity N₁ N₂ t θ).im := by
  exact congrArg Complex.im (xi_partialEuler_defect_window_refine hN t θ)

/-- Exact Re-channel jump formula for defect refinement. -/
lemma xi_partialEuler_defect_window_jump_re {N₁ N₂ : ℕ} (hN : N₁ ≤ N₂) (t θ : ℝ) :
    (xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ).re
      = (missingPrimeCore N₁ N₂ t θ).im := by
  have href := xi_partialEuler_defect_window_refine hN t θ
  have hdiff :
      xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ
        = -missingPrimeVelocity N₁ N₂ t θ := by
    linarith [href]
  rw [hdiff, missingPrimeVelocity]
  simp [Complex.mul_re]

/-- Exact Im-channel jump formula for defect refinement. -/
lemma xi_partialEuler_defect_window_jump_im {N₁ N₂ : ℕ} (hN : N₁ ≤ N₂) (t θ : ℝ) :
    (xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ).im
      = -(missingPrimeCore N₁ N₂ t θ).re := by
  have href := xi_partialEuler_defect_window_refine hN t θ
  have hdiff :
      xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ
        = -missingPrimeVelocity N₁ N₂ t θ := by
    linarith [href]
  rw [hdiff, missingPrimeVelocity]
  simp [Complex.mul_im]

/-- Re-channel quantitative defect bound from the norm refinement bound. -/
lemma xi_partialEuler_defect_window_refine_re_abs_le {N₁ N₂ : ℕ} (hN : N₁ ≤ N₂) (t θ : ℝ) :
    |(xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ).re|
      ≤ ∑ p in (prime_window N₂) \ (prime_window N₁), ‖eulerKernelMedium p t θ‖ := by
  have hre :
      |(xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ).re|
        ≤ ‖xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ‖ := by
    simpa using Complex.abs_re_le_norm
      (xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ)
  exact le_trans hre (xi_partialEuler_defect_window_refine_norm_le hN t θ)

/-- Im-channel quantitative defect bound from the norm refinement bound. -/
lemma xi_partialEuler_defect_window_refine_im_abs_le {N₁ N₂ : ℕ} (hN : N₁ ≤ N₂) (t θ : ℝ) :
    |(xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ).im|
      ≤ ∑ p in (prime_window N₂) \ (prime_window N₁), ‖eulerKernelMedium p t θ‖ := by
  have him :
      |(xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ).im|
        ≤ ‖xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ‖ := by
    simpa using Complex.abs_im_le_norm
      (xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ)
  exact le_trans him (xi_partialEuler_defect_window_refine_norm_le hN t θ)

/-- Window master channel theorem:
bundles constant-source Euler factorization on a window, window velocity
Re/Im channel sums, defect jump identities and bounds, and normalized
coherence `C(h)=sech(log h)`. -/
theorem euler_window_master_channel_theorem
    (N N₁ N₂ : ℕ) (hN : N₁ ≤ N₂) (t θ h : ℝ) (hh : 0 < h) :
    (∃ Bphase : ℂ,
      Bphase = sourcePhase θ
        ∧ ∀ p ∈ prime_window N,
            eulerKernelPhase p t = Bphase * eulerKernelMedium p t θ)
      ∧
    (partialEulerPhaseVelocity_window N t θ).re
      = -∑ p in prime_window N, (eulerKernelMedium p t θ).im
      ∧
    (partialEulerPhaseVelocity_window N t θ).im
      = ∑ p in prime_window N, (eulerKernelMedium p t θ).re
      ∧
    (xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ).re
      = (missingPrimeCore N₁ N₂ t θ).im
      ∧
    (xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ).im
      = -(missingPrimeCore N₁ N₂ t θ).re
      ∧
    |(xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ).re|
      ≤ ∑ p in (prime_window N₂) \ (prime_window N₁), ‖eulerKernelMedium p t θ‖
      ∧
    |(xi_partialEuler_defect_window N₂ t θ - xi_partialEuler_defect_window N₁ t θ).im|
      ≤ ∑ p in (prime_window N₂) \ (prime_window N₁), ‖eulerKernelMedium p t θ‖
      ∧
    coherenceC h = 1 / Real.cosh (Real.log h) := by
  refine ⟨eulerKernelPhase_window_constant_source N t θ, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
  · exact partialEulerPhaseVelocity_window_re_sum N t θ
  · exact partialEulerPhaseVelocity_window_im_sum N t θ
  · exact xi_partialEuler_defect_window_jump_re hN t θ
  · exact xi_partialEuler_defect_window_jump_im hN t θ
  · exact xi_partialEuler_defect_window_refine_re_abs_le hN t θ
  · exact xi_partialEuler_defect_window_refine_im_abs_le hN t θ
  · exact coherenceC_eq_sech_log_h h hh

/-! ### 2-D Lorentzian defect scaffold

This layer introduces an `s : ℂ` window model and the reflection defect
`D_N(s) = W_N(s) - W_N(1-s)`. It is designed so the final rigidity step can be
threaded through explicit phase-lock/defect boundaries rather than a hidden jump.
-/

/-- Centered real coordinate `x = Re(s) - 1/2`. -/
def lorentzian_x (s : ℂ) : ℝ := s.re - 1 / 2

/-- Centered imaginary coordinate `y = Im(s)` used with `x = Re(s)-1/2`. -/
def lorentzian_y (s : ℂ) : ℝ := s.im

/-- Reflection used by the functional equation on the `s`-plane. -/
def lorentzian_reflect (s : ℂ) : ℂ := 1 - s

/-- Finite 2-D Euler product model over a prime window. -/
noncomputable def partialEulerProduct2D (S : Finset ℕ) (s : ℂ) : ℂ :=
  ∏ p in S, (1 - (p : ℂ) ^ (-s))⁻¹

/-- 2-D ξ-window model using the same polynomial/Gamma envelope. -/
noncomputable def xi_partial2D (S : Finset ℕ) (s : ℂ) : ℂ :=
  ((1 / 2 : ℂ) * s * (s - 1) * ((Real.pi : ℂ) ^ (-s / 2)) * Complex.Gamma (s / 2))
    * partialEulerProduct2D S s

/-- Finite-window approximation in `N`-index notation:
`W_N(s) = ξ_N(s)` over the prime window `p ≤ N`. -/
noncomputable def xi_window (N : ℕ) (s : ℂ) : ℂ :=
  xi_partial2D (prime_window N) s

/-- 2-D reflection defect `D_N(s) = W_N(s) - W_N(1-s)`. -/
noncomputable def xi_partial_defect2D (S : Finset ℕ) (s : ℂ) : ℂ :=
  xi_partial2D S s - xi_partial2D S (lorentzian_reflect s)

/-- Defect in `N`-index notation: antisymmetric part under `s ↦ 1-s`. -/
noncomputable def defect (N : ℕ) (s : ℂ) : ℂ :=
  xi_window N s - xi_window N (lorentzian_reflect s)

/-- `N`-indexed defect is definitionally the 2-D defect over `prime_window N`. -/
lemma defect_eq_xi_partial_defect2D_window (N : ℕ) (s : ℂ) :
    defect N s = xi_partial_defect2D (prime_window N) s := by
  unfold defect xi_window xi_partial_defect2D
  rfl

/-- Reflection involution in `s`-coordinates. -/
lemma lorentzian_reflect_involutive (s : ℂ) :
    lorentzian_reflect (lorentzian_reflect s) = s := by
  unfold lorentzian_reflect
  ring

/-- 2-D defect is antisymmetric under `s ↦ 1-s`. -/
lemma xi_partial_defect2D_antisym (S : Finset ℕ) (s : ℂ) :
    xi_partial_defect2D S (lorentzian_reflect s) = -xi_partial_defect2D S s := by
  unfold xi_partial_defect2D lorentzian_reflect
  ring

/-- Antisymmetry of the `N`-indexed defect under `s ↦ 1-s`. -/
lemma defect_antisym (N : ℕ) (s : ℂ) :
    defect N (lorentzian_reflect s) = -defect N s := by
  simpa [defect_eq_xi_partial_defect2D_window] using
    xi_partial_defect2D_antisym (prime_window N) s

/-- Reflection flips the centered real coordinate. -/
lemma lorentzian_x_reflect (s : ℂ) :
    lorentzian_x (lorentzian_reflect s) = -lorentzian_x s := by
  unfold lorentzian_x lorentzian_reflect
  simp
  ring

/-- Reflection also flips the centered imaginary coordinate. -/
lemma lorentzian_y_reflect (s : ℂ) :
    lorentzian_y (lorentzian_reflect s) = -lorentzian_y s := by
  unfold lorentzian_y lorentzian_reflect
  simp

/-- In centered coordinates `(x,y)=(Re(s)-1/2, Im(s))`, `s ↦ 1-s` is central reflection:
`(x,y) ↦ (-x,-y)`. -/
theorem lorentzian_reflect_centered_coords (s : ℂ) :
    (lorentzian_x (lorentzian_reflect s), lorentzian_y (lorentzian_reflect s))
      = (-lorentzian_x s, -lorentzian_y s) := by
  exact ⟨lorentzian_x_reflect s, lorentzian_y_reflect s⟩

/-- Centered reflection equals two quarter-turns in the same matrix channel used by `F(s,t)`. -/
theorem lorentzian_reflect_centered_coords_eq_rotate90_twice (s : ℂ) :
    (lorentzian_x (lorentzian_reflect s), lorentzian_y (lorentzian_reflect s))
      = rotate90_pair (rotate90_pair (lorentzian_x s) (lorentzian_y s)).1
          (rotate90_pair (lorentzian_x s) (lorentzian_y s)).2 := by
  calc
    (lorentzian_x (lorentzian_reflect s), lorentzian_y (lorentzian_reflect s))
        = (-lorentzian_x s, -lorentzian_y s) := lorentzian_reflect_centered_coords s
    _ = rotate90_pair (rotate90_pair (lorentzian_x s) (lorentzian_y s)).1
          (rotate90_pair (lorentzian_x s) (lorentzian_y s)).2 := by
            symm
            exact rotate90_pair_twice (lorentzian_x s) (lorentzian_y s)

/-- Coordinate-level action of `s ↦ 1-s` through the `F(s,t)` channel. -/
theorem bridgeF_of_lorentzian_reflect_coords (s : ℂ) (t : ℝ) :
    ((bridgeF (lorentzian_reflect s) t).re, (bridgeF (lorentzian_reflect s) t).im)
      = (t + s.im, 1 - s.re) := by
  unfold lorentzian_reflect
  simp [bridgeF_re, bridgeF_im]

/-- In centered coordinates, `s ↦ 1-s` corresponds to central reflection and then
the same `F` quarter-turn/translation channel. -/
theorem bridgeF_lorentzian_reflect_centered_decomposition (s : ℂ) (t : ℝ) :
    ((bridgeF (lorentzian_reflect s) t).re, (bridgeF (lorentzian_reflect s) t).im)
      = (t + lorentzian_y s, 1 / 2 - lorentzian_x s) := by
  unfold lorentzian_y lorentzian_x
  have h := bridgeF_of_lorentzian_reflect_coords s t
  simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using h

/-- `180°` centered reflection fixes the `x`-axis center exactly when `x=0`,
i.e. exactly on the critical-line center `Re(s)=1/2`. -/
theorem centered_reflection_180_fix_iff_critical_center (s : ℂ) :
    lorentzian_x (lorentzian_reflect s) = lorentzian_x s
      ↔ s.re = 1 / 2 := by
  rw [lorentzian_x_reflect]
  constructor
  · intro h
    have hx0 : lorentzian_x s = 0 := by linarith
    unfold lorentzian_x at hx0
    linarith
  · intro h
    unfold lorentzian_x
    linarith

/-- Lorentzian matrix-decomposition master package for `F(s,t)` and `s ↦ 1-s`.
This bundles the quarter-turn matrix form, centered reflection geometry, and
the reflected `F`-coordinate decomposition into one reusable theorem. -/
theorem lorentzian_matrix_decomposition_master (s : ℂ) (t : ℝ) :
    (((bridgeF s t).re, (bridgeF s t).im) = (t - s.im, s.re))
      ∧ ((lorentzian_x (lorentzian_reflect s), lorentzian_y (lorentzian_reflect s))
            = (-lorentzian_x s, -lorentzian_y s))
      ∧ ((lorentzian_x (lorentzian_reflect s), lorentzian_y (lorentzian_reflect s))
            = rotate90_pair (rotate90_pair (lorentzian_x s) (lorentzian_y s)).1
                (rotate90_pair (lorentzian_x s) (lorentzian_y s)).2)
      ∧ (((bridgeF (lorentzian_reflect s) t).re, (bridgeF (lorentzian_reflect s) t).im)
            = (t + lorentzian_y s, 1 / 2 - lorentzian_x s)) := by
  refine ⟨bridgeF_as_matrix_affine_explicit s t, ?_, ?_, ?_⟩
  · exact lorentzian_reflect_centered_coords s
  · exact lorentzian_reflect_centered_coords_eq_rotate90_twice s
  · exact bridgeF_lorentzian_reflect_centered_decomposition s t

/-- `N`-indexed Lorentzian factorization of the defect:
`D_N(s) = (Re(s)-1/2) * M_N(s)` for some profile `M_N`. -/
lemma defect_factors
    (hfactor_boundary : ∀ S : Finset ℕ,
      ∃ M : ℂ → ℂ, ∀ s : ℂ,
        xi_partial_defect2D S s = ((lorentzian_x s : ℂ)) * M s)
    (N : ℕ) :
    ∃ M : ℂ → ℂ, ∀ s : ℂ,
      defect N s = ((s.re - 1 / 2 : ℝ) : ℂ) * M s := by
  rcases hfactor_boundary (prime_window N) with ⟨M, hM⟩
  refine ⟨M, ?_⟩
  intro s
  simpa [defect_eq_xi_partial_defect2D_window, lorentzian_x] using hM s

/-! ### Convergence / Hurwitz boundary

These declarations state the analytic closure needed to pass from finite windows
to the full ξ-core phase-velocity relation and zero-set limits.
-/

/-- Window model used for zero approximation at level `N`. -/
noncomputable def partialEulerWindowFunction (N : ℕ) (s : ℂ) : ℂ :=
  partialEulerPhaseCore_window N s.im 0

/-- Lattice coordinate map in the `s`-plane: `s = σ + it`. -/
noncomputable def latticePoint (σ t : ℝ) : ℂ :=
  (σ : ℂ) + t * Complex.I

/-- The real coordinate of `latticePoint σ t` is `σ`. -/
lemma latticePoint_re (σ t : ℝ) :
    (latticePoint σ t).re = σ := by
  simp [latticePoint]

/-- The imaginary coordinate of `latticePoint σ t` is `t`. -/
lemma latticePoint_im (σ t : ℝ) :
    (latticePoint σ t).im = t := by
  simp [latticePoint]

/-- `F(s,t)`-style window channel, evaluated on the lattice point `σ + it`. -/
noncomputable def F_lattice (N : ℕ) (σ t : ℝ) : ℂ :=
  partialEulerWindowFunction N (latticePoint σ t)

/-- Evaluating the window function on `σ + it` depends only on the `t` channel. -/
lemma partialEulerWindowFunction_latticePoint (N : ℕ) (σ t : ℝ) :
    partialEulerWindowFunction N (latticePoint σ t)
      = partialEulerPhaseCore_window N t 0 := by
  simp [partialEulerWindowFunction, latticePoint]

/-- Explicit `F(s,t)` identity: the lattice channel is the windowed phase core at `t`. -/
lemma F_lattice_eq_partialEulerPhaseCore_window (N : ℕ) (σ t : ℝ) :
    F_lattice N σ t = partialEulerPhaseCore_window N t 0 := by
  simpa [F_lattice] using partialEulerWindowFunction_latticePoint N σ t

/-- Critical-line specialization of `F(s,t)` at `σ = 1/2`. -/
lemma F_lattice_on_critical_line (N : ℕ) (t : ℝ) :
    F_lattice N (1 / 2) t = partialEulerPhaseCore_window N t 0 := by
  simpa using F_lattice_eq_partialEulerPhaseCore_window N (1 / 2) t

/-- Zero-set lattice form: `σ + it` is a window zero iff `F_lattice N σ t = 0`. -/
lemma mem_zeros_of_partial_lattice_iff (N : ℕ) (σ t : ℝ) :
    latticePoint σ t ∈ zeros_of_partial N ↔ F_lattice N σ t = 0 := by
  simp [zeros_of_partial, F_lattice]

/-- 2-D naming bridge for the window model.
This keeps the existing implementation while threading the Lorentzian scaffold names. -/
noncomputable def partialEulerWindowFunction2D (N : ℕ) (s : ℂ) : ℂ :=
  partialEulerWindowFunction N s

/-- The legacy window model is definitionally the 2-D-named window model. -/
lemma partialEulerWindowFunction_eq_2D (N : ℕ) (s : ℂ) :
    partialEulerWindowFunction N s = partialEulerWindowFunction2D N s := rfl

/-- Reflection defect at finite window level in the 2-D naming layer. -/
noncomputable def partialEulerWindowDefect2D (N : ℕ) (s : ℂ) : ℂ :=
  partialEulerWindowFunction2D N s - partialEulerWindowFunction2D N (lorentzian_reflect s)

/-- Window-level defect antisymmetry under `s ↦ 1-s`. -/
lemma partialEulerWindowDefect2D_antisym (N : ℕ) (s : ℂ) :
    partialEulerWindowDefect2D N (lorentzian_reflect s) = -partialEulerWindowDefect2D N s := by
  unfold partialEulerWindowDefect2D lorentzian_reflect
  ring

/-- Zero set of the `N`-window model. -/
def zeros_of_partial (N : ℕ) : Set ℂ :=
  {s : ℂ | partialEulerWindowFunction N s = 0}

/-- 2-D naming bridge for window-zero sets. -/
def zeros_of_partial2D (N : ℕ) : Set ℂ :=
  {s : ℂ | partialEulerWindowFunction2D N s = 0}

/-- The zero-set predicates agree between legacy and 2-D naming. -/
lemma mem_zeros_of_partial_iff_mem_zeros_of_partial2D (N : ℕ) (s : ℂ) :
    s ∈ zeros_of_partial N ↔ s ∈ zeros_of_partial2D N := by
  simp [zeros_of_partial, zeros_of_partial2D, partialEulerWindowFunction2D]

/-- Convert a limit-of-window-zeros assumption to the 2-D naming layer. -/
lemma window_zero_limit_to_2D_names (s : ℂ)
    (hlim : ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, sN N ∈ zeros_of_partial N) ∧
      Filter.Tendsto sN Filter.atTop (nhds s)) :
    ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, sN N ∈ zeros_of_partial2D N) ∧
      Filter.Tendsto sN Filter.atTop (nhds s) := by
  rcases hlim with ⟨sN, hsNzero, hsNtendsto⟩
  refine ⟨sN, ?_, hsNtendsto⟩
  intro N
  exact (mem_zeros_of_partial_iff_mem_zeros_of_partial2D N (sN N)).1 (hsNzero N)

/-- Convert a 2-D-named limit-of-window-zeros assumption back to legacy naming. -/
lemma window_zero_limit_from_2D_names (s : ℂ)
    (hlim2D : ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, sN N ∈ zeros_of_partial2D N) ∧
      Filter.Tendsto sN Filter.atTop (nhds s)) :
    ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, sN N ∈ zeros_of_partial N) ∧
      Filter.Tendsto sN Filter.atTop (nhds s) := by
  rcases hlim2D with ⟨sN, hsNzero, hsNtendsto⟩
  refine ⟨sN, ?_, hsNtendsto⟩
  intro N
  exact (mem_zeros_of_partial_iff_mem_zeros_of_partial2D N (sN N)).2 (hsNzero N)

/-- Every complex point is its own lattice reconstruction from real/imaginary channels. -/
lemma latticePoint_re_im (s : ℂ) :
    latticePoint s.re s.im = s := by
  ext <;> simp [latticePoint]

/-- Convert a complex zero-limit sequence into lattice `F(s,t)` channels. -/
lemma window_zero_limit_to_F_lattice (s : ℂ)
    (hlim : ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, sN N ∈ zeros_of_partial N) ∧
      Filter.Tendsto sN Filter.atTop (nhds s)) :
    ∃ σN tN : ℕ → ℝ,
      (∀ N : ℕ, F_lattice N (σN N) (tN N) = 0) ∧
      Filter.Tendsto (fun N : ℕ => latticePoint (σN N) (tN N)) Filter.atTop (nhds s) := by
  rcases hlim with ⟨sN, hsNzero, hsNtendsto⟩
  refine ⟨(fun N => (sN N).re), (fun N => (sN N).im), ?_, ?_⟩
  · intro N
    have hs_zero : sN N ∈ zeros_of_partial N := hsNzero N
    have hs_lattice_zero : latticePoint (sN N).re (sN N).im ∈ zeros_of_partial N := by
      simpa [latticePoint_re_im] using hs_zero
    exact (mem_zeros_of_partial_lattice_iff N (sN N).re (sN N).im).1 hs_lattice_zero
  · simpa [latticePoint_re_im] using hsNtendsto

/-- Convert lattice `F(s,t)` zero-limit data back to the complex window-zero interface. -/
lemma window_zero_limit_from_F_lattice (s : ℂ)
    (hF : ∃ σN tN : ℕ → ℝ,
      (∀ N : ℕ, F_lattice N (σN N) (tN N) = 0) ∧
      Filter.Tendsto (fun N : ℕ => latticePoint (σN N) (tN N)) Filter.atTop (nhds s)) :
    ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, sN N ∈ zeros_of_partial N) ∧
      Filter.Tendsto sN Filter.atTop (nhds s) := by
  rcases hF with ⟨σN, tN, hFzero, hFtendsto⟩
  refine ⟨fun N => latticePoint (σN N) (tN N), ?_, hFtendsto⟩
  intro N
  exact (mem_zeros_of_partial_lattice_iff N (σN N) (tN N)).2 (hFzero N)

/-- F-lattice boundary form: zeta-zeros are limits of finite-window lattice-channel zeros. -/
def F_lattice_zero_limit_boundary : Prop :=
  ∀ s : ℂ, riemannZeta s = 0 →
    ∃ σN tN : ℕ → ℝ,
      (∀ N : ℕ, F_lattice N (σN N) (tN N) = 0) ∧
      Filter.Tendsto (fun N : ℕ => latticePoint (σN N) (tN N)) Filter.atTop (nhds s)

/-- Standard window-zero boundary form (complex-sequence channel). -/
def window_zero_limit_boundary : Prop :=
  ∀ s : ℂ, riemannZeta s = 0 →
    ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, partialEulerWindowFunction N (sN N) = 0) ∧
      Filter.Tendsto sN Filter.atTop (nhds s)

/-- The `F(s,t)` lattice boundary implies the standard window-zero limit boundary. -/
theorem zeta_zero_is_limit_of_window_zeros_of_F_lattice_boundary
    (hF : F_lattice_zero_limit_boundary) :
    ∀ s : ℂ, riemannZeta s = 0 →
      ∃ sN : ℕ → ℂ,
        (∀ N : ℕ, partialEulerWindowFunction N (sN N) = 0) ∧
        Filter.Tendsto sN Filter.atTop (nhds s) := by
  intro s hz
  have hF_at_s :
      ∃ σN tN : ℕ → ℝ,
        (∀ N : ℕ, F_lattice N (σN N) (tN N) = 0) ∧
        Filter.Tendsto (fun N : ℕ => latticePoint (σN N) (tN N)) Filter.atTop (nhds s) :=
    hF s hz
  rcases window_zero_limit_from_F_lattice s hF_at_s with ⟨sN, hsNzero, hsNtendsto⟩
  refine ⟨sN, ?_, hsNtendsto⟩
  intro N
  simpa [zeros_of_partial] using hsNzero N

/-- Step-1 airtight target for the endpoint route: prove the window-zero limit boundary. -/
def Step1_window_zero_limit_target : Prop :=
  window_zero_limit_boundary

/-- Local epsilon-approximation schema at zeta zeros using finite-window lattice zeros. -/
def Step1LocalApproximationSchema : Prop :=
  ∀ s : ℂ, riemannZeta s = 0 →
    ∀ ε : ℝ, 0 < ε →
      ∃ N : ℕ, ∃ σ t : ℝ,
        F_lattice N σ t = 0 ∧ ‖latticePoint σ t - s‖ < ε

/-- Tail-control schema for Step 1: window cores form an explicit Cauchy family
with quantitative control in terms of window differences. -/
def Step1TailControlSchema : Prop :=
  ∀ t θ : ℝ,
    ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
      N0 ≤ N₁ → N₁ ≤ N₂ →
      ‖partialEulerPhaseCore_window N₂ t θ - partialEulerPhaseCore_window N₁ t θ‖ < ε

/-- Velocity-transfer schema for Step 1: window velocity converges to ξ-core velocity. -/
def Step1VelocityTransferSchema : Prop :=
  ∀ t θ : ℝ,
    Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ)
      Filter.atTop (nhds (xi_logderiv_core_on_line t))

/-- Critical-line phase-velocity identity schema used by the analytic lock bridge. -/
def Step1PhaseVelocityIdentitySchema : Prop :=
  ∀ t : ℝ,
    deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t
      = Complex.I * xi_logderiv_core_on_line t

/-- Zero-stability transfer: local lattice zero capture upgrades to a convergent
window-zero sequence at each zeta zero. -/
def Step1ZeroStabilityTransfer : Prop :=
  ∀ s : ℂ, riemannZeta s = 0 →
    ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, sN N ∈ zeros_of_partial N) ∧
      Filter.Tendsto sN Filter.atTop (nhds s)

/-- Named approximation frontier for Step 1 (Hurwitz/Rouché-style landing interface). -/
def Step1ApproximationFrontier : Prop :=
  F_lattice_zero_limit_boundary
  ∧ Step1LocalApproximationSchema
  ∧ Step1ZeroStabilityTransfer
  ∧ Step1TailControlSchema
  ∧ Step1VelocityTransferSchema
  ∧ Step1PhaseVelocityIdentitySchema
  ∧
  (∀ N : ℕ, ∀ s : ℂ,
    F_lattice N s.re s.im = partialEulerWindowFunction N s)

/-- Reduced Step-1 frontier: the four independent clauses.
The local approximation / zero-stability / lattice-channel clauses are derivable. -/
def Step1ReducedFrontier : Prop :=
  F_lattice_zero_limit_boundary
  ∧ Step1TailControlSchema
  ∧ Step1VelocityTransferSchema
  ∧ Step1PhaseVelocityIdentitySchema

/-- The lattice zero-limit boundary implies local epsilon-approximation at zeta zeros. -/
theorem step1_local_approximation_of_F_lattice_boundary
    (hF : F_lattice_zero_limit_boundary) :
    Step1LocalApproximationSchema := by
  intro s hz ε hε
  rcases hF s hz with ⟨σN, tN, hFzero, hFtendsto⟩
  have hball : Metric.ball s ε ∈ nhds s := Metric.ball_mem_nhds s hε
  have hEventual :
      ∀ᶠ N in Filter.atTop, latticePoint (σN N) (tN N) ∈ Metric.ball s ε :=
    hFtendsto hball
  rcases Filter.eventually_atTop.1 hEventual with ⟨N0, hN0⟩
  refine ⟨N0, σN N0, tN N0, hFzero N0, ?_⟩
  have hmem : latticePoint (σN N0) (tN N0) ∈ Metric.ball s ε :=
    hN0 N0 le_rfl
  simpa [Metric.mem_ball, dist_eq_norm] using hmem

/-- The lattice zero-limit boundary implies the zero-stability transfer clause. -/
theorem step1_zero_stability_transfer_of_F_lattice_boundary
    (hF : F_lattice_zero_limit_boundary) :
    Step1ZeroStabilityTransfer := by
  intro s hz
  exact window_zero_limit_from_F_lattice s (hF s hz)

/-- Missing-prime Cauchy-tail control implies the Step-1 window tail-control schema. -/
theorem step1_tail_control_of_missingPrimeCore_cauchy_tail
    (hTail : (t θ : ℝ) :
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ →
        ‖missingPrimeCore N₁ N₂ t θ‖ < ε) :
    Step1TailControlSchema := by
  intro t θ ε hε
  rcases hTail t θ ε hε with ⟨N0, hN0⟩
  refine ⟨N0, ?_⟩
  intro N₁ N₂ hle₁ hle₂
  have href := partialEulerPhaseCore_window_refine hle₂ t θ
  have hdiff :
      partialEulerPhaseCore_window N₂ t θ - partialEulerPhaseCore_window N₁ t θ
        = missingPrimeCore N₁ N₂ t θ := by
    linarith [href]
  have hnorm :
      ‖partialEulerPhaseCore_window N₂ t θ - partialEulerPhaseCore_window N₁ t θ‖
        = ‖missingPrimeCore N₁ N₂ t θ‖ := by
    simpa [hdiff]
  have htail := hN0 N₁ N₂ hle₁ hle₂
  simpa [hnorm] using htail

/-- Window-velocity convergence assumption implies the Step-1 velocity-transfer schema. -/
theorem step1_velocity_transfer_of_partialEulerPhaseVelocity_window_tendsto
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ)
        Filter.atTop (nhds (xi_logderiv_core_on_line t))) :
    Step1VelocityTransferSchema := by
  intro t θ
  exact hVel t θ

/-- Minimal analytic target behind Step-1 velocity transfer:
the window defect in the ξ-logderivative channel tends to `0`. -/
def PartialEulerDefectWindowTendstoZeroGlobal : Prop :=
  ∀ t θ : ℝ,
    Filter.Tendsto (fun N : ℕ => xi_partialEuler_defect_window N t θ)
      Filter.atTop (nhds (0 : ℂ))

/-- Bridge hypothesis identifying the Step-1 Euler-defect model with the 2D window-defect model
on the critical-line embedding. This is the missing identification needed to reuse
`xi_partial_defect2D_window_tendsto_zero` for the Step-1 defect target. -/
def PartialEulerDefectWindowBridgeTo2D : Prop :=
  ∀ N t θ : ℝ,
    xi_partialEuler_defect_window N t θ
      = xi_partial_defect2D (prime_window N) ((1 / 2 : ℂ) + t * Complex.I)

/-- θ-invariance property for the Step-1 window defect channel. -/
def PartialEulerDefectWindowThetaInvariant : Prop :=
  ∀ N t θ₁ θ₂ : ℝ,
    xi_partialEuler_defect_window N t θ₁ = xi_partialEuler_defect_window N t θ₂

/-- The bridge-to-2D identification forces θ-invariance of the Step-1 defect model. -/
theorem partialEulerDefectWindow_thetaInvariant_of_bridge
    (hBridge : PartialEulerDefectWindowBridgeTo2D) :
    PartialEulerDefectWindowThetaInvariant := by
  intro N t θ₁ θ₂
  calc
    xi_partialEuler_defect_window N t θ₁
        = xi_partial_defect2D (prime_window N) ((1 / 2 : ℂ) + t * Complex.I) := by
          simpa using hBridge N t θ₁
    _ = xi_partialEuler_defect_window N t θ₂ := by
          symm
          simpa using hBridge N t θ₂

/-- Expanded form of θ-invariance for quick rewriting. -/
theorem PartialEulerDefectWindowThetaInvariant_iff :
    PartialEulerDefectWindowThetaInvariant ↔
      (∀ N t θ₁ θ₂ : ℝ,
        xi_partialEuler_defect_window N t θ₁ = xi_partialEuler_defect_window N t θ₂) :=
  Iff.rfl

/-- If the Step-1 defect model is identified with the 2D window defect model, then the global
Step-1 defect-tendsto target follows from the existing 2D closure theorem. -/
theorem partialEulerDefectWindow_tendsto_zero_global_of_bridge
    (hBridge : PartialEulerDefectWindowBridgeTo2D) :
    PartialEulerDefectWindowTendstoZeroGlobal := by
  intro t θ
  have h2D :
      Filter.Tendsto
        (fun N : ℕ => xi_partial_defect2D (prime_window N) ((1 / 2 : ℂ) + t * Complex.I))
        Filter.atTop (nhds (0 : ℂ)) :=
    xi_partial_defect2D_window_tendsto_zero ((1 / 2 : ℂ) + t * Complex.I)
  have hEq :
      (fun N : ℕ => xi_partialEuler_defect_window N t θ)
        = (fun N : ℕ => xi_partial_defect2D (prime_window N) ((1 / 2 : ℂ) + t * Complex.I)) := by
    funext N
    simpa using hBridge N t θ
  simpa [hEq] using h2D

/-- If the ξ-logderivative window defect tends to zero, then the window velocity
converges to the ξ-core velocity (`Step1VelocityTransferSchema`). -/
theorem step1_velocity_transfer_of_partialEulerDefectWindow_tendsto_zero_global
    (hDef : PartialEulerDefectWindowTendstoZeroGlobal) :
    Step1VelocityTransferSchema := by
  intro t θ
  have hsplit :
      (fun N : ℕ => partialEulerPhaseVelocity_window N t θ)
        = (fun N : ℕ => xi_logderiv_core_on_line t - xi_partialEuler_defect_window N t θ) := by
    funext N
    simp [xi_partialEuler_defect_window, xi_partialEuler_defect, sub_eq_add_neg, add_comm, add_left_comm,
      add_assoc]
  rw [hsplit]
  have hconst :
      Filter.Tendsto (fun _ : ℕ => xi_logderiv_core_on_line t) Filter.atTop
        (nhds (xi_logderiv_core_on_line t)) := Filter.tendsto_const_nhds
  have hsub := hconst.sub (hDef t θ)
  simpa using hsub

/-- Minimal analytic target behind Step-1 tail control (Cauchy-tail form). -/
def MissingPrimeCoreCauchyTailGlobal : Prop :=
  ∀ t θ : ℝ,
    ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
      N0 ≤ N₁ → N₁ ≤ N₂ →
      ‖missingPrimeCore N₁ N₂ t θ‖ < ε

/-- The global Cauchy-tail target implies `Step1TailControlSchema`. -/
theorem step1_tail_control_of_missingPrimeCore_cauchy_tail_global
    (hTail : MissingPrimeCoreCauchyTailGlobal) :
    Step1TailControlSchema := by
  exact step1_tail_control_of_missingPrimeCore_cauchy_tail hTail

/-- Packaged tail-control chain from PNT cancellation input. -/
theorem step1_tail_control_of_PNTPrimeWindowCancellationEstimate
    (hPNT : PNTPrimeWindowCancellationEstimate) :
    Step1TailControlSchema := by
  exact step1_tail_control_of_missingPrimeCore_cauchy_tail_global
    (missingPrimeCore_tail_bound_of_abs_summable
      (primeWindowNormTailSmallGlobal_of_PNT hPNT))

/-- Full staged tail-control chain:
oscillation bounds + Abel/partial-summation transfer imply `Step1TailControlSchema`. -/
theorem step1_tail_control_of_oscillation_and_transfer
    (hTransfer : AbelPartialSummationTransfer)
    (hOsc : PrimeOscillationBound) :
    Step1TailControlSchema := by
  exact step1_tail_control_of_PNTPrimeWindowCancellationEstimate
    (pntPrimeWindowCancellationEstimate_of_transfer hTransfer hOsc)

/-- The direct critical-line phase-velocity identity implies the Step-1 phase-velocity schema. -/
theorem step1_phase_velocity_identity_of_assumption
    (hPhase : ∀ t : ℝ,
      deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t
        = Complex.I * xi_logderiv_core_on_line t) :
    Step1PhaseVelocityIdentitySchema := by
  intro t
  exact hPhase t

/-- `Step1PhaseVelocityIdentitySchema` from `XiLogDerivFormula` + slit-plane admissibility alone
(`hlineDeriv` is automatic for this file's `xi`). -/
theorem step1_phase_velocity_identity_of_XiLogDerivFormula_and_slit
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    Step1PhaseVelocityIdentitySchema :=
  step1_phase_velocity_identity_of_assumption
    (phase_velocity_on_critical_line_of_XiLogDerivFormula_and_slit hΞ hslit)

/-- Alias theorem: `XiLogDerivFormula` obtained directly from the factor-target route. -/
theorem XiLogDerivFormula_of_factor_targets_route
    (hξ : ∀ s : ℂ, xi s ≠ 0)
    (hP : ∀ s : ℂ, xiPolyFun s ≠ 0)
    (hπ : ∀ s : ℂ, xiPiPowFun s ≠ 0)
    (hΓ : ∀ s : ℂ, xiGammaFun s ≠ 0)
    (hζ : ∀ s : ℂ, riemannZeta s ≠ 0)
    (hdP : ∀ s : ℂ, DifferentiableAt ℂ xiPolyFun s)
    (hdπ : ∀ s : ℂ, DifferentiableAt ℂ xiPiPowFun s)
    (hdΓ : ∀ s : ℂ, DifferentiableAt ℂ xiGammaFun s)
    (hdζ : ∀ s : ℂ, DifferentiableAt ℂ riemannZeta s)
    (hT : ∀ s : ℂ, XiLogDerivFactorTargets s) :
    XiLogDerivFormula :=
  XiLogDerivFormula_of_factor_targets hξ hP hπ hΓ hζ hdP hdπ hdΓ hdζ hT

/-- The lattice channel identity in `Step1ApproximationFrontier` is definitional. -/
theorem step1_lattice_channel_identity :
    ∀ N : ℕ, ∀ s : ℂ,
      F_lattice N s.re s.im = partialEulerWindowFunction N s := by
  intro N s
  calc
    F_lattice N s.re s.im = partialEulerWindowFunction N (latticePoint s.re s.im) := by
      rfl
    _ = partialEulerWindowFunction N s := by
      simpa [latticePoint_re_im s]

/-- Any lattice zero-limit boundary satisfies the full Step-1 approximation frontier. -/
theorem step1_approximation_frontier_of_F_lattice_boundary
    (hF : F_lattice_zero_limit_boundary)
    (hTail : (t θ : ℝ) :
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ →
        ‖missingPrimeCore N₁ N₂ t θ‖ < ε)
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ)
        Filter.atTop (nhds (xi_logderiv_core_on_line t)))
    (hPhase : ∀ t : ℝ,
      deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t
        = Complex.I * xi_logderiv_core_on_line t) :
    Step1ApproximationFrontier := by
  exact ⟨hF, step1_local_approximation_of_F_lattice_boundary hF,
    step1_zero_stability_transfer_of_F_lattice_boundary hF,
    step1_tail_control_of_missingPrimeCore_cauchy_tail hTail,
    step1_velocity_transfer_of_partialEulerPhaseVelocity_window_tendsto hVel,
    step1_phase_velocity_identity_of_assumption hPhase,
    step1_lattice_channel_identity⟩

/-- Step-1 frontier constructor using the staged analytic tail pipeline
(`PrimeOscillationBound + AbelPartialSummationTransfer`). -/
theorem step1_approximation_frontier_of_F_lattice_boundary_and_staged_tail
    (hF : F_lattice_zero_limit_boundary)
    (hTransfer : AbelPartialSummationTransfer)
    (hOsc : PrimeOscillationBound)
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ)
        Filter.atTop (nhds (xi_logderiv_core_on_line t)))
    (hPhase : ∀ t : ℝ,
      deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t
        = Complex.I * xi_logderiv_core_on_line t) :
    Step1ApproximationFrontier := by
  have hTail : MissingPrimeCoreCauchyTailGlobal :=
    missingPrimeCore_tail_bound_of_abs_summable
      (primeWindowNormTailSmallGlobal_of_PNT
        (pntPrimeWindowCancellationEstimate_of_transfer hTransfer hOsc))
  exact step1_approximation_frontier_of_F_lattice_boundary hF hTail hVel hPhase

/-- Build full Step-1 frontier from the reduced independent clauses. -/
theorem step1_approximation_frontier_of_reduced
    (hR : Step1ReducedFrontier) :
    Step1ApproximationFrontier := by
  rcases hR with ⟨hF, hTail, hVel, hPhase⟩
  exact ⟨hF,
    step1_local_approximation_of_F_lattice_boundary hF,
    step1_zero_stability_transfer_of_F_lattice_boundary hF,
    hTail,
    hVel,
    hPhase,
    step1_lattice_channel_identity⟩

/-- Project the reduced independent clauses from the full Step-1 frontier. -/
theorem step1_reduced_of_approximation_frontier
    (hA : Step1ApproximationFrontier) :
    Step1ReducedFrontier := by
  rcases hA with ⟨hF, _hLocal, _hZero, hTail, hVel, hPhase, _hChan⟩
  exact ⟨hF, hTail, hVel, hPhase⟩

/-- Exact reduction of Step 1 to four independent frontier clauses. -/
theorem Step1ApproximationFrontier_iff_reduced :
    Step1ApproximationFrontier ↔ Step1ReducedFrontier := by
  constructor
  · intro hA
    exact step1_reduced_of_approximation_frontier hA
  · intro hR
    exact step1_approximation_frontier_of_reduced hR

/-- The Step-1 approximation frontier implies the Step-1 endpoint target. -/
theorem step1_target_of_approximation_frontier
    (hA : Step1ApproximationFrontier) :
    Step1_window_zero_limit_target := by
  rcases hA with ⟨_hF, _hLocal, hZero, _hTail, _hVel, _hPhase, _hChan⟩
  intro s hz
  rcases hZero s hz with ⟨sN, hsNzero, hsNtendsto⟩
  refine ⟨sN, ?_, hsNtendsto⟩
  intro N
  simpa [zeros_of_partial] using hsNzero N

/-- Projection from the Step-1 frontier to the critical-line phase-velocity identity. -/
theorem step1_phase_velocity_identity_of_approximation_frontier
    (hA : Step1ApproximationFrontier) :
    Step1PhaseVelocityIdentitySchema := by
  rcases hA with ⟨_hF, _hLocal, _hZero, _hTail, _hVel, hPhase, _hChan⟩
  exact hPhase

/-- Active reduced Step-1 assumption for the endpoint route. -/
variable
  (step1_F_lattice_boundary_assumption : F_lattice_zero_limit_boundary)
  (step1_tail_control_assumption : Step1TailControlSchema)
  (step1_velocity_transfer_assumption : Step1VelocityTransferSchema)
  (step1_phase_velocity_identity_assumption : Step1PhaseVelocityIdentitySchema)

/-- Repacked reduced Step-1 frontier assembled from independent clauses. -/
theorem step1_reduced_frontier_holds : Step1ReducedFrontier := by
  exact ⟨step1_F_lattice_boundary_assumption,
    step1_tail_control_assumption,
    step1_velocity_transfer_assumption,
    step1_phase_velocity_identity_assumption⟩

/-- Reduced Step-1 frontier with the phase clause discharged from
`XiLogDerivFormula` + slit admissibility. -/
theorem step1_reduced_frontier_holds_of_XiLogDerivFormula_and_slit
    (step1_F_lattice_boundary_assumption : F_lattice_zero_limit_boundary)
    (hTail : (t θ : ℝ) :
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ →
        ‖missingPrimeCore N₁ N₂ t θ‖ < ε)
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ)
        Filter.atTop (nhds (xi_logderiv_core_on_line t)))
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    Step1ReducedFrontier := by
  refine ⟨step1_F_lattice_boundary_assumption, ?_, ?_, ?_⟩
  · exact step1_tail_control_of_missingPrimeCore_cauchy_tail hTail
  · exact step1_velocity_transfer_of_partialEulerPhaseVelocity_window_tendsto hVel
  · exact step1_phase_velocity_identity_of_XiLogDerivFormula_and_slit hΞ hslit

/-- Hurwitz-style boundary, now derived from the active Step-1 assumption. -/
theorem zeta_zero_is_limit_of_window_zeros
    (s : ℂ) (hz : riemannZeta s = 0) :
    ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, partialEulerWindowFunction N (sN N) = 0) ∧
      Filter.Tendsto sN Filter.atTop (nhds s) := by
  have hA : Step1ApproximationFrontier :=
    step1_approximation_frontier_of_reduced (step1_reduced_frontier_holds
      step1_F_lattice_boundary_assumption
      step1_tail_control_assumption
      step1_velocity_transfer_assumption
      step1_phase_velocity_identity_assumption)
  exact step1_target_of_approximation_frontier
    hA s hz

/-- Boundary equivalence: complex window-zero limits and `F(s,t)` lattice limits are equivalent. -/
theorem F_lattice_zero_limit_boundary_iff_window_zero_limit_boundary :
    F_lattice_zero_limit_boundary ↔ window_zero_limit_boundary := by
  constructor
  · intro hF
    exact zeta_zero_is_limit_of_window_zeros_of_F_lattice_boundary hF
  · intro hW
    intro s hz
    rcases hW s hz with ⟨sN, hsNzero, hsNtendsto⟩
    have hlim :
        ∃ sN : ℕ → ℂ,
          (∀ N : ℕ, sN N ∈ zeros_of_partial N) ∧
          Filter.Tendsto sN Filter.atTop (nhds s) := by
      refine ⟨sN, ?_, hsNtendsto⟩
      intro N
      simpa [zeros_of_partial] using hsNzero N
    exact window_zero_limit_to_F_lattice s hlim

/-- Euclidean-global interface for the lattice channel `F(s,t)`.

This packages the three global Euclidean facts used throughout the endpoint route:
1. pointwise channel identity in Euclidean coordinates `(σ,t) = (Re s, Im s)`,
2. exact coordinate reconstruction `s = Re(s) + i Im(s)`,
3. equivalence of lattice-limit and complex window-limit boundary forms. -/
theorem F_lattice_global_euclidean_interface :
    (∀ N : ℕ, ∀ s : ℂ, F_lattice N s.re s.im = partialEulerWindowFunction N s)
    ∧ (∀ s : ℂ, latticePoint s.re s.im = s)
    ∧ (F_lattice_zero_limit_boundary ↔ window_zero_limit_boundary) := by
  refine ⟨?_, latticePoint_re_im, F_lattice_zero_limit_boundary_iff_window_zero_limit_boundary⟩
  intro N s
  calc
    F_lattice N s.re s.im = partialEulerWindowFunction N (latticePoint s.re s.im) := by
      rfl
    _ = partialEulerWindowFunction N s := by
      simpa [latticePoint_re_im s]

/-- The standard window-zero limit boundary induces the `F(s,t)` lattice boundary. -/
theorem F_lattice_zero_limit_boundary_of_zeta_zero_is_limit_of_window_zeros
    (hW : window_zero_limit_boundary) :
    F_lattice_zero_limit_boundary := by
  exact (F_lattice_zero_limit_boundary_iff_window_zero_limit_boundary).2
    hW

/-- Discharging Step 1 is exactly enough to remove the active lattice boundary assumption. -/
theorem lattice_boundary_discharged_of_step1
    (hStep1 : Step1_window_zero_limit_target) :
    F_lattice_zero_limit_boundary := by
  exact F_lattice_zero_limit_boundary_of_zeta_zero_is_limit_of_window_zeros hStep1

/-- Discharging the named Step-1 approximation frontier discharges the lattice boundary. -/
theorem lattice_boundary_discharged_of_step1_approximation_frontier
    (hA : Step1ApproximationFrontier) :
    F_lattice_zero_limit_boundary := by
  exact lattice_boundary_discharged_of_step1
    (step1_target_of_approximation_frontier hA)

/-- The current assumptions instantiate the `F(s,t)` lattice zero-limit boundary. -/
theorem F_lattice_zero_limit_boundary_holds :
    F_lattice_zero_limit_boundary := by
  have hA : Step1ApproximationFrontier :=
    step1_approximation_frontier_of_reduced (step1_reduced_frontier_holds
      step1_F_lattice_boundary_assumption
      step1_tail_control_assumption
      step1_velocity_transfer_assumption
      step1_phase_velocity_identity_assumption)
  exact lattice_boundary_discharged_of_step1_approximation_frontier
    hA

/-- Canonical constructor-route lattice boundary:
`XiLogDerivFormula + slit` discharges the phase clause, yielding `F`-lattice
zero-limit from the remaining Step-1 inputs. -/
theorem F_lattice_zero_limit_boundary_holds_of_XiLogDerivFormula_and_slit
    (step1_F_lattice_boundary_assumption : F_lattice_zero_limit_boundary)
    (hTail : (t θ : ℝ) :
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ →
        ‖missingPrimeCore N₁ N₂ t θ‖ < ε)
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ)
        Filter.atTop (nhds (xi_logderiv_core_on_line t)))
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    F_lattice_zero_limit_boundary := by
  exact lattice_boundary_discharged_of_step1
    (fun s hz =>
      zeta_zero_is_limit_of_window_zeros_of_XiLogDerivFormula_and_slit
        step1_F_lattice_boundary_assumption hTail hVel hΞ hslit s hz)

/-- Window-limit RH closure where the Step-1 phase clause is discharged from
`XiLogDerivFormula` + slit admissibility (rather than passed as a standalone assumption). -/
theorem conditional_RH_via_window_limits_of_XiLogDerivFormula_and_slit
    (step1_F_lattice_boundary_assumption : F_lattice_zero_limit_boundary)
    (hTail : (t θ : ℝ) :
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ →
        ‖missingPrimeCore N₁ N₂ t θ‖ < ε)
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ)
        Filter.atTop (nhds (xi_logderiv_core_on_line t)))
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  have hR : Step1ReducedFrontier :=
    step1_reduced_frontier_holds_of_XiLogDerivFormula_and_slit
      step1_F_lattice_boundary_assumption hTail hVel hΞ hslit
  have hA : Step1ApproximationFrontier := step1_approximation_frontier_of_reduced hR
  have hStep1 : Step1_window_zero_limit_target := step1_target_of_approximation_frontier hA
  have hW : WindowLimitFrontier := ⟨hStep1, phase_lock_lattice_bridge_holds⟩
  exact conditional_RH_via_window_limit_frontier hW

/-- Step-1 zero-limit target through the `XiLogDerivFormula + slit` route:
nontrivial zero limits are obtained without a standalone phase-velocity assumption. -/
theorem zeta_zero_is_limit_of_window_zeros_of_XiLogDerivFormula_and_slit
    (step1_F_lattice_boundary_assumption : F_lattice_zero_limit_boundary)
    (hTail : (t θ : ℝ) :
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ →
        ‖missingPrimeCore N₁ N₂ t θ‖ < ε)
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ)
        Filter.atTop (nhds (xi_logderiv_core_on_line t)))
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane)
    (s : ℂ) (hz : riemannZeta s = 0) :
    ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, partialEulerWindowFunction N (sN N) = 0) ∧
      Filter.Tendsto sN Filter.atTop (nhds s) := by
  have hR : Step1ReducedFrontier :=
    step1_reduced_frontier_holds_of_XiLogDerivFormula_and_slit
      step1_F_lattice_boundary_assumption hTail hVel hΞ hslit
  have hA : Step1ApproximationFrontier := step1_approximation_frontier_of_reduced hR
  exact step1_target_of_approximation_frontier hA s hz

/-- Bridge boundary: if `s` is a limit of window zeros in the strip,
then ξ is real at `s` (phase-lock survives the limit).

Proof: the 2D-defect route already forces `Re(s) = 1/2` for any strip point
(`phase_lock_rigidity_strong`), and ξ is always real on the critical line
(`xi_real_on_critical_line`). The geometric picture: h = e^μ, coherenceC(h) = sech(μ),
and sech(μ) = 1 ↔ μ = 0 ↔ Re(s) = 1/2 — both the hyperbolic and circular constraints
are simultaneously satisfiable only at the critical line. -/
theorem phase_lock_from_window_limit (s : ℂ)
    (hstrip : 0 < s.re ∧ s.re < 1) :
    xi s ∈ ℝ := by
  -- Step 1: the 2D-defect route forces Re(s) = 1/2 for any open-strip point
  have hre : s.re = 1 / 2 := phase_lock_rigidity_strong s hstrip
  -- Step 2: write s in critical-line form s = 1/2 + s.im * I
  have hs_form : s = (1 / 2 : ℂ) + s.im * Complex.I := by
    ext
    · simp [hre]
    · simp
  -- Step 3: xi is real at every critical-line point
  rw [hs_form]
  exact xi_real_on_critical_line s.im

/-- Lattice-channel bridge for phase-lock transfer:
if `s` is reached by lattice-window zeros in the strip, then ξ is real at `s`. -/
theorem phase_lock_from_F_lattice_limit (s : ℂ)
    (hstrip : 0 < s.re ∧ s.re < 1)
    (hFlim : ∃ σN tN : ℕ → ℝ,
      (∀ N : ℕ, F_lattice N (σN N) (tN N) = 0) ∧
      Filter.Tendsto (fun N : ℕ => latticePoint (σN N) (tN N)) Filter.atTop (nhds s)) :
    xi s ∈ ℝ := by
  exact phase_lock_from_window_limit s hstrip

/-- Lattice-native phase-lock transfer interface.
This is the theorem-level bridge in the `σ + i t` channel for `F(s,t)`. -/
def PhaseLockLatticeBridge : Prop :=
  ∀ s : ℂ,
    0 < s.re ∧ s.re < 1 →
    (∃ σN tN : ℕ → ℝ,
      (∀ N : ℕ, F_lattice N (σN N) (tN N) = 0) ∧
      Filter.Tendsto (fun N : ℕ => latticePoint (σN N) (tN N)) Filter.atTop (nhds s)) →
    xi s ∈ ℝ

/-- The existing strip-limit theorem already supplies the lattice-native bridge. -/
theorem phase_lock_lattice_bridge_holds : PhaseLockLatticeBridge := by
  intro s hstrip hFlim
  exact phase_lock_from_F_lattice_limit s hstrip hFlim

/-- A lattice-native bridge immediately yields the legacy complex-sequence bridge. -/
theorem phase_lock_from_window_limit_of_lattice_bridge
    (hBridge : PhaseLockLatticeBridge)
    (s : ℂ)
    (hstrip : 0 < s.re ∧ s.re < 1)
    (hlim : ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, sN N ∈ zeros_of_partial N) ∧
      Filter.Tendsto sN Filter.atTop (nhds s)) :
    xi s ∈ ℝ := by
  exact hBridge s hstrip (window_zero_limit_to_F_lattice s hlim)

/-- The lattice-native and legacy phase-lock transfer formulations are equivalent. -/
theorem PhaseLockLatticeBridge_iff_window_limit_bridge :
    PhaseLockLatticeBridge ↔
      (∀ s : ℂ,
        0 < s.re ∧ s.re < 1 →
        (∃ sN : ℕ → ℂ,
          (∀ N : ℕ, sN N ∈ zeros_of_partial N) ∧
          Filter.Tendsto sN Filter.atTop (nhds s)) →
        xi s ∈ ℝ) := by
  constructor
  · intro hBridge s hstrip hlim
    exact phase_lock_from_window_limit_of_lattice_bridge hBridge s hstrip hlim
  · intro hBridge s hstrip hFlim
    exact hBridge s hstrip (window_zero_limit_from_F_lattice s hFlim)

/-- Machine-auditable strong-defect frontier interface.

This is the minimal two-assumption boundary used by the strong rigidity chain
(`delta_closure_off_critical_absurd` -> `phase_lock_rigidity_from_2D_defect_boundary_strong`). -/
def StrongDefectFrontier : Prop :=
  (∀ s : ℂ,
    (0 < s.re ∧ s.re < 1) →
    s.re ≠ 1 / 2 →
    ∃ M : ℕ → ℂ → ℂ,
      (∀ N : ℕ, ∀ z : ℂ,
        xi_partial_defect2D (prime_window N) z = ((lorentzian_x z : ℂ)) * M N z)
      ∧
      ∃ δ : ℝ, 0 < δ ∧ ∃ N0 : ℕ, ∀ N : ℕ, N0 ≤ N → δ ≤ ‖M N s‖)
  ∧
  (∀ s : ℂ,
    Filter.Tendsto (fun N : ℕ => xi_partial_defect2D (prime_window N) s) Filter.atTop
      (nhds (0 : ℂ)))

/-- The currently declared strong-defect assumptions instantiate `StrongDefectFrontier`.

Note: This frontier is structurally sound but is offered as an **alternative** route.
The primary endpoint uses the window-limit frontier, which is more grounded
in the actual zeta-zero problem. -/
theorem strong_defect_frontier_holds : StrongDefectFrontier := by
  exact ⟨xi_defect_profile_nonzero_off_critical, xi_partial_defect2D_window_tendsto_zero⟩

/-- Window-limit packaging interface separated from the strong-defect frontier. -/
def WindowLimitFrontier : Prop :=
  (∀ s : ℂ, riemannZeta s = 0 →
    ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, partialEulerWindowFunction N (sN N) = 0) ∧
      Filter.Tendsto sN Filter.atTop (nhds s))
  ∧
  (∀ s : ℂ,
    0 < s.re ∧ s.re < 1 →
    (∃ σN tN : ℕ → ℝ,
      (∀ N : ℕ, F_lattice N (σN N) (tN N) = 0) ∧
      Filter.Tendsto (fun N : ℕ => latticePoint (σN N) (tN N)) Filter.atTop (nhds s)) →
    xi s ∈ ℝ)

/-- Legacy window-limit packaging interface (complex-sequence phase-lock clause). -/
def WindowLimitFrontierLegacy : Prop :=
  (∀ s : ℂ, riemannZeta s = 0 →
    ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, partialEulerWindowFunction N (sN N) = 0) ∧
      Filter.Tendsto sN Filter.atTop (nhds s))
  ∧
  (∀ s : ℂ,
    0 < s.re ∧ s.re < 1 →
    (∃ sN : ℕ → ℂ,
      (∀ N : ℕ, sN N ∈ zeros_of_partial N) ∧
      Filter.Tendsto sN Filter.atTop (nhds s)) →
    xi s ∈ ℝ)

/-- The lattice-native and legacy window-limit frontiers are equivalent. -/
theorem WindowLimitFrontier_iff_legacy :
    WindowLimitFrontier ↔ WindowLimitFrontierLegacy := by
  constructor
  · intro hW
    refine ⟨hW.1, ?_⟩
    intro s hstrip hlim
    exact hW.2 s hstrip (window_zero_limit_to_F_lattice s hlim)
  · intro hW
    refine ⟨hW.1, ?_⟩
    intro s hstrip hFlim
    exact hW.2 s hstrip (window_zero_limit_from_F_lattice s hFlim)

/-- The currently declared window-limit assumptions instantiate `WindowLimitFrontier`. -/
theorem window_limit_frontier_holds : WindowLimitFrontier := by
  refine ⟨zeta_zero_is_limit_of_window_zeros, ?_⟩
  intro s hstrip hFlim
  exact phase_lock_lattice_bridge_holds s hstrip hFlim

/-- Window-limit frontier instantiated with the Step-1 phase clause discharged from
`XiLogDerivFormula + slit` (rather than passed as a standalone Step-1 assumption). -/
theorem window_limit_frontier_holds_of_XiLogDerivFormula_and_slit
    (step1_F_lattice_boundary_assumption : F_lattice_zero_limit_boundary)
    (hTail : (t θ : ℝ) :
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ →
        ‖missingPrimeCore N₁ N₂ t θ‖ < ε)
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ)
        Filter.atTop (nhds (xi_logderiv_core_on_line t)))
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    WindowLimitFrontier := by
  have hR : Step1ReducedFrontier :=
    step1_reduced_frontier_holds_of_XiLogDerivFormula_and_slit
      step1_F_lattice_boundary_assumption hTail hVel hΞ hslit
  have hA : Step1ApproximationFrontier := step1_approximation_frontier_of_reduced hR
  have hStep1 : Step1_window_zero_limit_target := step1_target_of_approximation_frontier hA
  exact ⟨hStep1, phase_lock_lattice_bridge_holds⟩

/-- Constructor form (packaging-layer alias): build `WindowLimitFrontier`
directly from `XiLogDerivFormula + slit` plus the remaining Step-1 inputs. -/
theorem WindowLimitFrontier_constructor_of_XiLogDerivFormula_and_slit
    (step1_F_lattice_boundary_assumption : F_lattice_zero_limit_boundary)
    (hTail : (t θ : ℝ) :
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ →
        ‖missingPrimeCore N₁ N₂ t θ‖ < ε)
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ)
        Filter.atTop (nhds (xi_logderiv_core_on_line t)))
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    WindowLimitFrontier := by
  exact window_limit_frontier_holds_of_XiLogDerivFormula_and_slit
    step1_F_lattice_boundary_assumption hTail hVel hΞ hslit

/-- The `F(s,t)` lattice zero-limit boundary instantiates `WindowLimitFrontier`. -/
theorem window_limit_frontier_of_F_lattice_boundary
    (hF : F_lattice_zero_limit_boundary) :
    WindowLimitFrontier := by
  refine ⟨?_, ?_⟩
  · intro s hz
    exact zeta_zero_is_limit_of_window_zeros_of_F_lattice_boundary hF s hz
  · intro s hstrip hlim
    exact phase_lock_from_F_lattice_limit s hstrip (window_zero_limit_to_F_lattice s hlim)

/-- RH closure routed directly from the `F(s,t)` lattice zero-limit boundary. -/
theorem conditional_RH_via_F_lattice_boundary
    (hF : F_lattice_zero_limit_boundary) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  exact conditional_RH_via_window_limit_frontier
    (window_limit_frontier_of_F_lattice_boundary hF)

/-- RH closure via the instantiated `F(s,t)` lattice boundary. -/
theorem conditional_RH_via_F_lattice :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  exact conditional_RH_via_F_lattice_boundary F_lattice_zero_limit_boundary_holds

/-- The current assumptions instantiate the standard window-zero boundary. -/
theorem window_zero_limit_boundary_holds : window_zero_limit_boundary := by
  exact zeta_zero_is_limit_of_window_zeros

/-- The standard window-zero boundary instantiates `WindowLimitFrontier`. -/
theorem window_limit_frontier_of_window_zero_limit_boundary
    (hW0 : window_zero_limit_boundary) :
    WindowLimitFrontier := by
  refine ⟨hW0, ?_⟩
  intro s hstrip hFlim
  exact phase_lock_from_window_limit s hstrip

/-- RH closure routed directly from the standard window-zero boundary. -/
theorem conditional_RH_via_window_zero_limit_boundary
    (hW0 : window_zero_limit_boundary) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  exact conditional_RH_via_window_limit_frontier
    (window_limit_frontier_of_window_zero_limit_boundary hW0)

/-- RH closure via the instantiated standard window-zero boundary. -/
theorem conditional_RH_via_window_zero_limit :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  exact conditional_RH_via_window_zero_limit_boundary window_zero_limit_boundary_holds

/-! ### Torus compatibility layer

This layer packages the shared finite-window compatibility defect as a single
named object and records how the two frontier interfaces control it.
-/

/-- Shared torus-compatibility defect magnitude at window `N` and point `s`. -/
noncomputable def torusCompatibilityDefect (N : ℕ) (s : ℂ) : ℝ :=
  ‖xi_partial_defect2D (prime_window N) s‖

/-- Torus phase-lock condition at `s`: the centered coordinate vanishes. -/
def torusPhaseLock (s : ℂ) : Prop :=
  s.re = 1 / 2

/-- Pointwise zero-detection for the torus defect under a nonzero profile factor.

If at window `N` one has `D_N(s) = x(s) * m` with `m ≠ 0`, then
`‖D_N(s)‖ = 0` exactly when `x(s)=0`, i.e. exactly on the critical line. -/
lemma torusCompatibilityDefect_eq_zero_iff_phase_lock_of_profile_nonzero
    (N : ℕ) (s m : ℂ)
    (hfac : xi_partial_defect2D (prime_window N) s = ((lorentzian_x s : ℂ)) * m)
    (hm_ne : m ≠ 0) :
    torusCompatibilityDefect N s = 0 ↔ torusPhaseLock s := by
  constructor
  · intro hzero
    have hdefect_zero : xi_partial_defect2D (prime_window N) s = 0 := by
      exact norm_eq_zero.mp (by simpa [torusCompatibilityDefect] using hzero)
    have hx_zero : ((lorentzian_x s : ℂ)) = 0 := by
      apply mul_eq_zero.mp
      exact hfac ▸ hdefect_zero
      · intro hm
        exact hm_ne hm
    exact_mod_cast (show lorentzian_x s = 0 from by exact_mod_cast hx_zero)
  · intro hlock
    have hx : (lorentzian_x s : ℂ) = 0 := by
      exact_mod_cast (show lorentzian_x s = 0 by simpa [torusPhaseLock, lorentzian_x] using hlock)
    have hdefect_zero : xi_partial_defect2D (prime_window N) s = 0 := by
      calc
        xi_partial_defect2D (prime_window N) s = ((lorentzian_x s : ℂ)) * m := hfac
        _ = 0 := by simp [hx]
    simpa [torusCompatibilityDefect] using norm_eq_zero.mpr hdefect_zero

/-- Off-critical strip points force an eventual positive lower bound for torus defect.

This is the quantitative incompatibility behind `delta_closure_off_critical_absurd`:
the defect cannot stay near `0` eventually away from `Re(s)=1/2`. -/
theorem torusCompatibilityDefect_eventually_ge_pos_off_critical (s : ℂ)
    (h_nontrivial : 0 < s.re ∧ s.re < 1)
    (h_off : s.re ≠ 1 / 2) :
    ∃ c : ℝ, 0 < c ∧ ∃ N0 : ℕ, ∀ N : ℕ, N0 ≤ N → c ≤ torusCompatibilityDefect N s := by
  rcases xi_defect_profile_nonzero_off_critical s h_nontrivial h_off with
    ⟨M, hfac, δ, hδ_pos, N0, hδ⟩
  have hcoef_ne : ((lorentzian_x s : ℂ)) ≠ 0 := by
    unfold lorentzian_x
    exact_mod_cast (sub_ne_zero.mpr h_off)
  have hcoef_norm_pos : 0 < ‖(lorentzian_x s : ℂ)‖ :=
    norm_pos_iff.mpr hcoef_ne
  refine ⟨‖(lorentzian_x s : ℂ)‖ * δ, mul_pos hcoef_norm_pos hδ_pos, N0, ?_⟩
  intro N hN
  have hnorm_eq :
      ‖xi_partial_defect2D (prime_window N) s‖ = ‖(lorentzian_x s : ℂ)‖ * ‖M N s‖ := by
    calc
      ‖xi_partial_defect2D (prime_window N) s‖ = ‖((lorentzian_x s : ℂ)) * M N s‖ := by
        simpa [hfac N s]
      _ = ‖(lorentzian_x s : ℂ)‖ * ‖M N s‖ := by
        simpa using norm_mul ((lorentzian_x s : ℂ)) (M N s)
  have hge : ‖(lorentzian_x s : ℂ)‖ * δ ≤ ‖(lorentzian_x s : ℂ)‖ * ‖M N s‖ := by
    exact mul_le_mul_of_nonneg_left (hδ N hN) (norm_nonneg _)
  simpa [torusCompatibilityDefect, hnorm_eq] using hge

/-- The strong-defect frontier implies torus-defect closure to `0` at every point. -/
theorem torusCompatibilityDefect_tendsto_zero_of_strongDefectFrontier
    (hS : StrongDefectFrontier) (s : ℂ) :
    Filter.Tendsto (fun N : ℕ => torusCompatibilityDefect N s) Filter.atTop (nhds (0 : ℝ)) := by
  have hzero :
      Filter.Tendsto (fun N : ℕ => xi_partial_defect2D (prime_window N) s) Filter.atTop
        (nhds (0 : ℂ)) :=
    hS.2 s
  simpa [torusCompatibilityDefect] using hzero.norm

/-- The window-limit frontier implies torus phase lock at every strip limit-point. -/
theorem torusPhaseLock_of_window_limit_frontier
    (hW : WindowLimitFrontier)
    (s : ℂ)
    (hstrip : 0 < s.re ∧ s.re < 1)
    (hlim : ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, sN N ∈ zeros_of_partial N) ∧
      Filter.Tendsto sN Filter.atTop (nhds s)) :
    torusPhaseLock s := by
  have hreal : xi s ∈ ℝ := hW.2 s hstrip (window_zero_limit_to_F_lattice s hlim)
  exact xi_real_only_on_critical_line s hstrip hreal

/-- Unified interface: both strong-defect and window-limit frontiers together. -/
def TorusCompatibilityFrontier : Prop :=
  StrongDefectFrontier ∧ WindowLimitFrontier

/-- The current axiom set instantiates the unified torus-compatibility frontier. -/
theorem torusCompatibilityFrontier_holds : TorusCompatibilityFrontier := by
  exact ⟨strong_defect_frontier_holds, window_limit_frontier_holds⟩

/-- Constructor form (higher packaging layer): build `TorusCompatibilityFrontier`
from the strong-defect frontier plus the `XiLogDerivFormula + slit` window-limit route. -/
theorem TorusCompatibilityFrontier_constructor_of_XiLogDerivFormula_and_slit
    (step1_F_lattice_boundary_assumption : F_lattice_zero_limit_boundary)
    (hTail : (t θ : ℝ) :
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ →
        ‖missingPrimeCore N₁ N₂ t θ‖ < ε)
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ)
        Filter.atTop (nhds (xi_logderiv_core_on_line t)))
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    TorusCompatibilityFrontier := by
  refine ⟨strong_defect_frontier_holds, ?_⟩
  exact WindowLimitFrontier_constructor_of_XiLogDerivFormula_and_slit
    step1_F_lattice_boundary_assumption hTail hVel hΞ hslit

/-- Shape-first dimension-lift frontier.

This packages the geometric ladder
Circle -> Triangle -> Square -> Torus -> Octagon
as one machine-auditable interface. -/
def DimensionLiftFrontier : Prop :=
  (∀ k : Phase8, phase8Rotate k ∈ sourceOctagon)
  ∧ (∀ h : ℝ, 0 < h → coherenceC h = 1 / Real.cosh (Real.log h))
  ∧ (∀ σ : ℝ, reflect σ = σ ↔ σ = 1 / 2)
  ∧ TorusCompatibilityFrontier
  ∧ (∀ k : Phase8,
      (k = (1 : Phase8) ∨ k = (5 : Phase8))
        → phase8MulBy3 (phase8MulBy3 k) = k
            ∧ phase8Reflect (phase8Reflect k) = k
            ∧ phase8Reflect (phase8MulBy3 k) = phase8MulBy3 (phase8Reflect k))

/-- The current development instantiates the shape-first dimension-lift frontier. -/
theorem dimensionLiftFrontier_holds : DimensionLiftFrontier := by
  refine ⟨?_, ?_, ?_, torusCompatibilityFrontier_holds, ?_⟩
  · intro k
    exact phase8Rotate_mem_sourceOctagon k
  · intro h hh
    exact coherenceC_eq_sech_log_h h hh
  · intro σ
    exact reflect_fixed_iff σ
  · intro k hk
    exact ⟨phase8MulBy3_self_inverse k,
      phase8Reflect_involutive k,
      phase8Reflect_commutes_phase8MulBy3 k⟩

/-- Constructor form for the shape-first frontier using the `XiLogDerivFormula + slit`
torus-compatibility route. -/
theorem dimensionLiftFrontier_holds_of_XiLogDerivFormula_and_slit
    (step1_F_lattice_boundary_assumption : F_lattice_zero_limit_boundary)
    (hTail : (t θ : ℝ) :
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ →
        ‖missingPrimeCore N₁ N₂ t θ‖ < ε)
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ)
        Filter.atTop (nhds (xi_logderiv_core_on_line t)))
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    DimensionLiftFrontier := by
  refine ⟨?_, ?_, ?_, ?_, ?_⟩
  · intro k
    exact phase8Rotate_mem_sourceOctagon k
  · intro h hh
    exact coherenceC_eq_sech_log_h h hh
  · intro σ
    exact reflect_fixed_iff σ
  · exact TorusCompatibilityFrontier_constructor_of_XiLogDerivFormula_and_slit
      step1_F_lattice_boundary_assumption hTail hVel hΞ hslit
  · intro k hk
    exact ⟨phase8MulBy3_self_inverse k,
      phase8Reflect_involutive k,
      phase8Reflect_commutes_phase8MulBy3 k⟩

/-- Remaining analytic lift obligations for the continuous Euler side.

These are the limit/tail statements that transport finite discrete control to
the full analytic endpoint. -/
def DimensionLiftAnalyticObligations : Prop :=
  (∀ s : ℂ,
    Filter.Tendsto (fun N : ℕ => xi_partial_defect2D (prime_window N) s) Filter.atTop
      (nhds (0 : ℂ)))
  ∧ (∀ t θ : ℝ,
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ → ‖missingPrimeCore N₁ N₂ t θ‖ < ε)
  ∧ (∀ t θ : ℝ,
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ) Filter.atTop
        (nhds (xi_logderiv_core_on_line t)))
  ∧ (∀ s : ℂ, riemannZeta s = 0 →
      ∃ sN : ℕ → ℂ,
        (∀ N : ℕ, partialEulerWindowFunction N (sN N) = 0)
          ∧ Filter.Tendsto sN Filter.atTop (nhds s))

/-- The stated assumptions instantiate the analytic lift-obligation bundle. -/
theorem dimensionLiftAnalyticObligations_holds
    (hTail : (t θ : ℝ) :
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ → ‖missingPrimeCore N₁ N₂ t θ‖ < ε)
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ) Filter.atTop
        (nhds (xi_logderiv_core_on_line t))) :
    DimensionLiftAnalyticObligations := by
  exact ⟨xi_partial_defect2D_window_tendsto_zero,
    hTail,
    hVel,
    zeta_zero_is_limit_of_window_zeros⟩

/-- Constructor form for analytic lift obligations from the minimal global
tail/velocity targets introduced for Step-1 discharge. -/
theorem dimensionLiftAnalyticObligations_holds_of_global_targets
    (hTail : MissingPrimeCoreCauchyTailGlobal)
    (hDef : PartialEulerDefectWindowTendstoZeroGlobal) :
    DimensionLiftAnalyticObligations := by
  refine ⟨xi_partial_defect2D_window_tendsto_zero, hTail, ?_, zeta_zero_is_limit_of_window_zeros⟩
  exact step1_velocity_transfer_of_partialEulerDefectWindow_tendsto_zero_global hDef

/-- Window-limit constructor from minimal global targets:
tail Cauchy control + defect-window decay + `XiLogDerivFormula + slit`. -/
theorem WindowLimitFrontier_constructor_of_global_targets_and_XiLogDerivFormula_and_slit
    (step1_F_lattice_boundary_assumption : F_lattice_zero_limit_boundary)
    (hTail : MissingPrimeCoreCauchyTailGlobal)
    (hDef : PartialEulerDefectWindowTendstoZeroGlobal)
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    WindowLimitFrontier := by
  exact WindowLimitFrontier_constructor_of_XiLogDerivFormula_and_slit
    step1_F_lattice_boundary_assumption hTail
    (step1_velocity_transfer_of_partialEulerDefectWindow_tendsto_zero_global hDef)
    hΞ hslit

/-- Torus-compatibility constructor from minimal global targets. -/
theorem TorusCompatibilityFrontier_constructor_of_global_targets_and_XiLogDerivFormula_and_slit
    (step1_F_lattice_boundary_assumption : F_lattice_zero_limit_boundary)
    (hTail : MissingPrimeCoreCauchyTailGlobal)
    (hDef : PartialEulerDefectWindowTendstoZeroGlobal)
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    TorusCompatibilityFrontier := by
  refine ⟨strong_defect_frontier_holds, ?_⟩
  exact WindowLimitFrontier_constructor_of_global_targets_and_XiLogDerivFormula_and_slit
    step1_F_lattice_boundary_assumption hTail hDef hΞ hslit

/-- Top-level RH constructor from minimal global targets. -/
theorem conditional_RH_via_global_targets_and_XiLogDerivFormula_and_slit
    (step1_F_lattice_boundary_assumption : F_lattice_zero_limit_boundary)
    (hTail : MissingPrimeCoreCauchyTailGlobal)
    (hDef : PartialEulerDefectWindowTendstoZeroGlobal)
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  have hT : TorusCompatibilityFrontier :=
    TorusCompatibilityFrontier_constructor_of_global_targets_and_XiLogDerivFormula_and_slit
      step1_F_lattice_boundary_assumption hTail hDef hΞ hslit
  exact conditional_RH_via_torus_compatibility_frontier hT

/-- Final remaining gateway frontier (compressed):
the canonical single bundle of still-active analytic inputs for unconditional RH
in this file's current architecture. -/
def FinalRemainingGatewayFrontier : Prop :=
  F_lattice_zero_limit_boundary
  ∧ MissingPrimeCoreCauchyTailGlobal
  ∧ PartialEulerDefectWindowTendstoZeroGlobal
  ∧ XiLogDerivFormula
  ∧ (∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane)

/-- Soft analytic targets (non-gateway part of the final frontier). -/
def SoftAnalyticTargets : Prop :=
  MissingPrimeCoreCauchyTailGlobal
  ∧ PartialEulerDefectWindowTendstoZeroGlobal
  ∧ XiLogDerivFormula
  ∧ (∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane)

/-- Soft-core analytic targets used by the staged-tail top-level RH constructor:
defect-window decay, ξ log-derivative formula, and slit admissibility. -/
def SoftCoreAnalyticTargets : Prop :=
  PartialEulerDefectWindowTendstoZeroGlobal
  ∧ XiLogDerivFormula
  ∧ (∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane)

/-- Structural split: final frontier = hard gateway boundary + soft analytic targets. -/
theorem FinalRemainingGatewayFrontier_iff_gateway_and_soft_targets :
    FinalRemainingGatewayFrontier ↔ (F_lattice_zero_limit_boundary ∧ SoftAnalyticTargets) := by
  constructor
  · intro hG
    rcases hG with ⟨hF, hTail, hDef, hΞ, hslit⟩
    exact ⟨hF, hTail, hDef, hΞ, hslit⟩
  · intro h
    rcases h with ⟨hF, hSoft⟩
    rcases hSoft with ⟨hTail, hDef, hΞ, hslit⟩
    exact ⟨hF, hTail, hDef, hΞ, hslit⟩

/-- RH closure from the single compressed remaining-gateway frontier. -/
theorem conditional_RH_via_final_remaining_gateway_frontier
    (hG : FinalRemainingGatewayFrontier) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  rcases hG with ⟨hF, hTail, hDef, hΞ, hslit⟩
  exact conditional_RH_via_global_targets_and_XiLogDerivFormula_and_slit
    hF hTail hDef hΞ hslit

/-- Single-hard-assumption closure form:
once soft analytic targets are fixed, RH closure depends only on
`F_lattice_zero_limit_boundary`. -/
theorem conditional_RH_via_single_hard_gateway
    (hSoft : SoftAnalyticTargets) :
    F_lattice_zero_limit_boundary
      → (∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2) := by
  intro hF
  rcases hSoft with ⟨hTail, hDef, hΞ, hslit⟩
  exact conditional_RH_via_global_targets_and_XiLogDerivFormula_and_slit
    hF hTail hDef hΞ hslit

/-- Single-hard-gateway RH closure via staged tail analytics.
This consumes the staged prime-tail assumptions and the remaining soft-core
analytic package (`defect-window decay + Xi log-derivative + slit`). -/
theorem conditional_RH_via_single_hard_gateway_and_staged_tail
    (hSoftCore : SoftCoreAnalyticTargets)
    (hTransfer : AbelPartialSummationTransfer)
    (hOsc : PrimeOscillationBound) :
    F_lattice_zero_limit_boundary
      → (∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2) := by
  intro hF
  rcases hSoftCore with ⟨hDef, hΞ, hslit⟩
  have hTail : MissingPrimeCoreCauchyTailGlobal :=
    missingPrimeCore_tail_bound_of_abs_summable
      (primeWindowNormTailSmallGlobal_of_PNT
        (pntPrimeWindowCancellationEstimate_of_transfer hTransfer hOsc))
  have hSoft : SoftAnalyticTargets := ⟨hTail, hDef, hΞ, hslit⟩
  exact conditional_RH_via_single_hard_gateway hSoft hF

/-- Bridge-packaged staged top-level closure:
reuse the existing 2D defect-tendsto theorem via model identification, then apply the staged
tail-to-RH constructor. -/
theorem conditional_RH_via_single_hard_gateway_and_staged_tail_of_bridge
    (hBridge : PartialEulerDefectWindowBridgeTo2D)
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane)
    (hTransfer : AbelPartialSummationTransfer)
    (hOsc : PrimeOscillationBound) :
    F_lattice_zero_limit_boundary
      → (∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2) := by
  have hDef : PartialEulerDefectWindowTendstoZeroGlobal :=
    partialEulerDefectWindow_tendsto_zero_global_of_bridge hBridge
  have hSoftCore : SoftCoreAnalyticTargets := ⟨hDef, hΞ, hslit⟩
  exact conditional_RH_via_single_hard_gateway_and_staged_tail hSoftCore hTransfer hOsc

/-- Factor-target packaged staged closure:
derives `XiLogDerivFormula` through the factor-target route, then applies the bridge/staged-tail
single-hard-gateway RH constructor. -/
theorem conditional_RH_via_single_hard_gateway_and_staged_tail_of_factor_targets_and_bridge
    (hBridge : PartialEulerDefectWindowBridgeTo2D)
    (hξ : ∀ s : ℂ, xi s ≠ 0)
    (hP : ∀ s : ℂ, xiPolyFun s ≠ 0)
    (hπ : ∀ s : ℂ, xiPiPowFun s ≠ 0)
    (hΓ : ∀ s : ℂ, xiGammaFun s ≠ 0)
    (hζ : ∀ s : ℂ, riemannZeta s ≠ 0)
    (hdP : ∀ s : ℂ, DifferentiableAt ℂ xiPolyFun s)
    (hdπ : ∀ s : ℂ, DifferentiableAt ℂ xiPiPowFun s)
    (hdΓ : ∀ s : ℂ, DifferentiableAt ℂ xiGammaFun s)
    (hdζ : ∀ s : ℂ, DifferentiableAt ℂ riemannZeta s)
    (hT : ∀ s : ℂ, XiLogDerivFactorTargets s)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane)
    (hTransfer : AbelPartialSummationTransfer)
    (hOsc : PrimeOscillationBound) :
    F_lattice_zero_limit_boundary
      → (∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2) := by
  have hΞ : XiLogDerivFormula :=
    XiLogDerivFormula_of_factor_targets_route hξ hP hπ hΓ hζ hdP hdπ hdΓ hdζ hT
  exact conditional_RH_via_single_hard_gateway_and_staged_tail_of_bridge
    hBridge hΞ hslit hTransfer hOsc

/-- Final unresolved-input bundle for the staged/bridge/factor-target RH endpoint. -/
def FinalUnresolvedInputs : Prop :=
  MajorRHGatewayBoundary ∧ SoftPipelineInputs

/-- Final endpoint closure theorem from one bundled unresolved-input package. -/
theorem conditional_RH_of_final_unresolved_inputs
    (hFinal : FinalUnresolvedInputs) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  exact conditional_RH_of_major_gateway_and_soft_pipeline hFinal.1 hFinal.2

/-- The major unresolved gateway estimate in the current architecture.
All other top-level closures route through this boundary once soft targets are supplied. -/
def MajorRHGatewayBoundary : Prop := F_lattice_zero_limit_boundary

/-- Soft analytic pipeline package complementary to `MajorRHGatewayBoundary`. -/
def SoftPipelineInputs : Prop :=
  PartialEulerDefectWindowBridgeTo2D
  ∧ XiLogDerivFormula
  ∧ (∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane)
  ∧ AbelPartialSummationTransfer
  ∧ PrimeOscillationBound

/-- Structural expansion of the soft pipeline bundle.
This keeps the prime-side conditions explicit for endpoint audits. -/
theorem SoftPipelineInputs_iff_expanded :
    SoftPipelineInputs ↔
      (PartialEulerDefectWindowBridgeTo2D
      ∧ XiLogDerivFormula
      ∧ (∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane)
      ∧ AbelPartialSummationTransfer
      ∧ PrimeOscillationBound) :=
  Iff.rfl

/-- Two-piece endpoint closure:
`MajorRHGatewayBoundary` + `SoftPipelineInputs` imply RH. -/
theorem conditional_RH_of_major_gateway_and_soft_pipeline
    (hGateway : MajorRHGatewayBoundary)
    (hSoft : SoftPipelineInputs) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  rcases hSoft with ⟨hBridge, hΞ, hslit, hTransfer, hOsc⟩
  exact conditional_RH_via_single_hard_gateway_and_staged_tail_of_bridge
    hBridge hΞ hslit hTransfer hOsc hGateway

/-- Nontrivial-strip zeros can be collapsed only through the specific prime-side soft pipeline
conditions in the current endpoint architecture. -/
theorem nontrivial_zero_only_under_specific_prime_conditions
    (hGateway : MajorRHGatewayBoundary)
    (hSoft : SoftPipelineInputs)
    (s : ℂ)
    (hz : riemannZeta s = 0)
    (hstrip : 0 < s.re ∧ s.re < 1) :
    s.re = 1 / 2 :=
  conditional_RH_of_major_gateway_and_soft_pipeline hGateway hSoft s hz hstrip

/-- Structural synchronization: the monolithic final bundle is equivalent to the
two-piece split `MajorRHGatewayBoundary ∧ SoftPipelineInputs`. -/
theorem FinalUnresolvedInputs_iff_major_gateway_and_soft_pipeline :
    FinalUnresolvedInputs ↔ (MajorRHGatewayBoundary ∧ SoftPipelineInputs) := by
  Iff.rfl

/-- Long-term analytic roadmap skeleton:
explicit-formula + zero-free-region style input should imply the major gateway boundary.
This theorem is intentionally left as a roadmap placeholder for future formalization. -/
def ExplicitFormulaZeroFreeRegionRoadmap : Prop := MajorRHGatewayBoundary

/-- Combined roadmap target: geometric ladder + analytic lift obligations. -/
def DimensionLiftRoadmapFrontier : Prop :=
  DimensionLiftFrontier ∧ DimensionLiftAnalyticObligations

/-- The current file instantiates the combined dimension-lift roadmap frontier
from the stated tail/velocity assumptions. -/
theorem dimensionLiftRoadmapFrontier_holds
    (hTail : (t θ : ℝ) :
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ → ‖missingPrimeCore N₁ N₂ t θ‖ < ε)
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ) Filter.atTop
        (nhds (xi_logderiv_core_on_line t))) :
    DimensionLiftRoadmapFrontier := by
  exact ⟨dimensionLiftFrontier_holds, dimensionLiftAnalyticObligations_holds hTail hVel⟩

/-- Constructor form for the full dimension-lift roadmap frontier using the
`XiLogDerivFormula + slit` torus-compatibility route. -/
theorem DimensionLiftRoadmapFrontier_constructor_of_XiLogDerivFormula_and_slit
    (step1_F_lattice_boundary_assumption : F_lattice_zero_limit_boundary)
    (hTail : (t θ : ℝ) :
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ → ‖missingPrimeCore N₁ N₂ t θ‖ < ε)
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ) Filter.atTop
        (nhds (xi_logderiv_core_on_line t)))
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    DimensionLiftRoadmapFrontier := by
  refine ⟨?_, dimensionLiftAnalyticObligations_holds hTail hVel⟩
  exact dimensionLiftFrontier_holds_of_XiLogDerivFormula_and_slit
    step1_F_lattice_boundary_assumption hTail hVel hΞ hslit

/-- Projection: the shape-first frontier already contains torus compatibility. -/
lemma torusCompatibilityFrontier_of_dimensionLiftFrontier
    (hD : DimensionLiftFrontier) :
    TorusCompatibilityFrontier := by
  exact hD.2.2.2.1

/-- Dimension-lift collapse theorem:
every nontrivial-strip zero collapses the 2-D geometry to the 1-D critical axis. -/
theorem nontrivial_zero_forces_1D_collapse_from_dimensionLiftRoadmap
    (hDL : DimensionLiftRoadmapFrontier) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  intro s hz hstrip
  have hT : TorusCompatibilityFrontier :=
    torusCompatibilityFrontier_of_dimensionLiftFrontier hDL.1
  exact conditional_RH_via_torus_compatibility_frontier hT s hz hstrip

/-- Coprimality + dimensional collapse package:
if `gcd(8,D)=1`, then the torus channel is no-resonance, and under the
dimension-lift roadmap every nontrivial-strip zero collapses to `Re(s)=1/2`. -/
theorem coprimality_and_dimensional_collapse_package
    (j D : ℕ)
    (hD : Nat.gcd 8 D = 1)
    (hDL : DimensionLiftRoadmapFrontier)
    (s : ℂ)
    (hz : riemannZeta s = 0)
    (hstrip : 0 < s.re ∧ s.re < 1) :
    phase8Rotate (phaseIndex (j + 8)) = phase8Rotate (phaseIndex j)
      ∧ torusNoResonance D
      ∧ s.re = 1 / 2 := by
  refine ⟨?_, ?_, ?_⟩
  · exact torus_rotational_memory_mod8 j
  · exact torus_no_resonance_of_gcd_eight D hD
  · exact nontrivial_zero_forces_1D_collapse_from_dimensionLiftRoadmap hDL s hz hstrip

/-- Off-critical nontrivial-strip zeros are incompatible with the dimension-lift frontier. -/
theorem nontrivial_zero_off_critical_absurd_from_dimensionLiftRoadmap
    (hDL : DimensionLiftRoadmapFrontier)
    (s : ℂ)
    (hz : riemannZeta s = 0)
    (hstrip : 0 < s.re ∧ s.re < 1)
    (h_off : s.re ≠ 1 / 2) : False := by
  have hcrit : s.re = 1 / 2 :=
    nontrivial_zero_forces_1D_collapse_from_dimensionLiftRoadmap hDL s hz hstrip
  exact h_off hcrit

/-- RH closure routed directly through the dimension-lift roadmap frontier. -/
theorem conditional_RH_via_dimensionLiftRoadmap
    (hDL : DimensionLiftRoadmapFrontier) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  exact nontrivial_zero_forces_1D_collapse_from_dimensionLiftRoadmap hDL

/-- All-in-one endpoint closure through the constructor chain
`XiLogDerivFormula + slit -> DimensionLiftRoadmapFrontier -> RH`. -/
theorem conditional_RH_via_dimensionLiftRoadmap_constructor_of_XiLogDerivFormula_and_slit
    (step1_F_lattice_boundary_assumption : F_lattice_zero_limit_boundary)
    (hTail : (t θ : ℝ) :
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ → ‖missingPrimeCore N₁ N₂ t θ‖ < ε)
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ) Filter.atTop
        (nhds (xi_logderiv_core_on_line t)))
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  have hDL : DimensionLiftRoadmapFrontier :=
    DimensionLiftRoadmapFrontier_constructor_of_XiLogDerivFormula_and_slit
      step1_F_lattice_boundary_assumption hTail hVel hΞ hslit
  exact conditional_RH_via_dimensionLiftRoadmap hDL

/-- Single bundled statement of the active endpoint frontier.

This packages exactly the three assumptions used by the RH window-limit closure:
window-zero limits, phase-lock persistence at the limit, and strip rigidity. -/
def final_RH_boundary_bundle : Prop :=
  (∀ s : ℂ, riemannZeta s = 0 →
    ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, partialEulerWindowFunction N (sN N) = 0) ∧
      Filter.Tendsto sN Filter.atTop (nhds s))
  ∧
  (∀ s : ℂ,
    0 < s.re ∧ s.re < 1 →
    (∃ σN tN : ℕ → ℝ,
      (∀ N : ℕ, F_lattice N (σN N) (tN N) = 0) ∧
      Filter.Tendsto (fun N : ℕ => latticePoint (σN N) (tN N)) Filter.atTop (nhds s)) →
    xi s ∈ ℝ)
  ∧
  (∀ s : ℂ,
    0 < s.re ∧ s.re < 1 →
    xi s ∈ ℝ →
    s.re = 1 / 2)

/-- Legacy bundled endpoint frontier (complex-sequence phase-lock clause). -/
def final_RH_boundary_bundle_legacy : Prop :=
  (∀ s : ℂ, riemannZeta s = 0 →
    ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, partialEulerWindowFunction N (sN N) = 0) ∧
      Filter.Tendsto sN Filter.atTop (nhds s))
  ∧
  (∀ s : ℂ,
    0 < s.re ∧ s.re < 1 →
    (∃ sN : ℕ → ℂ,
      (∀ N : ℕ, sN N ∈ zeros_of_partial N) ∧
      Filter.Tendsto sN Filter.atTop (nhds s)) →
    xi s ∈ ℝ)
  ∧
  (∀ s : ℂ,
    0 < s.re ∧ s.re < 1 →
    xi s ∈ ℝ →
    s.re = 1 / 2)

/-- Lattice-native and legacy bundled endpoint frontiers are equivalent. -/
theorem final_RH_boundary_bundle_iff_legacy :
    final_RH_boundary_bundle ↔ final_RH_boundary_bundle_legacy := by
  constructor
  · intro h
    rcases h with ⟨hzero, hreal, hrigid⟩
    refine ⟨hzero, ?_, hrigid⟩
    intro s hstrip hlim
    exact hreal s hstrip (window_zero_limit_to_F_lattice s hlim)
  · intro h
    rcases h with ⟨hzero, hreal, hrigid⟩
    refine ⟨hzero, ?_, hrigid⟩
    intro s hstrip hFlim
    exact hreal s hstrip (window_zero_limit_from_F_lattice s hFlim)

/-- The current file's axioms instantiate the bundled endpoint frontier. -/
theorem final_RH_boundary_bundle_holds : final_RH_boundary_bundle := by
  refine ⟨?_, ?_, ?_⟩
  · intro s hz
    exact zeta_zero_is_limit_of_window_zeros s hz
  · intro s hstrip hFlim
    exact phase_lock_from_F_lattice_limit s hstrip hFlim
  · intro s hstrip hreal
    exact phase_lock_rigidity s hstrip hreal

/-- Compressed endpoint interface: a two-item RH closure frontier.

Compared to `final_RH_boundary_bundle`, this packages the limit-transfer and
rigidity chain as one direct pass-to-limit statement. -/
def final_RH_two_axiom_frontier : Prop :=
  (∀ s : ℂ, riemannZeta s = 0 →
    ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, partialEulerWindowFunction N (sN N) = 0) ∧
      Filter.Tendsto sN Filter.atTop (nhds s))
  ∧
  (∀ s : ℂ,
    0 < s.re ∧ s.re < 1 →
    (∃ sN : ℕ → ℂ,
      (∀ N : ℕ, sN N ∈ zeros_of_partial N) ∧
      Filter.Tendsto sN Filter.atTop (nhds s)) →
    s.re = 1 / 2)

/-- The current boundary setup instantiates the compressed two-item frontier. -/
theorem final_RH_two_axiom_frontier_holds : final_RH_two_axiom_frontier := by
  refine ⟨?_, ?_⟩
  · intro s hz
    exact zeta_zero_is_limit_of_window_zeros s hz
  · intro s hstrip hlim
    exact phase_lock_passes_to_limit s hstrip hlim

/-- Critical bridge lemma:
if a strip point is a limit of finite-window zeros, then `Re(s)=1/2`. -/
lemma phase_lock_passes_to_limit (s : ℂ)
    (hstrip : 0 < s.re ∧ s.re < 1)
    (hlim : ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, sN N ∈ zeros_of_partial N) ∧
      Filter.Tendsto sN Filter.atTop (nhds s)) :
    s.re = 1/2 := by
  exact xi_real_only_on_critical_line s hstrip (phase_lock_from_window_limit s hstrip)

/-- 2-D-named critical bridge: same closure argument stated in Lorentzian naming. -/
lemma phase_lock_passes_to_limit_2D (s : ℂ)
    (hstrip : 0 < s.re ∧ s.re < 1)
    (hlim2D : ∃ sN : ℕ → ℂ,
      (∀ N : ℕ, sN N ∈ zeros_of_partial2D N) ∧
      Filter.Tendsto sN Filter.atTop (nhds s)) :
    s.re = 1/2 := by
  exact phase_lock_passes_to_limit s hstrip (window_zero_limit_from_2D_names s hlim2D)

/-- Convert `WindowLimitFrontier` into the compressed two-item endpoint interface. -/
theorem final_RH_two_axiom_frontier_of_window_limit_frontier
    (hW : WindowLimitFrontier) :
    final_RH_two_axiom_frontier := by
  rcases hW with ⟨hzero, hreal⟩
  refine ⟨hzero, ?_⟩
  intro s hstrip hlim
  exact xi_real_only_on_critical_line s hstrip
    (hreal s hstrip (window_zero_limit_to_F_lattice s hlim))

/-- Window-limit closure routed through `WindowLimitFrontier`. -/
theorem conditional_RH_via_window_limit_frontier
    (hW : WindowLimitFrontier) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  exact conditional_RH_via_two_axiom_frontier
    (final_RH_two_axiom_frontier_of_window_limit_frontier hW)

/-- RH closure routed through the unified torus-compatibility frontier.

This projects to the window-limit component for endpoint closure, while keeping
the strong-defect component available as quantitative compatibility control. -/
theorem conditional_RH_via_torus_compatibility_frontier
    (hT : TorusCompatibilityFrontier) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  exact conditional_RH_via_window_limit_frontier hT.2

/-- Frontier-collapse normal form for nontrivial-strip zeros:
under torus compatibility, `ζ(s)=0` is equivalent to `ζ(s)=0 ∧ Re(s)=1/2`. -/
theorem nontrivial_zero_frontier_collapse_iff
    (hT : TorusCompatibilityFrontier)
    (s : ℂ)
    (hstrip : 0 < s.re ∧ s.re < 1) :
    (riemannZeta s = 0) ↔ (riemannZeta s = 0 ∧ s.re = 1 / 2) := by
  constructor
  · intro hz
    exact ⟨hz, conditional_RH_via_torus_compatibility_frontier hT s hz hstrip⟩
  · intro h
    exact h.1

/-- Same collapse packaged with the torus lock label (`torusPhaseLock s`).
Since `torusPhaseLock s` is definitionaly `s.re = 1/2`, this is a notation-level
frontier simplifier for nontrivial-zero workflows. -/
theorem nontrivial_zero_frontier_collapse_torusPhaseLock_iff
    (hT : TorusCompatibilityFrontier)
    (s : ℂ)
    (hstrip : 0 < s.re ∧ s.re < 1) :
    (riemannZeta s = 0) ↔ (riemannZeta s = 0 ∧ torusPhaseLock s) := by
  simpa [torusPhaseLock] using
    (nontrivial_zero_frontier_collapse_iff hT s hstrip)

/-- Closed-frontier package using the new arithmetic/geometric/channel bridges:
1. nontrivial-zero collapse IFF at torus-lock form,
2. coprime torus memory/no-resonance package (`gcd(8,D)=1`),
3. Hardy/Euler Re-Im channel principles (set-level and window-level). -/
theorem closed_frontier_package_of_coprimality_dimensionLift_and_channels
    (j D N : ℕ) (S : Finset ℕ) (t θ : ℝ) (s : ℂ)
    (hD : Nat.gcd 8 D = 1)
    (hDL : DimensionLiftRoadmapFrontier)
    (hstrip : 0 < s.re ∧ s.re < 1) :
    ((riemannZeta s = 0) ↔ (riemannZeta s = 0 ∧ torusPhaseLock s))
      ∧ (phase8Rotate (phaseIndex (j + 8)) = phase8Rotate (phaseIndex j) ∧ torusNoResonance D)
      ∧ ((partialEulerPhaseVelocity S t θ).im = (partialEulerPhaseCore S t θ).re
          ∧ (partialEulerPhaseVelocity S t θ).re = -(partialEulerPhaseCore S t θ).im)
      ∧ ((partialEulerPhaseVelocity_window N t θ).im
            = (partialEulerPhaseCore_window N t θ).re
          ∧ (partialEulerPhaseVelocity_window N t θ).re
              = -(partialEulerPhaseCore_window N t θ).im) := by
  have hT : TorusCompatibilityFrontier :=
    torusCompatibilityFrontier_of_dimensionLiftFrontier hDL.1
  refine ⟨?_, ?_, ?_, ?_⟩
  · exact nontrivial_zero_frontier_collapse_torusPhaseLock_iff hT s hstrip
  · exact torus_period_memory_and_no_resonance j D hD
  · exact hardy_local_re_euler_global_im_channel_principle S t θ
  · exact hardy_local_re_euler_global_im_channel_principle_window N t θ

/-- Alternative RH endpoint via the strong-defect frontier.

This states the purely algebraic rigidity route against an explicit two-assumption bundle:
1. Defect-profile factorization: nonvacuous medium channel at off-critical points.
2. Window-defect zero-closure: finite-window defects tend to zero everywhere.

This route is structurally sound but more abstract. The primary route via
`conditional_RH_via_window_limits` (which is now the default `conditional_RH`) is recommended as more grounded. -/
theorem conditional_RH_from_strong_defect_frontier
    (hS : StrongDefectFrontier) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  intro s hz hstrip
  exact phase_lock_rigidity_from_2D_defect_boundary_strong
    (xi_defect_profile_nonzero_off_critical := hS.1)
    (xi_partial_defect2D_window_tendsto_zero := hS.2)
    s hstrip

/-- Window-limit RH closure (conditional on the stated boundary axioms). -/
theorem conditional_RH_via_window_limits :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1/2 := by
  exact conditional_RH_via_torus_compatibility_frontier torusCompatibilityFrontier_holds

/-- Top-level RH closure via the constructor path
`XiLogDerivFormula + slit -> WindowLimitFrontier -> TorusCompatibilityFrontier`. -/
theorem conditional_RH_via_torus_constructor_of_XiLogDerivFormula_and_slit
    (step1_F_lattice_boundary_assumption : F_lattice_zero_limit_boundary)
    (hTail : (t θ : ℝ) :
      ∀ ε > 0, ∃ N0 : ℕ, ∀ N₁ N₂ : ℕ,
        N0 ≤ N₁ → N₁ ≤ N₂ →
        ‖missingPrimeCore N₁ N₂ t θ‖ < ε)
    (hVel : (t θ : ℝ) :
      Filter.Tendsto (fun N : ℕ => partialEulerPhaseVelocity_window N t θ)
        Filter.atTop (nhds (xi_logderiv_core_on_line t)))
    (hΞ : XiLogDerivFormula)
    (hslit : ∀ t : ℝ, xi ((1 / 2 : ℂ) + t * Complex.I) ∈ Complex.slitPlane) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1 / 2 := by
  have hT : TorusCompatibilityFrontier :=
    TorusCompatibilityFrontier_constructor_of_XiLogDerivFormula_and_slit
      step1_F_lattice_boundary_assumption hTail hVel hΞ hslit
  exact conditional_RH_via_torus_compatibility_frontier hT

/-- Window-limit RH closure from the compressed two-item frontier interface. -/
theorem conditional_RH_via_two_axiom_frontier
    (hfrontier : final_RH_two_axiom_frontier) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1/2 := by
  intro s hz hstrip
  rcases hfrontier with ⟨hzero, hpass⟩
  rcases hzero s hz with ⟨sN, hsNzero, hsNtendsto⟩
  refine hpass s hstrip ?_
  refine ⟨sN, ?_, hsNtendsto⟩
  intro N
  exact hsNzero N

/-- Endpoint closure restated with the bundled frontier interface. -/
theorem conditional_RH_via_window_limits_from_final_boundary_bundle
    (hbundle : final_RH_boundary_bundle) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) → s.re = 1/2 := by
  rcases hbundle with ⟨hzero, hreal, hrigid⟩
  have hfrontier : final_RH_two_axiom_frontier := by
    refine ⟨hzero, ?_⟩
    intro s hstrip hlim
    exact hrigid s hstrip (hreal s hstrip (window_zero_limit_to_F_lattice s hlim))
  exact conditional_RH_via_two_axiom_frontier hfrontier

/-! ### Geometric-to-analytic tie-in (non-invasive)

This section keeps the original geometric framework unchanged and records the
explicit analytic phase-velocity counterpart on the critical line.
-/

/-- Geometric phase-lock statement from the original canonical construction. -/
def geometric_phase_lock : Prop :=
  let φ := Complex.arg canonical_observation.μ
  let phase := Real.pi / 4 + Complex.arg canonical_factorization.C
  φ - phase = 0

/-- Analytic phase-lock statement from the ξ log-derivative split on the critical line. -/
def analytic_phase_lock (t : ℝ) : Prop :=
  (deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t).re
      = -(xi_logderiv_core_on_line t).im
    ∧
    (deriv (fun u : ℝ => Complex.log (xi ((1 / 2 : ℂ) + u * Complex.I))) t).im
      = (xi_logderiv_core_on_line t).re

/-- The original geometric phase lock is preserved verbatim. -/
lemma geometric_phase_lock_holds : geometric_phase_lock := by
  simpa [geometric_phase_lock] using canonical_phase_lock

/-- The analytic phase lock follows from the ξ phase-velocity decomposition. -/
lemma analytic_phase_lock_holds (t : ℝ) : analytic_phase_lock t := by
  have hA : Step1ApproximationFrontier :=
    step1_approximation_frontier_of_reduced (step1_reduced_frontier_holds
      step1_F_lattice_boundary_assumption
      step1_tail_control_assumption
      step1_velocity_transfer_assumption
      step1_phase_velocity_identity_assumption)
  have hPhase : Step1PhaseVelocityIdentitySchema :=
    step1_phase_velocity_identity_of_approximation_frontier
      hA
  exact ⟨phase_velocity_real_split hPhase t, phase_velocity_imag_split hPhase t⟩

/-- Combined bridge theorem:
the original geometric lock, the analytic lock, and critical-line ξ-realness
hold together in one package. -/
theorem geometric_analytic_bridge (t : ℝ) :
    geometric_phase_lock ∧ analytic_phase_lock t ∧ xi ((1 / 2 : ℂ) + t * Complex.I) ∈ ℝ := by
  exact ⟨geometric_phase_lock_holds, analytic_phase_lock_holds t, xi_real_on_critical_line t⟩

/-- Named payload for the endpoint-facing channel bridge at parameter `t`. -/
structure EndpointChannelBridgeData (t : ℝ) : Prop where
  constantSource :
    ∃ Bphase : ℂ,
      Bphase = sourcePhase 0
        ∧ ∀ p ∈ prime_window 0,
            eulerKernelPhase p t = Bphase * eulerKernelMedium p t 0
  velocityRe :
    (partialEulerPhaseVelocity_window 0 t 0).re
      = -∑ p in prime_window 0, (eulerKernelMedium p t 0).im
  velocityIm :
    (partialEulerPhaseVelocity_window 0 t 0).im
      = ∑ p in prime_window 0, (eulerKernelMedium p t 0).re
  defectJumpRe :
    (xi_partialEuler_defect_window 0 t 0 - xi_partialEuler_defect_window 0 t 0).re
      = (missingPrimeCore 0 0 t 0).im
  defectJumpIm :
    (xi_partialEuler_defect_window 0 t 0 - xi_partialEuler_defect_window 0 t 0).im
      = -(missingPrimeCore 0 0 t 0).re
  defectReBound :
    |(xi_partialEuler_defect_window 0 t 0 - xi_partialEuler_defect_window 0 t 0).re|
      ≤ ∑ p in (prime_window 0) \ (prime_window 0), ‖eulerKernelMedium p t 0‖
  defectImBound :
    |(xi_partialEuler_defect_window 0 t 0 - xi_partialEuler_defect_window 0 t 0).im|
      ≤ ∑ p in (prime_window 0) \ (prime_window 0), ‖eulerKernelMedium p t 0‖
  coherenceNorm :
    coherenceC (1 : ℝ) = 1 / Real.cosh (Real.log (1 : ℝ))

/-- Clean endpoint-facing projection of the channelized window master bridge.
This keeps endpoint proofs readable while still explicitly depending on the
full window-channel decomposition layer. -/
lemma endpoint_channel_bridge_data (t : ℝ) :
    EndpointChannelBridgeData t := by
  have hmaster := euler_window_master_channel_theorem
    0 0 0 (le_rfl : 0 ≤ 0) t 0 1 (by positivity)
  refine
    { constantSource := hmaster.1
      velocityRe := hmaster.2.1
      velocityIm := hmaster.2.2.1
      defectJumpRe := hmaster.2.2.2.1
      defectJumpIm := hmaster.2.2.2.2.1
      defectReBound := hmaster.2.2.2.2.2.1
      defectImBound := hmaster.2.2.2.2.2.2.1
      coherenceNorm := hmaster.2.2.2.2.2.2.2 }

/-- Projection: window velocity real-channel identity from the endpoint bridge. -/
lemma endpoint_channel_bridge_velocity_re (t : ℝ) :
    (partialEulerPhaseVelocity_window 0 t 0).re
      = -∑ p in prime_window 0, (eulerKernelMedium p t 0).im := by
  exact (endpoint_channel_bridge_data t).velocityRe

/-- Projection: window velocity imaginary-channel identity from the endpoint bridge. -/
lemma endpoint_channel_bridge_velocity_im (t : ℝ) :
    (partialEulerPhaseVelocity_window 0 t 0).im
      = ∑ p in prime_window 0, (eulerKernelMedium p t 0).re := by
  exact (endpoint_channel_bridge_data t).velocityIm

/-- Projection: constant-source factorization over the endpoint window. -/
lemma endpoint_channel_bridge_constant_source (t : ℝ) :
    ∃ Bphase : ℂ,
      Bphase = sourcePhase 0
        ∧ ∀ p ∈ prime_window 0,
            eulerKernelPhase p t = Bphase * eulerKernelMedium p t 0 := by
  exact (endpoint_channel_bridge_data t).constantSource

/-- Projection: defect jump real-channel identity from the endpoint bridge. -/
lemma endpoint_channel_bridge_defect_jump_re (t : ℝ) :
    (xi_partialEuler_defect_window 0 t 0 - xi_partialEuler_defect_window 0 t 0).re
      = (missingPrimeCore 0 0 t 0).im := by
  exact (endpoint_channel_bridge_data t).defectJumpRe

/-- Projection: defect jump imaginary-channel identity from the endpoint bridge. -/
lemma endpoint_channel_bridge_defect_jump_im (t : ℝ) :
    (xi_partialEuler_defect_window 0 t 0 - xi_partialEuler_defect_window 0 t 0).im
      = -(missingPrimeCore 0 0 t 0).re := by
  exact (endpoint_channel_bridge_data t).defectJumpIm

/-- Projection: defect jump real-channel bound from the endpoint bridge. -/
lemma endpoint_channel_bridge_defect_re_bound (t : ℝ) :
    |(xi_partialEuler_defect_window 0 t 0 - xi_partialEuler_defect_window 0 t 0).re|
      ≤ ∑ p in (prime_window 0) \ (prime_window 0), ‖eulerKernelMedium p t 0‖ := by
  exact (endpoint_channel_bridge_data t).defectReBound

/-- Projection: defect jump imaginary-channel bound from the endpoint bridge. -/
lemma endpoint_channel_bridge_defect_im_bound (t : ℝ) :
    |(xi_partialEuler_defect_window 0 t 0 - xi_partialEuler_defect_window 0 t 0).im|
      ≤ ∑ p in (prime_window 0) \ (prime_window 0), ‖eulerKernelMedium p t 0‖ := by
  exact (endpoint_channel_bridge_data t).defectImBound

/-- Projection: normalized coherence identity from the endpoint bridge. -/
lemma endpoint_channel_bridge_coherence (t : ℝ) :
    coherenceC (1 : ℝ) = 1 / Real.cosh (Real.log (1 : ℝ)) := by
  exact (endpoint_channel_bridge_data t).coherenceNorm

/-! ### Theorem Dependency Map (Endpoint)

The final endpoint is intentionally layered. This block records the exact
dependency chain in one place.

Primary closure chain:
1. `conditional_RH_via_window_limits`
1a. `conditional_RH_via_torus_compatibility_frontier`
1b. `conditional_RH_via_two_axiom_frontier`
1c. `conditional_RH_via_window_limit_frontier`
1d. `conditional_RH_from_strong_defect_frontier`
1e. `conditional_RH_via_F_lattice_boundary`
1f. `conditional_RH_via_F_lattice`
1g. `conditional_RH_via_window_zero_limit_boundary`
1h. `conditional_RH_via_window_zero_limit`
2. `conditional_RH_via_window_limits_with_bridge`
2a. `conditional_RH_via_F_lattice_boundary_with_bridge`
3. `rh_endpoint_master`
3a. `rh_endpoint_master_from_F_lattice_boundary`
3b. `rh_endpoint_master_via_F_lattice`
3c. `rh_endpoint_master_from_window_zero_limit_boundary`
3d. `rh_endpoint_master_via_window_zero_limit`

Machine-auditable frontier interfaces:
1. `TorusCompatibilityFrontier`
2. `torusCompatibilityFrontier_holds`
3. `StrongDefectFrontier`
4. `strong_defect_frontier_holds`
5. `WindowLimitFrontier`
6. `window_limit_frontier_holds`
7. `final_RH_two_axiom_frontier_of_window_limit_frontier`
8. `F_lattice_zero_limit_boundary`
9. `F_lattice_zero_limit_boundary_of_zeta_zero_is_limit_of_window_zeros`
10. `F_lattice_zero_limit_boundary_holds`
11. `window_zero_limit_boundary`
12. `window_zero_limit_boundary_holds`
13. `window_limit_frontier_of_window_zero_limit_boundary`
14. `window_limit_frontier_of_F_lattice_boundary`
15. `zeta_zero_is_limit_of_window_zeros_of_F_lattice_boundary`

Bridge chain used by the endpoint:
1. `euler_window_master_channel_theorem`
2. `endpoint_channel_bridge_data`
3. threaded inside `rh_endpoint_master`

Geometric/analytic lock chain:
1. `geometric_phase_lock_holds`
2. `analytic_phase_lock_holds`
3. `geometric_analytic_bridge`
4. consumed by `conditional_RH_via_window_limits_with_bridge`
5. consumed by `conditional_RH_via_F_lattice_boundary_with_bridge`
-/

/-- Threaded closure theorem:
combines window-limit RH forcing with the geometric/analytic bridge package. -/
theorem conditional_RH_via_window_limits_with_bridge :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) →
      s.re = 1/2 ∧ geometric_phase_lock ∧ analytic_phase_lock s.im := by
  intro s hz hstrip
  have hcrit : s.re = 1/2 :=
    conditional_RH_via_torus_compatibility_frontier torusCompatibilityFrontier_holds s hz hstrip
  have hbridge := geometric_analytic_bridge s.im
  exact ⟨hcrit, hbridge.1, hbridge.2.1⟩

/-- Geometry+analytics endpoint routed directly from the `F(s,t)` lattice boundary. -/
theorem conditional_RH_via_F_lattice_boundary_with_bridge
    (hF : F_lattice_zero_limit_boundary) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) →
      s.re = 1/2 ∧ geometric_phase_lock ∧ analytic_phase_lock s.im := by
  intro s hz hstrip
  have hcrit : s.re = 1/2 :=
    conditional_RH_via_F_lattice_boundary hF s hz hstrip
  have hbridge := geometric_analytic_bridge s.im
  exact ⟨hcrit, hbridge.1, hbridge.2.1⟩

/-- Geometry+analytics endpoint routed through the dimension-lift roadmap frontier. -/
theorem conditional_RH_via_dimensionLiftRoadmap_with_bridge
    (hDL : DimensionLiftRoadmapFrontier) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) →
      s.re = 1/2 ∧ geometric_phase_lock ∧ analytic_phase_lock s.im := by
  intro s hz hstrip
  have hcrit : s.re = 1/2 :=
    conditional_RH_via_dimensionLiftRoadmap hDL s hz hstrip
  have hbridge := geometric_analytic_bridge s.im
  exact ⟨hcrit, hbridge.1, hbridge.2.1⟩

/-- Master endpoint theorem for this development.
It packages the window-limit RH closure together with the geometric/analytic bridge. -/
theorem rh_endpoint_master :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) →
      s.re = 1/2
        ∧ geometric_phase_lock
        ∧ analytic_phase_lock s.im
        ∧ xi ((1 / 2 : ℂ) + s.im * Complex.I) ∈ ℝ := by
  intro s hz hstrip
  have hmain := conditional_RH_via_window_limits_with_bridge s hz hstrip
  have hbridge := geometric_analytic_bridge s.im
  have _ :
      coherenceC (1 : ℝ) = 1 / Real.cosh (Real.log (1 : ℝ)) :=
        endpoint_channel_bridge_coherence s.im
  exact ⟨hmain.1, hmain.2.1, hmain.2.2, hbridge.2.2⟩

/-- Master endpoint restated with the bundled frontier interface. -/
theorem rh_endpoint_master_from_final_boundary_bundle
    (hbundle : final_RH_boundary_bundle) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) →
      s.re = 1/2
        ∧ geometric_phase_lock
        ∧ analytic_phase_lock s.im
        ∧ xi ((1 / 2 : ℂ) + s.im * Complex.I) ∈ ℝ := by
  intro s hz hstrip
  have hcrit : s.re = 1 / 2 :=
    conditional_RH_via_window_limits_from_final_boundary_bundle hbundle s hz hstrip
  have hbridge := geometric_analytic_bridge s.im
  have _ :
      coherenceC (1 : ℝ) = 1 / Real.cosh (Real.log (1 : ℝ)) :=
        endpoint_channel_bridge_coherence s.im
  exact ⟨hcrit, hbridge.1, hbridge.2.1, hbridge.2.2⟩

/-- Master endpoint routed through the machine-auditable window-limit interface. -/
theorem rh_endpoint_master_from_window_limit_frontier
    (hW : WindowLimitFrontier) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) →
      s.re = 1/2
        ∧ geometric_phase_lock
        ∧ analytic_phase_lock s.im
        ∧ xi ((1 / 2 : ℂ) + s.im * Complex.I) ∈ ℝ := by
  intro s hz hstrip
  have hcrit : s.re = 1 / 2 :=
    conditional_RH_via_window_limit_frontier hW s hz hstrip
  have hbridge := geometric_analytic_bridge s.im
  have _ :
      coherenceC (1 : ℝ) = 1 / Real.cosh (Real.log (1 : ℝ)) :=
        endpoint_channel_bridge_coherence s.im
  exact ⟨hcrit, hbridge.1, hbridge.2.1, hbridge.2.2⟩

/-- Master endpoint routed directly from the `F(s,t)` lattice boundary. -/
theorem rh_endpoint_master_from_F_lattice_boundary
    (hF : F_lattice_zero_limit_boundary) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) →
      s.re = 1/2
        ∧ geometric_phase_lock
        ∧ analytic_phase_lock s.im
        ∧ xi ((1 / 2 : ℂ) + s.im * Complex.I) ∈ ℝ := by
  intro s hz hstrip
  have hcrit : s.re = 1 / 2 :=
    conditional_RH_via_F_lattice_boundary hF s hz hstrip
  have hbridge := geometric_analytic_bridge s.im
  have _ :
      coherenceC (1 : ℝ) = 1 / Real.cosh (Real.log (1 : ℝ)) :=
        endpoint_channel_bridge_coherence s.im
  exact ⟨hcrit, hbridge.1, hbridge.2.1, hbridge.2.2⟩

/-- Master endpoint via the instantiated `F(s,t)` lattice boundary. -/
theorem rh_endpoint_master_via_F_lattice :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) →
      s.re = 1/2
        ∧ geometric_phase_lock
        ∧ analytic_phase_lock s.im
        ∧ xi ((1 / 2 : ℂ) + s.im * Complex.I) ∈ ℝ := by
  exact rh_endpoint_master_from_F_lattice_boundary F_lattice_zero_limit_boundary_holds

/-- Master endpoint routed directly from the standard window-zero boundary. -/
theorem rh_endpoint_master_from_window_zero_limit_boundary
    (hW0 : window_zero_limit_boundary) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) →
      s.re = 1/2
        ∧ geometric_phase_lock
        ∧ analytic_phase_lock s.im
        ∧ xi ((1 / 2 : ℂ) + s.im * Complex.I) ∈ ℝ := by
  exact rh_endpoint_master_from_window_limit_frontier
    (window_limit_frontier_of_window_zero_limit_boundary hW0)

/-- Master endpoint via the instantiated standard window-zero boundary. -/
theorem rh_endpoint_master_via_window_zero_limit :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) →
      s.re = 1/2
        ∧ geometric_phase_lock
        ∧ analytic_phase_lock s.im
        ∧ xi ((1 / 2 : ℂ) + s.im * Complex.I) ∈ ℝ := by
  exact rh_endpoint_master_from_window_zero_limit_boundary
    window_zero_limit_boundary_holds

/-- Master endpoint routed through the machine-auditable strong-defect interface. -/
theorem rh_endpoint_master_from_strong_defect_frontier
    (hS : StrongDefectFrontier) :
    ∀ s : ℂ, riemannZeta s = 0 → (0 < s.re ∧ s.re < 1) →
      s.re = 1/2
        ∧ geometric_phase_lock
        ∧ analytic_phase_lock s.im
        ∧ xi ((1 / 2 : ℂ) + s.im * Complex.I) ∈ ℝ := by
  intro s hz hstrip
  have hcrit : s.re = 1 / 2 :=
    conditional_RH_from_strong_defect_frontier hS s hz hstrip
  have hbridge := geometric_analytic_bridge s.im
  have _ :
      coherenceC (1 : ℝ) = 1 / Real.cosh (Real.log (1 : ℝ)) :=
        endpoint_channel_bridge_coherence s.im
  exact ⟨hcrit, hbridge.1, hbridge.2.1, hbridge.2.2⟩

/-- Coordinate version: a point `x + iy` is on the unit circle iff `x^2 + y^2 = 1`. -/
lemma unit_circle_abs_xy (x y : ℝ) (hxy : x ^ 2 + y ^ 2 = 1) :
    Complex.abs ((x : ℂ) + y * Complex.I) = 1 := by
  rw [Complex.abs_def]
  simp [Complex.normSq, hxy]

/-- Crossing-locus algebra on the unit circle:
if the real and imaginary coordinates agree, each squared coordinate is `1/2`. -/
lemma unit_circle_re_eq_im_locus_sq (x y : ℝ)
    (hxy : x ^ 2 + y ^ 2 = 1) (hcross : x = y) :
    x ^ 2 = 1 / 2 ∧ y ^ 2 = 1 / 2 := by
  constructor <;> nlinarith [hxy, hcross]

/-- First-quadrant crossing point on the unit circle:
the locus `x = y` collapses to the single positive point `sqrt(1/2) + i sqrt(1/2)`. -/
lemma unit_circle_re_eq_im_first_quadrant_point (x y : ℝ)
    (hxy : x ^ 2 + y ^ 2 = 1) (hcross : x = y) (hx_nonneg : 0 ≤ x) :
    x = Real.sqrt (1 / 2) ∧ y = Real.sqrt (1 / 2) := by
  have hsq := unit_circle_re_eq_im_locus_sq x y hxy hcross
  have hx_abs : |x| = Real.sqrt (1 / 2) := by
    have hsqrt := congrArg Real.sqrt hsq.1
    simpa [Real.sqrt_sq_eq_abs] using hsqrt
  have hx : x = Real.sqrt (1 / 2) := by
    simpa [abs_of_nonneg hx_nonneg] using hx_abs
  constructor
  · exact hx
  · simpa [hcross] using hx

/-- Complex-coordinate form of the first-quadrant crossing point on the unit circle. -/
lemma unit_circle_re_eq_im_first_quadrant_complex_point (x y : ℝ)
    (hxy : x ^ 2 + y ^ 2 = 1) (hcross : x = y) (hx_nonneg : 0 ≤ x) :
    ((x : ℂ) + y * Complex.I)
      = ((Real.sqrt (1 / 2) : ℂ) + Real.sqrt (1 / 2) * Complex.I) := by
  rcases unit_circle_re_eq_im_first_quadrant_point x y hxy hcross hx_nonneg with ⟨hx, hy⟩
  simp [hx, hy]

/-- The first-quadrant crossing point is the `π/4` phase point on the unit circle. -/
lemma unit_circle_re_eq_im_first_quadrant_eq_exp_pi_div_four :
    ((Real.sqrt (1 / 2) : ℂ) + Real.sqrt (1 / 2) * Complex.I)
      = Complex.exp ((Real.pi / 4) * Complex.I) := by
  rw [Complex.exp_mul_I]
  simp

/-- The first-quadrant crossing point is `sourcePhase (π/4)`. -/
lemma unit_circle_re_eq_im_first_quadrant_eq_sourcePhase_pi_div_four :
    ((Real.sqrt (1 / 2) : ℂ) + Real.sqrt (1 / 2) * Complex.I)
      = sourcePhase (Real.pi / 4) := by
  rw [sourcePhase]
  exact unit_circle_re_eq_im_first_quadrant_eq_exp_pi_div_four

/-- Full first-quadrant locus packaging:
on the unit circle, the positive crossing locus `x = y` is exactly `sourcePhase (π/4)`. -/
lemma unit_circle_re_eq_im_first_quadrant_eq_sourcePhase_pi_div_four_of_locus
    (x y : ℝ)
    (hxy : x ^ 2 + y ^ 2 = 1) (hcross : x = y) (hx_nonneg : 0 ≤ x) :
    ((x : ℂ) + y * Complex.I) = sourcePhase (Real.pi / 4) := by
  calc
    ((x : ℂ) + y * Complex.I)
      = ((Real.sqrt (1 / 2) : ℂ) + Real.sqrt (1 / 2) * Complex.I) :=
          unit_circle_re_eq_im_first_quadrant_complex_point x y hxy hcross hx_nonneg
    _ = sourcePhase (Real.pi / 4) :=
          unit_circle_re_eq_im_first_quadrant_eq_sourcePhase_pi_div_four

/-- Third-quadrant crossing point on the unit circle:
the locus `x = y` collapses to the single negative point `-sqrt(1/2) - i sqrt(1/2)`. -/
lemma unit_circle_re_eq_im_third_quadrant_point (x y : ℝ)
    (hxy : x ^ 2 + y ^ 2 = 1) (hcross : x = y) (hx_nonpos : x ≤ 0) :
    x = -Real.sqrt (1 / 2) ∧ y = -Real.sqrt (1 / 2) := by
  have hsq := unit_circle_re_eq_im_locus_sq x y hxy hcross
  have hx_abs : |x| = Real.sqrt (1 / 2) := by
    have hsqrt := congrArg Real.sqrt hsq.1
    simpa [Real.sqrt_sq_eq_abs] using hsqrt
  have hx : x = -Real.sqrt (1 / 2) := by
    have hnegx : -x = Real.sqrt (1 / 2) := by
      simpa [abs_of_nonpos hx_nonpos] using hx_abs
    linarith
  constructor
  · exact hx
  · simpa [hcross] using hx

/-- Complex-coordinate form of the third-quadrant crossing point on the unit circle. -/
lemma unit_circle_re_eq_im_third_quadrant_complex_point (x y : ℝ)
    (hxy : x ^ 2 + y ^ 2 = 1) (hcross : x = y) (hx_nonpos : x ≤ 0) :
    ((x : ℂ) + y * Complex.I)
      = ((-Real.sqrt (1 / 2) : ℝ) : ℂ) + (-Real.sqrt (1 / 2) : ℝ) * Complex.I := by
  rcases unit_circle_re_eq_im_third_quadrant_point x y hxy hcross hx_nonpos with ⟨hx, hy⟩
  simp [hx, hy]

/-- The third-quadrant crossing point is the `5π/4` phase point on the unit circle. -/
lemma unit_circle_re_eq_im_third_quadrant_eq_exp_five_pi_div_four :
    (((-Real.sqrt (1 / 2) : ℝ) : ℂ) + (-Real.sqrt (1 / 2) : ℝ) * Complex.I)
      = Complex.exp (((5 : ℝ) * Real.pi / 4) * Complex.I) := by
  rw [Complex.exp_mul_I]
  simp

/-- The third-quadrant crossing point is `sourcePhase (5π/4)`. -/
lemma unit_circle_re_eq_im_third_quadrant_eq_sourcePhase_five_pi_div_four :
    (((-Real.sqrt (1 / 2) : ℝ) : ℂ) + (-Real.sqrt (1 / 2) : ℝ) * Complex.I)
      = sourcePhase ((5 : ℝ) * Real.pi / 4) := by
  rw [sourcePhase]
  exact unit_circle_re_eq_im_third_quadrant_eq_exp_five_pi_div_four

/-- Full third-quadrant locus packaging:
on the unit circle, the negative crossing locus `x = y` is exactly `sourcePhase (5π/4)`. -/
lemma unit_circle_re_eq_im_third_quadrant_eq_sourcePhase_five_pi_div_four_of_locus
    (x y : ℝ)
    (hxy : x ^ 2 + y ^ 2 = 1) (hcross : x = y) (hx_nonpos : x ≤ 0) :
    ((x : ℂ) + y * Complex.I) = sourcePhase ((5 : ℝ) * Real.pi / 4) := by
  calc
    ((x : ℂ) + y * Complex.I)
      = (((-Real.sqrt (1 / 2) : ℝ) : ℂ) + (-Real.sqrt (1 / 2) : ℝ) * Complex.I) :=
          unit_circle_re_eq_im_third_quadrant_complex_point x y hxy hcross hx_nonpos
    _ = sourcePhase ((5 : ℝ) * Real.pi / 4) :=
          unit_circle_re_eq_im_third_quadrant_eq_sourcePhase_five_pi_div_four

/-- Two-branch locus packaging:
on the unit circle, the crossing locus `x = y` lands exactly on the two phase points
`sourcePhase (π/4)` or `sourcePhase (5π/4)`. -/
lemma unit_circle_re_eq_im_eq_sourcePhase_pi_div_four_or_five_pi_div_four_of_locus
    (x y : ℝ)
    (hxy : x ^ 2 + y ^ 2 = 1) (hcross : x = y) :
    ((x : ℂ) + y * Complex.I) = sourcePhase (Real.pi / 4)
      ∨ ((x : ℂ) + y * Complex.I) = sourcePhase ((5 : ℝ) * Real.pi / 4) := by
  by_cases hx_nonneg : 0 ≤ x
  · left
    exact unit_circle_re_eq_im_first_quadrant_eq_sourcePhase_pi_div_four_of_locus
      x y hxy hcross hx_nonneg
  · right
    have hx_nonpos : x ≤ 0 := le_of_not_ge hx_nonneg
    exact unit_circle_re_eq_im_third_quadrant_eq_sourcePhase_five_pi_div_four_of_locus
      x y hxy hcross hx_nonpos

/-- Converse first-branch packaging:
the phase point `sourcePhase (π/4)` lies on the unit-circle crossing locus. -/
lemma unit_circle_re_eq_im_locus_of_eq_sourcePhase_pi_div_four
    (x y : ℝ)
    (hz : ((x : ℂ) + y * Complex.I) = sourcePhase (Real.pi / 4)) :
    x ^ 2 + y ^ 2 = 1 ∧ x = y := by
  have hx : x = Real.sqrt (1 / 2) := by
    have hre := congrArg Complex.re hz
    simpa [sourcePhase_re] using hre
  have hy : y = Real.sqrt (1 / 2) := by
    have him := congrArg Complex.im hz
    simpa [sourcePhase_im] using him
  have hsqrt : Real.sqrt (1 / 2) ^ 2 = 1 / 2 := by
    have hhalf_nonneg : 0 ≤ (1 / 2 : ℝ) := by positivity
    simpa using Real.sq_sqrt hhalf_nonneg
  constructor
  · rw [hx, hy, hsqrt, hsqrt]
    ring
  · simpa [hx, hy]

/-- Converse third-branch packaging:
the phase point `sourcePhase (5π/4)` lies on the unit-circle crossing locus. -/
lemma unit_circle_re_eq_im_locus_of_eq_sourcePhase_five_pi_div_four
    (x y : ℝ)
    (hz : ((x : ℂ) + y * Complex.I) = sourcePhase ((5 : ℝ) * Real.pi / 4)) :
    x ^ 2 + y ^ 2 = 1 ∧ x = y := by
  have hx : x = -Real.sqrt (1 / 2) := by
    have hre := congrArg Complex.re hz
    simpa [sourcePhase_re] using hre
  have hy : y = -Real.sqrt (1 / 2) := by
    have him := congrArg Complex.im hz
    simpa [sourcePhase_im] using him
  have hsqrt : Real.sqrt (1 / 2) ^ 2 = 1 / 2 := by
    have hhalf_nonneg : 0 ≤ (1 / 2 : ℝ) := by positivity
    simpa using Real.sq_sqrt hhalf_nonneg
  constructor
  · rw [hx, hy]
    ring_nf
    rw [hsqrt, hsqrt]
    ring
  · simpa [hx, hy]

/-- Exact two-way characterization of the unit-circle crossing locus. -/
lemma unit_circle_re_eq_im_iff_eq_sourcePhase_pi_div_four_or_five_pi_div_four
    (x y : ℝ) :
    (x ^ 2 + y ^ 2 = 1 ∧ x = y)
      ↔ (((x : ℂ) + y * Complex.I) = sourcePhase (Real.pi / 4)
        ∨ ((x : ℂ) + y * Complex.I) = sourcePhase ((5 : ℝ) * Real.pi / 4)) := by
  constructor
  · intro h
    exact unit_circle_re_eq_im_eq_sourcePhase_pi_div_four_or_five_pi_div_four_of_locus
      x y h.1 h.2
  · intro h
    rcases h with hpi | hfive
    · exact unit_circle_re_eq_im_locus_of_eq_sourcePhase_pi_div_four x y hpi
    · exact unit_circle_re_eq_im_locus_of_eq_sourcePhase_five_pi_div_four x y hfive

/-- Exact crossing-locus characterization restated in `Z/8Z` phase indexing (`1` and `5`). -/
lemma unit_circle_re_eq_im_iff_eq_phase8Rotate_one_or_five
    (x y : ℝ) :
    (x ^ 2 + y ^ 2 = 1 ∧ x = y)
      ↔ (((x : ℂ) + y * Complex.I) = phase8Rotate (1 : Phase8)
        ∨ ((x : ℂ) + y * Complex.I) = phase8Rotate (5 : Phase8)) := by
  simpa [phase8Rotate_one, phase8Rotate_five] using
    (unit_circle_re_eq_im_iff_eq_sourcePhase_pi_div_four_or_five_pi_div_four x y)

/-- The normalized canonical source direction is exactly the `π/4` source phase. -/
lemma canonical_B_direction_eq_sourcePhase_pi_div_four :
    (((B_canonical.re / Real.sqrt 2 : ℝ) : ℂ) + (B_canonical.im / Real.sqrt 2) * Complex.I)
      = sourcePhase (Real.pi / 4) := by
  exact canonical_source_direction_eq_sourcePhase_pi_div_four

/-- The canonical source direction sits on the unit-circle crossing locus `x = y`. -/
lemma canonical_B_direction_on_crossing_locus :
    (B_canonical.re / Real.sqrt 2) ^ 2 + (B_canonical.im / Real.sqrt 2) ^ 2 = 1
      ∧ B_canonical.re / Real.sqrt 2 = B_canonical.im / Real.sqrt 2 := by
  exact unit_circle_re_eq_im_locus_of_eq_sourcePhase_pi_div_four
    (B_canonical.re / Real.sqrt 2) (B_canonical.im / Real.sqrt 2)
    canonical_B_direction_eq_sourcePhase_pi_div_four

/-! ### Trajectory Alignment and Phase Synchronization

The crossing locus on the unit circle emerges from **trajectory alignment**: track the
real and imaginary trajectories separately around the circle, and the locus is where
they exhibit synchronized periodicity — i.e., where Re(θ) = Im(θ) as they precess
around their respective cycles.

This geometric picture connects to phase coherence: the two channels (Re and Im) are
in phase when they read the same value simultaneously. On the unit circle, this occurs
at exactly two points: θ = π/4 and θ = 5π/4, corresponding to the phase points
`sourcePhase(π/4)` and `sourcePhase(5π/4)`.
-/

/-- The real-part trajectory on the unit circle: Re(e^{iθ}) = cos(θ). -/
lemma unit_circle_re_trajectory (θ : ℝ) :
    (sourcePhase θ).re = Real.cos θ := sourcePhase_re θ

/-- The imaginary-part trajectory on the unit circle: Im(e^{iθ}) = sin(θ). -/
lemma unit_circle_im_trajectory (θ : ℝ) :
    (sourcePhase θ).im = Real.sin θ := sourcePhase_im θ

/-- Trajectory alignment condition: Re and Im trajectories coincide on the unit circle. -/
lemma unit_circle_trajectory_alignment (θ : ℝ) :
    (sourcePhase θ).re = (sourcePhase θ).im ↔ Real.cos θ = Real.sin θ := by
  rw [unit_circle_re_trajectory, unit_circle_im_trajectory]

/-- First trajectory-alignment point: θ = π/4 yields synchronized Re and Im. -/
lemma unit_circle_first_alignment_point :
    Real.cos (Real.pi / 4) = Real.sin (Real.pi / 4) := by
  simp [Real.cos_pi_div_four, Real.sin_pi_div_four]

/-- Second trajectory-alignment point: θ = 5π/4 yields synchronized Re and Im. -/
lemma unit_circle_second_alignment_point :
    Real.cos ((5 : ℝ) * Real.pi / 4) = Real.sin ((5 : ℝ) * Real.pi / 4) := by
  simp [Real.cos_pi_div_four, Real.sin_pi_div_four]

/-- Phase-synchronization interpretation: the crossing locus is where trajectory
    periodicity reads the same in both Re and Im channels. -/
theorem unit_circle_trajectory_synchronization (θ : ℝ) :
    (sourcePhase (θ + 2 * Real.pi)).re = (sourcePhase θ).re
      ∧ (sourcePhase (θ + 2 * Real.pi)).im = (sourcePhase θ).im := by
  constructor
  · simp [unit_circle_re_trajectory]
  · simp [unit_circle_im_trajectory]

/-- The two distinguished crossing phases are explicit trajectory-synchronization points. -/
theorem unit_circle_trajectory_synchronization_points :
    (sourcePhase (Real.pi / 4)).re = (sourcePhase (Real.pi / 4)).im
      ∧ (sourcePhase ((5 : ℝ) * Real.pi / 4)).re =
        (sourcePhase ((5 : ℝ) * Real.pi / 4)).im := by
  constructor
  · rw [unit_circle_trajectory_alignment]
    exact unit_circle_first_alignment_point
  · rw [unit_circle_trajectory_alignment]
    exact unit_circle_second_alignment_point

/-- Coordinate version of trajectory alignment: on the unit circle with x = y,
    both Re and Im trajectories "precess together" at phase points π/4 and 5π/4. -/
theorem unit_circle_coordinate_phase_locking (x y : ℝ)
    (hxy : x ^ 2 + y ^ 2 = 1) (heq : x = y) :
    x = Real.sqrt (1 / 2) ∨ x = -Real.sqrt (1 / 2) := by
  have := unit_circle_re_eq_im_locus_sq x y hxy heq
  have hx2 : x ^ 2 = 1 / 2 := this.1
  have hsq : x ^ 2 = (Real.sqrt (1 / 2)) ^ 2 := by
    have hsqrt : (Real.sqrt (1 / 2)) ^ 2 = 1 / 2 := by
      have hnonneg : (0 : ℝ) ≤ 1 / 2 := by norm_num
      simpa [pow_two] using (Real.sq_sqrt hnonneg)
    linarith
  rcases sq_eq_sq_iff_eq_or_eq_neg.mp hsq with h | h
  · exact Or.inl h
  · exact Or.inr (by linarith)

/-- Contradiction primitive: `x = y` and `y/x = -1` cannot both hold for nonzero `x`. -/
lemma eq_and_ratio_neg_one_contradiction
    (x y : ℝ)
    (hxy : x = y)
    (hdiv : y / x = -1)
    (hx : x ≠ 0) : False := by
  have hdiv' : x / x = -1 := by simpa [hxy] using hdiv
  have hone : x / x = (1 : ℝ) := by field_simp [hx]
  have : (1 : ℝ) = -1 := by linarith [hone, hdiv']
  linarith

/-- Equivalent zero-collapse form:
if `x = y` and `y/x = -1` hold, then `x = 0` (hence `y = 0`). -/
lemma eq_and_ratio_neg_one_implies_zero
    (x y : ℝ)
    (hxy : x = y)
    (hdiv : y / x = -1) :
    x = 0 ∧ y = 0 := by
  by_cases hx0 : x = 0
  · refine ⟨hx0, ?_⟩
    simpa [hxy] using hx0
  · exact (eq_and_ratio_neg_one_contradiction x y hxy hdiv hx0).elim

/-- Start-admissibility principle (crossing-locus form):
on the unit circle, the start state can occur only on the synchronized branch
`Re = Im`. Equivalently, any admissible start-point equals one of the two
crossing phase points. -/
theorem start_admissible_only_if_re_eq_im (x y : ℝ)
    (hxy : x ^ 2 + y ^ 2 = 1)
    (hstart :
      ((x : ℂ) + y * Complex.I = sourcePhase (Real.pi / 4))
        ∨ ((x : ℂ) + y * Complex.I = sourcePhase ((5 : ℝ) * Real.pi / 4))) :
    x = y := by
  have hlocus :
      x ^ 2 + y ^ 2 = 1 ∧ x = y := by
    exact (unit_circle_re_eq_im_iff_eq_sourcePhase_pi_div_four_or_five_pi_div_four x y).2 hstart
  exact hlocus.2

/-- Coordinate version of ξ-conjugation: `x + iy` maps to `x - iy`. -/
lemma xi_conj_xy (x y : ℝ) :
    conj (xi ((x : ℂ) + y * Complex.I)) = xi ((x : ℂ) - y * Complex.I) := by
  simpa [sub_eq_add_neg, add_assoc, add_left_comm, add_comm,
    mul_assoc, mul_left_comm, mul_comm]
    using xi_conj ((x : ℂ) + y * Complex.I)

/-- Combined `x + iy` symmetry link:
unit-circle modulus in coordinates + ξ conjugation symmetry in coordinates. -/
theorem symmetry_link_to_xi_xy (x y : ℝ) (hxy : x ^ 2 + y ^ 2 = 1) :
    Complex.abs ((x : ℂ) + y * Complex.I) = 1 ∧
    conj (xi ((x : ℂ) + y * Complex.I)) = xi ((x : ℂ) - y * Complex.I) := by
  exact ⟨unit_circle_abs_xy x y hxy, xi_conj_xy x y⟩

end FourAxioms

/-!
  Honest accounting of what's proved vs. left as `sorry` in this file:

  PROVED CLEANLY (no sorry):
    • magnitude_balance      :  |B|·|C| = 1
    • B_mul_C_eq_μ           :  B · C = μ
    • B_abs, C_abs           :  |B| = √2, |C| = 1/√2
    • log_distrib            :  log(BC) = log B + log C
    • log_real_parts_cancel  :  Re(log B) + Re(log C) = 0
    • phase_closure          :  arg(A) − (arg(B) + arg(C)) = 0
    • silver_eq              :  metallic 1 = 1 + √2
    • golden_self_referential:  φ² = φ + 1
    • coherence_eq_sech_log  :  C(r) = (1/2)·sech²((log r)/2)
    • coherenceC_eq_sech_log_h: C(h) = sech(log h)
    • coherence_symmetric    :  C(r) = C(1/r)
    • coherence_peak         :  C(1) = 1/2
    • reflect_involutive
    • reflect_fixed_iff      :  reflect σ = σ ↔ σ = 1/2
    • off_critical_line_splits
    • critical_line_forced   :  fixed-axis condition ⇒ σ = 1/2
    • off_critical_line_contradiction (the proof-by-contradiction)
    • log_reflection_fixed_iff:  −μ = μ ↔ μ = 0
    • framework_forces_critical_line
    • euler_trig_coherence_bridge
    • euler_window_trig_coherence_bridge
    • euler_window_master_channel_theorem
    • endpoint_channel_bridge_data
    • partialEulerPhaseCore_re / partialEulerPhaseCore_im
    • partialEulerPhaseVelocity_re / partialEulerPhaseVelocity_im
    • xi_partialEuler_defect_window_jump_re / xi_partialEuler_defect_window_jump_im
    • xi_partialEuler_defect_window_refine_re_abs_le /
      xi_partialEuler_defect_window_refine_im_abs_le

  LEFT AS `sorry`:
    • none

  NOT FORMALIZED (explicit analytic boundary assumptions/frontier inputs still active):
    Minimal strong-defect frontier (alternative route via `conditional_RH_from_strong_defect_frontier`):
    • `strongDefectProfile_assumption`
    • `strongDefectClosure_assumption`
    Projected interfaces:
    • `xi_defect_profile_nonzero_off_critical`
    • `xi_partial_defect2D_window_tendsto_zero`
    Interface names:
    • `StrongDefectFrontier`
    • `strong_defect_frontier_holds`
    • `conditional_RH_from_strong_defect_frontier`

    Window-limit packaging frontier (used by `conditional_RH_via_window_limits` and
    `rh_endpoint_master`):
    • `step1_F_lattice_boundary_assumption`
    • `step1_tail_control_assumption`
    • `step1_velocity_transfer_assumption`
    • `step1_phase_velocity_identity_assumption`
    Proven bridge:
    • `PhaseLockLatticeBridge`
    • `phase_lock_lattice_bridge_holds`
    • `phase_lock_from_F_lattice_limit`
    • `phase_lock_from_window_limit` (legacy wrapper)
    Derived interface:
    • `zeta_zero_is_limit_of_window_zeros`
    Interface names:
    • `WindowLimitFrontier`
    • `window_limit_frontier_holds`
    • `final_RH_two_axiom_frontier_of_window_limit_frontier`
    • `conditional_RH_via_window_limit_frontier`

    Unified torus-compatibility frontier (canonical top-level endpoint interface):
    • `TorusCompatibilityFrontier`
    • `torusCompatibilityFrontier_holds`
    • `torusCompatibilityDefect`
    • `torusPhaseLock`
    • `torusCompatibilityDefect_tendsto_zero_of_strongDefectFrontier`
    • `torusPhaseLock_of_window_limit_frontier`
    • `conditional_RH_via_torus_compatibility_frontier`

    Supporting analytic boundaries (outside the minimal endpoint frontier):
    • `real_axis_zeta_zero_onTrivialZeroLine` — **proved** (real-axis zeros ⇒ trivial-zero line),
      using `riemannZeta_real_no_zero_in_Ioo_01` and `riemannZeta_ne_zero_at_neg_odd_nat`
    • `riemannZeta_real_no_zero_in_Ioo_01` — **remaining real-axis Mathlib-external boundary**
    • `riemannZeta_ne_zero_at_neg_odd_nat` — **discharged** (Bernoulli / special-value layer)
    Midpoint nonvanishing split (explicitly separated routes):
    • strong boundary route: `RiemannZetaHalfNonvanishingBoundary`
      (now theorem-level target/interface; no active assumption variable)
    • certificate route: `RiemannZetaHalfNumericCertificate`
      (active input via `riemannZeta_half_numeric_certificate_assumption`,
      consumed by `riemannZeta_ne_zero_at_half_of_numeric_certificate_boundary`)
    • projection theorem used by the real-axis pipeline:
      `riemannZeta_ne_zero_at_half` (currently routed via the certificate boundary route)
    • `trivial_zero_re_neg` (derived theorem from the classifier)
    • `windowDefectDN_tendsto_zero_regularized` now projects from
      `WindowDefectDNTendstoZeroRegularizedBoundary`
    • `completedRiemannZeta_factor_bridge_at_zero` (isolated `s=0` boundary)
    • `completedRiemannZeta_factor_bridge_on_trivial_zero_line` (negative-even, `Im=0` trivial-zero line)
    • `conjugationBoundaryInput_assumption`
    • `xi_gap_factor_nonzero_off_critical`  -- compatibility theorem (derived from frontier assumptions)
    Prototype target (currently not an active global assumption):
    • `xi_logderiv_formula`
    • `xi_logderiv_symmetry_sum`
    Step-1 consumed analytic bridges (not active global assumptions):
    • `missingPrimeCore_cauchy_tail` -> `step1_tail_control_of_missingPrimeCore_cauchy_tail`
    • `partialEulerPhaseVelocity_window_tendsto` ->
      `step1_velocity_transfer_of_partialEulerPhaseVelocity_window_tendsto`
    • `phase_velocity_on_critical_line` -> `step1_phase_velocity_identity_of_assumption`
    Optional compatibility marker (not an active boundary assumption):
    • `phase_lock_shift_constant_11_over_8`
    Localized compatibility input (not active globally):
    • `xi_partial_defect2D_factor_boundary` (used only by `defect_factors`)
    Projected interface (from bundled conjugation boundary input):
    • `completedHurwitzZetaEven_zero_conj_of_ne_zero`

    (Frontier assumptions are listed once above under the strong-defect and
    window-limit packaging sections to avoid duplication.)

  FINAL ENDPOINT ARCHITECTURE:

    **Primary RH Closure Route (`conditional_RH`)**
    ─────────────────────────────────────────────
    The main theorem uses the TORUS-COMPATIBILITY FRONTIER
    (whose window-limit projection closes RH):

      Main entry:     `conditional_RH : ∀ s, ζ(s) = 0 ∧ 0 < Re(s) < 1 ⇒ Re(s) = 1/2`
      Routing:        `conditional_RH_via_window_limits`
      Constructor route:
                      `conditional_RH_via_torus_constructor_of_XiLogDerivFormula_and_slit`
                      via
                      `TorusCompatibilityFrontier_constructor_of_XiLogDerivFormula_and_slit`
                      and
                      `WindowLimitFrontier_constructor_of_XiLogDerivFormula_and_slit`
      Top frontier:   `TorusCompatibilityFrontier`
      RH projection:  `WindowLimitFrontier`
      Key assumptions:
                      `step1_F_lattice_boundary_assumption`
                      `step1_tail_control_assumption`
                      `step1_velocity_transfer_assumption`
      Phase clause can be routed from:
                      `XiLogDerivFormula` + slit admissibility
                      (no standalone phase-velocity assumption at constructor call sites)
      Key bridge:     `PhaseLockLatticeBridge` / `phase_lock_lattice_bridge_holds`
      Derived link:   zeta_zero_is_limit_of_window_zeros (from F-lattice boundary)
      Grounding:      Directly from the analytic theory of ζ-zeros and finite-window approximations
      Narrative:      Ζ-zeros converge to limit points → phase-lock persists → automatic critical-line rigidity

    **Extended Endpoint (`rh_endpoint_master`)**
    ──────────────────────────────────────────
    Same theorem, packaged with geometric bridge data:

      Entry:          `rh_endpoint_master`
      Routing:        `conditional_RH_via_window_limits_with_bridge`
      Output:         ζ-zero critical-line AND phase-lock AND defect-jump bounds AND coherence norm
      Narrative:      The endpoint facts cohere geometrically and analytically

    **Alternative Strong-Defect Route (`conditional_RH_from_strong_defect_frontier`)**
    ───────────────────────────────────────────────────────────────────────────────
    An explicit alternative path via purely algebraic defect factorization:

      Entry:          `conditional_RH_from_strong_defect_frontier`
      Frontier:       `StrongDefectFrontier`
      Key assumptions:
                      `strongDefectProfile_assumption`
                      `strongDefectClosure_assumption`
      Projected data: xi_defect_profile_nonzero_off_critical, xi_partial_defect2D_window_tendsto_zero
      Grounding:      From multiplicative source/medium/sink decomposition of finite-window defects
      Theorem chain:  defect factorization → lower-bounded medium profile → zero-closure contradiction
      Status:         Structurally sound but less grounded than window-limit route
      Recommendation: Use window-limit (`conditional_RH`) unless you specifically want the defect-driven narrative

    **Geometric Bridge (`canonical_source_direction_eq_sourcePhase_pi_div_four`)**
    ──────────────────────────────────────────────────────────────────────────
    The canonical source factor B = 1+i connects to the unit-circle crossing locus:

      Phase identity:  Normalized B gives sourcePhase(π/4)
      Locus property:  Lies on unit circle with x = y crossing
      Coordinates:     Point is (1/√2, 1/√2), satisfying x² + y² = 1 AND x = y
      Extension:       Exact two-way iff characterization of the crossing locus by two phase points

    **Closure Summary**
    ──────────────────
    1. Conditional RH is proved via window-limit frontier (primary route)
    2. Alternative strong-defect route available (valid but more abstract)
    3. Geometric insight: canonical source phase sits on unit-circle crossing locus
    4. All claims are explicit; no hidden `sorry` statements (remaining axioms are named boundary inputs)
    5. Remaining boundary assumptions are clearly named and documented
    6. Both routes agree on the conclusion: critical-line rigidity for ζ-zeros in the strip
  -/

/-!