Add lean source and binary files (part 109)

lean/OAI/NumberTheory/Ostmann/Arithmetic/JointSampledComparison.lean

@@ -0,0 +1,65 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.SampledPrimeCoincidence
+
+namespace OAI
+
+/-! # Joint signed replacement with actual internal-prime coordinates
+
+Different tests can use different sampled primes and can depend on the other
+prime coordinates. Each test only excludes its own prime coordinate.
+-/
+
+namespace Ostmann
+
+open scoped BigOperators Classical
+
+theorem joint_sampled_polynomial_comparison_le {A I : Type*}
+    [Fintype A] [Nonempty A] [Fintype I] {n : ℕ}
+    (value : A → ℤ) (hinj : Function.Injective value)
+    (prime : A → ℕ) (hpInj : Function.Injective prime) (hprime : ∀ a, (prime a).Prime)
+    (F : I → MvPolynomial (Fin (n + 1)) ℤ) (coordinate : I → Fin (n + 1))
+    (habsent : ∀ i, coordinate i ∉ (F i).vars)
+    (μ : Fin (n + 1) → A → ℝ) (hμ : ∀ j a, 0 ≤ μ j a)
+    (hmass : ∀ j, ∑ a, μ j a = 1)
+    (α β V H : ℝ) (hα : 0 ≤ α) (hβ : 0 ≤ β) (hV : 0 < V) (hH : 1 ≤ H)
+    (hmax : ∀ j a, μ j a ≤ α) (hpmax : ∀ i a, μ (coordinate i) a ≤ β)
+    (hsize : ∀ i a, μ (coordinate i) a ≠ 0 → V ≤ Real.log (prime a : ℝ))
+    (hvalue : ∀ i x, |(integerTestValue value (F i) x : ℝ)| ≤ H)
+    (Ψ : (Fin (n + 1) → A) → (I → Bool) → ℂ)
+    (B : ℝ) (hB : 0 ≤ B) (hΨ : ∀ x flags, ‖Ψ x flags‖ ≤ B) :
+    ‖∑ x, (productPrior μ x : ℂ) *
+      (Ψ x (fun i => arithmeticTestFlag
+        (prime (x (coordinate i)) ∣ (integerTestValue value (F i) x).natAbs)) -
+       Ψ x (fun i => arithmeticTestFlag (F i = 0)))‖ ≤
+      2 * B * ∑ i, (((F i).totalDegree : ℝ) * α + (Real.log H / V) * β) := by
+  let bad := fun i x => F i ≠ 0 ∧ prime (x (coordinate i)) ∣ (integerTestValue value (F i) x).natAbs
+  have hprob (i : I) : (∑ x, productPrior μ x * if bad i x then (1 : ℝ) else 0) ≤
+      ((F i).totalDegree : ℝ) * α + (Real.log H / V) * β := by
+    by_cases hi : F i = 0
+    · simp only [bad, hi, ne_eq, not_true_eq_false, false_and, ite_false, mul_zero,
+        Finset.sum_const_zero]
+      exact add_nonneg (mul_nonneg (Nat.cast_nonneg _) hα)
+        (mul_nonneg (div_nonneg (Real.log_nonneg hH) hV.le) hβ)
+    · simp only [bad, hi, ne_eq, not_false_eq_true, true_and]
+      exact sampled_coordinate_prime_coincidence_le value hinj prime hpInj hprime (F i) hi
+        (coordinate i) (habsent i) μ hμ hmass α β V H hα hβ hV hH hmax (hpmax i) (hsize i) (hvalue i)
+  have heq (x : Fin (n + 1) → A) (hx : ∀ i, ¬bad i x) :
+      (fun i => arithmeticTestFlag
+        (prime (x (coordinate i)) ∣ (integerTestValue value (F i) x).natAbs)) =
+      (fun i => arithmeticTestFlag (F i = 0)) := by
+    funext i
+    by_cases hi : F i = 0
+    · simp [hi, integerTestValue]
+    · have hnd : ¬prime (x (coordinate i)) ∣ (integerTestValue value (F i) x).natAbs :=
+        fun h => hx i ⟨hi, h⟩
+      simp [hi, hnd]
+  have h := @weighted_flag_comparison_le (Fin (n + 1) → A) I inferInstance inferInstance
+    (productPrior μ) (productPrior_nonneg μ hμ)
+    (fun x i => arithmeticTestFlag
+      (prime (x (coordinate i)) ∣ (integerTestValue value (F i) x).natAbs))
+    (fun _ i => arithmeticTestFlag (F i = 0)) bad (fun _ _ => inferInstance)
+    heq Ψ B hB hΨ
+  exact h.trans (mul_le_mul_of_nonneg_left (Finset.sum_le_sum fun i _ => hprob i) (by positivity))
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/JointSplitProbability.lean

@@ -0,0 +1,49 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.SplitSquareSupport
+
+namespace OAI
+
+/-! # The joint support bound for two genuine arithmetic history splits -/
+
+namespace Ostmann
+
+open scoped BigOperators Classical
+
+theorem reduced_modulus_pos {s v : ℕ} (hs : s ≠ 0) : 0 < s / v.gcd s :=
+  Nat.div_pos (Nat.le_of_dvd (Nat.pos_of_ne_zero hs) (Nat.gcd_dvd_right v s))
+    (Nat.gcd_pos_of_pos_right v (Nat.pos_of_ne_zero hs))
+
+/-- The two histories share the random child product but may have different
+parent products, pivots, and frequencies. No complete-history validity event
+has been conditioned on in this average. -/
+theorem joint_split_probability_le {s t Q : ℕ} [NeZero s] [NeZero t] [NeZero Q]
+    (hs : s ∣ Q) (ht : t ∣ Q) (v w v' w' : ℕ)
+    (hgcd : v.gcd s = w.gcd s) (hgcd' : v'.gcd t = w'.gcd t)
+    (A B P : (ZMod s)ˣ) (A' B' P' : (ZMod t)ˣ) :
+    (Fintype.card (ZMod Q)ˣ : ℝ)⁻¹ * (∑ x : (ZMod Q)ˣ,
+      if (v : ZMod s) * (A * (P / ZMod.unitsMap hs x) : (ZMod s)ˣ) =
+          (w : ZMod s) * (B * ZMod.unitsMap hs x : (ZMod s)ˣ) ∧
+        (v' : ZMod t) * (A' * (P' / ZMod.unitsMap ht x) : (ZMod t)ˣ) =
+          (w' : ZMod t) * (B' * ZMod.unitsMap ht x : (ZMod t)ˣ)
+      then (1 : ℝ) else 0) ≤
+      2 * (((s / v.gcd s).lcm (t / v'.gcd t)).divisors.card : ℝ) ^ 2 /
+        (s / v.gcd s).lcm (t / v'.gcd t) := by
+  let a := s / v.gcd s
+  let b := t / v'.gcd t
+  let _ : NeZero a := ⟨Nat.ne_of_gt (reduced_modulus_pos (v := v) (NeZero.ne s))⟩
+  let _ : NeZero b := ⟨Nat.ne_of_gt (reduced_modulus_pos (v := v') (NeZero.ne t))⟩
+  have ha : a ∣ s := Nat.div_dvd_of_dvd (Nat.gcd_dvd_right v s)
+  have hb : b ∣ t := Nat.div_dvd_of_dvd (Nat.gcd_dvd_right v' t)
+  have hleft (x : (ZMod Q)ˣ) :
+      ZMod.unitsMap ha (ZMod.unitsMap hs x) = ZMod.unitsMap (ha.trans hs) x :=
+    DFunLike.congr_fun (ZMod.unitsMap_comp ha hs) x
+  have hright (x : (ZMod Q)ˣ) :
+      ZMod.unitsMap hb (ZMod.unitsMap ht x) = ZMod.unitsMap (hb.trans ht) x :=
+    DFunLike.congr_fun (ZMod.unitsMap_comp hb ht) x
+  simp_rw [unit_split_iff_square v w hgcd, unit_split_iff_square v' w' hgcd',
+    hleft, hright]
+  exact reduced_simultaneous_square_probability_le (ha.trans hs) (hb.trans ht)
+    (splitSquareTarget v w hgcd A B P) (splitSquareTarget v' w' hgcd' A' B' P')
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/JointSquareLiftExclusions.lean

@@ -0,0 +1,76 @@
+import OAI.NumberTheory.Ostmann.Tree.UniformCoordinateAverage
+import OAI.NumberTheory.Ostmann.Arithmetic.SquareLiftExclusions
+import OAI.NumberTheory.Ostmann.Arithmetic.WeightedFlagComparison
+
+namespace OAI
+
+/-! # Dropping all prime-square exclusions in the uniform CRT fibers -/
+
+namespace Ostmann
+open scoped BigOperators Classical
+
+theorem squareLiftPairs_card (p : ℕ) [Fact p.Prime] (x₀ y₀ : ZMod p) :
+    Fintype.card (SquareLiftPairs p x₀ y₀) = p ^ 2 := by
+  rw [Fintype.card_prod, card_squareReduction_fiber, card_squareReduction_fiber, pow_two]
+
+theorem squareLiftPairs_nonempty (p : ℕ) [Fact p.Prime] (x₀ y₀ : ZMod p) :
+    Nonempty (SquareLiftPairs p x₀ y₀) := by
+  exact ⟨⟨⟨(x₀.val : ZMod (p ^ 2)), by simp only [squareReduction_natCast, ZMod.natCast_zmod_val]⟩, ⟨(y₀.val : ZMod (p ^ 2)), by simp only [squareReduction_natCast, ZMod.natCast_zmod_val]⟩⟩⟩
+
+/-- A simultaneous lift comparison for a signed integrand. The remaining
+arithmetic conditions can be included in `F`; they are never conditioned away. -/
+theorem joint_square_lift_removed_mass_le {I : Type*} [Fintype I] [DecidableEq I]
+    (p : I → ℕ) [∀ i, Fact (p i).Prime] (J : I → Type*) [∀ i, Fintype (J i)]
+    (a b : ∀ i, J i → ZMod (p i ^ 2)) (x₀ y₀ : ∀ i, ZMod (p i))
+    (hy : ∀ i, y₀ i ≠ 0)
+    (hrow : ∀ i j, squareReduction (p i) (a i j) ≠ 0 ∨ squareReduction (p i) (b i j) ≠ 0)
+    (hbase : ∀ i j, squareReduction (p i) (a i j) * x₀ i +
+      squareReduction (p i) (b i j) * y₀ i = 0)
+    (F : (∀ i, SquareLiftPairs (p i) (x₀ i) (y₀ i)) → ℂ)
+    (B : ℝ) (hB : 0 ≤ B) (hF : ∀ x, ‖F x‖ ≤ B) :
+    (Fintype.card (∀ i, SquareLiftPairs (p i) (x₀ i) (y₀ i)) : ℝ)⁻¹ *
+      ‖(∑ x, if ∀ i j, a i j * (x i).1.1 + b i j * (x i).2.1 ≠ 0 then F x else 0) -
+        ∑ x, F x‖ ≤ 2 * B * ∑ i, (Fintype.card (J i) : ℝ) / p i := by
+  let X := fun i => SquareLiftPairs (p i) (x₀ i) (y₀ i)
+  let : ∀ i, Nonempty (X i) := fun i => squareLiftPairs_nonempty _ _ _
+  let bad := fun i (x : X i) => ∃ j, a i j * x.1.1 + b i j * x.2.1 = 0
+  let w : ℝ := (Fintype.card (∀ i, X i) : ℝ)⁻¹
+  have hw : 0 ≤ w := inv_nonneg.mpr (Nat.cast_nonneg _)
+  have hlocal (i : I) : (Fintype.card (X i) : ℝ)⁻¹ *
+      (∑ x : X i, if bad i x then (1 : ℝ) else 0) ≤
+      (Fintype.card (J i) : ℝ) / p i := by
+    have h := square_lift_nonzero_rows_removed_mass_le (a i) (b i) (x₀ i) (y₀ i)
+      (hy i) (hrow i) (hbase i) (fun _ => (1 : ℂ)) 1 (by norm_num) (by simp)
+    rw [squareLiftPairs_card]
+    simpa only [bad, X, ← Finset.sum_filter, Finset.sum_const, Finset.card_univ,
+      nsmul_eq_mul, mul_one, Nat.cast_pow, norm_natCast, one_mul, div_eq_mul_inv, mul_comm] using h
+  have hprob (i : I) : ∑ x : ∀ i, X i, w * (if bad i (x i) then (1 : ℝ) else 0) ≤
+      (Fintype.card (J i) : ℝ) / p i := by
+    rw [← Finset.mul_sum]
+    exact (uniform_pi_coordinate_average X i (fun x => if bad i x then 1 else 0)).trans_le (hlocal i)
+  let Ψ := fun (x : ∀ i, X i) (flags : I → Bool) => if ∀ i, flags i = true then F x else 0
+  have h := weighted_flag_comparison_le (fun _ : ∀ i, X i => w) (fun _ => hw)
+    (fun x i => decide (¬bad i (x i))) (fun _ _ => true)
+    (fun i x => bad i (x i))
+    (by intro x hx; funext i; simp [hx i]) Ψ B hB (by
+      intro x flags
+      dsimp only [Ψ]
+      split_ifs
+      · exact hF x
+      · simpa using hB)
+  have he (x : ∀ i, X i) : Ψ x (fun i => decide (¬bad i (x i))) =
+      if ∀ i j, a i j * (x i).1.1 + b i j * (x i).2.1 ≠ 0 then F x else 0 := by
+    simp only [Ψ, decide_eq_true_eq, bad, not_exists]
+  simp only [he, Ψ, implies_true, ite_true] at h
+  have hn : ‖∑ x : ∀ i, X i, (w : ℂ) *
+      ((if ∀ i j, a i j * (x i).1.1 + b i j * (x i).2.1 ≠ 0 then F x else 0) - F x)‖ =
+      w * ‖(∑ x, if ∀ i j, a i j * (x i).1.1 + b i j * (x i).2.1 ≠ 0 then F x else 0) -
+        ∑ x, F x‖ := by
+    rw [← Finset.mul_sum, Finset.sum_sub_distrib, norm_mul, Complex.norm_real,
+      Real.norm_of_nonneg hw]
+  rw [hn] at h
+  exact h.trans (mul_le_mul_of_nonneg_left (Finset.sum_le_sum fun i _ => hprob i) (by positivity))
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LcmFrequencySum.lean

@@ -0,0 +1,117 @@
+import Mathlib.NumberTheory.Harmonic.Bounds
+import Mathlib.Data.Nat.GCD.Basic
+import Mathlib.Tactic.Ring
+import Mathlib.Tactic.Positivity
+
+namespace OAI
+
+/-! # The reciprocal-lcm sum in the frequency budget
+
+The gcd coordinates embed each frequency pair into three independent
+positive harmonic sums. No asymptotic divisor estimate is used here.
+-/
+
+namespace Ostmann
+
+open scoped BigOperators
+
+def gcdFrequencyCoordinates (x : ℕ × ℕ) : ℕ × ℕ × ℕ :=
+  (x.1.gcd x.2, x.1 / x.1.gcd x.2, x.2 / x.1.gcd x.2)
+
+theorem gcdFrequencyCoordinates_recover (x : ℕ × ℕ) :
+    (gcdFrequencyCoordinates x).1 * (gcdFrequencyCoordinates x).2.1 = x.1 ∧
+    (gcdFrequencyCoordinates x).1 * (gcdFrequencyCoordinates x).2.2 = x.2 := by
+  exact ⟨Nat.mul_div_cancel' (Nat.gcd_dvd_left _ _),
+    Nat.mul_div_cancel' (Nat.gcd_dvd_right _ _)⟩
+
+theorem gcdFrequencyCoordinates_injective : Function.Injective gcdFrequencyCoordinates := by
+  intro x y h
+  obtain ⟨hx₁, hx₂⟩ := gcdFrequencyCoordinates_recover x
+  obtain ⟨hy₁, hy₂⟩ := gcdFrequencyCoordinates_recover y
+  apply Prod.ext
+  · exact hx₁.symm.trans ((congrArg (fun z : ℕ × ℕ × ℕ => z.1 * z.2.1) h).trans hy₁)
+  · exact hx₂.symm.trans ((congrArg (fun z : ℕ × ℕ × ℕ => z.1 * z.2.2) h).trans hy₂)
+
+theorem gcdFrequencyCoordinates_lcm (a b : ℕ) (ha : 0 < a) :
+    (gcdFrequencyCoordinates (a, b)).1 * (gcdFrequencyCoordinates (a, b)).2.1 *
+      (gcdFrequencyCoordinates (a, b)).2.2 = a.lcm b := by
+  have hg := Nat.gcd_pos_of_pos_left b ha
+  obtain ⟨ha', hb'⟩ := gcdFrequencyCoordinates_recover (a, b)
+  apply Nat.eq_of_mul_eq_mul_left hg
+  calc
+    _ = ((gcdFrequencyCoordinates (a, b)).1 * (gcdFrequencyCoordinates (a, b)).2.1) *
+        ((gcdFrequencyCoordinates (a, b)).1 * (gcdFrequencyCoordinates (a, b)).2.2) := by
+      dsimp [gcdFrequencyCoordinates]
+      ring
+    _ = a * b := by rw [ha', hb']
+    _ = _ := (Nat.gcd_mul_lcm a b).symm
+
+theorem gcdFrequencyCoordinates_mem {N a b : ℕ}
+    (ha : a ∈ Finset.Icc 1 N) (hb : b ∈ Finset.Icc 1 N) :
+    gcdFrequencyCoordinates (a, b) ∈
+      (Finset.Icc 1 N).product ((Finset.Icc 1 N).product (Finset.Icc 1 N)) := by
+  obtain ⟨ha₀, haN⟩ := Finset.mem_Icc.mp ha
+  obtain ⟨hb₀, hbN⟩ := Finset.mem_Icc.mp hb
+  have hap : 0 < a := ha₀
+  have hbp : 0 < b := hb₀
+  have hg := Nat.gcd_pos_of_pos_left b hap
+  have hga := Nat.le_of_dvd hap (Nat.gcd_dvd_left a b)
+  have hgb := Nat.le_of_dvd hbp (Nat.gcd_dvd_right a b)
+  apply Finset.mem_product.mpr
+  refine ⟨Finset.mem_Icc.mpr ⟨hg, hga.trans haN⟩, Finset.mem_product.mpr ⟨?_, ?_⟩⟩
+  · exact Finset.mem_Icc.mpr ⟨Nat.div_pos hga hg, (Nat.div_le_self _ _).trans haN⟩
+  · exact Finset.mem_Icc.mpr ⟨Nat.div_pos hgb hg, (Nat.div_le_self _ _).trans hbN⟩
+
+/-- Exact finite bound before estimating the harmonic sum. -/
+theorem reciprocal_lcm_sum_le_harmonic_cube (N : ℕ) :
+    (∑ a ∈ Finset.Icc 1 N, ∑ b ∈ Finset.Icc 1 N, ((a.lcm b : ℕ) : ℝ)⁻¹) ≤
+      (∑ n ∈ Finset.Icc 1 N, (n : ℝ)⁻¹) ^ 3 := by
+  let S := Finset.Icc 1 N
+  let w : ℕ × ℕ × ℕ → ℝ := fun z => (z.1 : ℝ)⁻¹ * (z.2.1 : ℝ)⁻¹ * (z.2.2 : ℝ)⁻¹
+  have hw (x : ℕ × ℕ) (hx : x ∈ S.product S) :
+      ((x.1.lcm x.2 : ℕ) : ℝ)⁻¹ = w (gcdFrequencyCoordinates x) := by
+    have ha : 0 < x.1 := (Finset.mem_Icc.mp (Finset.mem_product.mp hx).1).1
+    rw [← gcdFrequencyCoordinates_lcm x.1 x.2 ha]
+    simp only [w, Nat.cast_mul, mul_inv_rev]
+    ring
+  have hsub : (S.product S).image gcdFrequencyCoordinates ⊆ S.product (S.product S) := by
+    intro z hz
+    obtain ⟨x, hx, rfl⟩ := Finset.mem_image.mp hz
+    exact gcdFrequencyCoordinates_mem (Finset.mem_product.mp hx).1 (Finset.mem_product.mp hx).2
+  calc
+    _ = ∑ x ∈ S.product S, w (gcdFrequencyCoordinates x) := by
+      simp only [Finset.product_eq_sprod]
+      rw [Finset.sum_product S S (fun x => w (gcdFrequencyCoordinates x))]
+      apply Finset.sum_congr rfl
+      intro a ha
+      apply Finset.sum_congr rfl
+      intro b hb
+      exact hw (a, b) (Finset.mem_product.mpr ⟨ha, hb⟩)
+    _ = ∑ z ∈ (S.product S).image gcdFrequencyCoordinates, w z := by
+      exact (Finset.sum_image (fun _ _ _ _ h => gcdFrequencyCoordinates_injective h)).symm
+    _ ≤ ∑ z ∈ S.product (S.product S), w z :=
+      Finset.sum_le_sum_of_subset_of_nonneg hsub (fun _ _ _ => by dsimp [w]; positivity)
+    _ = ∑ a ∈ S, ∑ b ∈ S, ∑ c ∈ S, (a : ℝ)⁻¹ * (b : ℝ)⁻¹ * (c : ℝ)⁻¹ := by
+      simp only [Finset.product_eq_sprod]
+      rw [Finset.sum_product S (S ×ˢ S) w]
+      apply Finset.sum_congr rfl
+      intro a _
+      exact Finset.sum_product S S (fun z => w (a, z))
+    _ = _ := by
+      simp only [← Finset.mul_sum, ← Finset.sum_mul]
+      dsimp [S]
+      ring
+
+/-- The quantitative frequency-pair estimate used by the norm comparison. -/
+theorem reciprocal_lcm_sum_le_log_cube (N : ℕ) :
+    (∑ a ∈ Finset.Icc 1 N, ∑ b ∈ Finset.Icc 1 N, ((a.lcm b : ℕ) : ℝ)⁻¹) ≤
+      (1 + Real.log N) ^ 3 := by
+  have hH : (∑ n ∈ Finset.Icc 1 N, (n : ℝ)⁻¹) ≤ 1 + Real.log N := by
+    simpa only [harmonic_eq_sum_Icc, Rat.cast_sum, Rat.cast_inv, Rat.cast_natCast]
+      using harmonic_le_one_add_log N
+  exact (reciprocal_lcm_sum_le_harmonic_cube N).trans
+    (pow_le_pow_left₀ (Finset.sum_nonneg fun _ _ => by positivity) hH 3)
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LeafFrequencyBudget.lean

@@ -0,0 +1,62 @@
+import Mathlib.Analysis.SpecialFunctions.Log.Basic
+import Mathlib.Analysis.Real.Sqrt
+import Mathlib.Tactic.Linarith
+import Mathlib.Tactic.Ring
+import Mathlib.Tactic.Positivity
+
+namespace OAI
+
+/-! # The remaining leaf-frequency budget in the norm comparison -/
+
+namespace Ostmann
+
+theorem sqrt_cost_sublinear (A B ε : ℝ) (_hA : 0 ≤ A) (hε : 0 < ε) :
+    ∃ M : ℝ, ∀ m : ℝ, M ≤ m → A * Real.sqrt m + B ≤ ε * m := by
+  refine ⟨max ((2 * A / ε) ^ 2) (2 * max B 0 / ε), fun m hm => ?_⟩
+  have hmA : (2 * A / ε) ^ 2 ≤ m := (le_max_left _ _).trans hm
+  have hmB : 2 * max B 0 / ε ≤ m := (le_max_right _ _).trans hm
+  have hm0 : 0 ≤ m := (sq_nonneg _).trans hmA
+  have hr := Real.le_sqrt_of_sq_le hmA
+  have hA' : A ≤ ε / 2 * Real.sqrt m := by
+    have h := (div_le_iff₀ hε).mp hr
+    nlinarith
+  have hprod := mul_le_mul_of_nonneg_right hA' (Real.sqrt_nonneg m)
+  have hsq := Real.sq_sqrt hm0
+  have hB' : B ≤ ε / 2 * m := by
+    have h := (div_le_iff₀ hε).mp hmB
+    have hmax := le_max_left B 0
+    nlinarith
+  nlinarith
+
+theorem leaf_frequency_budget (r V : ℕ) (Δ m K : ℝ)
+    (hV : (V : ℝ) ≤ Real.exp (Δ + Real.sqrt m)) :
+    (2 * (V : ℝ)) ^ (2 * r) * Real.exp (-(r : ℝ) * Δ + K) ≤
+      Real.exp ((r : ℝ) * Δ + 2 * r * Real.sqrt m + 2 * r * Real.log 2 + K) := by
+  calc
+    _ ≤ (2 * Real.exp (Δ + Real.sqrt m)) ^ (2 * r) * Real.exp (-(r : ℝ) * Δ + K) :=
+      mul_le_mul_of_nonneg_right
+        (pow_le_pow_left₀ (by positivity) (by linarith) _) (Real.exp_pos _).le
+    _ = _ := by
+      nth_rw 1 [show (2 : ℝ) = Real.exp (Real.log 2) by rw [Real.exp_log (by norm_num)]]
+      rw [← Real.exp_add, ← Real.exp_nat_mul, ← Real.exp_add]
+      congr 1
+      simp only [Nat.cast_mul, Nat.cast_ofNat]
+      ring
+
+/-- After the smooth factor `exp(-r*Delta)`, summing the two histories'
+leaf frequencies costs `exp(r*Delta + o(m))`. -/
+theorem leaf_frequency_budget_sublinear (r : ℕ) (K ε : ℝ) (hε : 0 < ε) :
+    ∃ M : ℝ, ∀ m : ℝ, M ≤ m → ∀ Δ : ℝ, ∀ V : ℕ,
+      (V : ℝ) ≤ Real.exp (Δ + Real.sqrt m) →
+      (2 * (V : ℝ)) ^ (2 * r) * Real.exp (-(r : ℝ) * Δ + K) ≤
+        Real.exp ((r : ℝ) * Δ + ε * m) := by
+  obtain ⟨M, hM⟩ := sqrt_cost_sublinear (2 * r) (2 * r * Real.log 2 + K) ε
+    (by positivity) hε
+  refine ⟨M, fun m hm Δ V hV => (leaf_frequency_budget r V Δ m K hV).trans ?_⟩
+  apply Real.exp_le_exp.mpr
+  have h := hM m hm
+  linarith
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LeafFrequencySupport.lean

@@ -0,0 +1,50 @@
+import Mathlib.Analysis.SpecialFunctions.ExpDeriv
+import OAI.NumberTheory.Ostmann.Construction.HistorySmoothFactor
+
+namespace OAI
+
+/-! # Frequency support forced by the actual leaf Fourier factor -/
+
+namespace Ostmann
+
+open Filter
+
+theorem archimedeanLeaf_frequency_le (X M s cutoff Δ C K : ℝ) (ψhat : ℝ → ℂ)
+    (hX : 0 < X) (hM : 0 < M) (hupper : M ≤ X * Real.exp (Δ + C))
+    (hsupport : ∀ t, ψhat t ≠ 0 → |t| ≤ Real.exp K)
+    (hne : archimedeanLeafFactor X M s cutoff ψhat ≠ 0) :
+    |s| ≤ Real.exp (Δ + C + K) := by
+  have hψ : ψhat (-s * X / M) ≠ 0 := by
+    intro hz
+    apply hne
+    simp only [archimedeanLeafFactor, hz, mul_zero]
+  have harg := hsupport _ hψ
+  rw [abs_div, abs_mul, abs_neg, abs_of_pos hX, abs_of_pos hM] at harg
+  have harg' := (div_le_iff₀ hM).mp harg
+  apply (mul_le_mul_iff_left₀ hX).mp
+  calc
+    |s| * X ≤ Real.exp K * M := harg'
+    _ ≤ Real.exp K * (X * Real.exp (Δ + C)) :=
+      mul_le_mul_of_nonneg_left hupper (Real.exp_pos _).le
+    _ = Real.exp (Δ + C + K) * X := by
+      simp only [Real.exp_add]
+      ring
+
+/-- The square-root margin in E_0 eventually covers the fixed Fourier
+support radius and all bounded errors in the leaf modulus. -/
+theorem archimedeanLeaf_frequency_window (C K : ℝ) :
+    ∀ᶠ m : ℝ in atTop, ∀ X M s cutoff Δ : ℝ, ∀ ψhat : ℝ → ℂ,
+      0 < X → 0 < M → M ≤ X * Real.exp (Δ + C) →
+      (∀ t, ψhat t ≠ 0 → |t| ≤ Real.exp K) →
+      archimedeanLeafFactor X M s cutoff ψhat ≠ 0 →
+      |s| ≤ Real.exp (Δ + Real.sqrt m) := by
+  filter_upwards [eventually_ge_atTop ((C + K) ^ 2)] with m hm
+  intro X M s cutoff Δ ψhat hX hM hupper hsupport hne
+  have hsqrt : C + K ≤ Real.sqrt m := Real.le_sqrt_of_sq_le hm
+  apply (archimedeanLeaf_frequency_le X M s cutoff Δ C K ψhat hX hM hupper hsupport hne).trans
+  apply Real.exp_le_exp.mpr
+  linarith
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LeafModulusRanges.lean

@@ -0,0 +1,53 @@
+import OAI.NumberTheory.Ostmann.Construction.HistorySmoothBound
+
+namespace OAI
+
+/-! # The leaf modulus from the giant, protected and compensation ranges -/
+
+namespace Ostmann
+
+/-- `P`, `U`, and `D` are the products of protected, compensation, and
+outside spectator slots. The center identity is equation (45). -/
+theorem leaf_modulus_lower_from_ranges
+    (X x₁ x₂ P U D G tD J W Δ cG cP cU cD : ℝ)
+    (hX : 0 < X) (hx₁ : 0 < x₁) (hx₂ : 0 < x₂)
+    (hP : 0 < P) (hU : 0 < U) (hD : 0 < D)
+    (hcenter : 2 * G + 2 * tD + J + W = Real.log X + Δ)
+    (hg₁ : G - cG ≤ Real.log x₁) (hg₂ : G - cG ≤ Real.log x₂)
+    (hp : J - cP ≤ Real.log P) (hu : W - cU ≤ Real.log U)
+    (hd : 2 * tD - cD ≤ Real.log D) :
+    X * Real.exp (Δ - (2 * cG + cP + cU + cD)) ≤ x₁ * x₂ * P * U * D := by
+  have hM : 0 < x₁ * x₂ * P * U * D := by positivity
+  have hlog : Real.log (x₁ * x₂ * P * U * D) =
+      Real.log x₁ + Real.log x₂ + Real.log P + Real.log U + Real.log D := by
+    rw [Real.log_mul (by positivity) (ne_of_gt hD),
+      Real.log_mul (by positivity) (ne_of_gt hU),
+      Real.log_mul (by positivity) (ne_of_gt hP),
+      Real.log_mul (ne_of_gt hx₁) (ne_of_gt hx₂)]
+  have hlow : Real.log X + (Δ - (2 * cG + cP + cU + cD)) ≤
+      Real.log (x₁ * x₂ * P * U * D) := by rw [hlog]; linarith
+  calc
+    _ = Real.exp (Real.log X + (Δ - (2 * cG + cP + cU + cD))) := by
+      rw [Real.exp_add, Real.exp_log hX]
+    _ ≤ Real.exp (Real.log (x₁ * x₂ * P * U * D)) := Real.exp_le_exp.mpr hlow
+    _ = _ := Real.exp_log hM
+
+/-- The corresponding size of the square-root prefactor in a leaf of
+equation (50); the error in the exponent is independent of frequency. -/
+theorem leaf_sqrt_ratio_from_ranges
+    (X x₁ x₂ P U D G tD J W Δ cG cP cU cD : ℝ)
+    (hX : 0 < X) (hx₁ : 0 < x₁) (hx₂ : 0 < x₂)
+    (hP : 0 < P) (hU : 0 < U) (hD : 0 < D)
+    (hcenter : 2 * G + 2 * tD + J + W = Real.log X + Δ)
+    (hg₁ : G - cG ≤ Real.log x₁) (hg₂ : G - cG ≤ Real.log x₂)
+    (hp : J - cP ≤ Real.log P) (hu : W - cU ≤ Real.log U)
+    (hd : 2 * tD - cD ≤ Real.log D) :
+    Real.sqrt (X / (x₁ * x₂ * P * U * D)) ≤
+      Real.exp (((2 * cG + cP + cU + cD) - Δ) / 2) :=
+  sqrt_ratio_le_exp X _ Δ _ (by positivity)
+    (leaf_modulus_lower_from_ranges X x₁ x₂ P U D G tD J W Δ cG cP cU cD
+      hX hx₁ hx₂ hP hU hD hcenter hg₁ hg₂ hp hu hd)
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LinearReversal.lean

@@ -0,0 +1,72 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+namespace Ostmann.Arithmetic.LinearReversal
+
+variable {K : Type*} [Field K]
+
+def leftStep (a b : K) (hb : b ≠ 0) : (K × K) ≃ₗ[K] (K × K) where
+  toFun z := (a*z.1+b*z.2,z.1)
+  invFun z := (z.2,(z.1-a*z.2)/b)
+  left_inv z := by
+    apply Prod.ext
+    · rfl
+    · dsimp
+      field_simp
+      ring
+  right_inv z := by
+    apply Prod.ext
+    · dsimp
+      field_simp
+      ring
+    · rfl
+  map_add' z w := by ext <;> dsimp; ring
+  map_smul' c z := by ext <;> dsimp; ring
+
+def rightStep (a b : K) (ha : a ≠ 0) : (K × K) ≃ₗ[K] (K × K) where
+  toFun z := (a*z.1+b*z.2,z.2)
+  invFun z := ((z.1-b*z.2)/a,z.2)
+  left_inv z := by
+    apply Prod.ext
+    · dsimp
+      field_simp
+      ring
+    · rfl
+  right_inv z := by
+    apply Prod.ext
+    · dsimp
+      field_simp
+      ring
+    · rfl
+  map_add' z w := by ext <;> dsimp; ring
+  map_smul' c z := by ext <;> dsimp; ring
+
+theorem pivot_linear {v w Cp Cm s u p Xp Xm : K}
+    (hs : s ≠ 0) (hu : u ≠ 0)
+    (h : v*(Xm*Cm)-w*(Xp*Cp)=s*u*p) :
+    p = (-w*Cp/(s*u))*Xp+(v*Cm/(s*u))*Xm := by
+  field_simp
+  linear_combination -h
+
+theorem nonzero_form_comp (e : (K × K) ≃ₗ[K] (K × K)) (a b : K)
+    (h : a ≠ 0 ∨ b ≠ 0) :
+    ¬ ∀ z : K × K, a*(e z).1+b*(e z).2=0 := by
+  intro hz
+  have h₁ := hz (e.symm (1,0))
+  have h₂ := hz (e.symm (0,1))
+  simp only [e.apply_symm_apply,mul_one,mul_zero,add_zero,zero_add] at h₁ h₂
+  exact h.elim (fun ha => ha h₁) (fun hb => hb h₂)
+
+theorem left_row_coefficients (a b c d x y : K) :
+    c*(a*x+b*y)+d*x=(c*a+d)*x+(c*b)*y := by ring
+
+theorem right_row_coefficients (a b c d x y : K) :
+    c*(a*x+b*y)+d*y=(c*a)*x+(c*b+d)*y := by ring
+
+end Ostmann.Arithmetic.LinearReversal
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LogCellPartitionBoundary.lean

@@ -0,0 +1,94 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionPrimes
+import OAI.NumberTheory.Ostmann.Arithmetic.PrimeCellReplacementUniform
+
+namespace OAI
+
+open _root_.Erdos970 _root_.OAI.Erdos970
+
+open Erdos970.Erdos970Dependency.SiegelWalfisz
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open PrimeProgression PrimeCellReplacement Classical
+
+theorem log_eq_left_of_closed_not_assigned (N : ℕ) (lo hi η : ℝ)
+    (j : Fin (gridCount lo hi η)) {p : ℕ}
+    (hp : p ∈ logPrimeSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)))
+    (hpnot : p ∉ assignedPrimeSupport N lo hi η j) :
+    Real.log (p:ℝ) = gridPoint lo hi η j.val := by
+  have hclosed := (mem_logPrimeSupport _ _ _ _).mp hp
+  have hnot : ¬(j.val=0 ∨ gridPoint lo hi η j.val < Real.log (p:ℝ)) := by
+    intro h
+    exact hpnot (Finset.mem_filter.mpr ⟨hp,h⟩)
+  push Not at hnot
+  exact le_antisymm hnot.2 hclosed.2.2.1
+
+theorem closed_assigned_difference_card_le (N : ℕ) (lo hi η : ℝ)
+    (j : Fin (gridCount lo hi η)) :
+    ((logPrimeSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1))) \
+      assignedPrimeSupport N lo hi η j).card ≤ 1 := by
+  apply Finset.card_le_one.mpr
+  intro p hp q hq
+  have hp' := Finset.mem_sdiff.mp hp
+  have hq' := Finset.mem_sdiff.mp hq
+  have hpl := log_eq_left_of_closed_not_assigned N lo hi η j hp'.1 hp'.2
+  have hql := log_eq_left_of_closed_not_assigned N lo hi η j hq'.1 hq'.2
+  have hpp := ((mem_logPrimeSupport _ _ _ _).mp hp'.1).2.1.pos
+  have hqp := ((mem_logPrimeSupport _ _ _ _).mp hq'.1).2.1.pos
+  have he : (p:ℝ)=(q:ℝ) := Real.log_injOn_pos
+    (by change (0:ℝ)<p; exact_mod_cast hpp) (by change (0:ℝ)<q; exact_mod_cast hqp) (hpl.trans hql.symm)
+  exact_mod_cast he
+
+theorem norm_closed_assigned_test_error {E : Type*} [NormedAddCommGroup E]
+    (N : ℕ) (lo hi η : ℝ) (j : Fin (gridCount lo hi η)) (f : ℕ → E)
+    {A : ℝ} (hA : 0 ≤ A)
+    (hf : ∀ p ∈ logPrimeSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)),
+      p ∉ assignedPrimeSupport N lo hi η j → ‖f p‖ ≤ A) :
+    ‖(∑ p ∈ logPrimeSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)), f p) -
+      (∑ p ∈ assignedPrimeSupport N lo hi η j, f p)‖ ≤ A := by
+  have hsub : assignedPrimeSupport N lo hi η j ⊆
+      logPrimeSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)) :=
+    Finset.filter_subset _ _
+  rw [← Finset.sum_sdiff_eq_sub hsub]
+  apply (norm_sum_le _ _).trans
+  calc
+    _ ≤ ∑ _p ∈ (logPrimeSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1))) \
+        assignedPrimeSupport N lo hi η j, A :=
+      Finset.sum_le_sum (fun p hp => hf p (Finset.mem_sdiff.mp hp).1 (Finset.mem_sdiff.mp hp).2)
+    _ = (((logPrimeSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1))) \
+        assignedPrimeSupport N lo hi η j).card:ℝ)*A := by simp
+    _ ≤ A := by
+      have hc : (((logPrimeSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1))) \
+        assignedPrimeSupport N lo hi η j).card:ℝ) ≤ 1 := by
+        exact_mod_cast closed_assigned_difference_card_le N lo hi η j
+      simpa using mul_le_mul_of_nonneg_right hc hA
+
+def assignedResidueMass (N M : ℕ) (a : ZMod M) (lo hi η Z : ℝ)
+    (j : Fin (gridCount lo hi η)) : ℝ :=
+  ∑ p ∈ (assignedPrimeSupport N lo hi η j).filter (fun p : ℕ => (p:ZMod M)=a),
+    (Z*(p:ℝ))⁻¹
+
+theorem residueMass_assigned_error (N M : ℕ) (a : ZMod M) (lo hi η : ℝ)
+    (j : Fin (gridCount lo hi η)) {Z : ℝ} (hZ : 0 < Z) :
+    |residueMass N M a (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)) Z -
+      assignedResidueMass N M a lo hi η Z j| ≤ (Z*Real.exp (gridPoint lo hi η j.val))⁻¹ := by
+  unfold residueMass assignedResidueMass
+  simp only [Finset.sum_filter]
+  change ‖(∑ p ∈ logPrimeSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)),
+      if (p:ZMod M)=a then (Z*(p:ℝ))⁻¹ else 0) -
+    (∑ p ∈ assignedPrimeSupport N lo hi η j, if (p:ZMod M)=a then (Z*(p:ℝ))⁻¹ else 0)‖ ≤ _
+  apply norm_closed_assigned_test_error N lo hi η j _ (by positivity)
+  intro p hp hpnot
+  have hpl := log_eq_left_of_closed_not_assigned N lo hi η j hp hpnot
+  have hpp : (0:ℝ) < p := by exact_mod_cast ((mem_logPrimeSupport _ _ _ _).mp hp).2.1.pos
+  have he : (p:ℝ)=Real.exp (gridPoint lo hi η j.val) := by rw [← hpl,Real.exp_log hpp]
+  split_ifs
+  · rw [he,Real.norm_eq_abs,abs_of_nonneg (by positivity)]
+  · simp
+    positivity
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LogCellPartitionBoxes.lean

@@ -0,0 +1,88 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionGrid
+import OAI.NumberTheory.Ostmann.Arithmetic.PrimeCellIntegralFreezing
+
+namespace OAI
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open MeasureTheory PrimeCellFreezing
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+abbrev GridBoxIndex (lo hi η : ι → ℝ) := ∀ i, Fin (gridCount (lo i) (hi i) (η i))
+
+def boxLower (lo hi η : ι → ℝ) (j : GridBoxIndex lo hi η) (i : ι) : ℝ :=
+  gridPoint (lo i) (hi i) (η i) (j i).val
+
+def boxUpper (lo hi η : ι → ℝ) (j : GridBoxIndex lo hi η) (i : ι) : ℝ :=
+  gridPoint (lo i) (hi i) (η i) ((j i).val+1)
+
+def assignedBox (lo hi η : ι → ℝ) (j : GridBoxIndex lo hi η) : Set (ι → ℝ) :=
+  Set.univ.pi fun i => assignedCell (lo i) (hi i) (η i) (j i)
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem assignedBox_subset_rectangle {lo hi η : ι → ℝ} (h : ∀ i, lo i ≤ hi i)
+    (j : GridBoxIndex lo hi η) : assignedBox lo hi η j ⊆ logRectangle lo hi := by
+  intro t ht i hi'
+  exact assignedCell_subset_interval (h i) (j i) (ht i hi')
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem iUnion_assignedBox {lo hi η : ι → ℝ} (h : ∀ i, lo i ≤ hi i) :
+    (⋃ j : GridBoxIndex lo hi η, assignedBox lo hi η j) = logRectangle lo hi := by
+  ext t
+  constructor
+  · intro ht
+    obtain ⟨j,hj⟩ := Set.mem_iUnion.mp ht
+    exact assignedBox_subset_rectangle h j hj
+  · intro ht
+    have hc : ∀ i, ∃ j : Fin (gridCount (lo i) (hi i) (η i)),
+        t i ∈ assignedCell (lo i) (hi i) (η i) j :=
+      fun i => exists_assignedCell (h i) (ht i (Set.mem_univ i))
+    choose j hj using hc
+    exact Set.mem_iUnion.mpr ⟨j,fun i _ => hj i⟩
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem assignedBox_pairwiseDisjoint {lo hi η : ι → ℝ} (h : ∀ i, lo i ≤ hi i) :
+    Pairwise (fun j k : GridBoxIndex lo hi η => Disjoint (assignedBox lo hi η j) (assignedBox lo hi η k)) := by
+  intro j k hjk
+  obtain ⟨i,hi⟩ := Function.ne_iff.mp hjk
+  apply Set.disjoint_left.mpr
+  intro t htj htk
+  exact Set.disjoint_left.mp (assignedCell_pairwiseDisjoint (h i) hi)
+    (htj i (Set.mem_univ i)) (htk i (Set.mem_univ i))
+
+omit [DecidableEq ι] in
+theorem measurableSet_assignedBox (lo hi η : ι → ℝ) (j : GridBoxIndex lo hi η) :
+    MeasurableSet (assignedBox lo hi η j) :=
+  MeasurableSet.univ_pi fun i => measurableSet_assignedCell (lo i) (hi i) (η i) (j i)
+
+omit [DecidableEq ι] in
+theorem assignedBox_ae_eq_closed (lo hi η : ι → ℝ) (j : GridBoxIndex lo hi η) :
+    assignedBox lo hi η j =ᵐ[volume] logRectangle (boxLower lo hi η j) (boxUpper lo hi η j) := by
+  change (Set.univ.pi fun i => assignedCell (lo i) (hi i) (η i) (j i)) =ᵐ[Measure.pi (fun _ : ι => (volume : Measure ℝ))]
+    (Set.univ.pi fun i => Set.Icc (boxLower lo hi η j i) (boxUpper lo hi η j i))
+  exact Measure.ae_eq_set_pi fun i _ => assignedCell_ae_eq_closed (lo i) (hi i) (η i) (j i)
+
+theorem integral_rectangle_eq_sum_boxes {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    (lo hi η : ι → ℝ) (h : ∀ i, lo i ≤ hi i) (f : (ι → ℝ) → E)
+    (hf : IntegrableOn f (logRectangle lo hi)) :
+    (∫ t in logRectangle lo hi, f t) =
+      ∑ j : GridBoxIndex lo hi η, ∫ t in logRectangle (boxLower lo hi η j) (boxUpper lo hi η j), f t := by
+  rw [← iUnion_assignedBox (η:=η) h]
+  rw [integral_iUnion_fintype (measurableSet_assignedBox lo hi η)
+    (assignedBox_pairwiseDisjoint h) (fun j => hf.mono_set (assignedBox_subset_rectangle h j))]
+  apply Finset.sum_congr rfl
+  intro j hj
+  exact setIntegral_congr_set (assignedBox_ae_eq_closed lo hi η j)
+
+theorem logCellMass_eq_sum_boxes (w lo hi η : ι → ℝ)
+    (h : ∀ i, lo i ≤ hi i) (hlo : ∀ i, 0 < lo i) :
+    logCellMass w lo hi = ∑ j : GridBoxIndex lo hi η,
+      logCellMass w (boxLower lo hi η j) (boxUpper lo hi η j) :=
+  integral_rectangle_eq_sum_boxes lo hi η h (logCellDensity w)
+    (integrableOn_logCellDensity w lo hi hlo)
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LogCellPartitionGrid.lean

@@ -0,0 +1,144 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.PrimeProgression
+
+namespace OAI
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open MeasureTheory
+
+def gridCount (lo hi η : ℝ) : ℕ := ⌈(hi-lo)/η⌉₊+1
+
+def gridStep (lo hi η : ℝ) : ℝ := (hi-lo)/(gridCount lo hi η:ℝ)
+
+def gridPoint (lo hi η : ℝ) (j : ℕ) : ℝ := lo+(j:ℝ)*gridStep lo hi η
+
+def assignedCell (lo hi η : ℝ) (j : Fin (gridCount lo hi η)) : Set ℝ :=
+  if j.val=0 then Set.Icc (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1))
+  else Set.Ioc (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1))
+
+theorem gridCount_pos (lo hi η : ℝ) : 0 < gridCount lo hi η := by unfold gridCount; omega
+
+theorem gridStep_nonneg {lo hi η : ℝ} (h : lo ≤ hi) : 0 ≤ gridStep lo hi η := by
+  unfold gridStep
+  exact div_nonneg (sub_nonneg.mpr h) (Nat.cast_nonneg _)
+
+@[simp] theorem gridPoint_zero (lo hi η : ℝ) : gridPoint lo hi η 0 = lo := by simp [gridPoint]
+
+@[simp] theorem gridPoint_last (lo hi η : ℝ) :
+    gridPoint lo hi η (gridCount lo hi η) = hi := by
+  have hn : (gridCount lo hi η:ℝ) ≠ 0 := by exact_mod_cast (gridCount_pos lo hi η).ne'
+  unfold gridPoint gridStep
+  field_simp
+  ring
+
+theorem gridPoint_mono {lo hi η : ℝ} (h : lo ≤ hi) : Monotone (gridPoint lo hi η) := by
+  intro i j hij
+  unfold gridPoint
+  have hs := gridStep_nonneg (η:=η) h
+  gcongr
+
+theorem gridPoint_mem {lo hi η : ℝ} (h : lo ≤ hi) {j : ℕ} (hj : j ≤ gridCount lo hi η) :
+    gridPoint lo hi η j ∈ Set.Icc lo hi := by
+  have hm := gridPoint_mono (η:=η) h
+  exact ⟨by simpa using hm (Nat.zero_le j),by simpa using hm hj⟩
+
+theorem gridPoint_width (lo hi η : ℝ) (j : ℕ) :
+    gridPoint lo hi η (j+1)-gridPoint lo hi η j = gridStep lo hi η := by
+  unfold gridPoint
+  push_cast
+  ring
+
+theorem gridStep_le {lo hi η : ℝ} (_h : lo ≤ hi) (hη : 0 < η) : gridStep lo hi η ≤ η := by
+  have hn : (0:ℝ) < gridCount lo hi η := by exact_mod_cast gridCount_pos lo hi η
+  have hc := Nat.le_ceil ((hi-lo)/η)
+  have hc' : (hi-lo)/η ≤ (gridCount lo hi η:ℝ) := by
+    unfold gridCount
+    push_cast
+    linarith
+  apply (div_le_iff₀ hn).mpr
+  have hh := (div_le_iff₀ hη).mp hc'
+  nlinarith
+
+theorem gridCount_le_ceiling {lo hi η U : ℝ} (hη : 0 < η) (hU : hi-lo ≤ U) :
+    gridCount lo hi η ≤ ⌈U/η⌉₊+1 := by
+  unfold gridCount
+  exact Nat.add_le_add_right (Nat.ceil_mono (div_le_div_of_nonneg_right hU hη.le)) 1
+
+theorem assignedCell_subset_closed (lo hi η : ℝ) (j : Fin (gridCount lo hi η)) :
+    assignedCell lo hi η j ⊆ Set.Icc (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)) := by
+  unfold assignedCell
+  split_ifs
+  · exact Set.Subset.rfl
+  · exact Set.Ioc_subset_Icc_self
+
+theorem assignedCell_subset_interval {lo hi η : ℝ} (h : lo ≤ hi)
+    (j : Fin (gridCount lo hi η)) : assignedCell lo hi η j ⊆ Set.Icc lo hi := by
+  intro x hx
+  have hc := assignedCell_subset_closed lo hi η j hx
+  have hl := gridPoint_mem (η:=η) h j.isLt.le
+  have hu := gridPoint_mem (η:=η) h (show j.val+1 ≤ gridCount lo hi η by omega)
+  exact ⟨hl.1.trans hc.1,hc.2.trans hu.2⟩
+
+theorem assignedCell_disjoint_of_lt {lo hi η : ℝ} (h : lo ≤ hi)
+    {i j : Fin (gridCount lo hi η)} (hij : i < j) :
+    Disjoint (assignedCell lo hi η i) (assignedCell lo hi η j) := by
+  apply Set.disjoint_left.mpr
+  intro x hxi hxj
+  have hi' := (assignedCell_subset_closed lo hi η i hxi).2
+  have hj0 : j.val ≠ 0 := by
+    have hh : i.val < j.val := hij
+    omega
+  have hjc : x ∈ Set.Ioc (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)) := by
+    simpa only [assignedCell,ite_eq_right hj0] using hxj
+  have hj' := hjc.1
+  have hm := gridPoint_mono (η:=η) h (show i.val+1 ≤ j.val by exact hij)
+  linarith
+
+theorem assignedCell_pairwiseDisjoint {lo hi η : ℝ} (h : lo ≤ hi) :
+    Pairwise (fun i j : Fin (gridCount lo hi η) => Disjoint (assignedCell lo hi η i) (assignedCell lo hi η j)) := by
+  intro i j hne
+  rcases lt_or_gt_of_ne hne with hij | hji
+  · exact assignedCell_disjoint_of_lt h hij
+  · exact (assignedCell_disjoint_of_lt h hji).symm
+
+theorem exists_assignedCell {lo hi η x : ℝ} (h : lo ≤ hi) (hx : x ∈ Set.Icc lo hi) :
+    ∃ j : Fin (gridCount lo hi η), x ∈ assignedCell lo hi η j := by
+  by_cases hx0 : x=lo
+  · refine ⟨⟨0,gridCount_pos lo hi η⟩,?_⟩
+    have hu := gridPoint_mem (η:=η) h (gridCount_pos lo hi η)
+    simp only [assignedCell,ite_true,gridPoint_zero,Set.mem_Icc]
+    exact ⟨by linarith,by simpa only [hx0,Nat.zero_add] using hu.1⟩
+  · have hx' : x ∈ Set.Ioc (gridPoint lo hi η 0) (gridPoint lo hi η (gridCount lo hi η)) := by
+      simp only [gridPoint_zero,gridPoint_last,Set.mem_Ioc]
+      exact ⟨lt_of_le_of_ne hx.1 (Ne.symm hx0),hx.2⟩
+    obtain ⟨j,hj,hxj⟩ := Set.mem_iUnion₂.mp (Ioc_subset_biUnion_Ioc (gridCount lo hi η)
+      (gridPoint lo hi η) hx')
+    refine ⟨⟨j,Finset.mem_range.mp hj⟩,?_⟩
+    unfold assignedCell
+    split_ifs
+    · exact ⟨hxj.1.le,hxj.2⟩
+    · exact hxj
+
+theorem iUnion_assignedCell {lo hi η : ℝ} (h : lo ≤ hi) :
+    (⋃ j : Fin (gridCount lo hi η), assignedCell lo hi η j) = Set.Icc lo hi := by
+  ext x
+  simp only [Set.mem_iUnion]
+  exact ⟨fun ⟨j,hj⟩ => assignedCell_subset_interval h j hj,exists_assignedCell h⟩
+
+theorem measurableSet_assignedCell (lo hi η : ℝ) (j : Fin (gridCount lo hi η)) :
+    MeasurableSet (assignedCell lo hi η j) := by
+  unfold assignedCell
+  split_ifs <;> measurability
+
+theorem assignedCell_ae_eq_closed (lo hi η : ℝ) (j : Fin (gridCount lo hi η)) :
+    assignedCell lo hi η j =ᵐ[volume] Set.Icc (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)) := by
+  unfold assignedCell
+  split_ifs
+  · rfl
+  · exact Ioc_ae_eq_Icc
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LogCellPartitionIntegerBoundary.lean

@@ -0,0 +1,111 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionIntegers
+
+namespace OAI
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open IntegerCell Classical
+
+theorem integer_log_eq_left_of_closed_not_assigned (N : ℕ) (lo hi η : ℝ)
+    (j : Fin (gridCount lo hi η)) {p : ℕ}
+    (hp : p ∈ cellSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)))
+    (hpnot : p ∉ assignedIntegerSupport N lo hi η j) :
+    Real.log (p:ℝ) = gridPoint lo hi η j.val := by
+  have hclosed := (mem_cellSupport _ _ _ _).mp hp
+  have hnot : ¬(j.val=0 ∨ gridPoint lo hi η j.val < Real.log (p:ℝ)) := by
+    intro h
+    exact hpnot (Finset.mem_filter.mpr ⟨hp,h⟩)
+  push Not at hnot
+  exact le_antisymm hnot.2 hclosed.2.2.1
+
+theorem integer_closed_assigned_difference_card_le (N : ℕ) (lo hi η : ℝ)
+    (j : Fin (gridCount lo hi η)) :
+    ((cellSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1))) \
+      assignedIntegerSupport N lo hi η j).card ≤ 1 := by
+  apply Finset.card_le_one.mpr
+  intro p hp q hq
+  have hp' := Finset.mem_sdiff.mp hp
+  have hq' := Finset.mem_sdiff.mp hq
+  have hpl := integer_log_eq_left_of_closed_not_assigned N lo hi η j hp'.1 hp'.2
+  have hql := integer_log_eq_left_of_closed_not_assigned N lo hi η j hq'.1 hq'.2
+  have hpp := ((mem_cellSupport _ _ _ _).mp hp'.1).2.1
+  have hqp := ((mem_cellSupport _ _ _ _).mp hq'.1).2.1
+  have he : (p:ℝ)=(q:ℝ) := Real.log_injOn_pos
+    (by change (0:ℝ)<p; exact_mod_cast hpp) (by change (0:ℝ)<q; exact_mod_cast hqp) (hpl.trans hql.symm)
+  exact_mod_cast he
+
+theorem norm_integer_closed_assigned_test_error {E : Type*} [NormedAddCommGroup E]
+    (N : ℕ) (lo hi η : ℝ) (j : Fin (gridCount lo hi η)) (f : ℕ → E)
+    {A : ℝ} (hA : 0 ≤ A)
+    (hf : ∀ p ∈ cellSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)),
+      p ∉ assignedIntegerSupport N lo hi η j → ‖f p‖ ≤ A) :
+    ‖(∑ p ∈ cellSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)), f p) -
+      (∑ p ∈ assignedIntegerSupport N lo hi η j, f p)‖ ≤ A := by
+  have hsub : assignedIntegerSupport N lo hi η j ⊆
+      cellSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)) :=
+    Finset.filter_subset _ _
+  rw [← Finset.sum_sdiff_eq_sub hsub]
+  apply (norm_sum_le _ _).trans
+  calc
+    _ ≤ ∑ _p ∈ (cellSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1))) \
+        assignedIntegerSupport N lo hi η j, A :=
+      Finset.sum_le_sum (fun p hp => hf p (Finset.mem_sdiff.mp hp).1 (Finset.mem_sdiff.mp hp).2)
+    _ = (((cellSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1))) \
+        assignedIntegerSupport N lo hi η j).card:ℝ)*A := by simp
+    _ ≤ A := by
+      have hc : (((cellSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1))) \
+        assignedIntegerSupport N lo hi η j).card:ℝ) ≤ 1 := by
+        exact_mod_cast integer_closed_assigned_difference_card_le N lo hi η j
+      simpa using mul_le_mul_of_nonneg_right hc hA
+
+def assignedIntegerResidueMass (N M : ℕ) (a : ZMod M) (lo hi η G : ℝ) (φ : ℝ → ℝ)
+    (j : Fin (gridCount lo hi η)) : ℝ :=
+  ∑ n ∈ (assignedIntegerSupport N lo hi η j).filter (fun n : ℕ => (n:ZMod M)=a),
+    Real.exp (-G)*φ (Real.log n-G)
+
+theorem integerResidueMass_assigned_error (N M : ℕ) (a : ZMod M) (lo hi η G : ℝ)
+    (φ : ℝ → ℝ) (j : Fin (gridCount lo hi η)) {B : ℝ} (hB : 0 ≤ B)
+    (hφ : ∀ t ∈ Set.Icc (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)),
+      |φ (t-G)| ≤ B) :
+    |integerResidueMass N M a (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)) G φ -
+      assignedIntegerResidueMass N M a lo hi η G φ j| ≤ Real.exp (-G)*B := by
+  unfold integerResidueMass assignedIntegerResidueMass
+  rw [integerSupport_eq_filter]
+  simp only [Finset.sum_filter]
+  change ‖(∑ n ∈ cellSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)),
+      if (n:ZMod M)=a then Real.exp (-G)*φ (Real.log n-G) else 0) -
+    (∑ n ∈ assignedIntegerSupport N lo hi η j,
+      if (n:ZMod M)=a then Real.exp (-G)*φ (Real.log n-G) else 0)‖ ≤ _
+  apply norm_integer_closed_assigned_test_error N lo hi η j _ (mul_nonneg (Real.exp_pos _).le hB)
+  intro n hn hnnot
+  split_ifs
+  · rw [Real.norm_eq_abs,abs_mul,abs_of_pos (Real.exp_pos _)]
+    exact mul_le_mul_of_nonneg_left (hφ _ ((mem_cellSupport _ _ _ _).mp hn).2.2)
+      (Real.exp_pos _).le
+  · simpa using mul_nonneg (Real.exp_pos (-G)).le hB
+
+theorem assignedIntegerResidueMass_error (N M : ℕ) [NeZero M] (a : ZMod M)
+    (lo hi η G : ℝ) (φ ψ : ℝ → ℝ) (j : Fin (gridCount lo hi η)) (B D : ℝ)
+    (h : lo ≤ hi) (hB : 0 ≤ B)
+    (hN : ⌊Real.exp (gridPoint lo hi η (j.val+1))⌋₊ ≤ N)
+    (hφ : ∀ t, HasDerivAt φ (ψ t) t) (hψ : Continuous ψ)
+    (hφB : ∀ t ∈ Set.Icc (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)), |φ (t-G)| ≤ B)
+    (hψD : ∀ t ∈ Set.Icc (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)), |ψ (t-G)| ≤ D) :
+    |assignedIntegerResidueMass N M a lo hi η G φ j -
+      integerDensityMass M (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)) G φ| ≤
+      Real.exp (-G)*(6*B+2*D*(gridPoint lo hi η (j.val+1)-gridPoint lo hi η j.val)) := by
+  have hb := integerResidueMass_assigned_error N M a lo hi η G φ j hB hφB
+  have he := integerResidueMass_error N M a φ ψ G
+    (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)) B D
+    (gridPoint_mono h (Nat.le_succ _)) hN hφ hψ hφB hψD
+  have ht := abs_sub_le (assignedIntegerResidueMass N M a lo hi η G φ j)
+    (integerResidueMass N M a (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)) G φ)
+    (integerDensityMass M (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)) G φ)
+  rw [abs_sub_comm] at hb
+  nlinarith
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LogCellPartitionIntegers.lean

@@ -0,0 +1,87 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.IntegerCellTests
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionGrid
+
+namespace OAI
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open IntegerCell Classical
+
+theorem mem_cellSupport (N p : ℕ) (lo hi : ℝ) :
+    p ∈ cellSupport N lo hi ↔ p ≤ N ∧ 0 < p ∧ lo ≤ Real.log (p:ℝ) ∧ Real.log (p:ℝ) ≤ hi := by
+  simp only [cellSupport, Finset.mem_filter, Finset.mem_range, Nat.lt_succ_iff]
+
+def assignedIntegerSupport (N : ℕ) (lo hi η : ℝ) (j : Fin (gridCount lo hi η)) : Finset ℕ :=
+  (cellSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1))).filter
+    (fun p => j.val=0 ∨ gridPoint lo hi η j.val < Real.log (p:ℝ))
+
+theorem mem_assignedIntegerSupport (N p : ℕ) (lo hi η : ℝ) (j : Fin (gridCount lo hi η)) :
+    p ∈ assignedIntegerSupport N lo hi η j ↔ p ≤ N ∧ 0 < p ∧ Real.log (p:ℝ) ∈ assignedCell lo hi η j := by
+  classical
+  simp only [assignedIntegerSupport,Finset.mem_filter,mem_cellSupport]
+  unfold assignedCell
+  split_ifs with hj
+  · simp [hj,Set.mem_Icc]
+  · simp [hj,Set.mem_Ioc]
+    constructor
+    · rintro ⟨⟨hpN,hp,hlo,hhi⟩,hlo'⟩
+      exact ⟨hpN,hp,hlo',hhi⟩
+    · rintro ⟨hpN,hp,hlo,hhi⟩
+      exact ⟨⟨hpN,hp,hlo.le,hhi⟩,hlo⟩
+
+theorem assignedIntegerSupport_subset {N : ℕ} {lo hi η : ℝ} (h : lo ≤ hi)
+    (j : Fin (gridCount lo hi η)) : assignedIntegerSupport N lo hi η j ⊆ cellSupport N lo hi := by
+  intro p hp
+  obtain ⟨hpN,hpp,hcell⟩ := (mem_assignedIntegerSupport N p lo hi η j).mp hp
+  have hb := assignedCell_subset_interval h j hcell
+  exact (mem_cellSupport N p lo hi).mpr ⟨hpN,hpp,hb.1,hb.2⟩
+
+theorem assignedIntegerSupport_eq_filter {N : ℕ} {lo hi η : ℝ} (h : lo ≤ hi)
+    (j : Fin (gridCount lo hi η)) :
+    assignedIntegerSupport N lo hi η j = (cellSupport N lo hi).filter
+      (fun p : ℕ => Real.log (p:ℝ) ∈ assignedCell lo hi η j) := by
+  classical
+  ext p
+  simp only [Finset.mem_filter]
+  constructor
+  · intro hp
+    exact ⟨assignedIntegerSupport_subset h j hp,(mem_assignedIntegerSupport N p lo hi η j).mp hp |>.2.2⟩
+  · rintro ⟨hp,hcell⟩
+    have hp' := (mem_cellSupport N p lo hi).mp hp
+    exact (mem_assignedIntegerSupport N p lo hi η j).mpr ⟨hp'.1,hp'.2.1,hcell⟩
+
+theorem exists_unique_assignedInteger {N p : ℕ} {lo hi η : ℝ} (h : lo ≤ hi)
+    (hp : p ∈ cellSupport N lo hi) :
+    ∃! j : Fin (gridCount lo hi η), p ∈ assignedIntegerSupport N lo hi η j := by
+  have hp' := (mem_cellSupport N p lo hi).mp hp
+  obtain ⟨j,hj⟩ := exists_assignedCell (η:=η) h hp'.2.2
+  refine ⟨j,(mem_assignedIntegerSupport N p lo hi η j).mpr ⟨hp'.1,hp'.2.1,hj⟩,?_⟩
+  intro k hk
+  by_contra hkj
+  exact Set.disjoint_left.mp (assignedCell_pairwiseDisjoint h hkj)
+    ((mem_assignedIntegerSupport N p lo hi η k).mp hk).2.2 hj
+
+theorem sum_assignedIntegerSupport {A : Type*} [AddCommMonoid A]
+    (N : ℕ) (lo hi η : ℝ) (h : lo ≤ hi) (f : ℕ → A) :
+    (∑ j : Fin (gridCount lo hi η), ∑ p ∈ assignedIntegerSupport N lo hi η j, f p) =
+      ∑ p ∈ cellSupport N lo hi, f p := by
+  classical
+  simp_rw [assignedIntegerSupport_eq_filter h,Finset.sum_filter]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro p hp
+  have hp' := (mem_cellSupport N p lo hi).mp hp
+  obtain ⟨j,hj⟩ := exists_assignedCell (η:=η) h hp'.2.2
+  rw [Finset.sum_eq_single j]
+  · simp [hj]
+  · intro k hk hkj
+    have hnot : Real.log (p:ℝ) ∉ assignedCell lo hi η k := fun hkp =>
+      Set.disjoint_left.mp (assignedCell_pairwiseDisjoint h hkj) hkp hj
+    simp [hnot]
+  · simp
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LogCellPartitionMesh.lean

@@ -0,0 +1,56 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionBoxes
+import OAI.NumberTheory.Ostmann.Arithmetic.PrimeCellMeshCounts
+
+namespace OAI
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open PrimeCellMeshBudget
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem boxLower_le_boxUpper {lo hi η : ι → ℝ} (h : ∀ i, lo i ≤ hi i)
+    (j : GridBoxIndex lo hi η) (i : ι) : boxLower lo hi η j i ≤ boxUpper lo hi η j i :=
+  gridPoint_mono (h i) (Nat.le_succ _)
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem boxLower_mem_interval {lo hi η : ι → ℝ} (h : ∀ i, lo i ≤ hi i)
+    (j : GridBoxIndex lo hi η) (i : ι) : boxLower lo hi η j i ∈ Set.Icc (lo i) (hi i) :=
+  gridPoint_mem (h i) (j i).isLt.le
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem boxUpper_mem_interval {lo hi η : ι → ℝ} (h : ∀ i, lo i ≤ hi i)
+    (j : GridBoxIndex lo hi η) (i : ι) : boxUpper lo hi η j i ∈ Set.Icc (lo i) (hi i) :=
+  gridPoint_mem (h i) (show (j i).val+1 ≤ gridCount (lo i) (hi i) (η i) by omega)
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem box_width_le {lo hi η : ι → ℝ} (h : ∀ i, lo i ≤ hi i) (hη : ∀ i, 0 < η i)
+    (j : GridBoxIndex lo hi η) (i : ι) : boxUpper lo hi η j i-boxLower lo hi η j i ≤ η i := by
+  rw [boxUpper,boxLower,gridPoint_width]
+  exact gridStep_le (h i) (hη i)
+
+theorem gridCount_le_meshIntervals (r : ScaleBudget.Row) (L lo hi : ℝ)
+    (hlen : hi-lo ≤ Real.exp (r.a₁*L)) :
+    gridCount lo hi (meshWidth r L) ≤ meshIntervals r L := by
+  exact gridCount_le_ceiling (by unfold meshWidth; positivity) hlen
+
+theorem gridBoxIndex_card (lo hi η : ι → ℝ) :
+    Fintype.card (GridBoxIndex lo hi η) = ∏ i, gridCount (lo i) (hi i) (η i) := by
+  rw [Fintype.card_pi]
+  simp
+
+theorem gridBoxIndex_card_le_mesh_power (r : ScaleBudget.Row) (L : ℝ) (lo hi : ι → ℝ)
+    (hlen : ∀ i, hi i-lo i ≤ Real.exp (r.a₁*L)) :
+    Fintype.card (GridBoxIndex lo hi (fun _ => meshWidth r L)) ≤
+      (meshIntervals r L)^(Fintype.card ι) := by
+  rw [gridBoxIndex_card]
+  calc
+    _ ≤ ∏ _i : ι, meshIntervals r L :=
+      Finset.prod_le_prod (fun i hi' => gridCount_le_meshIntervals r L (lo i) (hi i) (hlen i))
+    _ = _ := by simp
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LogCellPartitionMixed.lean

@@ -0,0 +1,98 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionBoxes
+import OAI.NumberTheory.Ostmann.Arithmetic.MixedCellIntegralFreezingMass
+
+namespace OAI
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open MeasureTheory PrimeCellFreezing MixedCellIntegralFreezing
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+abbrev MixedGridIndex (loI hiI ηI : ℝ) (lo hi η : ι → ℝ) :=
+  Fin (gridCount loI hiI ηI) × GridBoxIndex lo hi η
+
+def assignedMixedBox (loI hiI ηI : ℝ) (lo hi η : ι → ℝ)
+    (j : MixedGridIndex loI hiI ηI lo hi η) : Set (ℝ × (ι → ℝ)) :=
+  assignedCell loI hiI ηI j.1 ×ˢ assignedBox lo hi η j.2
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem assignedMixedBox_subset {loI hiI ηI : ℝ} {lo hi η : ι → ℝ}
+    (hI : loI ≤ hiI) (h : ∀ i, lo i ≤ hi i) (j : MixedGridIndex loI hiI ηI lo hi η) :
+    assignedMixedBox loI hiI ηI lo hi η j ⊆ mixedLogRectangle loI hiI lo hi := by
+  intro t ht
+  exact ⟨assignedCell_subset_interval hI j.1 ht.1,assignedBox_subset_rectangle h j.2 ht.2⟩
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem iUnion_assignedMixedBox {loI hiI ηI : ℝ} {lo hi η : ι → ℝ}
+    (hI : loI ≤ hiI) (h : ∀ i, lo i ≤ hi i) :
+    (⋃ j : MixedGridIndex loI hiI ηI lo hi η, assignedMixedBox loI hiI ηI lo hi η j) =
+      mixedLogRectangle loI hiI lo hi := by
+  ext t
+  constructor
+  · rintro ht
+    obtain ⟨j,hj⟩ := Set.mem_iUnion.mp ht
+    exact assignedMixedBox_subset hI h j hj
+  · intro ht
+    obtain ⟨j,hj⟩ := exists_assignedCell (η:=ηI) hI ht.1
+    have hp : t.2 ∈ ⋃ k : GridBoxIndex lo hi η, assignedBox lo hi η k := by
+      rw [iUnion_assignedBox h]
+      exact ht.2
+    obtain ⟨k,hk⟩ := Set.mem_iUnion.mp hp
+    exact Set.mem_iUnion.mpr ⟨(j,k),hj,hk⟩
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem assignedMixedBox_pairwiseDisjoint {loI hiI ηI : ℝ} {lo hi η : ι → ℝ}
+    (hI : loI ≤ hiI) (h : ∀ i, lo i ≤ hi i) :
+    Pairwise (fun j k : MixedGridIndex loI hiI ηI lo hi η =>
+      Disjoint (assignedMixedBox loI hiI ηI lo hi η j) (assignedMixedBox loI hiI ηI lo hi η k)) := by
+  intro j k hjk
+  apply Set.disjoint_left.mpr
+  intro t htj htk
+  by_cases hfirst : j.1=k.1
+  · have hsecond : j.2≠k.2 := fun hh => hjk (Prod.ext hfirst hh)
+    exact Set.disjoint_left.mp (assignedBox_pairwiseDisjoint h hsecond) htj.2 htk.2
+  · exact Set.disjoint_left.mp (assignedCell_pairwiseDisjoint hI hfirst) htj.1 htk.1
+
+omit [DecidableEq ι] in
+theorem assignedMixedBox_ae_eq_closed (loI hiI ηI : ℝ) (lo hi η : ι → ℝ)
+    (j : MixedGridIndex loI hiI ηI lo hi η) :
+    assignedMixedBox loI hiI ηI lo hi η j =ᵐ[volume]
+      mixedLogRectangle (gridPoint loI hiI ηI j.1.val) (gridPoint loI hiI ηI (j.1.val+1))
+        (boxLower lo hi η j.2) (boxUpper lo hi η j.2) := by
+  exact Measure.set_prod_ae_eq (assignedCell_ae_eq_closed loI hiI ηI j.1)
+    (assignedBox_ae_eq_closed lo hi η j.2)
+
+theorem integral_mixedRectangle_eq_sum_boxes {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    (loI hiI ηI : ℝ) (lo hi η : ι → ℝ) (hI : loI ≤ hiI) (h : ∀ i, lo i ≤ hi i)
+    (f : (ℝ × (ι → ℝ)) → E) (hf : IntegrableOn f (mixedLogRectangle loI hiI lo hi)) :
+    (∫ t in mixedLogRectangle loI hiI lo hi, f t) =
+      ∑ j : MixedGridIndex loI hiI ηI lo hi η,
+        ∫ t in mixedLogRectangle (gridPoint loI hiI ηI j.1.val) (gridPoint loI hiI ηI (j.1.val+1))
+          (boxLower lo hi η j.2) (boxUpper lo hi η j.2), f t := by
+  have hm (j : MixedGridIndex loI hiI ηI lo hi η) :
+      MeasurableSet (assignedMixedBox loI hiI ηI lo hi η j) :=
+    (measurableSet_assignedCell loI hiI ηI j.1).prod (measurableSet_assignedBox lo hi η j.2)
+  have hint (j : MixedGridIndex loI hiI ηI lo hi η) :
+      IntegrableOn f (assignedMixedBox loI hiI ηI lo hi η j) :=
+    hf.mono_set (assignedMixedBox_subset hI h j)
+  rw [← iUnion_assignedMixedBox (ηI:=ηI) (η:=η) hI h]
+  rw [integral_iUnion_fintype hm (assignedMixedBox_pairwiseDisjoint hI h) hint]
+  apply Finset.sum_congr rfl
+  intro j hj
+  exact setIntegral_congr_set (assignedMixedBox_ae_eq_closed loI hiI ηI lo hi η j)
+
+theorem mixedLogMass_eq_sum_boxes (M : ℕ) (loI hiI ηI G : ℝ) (φ : ℝ → ℝ)
+    (w lo hi η : ι → ℝ) (hI : loI ≤ hiI) (h : ∀ i, lo i ≤ hi i)
+    (hφ : Continuous φ) (hlo : ∀ i, 0 < lo i) :
+    mixedLogMass M loI hiI G φ w lo hi =
+      ∑ j : MixedGridIndex loI hiI ηI lo hi η,
+        mixedLogMass M (gridPoint loI hiI ηI j.1.val) (gridPoint loI hiI ηI (j.1.val+1)) G φ w
+          (boxLower lo hi η j.2) (boxUpper lo hi η j.2) :=
+  integral_mixedRectangle_eq_sum_boxes loI hiI ηI lo hi η hI h _
+    (integrableOn_mixedLogDensity M loI hiI G φ w lo hi hφ hlo)
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LogCellPartitionMixedMesh.lean

@@ -0,0 +1,32 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionMesh
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionMixed
+
+namespace OAI
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open PrimeCellMeshBudget
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+theorem mixedGridIndex_card (loI hiI ηI : ℝ) (lo hi η : ι → ℝ) :
+    Fintype.card (MixedGridIndex loI hiI ηI lo hi η) =
+      gridCount loI hiI ηI * ∏ i, gridCount (lo i) (hi i) (η i) := by
+  rw [Fintype.card_prod, Fintype.card_fin, gridBoxIndex_card]
+
+theorem mixedGridIndex_card_le_mesh_power (r : ScaleBudget.Row) (L loI hiI : ℝ)
+    (lo hi : ι → ℝ) (hI : hiI-loI ≤ Real.exp (r.a₁*L))
+    (hlen : ∀ i, hi i-lo i ≤ Real.exp (r.a₁*L)) :
+    Fintype.card (MixedGridIndex loI hiI (meshWidth r L) lo hi (fun _ => meshWidth r L)) ≤
+      (meshIntervals r L)^(Fintype.card ι+1) := by
+  rw [Fintype.card_prod, Fintype.card_fin]
+  calc
+    _ ≤ meshIntervals r L * (meshIntervals r L)^(Fintype.card ι) :=
+      Nat.mul_le_mul (gridCount_le_meshIntervals r L loI hiI hI)
+        (gridBoxIndex_card_le_mesh_power r L lo hi hlen)
+    _ = _ := by rw [pow_succ, Nat.mul_comm]
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LogCellPartitionMixedTuples.lean

@@ -0,0 +1,50 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionIntegers
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionMixed
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionTuples
+
+namespace OAI
+
+open _root_.Erdos970 _root_.OAI.Erdos970
+
+open Erdos970.Erdos970Dependency.SiegelWalfisz
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open IntegerCell PrimeCellReplacement
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+theorem sum_mixedTuples_eq_sum_assigned {A : Type*} [AddCommMonoid A]
+    (NI : ℕ) (N : ι → ℕ) (loI hiI ηI : ℝ) (lo hi η : ι → ℝ)
+    (hI : loI ≤ hiI) (h : ∀ i, lo i ≤ hi i) (F : ℕ → (ι → ℕ) → A) :
+    (∑ n ∈ cellSupport NI loI hiI, ∑ p : PrimeCellTuple N lo hi, F n (fun i => (p i).val)) =
+      ∑ j : MixedGridIndex loI hiI ηI lo hi η,
+        ∑ n ∈ assignedIntegerSupport NI loI hiI ηI j.1,
+          ∑ p : AssignedPrimeTuple N lo hi η j.2, F n (fun i => (p i).val) := by
+  classical
+  rw [← sum_assignedIntegerSupport NI loI hiI ηI hI]
+  rw [Fintype.sum_prod_type]
+  apply Finset.sum_congr rfl
+  intro j hj
+  simp_rw [sum_primeTuples_eq_sum_assigned N lo hi η h]
+  exact Finset.sum_comm
+
+theorem sum_mixed_prior_eq_sum_assigned
+    (NI : ℕ) (N : ι → ℕ) (loI hiI ηI G : ℝ) (φ : ℝ → ℝ) (lo hi η Z : ι → ℝ)
+    (hI : loI ≤ hiI) (h : ∀ i, lo i ≤ hi i) (F : ℕ → (ι → ℕ) → ℂ) :
+    (∑ n ∈ cellSupport NI loI hiI, ∑ p : PrimeCellTuple N lo hi,
+      ((Real.exp (-G)*φ (Real.log n-G):ℝ):ℂ) *
+        (∏ i, (((Z i*(p i).val)⁻¹:ℝ):ℂ)) * F n (fun i => (p i).val)) =
+      ∑ j : MixedGridIndex loI hiI ηI lo hi η,
+        ∑ n ∈ assignedIntegerSupport NI loI hiI ηI j.1,
+          ∑ p : AssignedPrimeTuple N lo hi η j.2,
+            ((Real.exp (-G)*φ (Real.log n-G):ℝ):ℂ) *
+              (∏ i, (((Z i*(p i).val)⁻¹:ℝ):ℂ)) * F n (fun i => (p i).val) :=
+  sum_mixedTuples_eq_sum_assigned NI N loI hiI ηI lo hi η hI h
+    (fun n p => ((Real.exp (-G)*φ (Real.log n-G):ℝ):ℂ) *
+      (∏ i, (((Z i*p i)⁻¹:ℝ):ℂ)) * F n p)
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LogCellPartitionPrimes.lean

@@ -0,0 +1,82 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionGrid
+
+namespace OAI
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open PrimeProgression Classical
+
+def assignedPrimeSupport (N : ℕ) (lo hi η : ℝ) (j : Fin (gridCount lo hi η)) : Finset ℕ :=
+  (logPrimeSupport N (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1))).filter
+    (fun p => j.val=0 ∨ gridPoint lo hi η j.val < Real.log (p:ℝ))
+
+theorem mem_assignedPrimeSupport (N p : ℕ) (lo hi η : ℝ) (j : Fin (gridCount lo hi η)) :
+    p ∈ assignedPrimeSupport N lo hi η j ↔ p ≤ N ∧ p.Prime ∧ Real.log (p:ℝ) ∈ assignedCell lo hi η j := by
+  classical
+  simp only [assignedPrimeSupport,Finset.mem_filter,mem_logPrimeSupport]
+  unfold assignedCell
+  split_ifs with hj
+  · simp [hj,Set.mem_Icc]
+  · simp [hj,Set.mem_Ioc]
+    constructor
+    · rintro ⟨⟨hpN,hp,hlo,hhi⟩,hlo'⟩
+      exact ⟨hpN,hp,hlo',hhi⟩
+    · rintro ⟨hpN,hp,hlo,hhi⟩
+      exact ⟨⟨hpN,hp,hlo.le,hhi⟩,hlo⟩
+
+theorem assignedPrimeSupport_subset {N : ℕ} {lo hi η : ℝ} (h : lo ≤ hi)
+    (j : Fin (gridCount lo hi η)) : assignedPrimeSupport N lo hi η j ⊆ logPrimeSupport N lo hi := by
+  intro p hp
+  obtain ⟨hpN,hpp,hcell⟩ := (mem_assignedPrimeSupport N p lo hi η j).mp hp
+  have hb := assignedCell_subset_interval h j hcell
+  exact (mem_logPrimeSupport N p lo hi).mpr ⟨hpN,hpp,hb.1,hb.2⟩
+
+theorem assignedPrimeSupport_eq_filter {N : ℕ} {lo hi η : ℝ} (h : lo ≤ hi)
+    (j : Fin (gridCount lo hi η)) :
+    assignedPrimeSupport N lo hi η j = (logPrimeSupport N lo hi).filter
+      (fun p : ℕ => Real.log (p:ℝ) ∈ assignedCell lo hi η j) := by
+  classical
+  ext p
+  simp only [Finset.mem_filter]
+  constructor
+  · intro hp
+    exact ⟨assignedPrimeSupport_subset h j hp,(mem_assignedPrimeSupport N p lo hi η j).mp hp |>.2.2⟩
+  · rintro ⟨hp,hcell⟩
+    have hp' := (mem_logPrimeSupport N p lo hi).mp hp
+    exact (mem_assignedPrimeSupport N p lo hi η j).mpr ⟨hp'.1,hp'.2.1,hcell⟩
+
+theorem exists_unique_assignedPrime {N p : ℕ} {lo hi η : ℝ} (h : lo ≤ hi)
+    (hp : p ∈ logPrimeSupport N lo hi) :
+    ∃! j : Fin (gridCount lo hi η), p ∈ assignedPrimeSupport N lo hi η j := by
+  have hp' := (mem_logPrimeSupport N p lo hi).mp hp
+  obtain ⟨j,hj⟩ := exists_assignedCell (η:=η) h hp'.2.2
+  refine ⟨j,(mem_assignedPrimeSupport N p lo hi η j).mpr ⟨hp'.1,hp'.2.1,hj⟩,?_⟩
+  intro k hk
+  by_contra hkj
+  exact Set.disjoint_left.mp (assignedCell_pairwiseDisjoint h hkj)
+    ((mem_assignedPrimeSupport N p lo hi η k).mp hk).2.2 hj
+
+theorem sum_assignedPrimeSupport {A : Type*} [AddCommMonoid A]
+    (N : ℕ) (lo hi η : ℝ) (h : lo ≤ hi) (f : ℕ → A) :
+    (∑ j : Fin (gridCount lo hi η), ∑ p ∈ assignedPrimeSupport N lo hi η j, f p) =
+      ∑ p ∈ logPrimeSupport N lo hi, f p := by
+  classical
+  simp_rw [assignedPrimeSupport_eq_filter h,Finset.sum_filter]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro p hp
+  have hp' := (mem_logPrimeSupport N p lo hi).mp hp
+  obtain ⟨j,hj⟩ := exists_assignedCell (η:=η) h hp'.2.2
+  rw [Finset.sum_eq_single j]
+  · simp [hj]
+  · intro k hk hkj
+    have hnot : Real.log (p:ℝ) ∉ assignedCell lo hi η k := fun hkp =>
+      Set.disjoint_left.mp (assignedCell_pairwiseDisjoint h hkj) hkp hj
+    simp [hnot]
+  · simp
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LogCellPartitionReplacement.lean

@@ -0,0 +1,57 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionBoundary
+
+namespace OAI
+
+open _root_.Erdos970 _root_.OAI.Erdos970
+
+open Erdos970.Erdos970Dependency.SiegelWalfisz
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open PrimeProgression PrimeCellReplacement
+
+theorem exists_assigned_residueMass_error_constants :
+    ∃ d K L₀ : ℝ, 0 < d ∧ 0 < K ∧ 1 ≤ L₀ ∧ ∀ lo hi η : ℝ,
+      L₀ ≤ lo → lo ≤ hi → 0 < η → η ≤ 1 → ∀ (N M : ℕ) [NeZero M] (Z : ℝ),
+      ⌊Real.exp hi⌋₊ ≤ N → 0 < Z → (M:ℝ) ≤ Real.exp (d*lo^(1/3:ℝ)) →
+      ∀ j : Fin (gridCount lo hi η), ∀ a : ZMod M, IsUnit a →
+      |assignedResidueMass N M a lo hi η Z j -
+        harmonicIntegral M (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1))/Z| ≤
+        (K/Z)*Real.exp (-d*(gridPoint lo hi η j.val)^(1/3:ℝ)) +
+          (Z*Real.exp (gridPoint lo hi η j.val))⁻¹ := by
+  obtain ⟨d,K,L₀,hd,hK,hL₀,hAP⟩ := exists_residueMass_error_constants
+  refine ⟨d,K,L₀,hd,hK,hL₀,?_⟩
+  intro lo hi η hlo horder hη hη1 N M _ Z hN hZ hmod j a ha
+  have hl := gridPoint_mem (η:=η) horder j.isLt.le
+  have hu := gridPoint_mem (η:=η) horder (show j.val+1≤gridCount lo hi η by omega)
+  have hcell : gridPoint lo hi η j.val ≤ gridPoint lo hi η (j.val+1) :=
+    gridPoint_mono horder (Nat.le_succ _)
+  have hlen : gridPoint lo hi η (j.val+1)-gridPoint lo hi η j.val ≤ 1 := by
+    rw [gridPoint_width]
+    exact (gridStep_le horder hη).trans hη1
+  have hcut : ⌊Real.exp (gridPoint lo hi η (j.val+1))⌋₊ ≤ N :=
+    (Nat.floor_mono (Real.exp_le_exp.mpr hu.2)).trans hN
+  have hmod' : (M:ℝ) ≤ Real.exp (d*(gridPoint lo hi η j.val)^(1/3:ℝ)) := by
+    apply hmod.trans
+    apply Real.exp_le_exp.mpr
+    exact mul_le_mul_of_nonneg_left
+      (Real.rpow_le_rpow (by linarith : 0≤lo) hl.1 (by norm_num)) hd.le
+  have hc := hAP (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1))
+    (hlo.trans hl.1) hcell hlen N M a Z hcut (NeZero.pos M) ha hZ hmod'
+  have hb := residueMass_assigned_error N M a lo hi η j hZ
+  calc
+    _ ≤ |assignedResidueMass N M a lo hi η Z j -
+          residueMass N M a (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)) Z| +
+        |residueMass N M a (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1)) Z -
+          harmonicIntegral M (gridPoint lo hi η j.val) (gridPoint lo hi η (j.val+1))/Z| :=
+      abs_sub_le _ _ _
+    _ ≤ (Z*Real.exp (gridPoint lo hi η j.val))⁻¹ +
+        (K/Z)*Real.exp (-d*(gridPoint lo hi η j.val)^(1/3:ℝ)) :=
+      add_le_add (by simpa only [abs_sub_comm] using hb) hc
+    _ = _ := by ring
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/LogCellPartitionTuples.lean

@@ -0,0 +1,65 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionBoxes
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionPrimes
+import OAI.NumberTheory.Ostmann.Arithmetic.PrimeCellJointReplacementPrior
+
+namespace OAI
+
+open _root_.Erdos970 _root_.OAI.Erdos970
+
+open Erdos970.Erdos970Dependency.SiegelWalfisz
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open PrimeProgression PrimeCellReplacement
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+abbrev AssignedPrimeTuple (N : ι → ℕ) (lo hi η : ι → ℝ) (j : GridBoxIndex lo hi η) :=
+  ∀ i, {p : ℕ // p ∈ assignedPrimeSupport (N i) (lo i) (hi i) (η i) (j i)}
+
+def assignedTupleEquiv (N : ι → ℕ) (lo hi η : ι → ℝ) (h : ∀ i, lo i ≤ hi i) :
+    (Σ j : GridBoxIndex lo hi η, AssignedPrimeTuple N lo hi η j) ≃ PrimeCellTuple N lo hi :=
+  Equiv.ofBijective
+    (fun x i => ⟨(x.2 i).val,assignedPrimeSupport_subset (h i) (x.1 i) (x.2 i).property⟩) (by
+      constructor
+      · rintro ⟨j,p⟩ ⟨k,q⟩ he
+        have hv (i : ι) : (p i).val=(q i).val := congrArg Subtype.val (congrFun he i)
+        have hjk : j=k := by
+          funext i
+          have hu := exists_unique_assignedPrime (η:=η i) (h i)
+            (assignedPrimeSupport_subset (h i) (j i) (p i).property)
+          exact hu.unique (p i).property (by rw [hv i]; exact (q i).property)
+        cases hjk
+        apply congrArg (Sigma.mk j)
+        funext i
+        exact Subtype.ext (hv i)
+      · intro p
+        have hc : ∀ i, ∃ j : Fin (gridCount (lo i) (hi i) (η i)),
+            (p i).val ∈ assignedPrimeSupport (N i) (lo i) (hi i) (η i) j :=
+          fun i => (exists_unique_assignedPrime (η:=η i) (h i) (p i).property).exists
+        choose j hj using hc
+        refine ⟨⟨j,fun i => ⟨(p i).val,hj i⟩⟩,?_⟩
+        funext i
+        rfl)
+
+theorem sum_primeTuples_eq_sum_assigned {A : Type*} [AddCommMonoid A]
+    (N : ι → ℕ) (lo hi η : ι → ℝ) (h : ∀ i, lo i ≤ hi i) (F : (ι → ℕ) → A) :
+    (∑ p : PrimeCellTuple N lo hi, F (fun i => (p i).val)) =
+      ∑ j : GridBoxIndex lo hi η, ∑ p : AssignedPrimeTuple N lo hi η j, F (fun i => (p i).val) := by
+  classical
+  have hh := Fintype.sum_equiv (assignedTupleEquiv N lo hi η h)
+    (fun x => F (fun i => (x.2 i).val)) (fun p => F (fun i => (p i).val)) (fun x => rfl)
+  simpa only [Fintype.sum_sigma] using hh.symm
+
+theorem sum_product_prime_prior_eq_sum_assigned
+    (N : ι → ℕ) (lo hi η Z : ι → ℝ) (h : ∀ i, lo i ≤ hi i) (F : (ι → ℕ) → ℂ) :
+    (∑ p : PrimeCellTuple N lo hi,
+      (∏ i, (((Z i*(p i).val)⁻¹:ℝ):ℂ))*F (fun i => (p i).val)) =
+      ∑ j : GridBoxIndex lo hi η, ∑ p : AssignedPrimeTuple N lo hi η j,
+        (∏ i, (((Z i*(p i).val)⁻¹:ℝ):ℂ))*F (fun i => (p i).val) :=
+  sum_primeTuples_eq_sum_assigned N lo hi η h (fun p => (∏ i, (((Z i*p i)⁻¹:ℝ):ℂ))*F p)
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MatchedHistoryEnergy.lean

@@ -0,0 +1,48 @@
+import OAI.NumberTheory.Ostmann.Construction.MatchedDiagonalEnergy
+import OAI.NumberTheory.Ostmann.Construction.ConstituentUniqueRootEnergy
+
+namespace OAI
+
+/-! # Matched diagonal energy without a frequency-history multiplicity loss -/
+
+namespace Ostmann
+open scoped BigOperators Classical ComplexConjugate
+
+theorem permuted_root_energy_le {A R : Type*} [Fintype A] [Fintype R]
+    (e : Equiv.Perm A) (μ : A → ℝ) (F : R → A → ℂ) (A₀ : ℝ)
+    (hA₀ : 0 ≤ A₀) (hμ : ∀ a, 0 ≤ μ a) (hbound : ∀ a, μ a ≤ A₀) :
+    ‖∑ s, ∑ a, ((μ a * μ (e a) : ℝ) : ℂ) * F s a * conj (F s (e a))‖ ≤
+      A₀ * ∑ s, ∑ a, μ a * ‖F s a‖ ^ 2 := by
+  have hs (s : R) := matched_diagonal_energy e μ μ (F s) (F s) (fun _ => 1) A₀
+    hA₀ hμ hμ (fun _ => by simp) (fun a _ _ => ⟨hbound a, hbound (e a)⟩)
+  simp only [mul_one] at hs
+  calc
+    _ ≤ ∑ s, ‖∑ a, ((μ a * μ (e a) : ℝ) : ℂ) * F s a * conj (F s (e a))‖ := norm_sum_le _ _
+    _ ≤ ∑ s, A₀ / 2 * ((∑ a, μ a * ‖F s a‖ ^ 2) + ∑ a, μ a * ‖F s a‖ ^ 2) :=
+      Finset.sum_le_sum fun s _ => hs s
+    _ = _ := by rw [← Finset.mul_sum, Finset.sum_add_distrib]; ring
+
+/-- Root equality is retained in the diagonal. Uniqueness removes the entire
+frequency-history multiplicity from its square-energy estimate. -/
+theorem permuted_history_energy_le {A D R : Type*}
+    [Fintype A] [Fintype D] [Fintype R]
+    (e : Equiv.Perm A) (μ : A → ℝ) (root : D → R) (F : D → A → ℂ) (A₀ : ℝ)
+    (hA₀ : 0 ≤ A₀) (hμ : ∀ a, 0 ≤ μ a) (hbound : ∀ a, μ a ≤ A₀)
+    (hunique : ∀ a d d', F d a ≠ 0 → F d' a ≠ 0 → root d = root d' → d = d') :
+    ‖∑ d, ∑ d', if root d = root d' then
+      ∑ a, ((μ a * μ (e a) : ℝ) : ℂ) * (F d a * conj (F d' (e a))) else 0‖ ≤
+      A₀ * ∑ d, ∑ a, μ a * ‖F d a‖ ^ 2 := by
+  rw [← rootFibreSum_weighted_pair root root (fun a => μ a * μ (e a)) F
+    (fun d a => F d (e a))]
+  have h := permuted_root_energy_le e μ (fun s a => rootFibreSum root s (fun d => F d a))
+    A₀ hA₀ hμ hbound
+  simp only [mul_assoc] at h
+  apply h.trans_eq
+  congr 1
+  rw [Finset.sum_comm]
+  simp_rw [← Finset.mul_sum, rootFibreSum_energy_of_unique root _ (hunique _), Finset.mul_sum]
+  exact Finset.sum_comm
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MatchedPriorCorrelation.lean

@@ -0,0 +1,78 @@
+import OAI.NumberTheory.Ostmann.Construction.MatchedHarmonicPrior
+import OAI.NumberTheory.Ostmann.Construction.MatchedGraphQuotient
+
+namespace OAI
+
+/-! # Exact counterpart-prior extraction before the external-pivot sum -/
+
+namespace Ostmann
+
+open scoped BigOperators Classical
+
+noncomputable def counterpartRoleUnary {n : ℕ} (Q : Fin n → Finset ℕ)
+    (e : Equiv.Perm (Fin n)) (ν : Fin n → ℕ → ℂ) (i : Fin n) (p : ℕ) : ℂ :=
+  (if p ∈ Q (e.symm i) then 1 else 0) * ν i p
+
+theorem counterpartRoleUnary_norm {n : ℕ} (Q : Fin n → Finset ℕ)
+    (e : Equiv.Perm (Fin n)) (ν : Fin n → ℕ → ℂ)
+    (hν : ∀ i p, ‖ν i p‖ ≤ 1) (i : Fin n) (p : ℕ) :
+    ‖counterpartRoleUnary Q e ν i p‖ ≤ 1 := by
+  unfold counterpartRoleUnary
+  split_ifs
+  · simpa only [one_mul] using hν i p
+  · simp only [zero_mul, norm_zero, zero_le_one]
+
+theorem counterpartRole_finiteEdgeWeight {n : ℕ} (P : Finset ℕ)
+    (Q : Fin n → Finset ℕ) (e : Equiv.Perm (Fin n))
+    (E : Fin n → Fin n → ℕ → ℕ → ℂ) (ν : Fin n → ℕ → ℂ) (x : Fin n → P) :
+    ((∏ i, counterpartRoleFactor P Q e i (x i) : ℝ) : ℂ) *
+        finiteEdgeWeight E ν (fun i => (x i : ℕ)) =
+      finiteEdgeWeight E (counterpartRoleUnary Q e ν) (fun i => (x i : ℕ)) := by
+  simp only [Complex.ofReal_prod, finiteEdgeWeight, ← Finset.prod_mul_distrib]
+  apply Finset.prod_congr rfl
+  intro i _
+  simp only [counterpartRoleFactor, counterpartRoleUnary]
+  split_ifs <;> simp only [Complex.ofReal_one, Complex.ofReal_zero, one_mul, zero_mul]
+
+/-- This equality factors out the harmonic normalizer and the reciprocal
+product scale before any external integer is summed. -/
+theorem matched_harmonic_correlation_eq {n : ℕ} (P : Finset ℕ)
+    (Q : Fin n → Finset ℕ) (e : Equiv.Perm (Fin n))
+    (μ : (Fin n → P) → ℝ) (G : (Fin n → P) → ℂ)
+    (X : ℝ) (hX : X ≠ 0) :
+    (∑ x, (μ x : ℂ) *
+      (productPrior (fun i => primeSubsetPrior P (Q i)) (fun i => x (e i)) : ℂ) * G x) =
+      (((∏ i, (∑ p ∈ Q i, (p : ℝ)⁻¹)⁻¹) * X⁻¹ : ℝ) : ℂ) *
+        ∑ x, (μ x : ℂ) * ((X / (∏ i, (x i : ℝ)) : ℝ) : ℂ) *
+          ((∏ i, counterpartRoleFactor P Q e i (x i) : ℝ) : ℂ) * G x := by
+  rw [Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro x _
+  rw [matched_harmonic_prior]
+  have he (C H R : ℝ) : C * H⁻¹ * R = (C * X⁻¹) * (X / H) * R := by
+    rw [div_eq_mul_inv]
+    calc
+      _ = C * (X⁻¹ * X) * H⁻¹ * R := by rw [inv_mul_cancel₀ hX]; ring
+      _ = _ := by ring
+  rw [he]
+  push_cast
+  ring
+
+/-- The actual two-prior correlation has the already-extracted small factor.
+Its hypothesis is the normalized ratio bound supplied by FullPrimeRatioPair. -/
+theorem matched_harmonic_correlation_bound {n : ℕ} (P : Finset ℕ)
+    (Q : Fin n → Finset ℕ) (e : Equiv.Perm (Fin n))
+    (μ : (Fin n → P) → ℝ) (G : (Fin n → P) → ℂ)
+    (X δ : ℝ) (hX : 0 < X)
+    (hbound : ‖∑ x, (μ x : ℂ) * ((X / (∏ i, (x i : ℝ)) : ℝ) : ℂ) *
+      ((∏ i, counterpartRoleFactor P Q e i (x i) : ℝ) : ℂ) * G x‖ ≤ δ) :
+    ‖∑ x, (μ x : ℂ) *
+      (productPrior (fun i => primeSubsetPrior P (Q i)) (fun i => x (e i)) : ℂ) * G x‖ ≤
+      (∏ i, (∑ p ∈ Q i, (p : ℝ)⁻¹)⁻¹) * X⁻¹ * δ := by
+  rw [matched_harmonic_correlation_eq P Q e μ G X hX.ne', norm_mul,
+    Complex.norm_real, Real.norm_of_nonneg (by positivity)]
+  exact mul_le_mul_of_nonneg_left hbound (by positivity)
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MixedCellGridReplacement.lean

@@ -0,0 +1,142 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MixedCellGridReplacementAssigned
+import OAI.NumberTheory.Ostmann.Arithmetic.MixedCellGridReplacementSmooth
+
+namespace OAI
+
+open _root_.Erdos970 _root_.OAI.Erdos970
+
+open Erdos970.Erdos970Dependency.SiegelWalfisz
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open scoped BigOperators
+open PrimeProgression PrimeCellReplacement PrimeCellFreezing MixedCellIntegralFreezing Characters.RationalHistory
+
+theorem exists_mixed_grid_smooth_replacement_constants :
+    ∃ d K L₀ : ℝ, 0 < d ∧ 0 < K ∧ 1 ≤ L₀ ∧
+      ∀ (ι : Type*) [Fintype ι] [DecidableEq ι]
+        (NI : ℕ) (N : ι → ℕ) (M : ℕ) [NeZero M]
+        (loI hiI ηI G Bφ Dφ : ℝ) (φ ψ : ℝ → ℝ) (lo hi η Z : ι → ℝ),
+        loI ≤ hiI → 0 < ηI → ⌊Real.exp hiI⌋₊ ≤ NI →
+        (∀ t, HasDerivAt φ (ψ t) t) → Continuous ψ →
+        (∀ t ∈ Set.Icc loI hiI, 0 ≤ φ (t-G)) →
+        (∀ t ∈ Set.Icc loI hiI, |φ (t-G)| ≤ Bφ) →
+        (∀ t ∈ Set.Icc loI hiI, |ψ (t-G)| ≤ Dφ) →
+        (∀ i, L₀ ≤ lo i ∧ lo i ≤ hi i ∧ 0 < η i ∧ η i ≤ 1 ∧
+          ⌊Real.exp (hi i)⌋₊ ≤ N i ∧ 0 < Z i ∧
+          (M:ℝ) ≤ Real.exp (d*(lo i)^(1/3:ℝ))) →
+        ∀ ε B error : ℝ, 0 ≤ ε → 1 ≤ B → 0 ≤ error →
+          (∀ (j : MixedGridIndex loI hiI ηI lo hi η) i,
+            (K/Z i)*Real.exp (-d*(boxLower lo hi η j.2 i)^(1/3:ℝ))+
+              (Z i*Real.exp (boxLower lo hi η j.2 i))⁻¹ ≤ ε) →
+          (∀ (j : MixedGridIndex loI hiI ηI lo hi η) i,
+            |harmonicIntegral M (boxLower lo hi η j.2 i) (boxUpper lo hi η j.2 i)/Z i|+
+              ((K/Z i)*Real.exp (-d*(boxLower lo hi η j.2 i)^(1/3:ℝ))+
+                (Z i*Real.exp (boxLower lo hi η j.2 i))⁻¹) ≤ B) →
+          (∀ j : MixedGridIndex loI hiI ηI lo hi η,
+            mixedGridError (ι:=ι) M loI hiI ηI G Bφ Dφ φ ε B j.1 ≤ error) →
+        ∀ (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ) (f : (Option ι → ℝ) → ℂ) (D mesh A : ℝ),
+          0 ≤ D → 0 ≤ mesh → ηI ≤ mesh → (∀ i, η i ≤ mesh) →
+          (∀ z∈logRectangle (Option.elim' loI lo) (Option.elim' hiI hi),
+            DifferentiableAt ℝ (fun y => f (fun i => Real.exp (y i))) z) →
+          (∀ z∈logRectangle (Option.elim' loI lo) (Option.elim' hiI hi),∀ i,
+            ‖deriv (fun t => f (Expr.logCurve (fun i => Real.exp (z i)) i t)) 0‖ ≤ D) →
+          (∀ z∈logRectangle (Option.elim' loI lo) (Option.elim' hiI hi),
+            ‖f (fun i => Real.exp (z i))‖ ≤ A) →
+          ‖mixedSmoothTestSum NI N M loI hiI G φ lo hi Z F f-
+            mixedPrincipalIntegral M loI hiI G φ lo hi Z f*
+              ∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,F r u‖ ≤
+            (2*(((Fintype.card ι:ℝ)+1)*D*mesh)*mixedPrincipalMass M loI hiI G φ lo hi Z+
+              (((Fintype.card ι:ℝ)+1)*D*mesh+A)*
+                (Fintype.card (MixedGridIndex loI hiI ηI lo hi η)*error))*
+              ∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,‖F r u‖ := by
+  obtain ⟨d,K,L₀,hd,hK,hL₀,hAP⟩ := exists_assigned_mixedCell_replacement_constants
+  refine ⟨d,K,L₀,hd,hK,hL₀,?_⟩
+  intro ι _ _ NI N M _ loI hiI ηI G Bφ Dφ φ ψ lo hi η Z
+    hI hηI hNI hφ hψ hφ0 hBφ hDφ hcell ε B error hε hB herror hE hbound herrorBound
+    F f D mesh A hD hm hmeshI hmesh hf hderiv hA
+  classical
+  have hφc : Continuous φ := continuous_iff_continuousAt.mpr fun t => (hφ t).continuousAt
+  have horder : ∀ i, lo i ≤ hi i := fun i => (hcell i).2.1
+  have hlo : ∀ i, 0 < lo i := fun i => lt_of_lt_of_le (by linarith) (hcell i).1
+  have hη : ∀ i, 0 < η i := fun i => (hcell i).2.2.1
+  have hZ : ∀ i, 0 < Z i := fun i => (hcell i).2.2.2.2.2.1
+  let v : ℝ := ((Fintype.card ι:ℝ)+1)*D*mesh
+  let T : ℝ := ∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,‖F r u‖
+  let mass : MixedGridIndex loI hiI ηI lo hi η → ℝ := fun j =>
+    mixedPrincipalMass M (gridPoint loI hiI ηI j.1.val) (gridPoint loI hiI ηI (j.1.val+1))
+      G φ (boxLower lo hi η j.2) (boxUpper lo hi η j.2) Z
+  have hT0 : 0 ≤ T := Finset.sum_nonneg fun _ _ => Finset.sum_nonneg fun _ _ => norm_nonneg _
+  have hlocal (j : MixedGridIndex loI hiI ηI lo hi η) :
+      ‖mixedSmoothAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F f-
+        mixedPrincipalIntegral M (gridPoint loI hiI ηI j.1.val) (gridPoint loI hiI ηI (j.1.val+1))
+          G φ (boxLower lo hi η j.2) (boxUpper lo hi η j.2) Z f*
+          ∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,F r u‖ ≤ (v*(2*mass j+error)+A*error)*T := by
+    have hl := gridPoint_mem (η:=ηI) hI j.1.isLt.le
+    have hu := gridPoint_mem (η:=ηI) hI (show j.1.val+1 ≤ gridCount loI hiI ηI by omega)
+    have hsubI : Set.Icc (gridPoint loI hiI ηI j.1.val)
+        (gridPoint loI hiI ηI (j.1.val+1)) ⊆ Set.Icc loI hiI :=
+      fun _ ht => ⟨hl.1.trans ht.1,ht.2.trans hu.2⟩
+    have hsub : logRectangle
+        (Option.elim' (gridPoint loI hiI ηI j.1.val) (boxLower lo hi η j.2))
+        (Option.elim' (gridPoint loI hiI ηI (j.1.val+1)) (boxUpper lo hi η j.2)) ⊆
+        logRectangle (Option.elim' loI lo) (Option.elim' hiI hi) := by
+      intro z hz i hi'
+      cases i with
+      | none => exact hsubI (hz none (Set.mem_univ _))
+      | some i =>
+        exact ⟨(boxLower_ge lo hi η horder j.2 i).trans (hz (some i) (Set.mem_univ _)).1,
+          (hz (some i) (Set.mem_univ _)).2.trans (boxUpper_le lo hi η horder j.2 i)⟩
+    let base : ℝ × (ι → ℝ) := (gridPoint loI hiI ηI j.1.val,boxLower lo hi η j.2)
+    have hbase : base∈mixedLogRectangle
+        (gridPoint loI hiI ηI j.1.val) (gridPoint loI hiI ηI (j.1.val+1))
+        (boxLower lo hi η j.2) (boxUpper lo hi η j.2) :=
+      ⟨⟨le_rfl,gridPoint_mono hI (Nat.le_succ _)⟩,
+        fun i _ => ⟨le_rfl,box_order lo hi η horder j.2 i⟩⟩
+    have hb := mixed_assigned_smooth_replacement_of_errors (error:=error)
+      NI N loI hiI ηI G φ lo hi η Z j hφc (fun t ht => hφ0 t (hsubI ht)) hZ
+      (fun i => (hlo i).trans_le (boxLower_ge lo hi η horder j.2 i)) F f hD hm
+      ((gridPoint_width loI hiI ηI j.1.val).trans_le ((gridStep_le hI hηI).trans hmeshI))
+      (fun i => (box_width_le lo hi η horder hη j.2 i).trans (hmesh i))
+      (fun z hz => hf z (hsub hz)) (fun z hz => hderiv z (hsub hz)) hbase
+    have he := hAP ι NI N M loI hiI ηI G Bφ Dφ φ ψ lo hi η Z
+      hI hNI hφ hψ hBφ hDφ hcell j ε B hε hB (hE j) (hbound j) F
+    have heAbs := hAP ι NI N M loI hiI ηI G Bφ Dφ φ ψ lo hi η Z
+      hI hNI hφ hψ hBφ hDφ hcell j ε B hε hB (hE j) (hbound j) (fun r u => (‖F r u‖:ℂ))
+    have he' := he.trans (mul_le_mul_of_nonneg_right (herrorBound j) hT0)
+    have heAbs' : ‖mixedAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j (fun r u => (‖F r u‖:ℂ))-
+        (mass j:ℂ)*∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,(‖F r u‖:ℂ)‖ ≤ error*T := by
+      simp only [Complex.norm_real,Real.norm_eq_abs,abs_norm] at heAbs
+      exact heAbs.trans (mul_le_mul_of_nonneg_right (herrorBound j) hT0)
+    have hAbase : ‖f (optionCoordinates (mixedExp base))‖ ≤ A := by
+      simpa only [optionCoordinates_mixedExp] using
+        hA _ (hsub ((optionCoordinates_mem_logRectangle _ _ _ _).mpr hbase))
+    exact (hb he' heAbs').trans (mul_le_mul_of_nonneg_right
+      (add_le_add le_rfl (mul_le_mul_of_nonneg_right hAbase herror)) hT0)
+  have hsum : (∑ j : MixedGridIndex loI hiI ηI lo hi η,(v*(2*mass j+error)+A*error)) =
+      2*v*mixedPrincipalMass M loI hiI G φ lo hi Z+
+        (v+A)*(Fintype.card (MixedGridIndex loI hiI ηI lo hi η)*error) := by
+    simp_rw [mul_add]
+    rw [Finset.sum_add_distrib,Finset.sum_add_distrib]
+    simp only [← mul_assoc,← Finset.mul_sum,Finset.sum_const,Finset.card_univ,nsmul_eq_mul]
+    rw [show (∑ j : MixedGridIndex loI hiI ηI lo hi η,mass j)=mixedPrincipalMass M loI hiI G φ lo hi Z from
+      (mixedPrincipalMass_eq_sum_boxes M loI hiI ηI G φ lo hi η Z hI horder hφc hlo).symm]
+    ring
+  rw [mixedSmoothTestSum_eq_sum_assigned NI N loI hiI ηI G φ lo hi η Z hI horder F f,
+    mixedPrincipalIntegral_eq_sum_boxes M loI hiI ηI G φ lo hi η Z hI horder hφc hlo f
+      (fun z hz => (hf z hz).continuousAt.continuousWithinAt),Finset.sum_mul,← Finset.sum_sub_distrib]
+  calc
+    _ ≤ ∑ j : MixedGridIndex loI hiI ηI lo hi η,
+        ‖mixedSmoothAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F f-
+          mixedPrincipalIntegral M (gridPoint loI hiI ηI j.1.val) (gridPoint loI hiI ηI (j.1.val+1))
+            G φ (boxLower lo hi η j.2) (boxUpper lo hi η j.2) Z f*
+            ∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,F r u‖ := norm_sum_le _ _
+    _ ≤ ∑ j : MixedGridIndex loI hiI ηI lo hi η,(v*(2*mass j+error)+A*error)*T :=
+      Finset.sum_le_sum fun j _ => hlocal j
+    _ = _ := by rw [← Finset.sum_mul,hsum]
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MixedCellGridReplacementAssigned.lean

@@ -0,0 +1,107 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MixedCellGridReplacementBasic
+
+namespace OAI
+
+open _root_.Erdos970 _root_.OAI.Erdos970
+
+open Erdos970.Erdos970Dependency.SiegelWalfisz
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open scoped BigOperators
+open PrimeProgression PrimeCellReplacement PrimeCellFreezing MixedCellJointReplacement
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+def mixedGridIntegerError (loI hiI ηI G Bφ Dφ : ℝ)
+    (j : Fin (gridCount loI hiI ηI)) : ℝ :=
+  Real.exp (-G)*(6*Bφ+2*Dφ*(gridPoint loI hiI ηI (j.val+1)-gridPoint loI hiI ηI j.val))
+
+def mixedGridError (M : ℕ) (loI hiI ηI G Bφ Dφ : ℝ) (φ : ℝ → ℝ)
+    (ε B : ℝ) (j : Fin (gridCount loI hiI ηI)) : ℝ :=
+  (mixedGridIntegerError loI hiI ηI G Bφ Dφ j +
+    (|IntegerCell.integerDensityMass M (gridPoint loI hiI ηI j.val)
+        (gridPoint loI hiI ηI (j.val+1)) G φ|+
+      mixedGridIntegerError loI hiI ηI G Bφ Dφ j)*(Fintype.card ι:ℝ)*ε)*B^Fintype.card ι
+
+theorem exists_assigned_mixedCell_replacement_constants :
+    ∃ d K L₀ : ℝ, 0 < d ∧ 0 < K ∧ 1 ≤ L₀ ∧
+      ∀ (ι : Type*) [Fintype ι] [DecidableEq ι]
+        (NI : ℕ) (N : ι → ℕ) (M : ℕ) [NeZero M]
+        (loI hiI ηI G Bφ Dφ : ℝ) (φ ψ : ℝ → ℝ) (lo hi η Z : ι → ℝ),
+        loI ≤ hiI → ⌊Real.exp hiI⌋₊ ≤ NI →
+        (∀ t, HasDerivAt φ (ψ t) t) → Continuous ψ →
+        (∀ t ∈ Set.Icc loI hiI, |φ (t-G)| ≤ Bφ) →
+        (∀ t ∈ Set.Icc loI hiI, |ψ (t-G)| ≤ Dφ) →
+        (∀ i, L₀ ≤ lo i ∧ lo i ≤ hi i ∧ 0 < η i ∧ η i ≤ 1 ∧
+          ⌊Real.exp (hi i)⌋₊ ≤ N i ∧ 0 < Z i ∧
+          (M:ℝ) ≤ Real.exp (d*(lo i)^(1/3:ℝ))) →
+        ∀ (j : MixedGridIndex loI hiI ηI lo hi η) (ε B : ℝ), 0 ≤ ε → 1 ≤ B →
+          (∀ i, (K/Z i)*Real.exp (-d*(boxLower lo hi η j.2 i)^(1/3:ℝ))+
+            (Z i*Real.exp (boxLower lo hi η j.2 i))⁻¹ ≤ ε) →
+          (∀ i, |harmonicIntegral M (boxLower lo hi η j.2 i) (boxUpper lo hi η j.2 i)/Z i|+
+            ((K/Z i)*Real.exp (-d*(boxLower lo hi η j.2 i)^(1/3:ℝ))+
+              (Z i*Real.exp (boxLower lo hi η j.2 i))⁻¹) ≤ B) →
+        ∀ F : ZMod M → (ι → (ZMod M)ˣ) → ℂ,
+          ‖mixedAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F-
+            (mixedPrincipalMass M (gridPoint loI hiI ηI j.1.val)
+              (gridPoint loI hiI ηI (j.1.val+1)) G φ
+              (boxLower lo hi η j.2) (boxUpper lo hi η j.2) Z:ℂ)*
+              (∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ, F r u)‖ ≤
+          mixedGridError (ι:=ι) M loI hiI ηI G Bφ Dφ φ ε B j.1*
+            (∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ, ‖F r u‖) := by
+  obtain ⟨d,K,L₀,hd,hK,hL₀,hprime⟩ := exists_assigned_joint_primeCell_replacement_constants
+  refine ⟨d,K,L₀,hd,hK,hL₀,?_⟩
+  intro ι _ _ NI N M _ loI hiI ηI G Bφ Dφ φ ψ lo hi η Z
+    hI hNI hφ hψ hBφ hDφ hcell j ε B hε hB hE hbound F
+  classical
+  have hBφ0 : 0 ≤ Bφ := (abs_nonneg _).trans (hBφ loI ⟨le_rfl,hI⟩)
+  have hDφ0 : 0 ≤ Dφ := (abs_nonneg _).trans (hDφ loI ⟨le_rfl,hI⟩)
+  have hl := gridPoint_mem (η:=ηI) hI j.1.isLt.le
+  have hu := gridPoint_mem (η:=ηI) hI (show j.1.val+1 ≤ gridCount loI hiI ηI by omega)
+  have horderI := gridPoint_mono (η:=ηI) hI (Nat.le_succ j.1.val)
+  have hsub : Set.Icc (gridPoint loI hiI ηI j.1.val)
+      (gridPoint loI hiI ηI (j.1.val+1)) ⊆ Set.Icc loI hiI :=
+    fun _ ht => ⟨hl.1.trans ht.1,ht.2.trans hu.2⟩
+  have hEI : 0 ≤ mixedGridIntegerError loI hiI ηI G Bφ Dφ j.1 := by
+    unfold mixedGridIntegerError
+    exact mul_nonneg (Real.exp_pos _).le
+      (add_nonneg (mul_nonneg (by norm_num) hBφ0)
+        (mul_nonneg (mul_nonneg (by norm_num) hDφ0) (sub_nonneg.mpr horderI)))
+  have hInteger (r : ZMod M) := assignedIntegerResidueMass_error NI M r loI hiI ηI G φ ψ j.1 Bφ Dφ
+    hI hBφ0 ((Nat.floor_mono (Real.exp_le_exp.mpr hu.2)).trans hNI) hφ hψ
+    (fun t ht => hBφ t (hsub ht)) (fun t ht => hDφ t (hsub ht))
+  have hProd : ‖∏ i, ((harmonicIntegral M (boxLower lo hi η j.2 i)
+      (boxUpper lo hi η j.2 i)/Z i:ℝ):ℂ)‖ ≤ B^Fintype.card ι := by
+    rw [norm_prod]
+    calc
+      _ ≤ ∏ _i : ι, B := by
+        apply Finset.prod_le_prod₀ (fun i _ => norm_nonneg _)
+        intro i _
+        have hZi := (hcell i).2.2.2.2.2.1
+        have hEi : 0 ≤ (K/Z i)*Real.exp (-d*(boxLower lo hi η j.2 i)^(1/3:ℝ))+
+            (Z i*Real.exp (boxLower lo hi η j.2 i))⁻¹ := by positivity
+        simp only [Complex.norm_real,Real.norm_eq_abs]
+        linarith [hbound i]
+      _ = _ := by simp
+  have hJoint (r : ZMod M) := hprime ι N M lo hi η Z hcell j.2 ε B hε hB hE hbound (F r)
+  have hh := mixed_sum_error
+    (fun r : ZMod M => assignedIntegerResidueMass NI M r loI hiI ηI G φ j.1)
+    (IntegerCell.integerDensityMass M (gridPoint loI hiI ηI j.1.val)
+      (gridPoint loI hiI ηI (j.1.val+1)) G φ)
+    (fun r => assignedJointComplexTestSum N M lo hi η Z j.2 (F r))
+    (∏ i, ((harmonicIntegral M (boxLower lo hi η j.2 i) (boxUpper lo hi η j.2 i)/Z i:ℝ):ℂ)) F
+    hEI (show 0 ≤ (Fintype.card ι:ℝ)*ε*B^Fintype.card ι by positivity)
+    (show 0 ≤ B^Fintype.card ι by positivity) hInteger hProd hJoint
+  rw [← mixedAssignedTestSum_eq_integer] at hh
+  rw [mixedPrincipalMass,MixedCellIntegralFreezing.residue_mixedLogMass_eq M _ _ _ _ _ _ _
+    horderI (box_order lo hi η (fun i => (hcell i).2.1) j.2)]
+  simp only [Complex.ofReal_mul,Complex.ofReal_prod]
+  convert hh using 1
+  dsimp [mixedGridError]
+  ring
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MixedCellGridReplacementBasic.lean

@@ -0,0 +1,125 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionIntegerBoundary
+import OAI.NumberTheory.Ostmann.Arithmetic.LogCellPartitionMixedTuples
+import OAI.NumberTheory.Ostmann.Arithmetic.MixedCellIntegralFreezingLog
+import OAI.NumberTheory.Ostmann.Arithmetic.MixedCellJointReplacementAlgebra
+import OAI.NumberTheory.Ostmann.Arithmetic.PrimeCellAssignedReplacement
+
+namespace OAI
+
+open _root_.Erdos970 _root_.OAI.Erdos970
+
+open Erdos970.Erdos970Dependency.SiegelWalfisz
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open scoped BigOperators
+open MeasureTheory PrimeProgression PrimeCellReplacement PrimeCellFreezing MixedCellIntegralFreezing
+variable {ι : Type*} [Fintype ι] [DecidableEq ι] {M : ℕ} [NeZero M]
+
+def mixedSmoothTestSum (NI : ℕ) (N : ι → ℕ) (M : ℕ) [NeZero M]
+    (loI hiI G : ℝ) (φ : ℝ → ℝ) (lo hi Z : ι → ℝ)
+    (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ) (f : (Option ι → ℝ) → ℂ) : ℂ :=
+  ∑ n ∈ IntegerCell.cellSupport NI loI hiI, ∑ p : PrimeCellTuple N lo hi,
+    ((Real.exp (-G)*φ (Real.log n-G):ℝ):ℂ)*
+      (∏ i, (((Z i*(p i).val)⁻¹:ℝ):ℂ))*
+      jointUnitTest (F (n:ZMod M)) (fun i => ((p i).val:ZMod M))*
+      f (Option.elim' (n:ℝ) (fun i => ((p i).val:ℝ)))
+
+def mixedAssignedTestSum (NI : ℕ) (N : ι → ℕ) (M : ℕ) [NeZero M]
+    (loI hiI ηI G : ℝ) (φ : ℝ → ℝ) (lo hi η Z : ι → ℝ)
+    (j : MixedGridIndex loI hiI ηI lo hi η) (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ) : ℂ :=
+  ∑ n ∈ assignedIntegerSupport NI loI hiI ηI j.1,
+    ((Real.exp (-G)*φ (Real.log n-G):ℝ):ℂ)*
+      assignedJointComplexTestSum N M lo hi η Z j.2 (F (n:ZMod M))
+
+def mixedSmoothAssignedTestSum (NI : ℕ) (N : ι → ℕ) (M : ℕ) [NeZero M]
+    (loI hiI ηI G : ℝ) (φ : ℝ → ℝ) (lo hi η Z : ι → ℝ)
+    (j : MixedGridIndex loI hiI ηI lo hi η) (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ)
+    (f : (Option ι → ℝ) → ℂ) : ℂ :=
+  ∑ n ∈ assignedIntegerSupport NI loI hiI ηI j.1,
+    ∑ p : AssignedPrimeTuple N lo hi η j.2,
+      ((Real.exp (-G)*φ (Real.log n-G):ℝ):ℂ)*
+        (assignedTupleWeight N lo hi η Z j.2 p:ℂ)*
+        jointUnitTest (F (n:ZMod M)) (fun i => ((p i).val:ZMod M))*
+        f (Option.elim' (n:ℝ) (fun i => ((p i).val:ℝ)))
+
+def mixedAssignedAbsMass (NI : ℕ) (N : ι → ℕ) (M : ℕ) [NeZero M]
+    (loI hiI ηI G : ℝ) (φ : ℝ → ℝ) (lo hi η Z : ι → ℝ)
+    (j : MixedGridIndex loI hiI ηI lo hi η) (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ) : ℝ :=
+  ∑ n ∈ assignedIntegerSupport NI loI hiI ηI j.1,
+    (Real.exp (-G)*φ (Real.log n-G))*assignedAbsMass N M lo hi η Z j.2 (F (n:ZMod M))
+
+def mixedPrincipalMass (M : ℕ) (loI hiI G : ℝ) (φ : ℝ → ℝ) (lo hi Z : ι → ℝ) : ℝ :=
+  mixedLogMass M loI hiI G φ (fun i => ((Nat.totient M:ℝ)*Z i)⁻¹) lo hi
+
+def mixedPrincipalIntegral (M : ℕ) (loI hiI G : ℝ) (φ : ℝ → ℝ) (lo hi Z : ι → ℝ)
+    (f : (Option ι → ℝ) → ℂ) : ℂ :=
+  mixedLogIntegral M loI hiI G φ (fun i => ((Nat.totient M:ℝ)*Z i)⁻¹) lo hi
+    (fun x => f (optionCoordinates x))
+
+theorem mixedAssignedTestSum_eq_integer (NI : ℕ) (N : ι → ℕ)
+    (loI hiI ηI G : ℝ) (φ : ℝ → ℝ) (lo hi η Z : ι → ℝ)
+    (j : MixedGridIndex loI hiI ηI lo hi η) (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ) :
+    mixedAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F =
+      ∑ r : ZMod M, (assignedIntegerResidueMass NI M r loI hiI ηI G φ j.1:ℂ)*
+        assignedJointComplexTestSum N M lo hi η Z j.2 (F r) := by
+  unfold mixedAssignedTestSum
+  rw [IntegerCell.sum_weighted_residueTest (assignedIntegerSupport NI loI hiI ηI j.1)
+    (fun n : ℕ => ((Real.exp (-G)*φ (Real.log n-G):ℝ):ℂ))
+    (fun r : ZMod M => assignedJointComplexTestSum N M lo hi η Z j.2 (F r))]
+  simp only [assignedIntegerResidueMass,Complex.ofReal_sum]
+
+theorem mixedAssignedAbsMass_cast (NI : ℕ) (N : ι → ℕ)
+    (loI hiI ηI G : ℝ) (φ : ℝ → ℝ) (lo hi η Z : ι → ℝ)
+    (j : MixedGridIndex loI hiI ηI lo hi η) (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ) :
+    (mixedAssignedAbsMass NI N M loI hiI ηI G φ lo hi η Z j F:ℂ) =
+      mixedAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j (fun r u => (‖F r u‖:ℂ)) := by
+  simp only [mixedAssignedAbsMass,mixedAssignedTestSum,Complex.ofReal_sum,
+    Complex.ofReal_mul,assignedAbsMass_cast]
+
+theorem mixedSmoothTestSum_eq_sum_assigned (NI : ℕ) (N : ι → ℕ)
+    (loI hiI ηI G : ℝ) (φ : ℝ → ℝ) (lo hi η Z : ι → ℝ)
+    (hI : loI ≤ hiI) (horder : ∀ i, lo i ≤ hi i)
+    (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ) (f : (Option ι → ℝ) → ℂ) :
+    mixedSmoothTestSum NI N M loI hiI G φ lo hi Z F f =
+      ∑ j : MixedGridIndex loI hiI ηI lo hi η,
+        mixedSmoothAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F f := by
+  simpa only [mixedSmoothTestSum,mixedSmoothAssignedTestSum,assignedTupleWeight,
+    Complex.ofReal_prod,mul_assoc] using
+    sum_mixed_prior_eq_sum_assigned NI N loI hiI ηI G φ lo hi η Z hI horder
+      (fun n p => jointUnitTest (F (n:ZMod M)) (fun i => (p i:ZMod M))*
+        f (Option.elim' (n:ℝ) (fun i => (p i:ℝ))))
+
+theorem mixedPrincipalMass_eq_sum_boxes (M : ℕ) (loI hiI ηI G : ℝ)
+    (φ : ℝ → ℝ) (lo hi η Z : ι → ℝ) (hI : loI ≤ hiI)
+    (horder : ∀ i, lo i ≤ hi i) (hφ : Continuous φ) (hlo : ∀ i, 0 < lo i) :
+    mixedPrincipalMass M loI hiI G φ lo hi Z =
+      ∑ j : MixedGridIndex loI hiI ηI lo hi η,
+        mixedPrincipalMass M (gridPoint loI hiI ηI j.1.val)
+          (gridPoint loI hiI ηI (j.1.val+1)) G φ (boxLower lo hi η j.2) (boxUpper lo hi η j.2) Z :=
+  mixedLogMass_eq_sum_boxes M loI hiI ηI G φ _ lo hi η hI horder hφ hlo
+
+theorem mixedPrincipalIntegral_eq_sum_boxes (M : ℕ) (loI hiI ηI G : ℝ)
+    (φ : ℝ → ℝ) (lo hi η Z : ι → ℝ) (hI : loI ≤ hiI)
+    (horder : ∀ i, lo i ≤ hi i) (hφ : Continuous φ) (hlo : ∀ i, 0 < lo i)
+    (f : (Option ι → ℝ) → ℂ)
+    (hf : ContinuousOn (fun z => f (fun i => Real.exp (z i)))
+      (logRectangle (Option.elim' loI lo) (Option.elim' hiI hi))) :
+    mixedPrincipalIntegral M loI hiI G φ lo hi Z f =
+      ∑ j : MixedGridIndex loI hiI ηI lo hi η,
+        mixedPrincipalIntegral M (gridPoint loI hiI ηI j.1.val)
+          (gridPoint loI hiI ηI (j.1.val+1)) G φ (boxLower lo hi η j.2) (boxUpper lo hi η j.2) Z f := by
+  apply integral_mixedRectangle_eq_sum_boxes loI hiI ηI lo hi η hI horder
+  have hh : ContinuousOn (fun z => f (optionCoordinates (mixedExp z)))
+      (mixedLogRectangle loI hiI lo hi) := by
+    simp only [optionCoordinates_mixedExp]
+    exact hf.comp continuous_optionCoordinates.continuousOn
+      (fun z hz => (optionCoordinates_mem_logRectangle loI hiI lo hi).mpr hz)
+  exact ((continuousOn_mixedLogDensity M loI hiI G φ _ lo hi hφ hlo).smul hh).integrableOn_compact
+    (isCompact_mixedLogRectangle loI hiI lo hi)
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MixedCellGridReplacementDiscrete.lean

@@ -0,0 +1,144 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MixedCellGridReplacementBasic
+
+namespace OAI
+
+open _root_.Erdos970 _root_.OAI.Erdos970
+
+open Erdos970.Erdos970Dependency.SiegelWalfisz
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open scoped BigOperators
+open PrimeCellReplacement PrimeCellFreezing MixedCellIntegralFreezing Characters.RationalHistory
+variable {ι : Type*} [Fintype ι] [DecidableEq ι] {M : ℕ} [NeZero M]
+
+def mixedAssignedLog (N : ι → ℕ) (lo hi η : ι → ℝ) (j : GridBoxIndex lo hi η)
+    (n : ℕ) (p : AssignedPrimeTuple N lo hi η j) : Option ι → ℝ :=
+  Option.elim' (Real.log (n:ℝ)) (assignedTupleLog N lo hi η j p)
+
+theorem mixedAssignedLog_mem (NI : ℕ) (N : ι → ℕ) (loI hiI ηI : ℝ) (lo hi η : ι → ℝ)
+    (j : MixedGridIndex loI hiI ηI lo hi η) {n : ℕ}
+    (hn : n ∈ assignedIntegerSupport NI loI hiI ηI j.1) (p : AssignedPrimeTuple N lo hi η j.2) :
+    mixedAssignedLog N lo hi η j.2 n p ∈
+      logRectangle (Option.elim' (gridPoint loI hiI ηI j.1.val) (boxLower lo hi η j.2))
+        (Option.elim' (gridPoint loI hiI ηI (j.1.val+1)) (boxUpper lo hi η j.2)) := by
+  intro i _
+  cases i with
+  | none => exact ((mem_cellSupport _ _ _ _).mp (Finset.mem_filter.mp hn).1).2.2
+  | some i => exact assignedTupleLog_mem N lo hi η j.2 p i (Set.mem_univ _)
+
+theorem exp_mixedAssignedLog (NI : ℕ) (N : ι → ℕ) (loI hiI ηI : ℝ) (lo hi η : ι → ℝ)
+    (j : MixedGridIndex loI hiI ηI lo hi η) {n : ℕ}
+    (hn : n ∈ assignedIntegerSupport NI loI hiI ηI j.1) (p : AssignedPrimeTuple N lo hi η j.2) :
+    (fun i => Real.exp (mixedAssignedLog N lo hi η j.2 n p i)) =
+      Option.elim' (n:ℝ) (fun i => ((p i).val:ℝ)) := by
+  funext i
+  cases i with
+  | none =>
+    apply Real.exp_log
+    exact_mod_cast ((mem_cellSupport _ _ _ _).mp (Finset.mem_filter.mp hn).1).2.1
+  | some i => exact congrFun (exp_assignedTupleLog N lo hi η j.2 p) i
+
+theorem mixed_assigned_freezing_of_variation (NI : ℕ) (N : ι → ℕ)
+    (loI hiI ηI G : ℝ) (φ : ℝ → ℝ) (lo hi η Z : ι → ℝ)
+    (j : MixedGridIndex loI hiI ηI lo hi η) (hZ : ∀ i, 0 ≤ Z i)
+    (hφ0 : ∀ t ∈ Set.Icc (gridPoint loI hiI ηI j.1.val)
+      (gridPoint loI hiI ηI (j.1.val+1)), 0 ≤ φ (t-G))
+    (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ) (f : (Option ι → ℝ) → ℂ)
+    (f₀ : ℂ) {v : ℝ}
+    (hvar : ∀ n ∈ assignedIntegerSupport NI loI hiI ηI j.1,
+      ∀ p : AssignedPrimeTuple N lo hi η j.2,
+      ‖f (Option.elim' (n:ℝ) (fun i => ((p i).val:ℝ)))-f₀‖ ≤ v) :
+    ‖mixedSmoothAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F f-
+      f₀*mixedAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F‖ ≤
+      v*mixedAssignedAbsMass NI N M loI hiI ηI G φ lo hi η Z j F := by
+  classical
+  have heq : mixedSmoothAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F f-
+      f₀*mixedAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F =
+      ∑ n ∈ assignedIntegerSupport NI loI hiI ηI j.1,
+        ∑ p : AssignedPrimeTuple N lo hi η j.2,
+          (((Real.exp (-G)*φ (Real.log n-G):ℝ):ℂ)*(assignedTupleWeight N lo hi η Z j.2 p:ℂ)*
+            jointUnitTest (F (n:ZMod M)) (fun i => ((p i).val:ZMod M)))*
+          (f (Option.elim' (n:ℝ) (fun i => ((p i).val:ℝ)))-f₀) := by
+    simp only [mixedSmoothAssignedTestSum,mixedAssignedTestSum,assignedJointTestSum_tupleWeight,
+      Finset.mul_sum,← Finset.sum_sub_distrib]
+    apply Finset.sum_congr rfl
+    intro n hn
+    apply Finset.sum_congr rfl
+    intro p hp
+    ring
+  rw [heq]
+  calc
+    _ ≤ ∑ n ∈ assignedIntegerSupport NI loI hiI ηI j.1,
+        ∑ p : AssignedPrimeTuple N lo hi η j.2,
+          ‖(((Real.exp (-G)*φ (Real.log n-G):ℝ):ℂ)*(assignedTupleWeight N lo hi η Z j.2 p:ℂ)*
+            jointUnitTest (F (n:ZMod M)) (fun i => ((p i).val:ZMod M)))*
+          (f (Option.elim' (n:ℝ) (fun i => ((p i).val:ℝ)))-f₀)‖ :=
+      (norm_sum_le _ _).trans (Finset.sum_le_sum fun n _ => norm_sum_le _ _)
+    _ ≤ ∑ n ∈ assignedIntegerSupport NI loI hiI ηI j.1,
+        ∑ p : AssignedPrimeTuple N lo hi η j.2,
+          v*((Real.exp (-G)*φ (Real.log n-G))*
+            (assignedTupleWeight N lo hi η Z j.2 p*
+              jointAbsTest (F (n:ZMod M)) (fun i => ((p i).val:ZMod M)))) := by
+      apply Finset.sum_le_sum
+      intro n hn
+      have hwI : 0 ≤ Real.exp (-G)*φ (Real.log n-G) :=
+        mul_nonneg (Real.exp_pos _).le
+          (hφ0 _ ((mem_cellSupport _ _ _ _).mp (Finset.mem_filter.mp hn).1).2.2)
+      apply Finset.sum_le_sum
+      intro p hp
+      have hwP := assignedTupleWeight_nonneg N lo hi η Z hZ j.2 p
+      rw [norm_mul,norm_mul,norm_mul,Complex.norm_real,Real.norm_eq_abs,
+        abs_of_nonneg hwI,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg hwP]
+      calc
+        _ ≤ ((Real.exp (-G)*φ (Real.log n-G))*assignedTupleWeight N lo hi η Z j.2 p*
+              jointAbsTest (F (n:ZMod M)) (fun i => ((p i).val:ZMod M)))*v :=
+          mul_le_mul (mul_le_mul_of_nonneg_left (jointUnitTest_norm_le _ _) (mul_nonneg hwI hwP))
+            (hvar n hn p) (norm_nonneg _) (mul_nonneg (mul_nonneg hwI hwP) (jointAbsTest_nonneg _ _))
+        _ = _ := by ring
+    _ = _ := by
+      simp only [mixedAssignedAbsMass,assignedAbsMass,Finset.mul_sum]
+
+theorem smooth_mixed_assigned_freezing_bound (NI : ℕ) (N : ι → ℕ)
+    (loI hiI ηI G : ℝ) (φ : ℝ → ℝ) (lo hi η Z : ι → ℝ)
+    (j : MixedGridIndex loI hiI ηI lo hi η) (hZ : ∀ i, 0 ≤ Z i)
+    (hφ0 : ∀ t ∈ Set.Icc (gridPoint loI hiI ηI j.1.val)
+      (gridPoint loI hiI ηI (j.1.val+1)), 0 ≤ φ (t-G))
+    (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ) (f : (Option ι → ℝ) → ℂ)
+    {D mesh : ℝ} (hD : 0 ≤ D) (hm : 0 ≤ mesh)
+    (hwidthI : gridPoint loI hiI ηI (j.1.val+1)-gridPoint loI hiI ηI j.1.val ≤ mesh)
+    (hwidth : ∀ i, boxUpper lo hi η j.2 i-boxLower lo hi η j.2 i ≤ mesh)
+    (hf : ∀ z∈logRectangle
+      (Option.elim' (gridPoint loI hiI ηI j.1.val) (boxLower lo hi η j.2))
+      (Option.elim' (gridPoint loI hiI ηI (j.1.val+1)) (boxUpper lo hi η j.2)),
+      DifferentiableAt ℝ (fun y => f (fun i => Real.exp (y i))) z)
+    (hd : ∀ z∈logRectangle
+      (Option.elim' (gridPoint loI hiI ηI j.1.val) (boxLower lo hi η j.2))
+      (Option.elim' (gridPoint loI hiI ηI (j.1.val+1)) (boxUpper lo hi η j.2)), ∀ i,
+      ‖deriv (fun t => f (Expr.logCurve (fun i => Real.exp (z i)) i t)) 0‖ ≤ D)
+    {base : Option ι → ℝ} (hbase : base∈logRectangle
+      (Option.elim' (gridPoint loI hiI ηI j.1.val) (boxLower lo hi η j.2))
+      (Option.elim' (gridPoint loI hiI ηI (j.1.val+1)) (boxUpper lo hi η j.2))) :
+    ‖mixedSmoothAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F f-
+      f (fun i => Real.exp (base i))*mixedAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F‖ ≤
+      ((Fintype.card ι:ℝ)+1)*D*mesh*mixedAssignedAbsMass NI N M loI hiI ηI G φ lo hi η Z j F := by
+  apply mixed_assigned_freezing_of_variation NI N loI hiI ηI G φ lo hi η Z j hZ hφ0 F f
+  intro n hn p
+  have hp := mixedAssignedLog_mem NI N loI hiI ηI lo hi η j hn p
+  have hwidth' : ∀ i : Option ι,
+      Option.elim' (gridPoint loI hiI ηI (j.1.val+1)) (boxUpper lo hi η j.2) i -
+      Option.elim' (gridPoint loI hiI ηI j.1.val) (boxLower lo hi η j.2) i ≤ mesh := by
+    intro i
+    cases i with
+    | none => exact hwidthI
+    | some i => exact hwidth i
+  have hh := positive_norm_sub_le f _ _ hD hm hf hd hp hbase
+    (logRectangle_coordinate_dist_le _ _ hwidth' hp hbase)
+  simpa only [exp_mixedAssignedLog NI N loI hiI ηI lo hi η j hn p,
+    Fintype.card_option,Nat.cast_add,Nat.cast_one] using hh
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MixedCellGridReplacementSmooth.lean

@@ -0,0 +1,117 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MixedCellGridReplacementDiscrete
+
+namespace OAI
+
+open _root_.Erdos970 _root_.OAI.Erdos970
+
+open Erdos970.Erdos970Dependency.SiegelWalfisz
+
+noncomputable section
+namespace Ostmann.Arithmetic.LogCellPartition
+open scoped BigOperators
+open PrimeCellFreezing MixedCellIntegralFreezing Characters.RationalHistory
+variable {ι : Type*} [Fintype ι] [DecidableEq ι] {M : ℕ} [NeZero M]
+
+theorem mixedAssignedAbsMass_le_of_error (NI : ℕ) (N : ι → ℕ)
+    (loI hiI ηI G : ℝ) (φ : ℝ → ℝ) (lo hi η Z : ι → ℝ)
+    (j : MixedGridIndex loI hiI ηI lo hi η) (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ)
+    (main error : ℝ)
+    (he : ‖mixedAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j (fun r u => (‖F r u‖:ℂ))-
+      (main:ℂ)*∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,(‖F r u‖:ℂ)‖ ≤
+      error*∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,‖F r u‖) :
+    mixedAssignedAbsMass NI N M loI hiI ηI G φ lo hi η Z j F ≤
+      (main+error)*∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,‖F r u‖ := by
+  rw [← mixedAssignedAbsMass_cast] at he
+  simp only [← Complex.ofReal_sum,← Complex.ofReal_mul,← Complex.ofReal_sub,
+    Complex.norm_real,Real.norm_eq_abs] at he
+  have hh := (le_abs_self _).trans he
+  linarith
+
+theorem mixed_assigned_smooth_replacement_of_errors (NI : ℕ) (N : ι → ℕ)
+    (loI hiI ηI G : ℝ) (φ : ℝ → ℝ) (lo hi η Z : ι → ℝ)
+    (j : MixedGridIndex loI hiI ηI lo hi η)
+    (hφ : Continuous φ)
+    (hφ0 : ∀ t ∈ Set.Icc (gridPoint loI hiI ηI j.1.val)
+      (gridPoint loI hiI ηI (j.1.val+1)), 0 ≤ φ (t-G))
+    (hZ : ∀ i, 0 < Z i) (hlo : ∀ i, 0 < boxLower lo hi η j.2 i)
+    (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ) (f : (Option ι → ℝ) → ℂ)
+    {D mesh error : ℝ} (hD : 0 ≤ D) (hm : 0 ≤ mesh)
+    (hwidthI : gridPoint loI hiI ηI (j.1.val+1)-gridPoint loI hiI ηI j.1.val ≤ mesh)
+    (hwidth : ∀ i, boxUpper lo hi η j.2 i-boxLower lo hi η j.2 i ≤ mesh)
+    (hf : ∀ z∈logRectangle
+      (Option.elim' (gridPoint loI hiI ηI j.1.val) (boxLower lo hi η j.2))
+      (Option.elim' (gridPoint loI hiI ηI (j.1.val+1)) (boxUpper lo hi η j.2)),
+      DifferentiableAt ℝ (fun y => f (fun i => Real.exp (y i))) z)
+    (hd : ∀ z∈logRectangle
+      (Option.elim' (gridPoint loI hiI ηI j.1.val) (boxLower lo hi η j.2))
+      (Option.elim' (gridPoint loI hiI ηI (j.1.val+1)) (boxUpper lo hi η j.2)), ∀ i,
+      ‖deriv (fun t => f (Expr.logCurve (fun i => Real.exp (z i)) i t)) 0‖ ≤ D)
+    {base : ℝ × (ι → ℝ)} (hbase : base∈mixedLogRectangle
+      (gridPoint loI hiI ηI j.1.val) (gridPoint loI hiI ηI (j.1.val+1))
+      (boxLower lo hi η j.2) (boxUpper lo hi η j.2))
+    (he : ‖mixedAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F-
+      (mixedPrincipalMass M (gridPoint loI hiI ηI j.1.val)
+        (gridPoint loI hiI ηI (j.1.val+1)) G φ (boxLower lo hi η j.2) (boxUpper lo hi η j.2) Z:ℂ)*
+        ∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,F r u‖ ≤ error*∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,‖F r u‖)
+    (heAbs : ‖mixedAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j (fun r u => (‖F r u‖:ℂ))-
+      (mixedPrincipalMass M (gridPoint loI hiI ηI j.1.val)
+        (gridPoint loI hiI ηI (j.1.val+1)) G φ (boxLower lo hi η j.2) (boxUpper lo hi η j.2) Z:ℂ)*
+        ∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,(‖F r u‖:ℂ)‖ ≤ error*∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,‖F r u‖) :
+    ‖mixedSmoothAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F f-
+      mixedPrincipalIntegral M (gridPoint loI hiI ηI j.1.val)
+        (gridPoint loI hiI ηI (j.1.val+1)) G φ (boxLower lo hi η j.2) (boxUpper lo hi η j.2) Z f*
+        ∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,F r u‖ ≤
+      (((Fintype.card ι:ℝ)+1)*D*mesh*
+        (2*mixedPrincipalMass M (gridPoint loI hiI ηI j.1.val)
+          (gridPoint loI hiI ηI (j.1.val+1)) G φ (boxLower lo hi η j.2) (boxUpper lo hi η j.2) Z+error)+
+        ‖f (optionCoordinates (mixedExp base))‖*error)*∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,‖F r u‖ := by
+  classical
+  let v : ℝ := ((Fintype.card ι:ℝ)+1)*D*mesh
+  let f₀ := f (optionCoordinates (mixedExp base))
+  let S := ∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,F r u
+  let T := ∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,‖F r u‖
+  let mass := mixedPrincipalMass M (gridPoint loI hiI ηI j.1.val)
+    (gridPoint loI hiI ηI (j.1.val+1)) G φ (boxLower lo hi η j.2) (boxUpper lo hi η j.2) Z
+  let integral := mixedPrincipalIntegral M (gridPoint loI hiI ηI j.1.val)
+    (gridPoint loI hiI ηI (j.1.val+1)) G φ (boxLower lo hi η j.2) (boxUpper lo hi η j.2) Z f
+  let actual := mixedAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F
+  have hv : 0 ≤ v := by dsimp [v]; positivity
+  have hmass := mixedAssignedAbsMass_le_of_error NI N loI hiI ηI G φ lo hi η Z j F mass error heAbs
+  have hdisc := smooth_mixed_assigned_freezing_bound NI N loI hiI ηI G φ lo hi η Z j
+    (fun i => (hZ i).le) hφ0 F f hD hm hwidthI hwidth hf hd
+    ((optionCoordinates_mem_logRectangle _ _ _ _).mpr hbase)
+  have hdisc' : ‖mixedSmoothAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F f-f₀*actual‖ ≤
+      v*((mass+error)*T) := by
+    simpa only [f₀,optionCoordinates_mixedExp] using
+      hdisc.trans (mul_le_mul_of_nonneg_left hmass hv)
+  have hap : ‖f₀*actual-f₀*((mass:ℂ)*S)‖ ≤ ‖f₀‖*(error*T) := by
+    rw [← mul_sub,norm_mul]
+    exact mul_le_mul_of_nonneg_left he (norm_nonneg _)
+  have hint := mixed_integral_freezing_of_log_partials M
+    (gridPoint loI hiI ηI j.1.val) (gridPoint loI hiI ηI (j.1.val+1)) G φ
+    (fun i => ((Nat.totient M:ℝ)*Z i)⁻¹) (boxLower lo hi η j.2) (boxUpper lo hi η j.2)
+    hφ hφ0 (fun i => inv_nonneg.mpr (mul_nonneg (Nat.cast_nonneg _) (hZ i).le)) hlo
+    f hD hm hwidthI hwidth hf hd hbase
+  have hint' : ‖(mass:ℂ)*f₀-integral‖ ≤ v*mass := by
+    rw [norm_sub_rev]
+    simpa only [integral,mass,mixedPrincipalIntegral,mixedPrincipalMass,Complex.real_smul] using hint
+  have hS : ‖S‖ ≤ T := (norm_sum_le _ _).trans (Finset.sum_le_sum fun r _ => norm_sum_le _ _)
+  have hmain : ‖f₀*((mass:ℂ)*S)-integral*S‖ ≤ (v*mass)*T := by
+    have heq : f₀*((mass:ℂ)*S)-integral*S = ((mass:ℂ)*f₀-integral)*S := by ring
+    rw [heq,norm_mul]
+    exact mul_le_mul hint' hS (norm_nonneg _) ((norm_nonneg _).trans hint')
+  calc
+    _ ≤ ‖mixedSmoothAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F f-f₀*actual‖+
+        ‖f₀*actual-f₀*((mass:ℂ)*S)‖+‖f₀*((mass:ℂ)*S)-integral*S‖ := by
+      have h₁ := norm_sub_le_norm_sub_add_norm_sub
+        (mixedSmoothAssignedTestSum NI N M loI hiI ηI G φ lo hi η Z j F f) (f₀*actual) (integral*S)
+      have h₂ := norm_sub_le_norm_sub_add_norm_sub (f₀*actual) (f₀*((mass:ℂ)*S)) (integral*S)
+      simpa only [add_assoc] using h₁.trans (add_le_add le_rfl h₂)
+    _ ≤ v*((mass+error)*T)+‖f₀‖*(error*T)+(v*mass)*T := add_le_add (add_le_add hdisc' hap) hmain
+    _ = _ := by dsimp only [v,f₀,T,mass]; ring
+
+end Ostmann.Arithmetic.LogCellPartition
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MixedCellIntegralFreezing.lean

@@ -0,0 +1,131 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MixedCellIntegralFreezingMass
+
+namespace OAI
+
+noncomputable section
+namespace Ostmann.Arithmetic.MixedCellIntegralFreezing
+open MeasureTheory PrimeCellFreezing
+open scoped BigOperators
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+def mixedExp (t : ℝ × (ι → ℝ)) : ℝ × (ι → ℝ) :=
+  (Real.exp t.1, fun i => Real.exp (t.2 i))
+
+def mixedLogIntegral (M : ℕ) (loI hiI G : ℝ) (φ : ℝ → ℝ)
+    (w lo hi : ι → ℝ) (f : (ℝ × (ι → ℝ)) → ℂ) : ℂ :=
+  ∫ t in mixedLogRectangle loI hiI lo hi, mixedLogDensity M G φ w t • f (mixedExp t)
+
+omit [DecidableEq ι] in
+theorem mixed_freezing_of_variation (M : ℕ) (loI hiI G : ℝ) (φ : ℝ → ℝ)
+    (w lo hi : ι → ℝ) (hφ : Continuous φ)
+    (hφ0 : ∀ t ∈ Set.Icc loI hiI, 0 ≤ φ (t-G))
+    (hw : ∀ i, 0 ≤ w i) (hlo : ∀ i, 0 < lo i)
+    (F : (ℝ × (ι → ℝ)) → ℂ)
+    (hF : ContinuousOn F (mixedLogRectangle loI hiI lo hi))
+    (base : ℝ × (ι → ℝ)) {C : ℝ}
+    (hvar : ∀ t ∈ mixedLogRectangle loI hiI lo hi, ‖F t - F base‖ ≤ C) :
+    ‖(∫ t in mixedLogRectangle loI hiI lo hi, mixedLogDensity M G φ w t • F t) -
+      mixedLogMass M loI hiI G φ w lo hi • F base‖ ≤
+      C * mixedLogMass M loI hiI G φ w lo hi := by
+  have hc := isCompact_mixedLogRectangle loI hiI lo hi
+  have hdc := continuousOn_mixedLogDensity M loI hiI G φ w lo hi hφ hlo
+  have hdi := integrableOn_mixedLogDensity M loI hiI G φ w lo hi hφ hlo
+  have hFi : IntegrableOn (fun t => mixedLogDensity M G φ w t • F t)
+      (mixedLogRectangle loI hiI lo hi) :=
+    (hdc.smul hF).integrableOn_compact hc
+  have hbi : IntegrableOn (fun t => mixedLogDensity M G φ w t • F base)
+      (mixedLogRectangle loI hiI lo hi) :=
+    (hdc.smul continuousOn_const).integrableOn_compact hc
+  have heq : (∫ t in mixedLogRectangle loI hiI lo hi, mixedLogDensity M G φ w t • F t) -
+      mixedLogMass M loI hiI G φ w lo hi • F base =
+      ∫ t in mixedLogRectangle loI hiI lo hi, mixedLogDensity M G φ w t • (F t-F base) := by
+    unfold mixedLogMass
+    rw [← integral_smul_const, ← integral_sub hFi hbi]
+    congr 1
+    funext t
+    exact (smul_sub _ _ _).symm
+  rw [heq]
+  calc
+    _ ≤ ∫ t in mixedLogRectangle loI hiI lo hi, mixedLogDensity M G φ w t * C := by
+      apply norm_integral_le_of_norm_le (hdi.mul_const C)
+      filter_upwards [ae_restrict_mem hc.measurableSet] with t ht
+      have hn := mixedLogDensity_nonneg M loI hiI G φ w lo hi hφ0 hw hlo ht
+      rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg hn]
+      exact mul_le_mul_of_nonneg_left (hvar t ht) hn
+    _ = C * mixedLogMass M loI hiI G φ w lo hi := by
+      rw [integral_mul_const]
+      exact mul_comm _ _
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem mixedLogRectangle_convex (loI hiI : ℝ) (lo hi : ι → ℝ) :
+    Convex ℝ (mixedLogRectangle loI hiI lo hi) :=
+  (convex_Icc loI hiI).prod (logRectangle_convex lo hi)
+
+omit [DecidableEq ι] in
+theorem mixedLogRectangle_dist_le (loI hiI : ℝ) (lo hi : ι → ℝ)
+    {mesh : ℝ} (hm : 0 ≤ mesh) (hwidthI : hiI-loI ≤ mesh)
+    (hwidth : ∀ i, hi i-lo i ≤ mesh)
+    {x y : ℝ × (ι → ℝ)}
+    (hx : x ∈ mixedLogRectangle loI hiI lo hi)
+    (hy : y ∈ mixedLogRectangle loI hiI lo hi) : ‖x-y‖ ≤ mesh := by
+  rw [Prod.norm_def, max_le_iff]
+  constructor
+  · simp only [Prod.fst_sub, Real.norm_eq_abs]
+    exact abs_le.mpr ⟨by linarith [hx.1.1, hy.1.2], by linarith [hy.1.1, hx.1.2]⟩
+  · apply (pi_norm_le_iff_of_nonneg hm).mpr
+    intro i
+    simpa only [Prod.snd_sub, Pi.sub_apply, Real.norm_eq_abs] using
+      logRectangle_coordinate_dist_le lo hi hwidth hx.2 hy.2 i
+
+omit [DecidableEq ι] in
+theorem mixed_positive_integral_freezing_bound (M : ℕ) (loI hiI G : ℝ) (φ : ℝ → ℝ)
+    (w lo hi : ι → ℝ) (hφ : Continuous φ)
+    (hφ0 : ∀ t ∈ Set.Icc loI hiI, 0 ≤ φ (t-G))
+    (hw : ∀ i, 0 ≤ w i) (hlo : ∀ i, 0 < lo i)
+    (f : (ℝ × (ι → ℝ)) → ℂ) {D mesh : ℝ} (hD : 0 ≤ D) (hm : 0 ≤ mesh)
+    (hwidthI : hiI-loI ≤ mesh) (hwidth : ∀ i, hi i-lo i ≤ mesh)
+    (hf : ∀ z ∈ mixedLogRectangle loI hiI lo hi,
+      DifferentiableAt ℝ (fun y => f (mixedExp y)) z)
+    (hd : ∀ z ∈ mixedLogRectangle loI hiI lo hi,
+      ‖fderiv ℝ (fun y => f (mixedExp y)) z‖ ≤ D)
+    {base : ℝ × (ι → ℝ)} (hbase : base ∈ mixedLogRectangle loI hiI lo hi) :
+    ‖mixedLogIntegral M loI hiI G φ w lo hi f -
+      mixedLogMass M loI hiI G φ w lo hi • f (mixedExp base)‖ ≤
+      D * mesh * mixedLogMass M loI hiI G φ w lo hi := by
+  apply mixed_freezing_of_variation M loI hiI G φ w lo hi hφ hφ0 hw hlo
+    (fun y => f (mixedExp y))
+    (fun z hz => (hf z hz).continuousAt.continuousWithinAt) base
+  intro z hz
+  have h := (mixedLogRectangle_convex loI hiI lo hi).norm_image_sub_le_of_norm_fderiv_le
+    hf hd hbase hz
+  exact h.trans (mul_le_mul_of_nonneg_left
+    (mixedLogRectangle_dist_le loI hiI lo hi hm hwidthI hwidth hz hbase) hD)
+
+omit [DecidableEq ι] in
+theorem residue_mixed_integral_freezing_bound (M : ℕ) (loI hiI G : ℝ) (φ : ℝ → ℝ)
+    (Z lo hi : ι → ℝ) (hφ : Continuous φ)
+    (hφ0 : ∀ t ∈ Set.Icc loI hiI, 0 ≤ φ (t-G))
+    (hZ : ∀ i, 0 < Z i) (hlo : ∀ i, 0 < lo i)
+    (hI : loI ≤ hiI) (horder : ∀ i, lo i ≤ hi i)
+    (f : (ℝ × (ι → ℝ)) → ℂ) {D mesh : ℝ} (hD : 0 ≤ D) (hm : 0 ≤ mesh)
+    (hwidthI : hiI-loI ≤ mesh) (hwidth : ∀ i, hi i-lo i ≤ mesh)
+    (hf : ∀ z ∈ mixedLogRectangle loI hiI lo hi,
+      DifferentiableAt ℝ (fun y => f (mixedExp y)) z)
+    (hd : ∀ z ∈ mixedLogRectangle loI hiI lo hi,
+      ‖fderiv ℝ (fun y => f (mixedExp y)) z‖ ≤ D)
+    {base : ℝ × (ι → ℝ)} (hbase : base ∈ mixedLogRectangle loI hiI lo hi) :
+    ‖mixedLogIntegral M loI hiI G φ (fun i => ((Nat.totient M : ℝ) * Z i)⁻¹) lo hi f -
+      (IntegerCell.integerDensityMass M loI hiI G φ *
+        ∏ i, PrimeProgression.harmonicIntegral M (lo i) (hi i) / Z i) • f (mixedExp base)‖ ≤
+      D * mesh * (IntegerCell.integerDensityMass M loI hiI G φ *
+        ∏ i, PrimeProgression.harmonicIntegral M (lo i) (hi i) / Z i) := by
+  rw [← residue_mixedLogMass_eq M loI hiI G φ Z lo hi hI horder]
+  exact mixed_positive_integral_freezing_bound M loI hiI G φ _ lo hi hφ hφ0
+    (fun i => inv_nonneg.mpr (mul_nonneg (Nat.cast_nonneg _) (hZ i).le))
+    hlo f hD hm hwidthI hwidth hf hd hbase
+
+end Ostmann.Arithmetic.MixedCellIntegralFreezing
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MixedCellIntegralFreezingLog.lean

@@ -0,0 +1,106 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MixedCellIntegralFreezing
+
+namespace OAI
+
+noncomputable section
+namespace Ostmann.Arithmetic.MixedCellIntegralFreezing
+open MeasureTheory PrimeCellFreezing Characters.RationalHistory
+open scoped BigOperators
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+def optionCoordinates (t : ℝ × (ι → ℝ)) : Option ι → ℝ := Option.elim' t.1 t.2
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem continuous_optionCoordinates : Continuous (optionCoordinates (ι := ι)) := by
+  apply continuous_pi
+  intro i
+  cases i with
+  | none => exact continuous_fst
+  | some i => exact (continuous_apply i).comp continuous_snd
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem optionCoordinates_mem_logRectangle (loI hiI : ℝ) (lo hi : ι → ℝ)
+    {t : ℝ × (ι → ℝ)} :
+    optionCoordinates t ∈ logRectangle (Option.elim' loI lo) (Option.elim' hiI hi) ↔
+      t ∈ mixedLogRectangle loI hiI lo hi := by
+  constructor
+  · intro h
+    exact ⟨h none (Set.mem_univ _), fun i _ => h (some i) (Set.mem_univ _)⟩
+  · intro h i _
+    cases i with
+    | none => exact h.1
+    | some i => exact h.2 i (Set.mem_univ i)
+
+omit [Fintype ι] [DecidableEq ι] in
+@[simp] theorem optionCoordinates_mixedExp (t : ℝ × (ι → ℝ)) :
+    optionCoordinates (mixedExp t) = fun j => Real.exp (optionCoordinates t j) := by
+  funext j
+  cases j <;> rfl
+
+theorem mixed_integral_freezing_of_log_partials
+    (M : ℕ) (loI hiI G : ℝ) (φ : ℝ → ℝ) (w lo hi : ι → ℝ)
+    (hφ : Continuous φ) (hφ0 : ∀ t ∈ Set.Icc loI hiI, 0 ≤ φ (t-G))
+    (hw : ∀ i, 0 ≤ w i) (hlo : ∀ i, 0 < lo i)
+    (f : (Option ι → ℝ) → ℂ) {D mesh : ℝ} (hD : 0 ≤ D) (hm : 0 ≤ mesh)
+    (hwidthI : hiI-loI ≤ mesh) (hwidth : ∀ i, hi i-lo i ≤ mesh)
+    (hf : ∀ z ∈ logRectangle (Option.elim' loI lo) (Option.elim' hiI hi),
+      DifferentiableAt ℝ (fun y => f (fun j => Real.exp (y j))) z)
+    (hd : ∀ z ∈ logRectangle (Option.elim' loI lo) (Option.elim' hiI hi), ∀ i,
+      ‖deriv (fun t => f (Expr.logCurve (fun j => Real.exp (z j)) i t)) 0‖ ≤ D)
+    {base : ℝ × (ι → ℝ)} (hbase : base ∈ mixedLogRectangle loI hiI lo hi) :
+    ‖mixedLogIntegral M loI hiI G φ w lo hi (fun x => f (optionCoordinates x)) -
+      mixedLogMass M loI hiI G φ w lo hi • f (optionCoordinates (mixedExp base))‖ ≤
+      ((Fintype.card ι : ℝ)+1)*D*mesh * mixedLogMass M loI hiI G φ w lo hi := by
+  have hF : ContinuousOn (fun z => f (optionCoordinates (mixedExp z)))
+      (mixedLogRectangle loI hiI lo hi) := by
+    intro z hz
+    have hh := (hf (optionCoordinates z)
+      ((optionCoordinates_mem_logRectangle loI hiI lo hi).mpr hz)).continuousAt.comp
+        continuous_optionCoordinates.continuousAt
+    simpa only [Function.comp_def, optionCoordinates_mixedExp] using hh.continuousWithinAt
+      (s := mixedLogRectangle loI hiI lo hi)
+  apply mixed_freezing_of_variation M loI hiI G φ w lo hi hφ hφ0 hw hlo
+    (fun z => f (optionCoordinates (mixedExp z))) hF base
+  intro z hz
+  have hwidth' : ∀ i : Option ι,
+      Option.elim' hiI hi i - Option.elim' loI lo i ≤ mesh := by
+    intro i
+    cases i with
+    | none => exact hwidthI
+    | some i => exact hwidth i
+  have hz' := (optionCoordinates_mem_logRectangle loI hiI lo hi).mpr hz
+  have hb' := (optionCoordinates_mem_logRectangle loI hiI lo hi).mpr hbase
+  have h := positive_norm_sub_le f (Option.elim' loI lo) (Option.elim' hiI hi)
+    hD hm hf hd hz' hb'
+    (logRectangle_coordinate_dist_le _ _ hwidth' hz' hb')
+  simpa only [Fintype.card_option, Nat.cast_add, Nat.cast_one, optionCoordinates_mixedExp] using h
+
+theorem residue_mixed_integral_freezing_of_log_partials
+    (M : ℕ) (loI hiI G : ℝ) (φ : ℝ → ℝ) (Z lo hi : ι → ℝ)
+    (hφ : Continuous φ) (hφ0 : ∀ t ∈ Set.Icc loI hiI, 0 ≤ φ (t-G))
+    (hZ : ∀ i, 0 < Z i) (hlo : ∀ i, 0 < lo i)
+    (hI : loI ≤ hiI) (horder : ∀ i, lo i ≤ hi i)
+    (f : (Option ι → ℝ) → ℂ) {D mesh : ℝ} (hD : 0 ≤ D) (hm : 0 ≤ mesh)
+    (hwidthI : hiI-loI ≤ mesh) (hwidth : ∀ i, hi i-lo i ≤ mesh)
+    (hf : ∀ z ∈ logRectangle (Option.elim' loI lo) (Option.elim' hiI hi),
+      DifferentiableAt ℝ (fun y => f (fun j => Real.exp (y j))) z)
+    (hd : ∀ z ∈ logRectangle (Option.elim' loI lo) (Option.elim' hiI hi), ∀ i,
+      ‖deriv (fun t => f (Expr.logCurve (fun j => Real.exp (z j)) i t)) 0‖ ≤ D)
+    {base : ℝ × (ι → ℝ)} (hbase : base ∈ mixedLogRectangle loI hiI lo hi) :
+    ‖mixedLogIntegral M loI hiI G φ (fun i => ((Nat.totient M : ℝ)*Z i)⁻¹) lo hi
+        (fun x => f (optionCoordinates x)) -
+      (IntegerCell.integerDensityMass M loI hiI G φ *
+        ∏ i, PrimeProgression.harmonicIntegral M (lo i) (hi i)/Z i) •
+          f (optionCoordinates (mixedExp base))‖ ≤
+      ((Fintype.card ι : ℝ)+1)*D*mesh * (IntegerCell.integerDensityMass M loI hiI G φ *
+        ∏ i, PrimeProgression.harmonicIntegral M (lo i) (hi i)/Z i) := by
+  rw [← residue_mixedLogMass_eq M loI hiI G φ Z lo hi hI horder]
+  exact mixed_integral_freezing_of_log_partials M loI hiI G φ _ lo hi hφ hφ0
+    (fun i => inv_nonneg.mpr (mul_nonneg (Nat.cast_nonneg _) (hZ i).le))
+    hlo f hD hm hwidthI hwidth hf hd hbase
+
+end Ostmann.Arithmetic.MixedCellIntegralFreezing
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MixedCellIntegralFreezingMass.lean

@@ -0,0 +1,85 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.IntegerCell
+import OAI.NumberTheory.Ostmann.Arithmetic.PrimeCellIntegralFreezing
+
+namespace OAI
+
+noncomputable section
+namespace Ostmann.Arithmetic.MixedCellIntegralFreezing
+open MeasureTheory PrimeCellFreezing
+open scoped BigOperators
+variable {ι : Type*} [Fintype ι]
+
+def mixedLogRectangle (loI hiI : ℝ) (lo hi : ι → ℝ) : Set (ℝ × (ι → ℝ)) :=
+  Set.Icc loI hiI ×ˢ logRectangle lo hi
+
+def mixedLogDensity (M : ℕ) (G : ℝ) (φ : ℝ → ℝ) (w : ι → ℝ)
+    (t : ℝ × (ι → ℝ)) : ℝ :=
+  (Real.exp (t.1-G) * φ (t.1-G) / (M : ℝ)) * logCellDensity w t.2
+
+def mixedLogMass (M : ℕ) (loI hiI G : ℝ) (φ : ℝ → ℝ) (w lo hi : ι → ℝ) : ℝ :=
+  ∫ t in mixedLogRectangle loI hiI lo hi, mixedLogDensity M G φ w t
+
+theorem mixedLogMass_eq (M : ℕ) (loI hiI G : ℝ) (φ : ℝ → ℝ) (w lo hi : ι → ℝ)
+    (hI : loI ≤ hiI) :
+    mixedLogMass M loI hiI G φ w lo hi =
+      IntegerCell.integerDensityMass M loI hiI G φ * logCellMass w lo hi := by
+  unfold mixedLogMass mixedLogDensity mixedLogRectangle
+  change (∫ t in Set.Icc loI hiI ×ˢ logRectangle lo hi,
+    (Real.exp (t.1-G) * φ (t.1-G) / (M : ℝ)) * logCellDensity w t.2
+      ∂(volume.prod volume)) = _
+  rw [setIntegral_prod_mul (fun t : ℝ => Real.exp (t-G) * φ (t-G) / (M : ℝ))
+    (logCellDensity w) (Set.Icc loI hiI) (logRectangle lo hi)]
+  congr 1
+  simp_rw [div_eq_mul_inv]
+  rw [integral_mul_const, integral_Icc_eq_integral_Ioc,
+    ← intervalIntegral.integral_of_le hI]
+  rfl
+
+theorem residue_mixedLogMass_eq (M : ℕ) (loI hiI G : ℝ) (φ : ℝ → ℝ) (Z lo hi : ι → ℝ)
+    (hI : loI ≤ hiI) (horder : ∀ i, lo i ≤ hi i) :
+    mixedLogMass M loI hiI G φ (fun i => ((Nat.totient M : ℝ) * Z i)⁻¹) lo hi =
+      IntegerCell.integerDensityMass M loI hiI G φ *
+        ∏ i, PrimeProgression.harmonicIntegral M (lo i) (hi i) / Z i := by
+  rw [mixedLogMass_eq M loI hiI G φ _ lo hi hI,
+    residue_logCellMass_eq_prod M Z lo hi horder]
+
+omit [Fintype ι] in
+theorem isCompact_mixedLogRectangle (loI hiI : ℝ) (lo hi : ι → ℝ) :
+    IsCompact (mixedLogRectangle loI hiI lo hi) :=
+  isCompact_Icc.prod (isCompact_logRectangle lo hi)
+
+theorem continuousOn_mixedLogDensity (M : ℕ) (loI hiI G : ℝ) (φ : ℝ → ℝ)
+    (w lo hi : ι → ℝ) (hφ : Continuous φ) (hlo : ∀ i, 0 < lo i) :
+    ContinuousOn (mixedLogDensity M G φ w) (mixedLogRectangle loI hiI lo hi) := by
+  have hI : Continuous (fun t : ℝ × (ι → ℝ) =>
+      Real.exp (t.1-G) * φ (t.1-G) / (M : ℝ)) := by fun_prop
+  exact hI.continuousOn.mul ((continuousOn_logCellDensity w lo hi hlo).comp
+    continuous_snd.continuousOn (fun _ ht => ht.2))
+
+theorem integrableOn_mixedLogDensity (M : ℕ) (loI hiI G : ℝ) (φ : ℝ → ℝ)
+    (w lo hi : ι → ℝ) (hφ : Continuous φ) (hlo : ∀ i, 0 < lo i) :
+    IntegrableOn (mixedLogDensity M G φ w) (mixedLogRectangle loI hiI lo hi) :=
+  (continuousOn_mixedLogDensity M loI hiI G φ w lo hi hφ hlo).integrableOn_compact
+    (isCompact_mixedLogRectangle loI hiI lo hi)
+
+theorem mixedLogDensity_nonneg (M : ℕ) (loI hiI G : ℝ) (φ : ℝ → ℝ)
+    (w lo hi : ι → ℝ) (hφ : ∀ t ∈ Set.Icc loI hiI, 0 ≤ φ (t-G))
+    (hw : ∀ i, 0 ≤ w i) (hlo : ∀ i, 0 < lo i)
+    {t : ℝ × (ι → ℝ)} (ht : t ∈ mixedLogRectangle loI hiI lo hi) :
+    0 ≤ mixedLogDensity M G φ w t :=
+  mul_nonneg (div_nonneg (mul_nonneg (Real.exp_pos _).le (hφ t.1 ht.1)) (Nat.cast_nonneg M))
+    (logCellDensity_nonneg w lo hi hw hlo ht.2)
+
+theorem mixedLogMass_nonneg (M : ℕ) (loI hiI G : ℝ) (φ : ℝ → ℝ)
+    (w lo hi : ι → ℝ) (hφ : ∀ t ∈ Set.Icc loI hiI, 0 ≤ φ (t-G))
+    (hw : ∀ i, 0 ≤ w i) (hlo : ∀ i, 0 < lo i) :
+    0 ≤ mixedLogMass M loI hiI G φ w lo hi := by
+  apply setIntegral_nonneg (isCompact_mixedLogRectangle loI hiI lo hi).measurableSet
+  intro t ht
+  exact mixedLogDensity_nonneg M loI hiI G φ w lo hi hφ hw hlo ht
+
+end Ostmann.Arithmetic.MixedCellIntegralFreezing
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MixedCellJointReplacementAlgebra.lean

@@ -0,0 +1,53 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MixedCellJointReplacementPrior
+
+namespace OAI
+
+open _root_.Erdos970 _root_.OAI.Erdos970
+
+open Erdos970.Erdos970Dependency.SiegelWalfisz
+
+noncomputable section
+namespace Ostmann.Arithmetic.MixedCellJointReplacement
+open scoped BigOperators
+
+theorem mixed_sum_error {α β : Type*} [Fintype α] [Fintype β]
+    (μ : α → ℝ) (J : ℝ) (X : α → ℂ) (P : ℂ) (F : α → β → ℂ)
+    {E Q B : ℝ} (hE : 0 ≤ E) (_hQ : 0 ≤ Q) (hB : 0 ≤ B)
+    (hμ : ∀ r, |μ r-J| ≤ E) (hP : ‖P‖ ≤ B)
+    (hX : ∀ r, ‖X r-P*(∑ u, F r u)‖ ≤ Q*(∑ u, ‖F r u‖)) :
+    ‖(∑ r, (μ r : ℂ)*X r)-(J : ℂ)*P*(∑ r, ∑ u, F r u)‖ ≤
+      (E*B+(|J|+E)*Q)*(∑ r, ∑ u, ‖F r u‖) := by
+  have hm (r : α) : ‖(μ r : ℂ)‖ ≤ |J|+E := by
+    have h := abs_add_le (μ r-J) J
+    rw [sub_add_cancel] at h
+    simp only [Complex.norm_real, Real.norm_eq_abs]
+    linarith [hμ r]
+  have hd (r : α) : ‖(μ r : ℂ)-(J : ℂ)‖ ≤ E := by
+    simpa only [← Complex.ofReal_sub, Complex.norm_real, Real.norm_eq_abs] using hμ r
+  have hp (r : α) : ‖(μ r : ℂ)*X r-(J : ℂ)*P*(∑ u, F r u)‖ ≤
+      (E*B+(|J|+E)*Q)*(∑ u, ‖F r u‖) := by
+    have he : (μ r : ℂ)*X r-(J : ℂ)*P*(∑ u, F r u) =
+      (μ r : ℂ)*(X r-P*(∑ u, F r u))+
+        ((μ r : ℂ)-(J : ℂ))*P*(∑ u, F r u) := by ring
+    rw [he]
+    calc
+      _ ≤ ‖(μ r : ℂ)*(X r-P*(∑ u, F r u))‖+
+          ‖((μ r : ℂ)-(J : ℂ))*P*(∑ u, F r u)‖ := norm_add_le _ _
+      _ = ‖(μ r : ℂ)‖*‖X r-P*(∑ u, F r u)‖+
+          ‖(μ r : ℂ)-(J : ℂ)‖*‖P‖*‖∑ u, F r u‖ := by simp only [norm_mul]
+      _ ≤ (|J|+E)*(Q*(∑ u, ‖F r u‖))+E*B*(∑ u, ‖F r u‖) := by
+        apply add_le_add
+        · exact mul_le_mul (hm r) (hX r) (norm_nonneg _) (by positivity)
+        · exact mul_le_mul (mul_le_mul (hd r) hP (norm_nonneg _) hE)
+            (norm_sum_le _ _) (norm_nonneg _) (mul_nonneg hE hB)
+      _ = _ := by ring
+  rw [Finset.mul_sum, ← Finset.sum_sub_distrib]
+  calc
+    _ ≤ ∑ r, ‖(μ r : ℂ)*X r-(J : ℂ)*P*(∑ u, F r u)‖ := norm_sum_le _ _
+    _ ≤ ∑ r, (E*B+(|J|+E)*Q)*(∑ u, ‖F r u‖) := Finset.sum_le_sum (fun r _ => hp r)
+    _ = _ := (Finset.mul_sum _ _ _).symm
+
+end Ostmann.Arithmetic.MixedCellJointReplacement
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MixedCellJointReplacementPrior.lean

@@ -0,0 +1,55 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.IntegerCell
+import OAI.NumberTheory.Ostmann.Arithmetic.PrimeCellJointReplacement
+
+namespace OAI
+
+open _root_.Erdos970 _root_.OAI.Erdos970
+
+open Erdos970.Erdos970Dependency.SiegelWalfisz
+
+noncomputable section
+namespace Ostmann.Arithmetic.MixedCellJointReplacement
+open scoped BigOperators
+open PrimeCellReplacement
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+def mixedComplexTestSum (NI : ℕ) (N : ι → ℕ) (M : ℕ) [NeZero M]
+    (loI hiI G : ℝ) (φ : ℝ → ℝ) (lo hi Z : ι → ℝ)
+    (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ) : ℂ :=
+  ∑ n ∈ IntegerCell.cellSupport NI loI hiI,
+    ((Real.exp (-G)*φ (Real.log n-G) : ℝ) : ℂ)*
+      jointComplexTestSum N M lo hi Z (F (n : ZMod M))
+
+theorem mixedComplexTestSum_expanded (NI : ℕ) (N : ι → ℕ) (M : ℕ) [NeZero M]
+    (loI hiI G : ℝ) (φ : ℝ → ℝ) (lo hi Z : ι → ℝ)
+    (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ) :
+    mixedComplexTestSum NI N M loI hiI G φ lo hi Z F =
+      ∑ n ∈ IntegerCell.cellSupport NI loI hiI, ∑ p : PrimeCellTuple N lo hi,
+        ((Real.exp (-G)*φ (Real.log n-G) : ℝ) : ℂ)*
+        (∏ i, (((Z i*((p i).val : ℝ))⁻¹ : ℝ) : ℂ))*
+        jointUnitTest (F (n : ZMod M)) (fun i => ((p i).val : ZMod M)) := by
+  simp only [mixedComplexTestSum, jointComplexTestSum, Finset.mul_sum, mul_assoc]
+
+theorem mixedComplexTestSum_eq_integer (NI : ℕ) (N : ι → ℕ) (M : ℕ) [NeZero M]
+    (loI hiI G : ℝ) (φ : ℝ → ℝ) (lo hi Z : ι → ℝ)
+    (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ) :
+    mixedComplexTestSum NI N M loI hiI G φ lo hi Z F =
+      ∑ r : ZMod M, (IntegerCell.integerResidueMass NI M r loI hiI G φ : ℂ)*
+        jointComplexTestSum N M lo hi Z (F r) := by
+  exact IntegerCell.complexTestSum_eq NI M loI hiI G φ
+    (fun r => jointComplexTestSum N M lo hi Z (F r))
+
+theorem mixedComplexTestSum_eq (NI : ℕ) (N : ι → ℕ) (M : ℕ) [NeZero M]
+    (loI hiI G : ℝ) (φ : ℝ → ℝ) (lo hi Z : ι → ℝ)
+    (F : ZMod M → (ι → (ZMod M)ˣ) → ℂ) :
+    mixedComplexTestSum NI N M loI hiI G φ lo hi Z F =
+      ∑ r : ZMod M, ∑ u : ι → (ZMod M)ˣ,
+        (IntegerCell.integerResidueMass NI M r loI hiI G φ : ℂ)*
+        (∏ i, (residueMass (N i) M (u i) (lo i) (hi i) (Z i) : ℂ))*F r u := by
+  rw [mixedComplexTestSum_eq_integer]
+  simp only [jointComplexTestSum_eq, Finset.mul_sum, mul_assoc]
+
+end Ostmann.Arithmetic.MixedCellJointReplacement
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MonomialDenominators.lean

@@ -0,0 +1,48 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.HistoryFieldEvaluation
+import OAI.NumberTheory.Ostmann.Characters.RationalHistoryVariables
+
+namespace OAI
+
+noncomputable section
+namespace Ostmann.Arithmetic.MonomialDenominators
+open MvPolynomial
+
+variable {ι : Type*}
+
+inductive Generated (S : Set ℤ) : MvPolynomial ι ℤ → Prop
+  | one : Generated S 1
+  | constant (c : ℤ) (hc : c ∈ S) : Generated S (C c)
+  | var (i : ι) : Generated S (X i)
+  | mul {P Q : MvPolynomial ι ℤ} : Generated S P → Generated S Q → Generated S (P*Q)
+
+theorem Generated.exists_monomial {S : Set ℤ} {P : MvPolynomial ι ℤ}
+    (hP : Generated S P) {K : Type*} [Field K]
+    (hS : ∀ c ∈ S, (c:K) ≠ 0) :
+    ∃ (d : ι →₀ ℕ) (c : ℤ), P = monomial d c ∧ (c:K) ≠ 0 := by
+  classical
+  induction hP with
+  | one => exact ⟨0,1,by simp,by simp⟩
+  | constant c hc => exact ⟨0,c,rfl,hS c hc⟩
+  | var i => exact ⟨Finsupp.single i 1,1,rfl,by simp⟩
+  | @mul P Q hP hQ ihP ihQ =>
+      obtain ⟨d,c,rfl,hc⟩ := ihP
+      obtain ⟨e,b,rfl,hb⟩ := ihQ
+      exact ⟨d+e,c*b,by rw [monomial_mul_monomial],by simpa only [Int.cast_mul] using mul_ne_zero hc hb⟩
+
+theorem Generated.eval₂_ne_zero {S : Set ℤ} {P : MvPolynomial ι ℤ}
+    (hP : Generated S P) {K : Type*} [Field K] [DecidableEq ι]
+    (hS : ∀ c ∈ S, (c:K) ≠ 0) (x : ι → K)
+    (hx : ∀ i ∈ P.vars, x i ≠ 0) : eval₂ (Int.castRingHom K) x P ≠ 0 := by
+  obtain ⟨d,c,rfl,hc⟩ := hP.exists_monomial hS
+  have hcZ : c ≠ 0 := by intro h; exact hc (by simp [h])
+  rw [vars_monomial hcZ] at hx
+  rw [eval₂_monomial]
+  apply mul_ne_zero hc
+  change (∏ i ∈ d.support, x i ^ d i) ≠ 0
+  exact Finset.prod_ne_zero_iff.mpr (fun i hi => pow_ne_zero _ (hx i hi))
+
+end Ostmann.Arithmetic.MonomialDenominators
+
+end
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingActualLineComparison.lean

@@ -0,0 +1,86 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingSampledIndexedProbability
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingLineProductComparison
+
+namespace OAI
+
+/-! # Symbolic replacement for the actual two-history internal line factors -/
+
+namespace Ostmann
+open scoped Classical BigOperators
+
+theorem moving_actual_line_product_comparison {A J : Type*}
+    [Fintype A] [Nonempty A] [Fintype J] {N n : ℕ}
+    (prime : A → ℕ) (hpInj : Function.Injective prime) (hprime : ∀ a, (prime a).Prime)
+    (T : Bool → MovingSlotData (Fin (N + 1)) n) (tier : Fin (N + 1) → ℕ)
+    (hlevels : ∀ side, (T side).Levels tier)
+    (rep : J → Fin (N + 1)) (base : ∀ j, MovingPairRepresentativeOccurrences T (rep j))
+    (d : ℕ) (F U : ℝ) (hF : 1 ≤ F) (hU : 1 ≤ U)
+    (hsize : ∀ side, (T side).SizeLE d)
+    (hfreq : ∀ side, (T side).Frequencies (fun s => |(s : ℝ)| ≤ F))
+    (hvalues : ∀ a, |((prime a : ℤ) : ℝ)| ≤ U)
+    (μ : Fin (N + 1) → A → ℝ) (hμ : ∀ i a, 0 ≤ μ i a)
+    (hmass : ∀ i, ∑ a, μ i a = 1)
+    (α β V : ℝ) (hα : 0 ≤ α) (hβ : 0 ≤ β) (hV : 0 < V)
+    (hmax : ∀ i a, μ i a ≤ α) (hpmax : ∀ j a, μ (rep j) a ≤ β)
+    (hprimeSize : ∀ j a, μ (rep j) a ≠ 0 → V ≤ Real.log (prime a : ℝ))
+    (weight : (Fin (N + 1) → A) → ℂ) (B : ℝ) (hB : 0 ≤ B)
+    (hweight : ∀ x, ‖weight x‖ * ∏ j, internalLineScalar true (prime (x (rep j))) ≤ B)
+    (hdisjoint : ∀ x, weight x ≠ 0 → ∀ i j,
+      tier i ≠ tier j → prime (x i) ≠ prime (x j))
+    (hunique : ∀ x, weight x ≠ 0 → ∀ j i, prime (x i) = prime (x (rep j)) → i = rep j)
+    (hfmod : ∀ x, weight x ≠ 0 → ∀ j side,
+      (T side).Frequencies (fun s => (s : ZMod (prime (x (rep j)))) ≠ 0)) :
+    ‖∑ x, (productPrior μ x : ℂ) * weight x *
+      ((∏ j, (movingSampledInternalProbability prime hprime T x (rep j) : ℂ)) -
+       ∏ j, (internalLineFlagWeight true (prime (x (rep j)))
+         (fun s => arithmeticTestFlag (lineTestPolynomials
+           (movingIndexedLine T (rep j) (base j)) ⟨(base j).1, (base j).2.val⟩ s = 0)) : ℂ))‖ ≤
+      2 * B * (Fintype.card J * (2 + Fintype.card (MovingPairOccurrenceIndex T))) *
+        ((2 * ((n + 1) * d) : ℕ) * α +
+          (Real.log (2 * ((2 * (F * U ^ d)) ^ (n + 1)) ^ 2) / V) * β) := by
+  let path := fun j o => (movingIndexedOccurrence T (rep j) (base j) o).path
+  let current := fun j o => (movingIndexedOccurrence T (rep j) (base j) o).current
+  let b : J → MovingPairOccurrenceIndex T := fun j => ⟨(base j).1, (base j).2.val⟩
+  have hi : Function.Injective (fun a => (prime a : ℤ)) := by
+    intro a b h
+    apply hpInj
+    exact Int.ofNat.inj h
+  have hu (x : Fin (N + 1) → A) (hx : weight x ≠ 0) (j : J) (o : MovingPairOccurrenceIndex T) :=
+    movingIndexedOccurrence_units T tier (fun i => prime (x i)) (fun i => hprime (x i))
+      (hdisjoint x hx) hlevels (rep j) (base j) (hfmod x hx j) o
+  have h := moving_slot_line_product_comparison (fun a => (prime a : ℤ)) hi prime hpInj hprime
+    path current b rep (fun _ => true) n d F U hF hU
+    (fun j o => movingIndexedOccurrence_path_length T tier hlevels (rep j) (base j) o)
+    (fun j o => movingIndexedOccurrence_size T d F hsize hfreq (rep j) (base j) o)
+    (fun j o => movingIndexedOccurrence_absent T tier hlevels (rep j) (base j) o)
+    hvalues μ hμ hmass α β V hα hβ hV hmax hpmax hprimeSize weight B hB hweight
+    (by
+      intro x hx j o s hs
+      simpa only [integerLineReduction, MovingSlotReversal.naturalReduction, Int.cast_natCast] using
+        (hu x hx j o).1 s hs)
+    (by
+      intro x hx j
+      simpa only [integerLineReduction, MovingSlotReversal.naturalReduction, Int.cast_natCast] using
+        (hu x hx j (b j)).2)
+  have he (x : Fin (N + 1) → A) :
+      weight x * (∏ j, (movingSampledInternalProbability prime hprime T x (rep j) : ℂ)) =
+      weight x * ∏ j, (movingSlotLineProbability (fun a => (prime a : ℤ)) prime hprime
+        (path j) (current j) true x (x (rep j)) : ℂ) := by
+    by_cases hx : weight x = 0
+    · simp only [hx, zero_mul]
+    · congr 1
+      apply Finset.prod_congr rfl
+      intro j _
+      exact congrArg (fun r : ℝ => (r : ℂ))
+        (movingSampledIndexedProbability prime hprime x T tier (hdisjoint x hx) hlevels
+          (rep j) (base j) (hunique x hx j) (hfmod x hx j))
+  convert h using 1
+  congr 1
+  apply Finset.sum_congr rfl
+  intro x _
+  rw [mul_assoc, mul_sub, he, ← mul_sub, ← mul_assoc]
+  rfl
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAdaptiveSupport.lean

@@ -0,0 +1,106 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingNodeUnits
+import OAI.NumberTheory.Ostmann.Construction.CompensatedAdaptiveSupport
+import OAI.NumberTheory.Ostmann.Arithmetic.ForwardHistorySupport
+
+namespace OAI
+
+/-! # Constructed adaptive support for the original moving-giant sampler -/
+
+namespace Ostmann
+open scoped Classical
+
+noncomputable def movingSampledPivotHistory {σ : Type*} (value : σ → ℕ)
+    (childBound pivotBound : ℕ → ℕ) (n Q : ℕ) (t : FrequencyTree ℤ n)
+    (small bulk : TreeLeafTuple (List σ) n) (a : MovingSampleSlots σ n) (XL XR : ℕ)
+    (y : TreeLeafTuple (ZMod Q)ˣ n)
+    (hy : treeIntegerResidues Q n
+      (treeLeafMap (fun q : ℕ => (q : ℤ)) n (movingSlotValues value n bulk)) y) :
+    SampledPivotHistory n Q where
+  bulk := treeLeafMap (fun q : ℕ => (q : ℤ)) n (movingSlotValues value n bulk)
+  residue := y
+  pivots := movingGiantArray value childBound pivotBound n
+    ⟨n, buildMovingSlotData n t small bulk a, XL, XR⟩ t
+  compatible := hy
+
+theorem movingSampledPivotHistory_valid {σ : Type*} (value : σ → ℕ)
+    (outside : List ℕ) (childBound pivotBound : ℕ → ℕ)
+    (F : MovingSlotState σ → ℤ → ℂ) (E : MovingSlotState σ → ℤ → ℤ → ℤ → ℝ)
+    (S : Finset ℤ) (n Q : ℕ) (t : FrequencyTree S n)
+    (small bulk : TreeLeafTuple (List σ) n) (a : MovingSampleSlots σ n) (XL XR : ℕ)
+    (y : TreeLeafTuple (ZMod Q)ˣ n)
+    (hy : treeIntegerResidues Q n
+      (treeLeafMap (fun q : ℕ => (q : ℤ)) n (movingSlotValues value n bulk)) y)
+    (hsmall : ∀ i s, s ∈ S → IsCoprime (value i : ℤ) s)
+    (hw : recursiveTransferWeight (movingSlotSystem value childBound pivotBound) F
+      (movingSlotCutoff value childBound pivotBound (movingGuardedExtra value outside E)) n
+      ⟨n, buildMovingSlotData n (frequencyTreeMap Subtype.val n t) small bulk a, XL, XR⟩
+      (frequencyTreeMap Subtype.val n t) ≠ 0) :
+    (movingSampledPivotHistory value childBound pivotBound n Q
+      (frequencyTreeMap Subtype.val n t) small bulk a XL XR y hy).compensatedValid
+        (movingSampleAncestorScheme value S n t small a XL XR)
+        (movingSampleCompensation value n small a) := by
+  exact ⟨movingSample_compensatedEquations value childBound pivotBound F
+    (movingGuardedExtra value outside E) S n t small bulk a XL XR hw,
+    movingSample_coefficient_units value outside childBound pivotBound F E S n t
+      small bulk a XL XR hsmall hw⟩
+
+theorem movingFrameConstants_compensation_coprime {σ : Type*} (value : σ → ℕ)
+    (R : ℤ) (hsmall : ∀ i, IsCoprime (value i : ℤ) R) (n : ℕ)
+    (small : TreeLeafTuple (List σ) n) (a : MovingSampleSlots σ n) (path : List Bool) :
+    IsCoprime ((movingFrameConstants value n small a path).compensation : ℤ) R := by
+  induction n generalizing path with
+  | zero =>
+    cases a
+    change IsCoprime (1 : ℤ) R
+    exact isCoprime_one_left
+  | succ n ih =>
+    cases a with
+    | node a l r =>
+      cases path with
+      | nil => exact movingNaturalProduct_coprime value _ R (fun i _ => hsmall i)
+      | cons b path => cases b <;> apply ih
+
+/-- The prefix tests are built from actual samples and are passed by every
+nonzero original history. There is no assumed adaptive-support event. -/
+theorem movingSample_adaptive_support {σ : Type*} (value : σ → ℕ)
+    (outside : List ℕ) (childBound pivotBound : ℕ → ℕ)
+    (F : MovingSlotState σ → ℤ → ℂ) (E : MovingSlotState σ → ℤ → ℤ → ℤ → ℝ)
+    (S : Finset ℤ) (n R : ℕ) [NeZero (R ^ (n + 2))] (t : FrequencyTree S n)
+    (hS : ∀ s ∈ S, s ≠ 0 ∧ s.natAbs ∣ R)
+    (small bulk : TreeLeafTuple (List σ) n) (a : MovingSampleSlots σ n) (XL XR : ℕ)
+    (hsmall : ∀ i, IsCoprime (value i : ℤ) (R : ℤ))
+    (y : TreeLeafTuple (ZMod (R ^ (n + 2)))ˣ n)
+    (hy : treeIntegerResidues (R ^ (n + 2)) n
+      (treeLeafMap (fun q : ℕ => (q : ℤ)) n (movingSlotValues value n bulk)) y)
+    (hw : recursiveTransferWeight (movingSlotSystem value childBound pivotBound) F
+      (movingSlotCutoff value childBound pivotBound (movingGuardedExtra value outside E)) n
+      ⟨n, buildMovingSlotData n (frequencyTreeMap Subtype.val n t) small bulk a, XL, XR⟩
+      (frequencyTreeMap Subtype.val n t) ≠ 0) :
+    let D := movingSampleAncestorScheme value S n t small a XL XR
+    let hs : ∀ i, (D.frequencies i).root ≠ 0 :=
+      fun i => (hS _ (singleTreeNodeFrequencies_root_mem S n t i.val i.isLt)).1
+    let hsR : ∀ i, (D.frequencies i).root.natAbs ∣ R :=
+      fun i => (hS _ (singleTreeNodeFrequencies_root_mem S n t i.val i.isLt)).2
+    singleArithmeticLeafSupport n
+      (compensatedAdaptiveData n R n D (movingSampleCompensation value n small a) hs hsR) y = 1 := by
+  dsimp only
+  let hist := movingSampledPivotHistory value childBound pivotBound n (R ^ (n + 2))
+    (frequencyTreeMap Subtype.val n t) small bulk a XL XR y hy
+  have hs : ∀ i s, s ∈ S → IsCoprime (value i : ℤ) s := by
+    intro i s hmem
+    exact (hsmall i).of_isCoprime_of_dvd_right
+      (Int.natAbs_dvd.mp (Int.natCast_dvd_natCast.mpr (hS s hmem).2))
+  apply compensatedAdaptiveData_actual_support n R n
+    (movingSampleAncestorScheme value S n t small a XL XR)
+    (movingSampleCompensation value n small a)
+    (fun i => movingFrameConstants_compensation_coprime value R hsmall n small a _)
+    (fun i => (preorderNodePath_length n i).le)
+    (fun i => (hS _ (singleTreeNodeFrequencies_root_mem S n t i.val i.isLt)).1)
+    (fun i => (hS _ (singleTreeNodeFrequencies_root_mem S n t i.val i.isLt)).2)
+    hist
+  exact movingSampledPivotHistory_valid value outside childBound pivotBound F E S n _ t
+    small bulk a XL XR y hy hs hw
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAlphabetRestriction.lean

@@ -0,0 +1,85 @@
+import OAI.NumberTheory.Ostmann.Construction.SupportedAlphabetSum
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingOriginalWeightRelabel
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingFrequencyCoefficient
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingTemplateCoefficient
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingPatternTree
+
+namespace OAI
+
+/-! # The original moving sampler on a smaller live alphabet -/
+namespace Ostmann
+open scoped Classical BigOperators SchwartzMap
+
+theorem movingCompensationExtra_map {A B : Type*} (e : B → A) (value : A → ℕ)
+    {n : ℕ} (T : MovingSlotData B n) (s v w : ℤ) :
+    movingCompensationExtra value (T.map e) s v w =
+      movingCompensationExtra (value ∘ e) T s v w := by
+  cases T <;> simp only [MovingSlotData.map, movingCompensationExtra,
+    MovingSlotReversal.naturalProduct_map]
+
+theorem movingOriginalSampleAverage_alphabet {A B I : Type} [Fintype A] [Fintype B]
+    (e : B ↪ A) (q : I → ℕ) [∀ i, Fact (q i).Prime]
+    (value : A → ℕ) (outside : List ℕ) (μ : ℕ → A → ℝ)
+    (childBound pivotBound : ℕ → ℕ)
+    (F : {n : ℕ} → MovingSlotData A n → ℤ → ℂ)
+    (g : ∀ i, ZMod (q i) → ℂ) (Dq : ∀ i, (ZMod (q i))ˣ) (S : Finset I)
+    (ψ : 𝓢(ℝ, ℂ)) (X lo hi : ℝ) (φ : ℝ → ℝ) (G : ℕ → ℝ)
+    (n : ℕ) (t : FrequencyTree ℤ n) (small bulk : TreeLeafTuple (List B) n)
+    (XL XR : ℕ) (hμ : ∀ j a, j < n → μ j a ≠ 0 → a ∈ Set.range e) :
+    movingOriginalSampleAverage q value outside μ childBound pivotBound F g Dq S ψ X lo hi φ G
+      n t (treeLeafMap (List.map e) n small) (treeLeafMap (List.map e) n bulk) XL XR =
+    movingOriginalSampleAverage q (value ∘ e) outside (fun j b => μ j (e b)) childBound pivotBound
+      (fun T => F (T.map e)) g Dq S ψ X lo hi φ G n t small bulk XL XR := by
+  unfold movingOriginalSampleAverage
+  rw [movingSamplesPrior_alphabet_sum e μ n _ hμ]
+  apply Finset.sum_congr rfl
+  intro a _
+  congr 1
+  rw [← buildMovingSlotData_map, movingOriginalGiantWeight_map, movingSupportedWeight_map]
+  congr 2
+  funext d T s v w
+  exact movingCompensationExtra_map e value T s v w
+
+theorem movingFrequencyCoefficient_original_alphabet {A B I : Type} [Fintype A] [Fintype B]
+    (e : B ↪ A) (q : I → ℕ) [∀ i, Fact (q i).Prime]
+    (value : A → ℕ) (outside : List ℕ) (μ : ℕ → A → ℝ)
+    (childBound pivotBound V : ℕ → ℕ)
+    (F : {n : ℕ} → MovingSlotData A n → ℤ → ℂ)
+    (g : ∀ i, ZMod (q i) → ℂ) (Dq : ∀ i, (ZMod (q i))ˣ) (S : Finset I)
+    (ψ : 𝓢(ℝ, ℂ)) (X lo hi : ℝ) (φ : ℝ → ℝ) (G : ℕ → ℝ)
+    (n : ℕ) (s : ℤ) (small bulk : TreeLeafTuple (List B) n)
+    (XL XR : ℕ) (hμ : ∀ j a, j < n → μ j a ≠ 0 → a ∈ Set.range e) :
+    movingFrequencyCoefficient value outside μ childBound pivotBound V
+      (movingOriginalLeaf value q F g Dq S ψ X lo hi) φ G n s
+      (treeLeafMap (List.map e) n small) (treeLeafMap (List.map e) n bulk) XL XR =
+    movingFrequencyCoefficient (value ∘ e) outside (fun j b => μ j (e b)) childBound pivotBound V
+      (movingOriginalLeaf (value ∘ e) q (fun T => F (T.map e)) g Dq S ψ X lo hi)
+      φ G n s small bulk XL XR := by
+  simp only [movingFrequencyCoefficient_original]
+  apply Finset.sum_congr rfl
+  intro t _
+  exact movingOriginalSampleAverage_alphabet e q value outside μ childBound pivotBound F g Dq S
+    ψ X lo hi φ G n _ small bulk XL XR hμ
+
+theorem movingTemplateCoefficient_original_alphabet {A B I : Type} [Fintype A] [Fintype B]
+    (e : B ↪ A) (q : I → ℕ) [∀ i, Fact (q i).Prime]
+    (value : A → ℕ) (outside : List ℕ) (μ : ℕ → A → ℝ)
+    (childBound pivotBound V : ℕ → ℕ)
+    (F : {n : ℕ} → MovingSlotData A n → ℤ → ℂ)
+    (g : ∀ i, ZMod (q i) → ℂ) (Dq : ∀ i, (ZMod (q i))ˣ) (S : Finset I)
+    (ψ : 𝓢(ℝ, ℂ)) (X lo hi : ℝ) (φ : ℝ → ℝ) (G : ℕ → ℝ)
+    (n r m : ℕ) (s : ℤ) (y : MovingRegularSlot n r m → B)
+    (XL XR : ℕ) (hμ : ∀ j a, j < n → μ j a ≠ 0 → a ∈ Set.range e) :
+    movingTemplateCoefficient value outside μ childBound pivotBound V
+      (movingOriginalLeaf value q F g Dq S ψ X lo hi) φ G n r m s (e ∘ y) XL XR =
+    movingTemplateCoefficient (value ∘ e) outside (fun j b => μ j (e b)) childBound pivotBound V
+      (movingOriginalLeaf (value ∘ e) q (fun T => F (T.map e)) g Dq S ψ X lo hi)
+      φ G n r m s y XL XR := by
+  unfold movingTemplateCoefficient
+  rw [← treeLeafMap_list_comp, ← treeLeafMap_list_comp]
+  exact movingFrequencyCoefficient_original_alphabet e q value outside μ childBound pivotBound V F
+    g Dq S ψ X lo hi φ G n s _ _ XL XR hμ
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAmplitudeAlphabet.lean

@@ -0,0 +1,53 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingAlphabetRestriction
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingTemplateAmplitude
+
+namespace OAI
+
+/-! # The literal prime amplitude is unchanged by restricting live regular primes -/
+namespace Ostmann
+open scoped Classical BigOperators SchwartzMap
+
+theorem movingTemplatePrimeAmplitude_original_alphabet {A B I : Type}
+    [Fintype A] [Fintype B]
+    (e : B ↪ A) (q : I → ℕ) [∀ i, Fact (q i).Prime]
+    (value : A → ℕ) (outside : List ℕ) (μ : ℕ → A → ℝ)
+    (childBound pivotBound V : ℕ → ℕ)
+    (F : {n : ℕ} → MovingSlotData A n → ℤ → ℂ)
+    (g : ∀ i, ZMod (q i) → ℂ) (Dq : ∀ i, (ZMod (q i))ˣ) (S : Finset I)
+    (ψ : 𝓢(ℝ, ℂ)) (X lo hi : ℝ) (φ : ℝ → ℝ) (G : ℕ → ℝ)
+    (n r m : ℕ) (Pg : Finset ℕ) (ρ : Pg → ℝ)
+    (ν : MovingRegularSlot n r m → A → ℝ)
+    (hμ : ∀ j a, j < n → μ j a ≠ 0 → a ∈ Set.range e)
+    (hν : ∀ i a, ν i a ≠ 0 → a ∈ Set.range e)
+    (greg ggiant : ∀ p : ℕ, ZMod p → ℂ) (favorable : ℕ → Bool) :
+    movingTemplatePrimeAmplitude value outside μ childBound pivotBound V
+      (movingOriginalLeaf value q F g Dq S ψ X lo hi) φ G n r m Pg ρ ν greg ggiant favorable =
+    movingTemplatePrimeAmplitude (value ∘ e) outside (fun j b => μ j (e b)) childBound pivotBound V
+      (movingOriginalLeaf (value ∘ e) q (fun T => F (T.map e)) g Dq S ψ X lo hi)
+      φ G n r m Pg ρ (fun i b => ν i (e b)) greg ggiant favorable := by
+  unfold movingTemplatePrimeAmplitude
+  apply Finset.sum_congr rfl
+  intro XL _
+  congr 1
+  apply Finset.sum_congr rfl
+  intro XR _
+  congr 1
+  apply Finset.sum_congr rfl
+  intro s _
+  have he := productPrior_alphabet_sum e ν (fun y =>
+    movingTemplateCoefficient value outside μ childBound pivotBound V
+      (movingOriginalLeaf value q F g Dq S ψ X lo hi) φ G n r m s.val y XL XR *
+    movingTaggedTransform
+      (Sum.elim (fun b : Bool => if b then (XL : ℕ) else (XR : ℕ)) (value ∘ y))
+      (Sum.elim (fun _ => true) (fun _ => false)) greg ggiant favorable outside.prod s.val) hν
+  simp only [finite_univ_canonical] at he ⊢
+  rw [he]
+  apply Finset.sum_congr rfl
+  intro y _
+  rw [movingTemplateCoefficient_original_alphabet e q value outside μ childBound pivotBound V
+    F g Dq S ψ X lo hi φ G n r m s.val y XL XR hμ]
+  rfl
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAmplitudeCoefficientSupport.lean

@@ -0,0 +1,339 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingNodeCoefficientSupport
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingConstructedLiveProductStep
+
+namespace OAI
+
+/-! # The full moving transfer with separation on its actual coefficient support -/
+namespace Ostmann
+open scoped Classical BigOperators ComplexConjugate
+
+private theorem coefficient_amplitude_pair_sum {A B C : Type} [Fintype A] [Fintype B] [Fintype C]
+    (ρ : A → ℝ) (ν : B → ℝ) (F : A → A → B → B → C → C → ℂ) :
+    (∑ a : A × (B × C), ∑ b : A × (B × C),
+      ((ρ a.1 * ν a.2.1 : ℝ) : ℂ) * ((ρ b.1 * ν b.2.1 : ℝ) : ℂ) *
+        F a.1 b.1 a.2.1 b.2.1 a.2.2 b.2.2) =
+      ∑ x, (ρ x : ℂ) * ∑ z, (ρ z : ℂ) *
+        ∑ y, (ν y : ℂ) * ∑ t, (ν t : ℂ) * ∑ v, ∑ w, F x z y t v w := by
+  simp only [Fintype.sum_prod_type, Finset.mul_sum, Complex.ofReal_mul]
+  conv_lhs =>
+    arg 2
+    ext x
+    arg 2
+    ext y
+    rw [Finset.sum_comm]
+  conv_lhs =>
+    arg 2
+    ext x
+    rw [Finset.sum_comm]
+  conv_lhs =>
+    arg 2
+    ext x
+    arg 2
+    ext z
+    arg 2
+    ext y
+    rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro x _
+  apply Finset.sum_congr rfl
+  intro z _
+  apply Finset.sum_congr rfl
+  intro y _
+  apply Finset.sum_congr rfl
+  intro t _
+  apply Finset.sum_congr rfl
+  intro v _
+  apply Finset.sum_congr rfl
+  intro w _
+  ring
+
+private theorem coefficient_amplitude_full_sum {U S A B C : Type}
+    [Fintype U] [Fintype S] [Fintype A] [Fintype B] [Fintype C]
+    (M : U → ℂ) (ρ : A → ℝ) (ν : B → ℝ)
+    (F : U → S → A → A → B → B → C → C → ℂ) :
+    (∑ u, M u * ∑ s, ∑ a : A × (B × C), ∑ b : A × (B × C),
+      ((ρ a.1 * ν a.2.1 : ℝ) : ℂ) * ((ρ b.1 * ν b.2.1 : ℝ) : ℂ) *
+        F u s a.1 b.1 a.2.1 b.2.1 a.2.2 b.2.2) =
+    ∑ XL, (ρ XL : ℂ) * ∑ XR, (ρ XR : ℂ) * ∑ s, ∑ u, M u *
+      ∑ left, (ν left : ℂ) * ∑ right, (ν right : ℂ) * ∑ v, ∑ w,
+        F u s XL XR left right v w := by
+  simp_rw [coefficient_amplitude_pair_sum]
+  simp only [Finset.mul_sum]
+  conv_lhs =>
+    arg 2
+    ext u
+    rw [Finset.sum_comm]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro XL _
+  conv_lhs =>
+    arg 2
+    ext u
+    rw [Finset.sum_comm]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro XR _
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro s _
+  apply Finset.sum_congr rfl
+  intro u _
+  apply Finset.sum_congr rfl
+  intro left _
+  apply Finset.sum_congr rfl
+  intro right _
+  apply Finset.sum_congr rfl
+  intro v _
+  apply Finset.sum_congr rfl
+  intro w _
+  ring
+
+theorem movingAmplitudeOffDiagonal_eq_next_on_coefficients {σ : Type} [Fintype σ]
+    (value : σ → ℕ) (hvalue : ∀ a, (value a).Prime) (outside : List ℕ)
+    (μ : ℕ → σ → ℝ) (childBound pivotBound V : ℕ → ℕ) (hV : Monotone V)
+    (F : MovingSlotState σ → ℤ → ℂ) (hF : ∀ x, F x 0 = 0)
+    (φ : ℝ → ℝ) (G : ℕ → ℝ) (n r m : ℕ)
+    (Pg : Finset ℕ) (hPg : ∀ q ∈ Pg, q.Prime) (ρ : Pg → ℝ)
+    (ν : MovingRegularSlot n r m → σ → ℝ)
+    (hlarge : ∀ q : Pg, V (n + 1) < (q : ℕ))
+    (I : Finset ℕ) (hI : ∀ p ∈ I, 0 < p)
+    (hφ : ∀ p : ℕ, 0 < p → φ (Real.log p - G (n + 1)) ≠ 0 → p ∈ I)
+    (hchild : V n ≤ childBound (n + 1))
+    (hgap : ∀ XR : Pg, ∀ right : MovingRegularSlot n r m → σ, (∏ i, ν i (right i)) ≠ 0 →
+      ∀ (u : TreeLeafIndex n × Fin 4 → σ), (∏ i, μ n (u i)) ≠ 0 →
+      ∀ (p : ℕ) (w : ℤ),
+      movingTemplateCoefficient value outside μ childBound pivotBound V F φ G n (4 + r) m w
+        (movingRestoreSample n r m u right) p XR ≠ 0 →
+      2 * pivotBound (n + 1) * childBound (n + 1) < (XR : ℕ) * ∏ i, value (right i))
+    (hRH : ∀ XR : Pg, ∀ right : MovingRegularSlot n r m → σ, (∏ i, ν i (right i)) ≠ 0 →
+      ∀ q, q.Prime → q ∣ (XR : ℕ) * (∏ i, value (right i)) → V (n + 1) < q)
+    (hcomp : ∀ u : TreeLeafIndex n × Fin 4 → σ, (∏ i, μ n (u i)) ≠ 0 →
+      (∀ p ∈ I, p * (∏ i, value (u i)) ≤ pivotBound (n + 1)) ∧
+      (∀ q, q.Prime → q ∣ ∏ i, value (u i) → childBound (n + 1) < q))
+    (greg ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool) :
+    movingAmplitudeOffDiagonal value outside μ childBound pivotBound V F φ G n r m Pg I
+      ρ ν greg ggiant favorable =
+    movingTemplatePrimeAmplitude value outside μ childBound pivotBound V F φ G (n + 1) r m
+      Pg ρ (movingTemplateDoubledPrior n r m ν) greg ggiant favorable := by
+  rw [movingTemplatePrimeAmplitude_next_on_coefficients value hvalue outside μ childBound pivotBound V hV
+    F hF φ G n r m Pg hPg ρ (movingTemplateDoubledPrior n r m ν) hlarge I hI hφ hchild
+    (by simpa only [movingTemplateDoubledPrior_side] using hgap)
+    (by simpa only [movingTemplateDoubledPrior_side] using hRH) hcomp]
+  simp only [movingTemplateDoubledPrior_side]
+  unfold movingAmplitudeOffDiagonal
+  dsimp only [movingAmplitudePrior]
+  have hr := coefficient_amplitude_full_sum
+    (U := TreeLeafIndex n × Fin 4 → σ) (S := transferFrequencyRange (V (n + 1)))
+    (A := Pg) (B := MovingRegularSlot n r m → σ) (C := transferFrequencyRange (V n))
+    (fun u => (((∏ i, μ n (u i)) * (∏ i, value (u i) : ℕ) : ℝ) : ℂ))
+    ρ (fun y => ∏ i, ν i (y i))
+    (fun u s XL XR left right v w => movingTemplateIntegerFourierTerm value outside μ
+      childBound pivotBound V F φ G n r m I XL XR s.val left right greg ggiant favorable
+        u v.val w.val)
+  convert hr using 1
+  simp only [Nat.cast_prod]
+
+theorem movingTemplatePrimeAmplitude_step_on_coefficients {σ : Type} [Fintype σ]
+    (value : σ → ℕ) (hvalue : ∀ a, (value a).Prime)
+    (outside : List ℕ) (μ : ℕ → σ → ℝ)
+    (childBound pivotBound V : ℕ → ℕ) (hV : Monotone V)
+    (F : MovingSlotState σ → ℤ → ℂ) (hF : ∀ x, F x 0 = 0)
+    (φ : ℝ → ℝ) (G : ℕ → ℝ) (n r m : ℕ)
+    (Pg I : Finset ℕ) (hPg : ∀ p ∈ Pg, p.Prime) (hPI : Pg ⊆ I)
+    (hI : ∀ p ∈ I, 0 < p) (hφ : ∀ x, 0 ≤ φ x)
+    (hpos : 0 < smoothGiantMass Pg φ (G (n + 1)))
+    (hμ : ∀ a, 0 ≤ μ n a) (hμmass : ∑ a, μ n a = 1)
+    (ν : MovingRegularSlot n r m → σ → ℝ)
+    (sets : ∀ q : ℕ, Finset (ZMod q))
+    (hsets : ∀ a, (sets (value a)).Nonempty)
+    (hcard : ∀ a, (sets (value a)).card < value a)
+    (ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool)
+    (hgiant : ∀ q : Pg, ∀ x, ggiant q (-x) = conj (ggiant q x))
+    (H : ℕ)
+    (hH : ∀ (u : TreeLeafIndex n × Fin 4 → σ), (∏ i, μ n (u i)) ≠ 0 →
+      ∀ (p : ℕ), p ∈ I →
+      ∀ (q : Pg) (y : MovingRegularSlot n r m → σ) (s : transferFrequencyRange (V n)),
+      movingTemplateCoefficient value outside μ childBound pivotBound V F φ G
+        n (4 + r) m s.val (movingRestoreSample n r m u y) p q ≠ 0 →
+        (q : ℕ) * (∏ i, value (y i)) ≤ H)
+    (hscale : ∀ (u : TreeLeafIndex n × Fin 4 → σ), (∏ i, μ n (u i)) ≠ 0 → ∀ p ∈ I,
+      2 * V n * H ≤ V (n + 1) * (p * ∏ i, value (u i)))
+    (hlarge : ∀ (q : Pg) (y : MovingRegularSlot n r m → σ),
+      (∏ i, ν i (y i)) ≠ 0 → ∀ ℓ, ℓ.Prime → ℓ ∣ (q : ℕ) * (∏ i, value (y i)) → V (n + 1) < ℓ)
+    (hvg : ∀ q : Pg, V (n + 1) < (q : ℕ))
+    (hφsupport : ∀ p : ℕ, 0 < p → φ (Real.log p - G (n + 1)) ≠ 0 → p ∈ I)
+    (hchild : V n ≤ childBound (n + 1))
+    (hgap : ∀ XR : Pg, ∀ right : MovingRegularSlot n r m → σ, (∏ i, ν i (right i)) ≠ 0 →
+      ∀ (u : TreeLeafIndex n × Fin 4 → σ), (∏ i, μ n (u i)) ≠ 0 →
+      ∀ (p : ℕ) (w : ℤ),
+      movingTemplateCoefficient value outside μ childBound pivotBound V F φ G n (4 + r) m w
+        (movingRestoreSample n r m u right) p XR ≠ 0 →
+      2 * pivotBound (n + 1) * childBound (n + 1) < (XR : ℕ) * ∏ i, value (right i))
+    (hcomp : ∀ u : TreeLeafIndex n × Fin 4 → σ, (∏ i, μ n (u i)) ≠ 0 →
+      (∀ p ∈ I, p * (∏ i, value (u i)) ≤ pivotBound (n + 1)) ∧
+      (∀ q, q.Prime → q ∣ ∏ i, value (u i) → childBound (n + 1) < q)) :
+    let ρ := smoothGiantPrior Pg φ (G (n + 1))
+    let greg := normalizedResidueFamily sets
+    Real.exp (-smoothGiantLogNormalizer Pg φ (G (n + 1))) *
+      ‖movingTemplatePrimeAmplitude value outside μ childBound pivotBound V F φ G n (4 + r) m
+        Pg ρ (movingTemplateRestoredPrior n r m (μ n) ν) greg ggiant favorable‖ ^ 2 ≤
+      movingAmplitudeDiagonal value outside μ childBound pivotBound V F φ G n r m Pg I
+        ρ ν greg ggiant favorable +
+      ‖movingTemplatePrimeAmplitude value outside μ childBound pivotBound V F φ G (n + 1) r m
+        Pg ρ (movingTemplateDoubledPrior n r m ν) greg ggiant favorable‖ := by
+  intro ρ greg
+  have he := movingAmplitudeOffDiagonal_eq_next_on_coefficients value hvalue outside μ childBound pivotBound V
+    hV F hF φ G n r m Pg hPg ρ ν hvg I hI hφsupport hchild hgap
+    (fun XR right hr => hlarge XR right hr) hcomp greg ggiant favorable
+  rw [← he]
+  exact movingTemplatePrimeAmplitude_transfer_on_live value hvalue outside μ childBound pivotBound V F
+    φ G n r m Pg I hPg hPI hI hφ hpos hμ hμmass ν sets hsets hcard ggiant favorable
+    hgiant H hH hscale hlarge
+
+theorem movingTemplatePrimeAmplitude_step_of_live_coefficients {σ J : Type} [Fintype σ]
+    (value : σ → ℕ) (hvalue : ∀ a, (value a).Prime)
+    (outside : List ℕ) (μ : ℕ → σ → ℝ)
+    (childBound pivotBound V : ℕ → ℕ) (hV : Monotone V)
+    (q : J → ℕ) [∀ i, Fact (q i).Prime]
+    (F : {n : ℕ} → MovingSlotData σ n → ℤ → ℂ)
+    (hF : ∀ {n} (T : MovingSlotData σ n), F T 0 = 0)
+    (g : ∀ i, ZMod (q i) → ℂ) (Dq : ∀ i, (ZMod (q i))ˣ) (S : Finset J)
+    (ψ : SchwartzMap ℝ ℂ) (X lo hi W : ℝ) (hX : 0 < X)
+    (hwindow : X * hi ≤ Real.exp W)
+    (φ : ℝ → ℝ) (G c : ℕ → ℝ) (hout : ∀ t, 1 ≤ |t| → φ t = 0)
+    (hμlower : ∀ j x, μ j x ≠ 0 → Real.exp (c j - 1) ≤ (value x : ℝ))
+    (n r m : ℕ)
+    (Pg I : Finset ℕ) (hPg : ∀ p ∈ Pg, p.Prime) (hPI : Pg ⊆ I)
+    (hI : ∀ p ∈ I, 0 < p) (hφ : ∀ x, 0 ≤ φ x)
+    (hpos : 0 < smoothGiantMass Pg φ (G (n + 1)))
+    (hμ : ∀ a, 0 ≤ μ n a) (hμmass : ∑ a, μ n a = 1)
+    (ν : MovingRegularSlot n r m → σ → ℝ)
+    (sets : ∀ q : ℕ, Finset (ZMod q))
+    (hsets : ∀ a, (sets (value a)).Nonempty)
+    (hcard : ∀ a, (sets (value a)).card < value a)
+    (ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool)
+    (hgiant : ∀ q : Pg, ∀ x, ggiant q (-x) = conj (ggiant q x))
+    (H : ℕ)
+    (hcap : ⌈Real.exp (movingProductExponent (movingCellPivotExponent G c) W n -
+      movingCellPivotExponent G c n)⌉₊ ≤ H)
+    (hIlower : ∀ p ∈ I, Real.exp (G (n + 1) - 1) ≤ (p : ℝ))
+    (hscale : ∀ (u : TreeLeafIndex n × Fin 4 → σ), (∏ i, μ n (u i)) ≠ 0 → ∀ p ∈ I,
+      2 * V n * H ≤ V (n + 1) * (p * ∏ i, value (u i)))
+    (hlarge : ∀ (q : Pg) (y : MovingRegularSlot n r m → σ),
+      (∏ i, ν i (y i)) ≠ 0 → ∀ ℓ, ℓ.Prime → ℓ ∣ (q : ℕ) * (∏ i, value (y i)) → V (n + 1) < ℓ)
+    (hvg : ∀ q : Pg, V (n + 1) < (q : ℕ))
+    (hφsupport : ∀ p : ℕ, 0 < p → φ (Real.log p - G (n + 1)) ≠ 0 → p ∈ I)
+    (hchild : V n ≤ childBound (n + 1))
+    (hgap : ∀ XR : Pg, ∀ right : MovingRegularSlot n r m → σ, (∏ i, ν i (right i)) ≠ 0 →
+      ∀ (u : TreeLeafIndex n × Fin 4 → σ), (∏ i, μ n (u i)) ≠ 0 →
+      ∀ (p : ℕ) (w : ℤ),
+      movingTemplateCoefficient value outside μ childBound pivotBound V (movingOriginalLeaf value q F g Dq S ψ X lo hi) φ G n (4 + r) m w
+        (movingRestoreSample n r m u right) p XR ≠ 0 →
+      2 * pivotBound (n + 1) * childBound (n + 1) < (XR : ℕ) * ∏ i, value (right i))
+    (hcomp : ∀ u : TreeLeafIndex n × Fin 4 → σ, (∏ i, μ n (u i)) ≠ 0 →
+      (∀ p ∈ I, p * (∏ i, value (u i)) ≤ pivotBound (n + 1)) ∧
+      (∀ q, q.Prime → q ∣ ∏ i, value (u i) → childBound (n + 1) < q)) :
+    let ρ := smoothGiantPrior Pg φ (G (n + 1))
+    let greg := normalizedResidueFamily sets
+    Real.exp (-smoothGiantLogNormalizer Pg φ (G (n + 1))) *
+      ‖movingTemplatePrimeAmplitude value outside μ childBound pivotBound V
+        (movingOriginalLeaf value q F g Dq S ψ X lo hi) φ G n (4 + r) m
+        Pg ρ (movingTemplateRestoredPrior n r m (μ n) ν) greg ggiant favorable‖ ^ 2 ≤
+      movingAmplitudeDiagonal value outside μ childBound pivotBound V
+        (movingOriginalLeaf value q F g Dq S ψ X lo hi) φ G n r m Pg I
+        ρ ν greg ggiant favorable +
+      ‖movingTemplatePrimeAmplitude value outside μ childBound pivotBound V
+        (movingOriginalLeaf value q F g Dq S ψ X lo hi) φ G (n + 1) r m
+        Pg ρ (movingTemplateDoubledPrior n r m ν) greg ggiant favorable‖ := by
+  let F₀ := movingOriginalLeaf value q F g Dq S ψ X lo hi
+  have hzero : ∀ x, F₀ x 0 = 0 :=
+    movingOriginalLeaf_zero value q F hF g Dq S ψ X lo hi
+  have hH (u : TreeLeafIndex n × Fin 4 → σ) (hu : (∏ i, μ n (u i)) ≠ 0)
+      (p : ℕ) (hp : p ∈ I) (q' : Pg) (y : MovingRegularSlot n r m → σ)
+      (s : transferFrequencyRange (V n))
+      (hc : movingTemplateCoefficient value outside μ childBound pivotBound V F₀ φ G
+        n (4 + r) m s.val (movingRestoreSample n r m u y) p q' ≠ 0) :
+      (q' : ℕ) * (∏ i, value (y i)) ≤ H :=
+    (movingTemplateCoefficient_recursive_cell_cap value outside μ childBound pivotBound V
+      q F g Dq S ψ X lo hi W hX hwindow φ G c hout hμlower n r m u hu
+      s.val y p q' (hIlower p hp) hc).trans hcap
+  exact movingTemplatePrimeAmplitude_step_on_coefficients value hvalue outside μ childBound pivotBound V
+    hV F₀ hzero φ G n r m Pg I hPg hPI hI hφ hpos hμ hμmass ν sets hsets hcard
+    ggiant favorable hgiant H hH hscale hlarge hvg hφsupport hchild hgap hcomp
+
+theorem movingTemplatePrimeAmplitude_step_constructed_coefficients {σ J : Type} [Fintype σ]
+    (value : σ → ℕ) (hvalue : ∀ a, (value a).Prime)
+    (outside : List ℕ) (μ : ℕ → σ → ℝ)
+    (childBound pivotBound V : ℕ → ℕ)
+    (q : J → ℕ) [∀ i, Fact (q i).Prime]
+    (F : {n : ℕ} → MovingSlotData σ n → ℤ → ℂ)
+    (hF : ∀ {n} (T : MovingSlotData σ n), F T 0 = 0)
+    (g : ∀ i, ZMod (q i) → ℂ) (Dq : ∀ i, (ZMod (q i))ˣ) (S : Finset J)
+    (ψ : SchwartzMap ℝ ℂ) (X lo hi W : ℝ) (hX : 0 < X)
+    (hwindow : X * hi ≤ Real.exp W)
+    (φ : ℝ → ℝ) (G c : ℕ → ℝ) (hout : ∀ t, 1 ≤ |t| → φ t = 0)
+    (hμlower : ∀ j x, μ j x ≠ 0 → Real.exp (c j - 1) ≤ (value x : ℝ))
+    (n r m : ℕ) (Y reserveMass : ℝ) (hm : 64 ≤ reserveMass) (hY : Y ≤ W)
+    (hVeq : V = movingProductNaturalCutoff (movingCellPivotExponent G c) W Y reserveMass)
+    (hbudget : ∀ j, 2 * movingCellPivotExponent G c j ≤
+      movingProductExponent (movingCellPivotExponent G c) W j)
+    (hpositive : 0 ≤ movingProductExponent (movingCellPivotExponent G c) W n -
+      movingCellPivotExponent G c n)
+    (Pg I : Finset ℕ) (hPg : ∀ p ∈ Pg, p.Prime) (hPI : Pg ⊆ I)
+    (hI : ∀ p ∈ I, 0 < p) (hφ : ∀ x, 0 ≤ φ x)
+    (hpos : 0 < smoothGiantMass Pg φ (G (n + 1)))
+    (hμ : ∀ a, 0 ≤ μ n a) (hμmass : ∑ a, μ n a = 1)
+    (ν : MovingRegularSlot n r m → σ → ℝ)
+    (sets : ∀ q : ℕ, Finset (ZMod q))
+    (hsets : ∀ a, (sets (value a)).Nonempty)
+    (hcard : ∀ a, (sets (value a)).card < value a)
+    (ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool)
+    (hgiant : ∀ q : Pg, ∀ x, ggiant q (-x) = conj (ggiant q x))
+    (H : ℕ)
+    (hHeq : H = ⌈Real.exp (movingProductExponent (movingCellPivotExponent G c) W n -
+      movingCellPivotExponent G c n)⌉₊)
+    (hIlower : ∀ p ∈ I, Real.exp (G (n + 1) - 1) ≤ (p : ℝ))
+    (hlarge : ∀ (q : Pg) (y : MovingRegularSlot n r m → σ),
+      (∏ i, ν i (y i)) ≠ 0 → ∀ ℓ, ℓ.Prime → ℓ ∣ (q : ℕ) * (∏ i, value (y i)) → V (n + 1) < ℓ)
+    (hvg : ∀ q : Pg, V (n + 1) < (q : ℕ))
+    (hφsupport : ∀ p : ℕ, 0 < p → φ (Real.log p - G (n + 1)) ≠ 0 → p ∈ I)
+    (hchild : V n ≤ childBound (n + 1))
+    (hgap : ∀ XR : Pg, ∀ right : MovingRegularSlot n r m → σ, (∏ i, ν i (right i)) ≠ 0 →
+      ∀ (u : TreeLeafIndex n × Fin 4 → σ), (∏ i, μ n (u i)) ≠ 0 →
+      ∀ (p : ℕ) (w : ℤ),
+      movingTemplateCoefficient value outside μ childBound pivotBound V (movingOriginalLeaf value q F g Dq S ψ X lo hi) φ G n (4 + r) m w
+        (movingRestoreSample n r m u right) p XR ≠ 0 →
+      2 * pivotBound (n + 1) * childBound (n + 1) < (XR : ℕ) * ∏ i, value (right i))
+    (hcomp : ∀ u : TreeLeafIndex n × Fin 4 → σ, (∏ i, μ n (u i)) ≠ 0 →
+      (∀ p ∈ I, p * (∏ i, value (u i)) ≤ pivotBound (n + 1)) ∧
+      (∀ q, q.Prime → q ∣ ∏ i, value (u i) → childBound (n + 1) < q)) :
+    let ρ := smoothGiantPrior Pg φ (G (n + 1))
+    let greg := normalizedResidueFamily sets
+    Real.exp (-smoothGiantLogNormalizer Pg φ (G (n + 1))) *
+      ‖movingTemplatePrimeAmplitude value outside μ childBound pivotBound V
+        (movingOriginalLeaf value q F g Dq S ψ X lo hi) φ G n (4 + r) m
+        Pg ρ (movingTemplateRestoredPrior n r m (μ n) ν) greg ggiant favorable‖ ^ 2 ≤
+      movingAmplitudeDiagonal value outside μ childBound pivotBound V
+        (movingOriginalLeaf value q F g Dq S ψ X lo hi) φ G n r m Pg I
+        ρ ν greg ggiant favorable +
+      ‖movingTemplatePrimeAmplitude value outside μ childBound pivotBound V
+        (movingOriginalLeaf value q F g Dq S ψ X lo hi) φ G (n + 1) r m
+        Pg ρ (movingTemplateDoubledPrior n r m ν) greg ggiant favorable‖ := by
+  have hV : Monotone V := by
+    rw [hVeq]
+    exact movingProductNaturalCutoff_monotone (movingCellPivotExponent G c) W Y reserveMass hbudget
+  have hcap : ⌈Real.exp (movingProductExponent (movingCellPivotExponent G c) W n -
+      movingCellPivotExponent G c n)⌉₊ ≤ H := by rw [hHeq]
+  have hscale (u : TreeLeafIndex n × Fin 4 → σ) (hu : (∏ i, μ n (u i)) ≠ 0)
+      (p : ℕ) (hp : p ∈ I) : 2 * V n * H ≤ V (n + 1) * (p * ∏ i, value (u i)) := by
+    rw [hVeq, hHeq]
+    exact movingProductNaturalCutoff_compensation_scale value μ G c hμlower W Y reserveMass
+      hm hY hbudget n hpositive u hu p (hIlower p hp)
+  exact movingTemplatePrimeAmplitude_step_of_live_coefficients value hvalue outside μ childBound pivotBound V hV
+    q F hF g Dq S ψ X lo hi W hX hwindow φ G c hout hμlower n r m Pg I hPg hPI hI hφ
+    hpos hμ hμmass ν sets hsets hcard ggiant favorable hgiant H hcap hIlower hscale
+    hlarge hvg hφsupport hchild hgap hcomp
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAmplitudeEnergyLogNorm.lean

@@ -0,0 +1,101 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingAmplitudeHarmonicCost
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingTemplateLogNorm
+
+namespace OAI
+
+/-! # The retained bulk cutoff in the one-branch diagonal energy -/
+
+namespace Ostmann
+open scoped Classical BigOperators
+
+/-- This comparison is applied after the harmonic diagonal reduction.
+The signed two-branch comparison keeps the log weights throughout. -/
+theorem movingAmplitudeRegularEnergy_bulk_log_le
+    (P Pg I : Finset ℕ) (tier : P → ℕ) (k : ℕ)
+    (outside : List ℕ) (cb cd : ℝ) (μ : ℕ → P → ℝ)
+    (hμ0 : ∀ j a, 0 ≤ μ j a) (hμ : ∀ j a, μ j a ≠ 0 → tier a = j)
+    (childBound pivotBound V : ℕ → ℕ) (F : MovingSlotState P → ℤ → ℂ)
+    (φ : ℝ → ℝ) (hφ : ∀ x, 0 ≤ φ x) (G : ℕ → ℝ)
+    (n r m : ℕ) (hn : n < k) (Q : MovingRegularSlot n r m → Finset ℕ)
+    (hsmall : ∀ j : TreeLeafIndex n × Fin r, ∀ q : P,
+      primeSubsetPrior P (Q (j.1, .inl j.2)) q ≠ 0 → tier q ≠ k)
+    (hbulk : ∀ j : TreeLeafIndex n × Fin m, ∀ q : P,
+      primeSubsetPrior P (Q (j.1, .inr j.2)) q ≠ 0 → tier q = k)
+    (greg : ∀ q : ℕ, ZMod q → ℂ) :
+    movingAmplitudeRegularEnergy P Pg I outside μ childBound pivotBound V
+      (fun x s => (movingBulkLeafLogWeight Subtype.val tier k outside cb cd x.data : ℂ) * F x s)
+      φ G n r m Q greg ≤
+    movingAmplitudeRegularEnergy P Pg I outside μ childBound pivotBound V F φ G n r m Q greg := by
+  unfold movingAmplitudeRegularEnergy
+  dsimp only
+  apply Finset.sum_le_sum
+  intro u _
+  by_cases hu : (∏ i, μ n (u i)) = 0
+  · simp only [hu, zero_mul, le_refl]
+  apply mul_le_mul_of_nonneg_left _
+    (mul_nonneg (Finset.prod_nonneg (fun i _ => hμ0 n (u i))) (Nat.cast_nonneg _))
+  apply Finset.sum_le_sum
+  intro p _
+  apply mul_le_mul_of_nonneg_left _ (hφ _)
+  apply Finset.sum_le_sum
+  intro a _
+  let α := movingAmplitudePrior Pg n r m V (smoothGiantPrior Pg φ (G (n + 1)))
+    (fun i => primeSubsetPrior P (Q i)) a
+  have hα : 0 ≤ α := mul_nonneg (smoothGiantPrior_nonneg Pg φ (G (n + 1)) hφ a.1)
+    (Finset.prod_nonneg (fun i _ => primeSubsetPrior_nonneg P (Q i) (a.2.1 i)))
+  by_cases ha : α = 0
+  · simp only [show movingAmplitudePrior Pg n r m V (smoothGiantPrior Pg φ (G (n + 1)))
+      (fun i => primeSubsetPrior P (Q i)) a = 0 from ha, zero_mul, le_refl]
+  have hν i : primeSubsetPrior P (Q i) (a.2.1 i) ≠ 0 :=
+    Finset.prod_ne_zero_iff.mp (right_ne_zero_of_mul ha) i (Finset.mem_univ i)
+  apply mul_le_mul_of_nonneg_left _ hα
+  apply pow_le_pow_left₀ (norm_nonneg _) _ 2
+  rw [norm_mul, norm_mul]
+  apply mul_le_mul_of_nonneg_right _ (norm_nonneg _)
+  exact movingTemplateCoefficient_restored_bulk_log_norm_le Subtype.val tier k outside cb cd
+    μ hμ childBound pivotBound V F φ G n r m a.2.2.val u hu a.2.1 hn
+    (fun j => hsmall j _ (hν _)) (fun j => hbulk j _ (hν _)) p a.1
+
+/-- The full diagonal reduces to the original one-branch energy with its explicit counterpart cost. -/
+theorem movingAmplitude_harmonic_unweighted_cost_le
+    (P Pg I : Finset ℕ) (hP : ∀ p ∈ P, p.Prime) (hPg : ∀ p ∈ Pg, p.Prime)
+    (tier : P → ℕ) (k : ℕ) (outside : List ℕ) (cb cd : ℝ)
+    (μ : ℕ → P → ℝ) (hμ0 : ∀ j a, 0 ≤ μ j a)
+    (hμ : ∀ j a, μ j a ≠ 0 → tier a = j)
+    (childBound pivotBound V : ℕ → ℕ) (F : MovingSlotState P → ℤ → ℂ)
+    (hF : ∀ x, F x 0 = 0)
+    (φ : ℝ → ℝ) (hφ0 : ∀ x, 0 ≤ φ x) (hφ1 : ∀ x, φ x ≤ 1) (G : ℕ → ℝ)
+    (n r m : ℕ) (hn : n < k) (Q : MovingRegularSlot n r m → Finset ℕ)
+    (hsmall : ∀ j : TreeLeafIndex n × Fin r, ∀ q : P,
+      primeSubsetPrior P (Q (j.1, .inl j.2)) q ≠ 0 → tier q ≠ k)
+    (hbulk : ∀ j : TreeLeafIndex n × Fin m, ∀ q : P,
+      primeSubsetPrior P (Q (j.1, .inr j.2)) q ≠ 0 → tier q = k)
+    (hvg : ∀ q : Pg, V n < (q : ℕ)) (hvr : ∀ q : P, V n < (q : ℕ))
+    (hsep : ∀ q : Pg, ∀ a : P, (q : ℕ) ≠ (a : ℕ))
+    (Gmin : ℝ) (hX : ∀ q : Pg, Real.exp Gmin ≤ (q : ℝ))
+    (greg ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool) :
+    let Fw := fun x s =>
+      (movingBulkLeafLogWeight Subtype.val tier k outside cb cd x.data : ℂ) * F x s
+    let K := Real.exp (smoothGiantLogNormalizer Pg φ (G (n + 1)) - Gmin -
+      (2 ^ n : ℕ) * (cb - 1)) * ((Fintype.card (MovingRegularSlot n r m)).factorial : ℝ) *
+        (∏ i, (∑ q ∈ Q i, (q : ℝ)⁻¹)⁻¹)
+    movingAmplitudeDiagonal Subtype.val outside μ childBound pivotBound V Fw φ G n r m Pg I
+      (smoothGiantPrior Pg φ (G (n + 1))) (fun i => primeSubsetPrior P (Q i)) greg ggiant favorable ≤
+      K * movingAmplitudeRegularEnergy P Pg I outside μ childBound pivotBound V F φ G n r m Q greg := by
+  intro Fw K
+  have hcost := movingAmplitude_harmonic_cost_le P Pg I hP hPg tier k outside cb cd μ hμ0 hμ
+    childBound pivotBound V F hF φ hφ0 hφ1 G n r m hn Q hsmall hbulk hvg hvr hsep
+    Gmin hX greg ggiant favorable
+  have hK : 0 ≤ K := by
+    dsimp only [K]
+    apply mul_nonneg
+    · exact mul_nonneg (Real.exp_nonneg _) (Nat.cast_nonneg _)
+    · exact Finset.prod_nonneg (fun i _ => inv_nonneg.mpr
+        (Finset.sum_nonneg (fun q _ => inv_nonneg.mpr (Nat.cast_nonneg q))))
+  exact hcost.trans (mul_le_mul_of_nonneg_left
+    (movingAmplitudeRegularEnergy_bulk_log_le P Pg I tier k outside cb cd μ hμ0 hμ
+      childBound pivotBound V F φ hφ0 G n r m hn Q hsmall hbulk greg) hK)
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAmplitudeFullHarmonicCost.lean

@@ -0,0 +1,132 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingAmplitudeEnergyLogNorm
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingFullHarmonicCost
+
+namespace OAI
+
+/-! # The complete small and bulk denominator in the original diagonal -/
+
+namespace Ostmann
+open scoped Classical BigOperators
+
+theorem movingAmplitude_full_harmonic_cost_le
+    (P Pg I : Finset ℕ) (hP : ∀ p ∈ P, p.Prime) (hPg : ∀ p ∈ Pg, p.Prime)
+    (tier : P → ℕ) (k : ℕ) (outside : List ℕ) (cb cd : ℝ)
+    (μ : ℕ → P → ℝ) (hμ0 : ∀ j a, 0 ≤ μ j a)
+    (hμ : ∀ j a, μ j a ≠ 0 → tier a = j)
+    (childBound pivotBound V : ℕ → ℕ) (F : MovingSlotState P → ℤ → ℂ)
+    (hF : ∀ x, F x 0 = 0)
+    (φ : ℝ → ℝ) (hφ0 : ∀ x, 0 ≤ φ x) (hφ1 : ∀ x, φ x ≤ 1) (G : ℕ → ℝ)
+    (n r m : ℕ) (hn : n < k) (Q : MovingRegularSlot n r m → Finset ℕ)
+    (hsmall : ∀ j : TreeLeafIndex n × Fin r, ∀ q : P,
+      primeSubsetPrior P (Q (j.1, .inl j.2)) q ≠ 0 → tier q ≠ k)
+    (hbulk : ∀ j : TreeLeafIndex n × Fin m, ∀ q : P,
+      primeSubsetPrior P (Q (j.1, .inr j.2)) q ≠ 0 → tier q = k)
+    (lower : TreeLeafIndex n × Fin r → ℝ)
+    (hlower : ∀ j : TreeLeafIndex n × Fin r, ∀ q : P,
+      primeSubsetPrior P (Q (j.1, .inl j.2)) q ≠ 0 → Real.exp (lower j) ≤ (q : ℝ))
+    (hvg : ∀ q : Pg, V n < (q : ℕ)) (hvr : ∀ q : P, V n < (q : ℕ))
+    (hsep : ∀ q : Pg, ∀ a : P, (q : ℕ) ≠ (a : ℕ))
+    (Gmin : ℝ) (hX : ∀ q : Pg, Real.exp Gmin ≤ (q : ℝ))
+    (greg ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool) :
+    let Fw := fun x s =>
+      (movingBulkLeafLogWeight Subtype.val tier k outside cb cd x.data : ℂ) * F x s
+    let K := Real.exp (smoothGiantLogNormalizer Pg φ (G (n + 1)) - Gmin -
+      ((∑ j, lower j) + (2 ^ n : ℕ) * (cb - 1))) * ((Fintype.card (MovingRegularSlot n r m)).factorial : ℝ) *
+        (∏ i, (∑ q ∈ Q i, (q : ℝ)⁻¹)⁻¹)
+    movingAmplitudeDiagonal Subtype.val outside μ childBound pivotBound V Fw φ G n r m Pg I
+      (smoothGiantPrior Pg φ (G (n + 1))) (fun i => primeSubsetPrior P (Q i)) greg ggiant favorable ≤
+      K * movingAmplitudeRegularEnergy P Pg I outside μ childBound pivotBound V Fw φ G n r m Q greg := by
+  intro Fw K
+  have hFw x : Fw x 0 = 0 := by simp only [Fw, hF, mul_zero]
+  have hdiag := movingAmplitude_harmonic_diagonal_le P Pg I hP hPg outside μ hμ0
+    childBound pivotBound V Fw hFw φ hφ0 hφ1 G n r m Q hvg hvr hsep greg ggiant favorable
+  apply hdiag.trans
+  dsimp only at hdiag ⊢
+  unfold movingAmplitudeRegularEnergy
+  simp only [Finset.mul_sum]
+  apply Finset.sum_le_sum
+  intro u _
+  by_cases hu : (∏ i, μ n (u i)) = 0
+  · simp only [hu, zero_mul, mul_zero, Finset.sum_const_zero, le_refl]
+  have hU : 0 ≤ (∏ i, μ n (u i)) * (∏ i, (u i : ℕ) : ℕ) :=
+    mul_nonneg (Finset.prod_nonneg (fun i _ => hμ0 n (u i))) (Nat.cast_nonneg _)
+  apply Finset.sum_le_sum
+  intro p hp
+  apply Finset.sum_le_sum
+  intro a _
+  let α := movingAmplitudePrior Pg n r m V (smoothGiantPrior Pg φ (G (n + 1)))
+    (fun i => primeSubsetPrior P (Q i)) a
+  have hα : 0 ≤ α := mul_nonneg (smoothGiantPrior_nonneg Pg φ (G (n + 1)) hφ0 a.1)
+    (Finset.prod_nonneg (fun i _ => primeSubsetPrior_nonneg P (Q i) (a.2.1 i)))
+  by_cases ha : α = 0
+  · simp only [show movingAmplitudePrior Pg n r m V (smoothGiantPrior Pg φ (G (n + 1)))
+      (fun i => primeSubsetPrior P (Q i)) a = 0 from ha, zero_mul, mul_zero, le_refl]
+  have hν i : primeSubsetPrior P (Q i) (a.2.1 i) ≠ 0 :=
+    Finset.prod_ne_zero_iff.mp (right_ne_zero_of_mul ha) i (Finset.mem_univ i)
+  by_cases hc : movingTemplateCoefficient Subtype.val outside μ childBound pivotBound V Fw φ G
+      n (4 + r) m a.2.2.val (movingRestoreSample n r m u a.2.1) p a.1 = 0
+  · simp only [hc, zero_mul, norm_zero, zero_pow (by norm_num : 2 ≠ 0), mul_zero, le_refl]
+  have hcost := movingTemplate_restored_full_harmonic_cost_le Subtype.val tier
+    (fun q => (hP q q.property).pos) k outside cb cd μ hμ childBound pivotBound V F φ G
+    n r m a.2.2.val u hu a.2.1 hn (fun j => hsmall j _ (hν _))
+    (fun j => hbulk j _ (hν _)) lower (fun j => hlower j _ (hν _)) p a.1 Q (smoothGiantLogNormalizer Pg φ (G (n + 1)))
+    Gmin (hX a.1) hc
+  have hpos := mul_nonneg hU (hφ0 (Real.log p - G (n + 1)))
+  have hcost' := mul_le_mul_of_nonneg_left hcost
+    (mul_nonneg (mul_nonneg hpos hα) (sq_nonneg
+      ‖movingTemplateCoefficient Subtype.val outside μ childBound pivotBound V Fw φ G
+        n (4 + r) m a.2.2.val (movingRestoreSample n r m u a.2.1) p a.1 *
+        primeProductTransform greg (p * (∏ i, (u i : ℕ)) * outside.prod * (a.1 : ℕ))
+          (∏ i, (a.2.1 i : ℕ)) a.2.2.val‖))
+  dsimp only [α] at hcost'
+  simp only [Nat.cast_prod] at hcost'
+  dsimp only [K]
+  simp only [Nat.cast_prod]
+  convert hcost' using 1 <;> ring
+
+/-- The full diagonal reduces to the original one-branch energy with its explicit counterpart cost. -/
+theorem movingAmplitude_full_harmonic_unweighted_cost_le
+    (P Pg I : Finset ℕ) (hP : ∀ p ∈ P, p.Prime) (hPg : ∀ p ∈ Pg, p.Prime)
+    (tier : P → ℕ) (k : ℕ) (outside : List ℕ) (cb cd : ℝ)
+    (μ : ℕ → P → ℝ) (hμ0 : ∀ j a, 0 ≤ μ j a)
+    (hμ : ∀ j a, μ j a ≠ 0 → tier a = j)
+    (childBound pivotBound V : ℕ → ℕ) (F : MovingSlotState P → ℤ → ℂ)
+    (hF : ∀ x, F x 0 = 0)
+    (φ : ℝ → ℝ) (hφ0 : ∀ x, 0 ≤ φ x) (hφ1 : ∀ x, φ x ≤ 1) (G : ℕ → ℝ)
+    (n r m : ℕ) (hn : n < k) (Q : MovingRegularSlot n r m → Finset ℕ)
+    (hsmall : ∀ j : TreeLeafIndex n × Fin r, ∀ q : P,
+      primeSubsetPrior P (Q (j.1, .inl j.2)) q ≠ 0 → tier q ≠ k)
+    (hbulk : ∀ j : TreeLeafIndex n × Fin m, ∀ q : P,
+      primeSubsetPrior P (Q (j.1, .inr j.2)) q ≠ 0 → tier q = k)
+    (lower : TreeLeafIndex n × Fin r → ℝ)
+    (hlower : ∀ j : TreeLeafIndex n × Fin r, ∀ q : P,
+      primeSubsetPrior P (Q (j.1, .inl j.2)) q ≠ 0 → Real.exp (lower j) ≤ (q : ℝ))
+    (hvg : ∀ q : Pg, V n < (q : ℕ)) (hvr : ∀ q : P, V n < (q : ℕ))
+    (hsep : ∀ q : Pg, ∀ a : P, (q : ℕ) ≠ (a : ℕ))
+    (Gmin : ℝ) (hX : ∀ q : Pg, Real.exp Gmin ≤ (q : ℝ))
+    (greg ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool) :
+    let Fw := fun x s =>
+      (movingBulkLeafLogWeight Subtype.val tier k outside cb cd x.data : ℂ) * F x s
+    let K := Real.exp (smoothGiantLogNormalizer Pg φ (G (n + 1)) - Gmin -
+      ((∑ j, lower j) + (2 ^ n : ℕ) * (cb - 1))) * ((Fintype.card (MovingRegularSlot n r m)).factorial : ℝ) *
+        (∏ i, (∑ q ∈ Q i, (q : ℝ)⁻¹)⁻¹)
+    movingAmplitudeDiagonal Subtype.val outside μ childBound pivotBound V Fw φ G n r m Pg I
+      (smoothGiantPrior Pg φ (G (n + 1))) (fun i => primeSubsetPrior P (Q i)) greg ggiant favorable ≤
+      K * movingAmplitudeRegularEnergy P Pg I outside μ childBound pivotBound V F φ G n r m Q greg := by
+  intro Fw K
+  have hcost := movingAmplitude_full_harmonic_cost_le P Pg I hP hPg tier k outside cb cd μ hμ0 hμ
+    childBound pivotBound V F hF φ hφ0 hφ1 G n r m hn Q hsmall hbulk lower hlower hvg hvr hsep
+    Gmin hX greg ggiant favorable
+  have hK : 0 ≤ K := by
+    dsimp only [K]
+    apply mul_nonneg
+    · exact mul_nonneg (Real.exp_nonneg _) (Nat.cast_nonneg _)
+    · exact Finset.prod_nonneg (fun i _ => inv_nonneg.mpr
+        (Finset.sum_nonneg (fun q _ => inv_nonneg.mpr (Nat.cast_nonneg q))))
+  exact hcost.trans (mul_le_mul_of_nonneg_left
+    (movingAmplitudeRegularEnergy_bulk_log_le P Pg I tier k outside cb cd μ hμ0 hμ
+      childBound pivotBound V F φ hφ0 G n r m hn Q hsmall hbulk greg) hK)
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAmplitudeHarmonicCost.lean

@@ -0,0 +1,103 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingAmplitudeHarmonicDiagonal
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingRestoredHarmonicCost
+
+namespace OAI
+
+/-! # A uniform counterpart cost for the complete original-prior diagonal -/
+
+namespace Ostmann
+open scoped Classical BigOperators
+
+noncomputable def movingAmplitudeRegularEnergy
+    (P Pg I : Finset ℕ) (outside : List ℕ) (μ : ℕ → P → ℝ)
+    (childBound pivotBound V : ℕ → ℕ) (F : MovingSlotState P → ℤ → ℂ)
+    (φ : ℝ → ℝ) (G : ℕ → ℝ) (n r m : ℕ)
+    (Q : MovingRegularSlot n r m → Finset ℕ)
+    (greg : ∀ q : ℕ, ZMod q → ℂ) : ℝ :=
+  let ρ := smoothGiantPrior Pg φ (G (n + 1))
+  let ν := fun i => primeSubsetPrior P (Q i)
+  ∑ u : TreeLeafIndex n × Fin 4 → P, (∏ i, μ n (u i)) * (∏ i, (u i : ℕ) : ℕ) *
+    ∑ p ∈ I, φ (Real.log p - G (n + 1)) *
+      ∑ a : MovingAmplitudeIndex P Pg n r m V,
+        movingAmplitudePrior Pg n r m V ρ ν a *
+          ‖movingTemplateCoefficient Subtype.val outside μ childBound pivotBound V F φ G
+            n (4 + r) m a.2.2.val (movingRestoreSample n r m u a.2.1) p a.1 *
+            primeProductTransform greg (p * (∏ i, (u i : ℕ)) * outside.prod * (a.1 : ℕ))
+              (∏ i, (a.2.1 i : ℕ)) a.2.2.val‖ ^ 2
+
+theorem movingAmplitude_harmonic_cost_le
+    (P Pg I : Finset ℕ) (hP : ∀ p ∈ P, p.Prime) (hPg : ∀ p ∈ Pg, p.Prime)
+    (tier : P → ℕ) (k : ℕ) (outside : List ℕ) (cb cd : ℝ)
+    (μ : ℕ → P → ℝ) (hμ0 : ∀ j a, 0 ≤ μ j a)
+    (hμ : ∀ j a, μ j a ≠ 0 → tier a = j)
+    (childBound pivotBound V : ℕ → ℕ) (F : MovingSlotState P → ℤ → ℂ)
+    (hF : ∀ x, F x 0 = 0)
+    (φ : ℝ → ℝ) (hφ0 : ∀ x, 0 ≤ φ x) (hφ1 : ∀ x, φ x ≤ 1) (G : ℕ → ℝ)
+    (n r m : ℕ) (hn : n < k) (Q : MovingRegularSlot n r m → Finset ℕ)
+    (hsmall : ∀ j : TreeLeafIndex n × Fin r, ∀ q : P,
+      primeSubsetPrior P (Q (j.1, .inl j.2)) q ≠ 0 → tier q ≠ k)
+    (hbulk : ∀ j : TreeLeafIndex n × Fin m, ∀ q : P,
+      primeSubsetPrior P (Q (j.1, .inr j.2)) q ≠ 0 → tier q = k)
+    (hvg : ∀ q : Pg, V n < (q : ℕ)) (hvr : ∀ q : P, V n < (q : ℕ))
+    (hsep : ∀ q : Pg, ∀ a : P, (q : ℕ) ≠ (a : ℕ))
+    (Gmin : ℝ) (hX : ∀ q : Pg, Real.exp Gmin ≤ (q : ℝ))
+    (greg ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool) :
+    let Fw := fun x s =>
+      (movingBulkLeafLogWeight Subtype.val tier k outside cb cd x.data : ℂ) * F x s
+    let K := Real.exp (smoothGiantLogNormalizer Pg φ (G (n + 1)) - Gmin -
+      (2 ^ n : ℕ) * (cb - 1)) * ((Fintype.card (MovingRegularSlot n r m)).factorial : ℝ) *
+        (∏ i, (∑ q ∈ Q i, (q : ℝ)⁻¹)⁻¹)
+    movingAmplitudeDiagonal Subtype.val outside μ childBound pivotBound V Fw φ G n r m Pg I
+      (smoothGiantPrior Pg φ (G (n + 1))) (fun i => primeSubsetPrior P (Q i)) greg ggiant favorable ≤
+      K * movingAmplitudeRegularEnergy P Pg I outside μ childBound pivotBound V Fw φ G n r m Q greg := by
+  intro Fw K
+  have hFw x : Fw x 0 = 0 := by simp only [Fw, hF, mul_zero]
+  have hdiag := movingAmplitude_harmonic_diagonal_le P Pg I hP hPg outside μ hμ0
+    childBound pivotBound V Fw hFw φ hφ0 hφ1 G n r m Q hvg hvr hsep greg ggiant favorable
+  apply hdiag.trans
+  dsimp only at hdiag ⊢
+  unfold movingAmplitudeRegularEnergy
+  simp only [Finset.mul_sum]
+  apply Finset.sum_le_sum
+  intro u _
+  by_cases hu : (∏ i, μ n (u i)) = 0
+  · simp only [hu, zero_mul, mul_zero, Finset.sum_const_zero, le_refl]
+  have hU : 0 ≤ (∏ i, μ n (u i)) * (∏ i, (u i : ℕ) : ℕ) :=
+    mul_nonneg (Finset.prod_nonneg (fun i _ => hμ0 n (u i))) (Nat.cast_nonneg _)
+  apply Finset.sum_le_sum
+  intro p hp
+  apply Finset.sum_le_sum
+  intro a _
+  let α := movingAmplitudePrior Pg n r m V (smoothGiantPrior Pg φ (G (n + 1)))
+    (fun i => primeSubsetPrior P (Q i)) a
+  have hα : 0 ≤ α := mul_nonneg (smoothGiantPrior_nonneg Pg φ (G (n + 1)) hφ0 a.1)
+    (Finset.prod_nonneg (fun i _ => primeSubsetPrior_nonneg P (Q i) (a.2.1 i)))
+  by_cases ha : α = 0
+  · simp only [show movingAmplitudePrior Pg n r m V (smoothGiantPrior Pg φ (G (n + 1)))
+      (fun i => primeSubsetPrior P (Q i)) a = 0 from ha, zero_mul, mul_zero, le_refl]
+  have hν i : primeSubsetPrior P (Q i) (a.2.1 i) ≠ 0 :=
+    Finset.prod_ne_zero_iff.mp (right_ne_zero_of_mul ha) i (Finset.mem_univ i)
+  by_cases hc : movingTemplateCoefficient Subtype.val outside μ childBound pivotBound V Fw φ G
+      n (4 + r) m a.2.2.val (movingRestoreSample n r m u a.2.1) p a.1 = 0
+  · simp only [hc, zero_mul, norm_zero, zero_pow (by norm_num : 2 ≠ 0), mul_zero, le_refl]
+  have hcost := movingTemplate_restored_harmonic_cost_le Subtype.val tier
+    (fun q => (hP q q.property).pos) k outside cb cd μ hμ childBound pivotBound V F φ G
+    n r m a.2.2.val u hu a.2.1 hn (fun j => hsmall j _ (hν _))
+    (fun j => hbulk j _ (hν _)) p a.1 Q (smoothGiantLogNormalizer Pg φ (G (n + 1)))
+    Gmin (hX a.1) hc
+  have hpos := mul_nonneg hU (hφ0 (Real.log p - G (n + 1)))
+  have hcost' := mul_le_mul_of_nonneg_left hcost
+    (mul_nonneg (mul_nonneg hpos hα) (sq_nonneg
+      ‖movingTemplateCoefficient Subtype.val outside μ childBound pivotBound V Fw φ G
+        n (4 + r) m a.2.2.val (movingRestoreSample n r m u a.2.1) p a.1 *
+        primeProductTransform greg (p * (∏ i, (u i : ℕ)) * outside.prod * (a.1 : ℕ))
+          (∏ i, (a.2.1 i : ℕ)) a.2.2.val‖))
+  dsimp only [α] at hcost'
+  simp only [Nat.cast_prod] at hcost'
+  dsimp only [K]
+  simp only [Nat.cast_prod]
+  convert hcost' using 1 <;> ring
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAmplitudeHarmonicDiagonal.lean

@@ -0,0 +1,58 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingAmplitudeTerms
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingTemplateHarmonicDiagonal
+
+namespace OAI
+
+/-! # Harmonic product-fibre control of the whole prime amplitude diagonal -/
+
+namespace Ostmann
+open scoped Classical BigOperators
+
+theorem movingAmplitude_harmonic_diagonal_le
+    (P Pg I : Finset ℕ) (hP : ∀ p ∈ P, p.Prime) (hPg : ∀ p ∈ Pg, p.Prime)
+    (outside : List ℕ) (μ : ℕ → P → ℝ) (hμ : ∀ j a, 0 ≤ μ j a)
+    (childBound pivotBound V : ℕ → ℕ)
+    (F : MovingSlotState P → ℤ → ℂ) (hF : ∀ x, F x 0 = 0)
+    (φ : ℝ → ℝ) (hφ0 : ∀ x, 0 ≤ φ x) (hφ1 : ∀ x, φ x ≤ 1) (G : ℕ → ℝ)
+    (n r m : ℕ) (Q : MovingRegularSlot n r m → Finset ℕ)
+    (hvg : ∀ q : Pg, V n < (q : ℕ)) (hvr : ∀ q : P, V n < (q : ℕ))
+    (hsep : ∀ q : Pg, ∀ a : P, (q : ℕ) ≠ (a : ℕ))
+    (greg ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool) :
+    let ρ := smoothGiantPrior Pg φ (G (n + 1))
+    let ν := fun i => primeSubsetPrior P (Q i)
+    let A := MovingAmplitudeIndex P Pg n r m V
+    let α := fun a : A => movingAmplitudePrior Pg n r m V ρ ν a
+    let θ := fun a : A =>
+      (Real.exp (smoothGiantLogNormalizer Pg φ (G (n + 1))) / (a.1 : ℕ)) *
+      ((Fintype.card (MovingRegularSlot n r m)).factorial : ℝ) *
+        (∏ i, (∑ q ∈ Q i, (q : ℝ)⁻¹)⁻¹) * ((∏ i, (a.2.1 i : ℕ)) : ℝ)⁻¹
+    movingAmplitudeDiagonal Subtype.val outside μ childBound pivotBound V F φ G n r m Pg I
+      ρ ν greg ggiant favorable ≤
+    ∑ u : TreeLeafIndex n × Fin 4 → P, (∏ i, μ n (u i)) * (∏ i, (u i : ℕ) : ℕ) *
+      ∑ p ∈ I, φ (Real.log p - G (n + 1)) * ∑ a : A, α a * θ a *
+        ‖movingTemplateCoefficient Subtype.val outside μ childBound pivotBound V F φ G
+          n (4 + r) m a.2.2.val (movingRestoreSample n r m u a.2.1) p a.1 *
+          primeProductTransform greg (p * (∏ i, (u i : ℕ)) * outside.prod * (a.1 : ℕ))
+            (∏ i, (a.2.1 i : ℕ)) a.2.2.val‖ ^ 2 := by
+  intro ρ ν A α θ
+  unfold movingAmplitudeDiagonal
+  dsimp only
+  apply Finset.sum_le_sum
+  intro u _
+  apply mul_le_mul_of_nonneg_left _
+    (mul_nonneg (Finset.prod_nonneg (fun i _ => hμ n (u i))) (Nat.cast_nonneg _))
+  apply Finset.sum_le_sum
+  intro p _
+  apply mul_le_mul_of_nonneg_left _ (hφ0 _)
+  have hd := movingTemplate_harmonic_diagonal_le P Pg hP hPg outside μ childBound pivotBound V
+    F hF φ hφ0 hφ1 G (G (n + 1)) n r m Q u p hvg hvr hsep greg ggiant favorable
+  dsimp only at hd
+  let : ∀ a : A, Fact (a.1 : ℕ).Prime := fun a => ⟨hPg _ a.1.property⟩
+  let : ∀ a : A, ∀ i, Fact (a.2.1 i : ℕ).Prime := fun a i => ⟨hP _ (a.2.1 i).property⟩
+  simpa only [movingTemplateTransferWeight, movingAmplitudePrior, movingOneGiant_transform_tagged,
+    ρ, ν, α, θ, Nat.cast_prod, Function.comp_def]
+    using hd
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAmplitudeIndex.lean

@@ -0,0 +1,58 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingTemplateAmplitudeRestore
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingTemplateWeightedSupport
+
+namespace OAI
+
+/-! # The surviving giant, regular tuple and frequency as one transfer index -/
+
+namespace Ostmann
+open scoped Classical BigOperators
+
+abbrev MovingAmplitudeIndex (σ : Type) (Pg : Finset ℕ) (n r m : ℕ) (V : ℕ → ℕ) :=
+  Pg × ((MovingRegularSlot n r m → σ) × transferFrequencyRange (V n))
+
+noncomputable def movingAmplitudePrior {σ : Type} (Pg : Finset ℕ) (n r m : ℕ)
+    (V : ℕ → ℕ) (ρ : Pg → ℝ) (ν : MovingRegularSlot n r m → σ → ℝ)
+    (a : MovingAmplitudeIndex σ Pg n r m V) : ℝ :=
+  ρ a.1 * ∏ i, ν i (a.2.1 i)
+
+/-- The frequency is part of the transfer index and has counting measure.
+Only the giant and regular prime coordinates carry probability weights. -/
+theorem movingTemplatePrimeAmplitude_index {σ : Type} [Fintype σ]
+    (value : σ → ℕ) (outside : List ℕ) (μ : ℕ → σ → ℝ)
+    (childBound pivotBound V : ℕ → ℕ) (F : MovingSlotState σ → ℤ → ℂ)
+    (φ : ℝ → ℝ) (G : ℕ → ℝ) (n r m : ℕ)
+    (Pg : Finset ℕ) (ρ : Pg → ℝ) (ν : MovingRegularSlot n r m → σ → ℝ)
+    (greg ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool) :
+    movingTemplatePrimeAmplitude value outside μ childBound pivotBound V F φ G n (4 + r) m
+      Pg ρ (movingTemplateRestoredPrior n r m (μ n) ν) greg ggiant favorable =
+    ∑ u : TreeLeafIndex n × Fin 4 → σ, ((∏ i, μ n (u i) : ℝ) : ℂ) *
+      ∑ p : Pg, (ρ p : ℂ) * ∑ a : MovingAmplitudeIndex σ Pg n r m V,
+        movingTemplateTransferWeight value outside μ childBound pivotBound V F φ G n r m
+          (fun a => a.2.2.val) (fun a => (movingAmplitudePrior Pg n r m V ρ ν a : ℂ))
+          (fun a => (a.1 : ℕ)) (fun a => a.2.1) u p a *
+          movingTaggedTransform
+            (Sum.elim (fun b : Bool => if b then (p : ℕ) else (a.1 : ℕ))
+              (value ∘ movingRestoreSample n r m u a.2.1))
+            (Sum.elim (fun _ => true) (fun _ => false)) greg ggiant favorable outside.prod a.2.2.val := by
+  rw [movingTemplatePrimeAmplitude_restore]
+  apply Finset.sum_congr rfl
+  intro u _
+  congr 1
+  apply Finset.sum_congr rfl
+  intro p _
+  congr 1
+  simp only [MovingAmplitudeIndex, Fintype.sum_prod_type, movingTemplateTransferWeight,
+    movingAmplitudePrior, Complex.ofReal_mul, Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro X _
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro s _
+  apply Finset.sum_congr rfl
+  intro y _
+  ring
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAmplitudeLiveCost.lean

@@ -0,0 +1,88 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingAmplitudeSymmetrizedCost
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingAmplitudeLiveSymmetrization
+
+namespace OAI
+
+/-! # Harmonic cost for live priors and the literal coefficient support -/
+
+namespace Ostmann
+open scoped Classical BigOperators
+
+theorem movingAmplitude_symmetrized_full_harmonic_cost_live
+    (P Pg I : Finset ℕ) (hP : ∀ p ∈ P, p.Prime) (hPg : ∀ p ∈ Pg, p.Prime)
+    (outside : List ℕ)
+    (μ : ℕ → P → ℝ) (hμ0 : ∀ j a, 0 ≤ μ j a)
+    (childBound pivotBound V : ℕ → ℕ) (F : MovingSlotState P → ℤ → ℂ)
+    (hF : ∀ x, F x 0 = 0)
+    (φ : ℝ → ℝ) (hφ0 : ∀ x, 0 ≤ φ x) (hφ1 : ∀ x, φ x ≤ 1) (G : ℕ → ℝ)
+    (n r m : ℕ) (Q : MovingRegularSlot n r m → Finset ℕ)
+    (hidentical : ∀ j k : TreeLeafIndex n × Fin m,
+      primeSubsetPrior P (Q (movingTemplateBulk n r m j)) =
+        primeSubsetPrior P (Q (movingTemplateBulk n r m k)))
+    (hvg : ∀ q : Pg, smoothGiantPrior Pg φ (G (n + 1)) q ≠ 0 → V n < (q : ℕ)) (hvr : ∀ i (q : P), primeSubsetPrior P (Q i) q ≠ 0 → V n < (q : ℕ))
+    (hsep : ∀ q : Pg, smoothGiantPrior Pg φ (G (n + 1)) q ≠ 0 →
+      ∀ i (a : P), primeSubsetPrior P (Q i) a ≠ 0 → (q : ℕ) ≠ (a : ℕ))
+    (Gmin : ℝ) (hX : ∀ q : Pg, smoothGiantPrior Pg φ (G (n + 1)) q ≠ 0 → Real.exp Gmin ≤ (q : ℝ))
+    (totalLower : ℝ)
+    (hproduct : ∀ (u : TreeLeafIndex n × Fin 4 → P), (∏ i, μ n (u i)) ≠ 0 →
+      ∀ (a : MovingAmplitudeIndex P Pg n r m V),
+      (∀ i, primeSubsetPrior P (Q i) (a.2.1 i) ≠ 0) →
+      ∀ p : ℕ, movingSymmetrizedTemplateCoefficient Subtype.val outside μ childBound pivotBound V F φ G
+        n r m a.2.2.val u a.2.1 p a.1 ≠ 0 →
+      Real.exp totalLower ≤ ((∏ i, (a.2.1 i : ℕ) : ℕ) : ℝ))
+    (greg ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool) :
+    let K := Real.exp (smoothGiantLogNormalizer Pg φ (G (n + 1)) - Gmin -
+      totalLower) * ((Fintype.card (MovingRegularSlot n r m)).factorial : ℝ) *
+        (∏ i, (∑ q ∈ Q i, (q : ℝ)⁻¹)⁻¹)
+    movingAmplitudeDiagonal Subtype.val outside μ childBound pivotBound V F φ G n r m Pg I
+      (smoothGiantPrior Pg φ (G (n + 1))) (fun i => primeSubsetPrior P (Q i)) greg ggiant favorable ≤
+      K * movingAmplitudeSymmetrizedRegularEnergy P Pg I outside μ childBound pivotBound V F φ G n r m Q greg := by
+  intro K
+  have hdiag := movingAmplitude_symmetrized_harmonic_diagonal_live P Pg I hP hPg outside μ hμ0
+    childBound pivotBound V F hF φ hφ0 hφ1 G n r m Q hidentical hvg hvr hsep greg ggiant favorable
+  apply hdiag.trans
+  dsimp only at hdiag ⊢
+  unfold movingAmplitudeSymmetrizedRegularEnergy
+  simp only [Finset.mul_sum]
+  apply Finset.sum_le_sum
+  intro u _
+  by_cases hu : (∏ i, μ n (u i)) = 0
+  · simp only [hu, zero_mul, mul_zero, Finset.sum_const_zero, le_refl]
+  have hU : 0 ≤ (∏ i, μ n (u i)) * (∏ i, (u i : ℕ) : ℕ) :=
+    mul_nonneg (Finset.prod_nonneg (fun i _ => hμ0 n (u i))) (Nat.cast_nonneg _)
+  apply Finset.sum_le_sum
+  intro p hp
+  apply Finset.sum_le_sum
+  intro a _
+  let α := movingAmplitudePrior Pg n r m V (smoothGiantPrior Pg φ (G (n + 1)))
+    (fun i => primeSubsetPrior P (Q i)) a
+  have hα : 0 ≤ α := mul_nonneg (smoothGiantPrior_nonneg Pg φ (G (n + 1)) hφ0 a.1)
+    (Finset.prod_nonneg (fun i _ => primeSubsetPrior_nonneg P (Q i) (a.2.1 i)))
+  by_cases ha : α = 0
+  · simp only [show movingAmplitudePrior Pg n r m V (smoothGiantPrior Pg φ (G (n + 1)))
+      (fun i => primeSubsetPrior P (Q i)) a = 0 from ha, zero_mul, mul_zero, le_refl]
+  have hν i : primeSubsetPrior P (Q i) (a.2.1 i) ≠ 0 :=
+    Finset.prod_ne_zero_iff.mp (right_ne_zero_of_mul ha) i (Finset.mem_univ i)
+  by_cases hc : movingSymmetrizedTemplateCoefficient Subtype.val outside μ childBound pivotBound V F φ G
+      n r m a.2.2.val u a.2.1 p a.1 = 0
+  · simp only [hc, zero_mul, norm_zero, zero_pow (by norm_num : 2 ≠ 0), mul_zero, le_refl]
+  have hcost := moving_harmonic_full_counterpart_le n r m Q
+    (smoothGiantLogNormalizer Pg φ (G (n + 1))) Gmin totalLower
+    (a.1 : ℕ) (fun i => (a.2.1 i : ℕ)) (hX a.1 (left_ne_zero_of_mul ha))
+    (hproduct u hu a hν p hc)
+  have hpos := mul_nonneg hU (hφ0 (Real.log p - G (n + 1)))
+  have hcost' := mul_le_mul_of_nonneg_left hcost
+    (mul_nonneg (mul_nonneg hpos hα) (sq_nonneg
+      ‖movingSymmetrizedTemplateCoefficient Subtype.val outside μ childBound pivotBound V F φ G
+        n r m a.2.2.val u a.2.1 p a.1 *
+        primeProductTransform greg (p * (∏ i, (u i : ℕ)) * outside.prod * (a.1 : ℕ))
+          (∏ i, (a.2.1 i : ℕ)) a.2.2.val‖))
+  dsimp only [α] at hcost'
+  simp only [Nat.cast_prod] at hcost'
+  dsimp only [K]
+  simp only [Nat.cast_prod]
+  convert hcost' using 1 <;> ring
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAmplitudeLiveHarmonic.lean

@@ -0,0 +1,59 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingAmplitudeTerms
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingTemplateLiveHarmonic
+
+namespace OAI
+
+/-! # Harmonic product-fibre control of the whole prime amplitude diagonal -/
+
+namespace Ostmann
+open scoped Classical BigOperators
+
+theorem movingAmplitude_harmonic_diagonal_live
+    (P Pg I : Finset ℕ) (hP : ∀ p ∈ P, p.Prime) (hPg : ∀ p ∈ Pg, p.Prime)
+    (outside : List ℕ) (μ : ℕ → P → ℝ) (hμ : ∀ j a, 0 ≤ μ j a)
+    (childBound pivotBound V : ℕ → ℕ)
+    (F : MovingSlotState P → ℤ → ℂ) (hF : ∀ x, F x 0 = 0)
+    (φ : ℝ → ℝ) (hφ0 : ∀ x, 0 ≤ φ x) (hφ1 : ∀ x, φ x ≤ 1) (G : ℕ → ℝ)
+    (n r m : ℕ) (Q : MovingRegularSlot n r m → Finset ℕ)
+    (hvg : ∀ q : Pg, smoothGiantPrior Pg φ (G (n + 1)) q ≠ 0 → V n < (q : ℕ)) (hvr : ∀ i (q : P), primeSubsetPrior P (Q i) q ≠ 0 → V n < (q : ℕ))
+    (hsep : ∀ q : Pg, smoothGiantPrior Pg φ (G (n + 1)) q ≠ 0 →
+      ∀ i (a : P), primeSubsetPrior P (Q i) a ≠ 0 → (q : ℕ) ≠ (a : ℕ))
+    (greg ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool) :
+    let ρ := smoothGiantPrior Pg φ (G (n + 1))
+    let ν := fun i => primeSubsetPrior P (Q i)
+    let A := MovingAmplitudeIndex P Pg n r m V
+    let α := fun a : A => movingAmplitudePrior Pg n r m V ρ ν a
+    let θ := fun a : A =>
+      (Real.exp (smoothGiantLogNormalizer Pg φ (G (n + 1))) / (a.1 : ℕ)) *
+      ((Fintype.card (MovingRegularSlot n r m)).factorial : ℝ) *
+        (∏ i, (∑ q ∈ Q i, (q : ℝ)⁻¹)⁻¹) * ((∏ i, (a.2.1 i : ℕ)) : ℝ)⁻¹
+    movingAmplitudeDiagonal Subtype.val outside μ childBound pivotBound V F φ G n r m Pg I
+      ρ ν greg ggiant favorable ≤
+    ∑ u : TreeLeafIndex n × Fin 4 → P, (∏ i, μ n (u i)) * (∏ i, (u i : ℕ) : ℕ) *
+      ∑ p ∈ I, φ (Real.log p - G (n + 1)) * ∑ a : A, α a * θ a *
+        ‖movingTemplateCoefficient Subtype.val outside μ childBound pivotBound V F φ G
+          n (4 + r) m a.2.2.val (movingRestoreSample n r m u a.2.1) p a.1 *
+          primeProductTransform greg (p * (∏ i, (u i : ℕ)) * outside.prod * (a.1 : ℕ))
+            (∏ i, (a.2.1 i : ℕ)) a.2.2.val‖ ^ 2 := by
+  intro ρ ν A α θ
+  unfold movingAmplitudeDiagonal
+  dsimp only
+  apply Finset.sum_le_sum
+  intro u _
+  apply mul_le_mul_of_nonneg_left _
+    (mul_nonneg (Finset.prod_nonneg (fun i _ => hμ n (u i))) (Nat.cast_nonneg _))
+  apply Finset.sum_le_sum
+  intro p _
+  apply mul_le_mul_of_nonneg_left _ (hφ0 _)
+  have hd := movingTemplate_harmonic_diagonal_live P Pg hP hPg outside μ childBound pivotBound V
+    F hF φ hφ0 hφ1 G (G (n + 1)) n r m Q u p hvg hvr hsep greg ggiant favorable
+  dsimp only at hd
+  let : ∀ a : A, Fact (a.1 : ℕ).Prime := fun a => ⟨hPg _ a.1.property⟩
+  let : ∀ a : A, ∀ i, Fact (a.2.1 i : ℕ).Prime := fun a i => ⟨hP _ (a.2.1 i).property⟩
+  simpa only [movingTemplateTransferWeight, movingAmplitudePrior, movingOneGiant_transform_tagged,
+    ρ, ν, α, θ, Nat.cast_prod, Function.comp_def]
+    using hd
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAmplitudeLiveStep.lean

@@ -0,0 +1,68 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingAmplitudeLiveTransfer
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingAmplitudeNext
+
+namespace OAI
+
+/-! # Consecutive original amplitudes with their supported product windows -/
+
+namespace Ostmann
+open scoped Classical BigOperators ComplexConjugate
+
+/-- The next term is the actual doubled-prior amplitude. The transfer
+inequality is derived rather than imposed as a recurrence hypothesis. -/
+theorem movingTemplatePrimeAmplitude_step_on_live {σ : Type} [Fintype σ]
+    (value : σ → ℕ) (hvalue : ∀ a, (value a).Prime)
+    (outside : List ℕ) (μ : ℕ → σ → ℝ)
+    (childBound pivotBound V : ℕ → ℕ) (hV : Monotone V)
+    (F : MovingSlotState σ → ℤ → ℂ) (hF : ∀ x, F x 0 = 0)
+    (φ : ℝ → ℝ) (G : ℕ → ℝ) (n r m : ℕ)
+    (Pg I : Finset ℕ) (hPg : ∀ p ∈ Pg, p.Prime) (hPI : Pg ⊆ I)
+    (hI : ∀ p ∈ I, 0 < p) (hφ : ∀ x, 0 ≤ φ x)
+    (hpos : 0 < smoothGiantMass Pg φ (G (n + 1)))
+    (hμ : ∀ a, 0 ≤ μ n a) (hμmass : ∑ a, μ n a = 1)
+    (ν : MovingRegularSlot n r m → σ → ℝ)
+    (sets : ∀ q : ℕ, Finset (ZMod q))
+    (hsets : ∀ a, (sets (value a)).Nonempty)
+    (hcard : ∀ a, (sets (value a)).card < value a)
+    (ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool)
+    (hgiant : ∀ q : Pg, ∀ x, ggiant q (-x) = conj (ggiant q x))
+    (H : ℕ)
+    (hH : ∀ (u : TreeLeafIndex n × Fin 4 → σ), (∏ i, μ n (u i)) ≠ 0 →
+      ∀ (p : ℕ), p ∈ I →
+      ∀ (q : Pg) (y : MovingRegularSlot n r m → σ) (s : transferFrequencyRange (V n)),
+      movingTemplateCoefficient value outside μ childBound pivotBound V F φ G
+        n (4 + r) m s.val (movingRestoreSample n r m u y) p q ≠ 0 →
+        (q : ℕ) * (∏ i, value (y i)) ≤ H)
+    (hscale : ∀ (u : TreeLeafIndex n × Fin 4 → σ), (∏ i, μ n (u i)) ≠ 0 → ∀ p ∈ I,
+      2 * V n * H ≤ V (n + 1) * (p * ∏ i, value (u i)))
+    (hlarge : ∀ (q : Pg) (y : MovingRegularSlot n r m → σ),
+      (∏ i, ν i (y i)) ≠ 0 → ∀ ℓ, ℓ.Prime → ℓ ∣ (q : ℕ) * (∏ i, value (y i)) → V (n + 1) < ℓ)
+    (hvg : ∀ q : Pg, V (n + 1) < (q : ℕ))
+    (hφsupport : ∀ p : ℕ, 0 < p → φ (Real.log p - G (n + 1)) ≠ 0 → p ∈ I)
+    (hchild : V n ≤ childBound (n + 1))
+    (hgap : ∀ XR : Pg, ∀ right : MovingRegularSlot n r m → σ, (∏ i, ν i (right i)) ≠ 0 →
+      2 * pivotBound (n + 1) * childBound (n + 1) < (XR : ℕ) * ∏ i, value (right i))
+    (hcomp : ∀ u : TreeLeafIndex n × Fin 4 → σ, (∏ i, μ n (u i)) ≠ 0 →
+      (∀ p ∈ I, p * (∏ i, value (u i)) ≤ pivotBound (n + 1)) ∧
+      (∀ q, q.Prime → q ∣ ∏ i, value (u i) → childBound (n + 1) < q)) :
+    let ρ := smoothGiantPrior Pg φ (G (n + 1))
+    let greg := normalizedResidueFamily sets
+    Real.exp (-smoothGiantLogNormalizer Pg φ (G (n + 1))) *
+      ‖movingTemplatePrimeAmplitude value outside μ childBound pivotBound V F φ G n (4 + r) m
+        Pg ρ (movingTemplateRestoredPrior n r m (μ n) ν) greg ggiant favorable‖ ^ 2 ≤
+      movingAmplitudeDiagonal value outside μ childBound pivotBound V F φ G n r m Pg I
+        ρ ν greg ggiant favorable +
+      ‖movingTemplatePrimeAmplitude value outside μ childBound pivotBound V F φ G (n + 1) r m
+        Pg ρ (movingTemplateDoubledPrior n r m ν) greg ggiant favorable‖ := by
+  intro ρ greg
+  have he := movingAmplitudeOffDiagonal_eq_next value hvalue outside μ childBound pivotBound V
+    hV F hF φ G n r m Pg hPg ρ ν hvg I hI hφsupport hchild hgap
+    (fun XR right hr => hlarge XR right hr) hcomp greg ggiant favorable
+  rw [← he]
+  exact movingTemplatePrimeAmplitude_transfer_on_live value hvalue outside μ childBound pivotBound V F
+    φ G n r m Pg I hPg hPI hI hφ hpos hμ hμmass ν sets hsets hcard ggiant favorable
+    hgiant H hH hscale hlarge
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAmplitudeLiveSupport.lean

@@ -0,0 +1,33 @@
+import OAI.NumberTheory.Ostmann.Construction.SmoothGiantLiveSupport
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingTemplateAmplitude
+
+namespace OAI
+
+/-! # The exact full giant amplitude on its nonzero finite support -/
+namespace Ostmann
+open scoped Classical BigOperators
+
+theorem movingTemplatePrimeAmplitude_live {σ : Type} [Fintype σ]
+    (value : σ → ℕ) (outside : List ℕ) (μ : ℕ → σ → ℝ)
+    (childBound pivotBound V : ℕ → ℕ) (F : MovingSlotState σ → ℤ → ℂ)
+    (φ : ℝ → ℝ) (G : ℕ → ℝ) (n r m : ℕ)
+    (P : Finset ℕ) (H : ℝ) (ν : MovingRegularSlot n r m → σ → ℝ)
+    (greg ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool) :
+    movingTemplatePrimeAmplitude value outside μ childBound pivotBound V F φ G n r m
+      P (smoothGiantPrior P φ H) ν greg ggiant favorable =
+    movingTemplatePrimeAmplitude value outside μ childBound pivotBound V F φ G n r m
+      (smoothGiantLivePrimes P φ H) (smoothGiantPrior (smoothGiantLivePrimes P φ H) φ H)
+      ν greg ggiant favorable := by
+  unfold movingTemplatePrimeAmplitude
+  exact smoothGiantPrior_double_sum_live P φ H (fun XL XR =>
+    ∑ s : transferFrequencyRange (V n),
+      ∑ y : MovingRegularSlot n r m → σ, ((∏ i, ν i (y i) : ℝ) : ℂ) *
+        (movingTemplateCoefficient value outside μ childBound pivotBound V F φ G n r m
+          s.val y XL XR *
+          movingTaggedTransform
+            (Sum.elim (fun b : Bool => if b then XL else XR) (value ∘ y))
+            (Sum.elim (fun _ => true) (fun _ => false)) greg ggiant favorable outside.prod s.val))
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAmplitudeLiveSymmetrization.lean

@@ -0,0 +1,63 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingAmplitudeTerms
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingTemplateLiveSymmetrization
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingSymmetrizedProductLower
+
+namespace OAI
+
+/-! # Harmonic product-fibre control of the whole prime amplitude diagonal -/
+
+namespace Ostmann
+open scoped Classical BigOperators
+
+theorem movingAmplitude_symmetrized_harmonic_diagonal_live
+    (P Pg I : Finset ℕ) (hP : ∀ p ∈ P, p.Prime) (hPg : ∀ p ∈ Pg, p.Prime)
+    (outside : List ℕ) (μ : ℕ → P → ℝ) (hμ : ∀ j a, 0 ≤ μ j a)
+    (childBound pivotBound V : ℕ → ℕ)
+    (F : MovingSlotState P → ℤ → ℂ) (hF : ∀ x, F x 0 = 0)
+    (φ : ℝ → ℝ) (hφ0 : ∀ x, 0 ≤ φ x) (hφ1 : ∀ x, φ x ≤ 1) (G : ℕ → ℝ)
+    (n r m : ℕ) (Q : MovingRegularSlot n r m → Finset ℕ)
+    (hν : ∀ j k : TreeLeafIndex n × Fin m,
+      primeSubsetPrior P (Q (movingTemplateBulk n r m j)) =
+        primeSubsetPrior P (Q (movingTemplateBulk n r m k)))
+    (hvg : ∀ q : Pg, smoothGiantPrior Pg φ (G (n + 1)) q ≠ 0 → V n < (q : ℕ)) (hvr : ∀ i (q : P), primeSubsetPrior P (Q i) q ≠ 0 → V n < (q : ℕ))
+    (hsep : ∀ q : Pg, smoothGiantPrior Pg φ (G (n + 1)) q ≠ 0 →
+      ∀ i (a : P), primeSubsetPrior P (Q i) a ≠ 0 → (q : ℕ) ≠ (a : ℕ))
+    (greg ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool) :
+    let ρ := smoothGiantPrior Pg φ (G (n + 1))
+    let ν := fun i => primeSubsetPrior P (Q i)
+    let A := MovingAmplitudeIndex P Pg n r m V
+    let α := fun a : A => movingAmplitudePrior Pg n r m V ρ ν a
+    let θ := fun a : A =>
+      (Real.exp (smoothGiantLogNormalizer Pg φ (G (n + 1))) / (a.1 : ℕ)) *
+      ((Fintype.card (MovingRegularSlot n r m)).factorial : ℝ) *
+        (∏ i, (∑ q ∈ Q i, (q : ℝ)⁻¹)⁻¹) * ((∏ i, (a.2.1 i : ℕ)) : ℝ)⁻¹
+    movingAmplitudeDiagonal Subtype.val outside μ childBound pivotBound V F φ G n r m Pg I
+      ρ ν greg ggiant favorable ≤
+    ∑ u : TreeLeafIndex n × Fin 4 → P, (∏ i, μ n (u i)) * (∏ i, (u i : ℕ) : ℕ) *
+      ∑ p ∈ I, φ (Real.log p - G (n + 1)) * ∑ a : A, α a * θ a *
+        ‖movingSymmetrizedTemplateCoefficient Subtype.val outside μ childBound pivotBound V F φ G
+          n r m a.2.2.val u a.2.1 p a.1 *
+          primeProductTransform greg (p * (∏ i, (u i : ℕ)) * outside.prod * (a.1 : ℕ))
+            (∏ i, (a.2.1 i : ℕ)) a.2.2.val‖ ^ 2 := by
+  intro ρ ν A α θ
+  unfold movingAmplitudeDiagonal
+  dsimp only
+  apply Finset.sum_le_sum
+  intro u _
+  apply mul_le_mul_of_nonneg_left _
+    (mul_nonneg (Finset.prod_nonneg (fun i _ => hμ n (u i))) (Nat.cast_nonneg _))
+  apply Finset.sum_le_sum
+  intro p _
+  apply mul_le_mul_of_nonneg_left _ (hφ0 _)
+  have hd := movingTemplate_symmetrized_harmonic_diagonal_live P Pg hP hPg outside μ childBound pivotBound V
+    F hF φ hφ0 hφ1 G (G (n + 1)) n r m Q hν u p hvg hvr hsep greg ggiant favorable
+  dsimp only at hd
+  let : ∀ a : A, Fact (a.1 : ℕ).Prime := fun a => ⟨hPg _ a.1.property⟩
+  let : ∀ a : A, ∀ i, Fact (a.2.1 i : ℕ).Prime := fun a i => ⟨hP _ (a.2.1 i).property⟩
+  simpa only [movingSymmetrizedTemplateCoefficient, movingTemplateTransferWeight, movingAmplitudePrior, movingOneGiant_transform_tagged,
+    ρ, ν, α, θ, Nat.cast_prod, Function.comp_def]
+    using hd
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAmplitudeLiveTransfer.lean

@@ -0,0 +1,117 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingAmplitudeTerms
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingTemplateLiveTransfer
+
+namespace OAI
+
+/-! # Transfer of the original amplitude with its supported product window -/
+
+namespace Ostmann
+open scoped Classical BigOperators ComplexConjugate
+
+/-- Specialization to the actual surviving giant, regular tuple and frequency.
+The compensation draw and the giant harmonic normalization are unchanged. -/
+theorem movingTemplatePrimeAmplitude_transfer_on_live {σ : Type} [Fintype σ]
+    (value : σ → ℕ) (hvalue : ∀ a, (value a).Prime)
+    (outside : List ℕ) (μ : ℕ → σ → ℝ)
+    (childBound pivotBound V : ℕ → ℕ) (F : MovingSlotState σ → ℤ → ℂ)
+    (φ : ℝ → ℝ) (G : ℕ → ℝ) (n r m : ℕ)
+    (Pg I : Finset ℕ) (hPg : ∀ p ∈ Pg, p.Prime) (hPI : Pg ⊆ I)
+    (hI : ∀ p ∈ I, 0 < p) (hφ : ∀ x, 0 ≤ φ x)
+    (hpos : 0 < smoothGiantMass Pg φ (G (n + 1)))
+    (hμ : ∀ a, 0 ≤ μ n a) (hμmass : ∑ a, μ n a = 1)
+    (ν : MovingRegularSlot n r m → σ → ℝ)
+    (sets : ∀ q : ℕ, Finset (ZMod q))
+    (hsets : ∀ a, (sets (value a)).Nonempty)
+    (hcard : ∀ a, (sets (value a)).card < value a)
+    (ggiant : ∀ q : ℕ, ZMod q → ℂ) (favorable : ℕ → Bool)
+    (hgiant : ∀ q : Pg, ∀ x, ggiant q (-x) = conj (ggiant q x))
+    (H : ℕ)
+    (hH : ∀ (u : TreeLeafIndex n × Fin 4 → σ), (∏ i, μ n (u i)) ≠ 0 →
+      ∀ (p : ℕ), p ∈ I →
+      ∀ (q : Pg) (y : MovingRegularSlot n r m → σ) (s : transferFrequencyRange (V n)),
+      movingTemplateCoefficient value outside μ childBound pivotBound V F φ G
+        n (4 + r) m s.val (movingRestoreSample n r m u y) p q ≠ 0 →
+        (q : ℕ) * (∏ i, value (y i)) ≤ H)
+    (hscale : ∀ (u : TreeLeafIndex n × Fin 4 → σ), (∏ i, μ n (u i)) ≠ 0 → ∀ p ∈ I,
+      2 * V n * H ≤ V (n + 1) * (p * ∏ i, value (u i)))
+    (hlarge : ∀ (q : Pg) (y : MovingRegularSlot n r m → σ),
+      (∏ i, ν i (y i)) ≠ 0 → ∀ ℓ, ℓ.Prime → ℓ ∣ (q : ℕ) * (∏ i, value (y i)) → V (n + 1) < ℓ) :
+    let ρ := smoothGiantPrior Pg φ (G (n + 1))
+    let greg := normalizedResidueFamily sets
+    Real.exp (-smoothGiantLogNormalizer Pg φ (G (n + 1))) *
+      ‖movingTemplatePrimeAmplitude value outside μ childBound pivotBound V F φ G n (4 + r) m
+        Pg ρ (movingTemplateRestoredPrior n r m (μ n) ν) greg ggiant favorable‖ ^ 2 ≤
+      movingAmplitudeDiagonal value outside μ childBound pivotBound V F φ G n r m Pg I
+        ρ ν greg ggiant favorable +
+      ‖movingAmplitudeOffDiagonal value outside μ childBound pivotBound V F φ G n r m Pg I
+        ρ ν greg ggiant favorable‖ := by
+  intro ρ greg
+  let A := MovingAmplitudeIndex σ Pg n r m V
+  let X := fun a : A => (a.1 : ℕ)
+  let y := fun a : A => a.2.1
+  let v := fun a : A => a.2.2.val
+  let α := fun a : A => (movingAmplitudePrior Pg n r m V ρ ν a : ℂ)
+  let : ∀ a : A, Fact (X a).Prime := fun a => ⟨hPg _ a.1.property⟩
+  let : ∀ a : A, ∀ i, Fact (value (y a i)).Prime := fun a i => ⟨hvalue (y a i)⟩
+  let : ∀ a : A, ∀ i, NeZero ((value ∘ y a) i) :=
+    fun a i => ⟨(hvalue (y a i)).ne_zero⟩
+  let L := fun a => movingOneGiantModuli (X a) (value ∘ y a)
+  let W := movingTemplateTransferWeight value outside μ childBound pivotBound V F φ G
+    n r m v α X y
+  have ht := movingTemplate_prior_transfer_on_live value hvalue outside μ childBound pivotBound V F
+    φ G n r m Pg I hPg hPI hI hφ hpos hμ hμmass X (fun a => hPg _ a.1.property)
+    y v α sets hsets hcard ggiant favorable (fun a => hgiant a.1)
+    (V n) H (V (n + 1)) (fun a => (mem_transferFrequencyRange _ _).mp a.2.2.property)
+    (fun u hu p hp a ha => hH u hu p hp a.1 (y a) a.2.2 (right_ne_zero_of_mul ha)) hscale (fun a ha => by
+      have hprior : movingAmplitudePrior Pg n r m V ρ ν a ≠ 0 :=
+        Complex.ofReal_ne_zero.mp ha
+      exact hlarge a.1 (y a) (right_ne_zero_of_mul hprior))
+  dsimp only at ht
+  rw [← movingTemplatePrimeAmplitude_index] at ht
+  have hC u p : movingRegularCoefficient L
+      (fun a => movingOneGiantFactors (X a) (value ∘ y a) greg ggiant favorable)
+      outside.prod (∏ i, value (u i)) v (W u) p =
+      fun a => W u p a * movingTaggedTransform (L a)
+        (Sum.elim (fun _ => true) (fun _ => false)) greg ggiant favorable
+        (p * (∏ i, value (u i)) * outside.prod) (v a) := by
+    funext a
+    exact congrArg (fun z => W u p a * z)
+      (movingOneGiant_transform_tagged (X a) (value ∘ y a) greg ggiant favorable
+        (p * (∏ i, value (u i)) * outside.prod) (v a))
+  convert ht using 1
+  congr 1
+  · unfold movingAmplitudeDiagonal
+    apply Finset.sum_congr rfl
+    intro u _
+    congr 1
+    apply Finset.sum_congr rfl
+    intro p _
+    congr 1
+    simp only [movingOneGiantModuli_product, Function.comp_apply]
+    exact congrArg (fun c : A → ℂ =>
+      (pivotDiagonal (fun a => X a * ∏ i, value (y a i)) v c).re) (hC u p).symm
+  · congr 1
+    unfold movingAmplitudeOffDiagonal
+    apply Finset.sum_congr rfl
+    intro u _
+    congr 1
+    conv_rhs => rw [← Finset.sum_coe_sort]
+    apply Finset.sum_congr rfl
+    intro s hs
+    apply Finset.sum_congr rfl
+    intro a _
+    apply Finset.sum_congr rfl
+    intro b _
+    simp only [movingOneGiantModuli_product, Function.comp_apply,
+      movingOneGiant_pair_transform_tagged]
+    dsimp only [movingTemplateIntegerFourierTerm, movingTemplateTransferWeight, A, X, y, v, α, W]
+    split_ifs
+    · simp only [map_mul, Complex.conj_ofReal]
+      simp only [starRingEnd_apply]
+      dsimp only [greg]
+      ring
+    · simp only [mul_zero]
+
+end Ostmann
+
+end OAI

lean/OAI/NumberTheory/Ostmann/Arithmetic/MovingAmplitudeMaskedEnergy.lean

@@ -0,0 +1,120 @@
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingAmplitudeHarmonicCost
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingRestoredEnergy
+import OAI.NumberTheory.Ostmann.Arithmetic.MovingMaskedTemplateEnergy
+
+namespace OAI
+
+/-! # The actual one-branch amplitude energy in restored arithmetic coordinates -/
+
+namespace Ostmann
+open scoped Classical BigOperators
+
+private theorem amplitude_energy_fubini {U T X Y S : Type}
+    [Fintype U] [Fintype X] [Fintype Y] [Fintype S]
+    (I : Finset T) (M : U → ℝ) (w : T → ℝ) (ρ : X → ℝ) (ν : Y → ℝ)
+    (F : U → T → X → Y → S → ℝ) :
+    (∑ u, M u * ∑ p ∈ I, w p * ∑ a : X × (Y × S),
+      (ρ a.1 * ν a.2.1) * F u p a.1 a.2.1 a.2.2) =
+    ∑ u, M u * ∑ y, ν y * ∑ p ∈ I, w p * ∑ x, ρ x * ∑ s, F u p x y s := by
+  simp only [Fintype.sum_prod_type, Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro u _
+  conv_lhs =>
+    arg 2
+    ext p
+    rw [Finset.sum_comm]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro y _
+  apply Finset.sum_congr rfl
+  intro p _
+  apply Finset.sum_congr rfl
+  intro x _
+  apply Finset.sum_congr rfl
+  intro s _
+  ring
+
+/-- The compensation draw and the surviving draw are independent original
+priors; this reordering introduces no frequency probability factor. -/
+theorem movingAmplitudeRegularEnergy_fubini
+    (P Pg I : Finset ℕ) (outside : List ℕ) (μ : ℕ → P → ℝ)
+    (childBound pivotBound V : ℕ → ℕ) (F : MovingSlotState P → ℤ → ℂ)
+    (φ : ℝ → ℝ) (G : ℕ → ℝ) (n r m : ℕ)
+    (Q : MovingRegularSlot n r m → Finset ℕ) (greg : ∀ q : ℕ, ZMod q → ℂ) :
+    movingAmplitudeRegularEnergy P Pg I outside μ childBound pivotBound V F φ G n r m Q greg =
+    ∑ u : TreeLeafIndex n × Fin 4 → P, (∏ i, μ n (u i)) * (∏ i, (u i : ℕ) : ℕ) *
+      ∑ y : MovingRegularSlot n r m → P, (∏ i, primeSubsetPrior P (Q i) (y i)) *
+        ∑ p ∈ I, φ (Real.log p - G (n + 1)) *
+          ∑ X : Pg, smoothGiantPrior Pg φ (G (n + 1)) X *
+            ∑ s : transferFrequencyRange (V n),
+              ‖movingTemplateCoefficient Subtype.val outside μ childBound pivotBound V F φ G
+                n (4 + r) m s.val (movingRestoreSample n r m u y) p X *
+                primeProductTransform greg (p * (∏ i, (u i : ℕ)) * outside.prod * (X : ℕ))
+                  (∏ i, (y i : ℕ)) s.val‖ ^ 2 := by
+  unfold movingAmplitudeRegularEnergy
+  dsimp only
+  have h := amplitude_energy_fubini
+    (U := TreeLeafIndex n × Fin 4 → P) (X := Pg)
+    (Y := MovingRegularSlot n r m → P) (S := transferFrequencyRange (V n)) I
+    (fun u => (∏ i, μ n (u i)) * (∏ i, (u i : ℕ) : ℕ))
+    (fun p => φ (Real.log p - G (n + 1)))
+    (smoothGiantPrior Pg φ (G (n + 1)))
+    (fun y => ∏ i, primeSubsetPrior P (Q i) (y i))
+    (fun u p X y s =>
+      ‖movingTemplateCoefficient Subtype.val outside μ childBound pivotBound V F φ G
+        n (4 + r) m s.val (movingRestoreSample n r m u y) p X *
+        primeProductTransform greg (p * (∏ i, (u i : ℕ)) * outside.prod * (X : ℕ))
+          (∏ i, (y i : ℕ)) s.val‖ ^ 2)
+  convert h using 1
+  simp only [movingAmplitudePrior, Nat.cast_prod]
+
+/-- This is the literal arithmetic energy under the original restored prior.
+The extracted compensation product is a weight, not a change of measure. -/
+theorem movingAmplitudeRegularEnergy_eq_masked
+    (P Pg I : Finset ℕ) (hP : ∀ p ∈ P, p.Prime) (outside : List ℕ) (μ : ℕ → P → ℝ)
+    (childBound pivotBound V : ℕ → ℕ) (F : MovingSlotState P → ℤ → ℂ)
+    (φ : ℝ → ℝ) (G : ℕ → ℝ) (n r m : ℕ)
+    (Q : MovingRegularSlot n r m → Finset ℕ) (greg : ∀ q : ℕ, ZMod q → ℂ) :
+    movingAmplitudeRegularEnergy P Pg I outside μ childBound pivotBound V F φ G n r m Q greg =
+      movingMaskedTemplateEnergy P Pg I hP outside μ childBound pivotBound V F φ G n r m Q greg
+        (fun x => (movingRestoredCompensationProduct Subtype.val n r m x : ℝ)) := by
+  rw [movingAmplitudeRegularEnergy_fubini]
+  unfold movingMaskedTemplateEnergy
+  rw [movingTemplateRestoredPrior_average_real]
+  simp only [movingRestoredCompensationProduct_restore, Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro u _
+  apply Finset.sum_congr rfl
+  intro y _
+  apply Finset.sum_congr rfl
+  intro p _
+  apply Finset.sum_congr rfl
+  intro X _
+  apply Finset.sum_congr rfl
+  intro s _
+  rw [movingMaskedTemplateKernel_restore]
+  ring
+
+/-- The compensation cost is now explicit, with the same original prior in
+both energies. The bound is used only after the nonnegative diagonal reduction. -/
+theorem movingAmplitudeRegularEnergy_le_masked
+    (P Pg I : Finset ℕ) (hP : ∀ p ∈ P, p.Prime) (outside : List ℕ) (μ : ℕ → P → ℝ)
+    (hμ : ∀ j a, 0 ≤ μ j a)
+    (childBound pivotBound V : ℕ → ℕ) (F : MovingSlotState P → ℤ → ℂ)
+    (φ : ℝ → ℝ) (hφ : ∀ t, 0 ≤ φ t) (G : ℕ → ℝ) (n r m : ℕ)
+    (Q : MovingRegularSlot n r m → Finset ℕ) (greg : ∀ q : ℕ, ZMod q → ℂ)
+    (b : ℝ) (hb : ∀ a, μ n a ≠ 0 → (a : ℝ) ≤ Real.exp b) :
+    movingAmplitudeRegularEnergy P Pg I outside μ childBound pivotBound V F φ G n r m Q greg ≤
+      Real.exp (((2 ^ n * 4 : ℕ) : ℝ) * b) *
+        movingMaskedTemplateEnergy P Pg I hP outside μ childBound pivotBound V F φ G n r m Q greg
+          (fun _ => 1) := by
+  rw [movingAmplitudeRegularEnergy_eq_masked P Pg I hP]
+  apply movingMaskedTemplateEnergy_weight_le P Pg I hP outside μ hμ
+    childBound pivotBound V F φ hφ G n r m Q greg
+  intro x hx
+  exact movingRestoredCompensationProduct_le_exp P (μ n) n r m
+    (fun i => primeSubsetPrior P (Q i)) b hb x hx
+
+end Ostmann
+
+end OAI