Add lean source and binary files (part 100)

lean/OAI/NumberTheory/DirichletL/Descent/Basic.lean

@@ -0,0 +1,170 @@
+import Mathlib.Basic.Real.Basic
+import Mathlib.Tactic.Linarith
+import Mathlib.Tactic.Ring
+import Mathlib.Tactic.Positivity
+
+namespace OAI
+
+namespace SevenEighths.InverseMoment
+
+def MarkedMargins (m r z c : ℝ) : Prop :=
+  r + 2 * z ≤ m - c ∧ 2 * r + 8 * z ≤ 3 * m - c
+
+def CanonicalMargins (F M Q z c : ℝ) : Prop :=
+  c ≤ F - M - Q - z ∧ c ≤ 4 * F - 3 * M - 6 * z
+
+theorem markedMargins_of_strict {m r z : ℝ}
+    (h₁ : r + 2 * z < m) (h₂ : 2 * r + 8 * z < 3 * m) :
+    ∃ c > 0, MarkedMargins m r z c := by
+  refine ⟨min (m - r - 2 * z) (3 * m - 2 * r - 8 * z), ?_, ?_⟩
+  · exact lt_min (by linarith) (by linarith)
+  · constructor
+    · have := min_le_left (m - r - 2 * z) (3 * m - 2 * r - 8 * z)
+      linarith
+    · have := min_le_right (m - r - 2 * z) (3 * m - 2 * r - 8 * z)
+      linarith
+
+theorem markedMargins_subcollection {m r z z' c : ℝ}
+    (h : MarkedMargins m r z c) (hz : z' ≤ z) :
+    MarkedMargins m r z' c := by
+  obtain ⟨h₁, h₂⟩ := h
+  constructor <;> linarith
+
+theorem canonicalMargins_subcollection {F M Q z z' c : ℝ}
+    (h : CanonicalMargins F M Q z c) (hz : z' ≤ z) :
+    CanonicalMargins F M Q z' c := by
+  obtain ⟨h₁, h₂⟩ := h
+  constructor <;> linarith
+
+theorem canonicalMargins_weaken {F M Q z c c' : ℝ}
+    (h : CanonicalMargins F M Q z c) (hc : c' ≤ c) :
+    CanonicalMargins F M Q z c' := by
+  exact ⟨hc.trans h.1, hc.trans h.2⟩
+
+def decrease (ell A t g theta V : ℝ) : ℝ := ell + A + t + g - theta + V
+
+def childF (F ell A t g theta V j delta : ℝ) : ℝ :=
+  F - decrease ell A t g theta V - 2 * ell + j + delta
+
+def childM (M ell A t g theta V j eta : ℝ) : ℝ :=
+  M - 2 * decrease ell A t g theta V - 2 * ell + j + eta
+
+theorem canonical_transition (F M ell A t g theta V j : ℝ) :
+    childF F ell A t g theta V j 0 - childM M ell A t g theta V j 0 =
+      F - M + decrease ell A t g theta V ∧
+    4 * childF F ell A t g theta V j 0 -
+      3 * childM M ell A t g theta V j 0 =
+      4 * F - 3 * M + 2 * (A + t + g - theta + V) + j := by
+  constructor <;> unfold childF childM decrease <;> ring
+
+theorem child_margins_sharp {F M Q Q' z c ell A t g theta V j delta eta : ℝ}
+    (h : CanonicalMargins F M Q z c)
+    (hA : 0 ≤ A) (ht : 0 ≤ t) (hV : 0 ≤ V) (hj : 0 ≤ j)
+    (hgt : -2 * eta ≤ g - theta)
+    (hQ : Q' ≤ Q + decrease ell A t g theta V + 4 * eta) :
+    c + delta - 5 * eta ≤
+      childF F ell A t g theta V j delta -
+      childM M ell A t g theta V j eta - Q' - z ∧
+    c + 4 * delta - 7 * eta ≤
+      4 * childF F ell A t g theta V j delta -
+      3 * childM M ell A t g theta V j eta - 6 * z := by
+  obtain ⟨h₁, h₂⟩ := h
+  unfold childF childM decrease at *
+  constructor <;> linarith
+
+theorem child_margins {F M Q Q' z c ell A t g theta V j delta eta : ℝ}
+    (h : CanonicalMargins F M Q z c)
+    (hA : 0 ≤ A) (ht : 0 ≤ t) (hV : 0 ≤ V) (hj : 0 ≤ j)
+    (hgt : -2 * eta ≤ g - theta) (hdelta : 0 ≤ delta) (heta : 0 ≤ eta)
+    (hQ : Q' ≤ Q + decrease ell A t g theta V + 4 * eta) :
+    CanonicalMargins (childF F ell A t g theta V j delta)
+      (childM M ell A t g theta V j eta) Q' z (c - 7 * eta) := by
+  obtain ⟨h₁, h₂⟩ := child_margins_sharp (delta := delta) h hA ht hV hj hgt hQ
+  constructor <;> linarith
+
+theorem child_row_decrease {M ell A t g theta V j eta d : ℝ}
+    (hA : 0 ≤ A) (ht : 0 ≤ t) (hgt : -2 * eta ≤ g - theta)
+    (hj : j ≤ 2 * ell + 3 * eta) (hterminal : d ≤ ell + V)
+    (heta : eta ≤ d / 16) :
+    3 * d / 2 ≤ M - childM M ell A t g theta V j eta := by
+  unfold childM decrease
+  linarith
+
+theorem childF_upper {F ell A t g theta V j delta eta : ℝ}
+    (hA : 0 ≤ A) (ht : 0 ≤ t) (hell : 0 ≤ ell) (hV : 0 ≤ V)
+    (hgt : -2 * eta ≤ g - theta) (hj : j ≤ 2 * ell + 3 * eta)
+    (hdelta : delta ≤ 6 * eta) :
+    childF F ell A t g theta V j delta ≤ F + 11 * eta := by
+  unfold childF decrease
+  linarith
+
+theorem clipping_bounds {N eta : ℝ} (heta : 0 ≤ eta) (hN : -6 * eta ≤ N) :
+    0 ≤ max 0 N - N ∧ max 0 N - N ≤ 6 * eta := by
+  constructor
+  · exact sub_nonneg.mpr (le_max_right 0 N)
+  · rcases le_total 0 N with h | h
+    · rw [max_eq_right h]; linarith
+    · rw [max_eq_left h]; linarith
+
+theorem step_energy_exponent {F Fc kappa lambda count delta eta tau pi eps : ℝ}
+    (hid : kappa + lambda + count + 2 * Fc = F)
+    (hdelta : delta ≤ 6 * eta) :
+    kappa + lambda + count + 2 * (Fc + delta) +
+      (9 / 2 + 18 + 11 / 2) * eta + tau + pi + eps ≤
+      F + 40 * eta + tau + pi + eps := by
+  linarith
+
+def initialF (r z G P delta : ℝ) : ℝ := r + z - 2 * G - P + delta
+
+def initialM (m r z G P eta tau : ℝ) : ℝ :=
+  2 * (r + z - 2 * G) - m - 2 * P + 6 * eta + tau
+
+theorem initial_margins_sharp {m r z G P delta eta tau Q c₁ c₂ : ℝ}
+    (h₁ : r + 2 * z ≤ m - c₁) (h₂ : 2 * r + 8 * z ≤ 3 * m - c₂)
+    (hG : 0 ≤ G) (hP : -2 * eta ≤ P) (hQ : Q ≤ P + G + 3 * eta) :
+    c₁ + delta - 9 * eta - tau ≤
+      initialF r z G P delta - initialM m r z G P eta tau - Q - (z - G) ∧
+    c₂ + 4 * delta - 22 * eta - 3 * tau ≤
+      4 * initialF r z G P delta - 3 * initialM m r z G P eta tau -
+        6 * (z - G) := by
+  unfold initialF initialM
+  constructor <;> linarith
+
+theorem initial_margins {m r z G P delta eta tau Q c₁ c₂ : ℝ}
+    (h₁ : r + 2 * z ≤ m - c₁) (h₂ : 2 * r + 8 * z ≤ 3 * m - c₂)
+    (hG : 0 ≤ G) (hP : -2 * eta ≤ P) (hQ : Q ≤ P + G + 3 * eta)
+    (hc : 0 ≤ min c₁ c₂) (hdelta : 0 ≤ delta) (heta : eta ≤ min c₁ c₂ / 100)
+    (htau : tau ≤ min c₁ c₂ / 100) :
+    CanonicalMargins (initialF r z G P delta)
+      (initialM m r z G P eta tau) Q (z - G) (3 * min c₁ c₂ / 4) := by
+  obtain ⟨ha, hb⟩ := initial_margins_sharp (delta := delta) (tau := tau) h₁ h₂ hG hP hQ
+  have hc₁ := min_le_left c₁ c₂
+  have hc₂ := min_le_right c₁ c₂
+  constructor <;> linarith
+
+theorem initial_prefactor_identity (m r z G P : ℝ) :
+    (m - 2 * (r + z - 2 * G) + P) + P +
+      2 * initialF r z G P 0 = m := by
+  unfold initialF
+  ring
+
+theorem initial_energy_exponent {m delta eta pi eps : ℝ}
+    (hdelta : delta ≤ 3 * eta) :
+    m + 3 * eta + 2 * eta + 2 * delta + pi + eps ≤
+      m + 11 * eta + pi + eps := by
+  linarith
+
+theorem total_step_loss {D eta tau pi eps : ℝ}
+    (h₁ : D * eta ≤ eps / 160) (h₂ : D * tau ≤ eps / 4)
+    (h₃ : D * pi ≤ eps / 4) :
+    D * (40 * eta + tau + pi) ≤ 3 * eps / 4 := by
+  nlinarith
+
+theorem depth_margin {c D h eta : ℝ} (heta : 0 ≤ eta) (hh : h ≤ D)
+    (hbudget : D * eta ≤ c / 14) : c / 2 ≤ c - 7 * h * eta := by
+  have := mul_le_mul_of_nonneg_right hh heta
+  nlinarith
+
+end SevenEighths.InverseMoment
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/Canonical.lean

@@ -0,0 +1,130 @@
+import OAI.NumberTheory.DirichletL.Descent.Poisson
+import OAI.NumberTheory.DirichletL.Descent.Completion
+
+namespace OAI
+
+namespace SevenEighths.InverseMoment
+open scoped BigOperators Classical SchwartzMap
+open ActualEisensteinCubic CompletedGauss FirstPassCubeLabels SecondPassArithmetic
+noncomputable section
+local notation "Eis" => ActualEisensteinCubic.O
+variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ]
+  (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal]
+  (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i})))
+  (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i})
+
+def finiteCanonicalMarkedRow (pool : Finset ι) (Ψ : Eis →* ℂ) (m f k : Eis)
+    (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ)
+    (W : ℝ → ℂ) (X : ℝ) : ℂ :=
+  fixedChildRow p hp hcop hg pool Ψ m
+    (fun U => primeMark slots lists a U * W (primeProductNorm p U / X)) f k
+
+omit [DecidableEq σ] in
+theorem finiteCanonicalMarkedRow_actual_columns
+    (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda ^ 2 ∣ p i - 1)
+    (pool : Finset ι) (Ψ : Eis →* ℂ) (m f k : Eis)
+    (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ)
+    (W : ℝ → ℂ) (X : ℝ) :
+    finiteCanonicalMarkedRow p hp hcop hg pool Ψ m f k slots lists a W X =
+      ∑ U ∈ pool.powerset,
+        columnWeight (CanonicalRowCompletion.rowTwist Ψ m f k)
+          (Ideal.span {∏ i ∈ U, p i}) *
+        (primeMark slots lists a U * W (primeProductNorm p U / X)) := by
+  unfold finiteCanonicalMarkedRow fixedChildRow
+  apply Finset.sum_congr rfl
+  intro U hU
+  have he := CanonicalRowCompletion.columnWeight_finset p hp hcop hg hpr U Ψ m f k
+    (fun U => primeMark slots lists a U * W (primeProductNorm p U / X))
+  symm
+  convert he using 1 ; simp only [secondChildColumn, canonicalSourceCoefficient] ; ring
+
+theorem secondChildSum_marked_canonical
+    (F V A : Finset ι) (Ψ : Eis →* ℂ) (m r c d e k : Eis)
+    (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ)
+    (W : ℝ → ℂ) (X : ℝ) :
+    secondChildSum p hp hcop hg F V Ψ m r c d e k
+      (fun U => primeMark slots lists a (A ∪ U) * W (primeProductNorm p U / X)) =
+    ∑ J ∈ slots.powerset, primeMark J lists a (A ∪ V) *
+      finiteCanonicalMarkedRow p hp hcop hg (F \ V) Ψ (m * r)
+        (c * e * ∏ i ∈ V, p i) (d * e * k)
+        (slots \ J) (fun i => lists i \ (A ∪ V)) a W (X / primeProductNorm p V) := by
+  unfold secondChildSum finiteCanonicalMarkedRow fixedChildRow
+  simp only [Finset.mul_sum]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro N hN
+  have hd : Disjoint V N := Finset.disjoint_left.mpr (fun i hi hn =>
+    (Finset.mem_sdiff.mp (Finset.mem_powerset.mp hN hn)).2 hi)
+  have hn : primeProductNorm p (V ∪ N) / X = primeProductNorm p N / (X / primeProductNorm p V) := by
+    rw [primeProductNorm_union p V N hd]
+    simp only [div_div_eq_mul_div]
+    ring
+  have hmark := primeMark_priority slots lists a (A ∪ V) N
+  simp only [primeMark_residual_lists] at hmark
+  simp only [secondChildColumn, ← Finset.union_assoc, hn]
+  rw [hmark]
+  simp only [Finset.sum_mul, Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro J hJ
+  ring
+
+omit [DecidableEq σ] in
+theorem finiteCanonicalMarkedRow_restore_pool
+    (pool B : Finset ι) (Ψ : Eis →* ℂ) (m f k : Eis)
+    (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ)
+    (W : ℝ → ℂ) (X : ℝ)
+    (hB : ∀ i ∈ B, m * f ∈ Ideal.span {p i}) :
+    finiteCanonicalMarkedRow p hp hcop hg (pool \ B) Ψ m f k slots lists a W X =
+      finiteCanonicalMarkedRow p hp hcop hg pool Ψ m f k slots lists a W X :=
+  fixedChildRow_restore_killed_pool p hp hcop hg pool B Ψ m f k _ hB
+
+omit [DecidableEq σ] in
+theorem finiteCanonicalMarkedRow_restore_lists
+    (pool B : Finset ι) (Ψ : Eis →* ℂ) (m f k : Eis)
+    (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ)
+    (W : ℝ → ℂ) (X : ℝ)
+    (hB : ∀ i ∈ B, m * f ∈ Ideal.span {p i}) :
+    finiteCanonicalMarkedRow p hp hcop hg pool Ψ m f k slots (fun i => lists i \ B) a W X =
+      finiteCanonicalMarkedRow p hp hcop hg pool Ψ m f k slots lists a W X := by
+  unfold finiteCanonicalMarkedRow fixedChildRow
+  apply Finset.sum_congr rfl
+  intro U hU
+  by_cases hd : Disjoint B U
+  · have he : U \ B = U := Finset.sdiff_eq_self_of_disjoint hd.symm
+    simp only [secondChildColumn, ← primeMark_residual_lists, he]
+  · obtain ⟨i, hiB, hiU⟩ := Finset.not_disjoint_iff.mp hd
+    rw [secondChildColumn_zero_of_mask_label_mem p hp hcop hg Ψ m f k _ U i hiU (hB i hiB),
+      secondChildColumn_zero_of_mask_label_mem p hp hcop hg Ψ m f k _ U i hiU (hB i hiB)]
+
+theorem secondChildSum_marked_fixed_pool
+    (F V A : Finset ι) (Ψ : Eis →* ℂ) (m r c d e k : Eis)
+    (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ)
+    (W : ℝ → ℂ) (X : ℝ) :
+    secondChildSum p hp hcop hg F V Ψ m r c d e k
+      (fun U => primeMark slots lists a (A ∪ U) * W (primeProductNorm p U / X)) =
+    ∑ J ∈ slots.powerset, primeMark J lists a (A ∪ V) *
+      finiteCanonicalMarkedRow p hp hcop hg F Ψ (m * r)
+        (c * e * ∏ i ∈ V, p i) (d * e * k)
+        (slots \ J) (fun i => lists i \ A) a W (X / primeProductNorm p V) := by
+  rw [secondChildSum_marked_canonical]
+  apply Finset.sum_congr rfl
+  intro J hJ
+  congr 1
+  have hV (i : ι) (hi : i ∈ V) : (m * r) * (c * e * ∏ j ∈ V, p j) ∈ Ideal.span {p i} :=
+    Ideal.mem_span_singleton.mpr (dvd_mul_of_dvd_right
+      (dvd_mul_of_dvd_right (Finset.dvd_prod_of_mem p hi) (c * e)) (m * r))
+  rw [finiteCanonicalMarkedRow_restore_pool p hp hcop hg F V Ψ (m * r)
+    (c * e * ∏ i ∈ V, p i) (d * e * k) _ _ _ _ _ hV]
+  have hlists : (fun i => lists i \ (A ∪ V)) = (fun i => (lists i \ A) \ V) := by
+    funext i
+    ext x
+    simp only [Finset.mem_sdiff, Finset.mem_union]
+    tauto
+  rw [hlists]
+  exact finiteCanonicalMarkedRow_restore_lists p hp hcop hg F V Ψ (m * r)
+    (c * e * ∏ i ∈ V, p i) (d * e * k) _ _ _ _ _ hV
+
+end
+end SevenEighths.InverseMoment
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalChildSupport.lean

@@ -0,0 +1,85 @@
+import OAI.NumberTheory.DirichletL.Descent.FirstCanonicalChildren
+
+namespace OAI
+
+noncomputable section
+open scoped Classical BigOperators
+
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CanonicalQuadraticSieve
+open InverseInitialArithmetic InverseSecondSourceBlocks InverseSecondFibers
+local notation "O"=>ActualEisensteinCubic.O
+variable {ι:Type*}[DecidableEq ι](p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+variable (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i})
+variable (hc:∀i,ringChar (O⧸Ideal.span {p i})≠2)
+
+include hp hg hc in
+omit [DecidableEq ι] in
+lemma canonical_source_prime_supported (i:ι):Supported (Ideal.span {p i}) :=by
+  have hn:(Ideal.span {p i}:Ideal O)≠0:=Ideal.span_singleton_eq_bot.not.mpr (hp i)
+  refine ⟨hn,?_⟩
+  intro P hP
+  obtain ⟨hprime,hle⟩:=(Ideal.mem_normalizedFactors_iff hn).mp hP
+  have he:Ideal.span {p i}=P:=(inferInstance:(Ideal.span {p i}:Ideal O).IsMaximal).eq_of_le hprime.ne_top hle
+  subst P
+  exact ⟨hg i,hc i⟩
+
+lemma canonical_supported_prod {α:Type*}(S:Finset α)(f:α→Ideal O)
+    (hf:∀i∈S,Supported (f i)):Supported (∏i∈S,f i) :=by
+  classical
+  induction S using Finset.induction_on with
+  | empty =>
+    change Supported (1:Ideal O)
+    refine ⟨one_ne_zero,?_⟩
+    intro P hP
+    rw [UniqueFactorizationMonoid.normalizedFactors_one] at hP
+    exact (Multiset.notMem_zero P hP).elim
+  | @insert i S hi ih =>
+    rw [Finset.prod_insert hi,supported_mul_iff]
+    exact ⟨hf i (Finset.mem_insert_self _ _),ih (fun j hj=>hf j (Finset.mem_insert_of_mem hj))⟩
+
+include hp hg hc in
+omit [DecidableEq ι] in
+lemma canonical_source_ideal_supported (S:Finset ι):Supported (sourceIdeal p S) :=by
+  rw [sourceIdeal,FiniteGaussPhase.span_finset_prod]
+  exact canonical_supported_prod S (fun i=>Ideal.span {p i}) (fun i _=>canonical_source_prime_supported p hp hg hc i)
+
+include hp hg hc in
+omit [DecidableEq ι] in
+lemma canonical_prime_product_supported (S:Finset ι)(v:ι→ℕ):Supported (Ideal.span {primeProduct p S v}) :=by
+  rw [primeProduct,FiniteGaussPhase.span_finset_prod]
+  apply canonical_supported_prod
+  intro i hi
+  rw [←Ideal.span_singleton_pow]
+  exact supported_pow (canonical_source_prime_supported p hp hg hc i) _
+
+include hp hg hc in
+lemma actual_second_label_supported {Jo Jn:ℕ}(x:MarkedSecondSource ι Jo Jn):
+    Supported (actualSecondChild p 1 1 x).2.1 :=by
+  change Supported ((Ideal.span {jLabel p x.cube.support
+    (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit})*
+    sourceIdeal p x.firstCommon*sourceIdeal p x.second.divisor*sourceIdeal p x.second.overlap)
+  simp only [supported_mul_iff]
+  exact ⟨⟨⟨canonical_prime_product_supported p hp hg hc _ _,canonical_source_ideal_supported p hp hg hc _⟩,
+    canonical_source_ideal_supported p hp hg hc _⟩,canonical_source_ideal_supported p hp hg hc _⟩
+
+include hp hg hc in
+theorem actual_cell_labels_supported {Jo Jn:ℕ}(S:Finset (MarkedSecondSource ι Jo Jn))(d:BlockIndex):
+    ∀I∈actualCellLabels p S d,Supported I :=by
+  intro I hI
+  obtain ⟨x,hx,rfl⟩:=Finset.mem_image.mp hI
+  exact actual_second_label_supported p hp hg hc x
+
+include hp hg hc in
+theorem actual_cell_labels_admissible {Jo Jn:ℕ}(S:Finset (MarkedSecondSource ι Jo Jn))(d:BlockIndex):
+    ∀I∈(actualCellLabels p S d).filter Squarefree,CanonicalQuadraticSieve.Admissible I :=by
+  intro I hI
+  obtain ⟨hm,hs⟩:=Finset.mem_filter.mp hI
+  have hh:=actual_cell_labels_supported p hp hg hc S d I hm
+  exact ⟨hh.1,hs,hh.2⟩
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteBudget.lean

@@ -0,0 +1,54 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongCosts
+import OAI.NumberTheory.DirichletL.Descent.RecursionParameters
+
+namespace OAI
+
+noncomputable section
+
+namespace SevenEighths.InverseMoment
+
+theorem actual_complete_step_cost (L eta epsChild:ℝ)(hL:0≤L)(heta:0<eta)
+    (heta1:eta≤1)(heps:0≤epsChild):
+    3*eta+firstPassEpsilon L eta*(2*L+7*eta)≤epsChild+60*eta ∧
+    2*L*firstPassEpsilon L eta≤eta ∧
+    (epsChild+60*eta)+2*L*firstPassEpsilon L eta+eta≤epsChild+62*eta := by
+  have hd:0<10*L+32:=by positivity
+  have hp:0<firstPassEpsilon L eta:=div_pos heta hd
+  have he:firstPassEpsilon L eta*(10*L+32)=eta:=by unfold firstPassEpsilon;field_simp
+  have hb:2*L+7*eta≤10*L+32:=by linarith
+  have hc:=mul_le_mul_of_nonneg_left hb hp.le
+  have hl:=mul_le_mul_of_nonneg_left (show 2*L≤10*L+32 by linarith) hp.le
+  constructor
+  · nlinarith
+  constructor <;> nlinarith
+
+theorem actual_complete_height_merge (dshort dlong:ℕ)(Z F cstar loss Cs Cb A theta:ℝ)
+    (hZ:1≤Z)(hcstar:0≤cstar)(hloss:0≤loss)(hCs:0≤Cs)(hCb:0≤Cb)(hA:0≤A):
+    Cs*(1+‖theta‖)^dshort*Z^(F-cstar/256)+
+      Cb*(1+A)*(1+‖theta‖)^dlong*Z^(F+loss)≤
+    (Cs+Cb)*(1+A)*(1+‖theta‖)^(max dshort dlong)*Z^(F+loss) := by
+  have hp:1≤1+‖theta‖:=by linarith [norm_nonneg theta]
+  have hshort:(1+‖theta‖)^dshort≤(1+‖theta‖)^(max dshort dlong):=
+    pow_le_pow_right₀ hp (le_max_left _ _)
+  have hlong:(1+‖theta‖)^dlong≤(1+‖theta‖)^(max dshort dlong):=
+    pow_le_pow_right₀ hp (le_max_right _ _)
+  have hz:0<Z:=zero_lt_one.trans_le hZ
+  have hs:Z^(F-cstar/256)≤Z^(F+loss):=
+    Real.rpow_le_rpow_of_exponent_le hZ (by linarith)
+  have hs':Cs*(1+‖theta‖)^dshort*Z^(F-cstar/256)≤
+      Cs*(1+A)*(1+‖theta‖)^(max dshort dlong)*Z^(F+loss):=by
+    calc
+      _≤Cs*(1+‖theta‖)^(max dshort dlong)*Z^(F+loss):=by gcongr
+      _≤_:=by
+        have hh:Cs≤Cs*(1+A):=by nlinarith
+        exact mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right hh (by positivity)) (by positivity)
+  have hl':Cb*(1+A)*(1+‖theta‖)^dlong*Z^(F+loss)≤
+      Cb*(1+A)*(1+‖theta‖)^(max dshort dlong)*Z^(F+loss):=by gcongr
+  have hh:=add_le_add hs' hl'
+  convert hh using 1 ; ring
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteChildren.lean

@@ -0,0 +1,158 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongCosts
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongHeightBin
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical SchwartzMap ContDiff
+namespace SevenEighths.InverseMoment
+open MeasureTheory ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve CanonicalCubeSeparation FirstPassCubeLabels SecondPassArithmetic
+open InverseMomentFirstLabelCell InverseMomentFirstSecondHeightCost CompletedHeight
+open FourierBridge JointLogSeparation InverseReflectedPhase InverseTerminalWidths InverseSecondFibers
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem actual_complete_state_from_children
+    (lo hi:ℝ)(hlo:0<lo)(hhi:0≤hi)(W:ℝ→ℂ)
+    (hsW:Function.support W⊆Set.Icc lo hi)(hW:ContDiff ℝ ∞ W)
+    (Vlog:𝓢(ℝ,ℂ))(Alog:ℝ)(hbox:∀x,Vlog x≠0 → |x|≤Alog)
+    (hone:∀x,|x|≤columnWindowRadius lo hi → Vlog x=1)
+    (L cstar eta tau saving em ed eps:ℝ)(hL:1≤L)(hcstar:0<cstar)(heta:0<eta)
+    (heta1:eta≤1)(hetac:eta≤cstar/100000)(htau:0<tau)(htau1:tau≤1)
+    (hem:0<em)(hed:0<ed)(heps:0<eps)(K:ℕ):
+    ∃(ω₁₁ ω₁₂ ω₂₁ ω₂₂:𝓢(ℝ,ℂ))(af₁ bf₁ af₂ bf₂ window bw:ℝ)(shortDegree:ℕ),
+      0<af₁ ∧ af₁≤bf₁ ∧ 0<af₂ ∧ af₂≤bf₂ ∧
+      HasCompactSupport (ω₁₁:ℝ→ℂ) ∧ HasCompactSupport (ω₁₂:ℝ→ℂ) ∧
+      HasCompactSupport (ω₂₁:ℝ→ℂ) ∧ HasCompactSupport (ω₂₂:ℝ→ℂ) ∧
+      tsupport (ω₁₁:ℝ→ℂ)⊆Set.Icc af₁ bf₁ ∧ tsupport (ω₁₂:ℝ→ℂ)⊆Set.Icc af₁ bf₁ ∧
+      tsupport (ω₂₁:ℝ→ℂ)⊆Set.Icc af₂ bf₂ ∧ tsupport (ω₂₂:ℝ→ℂ)⊆Set.Icc af₂ bf₂ ∧
+      1≤bw ∧ Real.exp Alog≤bw ∧ bw=Real.exp window ∧
+    ∀epsFirst epsSecond:ℝ,0<epsFirst → 0<epsSecond → ∀degree:ℕ,
+    ∀(q:ℕ)(hq:q≠0),∃Cs Cb Z₀:ℝ,0<Cs ∧ 0≤Cb ∧ 1<Z₀ ∧
+    ∀{σ:Type}[DecidableEq σ](m:O),m≠0 →
+    ∀Z N V M z₀ margin cutoff pi epschild A loss lossFinal theta:ℝ,
+      Z₀≤Z → 2≤Z → 2≤Z^eta → Real.exp 1≤Z^eta → 1≤eta*Real.log Z →
+      0≤N → 0≤V → 0≤M → N+V≤L → M≤N+V → z₀≤L →
+      hi≤Z^eta → Real.exp Alog≤Z^eta → Real.exp window≤Z^eta →
+      0≤cutoff → cutoff≤L → cutoff≤cstar/200 →
+      (Ideal.absNorm (Ideal.span {m}):ℝ)≤Z^L →
+      CanonicalMargins (N+V) M (normWidth Z (Ideal.span {m})) z₀ margin → cstar/2≤margin →
+      0≤pi → 6*eta≤pi → em*(20*(3*L+16)+30)≤pi/4 → ed*(20*(3*L+16)+30)≤pi/4 →
+      0≤epschild → -saving≤48*eta+tau+pi+epschild+epsSecond →
+      48*eta+tau+pi+epschild+epsSecond≤loss →
+      3*eta+epsFirst*(2*L+7*eta)≤lossFinal →
+      loss+(2*L+15*eta+tau)*epsFirst+epsFirst≤lossFinal → -saving≤lossFinal →
+      0≤A →
+    ∀labels:Finset (Ideal O),(∀I∈labels,Supported I ∧ Squarefree I ∧ (I.absNorm:ℝ)≤Z^V) →
+    ∀D:ℕ,hi*Z^N≤D → ∀slots:Finset σ,slots.card≤K →
+    ∀(lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)))(H:σ→ℝ),
+      (slots:Set σ).PairwiseDisjoint lists →
+      (∀i∈slots,1≤H i) → (∀i∈slots,∀P∈lists i,(Ideal.absNorm P.val:ℝ)≤H i) → (∏i∈slots,H i)≤Z^z₀ →
+    ∀(Ψ:O→*ℂ),(∀u,‖Ψ u‖≤1) →
+      CanonicalCoefficientClass.FactorsModulo (CanonicalCoefficientClass.fixedBaseConductor q) Ψ →
+    ∀a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)→ℂ,
+      (∀i∈slots,∀P∈lists i,‖a i P‖≤1) →
+      let S:=reflectionExcludedPrimes q;
+      let F:=InitialMeanSquare.outsideSquarefreeIdeals S D;
+      let hF:=InitialMeanSquare.outsideSquarefree_admissible S D (reflectionExcludedPrimes_bad q);
+      letI : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=fun i=>by rw [poolPrimary_span F hF i];infer_instance;
+      let om:=radialFromLog Vlog (Vlog.smooth ⊤) Alog hbox;
+      (∀j∈cubeLogRange hi (Z^N),
+        let ell:=actualCubeLength Z j;
+        let Q:=progressingCubes S D (Z^(cutoff-V)) (activeCubeLogBin S D hi (Z^N) j);
+        Q.Nonempty → ∀ξ:ℝ,∀k∈actualLongSourceKeys (poolPrimary F) (poolPrimary_ne_zero F hF)
+          (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Q labels Ψ m (m*excludedGenerator S)
+          slots lists a om Z M (N-3*ell) ell V (Z^(cutoff-V)) ξ L eta tau,
+          ChildBounds (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+            (poolPrimary_good F hF) Finset.univ Q k.1 k.2.1 k.2.2 true Ψ m slots lists a ω₁₁ ω₁₂
+            Z M (N-3*ell) ell V eta tau window bw epschild A K degree) →
+      (∀j∈cubeLogRange hi (Z^N),
+        let ell:=actualCubeLength Z j;
+        let Q:=progressingCubes S D (Z^(cutoff-V)) (activeCubeLogBin S D hi (Z^N) j);
+        Q.Nonempty → ∀ξ:���,∀k∈actualLongSourceKeys (poolPrimary F) (poolPrimary_ne_zero F hF)
+          (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Q labels Ψ m (m*excludedGenerator S)
+          slots lists a om Z M (N-3*ell) ell V (Z^(cutoff-V)) ξ L eta tau,
+          ChildBounds (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+            (poolPrimary_good F hF) Finset.univ Q k.1 k.2.1 k.2.2 false Ψ m slots lists a ω₂₁ ω₂₂
+            Z M (N-3*ell) ell V eta tau window bw epschild A K degree) →
+      Z^(-(N+V))*(∑I∈labels,secondLabelWeight K I*∑z∈nonzeroChildFrequencyBall 1 (Z^M),
+        ‖outsideCanonicalMarkedRow S D (reflectionExcludedPrimes_bad q) Ψ m (idealGenerator I) z
+          slots lists a (normTwistedSource W theta) (Z^N)‖^2)≤
+      Cs*(1+‖theta‖)^shortDegree*Z^(N+V-cstar/256)+
+      Cb*(1+A)*(1+‖theta‖)^(2*(InverseClippingProfiles.momentOrder (firstDegree degree)+(volume:Measure ℝ).integrablePower))*
+        Z^(N+V+lossFinal+2*L*epsFirst+eps) := by
+  have hL0:0≤L:=by linarith
+  obtain ⟨w11,w12,w21,w22,af1,bf1,af2,bf2,window,bw,ha1,hab1,ha2,hab2,
+    hw11,hw12,hw21,hw22,hs11,hs12,hs21,hs22,hbw,hbA,hbexp,hbin⟩:=
+    actual_marked_bin_height lo hi hlo hhi W hsW hW Vlog Alog hbox hone L eta tau saving em ed
+      hL0 heta.le heta1 htau htau1 hem hed K
+  obtain ⟨ds,hstate⟩:=actual_complete_state_from_live_bins lo hi hlo hhi W hsW hW L cstar eta eps
+    hL0 hcstar heta heta1 hetac heps K K
+  refine ⟨w11,w12,w21,w22,af1,bf1,af2,bf2,window,bw,ds,ha1,hab1,ha2,hab2,
+    hw11,hw12,hw21,hw22,hs11,hs12,hs21,hs22,hbw,hbA,hbexp,?_⟩
+  intro epsFirst epsSecond heF heS degree q hq
+  obtain ⟨Ccoef,C,hcoef,hC,hbin⟩:=hbin epsFirst epsSecond heF heS degree
+  obtain ⟨Cs,Z₀,hCs,hZ₀,hstate⟩:=hstate q hq
+  let Cb:=C*Ccoef^2*Real.exp (2*epsFirst)
+  refine ⟨Cs,Cs*Cb,Z₀,hCs,by dsimp [Cb];positivity,hZ₀,?_⟩
+  intro σ _ m hm Z N V M z₀ margin cutoff pi epschild A loss lossFinal theta hZ hZ2 h2 hExp hlog
+    hN hV hM hFcap hMF hzcap hbZ hAZ hwin hcut hcutL hcutc hmN hmargin hreserve
+    hpi hpieta hemc hedc hechild hsave hloss hprincipal hretained htail hA
+    labels hlabels D hD slots hcard lists H hdis hH1 hH hprod Ψ hΨ hperiod a ha
+  dsimp only
+  intro hleft hright
+  have hz:0<Z:=by linarith
+  have hZ1:1≤Z:=by linarith
+  let d:=2*(InverseClippingProfiles.momentOrder (firstDegree degree)+(volume:Measure ℝ).integrablePower)
+  let E:=Cb*(1+A)*Z^(N+V+lossFinal+2*L*epsFirst)*(1+‖theta‖)^d
+  have hE:0≤E:=by dsimp [E,Cb];positivity
+  have hbins:∀j∈cubeLogRange hi (Z^N),
+      (progressingCubes (reflectionExcludedPrimes q) D (Z^(cutoff-V))
+        (activeCubeLogBin (reflectionExcludedPrimes q) D hi (Z^N) j)).Nonempty →
+      Z^(-V)*rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin (reflectionExcludedPrimes q) D
+        (progressingCubes (reflectionExcludedPrimes q) D (Z^(cutoff-V))
+          (activeCubeLogBin (reflectionExcludedPrimes q) D hi (Z^N) j))
+        Ψ m (idealGenerator I) z (normTwistedSource W theta) (Z^N) (Z^(cutoff-V)) slots lists a) (Z^M)≤E := by
+    intro j hj hne
+    let ell:=actualCubeLength Z j
+    let S:=reflectionExcludedPrimes q
+    let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+    have hF:=InitialMeanSquare.outsideSquarefree_admissible S D (reflectionExcludedPrimes_bad q)
+    let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=fun i=>by rw [poolPrimary_span F hF i];infer_instance
+    let Q:=progressingCubes S D (Z^(cutoff-V)) (activeCubeLogBin S D hi (Z^N) j)
+    obtain ⟨hel,hr,hrL,helL,hFL,hgap,hqn⟩:=actual_long_bin_geometry S D (reflectionExcludedPrimes_bad q)
+      hi Z N V cutoff eta L j (by linarith) hL heta1 hV hFcap hbZ hlog hne
+    have hsN:(N-3*ell)+3*ell=N:=by ring
+    have hpr:3*eta+epsFirst*(5*ell+2*(N-3*ell)+7*eta)≤lossFinal:=by
+      have hNL:N≤L:=by linarith
+      nlinarith
+    have hh:=hbin theta S D (reflectionExcludedPrimes_bad q) (reflectionExcludedPrimes_prime q)
+      Q labels Ψ m slots lists a Z M (N-3*ell) ell V (Z^(cutoff-V)) pi epschild A loss lossFinal
+      hZ2 h2 hExp hM hFL (by linarith) hel hV hr hAZ
+      (by intro v hv;rw [←cubeIdeal_primeProduct_norm F hF];exact (hqn v hv).1)
+      (by intro v hv;rw [←cubeIdeal_primeProduct_norm F hF];exact (hqn v hv).2)
+      hrL helL (by linarith) hwin hpi hpieta hemc hedc hechild (by linarith) hloss hcard
+      (by linarith) hpr hretained (by linarith) hΨ hA
+      (fun I hI=>(hlabels I hI).2.1) (fun I hI=>(hlabels I hI).1.1)
+      (fun I hI=>((hlabels I hI).2.2).trans (Real.rpow_le_rpow_of_exponent_le hZ1 (by linarith)))
+      hdis ha (by simpa only [hsN] using hD) (hleft j hj hne) (hright j hj hne)
+    rw [hsN] at hh
+    apply hh.trans
+    have hc:=mul_le_mul_of_nonneg_right
+      (actual_long_uniform_parent_cost Z ell N V L epsFirst Ccoef C A lossFinal hZ1 helL heF.le hC hA)
+      (show 0≤(1+‖theta‖)^d by positivity)
+    simpa only [hsN] using hc
+  have hs:=hstate m hm Z N V M z₀ margin cutoff hZ hN (by linarith) hV (by linarith) hM (by linarith)
+    hzcap hcut hcutL hcutc hmN hmargin hreserve labels hlabels D hD slots hcard lists H
+    hdis hH1 hH hprod Ψ hΨ hperiod theta a ha E hE hbins
+  apply hs.trans_eq
+  dsimp [E,d]
+  rw [Real.rpow_add hz (N+V+lossFinal+2*L*epsFirst) eps]
+  ring
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteNormalized.lean

@@ -0,0 +1,91 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongNormalization
+import OAI.NumberTheory.DirichletL.Descent.CanonicalPunctureMaskEnergy
+import OAI.NumberTheory.DirichletL.Descent.CompletedReopening
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve FirstPassCubeLabels SecondPassArithmetic InverseInitialClippedColumns
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem normalizedColumnEnergy_eq_generator_sum {ι σ:Type*}[DecidableEq ι][DecidableEq σ]
+    (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+    (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+    (hg:∀i,goodLambda∉Ideal.span {p i})
+    (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+    (labels:Finset (Ideal O))(hlabels:∀I∈labels,primaryGenerator I≠0)
+    (weight:Ideal O→ℝ)(W:ℝ→ℂ)(X Z F R:ℝ)(hZ:0<Z) :
+    normalizedColumnEnergy p hp hcop hg pool Ψ m slots lists a labels
+      (nonzeroChildFrequencyBall 1 R) weight W X Z F=
+    Z^(-F)*(∑I∈labels,weight I*∑k∈nonzeroChildFrequencyBall 1 R,
+      ‖finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (idealGenerator I) k slots lists a W X‖^2) := by
+  have hn:‖((Z^(-F/2):ℝ):ℂ)‖^2=Z^(-F) := by
+    rw [Complex.norm_real,Real.norm_eq_abs,abs_of_pos (Real.rpow_pos_of_pos hZ _),
+      ←Real.rpow_mul_natCast hZ.le]
+    congr 1
+    ring
+  unfold normalizedColumnEnergy
+  simp only [norm_mul,mul_pow,hn,←Finset.mul_sum]
+  rw [Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro I hI
+  rw [canonical_ball_generator_energy p hp hcop hg pool Ψ m I (hlabels I hI)]
+  ring
+
+theorem outside_complete_normalized_energy {σ:Type*}[DecidableEq σ]
+    (S:Finset (Ideal O))(D:ℕ)(hbad:fixedBadPrimes⊆S)
+    (Ψ:O→*ℂ)(m:O)(slots:Finset σ)
+    (lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)))
+    (a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ)
+    (labels:Finset (Ideal O))(hlabels:∀I∈labels,Supported I)
+    (weight:Ideal O→ℝ)(W:ℝ→ℂ)(X Z Fexp R:ℝ)(hZ:0<Z) :
+    let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+    let hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad
+    letI : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=
+      fun i=>by rw [poolPrimary_span F hF i];infer_instance
+    Z^(-Fexp)*(∑I∈labels,weight I*∑k∈nonzeroChildFrequencyBall 1 R,
+      ‖outsideCanonicalMarkedRow S D hbad Ψ m (idealGenerator I) k slots lists a W X‖^2)=
+    normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF)
+      (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Ψ m slots lists a labels
+      (nonzeroChildFrequencyBall 1 R) weight W X Z Fexp := by
+  let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+  have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad
+  let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=
+    fun i=>by rw [poolPrimary_span F hF i];infer_instance
+  dsimp only
+  exact (normalizedColumnEnergy_eq_generator_sum (poolPrimary F) (poolPrimary_ne_zero F hF)
+    (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Ψ m slots lists a labels
+    (fun I hI=>supported_primaryGenerator_ne_zero I (hlabels I hI)) weight W X Z Fexp R hZ).symm
+
+theorem reflection_complete_normalized_energy {σ:Type*}[DecidableEq σ]
+    (q D:ℕ)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)
+    (lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)))
+    (a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)→ℂ)
+    (labels:Finset (Ideal O))(hlabels:∀I∈labels,Supported I)
+    (weight:Ideal O→ℝ)(W:ℝ→ℂ)(X Z Fexp R:ℝ)(hZ:0<Z) :
+    let S:=reflectionExcludedPrimes q
+    let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+    let hF:=InitialMeanSquare.outsideSquarefree_admissible S D (reflectionExcludedPrimes_bad q)
+    letI : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=
+      fun i=>by rw [poolPrimary_span F hF i];infer_instance
+    Z^(-Fexp)*(∑I∈labels,weight I*∑k∈nonzeroChildFrequencyBall 1 R,
+      ‖outsideCanonicalMarkedRow S D (reflectionExcludedPrimes_bad q) Ψ m (idealGenerator I) k
+        slots lists a W X‖^2)=
+    normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF)
+      (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Ψ
+      (ActualFiber.maskElement q m) slots lists a labels
+      (nonzeroChildFrequencyBall 1 R) weight W X Z Fexp := by
+  have h:=outside_complete_normalized_energy (reflectionExcludedPrimes q) D
+    (reflectionExcludedPrimes_bad q) Ψ m slots lists a labels hlabels weight W X Z Fexp R hZ
+  exact h.trans (reflection_pool_mask_energy q D Finset.univ Ψ m slots lists a labels
+    (nonzeroChildFrequencyBall 1 R) weight W X Z Fexp).symm
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteRank.lean

@@ -0,0 +1,125 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalCompleteChildren
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLiveBinRank
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical SchwartzMap ContDiff
+namespace SevenEighths.InverseMoment
+open MeasureTheory ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve CanonicalCubeSeparation FirstPassCubeLabels SecondPassArithmetic
+open InverseMomentFirstLabelCell InverseMomentFirstSecondHeightCost CompletedHeight
+open FourierBridge JointLogSeparation InverseReflectedPhase InverseTerminalWidths InverseSecondFibers
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem actual_complete_state_from_rank_moments
+    (lo hi:ℝ)(hlo:0<lo)(hhi:0≤hi)(W:ℝ→ℂ)
+    (hsW:Function.support W⊆Set.Icc lo hi)(hW:ContDiff ℝ ∞ W)
+    (Vlog:𝓢(ℝ,ℂ))(Alog:ℝ)(hbox:∀x,Vlog x≠0 → |x|≤Alog)
+    (hone:∀x,|x|≤columnWindowRadius lo hi → Vlog x=1)
+    (L cstar eta tau saving em ed eps:ℝ)(hL:1≤L)(hcstar:0<cstar)(heta:0<eta)
+    (heta1:eta≤1)(hetac:eta≤cstar/100000)(htau:0<tau)(htau1:tau≤1)
+    (hem:0<em)(hed:0<ed)(heps:0<eps)(K:ℕ):
+    ∃(ω₁₁ ω₁₂ ω₂₁ ω₂₂:𝓢(ℝ,ℂ))(af₁ bf₁ af₂ bf₂ window bw:ℝ)(shortDegree:ℕ),
+      0<af₁ ∧ af₁≤bf₁ ∧ 0<af₂ ∧ af₂≤bf₂ ∧
+      HasCompactSupport (ω₁₁:ℝ→ℂ) ∧ HasCompactSupport (ω₁₂:ℝ→ℂ) ∧
+      HasCompactSupport (ω₂₁:ℝ→ℂ) ∧ HasCompactSupport (ω₂₂:ℝ→ℂ) ∧
+      tsupport (ω₁₁:ℝ→ℂ)⊆Set.Icc af₁ bf₁ ∧ tsupport (ω₁₂:ℝ→ℂ)⊆Set.Icc af₁ bf₁ ∧
+      tsupport (ω₂₁:ℝ→ℂ)⊆Set.Icc af₂ bf₂ ∧ tsupport (ω₂₂:ℝ→ℂ)⊆Set.Icc af₂ bf₂ ∧
+      1≤bw ∧ Real.exp Alog≤bw ∧ bw=Real.exp window ∧
+    ∀epsFirst epsSecond:ℝ,0<epsFirst → 0<epsSecond → ∀degree:ℕ,
+    ∀(q:ℕ)(hq:q≠0),∃Cs Cb Z₀:ℝ,0<Cs ∧ 0≤Cb ∧ 1<Z₀ ∧
+    ∀{σ:Type}[DecidableEq σ](m:O),m≠0 →
+    ∀Z N V M z₀ margin cutoff pi epschild A loss lossFinal theta:ℝ,
+      Z₀≤Z → 2≤Z → 2≤Z^eta → Real.exp 1≤Z^eta → 1≤eta*Real.log Z →
+      0≤N → 0≤V → 0≤M → N+V≤L → M≤N+V → z₀≤L →
+      hi≤Z^eta → Real.exp Alog≤Z^eta → Real.exp window≤Z^eta →
+      0<cutoff → cutoff≤L → cutoff≤cstar/200 → eta≤cutoff/32 →
+      (Ideal.absNorm (Ideal.span {m}):ℝ)≤Z^L →
+      CanonicalMargins (N+V) M (normWidth Z (Ideal.span {m})) z₀ margin → cstar/2≤margin →
+      (Ideal.absNorm (Ideal.span {m}:Ideal O).radical:ℝ)≤Z^(normWidth Z (Ideal.span {m})) →
+      0≤pi → 6*eta≤pi → em*(20*(3*L+16)+30)≤pi/4 → ed*(20*(3*L+16)+30)≤pi/4 →
+      0≤epschild → -saving≤48*eta+tau+pi+epschild+epsSecond →
+      48*eta+tau+pi+epschild+epsSecond≤loss →
+      3*eta+epsFirst*(2*L+7*eta)≤lossFinal →
+      loss+(2*L+15*eta+tau)*epsFirst+epsFirst≤lossFinal → -saving≤lossFinal →
+      0≤A →
+    ∀labels:Finset (Ideal O),(∀I∈labels,Supported I ∧ Squarefree I ∧ (I.absNorm:ℝ)≤Z^V) →
+    ∀D:ℕ,hi*Z^N≤D → ∀slots:Finset σ,slots.card≤K →
+    ∀(lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)))(H:σ→ℝ),
+      (slots:Set σ).PairwiseDisjoint lists →
+      (∀i∈slots,1≤H i) → (∀i∈slots,∀P∈lists i,(Ideal.absNorm P.val:ℝ)≤H i) → (∏i∈slots,H i)≤Z^z₀ →
+    ∀(base Ψ:O→*ℂ),CanonicalCoefficientClass.IsBaseRayTwist base Ψ → (∀u,‖Ψ u‖≤1) →
+      CanonicalCoefficientClass.FactorsModulo (CanonicalCoefficientClass.fixedBaseConductor q) Ψ →
+    ∀a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)→ℂ,
+      (∀i∈slots,∀P∈lists i,‖a i P‖≤1) →
+      let S:=reflectionExcludedPrimes q;
+      let F:=InitialMeanSquare.outsideSquarefreeIdeals S D;
+      let hF:=InitialMeanSquare.outsideSquarefree_admissible S D (reflectionExcludedPrimes_bad q);
+      letI : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=fun i=>by rw [poolPrimary_span F hF i];infer_instance;
+      let _om:=radialFromLog Vlog (Vlog.smooth ⊤) Alog hbox;
+      CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+        (poolPrimary_good F hF) Finset.univ base slots lists a ω₁₁
+        Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree →
+      CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+        (poolPrimary_good F hF) Finset.univ base slots lists a ω₁₂
+        Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree →
+      CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+        (poolPrimary_good F hF) Finset.univ base slots lists a ω₂₁
+        Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree →
+      CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+        (poolPrimary_good F hF) Finset.univ base slots lists a ω₂₂
+        Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree →
+      Z^(-(N+V))*(∑I∈labels,secondLabelWeight K I*∑z∈nonzeroChildFrequencyBall 1 (Z^M),
+        ‖outsideCanonicalMarkedRow S D (reflectionExcludedPrimes_bad q) Ψ m (idealGenerator I) z
+          slots lists a (normTwistedSource W theta) (Z^N)‖^2)≤
+      Cs*(1+‖theta‖)^shortDegree*Z^(N+V-cstar/256)+
+      Cb*(1+A)*(1+‖theta‖)^(2*(InverseClippingProfiles.momentOrder (firstDegree degree)+(volume:Measure ℝ).integrablePower))*
+        Z^(N+V+lossFinal+2*L*epsFirst+eps) := by
+  obtain ⟨w11,w12,w21,w22,af1,bf1,af2,bf2,window,bw,ds,ha1,hab1,ha2,hab2,
+    hw11,hw12,hw21,hw22,hs11,hs12,hs21,hs22,hbw,hbA,hbexp,hstep⟩:=
+    actual_complete_state_from_children lo hi hlo hhi W hsW hW Vlog Alog hbox hone
+      L cstar eta tau saving em ed eps hL hcstar heta heta1 hetac htau htau1 hem hed heps K
+  refine ⟨w11,w12,w21,w22,af1,bf1,af2,bf2,window,bw,ds,ha1,hab1,ha2,hab2,
+    hw11,hw12,hw21,hw22,hs11,hs12,hs21,hs22,hbw,hbA,hbexp,?_⟩
+  intro epsFirst epsSecond heF heS degree q hq
+  obtain ⟨Cs,Cb,Z₀,hCs,hCb,hZ₀,hstep⟩:=hstep epsFirst epsSecond heF heS degree q hq
+  refine ⟨Cs,Cb,Z₀,hCs,hCb,hZ₀,?_⟩
+  intro σ _ m hm Z N V M z₀ margin cutoff pi epschild A loss lossFinal theta hZ hZ2 h2 hExp hlog
+    hN hV hM hFcap hMF hzcap hbZ hAZ hwin hcut hcutL hcutc hsmall hmN hmargin hreserve hpuncture
+    hpi hpieta hemc hedc hechild hsave hloss hprincipal hretained htail hA
+    labels hlabels D hD slots hcard lists H hdis hH1 hH hprod base Ψ hbase hΨ hperiod a ha
+  dsimp only
+  intro h11 h12 h21 h22
+  apply hstep m hm Z N V M z₀ margin cutoff pi epschild A loss lossFinal theta hZ hZ2 h2 hExp hlog
+    hN hV hM hFcap hMF hzcap hbZ hAZ hwin hcut.le hcutL hcutc hmN hmargin hreserve
+    hpi hpieta hemc hedc hechild hsave hloss hprincipal hretained htail hA
+    labels hlabels D hD slots hcard lists H hdis hH1 hH hprod Ψ hΨ hperiod a ha
+  · intro j hj
+    dsimp only
+    intro hne ξ k hk
+    exact actual_live_bin_rank_children (reflectionExcludedPrimes q) D (reflectionExcludedPrimes_bad q)
+      Z N V M cutoff eta L bw window hi (normWidth Z (Ideal.span {m})) z₀ margin epschild A
+      (M-3*(cutoff/2)/2) (N+V+15*eta) (margin-7*eta) tau
+      j (by linarith) hL heta.le heta1 hcut hsmall hV hFcap hbZ hlog hExp h2 hbw
+      (by rw [hbexp]; exact hwin.trans (Real.rpow_le_rpow_of_exponent_le (by linarith) (by linarith)))
+      (hwin.trans (Real.rpow_le_rpow_of_exponent_le (by linarith) (by linarith))) hne
+      base Ψ hbase m hm hmargin hpuncture le_rfl le_rfl le_rfl slots lists a w11 w12 K degree h11 h12 k.1 k.2.1 k.2.2 true
+
+  · intro j hj
+    dsimp only
+    intro hne ξ k hk
+    exact actual_live_bin_rank_children (reflectionExcludedPrimes q) D (reflectionExcludedPrimes_bad q)
+      Z N V M cutoff eta L bw window hi (normWidth Z (Ideal.span {m})) z₀ margin epschild A
+      (M-3*(cutoff/2)/2) (N+V+15*eta) (margin-7*eta) tau
+      j (by linarith) hL heta.le heta1 hcut hsmall hV hFcap hbZ hlog hExp h2 hbw
+      (by rw [hbexp]; exact hwin.trans (Real.rpow_le_rpow_of_exponent_le (by linarith) (by linarith)))
+      (hwin.trans (Real.rpow_le_rpow_of_exponent_le (by linarith) (by linarith))) hne
+      base Ψ hbase m hm hmargin hpuncture le_rfl le_rfl le_rfl slots lists a w21 w22 K degree h21 h22 k.1 k.2.1 k.2.2 false
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteRankNormalized.lean

@@ -0,0 +1,109 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalCompleteRank
+import OAI.NumberTheory.DirichletL.Descent.CanonicalCompleteNormalized
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical SchwartzMap ContDiff
+namespace SevenEighths.InverseMoment
+open MeasureTheory ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve CanonicalCubeSeparation FirstPassCubeLabels SecondPassArithmetic
+open InverseMomentFirstLabelCell InverseMomentFirstSecondHeightCost CompletedHeight
+open InverseInitialClippedColumns FourierBridge JointLogSeparation InverseReflectedPhase InverseTerminalWidths InverseSecondFibers
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem actual_complete_normalized_rank_step
+    (lo hi:ℝ)(hlo:0<lo)(hhi:0≤hi)(W:ℝ→ℂ)
+    (hsW:Function.support W⊆Set.Icc lo hi)(hW:ContDiff ℝ ∞ W)
+    (Vlog:𝓢(ℝ,ℂ))(Alog:ℝ)(hbox:∀x,Vlog x≠0 → |x|≤Alog)
+    (hone:∀x,|x|≤columnWindowRadius lo hi → Vlog x=1)
+    (L cstar eta tau saving em ed eps:ℝ)(hL:1≤L)(hcstar:0<cstar)(heta:0<eta)
+    (heta1:eta≤1)(hetac:eta≤cstar/100000)(htau:0<tau)(htau1:tau≤1)
+    (hem:0<em)(hed:0<ed)(heps:0<eps)(K:ℕ):
+    ∃(ω₁₁ ω₁₂ ω₂₁ ω₂₂:𝓢(ℝ,ℂ))(af₁ bf₁ af₂ bf₂ window bw:ℝ)(shortDegree:ℕ),
+      0<af₁ ∧ af₁≤bf₁ ∧ 0<af₂ ∧ af₂≤bf₂ ∧
+      HasCompactSupport (ω₁₁:ℝ→ℂ) ∧ HasCompactSupport (ω₁₂:ℝ→ℂ) ∧
+      HasCompactSupport (ω₂₁:ℝ→ℂ) ∧ HasCompactSupport (ω₂₂:ℝ→ℂ) ∧
+      tsupport (ω₁₁:ℝ→ℂ)⊆Set.Icc af₁ bf₁ ∧ tsupport (ω₁₂:ℝ→ℂ)⊆Set.Icc af₁ bf₁ ∧
+      tsupport (ω₂₁:ℝ→ℂ)⊆Set.Icc af₂ bf₂ ∧ tsupport (ω₂₂:ℝ→ℂ)⊆Set.Icc af₂ bf₂ ∧
+      1≤bw ∧ Real.exp Alog≤bw ∧ bw=Real.exp window ∧
+    ∀epsFirst epsSecond:ℝ,0<epsFirst → 0<epsSecond → ∀degree:ℕ,
+    ∀(q:ℕ)(hq:q≠0),∃Cs Cb Z₀:ℝ,0<Cs ∧ 0≤Cb ∧ 1<Z₀ ∧
+    ∀{σ:Type}[DecidableEq σ](m:O),m≠0 →
+    ∀Z N V M z₀ margin cutoff pi epschild A loss lossFinal theta:ℝ,
+      Z₀≤Z → 2≤Z → 2≤Z^eta → Real.exp 1≤Z^eta → 1≤eta*Real.log Z →
+      0≤N → 0≤V → 0≤M → N+V≤L → M≤N+V → z₀≤L →
+      hi≤Z^eta → Real.exp Alog≤Z^eta → Real.exp window≤Z^eta →
+      0<cutoff → cutoff≤L → cutoff≤cstar/200 → eta≤cutoff/32 →
+      (Ideal.absNorm (Ideal.span {m}):ℝ)≤Z^L →
+      CanonicalMargins (N+V) M (normWidth Z (Ideal.span {m})) z₀ margin → cstar/2≤margin →
+      (Ideal.absNorm (Ideal.span {m}:Ideal O).radical:ℝ)≤Z^(normWidth Z (Ideal.span {m})) →
+      0≤pi → 6*eta≤pi → em*(20*(3*L+16)+30)≤pi/4 → ed*(20*(3*L+16)+30)≤pi/4 →
+      0≤epschild → -saving≤48*eta+tau+pi+epschild+epsSecond →
+      48*eta+tau+pi+epschild+epsSecond≤loss →
+      3*eta+epsFirst*(2*L+7*eta)≤lossFinal →
+      loss+(2*L+15*eta+tau)*epsFirst+epsFirst≤lossFinal → -saving≤lossFinal →
+      0≤A →
+    ∀labels:Finset (Ideal O),(∀I∈labels,Supported I ∧ Squarefree I ∧ (I.absNorm:ℝ)≤Z^V) →
+    ∀D:ℕ,hi*Z^N≤D → ∀slots:Finset σ,slots.card≤K →
+    ∀(lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)))(H:σ→ℝ),
+      (slots:Set σ).PairwiseDisjoint lists →
+      (∀i∈slots,1≤H i) → (∀i∈slots,∀P∈lists i,(Ideal.absNorm P.val:ℝ)≤H i) → (∏i∈slots,H i)≤Z^z₀ →
+    ∀(base Ψ:O→*ℂ),CanonicalCoefficientClass.IsBaseRayTwist base Ψ → (∀u,‖Ψ u‖≤1) →
+      CanonicalCoefficientClass.FactorsModulo (CanonicalCoefficientClass.fixedBaseConductor q) Ψ →
+    ∀a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)→ℂ,
+      (∀i∈slots,∀P∈lists i,‖a i P‖≤1) →
+      let S:=reflectionExcludedPrimes q;
+      let F:=InitialMeanSquare.outsideSquarefreeIdeals S D;
+      let hF:=InitialMeanSquare.outsideSquarefree_admissible S D (reflectionExcludedPrimes_bad q);
+      letI : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=fun i=>by rw [poolPrimary_span F hF i];infer_instance;
+      let _om:=radialFromLog Vlog (Vlog.smooth ⊤) Alog hbox;
+      CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+        (poolPrimary_good F hF) Finset.univ base slots lists a ω₁₁
+        Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree →
+      CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+        (poolPrimary_good F hF) Finset.univ base slots lists a ω₁₂
+        Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree →
+      CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+        (poolPrimary_good F hF) Finset.univ base slots lists a ω₂₁
+        Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree →
+      CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+        (poolPrimary_good F hF) Finset.univ base slots lists a ω₂₂
+        Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree →
+      normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF)
+        (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Ψ m slots lists a labels
+        (nonzeroChildFrequencyBall 1 (Z^M)) (secondLabelWeight K) (normTwistedSource W theta)
+        (Z^N) Z (N+V)≤
+      Cs*(1+‖theta‖)^shortDegree*Z^(N+V-cstar/256)+
+      Cb*(1+A)*(1+‖theta‖)^(2*(InverseClippingProfiles.momentOrder (firstDegree degree)+(volume:Measure ℝ).integrablePower))*
+        Z^(N+V+lossFinal+2*L*epsFirst+eps) := by
+  obtain ⟨w11,w12,w21,w22,af1,bf1,af2,bf2,window,bw,ds,ha1,hab1,ha2,hab2,
+    hw11,hw12,hw21,hw22,hs11,hs12,hs21,hs22,hbw,hbA,hbexp,hstep⟩:=
+    actual_complete_state_from_rank_moments lo hi hlo hhi W hsW hW Vlog Alog hbox hone
+      L cstar eta tau saving em ed eps hL hcstar heta heta1 hetac htau htau1 hem hed heps K
+  refine ⟨w11,w12,w21,w22,af1,bf1,af2,bf2,window,bw,ds,ha1,hab1,ha2,hab2,
+    hw11,hw12,hw21,hw22,hs11,hs12,hs21,hs22,hbw,hbA,hbexp,?_⟩
+  intro epsFirst epsSecond heF heS degree q hq
+  obtain ⟨Cs,Cb,Z₀,hCs,hCb,hZ₀,hstep⟩:=hstep epsFirst epsSecond heF heS degree q hq
+  refine ⟨Cs,Cb,Z₀,hCs,hCb,hZ₀,?_⟩
+  intro σ _ m hm Z N V M z₀ margin cutoff pi epschild A loss lossFinal theta hZ hZ2 h2 hExp hlog
+    hN hV hM hFcap hMF hzcap hbZ hAZ hwin hcut hcutL hcutc hsmall hmN hmargin hreserve hpuncture
+    hpi hpieta hemc hedc hechild hsave hloss hprincipal hretained htail hA
+    labels hlabels D hD slots hcard lists H hdis hH1 hH hprod base Ψ hbase hΨ hperiod a ha
+  dsimp only
+  intro h11 h12 h21 h22
+  have hh:=hstep m hm Z N V M z₀ margin cutoff pi epschild A loss lossFinal theta hZ hZ2 h2 hExp hlog
+    hN hV hM hFcap hMF hzcap hbZ hAZ hwin hcut hcutL hcutc hsmall hmN hmargin hreserve hpuncture
+    hpi hpieta hemc hedc hechild hsave hloss hprincipal hretained htail hA
+    labels hlabels D hD slots hcard lists H hdis hH1 hH hprod base Ψ hbase hΨ hperiod a ha h11 h12 h21 h22
+  rw [outside_complete_normalized_energy (reflectionExcludedPrimes q) D (reflectionExcludedPrimes_bad q)
+    Ψ m slots lists a labels (fun I hI=>(hlabels I hI).1) (secondLabelWeight K)
+    (normTwistedSource W theta) (Z^N) Z (N+V) (Z^M) (by linarith)] at hh
+  exact hh
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteState.lean

@@ -0,0 +1,102 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalShortFinite
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongTotal
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical ContDiff
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve InverseReflectedPhase InverseTerminalWidths CompletedHeight
+open InverseCanonicalShortAttachment InverseSecondFibers FirstPassCubeLabels SecondPassArithmetic
+local notation "O"=>ActualEisensteinCubic.O
+universe v
+
+theorem actual_complete_state_from_live_bins
+    (lo hi:ℝ)(hlo:0<lo)(hhi:0≤hi)(W:ℝ→ℂ)
+    (hWs:Function.support W⊆Set.Icc lo hi)(hW:ContDiff ℝ ∞ W)
+    (L cstar eta eps:ℝ)(hL:0≤L)(hcstar:0<cstar)(heta:0<eta)
+    (heta1:eta≤1)(hetac:eta≤cstar/100000)(heps:0<eps)(rmax K:ℕ) :
+    ∃degree:ℕ,∀(q:ℕ)(_hq:q≠0),∃C Z₀:ℝ,0<C ∧ 1<Z₀ ∧
+    ∀{σ:Type v}[DecidableEq σ](m:O),m≠0 → ∀Z N V M z₀ margin cutoff:ℝ,
+      Z₀≤Z → 0≤N → N≤L → 0≤V → V≤L → 0≤M → M≤L → z₀≤L →
+      0≤cutoff → cutoff≤L → cutoff≤cstar/200 →
+      (Ideal.absNorm (Ideal.span {m}):ℝ)≤Z^L →
+      CanonicalMargins (N+V) M (normWidth Z (Ideal.span {m})) z₀ margin → cstar/2≤margin →
+    ∀labels:Finset (Ideal O),(∀I∈labels,Supported I ∧ Squarefree I ∧ (I.absNorm:ℝ)≤Z^V) →
+    ∀D:ℕ,hi*Z^N≤D → ∀slots:Finset σ,slots.card≤rmax →
+    ∀(lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)))(H:σ→ℝ),
+      (slots:Set σ).Pairwise (fun i j=>Disjoint (lists i) (lists j)) →
+      (∀i∈slots,1≤H i) → (∀i∈slots,∀P∈lists i,(Ideal.absNorm P.val:ℝ)≤H i) → (∏i∈slots,H i)≤Z^z₀ →
+    ∀(Ψ:O→*ℂ),(∀u,‖Ψ u‖≤1) →
+      CanonicalCoefficientClass.FactorsModulo (CanonicalCoefficientClass.fixedBaseConductor q) Ψ →
+    ∀(theta:ℝ)(a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)→ℂ),
+      (∀i∈slots,∀P∈lists i,‖a i P‖≤1) → ∀E:ℝ,0≤E →
+      let S:=reflectionExcludedPrimes q;
+      let test:=normTwistedSource W theta;
+      (∀j∈cubeLogRange hi (Z^N),
+        (progressingCubes S D (Z^(cutoff-V)) (activeCubeLogBin S D hi (Z^N) j)).Nonempty →
+        Z^(-V)*rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D
+          (progressingCubes S D (Z^(cutoff-V)) (activeCubeLogBin S D hi (Z^N) j))
+          Ψ m (idealGenerator I) z test (Z^N) (Z^(cutoff-V)) slots lists a) (Z^M)≤E) →
+      Z^(-(N+V))*(∑I∈labels,secondLabelWeight K I*∑z∈nonzeroChildFrequencyBall 1 (Z^M),
+        ‖outsideCanonicalMarkedRow S D (reflectionExcludedPrimes_bad q) Ψ m (idealGenerator I) z
+          slots lists a test (Z^N)‖^2)≤
+      C*((1+‖theta‖)^degree*Z^(N+V-cstar/256)+Z^eps*E) := by
+  obtain ⟨degree,hs⟩:=actual_complete_short_finite_uniform_degree lo hi hlo W hWs hW L cstar eta
+    hL hcstar heta heta1 hetac rmax K
+  obtain ⟨Cl,hCl,hl⟩:=actual_complete_energy_from_live_bins K hi L eps hhi hL heps
+  refine ⟨degree,?_⟩
+  intro q hq
+  obtain ⟨Cs,Z₀,hCs,hZ₀,hshort⟩:=hs q hq
+  refine ⟨2*Cs+Cl,Z₀,by positivity,hZ₀,?_⟩
+  intro σ _ m hm Z N V M z₀ margin cutoff hZ hN hNL hV hVL hM hML hzL hcut hcutL hcutc
+    hmN hmargin hreserve labels hlabels D hD slots hcard lists H hdis hH1 hH hprod Ψ hΨ hperiod theta a ha E hE
+  dsimp only
+  intro hbins
+  have hz:0<Z:=zero_lt_one.trans (lt_of_lt_of_le hZ₀ hZ)
+  have hZ1:1≤Z:=(hZ₀.trans_le hZ).le
+  let S:=reflectionExcludedPrimes q
+  let test:=normTwistedSource W theta
+  let mark:=indexedIdealMark (fun i:primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)=>i.val) slots lists a
+  have htest:HasCompactSupport test:=HasCompactSupport.of_support_subset_isCompact isCompact_Icc
+    ((normTwistedSource_support W theta).trans hWs)
+  have hupper:∀x,test x≠0 → x≤hi:=fun x hx=>(hWs (normTwistedSource_support W theta hx)).2
+  have hT:∀z∈nonzeroChildFrequencyBall 1 (Z^M),z≠0 ∧ (Ideal.absNorm (Ideal.span {z}):ℝ)≤Z^M := by
+    intro z hz
+    have hh:=(mem_nonzeroChildFrequencyBall 1 one_ne_zero (Z^M) z).mp hz
+    constructor
+    · intro he
+      simp only [he,mul_zero,map_zero,norm_zero,pow_succ,lt_self_iff_false] at hh
+      exact hh.1
+    · rw [←eisEmbedding_norm_sq_eq_absNorm_span]
+      simpa only [one_mul] using hh.2
+  have hshortbound:Z^(-V)*(∑I∈labels,secondLabelWeight K I*∑z∈nonzeroChildFrequencyBall 1 (Z^M),
+      ‖markedShortCompletedSum (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z)
+        test (Z^N) (Z^(cutoff-V)) mark‖^2)≤Cs*(1+‖theta‖)^degree*Z^(N+V-cstar/256) := by
+    by_cases hbig:cutoff≤V
+    · have he (I:Ideal O)(z:O):markedShortCompletedSum
+          (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z) test (Z^N) (Z^(cutoff-V)) mark=0:=
+        short_sum_zero_of_label_large _ _ _ _ _ _ _ hZ1 hbig
+      simp only [he,norm_zero,zero_pow (by decide:2≠0),Finset.sum_const_zero,mul_zero]
+      positivity
+    · exact hshort m hm Z N V M z₀ margin (cutoff-V) cutoff hZ hN hV hM hML hVL hzL
+        (by linarith) (by linarith) hmN hmargin hreserve (by linarith) (by linarith) hcutc
+        labels hlabels (nonzeroChildFrequencyBall 1 (Z^M)) hT D hD slots hcard lists H
+        hdis hH1 hH hprod Ψ hΨ hperiod theta a ha
+  have hb:=hl S D (reflectionExcludedPrimes_bad q) (reflectionExcludedPrimes_prime q) labels
+    (fun I hI=>(hlabels I hI).1.1) Ψ m slots lists a test htest Z N V (Z^M)
+    (Z^(cutoff-V)) (Cs*(1+‖theta‖)^degree*Z^(N+V-cstar/256)) E
+    hZ1 (Real.rpow_pos_of_pos hz _) hNL hVL (fun I hI=>(hlabels I hI).2.2)
+    hupper hD hE hshortbound hbins
+  apply hb.trans
+  have hA:0≤(1+‖theta‖)^degree*Z^(N+V-cstar/256):=by positivity
+  have hB:0≤Z^eps*E:=by positivity
+  nlinarith
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalEnergyExistenceData.lean

@@ -0,0 +1,55 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalRankEnergyMonotone
+
+namespace OAI
+
+noncomputable section
+
+open scoped Classical BigOperators SchwartzMap
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge CanonicalQuadraticSieve
+open CanonicalRowCompletion InverseReflectedPhase
+local notation "O"=>ActualEisensteinCubic.O
+
+def CanonicalEnergyExists (Mcap Fcap c eps L:ℝ)(K:ℕ)(W:𝓢(ℝ,ℂ)):Prop :=
+  ∃degree:ℕ,∃B:ℝ,1≤B ∧
+    ∀q:ℕ,q≠0→∃C Z₀:ℝ,0<C ∧ 1<Z₀ ∧
+    ∀Z:ℝ,Z₀≤Z→∀D:ℕ,B*Z^L≤D→
+    ∀{σ:Type}[DecidableEq σ](slots:Finset σ),slots.card≤K→
+    ∀(lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)))
+      (H:σ→ℝ)(a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)→ℂ),
+      (slots:Set σ).PairwiseDisjoint lists→
+      (∀i∈slots,1≤H i)→(∀i∈slots,∀P∈lists i,(Ideal.absNorm P.val:ℝ)≤H i)→
+      (∀i∈slots,∀P∈lists i,‖a i P‖≤1)→
+    ∀z:ℝ,0≤z→(∏i∈slots,H i)≤Z^z→
+    ∀base:O→*ℂ,(∀u,‖base u‖≤1)→
+      CanonicalCoefficientClass.FactorsModulo (CanonicalCoefficientClass.fixedBaseConductor q) base→
+      CompletePoolRankMoments q D slots lists a base W Z Mcap Fcap z c eps C K degree
+
+theorem canonical_energy_of_rank (n:ℕ)(L cstar cutoff eta Mcap Fcap c eps:ℝ)(K:ℕ)(W:𝓢(ℝ,ℂ))
+    (hM:Mcap≤rankRowCap n cutoff)(hF:Fcap≤rankTotalCap n L eta)
+    (hc:rankMargin n cstar eta≤c)(he:rankLoss n eta≤eps)
+    (h:RankEnergyExists n L cstar cutoff eta K W):
+    CanonicalEnergyExists Mcap Fcap c eps L K W :=by
+  obtain ⟨degree,B,hB,h⟩:=h
+  refine ⟨degree,B,hB,?_⟩
+  intro q hq
+  obtain ⟨C,Z₀,hC,hZ₀,h⟩:=h q hq
+  refine ⟨C,Z₀,hC,hZ₀,?_⟩
+  intro Z hZ D hD σ _ slots hslots lists H a hdis hH hP ha z hz hprod base hb hp
+  have hmom:=h Z hZ D hD slots hslots lists H a hdis hH hP ha z hz hprod base hb hp
+  dsimp only [CompletePoolRankMoments] at hmom ⊢
+  let F:=InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D
+  have hFa:=InitialMeanSquare.outsideSquarefree_admissible (reflectionExcludedPrimes q) D (reflectionExcludedPrimes_bad q)
+  let:∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=fun i=>by rw [poolPrimary_span F hFa i];infer_instance
+  apply canonical_rank_loss_le (poolPrimary F) (poolPrimary_ne_zero F hFa) (poolPrimary_coprime F hFa)
+    (poolPrimary_good F hFa) Finset.univ base slots lists a W Z Mcap Fcap z c (rankLoss n eta) eps C K degree
+    (by linarith) hC.le he
+  exact canonical_rank_restrict (poolPrimary F) (poolPrimary_ne_zero F hFa) (poolPrimary_coprime F hFa)
+    (poolPrimary_good F hFa) Finset.univ base slots lists a W Z Mcap (rankRowCap n cutoff)
+    Fcap (rankTotalCap n L eta) z c (rankMargin n cstar eta) (rankLoss n eta) C K degree hM hF hc hmom
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLiveBinRank.lean

@@ -0,0 +1,69 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalRankCapChildren
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongGeometry
+
+namespace OAI
+
+noncomputable section
+
+open scoped Classical BigOperators SchwartzMap
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge CanonicalQuadraticSieve
+open CanonicalRowCompletion FirstPassCubeLabels SecondPassArithmetic
+open InverseMomentFirstLabelCell InverseMomentFirstChildWindows
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem actual_live_bin_rank_children
+    (S:Finset (Ideal O))(D:ℕ)(hbad:fixedBadPrimes⊆S)
+    (Z N V M cutoff eta L b window bW Qwidth z c eps A Mnext Fnext cnext tau:ℝ)
+    (j:ℕ)(hZ:1<Z)(hL:1≤L)(heta:0≤eta)(heta1:eta≤1)
+    (hcut:0<cutoff)(hsmall:eta≤cutoff/32)(hV:0≤V)(hparentcap:N+V≤L)
+    (hbW:bW≤Z^eta)(hlog:1≤eta*Real.log Z)(hexp:Real.exp 1≤Z^eta)
+    (hbin:2≤Z^eta)(hb:1≤b)(hbt:b≤Z^(6*eta))(hwindow:Real.exp window≤Z^(4*eta))
+    (hne:(progressingCubes S D (Z^(cutoff-V)) (activeCubeLogBin S D bW (Z^N) j)).Nonempty)
+    (base Ψ:O→*ℂ)(hΨ:CanonicalCoefficientClass.IsBaseRayTwist base Ψ)(m:O)(hm:m≠0)
+    (hparent:CanonicalMargins (N+V) M Qwidth z c)
+    (hpuncture:(Ideal.absNorm (Ideal.span {m}:Ideal O).radical:ℝ)≤Z^Qwidth)
+    (hMc:M-3*(cutoff/2)/2≤Mnext)(hFc:N+V+15*eta≤Fnext)(hcc:cnext≤c-7*eta)
+    {σ:Type}[DecidableEq σ](slots:Finset σ)
+    (lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)))
+    (a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ)
+    (ω₁ ω₂:𝓢(ℝ,ℂ))(K degree:ℕ):
+    let F:=InitialMeanSquare.outsideSquarefreeIdeals S D;
+    let hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad;
+    letI:∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=fun i=>by rw [poolPrimary_span F hF i];infer_instance;
+    CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+      (poolPrimary_good F hF) Finset.univ base slots lists a ω₁ Z Mnext Fnext z cnext eps A K degree →
+    CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+      (poolPrimary_good F hF) Finset.univ base slots lists a ω₂ Z Mnext Fnext z cnext eps A K degree →
+    ∀k:SourceIndex,∀l jj:ℕ,∀negative:Bool,
+      ChildBounds (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+        (poolPrimary_good F hF) Finset.univ
+        (progressingCubes S D (Z^(cutoff-V)) (activeCubeLogBin S D bW (Z^N) j))
+        k l jj negative Ψ m slots lists a ω₁ ω₂
+        Z M (N-3*actualCubeLength Z j) (actualCubeLength Z j) V eta tau window b eps A K degree :=by
+  dsimp only
+  intro h₁ h₂ k l jj negative
+  let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+  have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad
+  let:∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=fun i=>by rw [poolPrimary_span F hF i];infer_instance
+  obtain ⟨hel,hr,hrL,helL,hFL,hgap,hqn⟩:=actual_long_bin_geometry S D hbad bW Z N V cutoff eta L j
+    hZ hL heta1 hV hparentcap hbW hlog hne
+  have hs:(N-3*actualCubeLength Z j)+3*actualCubeLength Z j+V=N+V:=by ring
+  apply canonical_rank_cap_children (poolPrimary F) (poolPrimary_ne_zero F hF)
+    (poolPrimary_coprime F hF) (poolPrimary_good F hF) (poolPrimary_odd F hF)
+    (fun i=>(primaryPrime_spec i.val (poolPrimary_ne_zero F hF i)).2.2.2)
+    Finset.univ _ k l jj negative base Ψ hΨ m hm slots lists a ω₁ ω₂
+    Z M _ _ V eta tau window b (cutoff/2) Qwidth z c eps A Mnext Fnext cnext K degree
+    hZ heta hbin hel hV hb hbt hwindow (by linarith) (by linarith) (by linarith)
+    (by simpa only [hs] using hparent) hpuncture ?_ hMc (by simpa only [hs] using hFc) hcc h₁ h₂
+  intro v hv
+  apply (hqn v hv).2.trans
+  calc
+    _≤Z^eta*Z^(actualCubeLength Z j):=mul_le_mul_of_nonneg_right hexp (Real.rpow_nonneg (by linarith) _)
+    _=Z^(actualCubeLength Z j+eta):=by rw [Real.rpow_add (by linarith : 0<Z)];ring
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongAggregate.lean

@@ -0,0 +1,64 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongCaller
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve FirstPassCubeLabels SecondPassArithmetic
+local notation "O"=>ActualEisensteinCubic.O
+
+ theorem actual_marked_bin_empty
+    {σ:Type*}[DecidableEq σ](S:Finset (Ideal O))(D:ℕ)
+    (Q:Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→₀ℕ))
+    (Ψ:O→*ℂ)(m f z:O)(W:ℝ→ℂ)(X H₀:ℝ)(slots:Finset σ)
+    (lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)))
+    (a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ)
+    (he:¬(progressingCubes S D H₀ Q).Nonempty) :
+    markedReopenedCubeBin S D Q Ψ m f z W X H₀ slots lists a=0 := by
+  rw [marked_long_filter,Finset.not_nonempty_iff_eq_empty.mp he]
+  simp only [markedReopenedCubeBin,Finset.sum_empty]
+
+theorem actual_large_bins_aggregate
+    {σ:Type*}[DecidableEq σ](S:Finset (Ideal O))(D:ℕ)
+    (labels:Finset (Ideal O))(Ψ:O→*ℂ)(m:O)(W:ℝ→ℂ)(b X H₀ R Z V E:ℝ)
+    (slots:Finset σ)(lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)))
+    (a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ)
+    (hbin:∀j∈cubeLogRange b X,
+      (progressingCubes S D H₀ (activeCubeLogBin S D b X j)).Nonempty→
+      Z^(-V)*rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D
+        (progressingCubes S D H₀ (activeCubeLogBin S D b X j))
+        Ψ m (idealGenerator I) z W X H₀ slots lists a) R≤E)
+    (hE:0≤E) :
+    Z^(-V)*((cubeLogRange b X).card*∑j∈cubeLogRange b X,
+      rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D
+        (progressingCubes S D H₀ (activeCubeLogBin S D b X j))
+        Ψ m (idealGenerator I) z W X H₀ slots lists a) R)≤
+      ((cubeLogRange b X).card:ℝ)^2*E := by
+  have hj (j:ℕ)(hj:j∈cubeLogRange b X) :
+      Z^(-V)*rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D
+        (progressingCubes S D H₀ (activeCubeLogBin S D b X j))
+        Ψ m (idealGenerator I) z W X H₀ slots lists a) R≤E := by
+    by_cases hn:(progressingCubes S D H₀ (activeCubeLogBin S D b X j)).Nonempty
+    · exact hbin j hj hn
+    · rw [Finset.not_nonempty_iff_eq_empty.mp hn]
+      simpa only [markedReopenedCubeBin,Finset.sum_empty,rowFamilyEnergy,
+        nonzeroRowMajorantSum,norm_zero,zero_pow (by decide:2≠0),Complex.ofReal_zero,
+        mul_zero,ite_self,tsum_zero,Finset.sum_const_zero,Complex.zero_re] using hE
+  calc
+    _=(cubeLogRange b X).card*∑j∈cubeLogRange b X,
+      Z^(-V)*rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D
+        (progressingCubes S D H₀ (activeCubeLogBin S D b X j))
+        Ψ m (idealGenerator I) z W X H₀ slots lists a) R := by rw [←Finset.mul_sum];ring
+    _≤(cubeLogRange b X).card*∑_j∈cubeLogRange b X,E := by
+      gcongr
+      exact hj _ ‹_›
+    _=_ := by rw [Finset.sum_const,nsmul_eq_mul];ring
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongBins.lean

@@ -0,0 +1,86 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongNormalization
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve FirstPassCubeLabels SecondPassArithmetic
+open InverseSecondFibers InverseInitialClippedColumns
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem actual_marked_family_binned
+    {σ:Type*}[DecidableEq σ](S:Finset (Ideal O))(D:ℕ)
+    (hbad:fixedBadPrimes⊆S)(hSp:∀P∈S,Prime P)
+    (labels:Finset (Ideal O))(Ψ:O→*ℂ)(m:O)(W:ℝ→ℂ)(hWc:HasCompactSupport W)
+    (b X H₀ K:ℝ)(hX:0<X)(hK:0<K)(hW:∀t,W t≠0→t≤b)(hD:b*X≤D)
+    (slots:Finset σ)(lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)))
+    (a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ) :
+    rowFamilyEnergy labels (fun I z=>outsideCanonicalMarkedRow S D hbad Ψ m
+      (idealGenerator I) z slots lists a W X) K ≤
+    2*X*(rowFamilyEnergy labels (fun I z=>
+      markedShortCompletedSum (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z) W X H₀
+        (indexedIdealMark (fun i:primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)=>i.val) slots lists a)) K+
+      (cubeLogRange b X).card*∑j∈cubeLogRange b X,
+        rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D
+          (progressingCubes S D H₀ (activeCubeLogBin S D b X j))
+          Ψ m (idealGenerator I) z W X H₀ slots lists a) K) := by
+  simp only [rowFamilyEnergy_eq_sum _ _ K hK]
+  have he:∀I z,
+      ‖outsideCanonicalMarkedRow S D hbad Ψ m (idealGenerator I) z slots lists a W X‖^2 ≤
+      2*X*(‖markedShortCompletedSum (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z) W X H₀
+        (indexedIdealMark (fun i:primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)=>i.val) slots lists a)‖^2+
+        (cubeLogRange b X).card*∑j∈cubeLogRange b X,
+          ‖markedReopenedCubeBin S D (progressingCubes S D H₀ (activeCubeLogBin S D b X j))
+            Ψ m (idealGenerator I) z W X H₀ slots lists a‖^2) := by
+    intro I z
+    have hh:=original_marked_binned_energy S D Ψ m (idealGenerator I) z W b X H₀ slots lists a
+      hbad hSp hWc hX hW hD
+    have hs:(∑j∈cubeLogRange b X,
+        ‖markedReopenedCubeBin S D (activeCubeLogBin S D b X j) Ψ m (idealGenerator I) z W X H₀ slots lists a‖^2)=
+        ∑j∈cubeLogRange b X,
+        ‖markedReopenedCubeBin S D (progressingCubes S D H₀ (activeCubeLogBin S D b X j))
+          Ψ m (idealGenerator I) z W X H₀ slots lists a‖^2 := by
+      apply Finset.sum_congr rfl
+      intro j hj
+      rw [marked_long_filter S D (activeCubeLogBin S D b X j) Ψ m (idealGenerator I) z W X H₀ slots lists a]
+    rw [hs] at hh
+    exact hh
+  calc
+    _≤∑I∈labels,∑z∈(firstFrequencyDisk (2*K)).erase 0,
+      (rowMajorant (‖ConcreteTraceCRT.eisEmbedding z‖^2/K)).re *
+      (2*X*(‖markedShortCompletedSum (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z) W X H₀
+        (indexedIdealMark (fun i:primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)=>i.val) slots lists a)‖^2+
+        (cubeLogRange b X).card*∑j∈cubeLogRange b X,
+          ‖markedReopenedCubeBin S D (progressingCubes S D H₀ (activeCubeLogBin S D b X j))
+            Ψ m (idealGenerator I) z W X H₀ slots lists a‖^2)) := by
+      apply Finset.sum_le_sum
+      intro I hI
+      apply Finset.sum_le_sum
+      intro z hz
+      exact mul_le_mul_of_nonneg_left (he I z) (rowMajorant_nonneg _)
+    _=_ := by
+      simp only [mul_add,Finset.sum_add_distrib,Finset.mul_sum]
+      congr 1
+      · apply Finset.sum_congr rfl
+        intro I hI
+        apply Finset.sum_congr rfl
+        intro z hz
+        exact mul_left_comm _ _ _
+      · simp_rw [Finset.sum_comm (s:=(firstFrequencyDisk (2*K)).erase 0) (t:=cubeLogRange b X)]
+        rw [Finset.sum_comm]
+        apply Finset.sum_congr rfl
+        intro j hj
+        apply Finset.sum_congr rfl
+        intro I hI
+        apply Finset.sum_congr rfl
+        intro z hz
+        ring
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongCaller.lean

@@ -0,0 +1,69 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongWeight
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongCount
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongIntegral
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve FirstPassCubeLabels SecondPassArithmetic
+open InverseSecondFibers InverseInitialClippedColumns IdealMobiusDivisorSum
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem normalized_complete_marked_split (K:ℕ)(L eps:ℝ)(hL:0≤L)(heps:0<eps) :
+    ∃C:ℝ,0<C ∧ ∀{σ:Type*}[DecidableEq σ]
+      (S:Finset (Ideal O))(D:ℕ)(hbad:fixedBadPrimes⊆S)(_hSp:∀P∈S,Prime P)
+      (labels:Finset (Ideal O))(_hlabels:∀I∈labels,Admissible I)
+      (Ψ:O→*ℂ)(m:O)(slots:Finset σ)
+      (lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)))
+      (a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ)
+      (W:ℝ→ℂ)(_hWc:HasCompactSupport W)(b Z N V R H₀:ℝ),
+      1≤Z→0<R→V≤L→(∀I∈labels,(I.absNorm:ℝ)≤Z^V)→
+      (∀t,W t≠0→t≤b)→b*Z^N≤D→
+      let F:=InitialMeanSquare.outsideSquarefreeIdeals S D;
+      let hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad;
+      letI : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=
+        fun i=>by rw [poolPrimary_span F hF i];infer_instance;
+      normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF)
+        (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Ψ m slots lists a labels
+        (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) W (Z^N) Z (N+V)≤
+      2*C*Z^(-V+eps)*(
+        rowFamilyEnergy labels (fun I z=>markedShortCompletedSum
+          (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z) W (Z^N) H₀
+          (indexedIdealMark (fun i:primePool F=>i.val) slots lists a)) R+
+        (cubeLogRange b (Z^N)).card*∑j∈cubeLogRange b (Z^N),
+          rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D
+            (progressingCubes S D H₀ (activeCubeLogBin S D b (Z^N) j))
+            Ψ m (idealGenerator I) z W (Z^N) H₀ slots lists a) R) := by
+  obtain ⟨C,hC,hh⟩:=normalized_second_energy_le_actual_family K L eps hL heps
+  refine ⟨C,hC,?_⟩
+  intro σ _ S D hbad hSp labels hlabels Ψ m slots lists a W hWc b Z N V R H₀
+    hZ hR hV hnorm hW hD
+  let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+  have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad
+  let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=
+    fun i=>by rw [poolPrimary_span F hF i];infer_instance
+  dsimp only
+  have hz:0<Z:=zero_lt_one.trans_le hZ
+  have hb:=hh (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+    (poolPrimary_good F hF) Finset.univ Ψ m slots lists a labels hlabels W
+    (Z^N) Z (N+V) V R hZ hR hV hnorm
+  have hsplit:=actual_marked_family_binned S D hbad hSp labels Ψ m W hWc
+    b (Z^N) H₀ R (Real.rpow_pos_of_pos hz _) hR hW hD slots lists a
+  have hcost: C*Z^(-(N+V)+eps)*(2*Z^N)=2*C*Z^(-V+eps) := by
+    calc
+      _=2*C*(Z^(-(N+V)+eps)*Z^N):=by ring
+      _=2*C*Z^(-V+eps):=by rw [←Real.rpow_add hz];congr 2;ring
+  apply hb.trans
+  have he:=mul_le_mul_of_nonneg_left hsplit (show 0≤C*Z^(-(N+V)+eps) by positivity)
+  rw [←mul_assoc,hcost] at he
+  exact he
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongCoefficient.lean

@@ -0,0 +1,63 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongSource
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve CanonicalCubeSeparation FirstPassCubeLabels SecondPassArithmetic
+local notation "O"=>ActualEisensteinCubic.O
+
+def actualLongCoefficient {ι:Type*}(p:ι→O)(Ψ:O→*ℂ)(m:O)(H₀ B ξ:ℝ)
+    (I:Ideal O)(v:ι→₀ℕ) : ℂ :=
+  separatedCubeCoefficient
+    (fun u:ι→₀ℕ=>reopenedCubeCoefficient H₀ (rowTwist Ψ m (idealGenerator I) 1)
+      (Ideal.span {primeProduct p u.support u}))
+    (fun u:ι→₀ℕ=>(Ideal.absNorm (Ideal.span {primeProduct p u.support u}):ℝ)) B ξ v
+
+theorem actualLongCoefficient_uniform (eps:ℝ)(heps:0<eps) :
+    ∃C:ℝ,0<C ∧ ∀{ι:Type*}(p:ι→O)(_hp:∀i,p i≠0)(Ψ:O→*ℂ)(_hΨ:∀x,‖Ψ x‖≤1)
+      (m:O)(H₀ B ξ:ℝ)(I:Ideal O)(v:ι→₀ℕ),0<B→
+      B≤‖ConcreteTraceCRT.eisEmbedding (primeProduct p v.support v)‖^2→
+      ‖ConcreteTraceCRT.eisEmbedding (primeProduct p v.support v)‖^2≤Real.exp 1*B→
+      ‖actualLongCoefficient p Ψ m H₀ B ξ I v‖≤C*(Real.exp 1*B)^eps := by
+  obtain ⟨C,hC,hbound⟩:=reopenedCubeCoefficient_small_power eps heps
+  refine ⟨C*Real.exp (1/2),mul_pos hC (Real.exp_pos _),?_⟩
+  intro ι p hp Ψ hΨ m H₀ B ξ I v hB hlo hhi
+  have hne:Ideal.span {primeProduct p v.support v}≠0 := by
+    apply Ideal.span_singleton_eq_bot.not.mpr
+    exact Finset.prod_ne_zero_iff.mpr (fun i hi=>pow_ne_zero _ (hp i))
+  rw [eisEmbedding_norm_sq_eq_absNorm_span] at hlo hhi
+  have hh:=hbound H₀ (rowTwist Ψ m (idealGenerator I) 1)
+    (rowTwist_norm Ψ hΨ m (idealGenerator I) 1) _ hne
+  have hb:‖reopenedCubeCoefficient H₀ (rowTwist Ψ m (idealGenerator I) 1)
+      (Ideal.span {primeProduct p v.support v})‖≤C*(Real.exp 1*B)^eps :=
+    hh.trans (mul_le_mul_of_nonneg_left (Real.rpow_le_rpow (by positivity) hhi heps.le) hC.le)
+  have hs:=separatedCubeCoefficient_bound
+    (fun u:ι→₀ℕ=>reopenedCubeCoefficient H₀ (rowTwist Ψ m (idealGenerator I) 1)
+      (Ideal.span {primeProduct p u.support u}))
+    (fun u:ι→₀ℕ=>(Ideal.absNorm (Ideal.span {primeProduct p u.support u}):ℝ)) B ξ
+    (C*(Real.exp 1*B)^eps) hB (by positivity) v hlo hhi hb
+  unfold actualLongCoefficient
+  convert hs using 1 ; ring
+
+theorem actualLongCoefficient_complete
+    (S:Finset (Ideal O))(D:ℕ)(hbad:fixedBadPrimes⊆S)
+    (Ψ:O→*ℂ)(m:O)(H₀ B ξ:ℝ)(I:Ideal O)
+    (v:primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→₀ℕ) :
+    actualLongCoefficient (poolPrimary (InitialMeanSquare.outsideSquarefreeIdeals S D))
+      Ψ (m*excludedGenerator S) H₀ B ξ I v=
+    separatedCubeCoefficient
+      (fun u=>reopenedCubeCoefficient H₀ (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) 1)
+        (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) u))
+      (fun u=>(Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) u):ℝ)) B ξ v := by
+  simp only [actualLongCoefficient,cubeIdeal_eq_primeProduct_span _
+    (InitialMeanSquare.outsideSquarefree_admissible S D hbad)]
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongCosts.lean

@@ -0,0 +1,68 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalCompleteState
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongGeometry
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical
+namespace SevenEighths.InverseMoment
+
+theorem actual_long_coefficient_cost (Z ell L epsilon Ccoef:ℝ)
+    (hZ:1≤Z)(hell:ell≤L)(heps:0≤epsilon):
+    (Ccoef*(Real.exp 1*Z^ell)^epsilon)^2≤
+      Ccoef^2*Real.exp (2*epsilon)*Z^(2*L*epsilon) := by
+  have hz:0<Z:=zero_lt_one.trans_le hZ
+  have hex:(Real.exp 1)^epsilon=Real.exp epsilon:=by rw [Real.rpow_def_of_pos (Real.exp_pos _),Real.log_exp,one_mul]
+  have hex2:(Real.exp epsilon)^2=Real.exp (2*epsilon):=by rw [←Real.exp_nat_mul];norm_num
+  have hid:(Ccoef*(Real.exp 1*Z^ell)^epsilon)^2=
+      Ccoef^2*Real.exp (2*epsilon)*Z^(2*ell*epsilon) := by
+    rw [Real.mul_rpow (Real.exp_pos _).le (Real.rpow_nonneg hz.le _),hex,
+      ←Real.rpow_mul hz.le,mul_pow,mul_pow,hex2,
+      ←Real.rpow_mul_natCast hz.le]
+    ring_nf
+  rw [hid]
+  apply mul_le_mul_of_nonneg_left _ (by positivity)
+  apply Real.rpow_le_rpow_of_exponent_le hZ
+  nlinarith
+
+theorem actual_long_uniform_parent_cost (Z ell N V L epsilon Ccoef C A loss:ℝ)
+    (hZ:1≤Z)(hell:ell≤L)(heps:0≤epsilon)(hC:0≤C)(hA:0≤A):
+    C*(Ccoef*(Real.exp 1*Z^ell)^epsilon)^2*(1+A)*Z^((N-3*ell)+3*ell+V+loss)≤
+      (C*Ccoef^2*Real.exp (2*epsilon))*(1+A)*Z^(N+V+loss+2*L*epsilon) := by
+  have hz:0<Z:=zero_lt_one.trans_le hZ
+  have h:=actual_long_coefficient_cost Z ell L epsilon Ccoef hZ hell heps
+  have hh:=mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right
+    (mul_le_mul_of_nonneg_left h hC) (by linarith:0≤1+A))
+    (Real.rpow_nonneg hz.le ((N-3*ell)+3*ell+V+loss))
+  apply hh.trans_eq
+  have hpow:Z^(2*L*epsilon)*Z^((N-3*ell)+3*ell+V+loss)=Z^(N+V+loss+2*L*epsilon):=by
+    rw [←Real.rpow_add hz];congr 1;ring
+  calc
+    _=(C*Ccoef^2*Real.exp (2*epsilon))*(1+A)*
+        (Z^(2*L*epsilon)*Z^((N-3*ell)+3*ell+V+loss)):=by ring
+    _=_:=by rw [hpow]
+
+theorem complete_state_power_absorption (Z F cstar eps loss C A height E:ℝ)
+    (hZ:1≤Z)(hc:0≤cstar)(heps:0≤eps)(hloss:0≤loss)
+    (hC:0≤C)(_hA:0≤A)(hheight:0≤height)
+    (hE:E≤A*height*Z^(F+loss)):
+    C*(height*Z^(F-cstar/256)+Z^eps*E)≤
+      C*(1+A)*height*Z^(F+loss+eps) := by
+  have hz:0<Z:=zero_lt_one.trans_le hZ
+  have hs:height*Z^(F-cstar/256)≤height*Z^(F+loss+eps):=by
+    apply mul_le_mul_of_nonneg_left _ hheight
+    exact Real.rpow_le_rpow_of_exponent_le hZ (by linarith)
+  have ht:Z^eps*E≤A*height*Z^(F+loss+eps):=by
+    have hh:=mul_le_mul_of_nonneg_left hE (Real.rpow_nonneg hz.le eps)
+    apply hh.trans_eq
+    rw [Real.rpow_add hz (F+loss) eps]
+    ring
+  have hh:=mul_le_mul_of_nonneg_left (add_le_add hs ht) hC
+  convert hh using 1 ; ring
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongCount.lean

@@ -0,0 +1,36 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongBins
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical
+namespace SevenEighths.InverseMoment
+open CanonicalRowCompletion SecondPassArithmetic
+
+theorem actual_cube_bin_count (b L eps:ℝ)(hb:0≤b)(hL:0≤L)(heps:0<eps) :
+    ∃C:ℝ,0<C ∧ ∀X Z:ℝ,0≤X→1≤Z→X≤Z^L→
+      ((cubeLogRange b X).card:ℝ)^2≤C*Z^eps := by
+  have hLp:0<L+1:=by linarith
+  have hd:0<3*eps/(L+1):=by positivity
+  obtain ⟨C,hC,hh⟩:=cubeLogRange_sq_small_power b (3*eps/(L+1)) hb hd
+  refine ⟨C,hC,?_⟩
+  intro X Z hX hZ hXL
+  have hz:0<Z:=zero_lt_one.trans_le hZ
+  have hscale:(Z^((L+1)/3))^3=Z^(L+1) := by
+    rw [←Real.rpow_mul_natCast hz.le]
+    congr 1
+    ring
+  have hpow:(Z^((L+1)/3))^(3*eps/(L+1))=Z^eps := by
+    rw [←Real.rpow_mul hz.le]
+    congr 1
+    field_simp
+  have hbnd:=hh X (Z^((L+1)/3)) hX (Real.one_le_rpow hZ (by positivity))
+    (by rw [hscale];exact hXL.trans (Real.rpow_le_rpow_of_exponent_le hZ (by linarith)))
+  simpa only [hpow] using hbnd
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongFinite.lean

@@ -0,0 +1,99 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongAggregate
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve FirstPassCubeLabels SecondPassArithmetic
+open InverseSecondFibers IdealMobiusDivisorSum
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem actual_complete_finite_split (K:ℕ)(L eps:ℝ)(hL:0≤L)(heps:0<eps) :
+    ∃C:ℝ,0<C ∧ ∀{σ:Type*}[DecidableEq σ]
+      (S:Finset (Ideal O))(D:ℕ)(hbad:fixedBadPrimes⊆S)(_hSp:∀P∈S,Prime P)
+      (labels:Finset (Ideal O))(_hlabels:∀I∈labels,I≠0)
+      (Ψ:O→*ℂ)(m:O)(slots:Finset σ)
+      (lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)))
+      (a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ)
+      (W:ℝ→ℂ)(_hWc:HasCompactSupport W)(b Z N V R H₀:ℝ),
+      1≤Z → 0<R → V≤L → (∀I∈labels,(I.absNorm:ℝ)≤Z^V) →
+      (∀t,W t≠0 → t≤b) → b*Z^N≤D →
+      Z^(-(N+V))*(∑I∈labels,secondLabelWeight K I*∑z∈nonzeroChildFrequencyBall 1 R,
+        ‖outsideCanonicalMarkedRow S D hbad Ψ m (idealGenerator I) z slots lists a W (Z^N)‖^2) ≤
+      2*(Z^(-V)*(∑I∈labels,secondLabelWeight K I*∑z∈nonzeroChildFrequencyBall 1 R,
+        ‖markedShortCompletedSum (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z)
+          W (Z^N) H₀ (indexedIdealMark (fun i:primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)=>i.val)
+            slots lists a)‖^2))+
+      2*C*Z^(-V+eps)*(cubeLogRange b (Z^N)).card*∑j∈cubeLogRange b (Z^N),
+        rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D
+          (progressingCubes S D H₀ (activeCubeLogBin S D b (Z^N) j))
+          Ψ m (idealGenerator I) z W (Z^N) H₀ slots lists a) R := by
+  obtain ⟨C,hC,hweight⟩:=second_label_weight_uniform K L eps hL heps
+  refine ⟨C,hC,?_⟩
+  intro σ _ S D hbad hSp labels hlabels Ψ m slots lists a W hWc b Z N V R H₀ hZ hR hV hnorm hW hD
+  have hz:0<Z:=zero_lt_one.trans_le hZ
+  let bins:=cubeLogRange b (Z^N)
+  let short:=fun I z=>markedShortCompletedSum (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z)
+    W (Z^N) H₀ (indexedIdealMark (fun i:primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)=>i.val) slots lists a)
+  let long:=fun j I z=>markedReopenedCubeBin S D
+    (progressingCubes S D H₀ (activeCubeLogBin S D b (Z^N) j))
+    Ψ m (idealGenerator I) z W (Z^N) H₀ slots lists a
+  let ball:=nonzeroChildFrequencyBall 1 R
+  have hpoint (I:Ideal O)(z:O):
+      ‖outsideCanonicalMarkedRow S D hbad Ψ m (idealGenerator I) z slots lists a W (Z^N)‖^2≤
+      2*Z^N*(‖short I z‖^2+bins.card*∑j∈bins,‖long j I z‖^2) := by
+    have hh:=original_marked_binned_energy S D Ψ m (idealGenerator I) z W b (Z^N) H₀ slots lists a
+      hbad hSp hWc (Real.rpow_pos_of_pos hz _) hW hD
+    convert hh using 1
+    congr 2
+    apply congrArg (fun x:ℝ=>(bins.card:ℝ)*x)
+    apply Finset.sum_congr rfl
+    intro j hj
+    rw [marked_long_filter S D (activeCubeLogBin S D b (Z^N) j) Ψ m (idealGenerator I) z W (Z^N) H₀ slots lists a]
+  have hlong (j:ℕ):
+      (∑I∈labels,secondLabelWeight K I*∑z∈ball,‖long j I z‖^2)≤
+      C*Z^eps*rowFamilyEnergy labels (long j) R := by
+    rw [rowFamilyEnergy,Complex.re_sum,Finset.mul_sum]
+    apply Finset.sum_le_sum
+    intro I hI
+    have hb:=finite_nonzero_row_energy_le_majorant (long j I) ball R hR
+      (by intro z hz;rw [←eisEmbedding_norm_sq_eq_absNorm_span]
+          simpa only [one_mul] using ((mem_nonzeroChildFrequencyBall 1 one_ne_zero R z).mp hz).2)
+      (by intro z hz he
+          have hn:=((mem_nonzeroChildFrequencyBall 1 one_ne_zero R z).mp hz).1
+          simp only [he,mul_zero,map_zero,norm_zero,pow_succ,lt_self_iff_false] at hn)
+    exact (mul_le_mul_of_nonneg_right (hweight Z V hZ hV I (hlabels I hI) (hnorm I hI))
+      (Finset.sum_nonneg (fun _ _=>sq_nonneg _))).trans (mul_le_mul_of_nonneg_left hb (by positivity))
+  have hsum:=Finset.sum_le_sum (s:=labels) (fun I hI=>
+    mul_le_mul_of_nonneg_left (Finset.sum_le_sum (s:=ball) (fun z hz=>hpoint I z))
+      (show 0≤secondLabelWeight K I by unfold secondLabelWeight;positivity))
+  have he:=mul_le_mul_of_nonneg_left hsum (Real.rpow_nonneg hz.le (-(N+V)))
+  have hc:Z^(-(N+V))*Z^N=Z^(-V):=by rw [←Real.rpow_add hz];congr 1;ring
+  have rearrange:
+      Z^(-(N+V))*(∑I∈labels,secondLabelWeight K I*∑z∈ball,
+        2*Z^N*(‖short I z‖^2+bins.card*∑j∈bins,‖long j I z‖^2))=
+      2*Z^(-V)*(∑I∈labels,secondLabelWeight K I*∑z∈ball,‖short I z‖^2)+
+      2*Z^(-V)*bins.card*∑j∈bins,∑I∈labels,secondLabelWeight K I*∑z∈ball,‖long j I z‖^2 := by
+    simp only [mul_add,Finset.sum_add_distrib,Finset.mul_sum]
+    simp_rw [Finset.sum_comm (s:=ball) (t:=bins)]
+    rw [Finset.sum_comm (s:=labels) (t:=bins)]
+    simp only [←Finset.mul_sum,mul_assoc,mul_left_comm]
+    rw [←hc]
+    ring
+  rw [rearrange] at he
+  apply he.trans
+  have hj:=mul_le_mul_of_nonneg_left (Finset.sum_le_sum (s:=bins) (fun j hj=>hlong j))
+    (show 0≤2*Z^(-V)*(bins.card:ℝ) by positivity)
+  rw [←Finset.mul_sum] at hj
+  have hpow:Z^(-V)*Z^eps=Z^(-V+eps):=(Real.rpow_add hz _ _).symm
+  convert add_le_add_left hj (2*Z^(-V)*(∑I∈labels,secondLabelWeight K I*∑z∈ball,‖short I z‖^2)) using 1 <;>
+    dsimp [bins,short,long,ball] <;> (try rw [←hpow]) <;> ring
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongFull.lean

@@ -0,0 +1,112 @@
+import OAI.NumberTheory.DirichletL.Descent.FirstDyadicPriorityBudget
+import OAI.NumberTheory.DirichletL.Descent.FirstDyadicOriginalBranches
+import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveParents
+import OAI.NumberTheory.DirichletL.Descent.FirstLiveCountBudget
+import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveAggregate
+import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveEnergy
+
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongCoefficient
+
+namespace OAI
+
+noncomputable section
+open scoped Classical BigOperators SchwartzMap
+
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic
+open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows
+open InverseMomentFirstOriginalProfile InverseMomentFirstProfileUniform
+open InverseAmbientProfileTower JointLogSeparation FourierBridge CompletedHeight
+open ConcreteTraceCRT (eisEmbedding)
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem actual_long_dyadic_full_energy
+    (om:𝓢(ℝ,ℂ))(a b:ℝ)(ha:0<a)(hs:Function.support om⊆Set.Icc a b) (Lcap Mmax eta tau saving:ℝ)(hcap:0≤Lcap)(hMmax:0≤Mmax)(hb:0≤b)
+    (heta:0≤eta)(heta1:eta≤1)(htau:0<tau)(htau1:tau≤1):
+    ∃(omega₁ omega₂:𝓢(ℝ,ℂ))(lo hi:ℝ),0<lo ∧ lo≤hi ∧
+      HasCompactSupport (omega₁:ℝ→ℂ) ∧ HasCompactSupport (omega₂:ℝ→ℂ) ∧
+      tsupport (omega₁:ℝ→ℂ)⊆Set.Icc lo hi ∧ tsupport (omega₂:ℝ→ℂ)⊆Set.Icc lo hi ∧
+    ∀eps:ℝ,0<eps→∀J:ℕ,∃Ccoef C Czero Ctail:ℝ,0<Ccoef ∧ 0≤C ∧ 0≤Czero ∧ 0≤Ctail ∧
+    ∀{ι σ:Type}[DecidableEq ι][DecidableEq σ](p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+      (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i})
+      (hinj:Function.Injective (fun i=>Ideal.span {p i}))
+      (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+      (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2)
+      (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1)
+      (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O))
+      (Ψ:O→*ℂ)(m mCoef:O)
+      (slots:Finset σ)(lists:σ→Finset ι)(weights:σ→ι→ℂ)
+      (Z M r ell V H₀ ξ Benergy:ℝ)
+      (_hZ:2≤Z)(_hbin:2≤Z^eta)(_hbinExp:Real.exp 1≤Z^eta)(_hM:0≤M)(_hF:r+3*ell+V≤Lcap)(_hMcap:M≤Mmax)(_hell:0≤ell)(_hV:0≤V)(_hr: -eta≤r)
+      (_hbZ:b≤Z^eta)(_hQpool:∀v∈Q,v.support⊆pool)
+      (_hQlo:∀v∈Q,Z^ell≤‖eisEmbedding (primeProduct p v.support v)‖^2)
+      (_hQhi:∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤Real.exp 1*Z^ell)
+      (_hrcap:r≤Lcap)(_hellcap:ell≤Lcap)
+
+      (_hΨ:∀u,‖Ψ u‖≤1)(_hB:0≤Benergy)
+      (_hsf:∀I∈labels,Squarefree I)(_hn:∀I∈labels,I≠0)
+      (_hlabels:∀I∈labels,(Ideal.absNorm I:ℝ)≤Z^(V+eta))
+      (_hslots:(slots:Set σ).PairwiseDisjoint lists)(_hweights:∀i∈slots,∀q∈lists i,‖weights i q‖≤1),
+      let mark:=fun v U=>primeMark slots lists weights (v.support∪U);
+      let Y:=Z^(2*Lcap+15*eta+tau);
+      let cutoff:=fun (q:CubeCoordinates ι) (C:Finset ι) (_I:Ideal O) (D:Finset ι)=>firstDyadicRadius p q C D Z M r ell V eta tau;
+      let W:=fun y=>normTwistedSource om ξ (y/Z^r);
+      let source:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y;
+      let keys:=liveJointKeys p source pool (sourceSummand p hp hcop hg (actualLongCoefficient p Ψ mCoef H₀ (Z^ell) ξ) cutoff Ψ m mark W rowMajorant (Z^M));
+      (∀k∈keys,∀z:Frequency×(Fin 9→ℝ),
+        (Z^(firstKappa M r ell V (dyadicExponent Z (k.1 3)) (dyadicExponent Z (k.1 0))
+          (dyadicExponent Z (k.1 2)) (dyadicExponent Z (k.1 4)))*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))*
+        globalPriorityOriginalEnergy p hg hp hinj (fun q=>q.rightExponent.support) pool
+          (InverseFirstGlobalCaps.labelParentCell p pool Q (fun _ _=>1) k.1 k.2.1 k.2.2)
+          (fun x=>(‖commonSelector p (fun _=>1) k.2.1 x.quotientSupport‖:ℂ))
+          true Ψ m slots lists weights omega₁
+          ((physicalScales (Z^r) k.1 k.2.1) 7)
+          (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7)
+          (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤Benergy*(tripleHeight J z.1*coordinateHeight J z.2))→
+      (∀k∈keys,∀z:Frequency×(Fin 9→ℝ),
+        (Z^(firstKappa M r ell V (dyadicExponent Z (k.1 3)) (dyadicExponent Z (k.1 1))
+          (dyadicExponent Z (k.1 2)) (dyadicExponent Z (k.1 4)))*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))*
+        globalPriorityOriginalEnergy p hg hp hinj (fun q=>q.leftExponent.support) pool
+          (InverseFirstGlobalCaps.labelParentCell p pool Q (fun _ _=>1) k.1 k.2.1 k.2.2)
+          (fun x=>(‖commonSelector p (fun _=>1) k.2.1 x.quotientSupport‖:ℂ))
+          false Ψ m slots lists weights omega₂
+          ((physicalScales (Z^r) k.1 k.2.1) 8)
+          (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8)
+          (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤Benergy*(tripleHeight J z.1*coordinateHeight J z.2))→
+      Z^(-r-2*ell-V)*CanonicalRowCompletion.rowFamilyEnergy labels (fun I z=>
+        varyingReopenedRow p hp hcop hg pool Q ((actualLongCoefficient p Ψ mCoef H₀ (Z^ell) ξ) I) Ψ m (ConcretePrimeRowBridge.idealGenerator I)
+          (fun v U=>mark v U*W (primeProductNorm p U)) z) (Z^M)≤
+        Czero*(Ccoef*(Real.exp 1*Z^ell)^eps)^2*Z^(M-ell+3*eta+eps*(5*ell+2*r+7*eta))+
+        C*(Ccoef*(Real.exp 1*Z^ell)^eps)^2*Benergy*(1+‖ξ‖)^(2*InverseClippingProfiles.momentOrder J)*
+          Z^((2*Lcap+15*eta+tau)*eps+eps)+Ctail*(Ccoef*(Real.exp 1*Z^ell)^eps)^2*Z^(-saving) := by
+  obtain ⟨omega₁,omega₂,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,he⟩:=
+    original_dyadic_full_energy om a b ha hs Lcap Mmax eta tau saving hcap hMmax hb heta heta1 htau htau1
+  refine ⟨omega₁,omega₂,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,?_⟩
+  intro eps heps J
+  obtain ⟨Ccoef,hCcoef,hcoef⟩:=actualLongCoefficient_uniform eps heps
+  obtain ⟨C,Czero,Ctail,hC,hCzero,hCtail,hfull⟩:=he eps heps J
+  refine ⟨Ccoef,C,Czero,Ctail,hCcoef,hC,hCzero,hCtail,?_⟩
+  intro ι σ _ _ p hp _ hg hinj hcop hc hpr pool Q labels Ψ m mCoef slots lists weights
+    Z M r ell V H₀ ξ Benergy hZ hbin hbinExp hM hF hMcap hell hV hr hbZ hQpool hQlo hQhi
+    hrcap hellcap hΨ hB hsf hn hlabels hslots hweights mark Y cutoff W source keys hleft hright
+  have hz:0<Z:=by linarith
+  have hQ:∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤Z^(ell+eta) := by
+    intro v hv
+    apply (hQhi v hv).trans
+    calc
+      Real.exp 1*Z^ell≤Z^eta*Z^ell:=mul_le_mul_of_nonneg_right hbinExp (Real.rpow_nonneg hz.le _)
+      _=Z^(ell+eta):=by rw [Real.rpow_add hz];ring
+  have hβ:∀I∈labels,∀v∈Q,
+      ‖actualLongCoefficient p Ψ mCoef H₀ (Z^ell) ξ I v‖≤Ccoef*(Real.exp 1*Z^ell)^eps := by
+    intro I hI v hv
+    exact hcoef p hp Ψ hΨ mCoef H₀ (Z^ell) ξ I v (Real.rpow_pos_of_pos hz _) (hQlo v hv) (hQhi v hv)
+  exact hfull p hp hg hinj hcop hc hpr pool Q labels
+    (actualLongCoefficient p Ψ mCoef H₀ (Z^ell) ξ) Ψ m slots lists weights
+    Z M r ell V (Ccoef*(Real.exp 1*Z^ell)^eps) ξ Benergy hZ hbin hM hF hMcap hell hV hr hbZ
+    hQpool hQ hrcap hellcap hΨ (by positivity) hB hsf hn hβ hlabels hslots hweights hleft hright
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongGeometry.lean

@@ -0,0 +1,66 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongCoefficient
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve CanonicalCubeSeparation FirstPassCubeLabels SecondPassArithmetic
+local notation "O"=>ActualEisensteinCubic.O
+
+def actualCubeLength (Z:ℝ)(j:ℕ):ℝ:=Real.logb Z (normLogScale j)
+
+theorem actualCubeLength_power (Z:ℝ)(hZ:1<Z)(j:ℕ) :
+    Z^(actualCubeLength Z j)=normLogScale j :=
+  Real.rpow_logb (zero_lt_one.trans hZ) (ne_of_gt hZ) (normLogScale_pos j)
+
+theorem actual_long_bin_geometry
+    (S:Finset (Ideal O))(D:ℕ)(hbad:fixedBadPrimes⊆S)
+    (b Z N V cutoff eta L:ℝ)(j:ℕ)(hZ:1<Z)(hL:1≤L)(heta:eta≤1)
+    (hV:0≤V)(hparent:N+V≤L)(hb:b≤Z^eta)(hlog:1≤eta*Real.log Z)
+    (hne:(progressingCubes S D (Z^(cutoff-V)) (activeCubeLogBin S D b (Z^N) j)).Nonempty) :
+    let ell:=actualCubeLength Z j;
+    let r:=N-3*ell;
+    let F:=InitialMeanSquare.outsideSquarefreeIdeals S D;
+    let Q:=progressingCubes S D (Z^(cutoff-V)) (activeCubeLogBin S D b (Z^N) j);
+    0≤ell ∧ -eta≤r ∧ r≤L ∧ ell≤L ∧ r+3*ell+V≤L ∧ cutoff-eta≤ell+V ∧
+      ∀v∈Q,Z^ell≤‖ConcreteTraceCRT.eisEmbedding (primeProduct (poolPrimary F) v.support v)‖^2 ∧
+        ‖ConcreteTraceCRT.eisEmbedding (primeProduct (poolPrimary F) v.support v)‖^2≤Real.exp 1*Z^ell := by
+  dsimp only
+  have hz:0<Z:=zero_lt_one.trans hZ
+  have hp:Z^(actualCubeLength Z j)=normLogScale j:=actualCubeLength_power Z hZ j
+  have hel:0≤actualCubeLength Z j:=Real.logb_nonneg hZ (normLogScale_ge_one j)
+  have hnorm (v:primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→₀ℕ)
+      (hv:v∈activeCubeLogBin S D b (Z^N) j) :
+      Z^(actualCubeLength Z j)≤(Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v):ℝ) ∧
+      (Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v):ℝ)≤Real.exp 1*Z^(actualCubeLength Z j) := by
+    rw [hp]
+    exact activeCubeLogBin_norms S D b (Z^N) j v hv
+  obtain ⟨v,hv⟩:=hne
+  have hvbin: v∈activeCubeLogBin S D b (Z^N) j := (Finset.mem_filter.mp hv).1
+  have hactive:= (Finset.mem_filter.mp hvbin).1
+  have hcube:(Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v):ℝ)^3≤b*Z^N :=
+    (Finset.mem_filter.mp hactive).2
+  have hsc:(Z^(actualCubeLength Z j))^3≤Z^(N+eta) := by
+    calc
+      _≤(Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v):ℝ)^3 :=
+        pow_le_pow_left₀ (Real.rpow_nonneg hz.le _) (hnorm v hvbin).1 3
+      _≤b*Z^N:=hcube
+      _≤Z^eta*Z^N:=mul_le_mul_of_nonneg_right hb (Real.rpow_nonneg hz.le _)
+      _=Z^(N+eta):=by rw [Real.rpow_add hz];ring
+  rw [←Real.rpow_mul_natCast hz.le] at hsc
+  have hscale:actualCubeLength Z j*3≤N+eta := (Real.rpow_le_rpow_left_iff hZ).mp hsc
+  have hprogress:=long_cube_progress_with_slack S D (activeCubeLogBin S D b (Z^N) j)
+    Z cutoff V (actualCubeLength Z j) eta hZ hlog ⟨v,hv⟩ (fun v hv=>(hnorm v hv).2)
+  refine ⟨hel,by linarith,by linarith,by linarith,by linarith,hprogress,?_⟩
+  intro u hu
+  rw [cubeIdeal_primeProduct_norm _ (InitialMeanSquare.outsideSquarefree_admissible S D hbad)]
+  exact hnorm u (Finset.mem_filter.mp hu).1
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongHeightBin.lean

@@ -0,0 +1,115 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongUniformTestBin
+import OAI.NumberTheory.DirichletL.Descent.CanonicalReopeningHeight
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical SchwartzMap ContDiff
+namespace SevenEighths.InverseMoment
+open MeasureTheory ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve CanonicalCubeSeparation FirstPassCubeLabels SecondPassArithmetic
+open InverseMomentFirstLabelCell InverseMomentFirstSecondHeightCost CompletedHeight
+open FourierBridge JointLogSeparation
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem actual_marked_bin_height
+    (a₀ b₀:ℝ)(ha₀:0<a₀)(hb₀:0≤b₀)
+    (W:ℝ→ℂ)(hsW:Function.support W⊆Set.Icc a₀ b₀)(hW:ContDiff ℝ ∞ W)
+    (Vlog:𝓢(ℝ,ℂ))(Alog:ℝ)(hbox:∀x,Vlog x≠0 → |x|≤Alog)
+    (hone:∀x,|x|≤CanonicalCubeSeparation.columnWindowRadius a₀ b₀ → Vlog x=1)
+    (Lcap eta tau saving em ed:ℝ)(hcap:0≤Lcap)
+    (heta:0≤eta)(heta1:eta≤1)(htau:0<tau)(htau1:tau≤1)
+    (hem:0<em)(hed:0<ed)(K:ℕ):
+    ∃(ω₁₁ ω₁₂ ω₂₁ ω₂₂:𝓢(ℝ,ℂ))(af₁ bf₁ af₂ bf₂ window bw:ℝ),
+      0<af₁ ∧ af₁≤bf₁ ∧ 0<af₂ ∧ af₂≤bf₂ ∧
+      HasCompactSupport (ω₁₁:ℝ → ℂ) ∧ HasCompactSupport (ω₁₂:ℝ → ℂ) ∧
+      HasCompactSupport (ω₂₁:ℝ → ℂ) ∧ HasCompactSupport (ω₂₂:ℝ → ℂ) ∧
+      tsupport (ω₁₁:ℝ → ℂ)⊆Set.Icc af₁ bf₁ ∧ tsupport (ω₁₂:ℝ → ℂ)⊆Set.Icc af₁ bf₁ ∧
+      tsupport (ω₂₁:ℝ → ℂ)⊆Set.Icc af₂ bf₂ ∧ tsupport (ω₂₂:ℝ → ℂ)⊆Set.Icc af₂ bf₂ ∧
+      1≤bw ∧ Real.exp Alog≤bw ∧ bw=Real.exp window ∧
+    ∀epsFirst epsSecond:ℝ,0<epsFirst → 0<epsSecond → ∀degree:ℕ,
+      ∃Ccoef C:ℝ,0<Ccoef ∧ 0≤C ∧
+    ∀theta:ℝ,
+    ∀{σ:Type}[DecidableEq σ](S:Finset (Ideal O))(D:ℕ)(hbad:fixedBadPrimes⊆S)(hSp:∀P∈S,Prime P),
+      let F:=InitialMeanSquare.outsideSquarefreeIdeals S D;
+      let hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad;
+      letI : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=
+        fun i=>by rw [poolPrimary_span F hF i];infer_instance;
+      let p:=poolPrimary F;
+      let hp:=poolPrimary_ne_zero F hF;
+      let hcop:=poolPrimary_coprime F hF;
+      let hg:=poolPrimary_good F hF;
+      let om:=radialFromLog Vlog (Vlog.smooth ⊤) Alog hbox;
+      ∀(Q:Finset (primePool F →₀ ℕ))(labels:Finset (Ideal O))(Ψ:O →* ℂ)(m:O)
+        (slots:Finset σ)(lists:σ → Finset (primePool F))(weights:σ → primePool F → ℂ)
+        (Z M r ell V H₀ pi epschild A loss lossFinal:ℝ),
+        2≤Z → 2≤Z^eta → Real.exp 1≤Z^eta → 0≤M → r+3*ell+V≤Lcap → M≤Lcap →
+        0≤ell → 0≤V → -eta≤r → Real.exp Alog≤Z^eta →
+        (∀v∈Q,Z^ell≤(Ideal.absNorm (cubeIdeal F v):ℝ)) →
+        (∀v∈Q,(Ideal.absNorm (cubeIdeal F v):ℝ)≤Real.exp 1*Z^ell) →
+        r≤Lcap → ell≤Lcap → V≤Lcap → Real.exp window≤Z^eta → 0≤pi → 6*eta≤pi →
+        em*(20*(3*Lcap+16)+30)≤pi/4 → ed*(20*(3*Lcap+16)+30)≤pi/4 →
+        0≤epschild → -saving≤r+3*ell+V+48*eta+tau+pi+epschild+epsSecond →
+        48*eta+tau+pi+epschild+epsSecond≤loss → slots.card≤K →
+        M-ell≤r+3*ell+V → 3*eta+epsFirst*(5*ell+2*r+7*eta)≤lossFinal →
+        loss+(2*Lcap+15*eta+tau)*epsFirst+epsFirst≤lossFinal → -saving≤r+3*ell+V+lossFinal →
+        (∀u,‖Ψ u‖≤1) → 0≤A → (∀I∈labels,Squarefree I) → (∀I∈labels,I≠0) →
+        (∀I∈labels,(Ideal.absNorm I:ℝ)≤Z^(V+eta)) →
+        (slots:Set σ).PairwiseDisjoint lists → (∀i∈slots,∀q∈lists i,‖weights i q‖≤1) →
+        b₀*Z^(r+3*ell)≤D →
+        (∀ξ:ℝ,∀k∈actualLongSourceKeys p hp hcop hg Finset.univ Q labels Ψ m (m*excludedGenerator S)
+          slots lists weights om Z M r ell V H₀ ξ Lcap eta tau,
+          ChildBounds p hp hcop hg Finset.univ Q k.1 k.2.1 k.2.2 true Ψ m slots lists weights ω₁₁ ω₁₂
+            Z M r ell V eta tau window bw epschild A K degree) →
+        (∀ξ:ℝ,∀k∈actualLongSourceKeys p hp hcop hg Finset.univ Q labels Ψ m (m*excludedGenerator S)
+          slots lists weights om Z M r ell V H₀ ξ Lcap eta tau,
+          ChildBounds p hp hcop hg Finset.univ Q k.1 k.2.1 k.2.2 false Ψ m slots lists weights ω₂₁ ω₂₂
+            Z M r ell V eta tau window bw epschild A K degree) →
+        Z^(-V)*rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D Q Ψ m (idealGenerator I) z
+          (normTwistedSource W theta) (Z^(r+3*ell)) H₀ slots lists weights) (Z^M)≤
+          C*(Ccoef*(Real.exp 1*Z^ell)^epsFirst)^2*(1+A)*Z^(r+3*ell+V+lossFinal)*
+            (1+‖theta‖)^(2*(InverseClippingProfiles.momentOrder (firstDegree degree)+(volume:Measure ℝ).integrablePower)) := by
+  obtain ⟨ω₁₁,ω₁₂,ω₂₁,ω₂₂,af₁,bf₁,af₂,bf₂,window,bw,
+    haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hbwexp,he⟩:=
+    actual_marked_bin_uniform_test a₀ b₀ ha₀ hb₀ Vlog Alog hbox hone
+      Lcap eta tau saving em ed hcap heta heta1 htau htau1 hem hed K
+  refine ⟨ω₁₁,ω₁₂,ω₂₁,ω₂₂,af₁,bf₁,af₂,bf₂,window,bw,
+    haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hbwexp,?_⟩
+  intro epsFirst epsSecond hepsF hepsS degree
+  obtain ⟨Ccoef,C,hCcoef,hC,hbin⟩:=he epsFirst epsSecond hepsF hepsS degree
+  obtain ⟨Cm,hCm,hmoment⟩:=reopening_twisted_moment_squared W a₀ b₀ ha₀ hsW hW
+    (InverseClippingProfiles.momentOrder (firstDegree degree))
+  refine ⟨Ccoef,C*Cm,hCcoef,mul_nonneg hC hCm,?_⟩
+  intro theta σ _ S D hbad hSp
+  let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+  have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad
+  let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=
+    fun i=>by rw [poolPrimary_span F hF i];infer_instance
+  dsimp only
+  intro Q labels Ψ m slots lists weights Z M r ell V H₀ pi epschild A loss lossFinal
+    hZ hbins hbinExp hM hFcap hMcap hell hV hr hbZ hQlo hQhi hrcap hellcap hVcap hwin
+    hpi hpieta hemcost hedcost hechild hsave hloss hcard hpar hprincipal hretained htail
+    hΨ hA hsf hn hlabels hslots hweights hD hleft hright
+  have hT:=CanonicalRowCompletion.normTwistedSource_contDiff W a₀ b₀ ha₀ hsW hW theta
+  have hsT:Function.support (normTwistedSource W theta)⊆Set.Icc a₀ b₀:=
+    (normTwistedSource_support W theta).trans hsW
+  have hbnd:=hbin (normTwistedSource W theta) hsT hT S D hbad hSp
+    Q labels Ψ m slots lists weights Z M r ell V H₀ pi epschild A loss lossFinal
+    hZ hbins hbinExp hM hFcap hMcap hell hV hr hbZ hQlo hQhi hrcap hellcap hVcap hwin
+    hpi hpieta hemcost hedcost hechild hsave hloss hcard hpar hprincipal hretained htail
+    hΨ hA hsf hn hlabels hslots hweights hD hleft hright
+  have hz:0<Z:=by linarith
+  apply hbnd.trans
+  calc
+    _ ≤ C*(Ccoef*(Real.exp 1*Z^ell)^epsFirst)^2*(1+A)*Z^(r+3*ell+V+lossFinal)*
+        (Cm*(1+‖theta‖)^(2*(InverseClippingProfiles.momentOrder (firstDegree degree)+
+          (volume:Measure ℝ).integrablePower))) :=
+      mul_le_mul_of_nonneg_left (hmoment theta hT) (by positivity)
+    _ = _ := by ring
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongIntegral.lean

@@ -0,0 +1,88 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongFull
+
+namespace OAI
+
+namespace SevenEighths.InverseMoment
+noncomputable section
+open scoped BigOperators Classical SchwartzMap ContDiff
+open MeasureTheory ActualEisensteinCubic CompletedGauss CanonicalRowCompletion
+open ConcretePrimeRowBridge CanonicalQuadraticSieve SecondPassArithmetic FirstPassCubeLabels
+open CanonicalCubeSeparation JointLogSeparation
+local notation "O" => ActualEisensteinCubic.O
+
+theorem actual_long_bin_normalized_energy
+    {σ : Type*} [DecidableEq σ]
+    (S : Finset (Ideal O)) (D : ℕ) (hbad : fixedBadPrimes ⊆ S) (hSp : ∀P∈S,Prime P)
+    (Q : Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D) →₀ ℕ))
+    (labels : Finset (Ideal O)) (Ψ : O →* ℂ) (m : O) (W : ℝ → ℂ)
+    (a b : ℝ) (ha : 0 < a) (hb : 0≤b) (hs : Function.support W ⊆ Set.Icc a b)
+    (hW : ContDiff ℝ ∞ W) (V : 𝓢(ℝ,ℂ))
+    (hV : ∀ u, |u| ≤ columnWindowRadius a b → V u = 1)
+    (Z r cubeLength Vheight H₀ K E : ℝ) (d : ℕ)
+    (hZ : 0 < Z) (hD : b*(Z^(r+3*cubeLength))≤D) (hK : 0 < K) (hE : 0 ≤ E)
+    (hn : ∀ v ∈ Q, (Z^cubeLength) ≤ (Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v) : ℝ))
+    (hn' : ∀ v ∈ Q, (Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v) : ℝ) ≤ Real.exp 1*(Z^cubeLength))
+    (slots : Finset σ)
+    (lists : σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)))
+    (weights : σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ) :
+    let F := InitialMeanSquare.outsideSquarefreeIdeals S D
+    let hF := InitialMeanSquare.outsideSquarefree_admissible S D hbad
+    letI : ∀ i : primePool F, (Ideal.span {poolPrimary F i}).IsMaximal :=
+      fun i => by rw [poolPrimary_span F hF i]; infer_instance
+    let β := fun I v => reopenedCubeCoefficient H₀
+      (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) 1) (cubeIdeal F v)
+    let n := fun v => (Ideal.absNorm (cubeIdeal F v) : ℝ)
+    (∀ ξ : ℝ, Z^(-r-2*cubeLength-Vheight)*rowFamilyEnergy labels (fun I z =>
+      varyingReopenedRow (poolPrimary F) (poolPrimary_ne_zero F hF)
+        (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Q
+        (separatedCubeCoefficient (β I) n (Z^cubeLength) ξ) Ψ m (idealGenerator I)
+        (fun v T => primeMark slots lists weights (T∪v.support)*frequencyTwist V ξ (columnLog (poolPrimary F) (Z^r) T)) z) K ≤
+      E*(1+|ξ|)^(2*d)) →
+    Z^(-Vheight)*rowFamilyEnergy labels (fun I z =>
+      markedReopenedCubeBin S D Q Ψ m (idealGenerator I) z W (Z^(r+3*cubeLength)) H₀ slots lists weights) K ≤
+      E *
+        (∫ ξ : ℝ, ‖reopeningCoefficient W a b ha hs hW ξ‖*(1+|ξ|)^d)^2 := by
+  dsimp only
+  let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+  have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad
+  let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=
+    fun i=>by rw [poolPrimary_span F hF i];infer_instance
+  let β:=fun I v=>reopenedCubeCoefficient H₀ (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) 1) (cubeIdeal F v)
+  let n:=fun v=>(Ideal.absNorm (cubeIdeal F v):ℝ)
+  intro hsource
+  have hcancel:Z^(r+2*cubeLength+Vheight)*Z^(-r-2*cubeLength-Vheight)=1 := by
+    rw [←Real.rpow_add hZ]
+    convert Real.rpow_zero Z using 2 ; ring
+  have hpoint:∀ξ:ℝ,rowFamilyEnergy labels (fun I z=>
+      varyingReopenedRow (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+        (poolPrimary_good F hF) Finset.univ Q (separatedCubeCoefficient (β I) n (Z^cubeLength) ξ)
+        Ψ m (idealGenerator I)
+        (fun v T=>primeMark slots lists weights (T∪v.support)*frequencyTwist V ξ (columnLog (poolPrimary F) (Z^r) T)) z) K≤
+      (Z^(r+2*cubeLength+Vheight)*E)*(1+|ξ|)^(2*d) := by
+    intro ξ
+    have hh:=mul_le_mul_of_nonneg_left (hsource ξ) (Real.rpow_nonneg hZ.le (r+2*cubeLength+Vheight))
+    rw [←mul_assoc,hcancel,one_mul] at hh
+    simpa only [mul_assoc] using hh
+  have hX:Z^(r+3*cubeLength)=(Z^cubeLength)^3*Z^r := by
+    rw [←Real.rpow_mul_natCast hZ.le,←Real.rpow_add hZ]
+    congr 1
+    ring
+  have hbnd:=markedReopenedCubeBin_energy S D hbad hSp Q labels Ψ m W a b ha hb hs hW V hV
+    (Z^cubeLength) (Z^r) (Z^(r+3*cubeLength)) H₀ K (Z^(r+2*cubeLength+Vheight)*E) d
+    (Real.rpow_pos_of_pos hZ _) (Real.rpow_pos_of_pos hZ _) hX hD hK (by positivity)
+    hn hn' slots lists weights hpoint
+  have hc:Z^(-Vheight)*((Z^cubeLength)^2*Z^r)⁻¹*Z^(r+2*cubeLength+Vheight)=1 := by
+    rw [←Real.rpow_mul_natCast hZ.le,←Real.rpow_add hZ,←Real.rpow_neg hZ.le,
+      ←Real.rpow_add hZ,←Real.rpow_add hZ]
+    convert Real.rpow_zero Z using 2 ; ring
+  have hh:=mul_le_mul_of_nonneg_left hbnd (Real.rpow_nonneg hZ.le (-Vheight))
+  apply hh.trans_eq
+  calc
+    _=(Z^(-Vheight)*((Z^cubeLength)^2*Z^r)⁻¹*Z^(r+2*cubeLength+Vheight))*
+      E*(∫ξ:ℝ,‖reopeningCoefficient W a b ha hs hW ξ‖*(1+|ξ|)^d)^2 := by ring
+    _=_:=by rw [hc,one_mul]
+
+end
+end SevenEighths.InverseMoment
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongKeys.lean

@@ -0,0 +1,34 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongParent
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic
+open InverseFirstGlobalCaps InverseSecondSourceBlocks
+open InverseMomentFirstOriginalProfile CompletedHeight
+local notation "O"=>ActualEisensteinCubic.O
+
+def actualLongSourceKeys {ι σ:Type}[DecidableEq ι][DecidableEq σ]
+    (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+    (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+    (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i})
+    (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O))(Ψ:O→*ℂ)(m mCoef:O)
+    (slots:Finset σ)(lists:σ→Finset ι)(weights:σ→ι→ℂ)(om:ℝ→ℂ)
+    (Z M r ell V H₀ ξ Lcap eta tau:ℝ) :=
+  let mark:=fun v U=>primeMark slots lists weights (v.support∪U)
+  let cutoff:=fun (q:CubeCoordinates ι)(C:Finset ι)(_I:Ideal O)(D:Finset ι)=>
+    firstDyadicRadius p q C D Z M r ell V eta tau
+  let W:=fun y=>normTwistedSource om ξ (y/Z^r)
+  let source:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels)
+    (fun x=>x.1) (Z^(2*Lcap+15*eta+tau))
+  liveJointKeys p source pool (sourceSummand p hp hcop hg
+    (actualLongCoefficient p Ψ mCoef H₀ (Z^ell) ξ) cutoff Ψ m mark W rowMajorant (Z^M))
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongNormalization.lean

@@ -0,0 +1,106 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongSource
+import OAI.NumberTheory.DirichletL.Descent.GeneratorTransport
+import OAI.NumberTheory.DirichletL.Descent.SecondNormalizedEnergy
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve FirstPassCubeLabels SecondPassArithmetic
+open InverseSecondFibers IdealMobiusDivisorSum InverseInitialClippedColumns
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem child_ball_unit_mem (u:Oˣ)(R:ℝ)(k:O) :
+    (u:O)*k∈nonzeroChildFrequencyBall 1 R ↔ k∈nonzeroChildFrequencyBall 1 R := by
+  simp only [mem_nonzeroChildFrequencyBall 1 one_ne_zero,one_mul,
+    GaussGeneratorTransport.norm_eisEmbedding_unit_mul]
+
+theorem child_ball_unit_sum {A:Type*}[AddCommMonoid A](u:Oˣ)(R:ℝ)(f:O→A) :
+    ∑k∈nonzeroChildFrequencyBall 1 R,f ((u:O)*k)=
+      ∑k∈nonzeroChildFrequencyBall 1 R,f k := by
+  apply Finset.sum_bij (fun k _=>(u:O)*k)
+  · intro k hk
+    exact (child_ball_unit_mem u R k).mpr hk
+  · intro x hx y hy he
+    exact mul_left_cancel₀ u.ne_zero he
+  · intro y hy
+    refine ⟨((u⁻¹:Oˣ):O)*y,(child_ball_unit_mem u⁻¹ R y).mpr hy,?_⟩
+    rw [←mul_assoc,←Units.val_mul,mul_inv_cancel,Units.val_one,one_mul]
+  · intros
+    rfl
+
+variable {ι σ:Type*}[DecidableEq ι]
+  (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+  (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+  (hg:∀i,goodLambda∉Ideal.span {p i})
+
+theorem canonical_ball_generator_energy
+    (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(I:Ideal O)(hI:primaryGenerator I≠0)
+    (slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)(W:ℝ→ℂ)(X K:ℝ) :
+    (∑k∈nonzeroChildFrequencyBall 1 K,
+      ‖finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (primaryGenerator I) k slots lists a W X‖^2)=
+    ∑k∈nonzeroChildFrequencyBall 1 K,
+      ‖finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (idealGenerator I) k slots lists a W X‖^2 := by
+  obtain ⟨u,hu⟩:=generator_eq_unit_primary I (idealGenerator I) (span_idealGenerator I) hI
+  let P:O→ℝ:=fun k=>
+    ‖finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (primaryGenerator I) k slots lists a W X‖^2
+  have hrot:=child_ball_unit_sum (u^4) K P
+  have he (k:O):
+      ‖finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (idealGenerator I) k slots lists a W X‖^2=
+      P (((u^4:Oˣ):O)*k) := by
+    rw [hu,finiteCanonicalMarkedRow_label_transfer]
+    rfl
+  simp only [he]
+  exact hrot.symm
+
+theorem normalized_energy_le_actual_family
+    (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+    (labels:Finset (Ideal O))(hlabels:∀I∈labels,primaryGenerator I≠0)
+    (weight:Ideal O→ℝ)(C:ℝ)(hC:0≤C)(hw:∀I∈labels,0≤weight I ∧ weight I≤C)
+    (W:ℝ→ℂ)(X Z F K:ℝ)(hZ:0<Z)(hK:0<K) :
+    normalizedColumnEnergy p hp hcop hg pool Ψ m slots lists a labels
+      (nonzeroChildFrequencyBall 1 K) weight W X Z F ≤
+      Z^(-F)*C*rowFamilyEnergy labels (fun I k=>
+        finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (idealGenerator I) k slots lists a W X) K := by
+  have hn:‖((Z^(-F/2):ℝ):ℂ)‖^2=Z^(-F) := by
+    rw [Complex.norm_real,Real.norm_eq_abs,abs_of_pos (Real.rpow_pos_of_pos hZ _),
+      ←Real.rpow_mul_natCast hZ.le]
+    congr 1
+    ring
+  unfold normalizedColumnEnergy
+  simp only [norm_mul,mul_pow,hn,←Finset.mul_sum]
+  have he : (∑ I∈labels,weight I*(Z^(-F)*∑k∈nonzeroChildFrequencyBall 1 K,
+      ‖finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (primaryGenerator I) k slots lists a W X‖^2))=
+      Z^(-F)*(∑ I∈labels,weight I*∑k∈nonzeroChildFrequencyBall 1 K,
+      ‖finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (primaryGenerator I) k slots lists a W X‖^2) := by
+    rw [Finset.mul_sum]
+    apply Finset.sum_congr rfl
+    intros
+    ring
+  rw [he]
+  rw [mul_assoc]
+  apply mul_le_mul_of_nonneg_left _ (Real.rpow_nonneg hZ.le _)
+  rw [rowFamilyEnergy,Complex.re_sum,Finset.mul_sum]
+  apply Finset.sum_le_sum
+  intro I hI
+  rw [canonical_ball_generator_energy p hp hcop hg pool Ψ m I (hlabels I hI)]
+  have hball:=finite_nonzero_row_energy_le_majorant
+    (fun k=>finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (idealGenerator I) k slots lists a W X)
+    (nonzeroChildFrequencyBall 1 K) K hK
+    (by intro k hk
+        rw [←eisEmbedding_norm_sq_eq_absNorm_span]
+        simpa only [one_mul] using ((mem_nonzeroChildFrequencyBall 1 one_ne_zero K k).mp hk).2)
+    (by intro k hk hn
+        have hh:=((mem_nonzeroChildFrequencyBall 1 one_ne_zero K k).mp hk).1
+        simp only [hn,mul_zero,map_zero,norm_zero,pow_succ,lt_self_iff_false] at hh)
+  exact (mul_le_mul_of_nonneg_right (hw I hI).2 (Finset.sum_nonneg (fun _ _=>sq_nonneg _))).trans
+    (mul_le_mul_of_nonneg_left hball hC)
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongParent.lean

@@ -0,0 +1,115 @@
+import OAI.NumberTheory.DirichletL.Descent.FirstTwoPassParentEnergy
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongCoefficient
+import OAI.NumberTheory.DirichletL.Descent.FirstDyadicFullEnergy
+import OAI.NumberTheory.DirichletL.Descent.FirstDyadicOriginalBranches
+import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveParents
+import OAI.NumberTheory.DirichletL.Descent.FirstLiveCountBudget
+import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveAggregate
+import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveEnergy
+
+namespace OAI
+
+noncomputable section
+open scoped Classical BigOperators SchwartzMap
+
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic
+open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows
+open InverseMomentFirstOriginalProfile InverseMomentFirstProfileUniform InverseMomentFirstLabelCell
+open InverseMomentFirstSecondHeightCost
+open InverseAmbientProfileTower JointLogSeparation FourierBridge CompletedHeight
+open ConcreteTraceCRT (eisEmbedding)
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem actual_long_parent_energy
+    (om:𝓢(ℝ,ℂ))(a b:ℝ)(ha:0<a)(hs:Function.support om⊆Set.Icc a b)
+    (Lcap eta tau saving em ed:ℝ)(hcap:0≤Lcap)(hb:0≤b)
+    (heta:0≤eta)(heta1:eta≤1)(htau:0<tau)(htau1:tau≤1)
+    (hem:0<em)(hed:0<ed)(K:ℕ):
+    ∃(ω₁₁ ω₁₂ ω₂₁ ω₂₂:𝓢(ℝ,ℂ))(af₁ bf₁ af₂ bf₂ window bw:ℝ),
+      0<af₁ ∧ af₁≤bf₁ ∧ 0<af₂ ∧ af₂≤bf₂ ∧
+      HasCompactSupport (ω₁₁:ℝ→ℂ) ∧ HasCompactSupport (ω₁₂:ℝ→ℂ) ∧
+      HasCompactSupport (ω₂₁:ℝ→ℂ) ∧ HasCompactSupport (ω₂₂:ℝ→ℂ) ∧
+      tsupport (ω₁₁:ℝ→ℂ)⊆Set.Icc af₁ bf₁ ∧ tsupport (ω₁₂:ℝ→ℂ)⊆Set.Icc af₁ bf₁ ∧
+      tsupport (ω₂₁:ℝ→ℂ)⊆Set.Icc af₂ bf₂ ∧ tsupport (ω₂₂:ℝ→ℂ)⊆Set.Icc af₂ bf₂ ∧
+      1≤bw ∧ b≤bw ∧ bw=Real.exp window ∧
+    ∀epsFirst epsSecond:ℝ,0<epsFirst→0<epsSecond→∀degree:ℕ,
+      ∃Ccoef C:ℝ,0<Ccoef ∧ 0≤C ∧
+    ∀{ι σ:Type}[DecidableEq ι][DecidableEq σ](p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+      (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i})
+      (_hinj:Function.Injective (fun i=>Ideal.span {p i}))
+      (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+      (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2)
+      (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1)
+      (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O))
+      (Ψ:O→*ℂ)(m mCoef:O)
+      (slots:Finset σ)(lists:σ→Finset ι)(weights:σ→ι→ℂ)
+      (Z M r ell V H₀ ξ pi epschild A loss lossFinal:ℝ)
+      (_hZ:2≤Z)(_hbin:2≤Z^eta)(_hbinExp:Real.exp 1≤Z^eta)(_hM:0≤M)(_hF:r+3*ell+V≤Lcap)(_hMcap:M≤Lcap)(_hell:0≤ell)(_hV:0≤V)(_hr: -eta≤r)
+      (_hbZ:b≤Z^eta)(_hQpool:∀v∈Q,v.support⊆pool)
+      (_hQlo:∀v∈Q,Z^ell≤‖eisEmbedding (primeProduct p v.support v)‖^2)
+      (_hQhi:∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤Real.exp 1*Z^ell)
+      (_hrcap:r≤Lcap)(_hellcap:ell≤Lcap)
+
+      (_hVcap:V≤Lcap)(_hwin:Real.exp window≤Z^eta)(_hpi:0≤pi)(_hpieta:6*eta≤pi)
+      (_hemcost:em*(20*(3*Lcap+16)+30)≤pi/4)(_hedcost:ed*(20*(3*Lcap+16)+30)≤pi/4)
+      (_hechild:0≤epschild)(_hsave: -saving≤r+3*ell+V+48*eta+tau+pi+epschild+epsSecond)
+      (_hloss:48*eta+tau+pi+epschild+epsSecond≤loss)(_hcard:slots.card≤K)
+      (_hparent:M-ell≤r+3*ell+V)
+      (_hprincipal:3*eta+epsFirst*(5*ell+2*r+7*eta)≤lossFinal)
+      (_hretained:loss+(2*Lcap+15*eta+tau)*epsFirst+epsFirst≤lossFinal)
+      (_htail: -saving≤r+3*ell+V+lossFinal)
+      (_hΨ:∀u,‖Ψ u‖≤1)(_hA:0≤A)
+      (_hsf:∀I∈labels,Squarefree I)(_hn:∀I∈labels,I≠0)
+      (_hlabels:∀I∈labels,(Ideal.absNorm I:ℝ)≤Z^(V+eta))
+      (_hslots:(slots:Set σ).PairwiseDisjoint lists)(_hweights:∀i∈slots,∀q∈lists i,‖weights i q‖≤1),
+      let mark:=fun v U=>primeMark slots lists weights (v.support∪U);
+      let Y:=Z^(2*Lcap+15*eta+tau);
+      let cutoff:=fun (q:CubeCoordinates ι) (C:Finset ι) (_I:Ideal O) (D:Finset ι)=>firstDyadicRadius p q C D Z M r ell V eta tau;
+      let W:=fun y=>normTwistedSource om ξ (y/Z^r);
+      let source:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y;
+      let keys:=liveJointKeys p source pool (sourceSummand p hp hcop hg (actualLongCoefficient p Ψ mCoef H₀ (Z^ell) ξ) cutoff Ψ m mark W rowMajorant (Z^M));
+      (∀k∈keys,ChildBounds p hp hcop hg pool Q k.1 k.2.1 k.2.2 true Ψ m slots lists weights ω₁₁ ω₁₂
+        Z M r ell V eta tau window bw epschild A K degree)→
+      (∀k∈keys,ChildBounds p hp hcop hg pool Q k.1 k.2.1 k.2.2 false Ψ m slots lists weights ω₂₁ ω₂₂
+        Z M r ell V eta tau window bw epschild A K degree)��
+      Z^(-r-2*ell-V)*CanonicalRowCompletion.rowFamilyEnergy labels (fun I z=>
+        varyingReopenedRow p hp hcop hg pool Q ((actualLongCoefficient p Ψ mCoef H₀ (Z^ell) ξ) I) Ψ m (ConcretePrimeRowBridge.idealGenerator I)
+          (fun v U=>mark v U*W (primeProductNorm p U)) z) (Z^M)≤
+        C*(Ccoef*(Real.exp 1*Z^ell)^epsFirst)^2*(1+A)*(1+‖ξ‖)^(2*InverseClippingProfiles.momentOrder (firstDegree degree))*
+          Z^(r+3*ell+V+lossFinal) := by
+  obtain ⟨ω₁₁,ω₁₂,ω₂₁,ω₂₂,af₁,bf₁,af₂,bf₂,window,bw,
+    haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hbwexp,he⟩:=
+    original_two_pass_parent_energy om a b ha hs Lcap eta tau saving em ed hcap hb heta heta1 htau htau1 hem hed K
+  refine ⟨ω₁₁,ω₁₂,ω₂₁,ω₂₂,af₁,bf₁,af₂,bf₂,window,bw,
+    haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hbwexp,?_⟩
+  intro epsFirst epsSecond hepsF hepsS degree
+  obtain ⟨Ccoef,hCcoef,hcoef⟩:=actualLongCoefficient_uniform epsFirst hepsF
+  obtain ⟨C,hC,hfull⟩:=he epsFirst epsSecond hepsF hepsS degree
+  refine ⟨Ccoef,C,hCcoef,hC,?_⟩
+  intro ι σ _ _ p hp _ hg hinj hcop hc hpr pool Q labels Ψ m mCoef slots lists weights
+    Z M r ell V H₀ ξ pi epschild A loss lossFinal hZ hbin hbinExp hM hF hMcap hell hV hr hbZ hQpool hQlo hQhi
+    hrcap hellcap hVcap hwin hpi hpieta hemcost hedcost hechild hsave hloss hcard hparent hprincipal hretained htail
+    hΨ hA hsf hn hlabels hslots hweights mark Y cutoff W source keys hleft hright
+  have hz:0<Z:=by linarith
+  have hQ:∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤Z^(ell+eta) := by
+    intro v hv
+    apply (hQhi v hv).trans
+    calc
+      Real.exp 1*Z^ell≤Z^eta*Z^ell:=mul_le_mul_of_nonneg_right hbinExp (Real.rpow_nonneg hz.le _)
+      _=Z^(ell+eta):=by rw [Real.rpow_add hz];ring
+  have hβ:∀I∈labels,∀v∈Q,
+      ‖actualLongCoefficient p Ψ mCoef H₀ (Z^ell) ξ I v‖≤Ccoef*(Real.exp 1*Z^ell)^epsFirst := by
+    intro I hI v hv
+    exact hcoef p hp Ψ hΨ mCoef H₀ (Z^ell) ξ I v (Real.rpow_pos_of_pos hz _) (hQlo v hv) (hQhi v hv)
+  exact hfull p hp hg hinj hcop hc hpr pool Q labels
+    (actualLongCoefficient p Ψ mCoef H₀ (Z^ell) ξ) Ψ m slots lists weights
+    Z M r ell V (Ccoef*(Real.exp 1*Z^ell)^epsFirst) ξ pi epschild A loss lossFinal hZ hbin hM hF hMcap hell hV hr hbZ
+    hQpool hQ hrcap hellcap hVcap hwin hpi hpieta hemcost hedcost hechild hsave hloss hcard hparent hprincipal hretained htail
+    hΨ (by positivity) hA hsf hn hβ hlabels hslots hweights hleft hright
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongSource.lean

@@ -0,0 +1,114 @@
+import OAI.NumberTheory.DirichletL.Descent.ReopenedBins
+import OAI.NumberTheory.DirichletL.Descent.FirstDyadicFullEnergy
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical SchwartzMap ContDiff
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalCubeSeparation CanonicalQuadraticSieve FirstPassCubeLabels SecondPassArithmetic
+open JointLogSeparation FourierBridge CompletedHeight
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem long_frequency_profile
+    {ι:Type*}(p:ι→O)(hp:∀i,p i≠0)
+    (V:𝓢(ℝ,ℂ))(A:ℝ)(hV:∀s,V s≠0→|s|≤A)
+    (Z r ξ:ℝ)(hZ:0<Z)(T:Finset ι) :
+    frequencyTwist V ξ (columnLog p (Z^r) T)=
+      normTwistedSource (radialFromLog V (V.smooth ⊤) A hV) ξ
+        (primeProductNorm p T/Z^r) := by
+  rw [normTwistedSource,radialFromLog_column p hp V (V.smooth ⊤) A hV _ (Real.rpow_pos_of_pos hZ r)]
+  simp only [frequencyTwist_apply,columnLog]
+
+theorem long_marked_source_eq
+    {ι σ:Type*}[DecidableEq ι][DecidableEq σ]
+    (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+    (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+    (hg:∀i,goodLambda∉Ideal.span {p i})
+    (pool:Finset ι)(Q:Finset (ι→₀ℕ))(β:(ι→₀ℕ)→ℂ)(Ψ:O→*ℂ)(m f z:O)
+    (slots:Finset σ)(lists:σ→Finset ι)(weights:σ→ι→ℂ)
+    (V:𝓢(ℝ,ℂ))(A:ℝ)(hV:∀s,V s≠0→|s|≤A)(Z r ξ:ℝ)(hZ:0<Z) :
+    varyingReopenedRow p hp hcop hg pool Q β Ψ m f
+      (fun v T=>primeMark slots lists weights (T∪v.support)*
+        frequencyTwist V ξ (columnLog p (Z^r) T)) z =
+    varyingReopenedRow p hp hcop hg pool Q β Ψ m f
+      (fun v T=>primeMark slots lists weights (v.support∪T)*
+        normTwistedSource (radialFromLog V (V.smooth ⊤) A hV) ξ
+          (primeProductNorm p T/Z^r)) z := by
+  congr 1
+  funext v T
+  rw [long_frequency_profile p hp V A hV Z r ξ hZ T,Finset.union_comm T v.support]
+
+theorem marked_long_filter
+    {σ:Type*}[DecidableEq σ](S:Finset (Ideal O))(D:ℕ)
+    (Q:Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→₀ℕ))
+    (Ψ:O→*ℂ)(m f z:O)(W:ℝ→ℂ)(X H₀:ℝ)(slots:Finset σ)
+    (lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)))
+    (weights:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ) :
+    markedReopenedCubeBin S D Q Ψ m f z W X H₀ slots lists weights=
+      markedReopenedCubeBin S D (progressingCubes S D H₀ Q) Ψ m f z W X H₀ slots lists weights := by
+  unfold markedReopenedCubeBin progressingCubes
+  dsimp only
+  symm
+  apply Finset.sum_subset (Finset.filter_subset _ _)
+  intro v hv hn
+  have hz:largeCubeCoefficient H₀ (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v)=0 := by
+    by_contra hh
+    exact hn (Finset.mem_filter.mpr ⟨hv,(largeCubeCoefficient_support H₀ _ hh).2⟩)
+  simp only [hz,zero_mul]
+
+theorem long_cube_progress
+    (S:Finset (Ideal O))(D:ℕ)
+    (Q:Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→₀ℕ))
+    (Z cutoff V ell:ℝ)(hZ:1<Z)
+    (hne:(progressingCubes S D (Z^(cutoff-V)) Q).Nonempty)
+    (hupper:∀v∈Q,(Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v):ℝ)≤
+      Real.exp 1*Z^ell) :
+    cutoff-1/Real.log Z≤ell+V := by
+  obtain ⟨v,hv⟩:=hne
+  obtain ⟨hv,hlower⟩:=Finset.mem_filter.mp hv
+  have hz:0<Z:=zero_lt_one.trans hZ
+  have he:=Real.log_le_log (Real.rpow_pos_of_pos hz _) (hlower.trans (hupper v hv))
+  rw [Real.log_rpow hz,Real.log_mul (Real.exp_pos _).ne' (Real.rpow_pos_of_pos hz _).ne',
+    Real.log_exp,Real.log_rpow hz] at he
+  have hlog:=Real.log_pos hZ
+  have hd: (cutoff-ell-V)*Real.log Z≤1:=by nlinarith
+  have hh:cutoff-ell-V≤1/Real.log Z:=(le_div_iff₀ hlog).mpr hd
+  linarith
+
+theorem long_cube_progress_with_slack
+    (S:Finset (Ideal O))(D:ℕ)
+    (Q:Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→₀ℕ))
+    (Z cutoff V ell eta:ℝ)(hZ:1<Z)(hlog:1≤eta*Real.log Z)
+    (hne:(progressingCubes S D (Z^(cutoff-V)) Q).Nonempty)
+    (hupper:∀v∈Q,(Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v):ℝ)≤
+      Real.exp 1*Z^ell) :
+    cutoff-eta≤ell+V := by
+  have h:=long_cube_progress S D Q Z cutoff V ell hZ hne hupper
+  have hh:1/Real.log Z≤eta:=(div_le_iff₀ (Real.log_pos hZ)).mpr (by simpa only [mul_comm] using hlog)
+  linarith
+
+theorem short_sum_zero_of_label_large
+    (Ψ:O→*ℂ)(W:ℝ→ℂ)(mark:Ideal O→ℂ)(X Z cutoff V:ℝ)
+    (hZ:1≤Z)(hV:cutoff≤V) :
+    markedShortCompletedSum Ψ W X (Z^(cutoff-V)) mark=0 := by
+  have ht:Z^(cutoff-V)≤1:=by
+    have he:=Real.rpow_le_rpow_of_exponent_le hZ (show cutoff-V≤0 by linarith)
+    simpa only [Real.rpow_zero] using he
+  unfold markedShortCompletedSum
+  trans ∑' _ : Ideal O,(0:ℂ)
+  · apply tsum_congr
+    intro I
+    by_cases hi:I=0
+    · subst I
+      simp
+    rw [ite_eq_right (not_lt.mpr (ht.trans (norm_at_least_one I hi)))]
+  · exact tsum_zero
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongTotal.lean

@@ -0,0 +1,67 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongFinite
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve FirstPassCubeLabels SecondPassArithmetic
+open InverseSecondFibers IdealMobiusDivisorSum
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem actual_complete_energy_from_live_bins (K:ℕ)(b L eps:ℝ)
+    (hb:0≤b)(hL:0≤L)(heps:0<eps) :
+    ∃C:ℝ,0<C ∧ ∀{σ:Type*}[DecidableEq σ]
+      (S:Finset (Ideal O))(D:ℕ)(hbad:fixedBadPrimes⊆S)(_hSp:∀P∈S,Prime P)
+      (labels:Finset (Ideal O))(_hlabels:∀I∈labels,I≠0)
+      (Ψ:O→*ℂ)(m:O)(slots:Finset σ)
+      (lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)))
+      (a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ)
+      (W:ℝ→ℂ)(_hWc:HasCompactSupport W)(Z N V R H₀ Eshort Elong:ℝ),
+      1≤Z → 0<R → N≤L → V≤L → (∀I∈labels,(I.absNorm:ℝ)≤Z^V) →
+      (∀t,W t≠0 → t≤b) → b*Z^N≤D → 0≤Elong →
+      Z^(-V)*(∑I∈labels,secondLabelWeight K I*∑z∈nonzeroChildFrequencyBall 1 R,
+        ‖markedShortCompletedSum (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z)
+          W (Z^N) H₀ (indexedIdealMark (fun i:primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)=>i.val)
+            slots lists a)‖^2)≤Eshort →
+      (∀j∈cubeLogRange b (Z^N),
+        (progressingCubes S D H₀ (activeCubeLogBin S D b (Z^N) j)).Nonempty →
+        Z^(-V)*rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D
+          (progressingCubes S D H₀ (activeCubeLogBin S D b (Z^N) j))
+          Ψ m (idealGenerator I) z W (Z^N) H₀ slots lists a) R≤Elong) →
+      Z^(-(N+V))*(∑I∈labels,secondLabelWeight K I*∑z∈nonzeroChildFrequencyBall 1 R,
+        ‖outsideCanonicalMarkedRow S D hbad Ψ m (idealGenerator I) z slots lists a W (Z^N)‖^2)≤
+      2*Eshort+C*Z^eps*Elong := by
+  obtain ⟨Cw,hCw,hw⟩:=actual_complete_finite_split K L (eps/2) hL (by positivity)
+  obtain ⟨Cb,hCb,hbnd⟩:=actual_cube_bin_count b L (eps/2) hb hL (by positivity)
+  refine ⟨2*Cw*Cb,by positivity,?_⟩
+  intro σ _ S D hbad hSp labels hlabels Ψ m slots lists a W hWc Z N V R H₀ Eshort Elong
+    hZ hR hN hV hnorm hW hD hE hshort hlong
+  have hz:0<Z:=zero_lt_one.trans_le hZ
+  have hs:=hw S D hbad hSp labels hlabels Ψ m slots lists a W hWc b Z N V R H₀ hZ hR hV hnorm hW hD
+  have ha:=actual_large_bins_aggregate S D labels Ψ m W b (Z^N) H₀ R Z V Elong slots lists a hlong hE
+  have hc:=hbnd (Z^N) Z (Real.rpow_nonneg hz.le _) hZ (Real.rpow_le_rpow_of_exponent_le hZ hN)
+  have hh:Z^(eps/2)*Z^(eps/2)=Z^eps := by rw [←Real.rpow_add hz];congr 1;ring
+  have hp:Z^(-V+eps/2)=Z^(-V)*Z^(eps/2):=Real.rpow_add hz _ _
+  have ha':2*Cw*Z^(-V+eps/2)*(cubeLogRange b (Z^N)).card*∑j∈cubeLogRange b (Z^N),
+      rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D
+        (progressingCubes S D H₀ (activeCubeLogBin S D b (Z^N) j))
+        Ψ m (idealGenerator I) z W (Z^N) H₀ slots lists a) R≤
+      (2*Cw*Cb)*Z^eps*Elong := by
+    have h1:=mul_le_mul_of_nonneg_left ha (show 0≤2*Cw*Z^(eps/2) by positivity)
+    have h2:=mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_right hc hE)
+      (show 0≤2*Cw*Z^(eps/2) by positivity)
+    have ht:=h1.trans h2
+    rw [hp]
+    convert ht using 1
+    · ring
+    · rw [←hh];ring
+  exact hs.trans (add_le_add (mul_le_mul_of_nonneg_left hshort (by norm_num:0≤(2:ℝ))) ha')
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongUniformTestBin.lean

@@ -0,0 +1,151 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongKeys
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongIntegral
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical SchwartzMap ContDiff
+namespace SevenEighths.InverseMoment
+open MeasureTheory ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve CanonicalCubeSeparation FirstPassCubeLabels SecondPassArithmetic
+open InverseMomentFirstLabelCell InverseMomentFirstSecondHeightCost CompletedHeight
+open FourierBridge JointLogSeparation
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem actual_marked_bin_uniform_test
+    (a₀ b₀:ℝ)(ha₀:0<a₀)(hb₀:0≤b₀)
+    (Vlog:𝓢(ℝ,ℂ))(Alog:ℝ)(hbox:∀x,Vlog x≠0 → |x|≤Alog)
+    (hone:∀x,|x|≤CanonicalCubeSeparation.columnWindowRadius a₀ b₀ → Vlog x=1)
+    (Lcap eta tau saving em ed:ℝ)(hcap:0≤Lcap)
+    (heta:0≤eta)(heta1:eta≤1)(htau:0<tau)(htau1:tau≤1)
+    (hem:0<em)(hed:0<ed)(K:ℕ):
+    ∃(ω₁₁ ω₁₂ ω₂₁ ω₂₂:𝓢(ℝ,ℂ))(af₁ bf₁ af₂ bf₂ window bw:ℝ),
+      0<af₁ ∧ af₁≤bf₁ ∧ 0<af₂ ∧ af₂≤bf₂ ∧
+      HasCompactSupport (ω₁₁:ℝ → ℂ) ∧ HasCompactSupport (ω₁₂:ℝ → ℂ) ∧
+      HasCompactSupport (ω₂₁:ℝ → ℂ) ∧ HasCompactSupport (ω₂₂:ℝ → ℂ) ∧
+      tsupport (ω₁₁:ℝ → ℂ)⊆Set.Icc af₁ bf₁ ∧ tsupport (ω₁₂:ℝ → ℂ)⊆Set.Icc af₁ bf₁ ∧
+      tsupport (ω₂₁:ℝ → ℂ)⊆Set.Icc af₂ bf₂ ∧ tsupport (ω₂₂:ℝ → ℂ)⊆Set.Icc af₂ bf₂ ∧
+      1≤bw ∧ Real.exp Alog≤bw ∧ bw=Real.exp window ∧
+    ∀epsFirst epsSecond:ℝ,0<epsFirst → 0<epsSecond → ∀degree:ℕ,
+      ∃Ccoef C:ℝ,0<Ccoef ∧ 0≤C ∧
+    ∀(test:ℝ → ℂ)(hs₀:Function.support test⊆Set.Icc a₀ b₀)(hTest:ContDiff ℝ ∞ test),
+    ∀{σ:Type}[DecidableEq σ](S:Finset (Ideal O))(D:ℕ)(hbad:fixedBadPrimes⊆S)(hSp:∀P∈S,Prime P),
+      let F:=InitialMeanSquare.outsideSquarefreeIdeals S D;
+      let hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad;
+      letI : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=
+        fun i=>by rw [poolPrimary_span F hF i];infer_instance;
+      let p:=poolPrimary F;
+      let hp:=poolPrimary_ne_zero F hF;
+      let hcop:=poolPrimary_coprime F hF;
+      let hg:=poolPrimary_good F hF;
+      let om:=radialFromLog Vlog (Vlog.smooth ⊤) Alog hbox;
+      ∀(Q:Finset (primePool F →₀ ℕ))(labels:Finset (Ideal O))(Ψ:O →* ℂ)(m:O)
+        (slots:Finset σ)(lists:σ → Finset (primePool F))(weights:σ → primePool F → ℂ)
+        (Z M r ell V H₀ pi epschild A loss lossFinal:ℝ),
+        2≤Z → 2≤Z^eta → Real.exp 1≤Z^eta → 0≤M → r+3*ell+V≤Lcap → M≤Lcap →
+        0≤ell → 0≤V → -eta≤r → Real.exp Alog≤Z^eta →
+        (∀v∈Q,Z^ell≤(Ideal.absNorm (cubeIdeal F v):ℝ)) →
+        (∀v∈Q,(Ideal.absNorm (cubeIdeal F v):ℝ)≤Real.exp 1*Z^ell) →
+        r≤Lcap → ell≤Lcap → V≤Lcap → Real.exp window≤Z^eta → 0≤pi → 6*eta≤pi →
+        em*(20*(3*Lcap+16)+30)≤pi/4 → ed*(20*(3*Lcap+16)+30)≤pi/4 →
+        0≤epschild → -saving≤r+3*ell+V+48*eta+tau+pi+epschild+epsSecond →
+        48*eta+tau+pi+epschild+epsSecond≤loss → slots.card≤K →
+        M-ell≤r+3*ell+V → 3*eta+epsFirst*(5*ell+2*r+7*eta)≤lossFinal →
+        loss+(2*Lcap+15*eta+tau)*epsFirst+epsFirst≤lossFinal → -saving≤r+3*ell+V+lossFinal →
+        (∀u,‖Ψ u‖≤1) → 0≤A → (∀I∈labels,Squarefree I) → (∀I∈labels,I≠0) →
+        (∀I∈labels,(Ideal.absNorm I:ℝ)≤Z^(V+eta)) →
+        (slots:Set σ).PairwiseDisjoint lists → (∀i∈slots,∀q∈lists i,‖weights i q‖≤1) →
+        b₀*Z^(r+3*ell)≤D →
+        (∀ξ:ℝ,∀k∈actualLongSourceKeys p hp hcop hg Finset.univ Q labels Ψ m (m*excludedGenerator S)
+          slots lists weights om Z M r ell V H₀ ξ Lcap eta tau,
+          ChildBounds p hp hcop hg Finset.univ Q k.1 k.2.1 k.2.2 true Ψ m slots lists weights ω₁₁ ω₁₂
+            Z M r ell V eta tau window bw epschild A K degree) →
+        (∀ξ:ℝ,∀k∈actualLongSourceKeys p hp hcop hg Finset.univ Q labels Ψ m (m*excludedGenerator S)
+          slots lists weights om Z M r ell V H₀ ξ Lcap eta tau,
+          ChildBounds p hp hcop hg Finset.univ Q k.1 k.2.1 k.2.2 false Ψ m slots lists weights ω₂₁ ω₂₂
+            Z M r ell V eta tau window bw epschild A K degree) →
+        Z^(-V)*rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D Q Ψ m (idealGenerator I) z
+          test (Z^(r+3*ell)) H₀ slots lists weights) (Z^M)≤
+          C*(Ccoef*(Real.exp 1*Z^ell)^epsFirst)^2*(1+A)*Z^(r+3*ell+V+lossFinal)*
+            (∫ξ:ℝ,‖reopeningCoefficient test a₀ b₀ ha₀ hs₀ hTest ξ‖*(1+|ξ|)^(InverseClippingProfiles.momentOrder (firstDegree degree)))^2 := by
+  let om:=radialFromLog Vlog (Vlog.smooth ⊤) Alog hbox
+  have hs:Function.support om⊆Set.Icc (Real.exp (-Alog)) (Real.exp Alog):=
+    fun x hx=>radialFromLog_support Vlog (Vlog.smooth ⊤) Alog hbox x hx
+  obtain ⟨ω₁₁,ω₁₂,ω₂₁,ω₂₂,af₁,bf₁,af₂,bf₂,window,bw,
+    haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hbwexp,he⟩:=
+    actual_long_parent_energy om (Real.exp (-Alog)) (Real.exp Alog) (Real.exp_pos _) hs
+      Lcap eta tau saving em ed hcap (Real.exp_pos _).le heta heta1 htau htau1 hem hed K
+  refine ⟨ω₁₁,ω₁₂,ω₂₁,ω₂₂,af₁,bf₁,af₂,bf₂,window,bw,
+    haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hbwexp,?_⟩
+  intro epsFirst epsSecond hepsF hepsS degree
+  obtain ⟨Ccoef,C,hCcoef,hC,hparent⟩:=he epsFirst epsSecond hepsF hepsS degree
+  let d:=InverseClippingProfiles.momentOrder (firstDegree degree)
+  refine ⟨Ccoef,C,hCcoef,hC,?_⟩
+  intro test hs₀ hTest
+  let moment:ℝ:=∫ξ:ℝ,‖reopeningCoefficient test a₀ b₀ ha₀ hs₀ hTest ξ‖*(1+|ξ|)^d
+  intro σ _ S D hbad hSp
+  let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+  have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad
+  let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=
+    fun i=>by rw [poolPrimary_span F hF i];infer_instance
+  dsimp only
+  intro Q labels Ψ m slots lists weights Z M r ell V H₀ pi epschild A loss lossFinal
+    hZ hbin hbinExp hM hFcap hMcap hell hV hr hbZ hQlo hQhi hrcap hellcap hVcap hwin
+    hpi hpieta hemcost hedcost hechild hsave hloss hcard hpar hprincipal hretained htail
+    hΨ hA hsf hn hlabels hslots hweights hD hleft hright
+  have hz:0<Z:=by linarith
+  have hg' : ∀i:primePool F,goodLambda∉Ideal.span {poolPrimary F i}:=poolPrimary_good F hF
+  have hinj:Function.Injective (fun i:primePool F=>Ideal.span {poolPrimary F i}) := by
+    intro i j hij
+    exact Subtype.ext (by simpa only [poolPrimary_span F hF] using hij)
+  have hpr (i:primePool F):goodLambda^2∣poolPrimary F i-1:=
+    (primaryPrime_spec i.val (poolPrimary_ne_zero F hF i)).2.2.2
+  let Gamma:=Ccoef*(Real.exp 1*Z^ell)^epsFirst
+  let E:=C*Gamma^2*(1+A)*Z^(r+3*ell+V+lossFinal)
+  have hE:0≤E:=by dsimp [E];positivity
+  refine (actual_long_bin_normalized_energy S D hbad hSp Q labels Ψ m test a₀ b₀ ha₀ hb₀ hs₀ hTest
+    Vlog hone Z r ell V H₀ (Z^M) E d hz hD (Real.rpow_pos_of_pos hz _) hE hQlo hQhi slots lists weights ?_).trans_eq ?_
+  · intro ξ
+    have hbnd:=hparent (poolPrimary F) (poolPrimary_ne_zero F hF) hg' hinj
+      (poolPrimary_coprime F hF) (poolPrimary_odd F hF) hpr Finset.univ Q labels Ψ m (m*excludedGenerator S)
+      slots lists weights Z M r ell V H₀ ξ pi epschild A loss lossFinal
+      hZ hbin hbinExp hM hFcap hMcap hell hV hr hbZ (fun _ _=>Finset.subset_univ _)
+      (by intro v hv;rw [cubeIdeal_primeProduct_norm F hF];exact hQlo v hv)
+      (by intro v hv;rw [cubeIdeal_primeProduct_norm F hF];exact hQhi v hv)
+      hrcap hellcap hVcap hwin hpi hpieta hemcost hedcost hechild hsave hloss hcard hpar hprincipal hretained htail
+      hΨ hA hsf hn hlabels hslots hweights (hleft ξ) (hright ξ)
+    have hc (I:Ideal O) := funext (actualLongCoefficient_complete S D hbad Ψ m H₀ (Z^ell) ξ I)
+    have hrow: (fun I z=>varyingReopenedRow (poolPrimary F) (poolPrimary_ne_zero F hF)
+        (poolPrimary_coprime F hF) hg' Finset.univ Q
+        (separatedCubeCoefficient (fun v=>reopenedCubeCoefficient H₀
+          (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) 1) (cubeIdeal F v))
+          (fun v=>(Ideal.absNorm (cubeIdeal F v):ℝ)) (Z^ell) ξ) Ψ m (idealGenerator I)
+        (fun v T=>primeMark slots lists weights (T∪v.support)*frequencyTwist Vlog ξ (columnLog (poolPrimary F) (Z^r) T)) z)=
+      (fun I z=>varyingReopenedRow (poolPrimary F) (poolPrimary_ne_zero F hF)
+        (poolPrimary_coprime F hF) hg' Finset.univ Q
+        (separatedCubeCoefficient (fun v=>reopenedCubeCoefficient H₀
+          (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) 1) (cubeIdeal F v))
+          (fun v=>(Ideal.absNorm (cubeIdeal F v):ℝ)) (Z^ell) ξ) Ψ m (idealGenerator I)
+        (fun v T=>primeMark slots lists weights (v.support∪T)*normTwistedSource om ξ (primeProductNorm (poolPrimary F) T/Z^r)) z) := by
+      funext I z
+      exact long_marked_source_eq (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+        hg' Finset.univ Q _ Ψ m (idealGenerator I) z slots lists weights Vlog Alog hbox Z r ξ hz
+    rw [hrow]
+    convert hbnd using 1
+    · apply congrArg (fun f => Z^(-r-2*ell-V)*rowFamilyEnergy labels f (Z^M))
+      funext I z
+      exact congrArg (fun coeff => varyingReopenedRow (poolPrimary F) (poolPrimary_ne_zero F hF)
+        (poolPrimary_coprime F hF) hg' Finset.univ Q coeff Ψ m (idealGenerator I)
+        (fun v T => primeMark slots lists weights (v.support∪T)*normTwistedSource om ξ
+          (primeProductNorm (poolPrimary F) T/Z^r)) z) (hc I).symm
+    · dsimp [E,Gamma,d]
+      try simp only [Real.norm_eq_abs]
+      ring
+  · dsimp [E,Gamma,moment]
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongWeight.lean

@@ -0,0 +1,65 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongNormalization
+import OAI.NumberTheory.DirichletL.Descent.TripleMass
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve FirstPassCubeLabels SecondPassArithmetic
+open InverseSecondFibers InverseInitialClippedColumns IdealMobiusDivisorSum
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem second_label_weight_uniform (K:ℕ)(L eps:ℝ)(hL:0≤L)(heps:0<eps) :
+    ∃C:ℝ,0<C ∧ ∀(Z V:ℝ),1≤Z→V≤L→∀I:Ideal O,I≠0→
+      (I.absNorm:ℝ)≤Z^V→secondLabelWeight K I≤C*Z^eps := by
+  let delta:=eps/(L+1)
+  have hd:0<delta:=div_pos heps (by linarith)
+  obtain ⟨C,hC,hh⟩:=ideal_divisor_power_small (9+4*K) delta hd
+  refine ⟨C,hC,?_⟩
+  intro Z V hZ hV I hI hnorm
+  have hz:0<Z:=zero_lt_one.trans_le hZ
+  have hbudget:L*delta≤eps := by
+    have he:(L+1)*delta=eps:=by dsimp [delta];field_simp
+    nlinarith
+  calc
+    secondLabelWeight K I≤C*(I.absNorm:ℝ)^delta:=hh I hI
+    _≤C*(Z^L)^delta:=by
+      gcongr
+      exact hnorm.trans (Real.rpow_le_rpow_of_exponent_le hZ hV)
+    _=C*Z^(L*delta):=by rw [←Real.rpow_mul hz.le]
+    _≤C*Z^eps:=by gcongr
+
+theorem normalized_second_energy_le_actual_family (K:ℕ)(L eps:ℝ)(hL:0≤L)(heps:0<eps) :
+    ∃C:ℝ,0<C ∧ ∀{ι σ:Type*}[DecidableEq ι][DecidableEq σ]
+      (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+      (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+      (hg:∀i,goodLambda∉Ideal.span {p i})
+      (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+      (labels:Finset (Ideal O))(_hlabels:∀I∈labels,Admissible I)
+      (W:ℝ→ℂ)(X Z F V R:ℝ),1≤Z→0<R→V≤L→
+      (∀I∈labels,(I.absNorm:ℝ)≤Z^V)→
+      normalizedColumnEnergy p hp hcop hg pool Ψ m slots lists a labels
+        (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) W X Z F≤
+        C*Z^(-F+eps)*rowFamilyEnergy labels (fun I k=>
+          finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (idealGenerator I) k slots lists a W X) R := by
+  obtain ⟨C,hC,hh⟩:=second_label_weight_uniform K L eps hL heps
+  refine ⟨C,hC,?_⟩
+  intro ι σ _ _ p hp _ hcop hg pool Ψ m slots lists a labels hlabels W X Z F V R hZ hR hV hnorm
+  have hz:0<Z:=zero_lt_one.trans_le hZ
+  have hb:=normalized_energy_le_actual_family p hp hcop hg pool Ψ m slots lists a labels
+    (fun I hI=>supported_primaryGenerator_ne_zero I (admissible_supported (hlabels I hI)))
+    (secondLabelWeight K) (C*Z^eps) (by positivity)
+    (fun I hI=>⟨by unfold secondLabelWeight;positivity,
+      hh Z V hZ hV I (hlabels I hI).1 (hnorm I hI)⟩) W X Z F R hz hR
+  convert hb using 1
+  rw [Real.rpow_add hz]
+  ring
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLowerMoments.lean

@@ -0,0 +1,88 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalChildSupport
+import OAI.NumberTheory.DirichletL.Descent.FirstLabelCellStep
+
+namespace OAI
+
+noncomputable section
+open scoped Classical BigOperators SchwartzMap
+
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CanonicalQuadraticSieve
+open InverseInitialClippedColumns InverseSecondFibers InverseSecondSourceBlocks
+open CanonicalCoefficientClass InverseMomentFirstLabelCell InverseMomentFirstChildWindows InverseFirstGlobalCaps
+local notation "O"=>ActualEisensteinCubic.O
+variable {ι σ:Type}[DecidableEq ι][DecidableEq σ]
+variable (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+variable (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+variable (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i})
+
+def CanonicalLowerMoments (pool:Finset ι)(base:O→*ℂ)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+    (W:𝓢(ℝ,ℂ))(Z Mmax Fcap z c eps A:ℝ)(K degree:ℕ):Prop :=
+  ∀(Ψ:O→*ℂ),IsBaseRayTwist base Ψ→∀(m:O),m≠0→∀N V M Qwidth:ℝ,
+    0≤N→0≤V→0≤M→0≤Qwidth→M<Mmax→N+V≤Fcap→
+    CanonicalMargins (N+V) M Qwidth z c→
+    ‖ConcreteTraceCRT.eisEmbedding m‖^2=Z^Qwidth→
+    ∀(subslots:Finset σ),subslots⊆slots→∀labels:Finset (Ideal O),
+      (∀I∈labels,Admissible I ∧ (Ideal.absNorm I:ℝ)≤Z^V)→∀s:ℝ,
+    normalizedColumnEnergy p hp hcop hg pool Ψ m subslots lists a labels
+      (nonzeroChildFrequencyBall 1 (Z^M)) (secondLabelWeight K) (childLogTest W s) (Z^N) Z (N+V)≤
+      A*Z^(N+V+eps)*(1+‖s‖)^(2*degree)
+
+include hp in
+theorem canonical_lower_moments_children
+    (hc:∀i,ringChar (O⧸Ideal.span {p i})≠2)
+    (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1)
+    (pool:Finset ι)(Q:Finset (ι→₀ℕ))(k:SourceIndex)(l j:ℕ)(negative:Bool)
+    (base Ψ:O→*ℂ)(hΨ:IsBaseRayTwist base Ψ)(m:O)(hm:m≠0)
+    (slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)(ω₁ ω₂:𝓢(ℝ,ℂ))
+    (Z M r ell V eta tau window b cutoff Qwidth z c eps A:ℝ)(K degree:ℕ)
+    (hZ:1<Z)(heta:0≤eta)(hbin:2≤Z^eta)(hell:0≤ell)(hV:0≤V)
+    (hb:1≤b)(hbt:b≤Z^(6*eta))(hwindow:Real.exp window≤Z^(4*eta))
+    (hd:0<cutoff)(hterminal:cutoff≤ell+V)(hsmall:eta≤cutoff/16)
+    (hparent:CanonicalMargins (r+3*ell+V) M Qwidth z c)
+    (hpuncture:(Ideal.absNorm (Ideal.span {m}:Ideal O).radical:ℝ)≤Z^Qwidth)
+    (hQ:∀v∈Q,‖ConcreteTraceCRT.eisEmbedding (primeProduct p v.support v)‖^2≤Z^(ell+eta))
+    (h₁:CanonicalLowerMoments p hp hcop hg pool base slots lists a ω₁ Z M (r+3*ell+V+15*eta) z (c-7*eta) eps A K degree)
+    (h₂:CanonicalLowerMoments p hp hcop hg pool base slots lists a ω₂ Z M (r+3*ell+V+15*eta) z (c-7*eta) eps A K degree):
+    ChildBounds p hp hcop hg pool Q k l j negative Ψ m slots lists a ω₁ ω₂
+      Z M r ell V eta tau window b eps A K degree :=by
+  intro ray core assigned hass
+  let S:=source p pool Q k l j negative assigned lists Z M r ell V eta tau window b
+  let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core
+  have hbase:IsBaseRayTwist base Ψ₀:=hΨ.firstCore _ _ _
+  have hstate:=source_state_bounds p hp pool Q k l j negative assigned lists Z M r ell V eta tau window b cutoff
+    hZ heta hbin hell hV hb hbt hwindow hterminal hsmall hQ
+  have hmargin:=source_child_margins p hp hpr pool Q k l j negative assigned lists Z M r ell V eta tau window b
+    m hm Qwidth z c hZ heta hbin hV hparent hpuncture hQ
+  have hlabels:=source_labels p hp pool Q k l j negative assigned lists Z M r ell V eta tau window b hZ heta hbin hQ
+  constructor
+  · intro zz d hdcell s J hJ γ hγ
+    have st:=hstate d hdcell
+    have mg:=hmargin d γ hγ
+    apply h₁ (secondRayMinus Ψ₀ zz) (hbase.secondMinus zz) (actualSecondInheritedRadicalPuncture m γ) mg.1
+      (max 0 (secondCellColumnExponent Z (columnScale Z r k l negative) d))
+      (actualCellLabelExponent Z (exponent Z (k 2)) (exponent Z j) eta d)
+      (actualCellRowExponent Z M ell (columnA Z k negative) (exponent Z l) V (exponent Z j) eta d)
+      (actualSecondPunctureWidth Z m γ) st.1 st.2.1 st.2.2.2.1 mg.2.1 (by linarith [st.2.2.2.2]) st.2.2.1 mg.2.2.2 mg.2.2.1
+      ((slots\assigned)\J) (Finset.sdiff_subset.trans Finset.sdiff_subset)
+      ((actualCellLabels p S d).filter Squarefree) ?_ s
+    intro I hI
+    exact ⟨actual_cell_labels_admissible p hp hg hc S d I hI,(hlabels.2 d I hI).2.2⟩
+  · intro zz d hdcell s J hJ γ hγ
+    have st:=hstate d hdcell
+    have mg:=hmargin d γ hγ
+    apply h₂ (secondRayPlus Ψ₀ zz) (hbase.secondPlus zz) (actualSecondInheritedRadicalPuncture m γ) mg.1
+      (max 0 (secondCellColumnExponent Z (columnScale Z r k l negative) d))
+      (actualCellLabelExponent Z (exponent Z (k 2)) (exponent Z j) eta d)
+      (actualCellRowExponent Z M ell (columnA Z k negative) (exponent Z l) V (exponent Z j) eta d)
+      (actualSecondPunctureWidth Z m γ) st.1 st.2.1 st.2.2.2.1 mg.2.1 (by linarith [st.2.2.2.2]) st.2.2.1 mg.2.2.2 mg.2.2.1
+      ((slots\assigned)\J) (Finset.sdiff_subset.trans Finset.sdiff_subset)
+      ((actualCellLabels p S d).filter Squarefree) ?_ s
+    intro I hI
+    exact ⟨actual_cell_labels_admissible p hp hg hc S d I hI,(hlabels.2 d I hI).2.2⟩
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalPunctureMask.lean

@@ -0,0 +1,113 @@
+import OAI.NumberTheory.DirichletL.Descent.ActualChildStatePuncture
+import OAI.NumberTheory.DirichletL.Inversion.InitialClippedColumns
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators Classical
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss
+open CanonicalRowCompletion ConcretePrimeRowBridge CanonicalQuadraticSieve
+open InverseInitialClippedColumns
+local notation "Eis" => ActualEisensteinCubic.O
+
+section General
+variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ]
+  (p : ι → Eis) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal]
+  (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+  (hg : ∀ i,goodLambda∉Ideal.span {p i})
+
+omit [DecidableEq ι] in
+theorem rowCoprimeMask_redundant_mul (S : Finset ι) (m c : Eis)
+    (hc : ∀ i∈S,c∈Ideal.span {p i}→m∈Ideal.span {p i}) :
+    rowCoprimeMask (fun i=>Ideal.span {p i}) S (m*c)=
+      rowCoprimeMask (fun i=>Ideal.span {p i}) S m := by
+  have he : (∃i∈S,m*c∈Ideal.span {p i}) ↔ ∃i∈S,m∈Ideal.span {p i} := by
+    constructor
+    · rintro ⟨i,hi,hm⟩
+      exact ⟨i,hi,((inferInstance : (Ideal.span {p i}).IsPrime).mem_or_mem hm).elim id (hc i hi)⟩
+    · rintro ⟨i,hi,hm⟩
+      exact ⟨i,hi,Ideal.mul_mem_right _ _ hm⟩
+  simp only [rowCoprimeMask,he]
+
+omit [DecidableEq σ] in
+theorem finiteCanonicalMarkedRow_redundant_puncture
+    (pool : Finset ι) (Ψ : Eis →* ℂ) (m c f k : Eis)
+    (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) (W : ℝ→ℂ) (X : ℝ)
+    (hc : ∀ i∈pool,c∈Ideal.span {p i}→m∈Ideal.span {p i}) :
+    finiteCanonicalMarkedRow p hp hcop hg pool Ψ (m*c) f k slots lists a W X=
+      finiteCanonicalMarkedRow p hp hcop hg pool Ψ m f k slots lists a W X := by
+  unfold finiteCanonicalMarkedRow fixedChildRow
+  apply Finset.sum_congr rfl
+  intro S hS
+  have hm := rowCoprimeMask_redundant_mul p S m c
+    (fun i hi=>hc i (Finset.mem_powerset.mp hS hi))
+  simp only [secondChildColumn,hm]
+
+omit [DecidableEq σ] in
+theorem normalizedColumnEnergy_redundant_puncture
+    (pool : Finset ι) (Ψ : Eis →* ℂ) (m c : Eis)
+    (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ)
+    (labels : Finset (Ideal Eis)) (rows : Finset Eis) (D : Ideal Eis→ℝ)
+    (W : ℝ→ℂ) (X Z F : ℝ)
+    (hc : ∀ i∈pool,c∈Ideal.span {p i}→m∈Ideal.span {p i}) :
+    normalizedColumnEnergy p hp hcop hg pool Ψ (m*c) slots lists a labels rows D W X Z F=
+      normalizedColumnEnergy p hp hcop hg pool Ψ m slots lists a labels rows D W X Z F := by
+  simp only [normalizedColumnEnergy,finiteCanonicalMarkedRow_redundant_puncture
+    p hp hcop hg pool Ψ m c _ _ slots lists a W X hc]
+
+omit [DecidableEq ι] in
+theorem puncture_mem_of_radical_dvd (m c : Eis)
+    (hc : (Ideal.span {c}:Ideal Eis).radical∣(Ideal.span {m}:Ideal Eis).radical)
+    (i : ι) (hi : c∈Ideal.span {p i}) : m∈Ideal.span {p i} := by
+  rw [←Ideal.span_singleton_le_iff_mem]
+  apply Ideal.le_radical.trans
+  apply (Ideal.dvd_iff_le.mp hc).trans
+  exact (inferInstance : (Ideal.span {p i}).IsPrime).radical_le_iff.mpr
+    (by rwa [Ideal.span_singleton_le_iff_mem])
+
+omit [DecidableEq ι] in
+theorem inherited_puncture_redundant_mem (m c : Eis)
+    (γ : InverseSecondFibers.OuterTriple)
+    (hc : (Ideal.span {c}:Ideal Eis).radical∣Ideal.span {m})
+    (i : ι) (hi : c∈Ideal.span {p i}) :
+    actualSecondInheritedRadicalPuncture m γ∈Ideal.span {p i} := by
+  have hd := actual_inherited_radical_preserves_fixed m γ (Ideal.span {c}).radical
+    (Ideal.radical_idem _) hc
+  apply puncture_mem_of_radical_dvd p _ c _ i hi
+  rw [actual_inherited_radical_is_radical]
+  exact hd
+
+end General
+
+theorem outside_pool_redundant_puncture {σ : Type*} [DecidableEq σ]
+    (S : Finset (Ideal Eis)) (D : ℕ) (hbad : fixedBadPrimes⊆S)
+    (hSp : ∀P∈S,Prime P)
+    (pool : Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)))
+    (Ψ : Eis →* ℂ) (m f k : Eis) (slots : Finset σ)
+    (lists : σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)))
+    (a : σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ)
+    (W : ℝ→ℂ) (X : ℝ) :
+    let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+    let hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad
+    letI : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=
+      fun i=>by rw [poolPrimary_span F hF i];infer_instance
+    finiteCanonicalMarkedRow (poolPrimary F) (poolPrimary_ne_zero F hF)
+      (poolPrimary_coprime F hF) (poolPrimary_good F hF) pool Ψ
+      (m*excludedGenerator S) f k slots lists a W X=
+    finiteCanonicalMarkedRow (poolPrimary F) (poolPrimary_ne_zero F hF)
+      (poolPrimary_coprime F hF) (poolPrimary_good F hF) pool Ψ m f k slots lists a W X := by
+  let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+  have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad
+  let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=
+    fun i=>by rw [poolPrimary_span F hF i];infer_instance
+  dsimp only
+  apply finiteCanonicalMarkedRow_redundant_puncture
+  intro i hi hc
+  rw [poolPrimary_span _ (InitialMeanSquare.outsideSquarefree_admissible S D hbad)] at hc
+  exact False.elim (excludedGenerator_not_mem_pool S D hSp i hc)
+
+end SevenEighths.InverseMoment
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalPunctureMaskEnergy.lean

@@ -0,0 +1,84 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalPunctureMask
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators Classical
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve InverseInitialClippedColumns
+local notation "Eis" => ActualEisensteinCubic.O
+
+theorem outside_pool_redundant_energy {σ : Type*} [DecidableEq σ]
+    (S : Finset (Ideal Eis)) (D : ℕ) (hbad : fixedBadPrimes⊆S)
+    (hSp : ∀P∈S,Prime P)
+    (pool : Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)))
+    (Ψ : Eis →* ℂ) (m : Eis) (slots : Finset σ)
+    (lists : σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)))
+    (a : σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ)
+    (labels : Finset (Ideal Eis)) (rows : Finset Eis) (weight : Ideal Eis→ℝ)
+    (W : ℝ→ℂ) (X Z Fexp : ℝ) :
+    let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+    let hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad
+    letI : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=
+      fun i=>by rw [poolPrimary_span F hF i];infer_instance
+    normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF)
+      (poolPrimary_coprime F hF) (poolPrimary_good F hF) pool Ψ
+      (m*excludedGenerator S) slots lists a labels rows weight W X Z Fexp=
+    normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF)
+      (poolPrimary_coprime F hF) (poolPrimary_good F hF) pool Ψ
+      m slots lists a labels rows weight W X Z Fexp := by
+  let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+  have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad
+  let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=
+    fun i=>by rw [poolPrimary_span F hF i];infer_instance
+  dsimp only
+  apply normalizedColumnEnergy_redundant_puncture
+  intro i hi hc
+  rw [poolPrimary_span F hF i] at hc
+  exact False.elim (excludedGenerator_not_mem_pool S D hSp i hc)
+
+theorem reflection_pool_mask_energy {σ : Type*} [DecidableEq σ]
+    (q D : ℕ)
+    (pool : Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)))
+    (Ψ : Eis →* ℂ) (m : Eis) (slots : Finset σ)
+    (lists : σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)))
+    (a : σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)→ℂ)
+    (labels : Finset (Ideal Eis)) (rows : Finset Eis) (weight : Ideal Eis→ℝ)
+    (W : ℝ→ℂ) (X Z Fexp : ℝ) :
+    let S:=reflectionExcludedPrimes q
+    let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+    let hF:=InitialMeanSquare.outsideSquarefree_admissible S D (reflectionExcludedPrimes_bad q)
+    letI : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=
+      fun i=>by rw [poolPrimary_span F hF i];infer_instance
+    normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF)
+      (poolPrimary_coprime F hF) (poolPrimary_good F hF) pool Ψ
+      (ActualFiber.maskElement q m) slots lists a labels rows weight W X Z Fexp=
+    normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF)
+      (poolPrimary_coprime F hF) (poolPrimary_good F hF) pool Ψ
+      m slots lists a labels rows weight W X Z Fexp :=
+  outside_pool_redundant_energy (reflectionExcludedPrimes q) D
+    (reflectionExcludedPrimes_bad q) (reflectionExcludedPrimes_prime q)
+    pool Ψ m slots lists a labels rows weight W X Z Fexp
+
+theorem inherited_radical_mask_energy {ι σ : Type*} [DecidableEq ι] [DecidableEq σ]
+    (p : ι→Eis) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal]
+    (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+    (hg : ∀i,goodLambda∉Ideal.span {p i})
+    (pool : Finset ι) (Ψ : Eis→*ℂ) (m c : Eis) (γ : InverseSecondFibers.OuterTriple)
+    (hc : (Ideal.span {c}:Ideal Eis).radical∣Ideal.span {m})
+    (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ)
+    (labels : Finset (Ideal Eis)) (rows : Finset Eis) (weight : Ideal Eis→ℝ)
+    (W : ℝ→ℂ) (X Z Fexp : ℝ) :
+    normalizedColumnEnergy p hp hcop hg pool Ψ
+      (actualSecondInheritedRadicalPuncture m γ*c) slots lists a labels rows weight W X Z Fexp=
+    normalizedColumnEnergy p hp hcop hg pool Ψ
+      (actualSecondInheritedRadicalPuncture m γ) slots lists a labels rows weight W X Z Fexp :=
+  normalizedColumnEnergy_redundant_puncture p hp hcop hg pool Ψ _ c
+    slots lists a labels rows weight W X Z Fexp
+    (fun i _=>inherited_puncture_redundant_mem p m c γ hc i)
+
+end SevenEighths.InverseMoment
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankCapChildren.lean

@@ -0,0 +1,55 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalRankMonotone
+
+namespace OAI
+
+noncomputable section
+open scoped Classical BigOperators SchwartzMap
+
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CanonicalQuadraticSieve
+open InverseMomentFirstLabelCell InverseMomentFirstChildWindows InverseFirstGlobalCaps
+local notation "O"=>ActualEisensteinCubic.O
+variable {ι σ:Type}[DecidableEq ι][DecidableEq σ]
+variable (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+variable (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+variable (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i})
+
+theorem canonical_rank_cap_children
+    (hc:∀i,ringChar (O⧸Ideal.span {p i})≠2)
+    (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1)
+    (pool:Finset ι)(Q:Finset (ι→₀ℕ))(k:SourceIndex)(l j:ℕ)(negative:Bool)
+    (base Ψ:O→*ℂ)(hΨ:CanonicalCoefficientClass.IsBaseRayTwist base Ψ)(m:O)(hm:m≠0)
+    (slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)(ω₁ ω₂:𝓢(ℝ,ℂ))
+    (Z M r ell V eta tau window b cutoff Qwidth z c eps A Mnext Fnext cnext:ℝ)(K degree:ℕ)
+    (hZ:1<Z)(heta:0≤eta)(hbin:2≤Z^eta)(hell:0≤ell)(hV:0≤V)
+    (hb:1≤b)(hbt:b≤Z^(6*eta))(hwindow:Real.exp window≤Z^(4*eta))
+    (hd:0<cutoff)(hterminal:cutoff≤ell+V)(hsmall:eta≤cutoff/16)
+    (hparent:CanonicalMargins (r+3*ell+V) M Qwidth z c)
+    (hpuncture:(Ideal.absNorm (Ideal.span {m}:Ideal O).radical:ℝ)≤Z^Qwidth)
+    (hQ:∀v∈Q,‖ConcreteTraceCRT.eisEmbedding (primeProduct p v.support v)‖^2≤Z^(ell+eta))
+    (hMc:M-3*cutoff/2≤Mnext)(hFc:r+3*ell+V+15*eta≤Fnext)(hcc:cnext≤c-7*eta)
+    (h₁:CanonicalRankMoments p hp hcop hg pool base slots lists a ω₁ Z Mnext Fnext z cnext eps A K degree)
+    (h₂:CanonicalRankMoments p hp hcop hg pool base slots lists a ω₂ Z Mnext Fnext z cnext eps A K degree):
+    ChildBounds p hp hcop hg pool Q k l j negative Ψ m slots lists a ω₁ ω₂
+      Z M r ell V eta tau window b eps A K degree :=by
+  exact canonical_rank_moments_children p hp hcop hg hc hpr pool Q k l j negative base Ψ hΨ m hm
+    slots lists a ω₁ ω₂ Z M r ell V eta tau window b cutoff Qwidth z c eps A K degree
+    hZ heta hbin hell hV hb hbt hwindow hd hterminal hsmall hparent hpuncture hQ
+    (canonical_rank_restrict p hp hcop hg pool base slots lists a ω₁ Z _ _ _ _ z _ _ eps A K degree hMc hFc hcc h₁)
+    (canonical_rank_restrict p hp hcop hg pool base slots lists a ω₂ Z _ _ _ _ z _ _ eps A K degree hMc hFc hcc h₂)
+
+theorem canonical_depth_ceilings (n:ℕ)(cutoff Fbase cbase eta:ℝ)(M F c:ℝ)
+    (hM:M≤3*(n:ℝ)*cutoff/2)(hF:F≤Fbase-15*(n:ℝ)*eta)
+    (hc:cbase+7*((n:ℝ)+1)*eta≤c):
+    M-3*cutoff/2≤3*((n:ℝ)-1)*cutoff/2 ∧
+    F+15*eta≤Fbase-15*((n:ℝ)-1)*eta ∧
+    cbase+7*(n:ℝ)*eta≤c-7*eta :=by
+  constructor
+  · linarith
+  constructor <;> linarith
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankDepthParameters.lean

@@ -0,0 +1,66 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalRankExistenceData
+import OAI.NumberTheory.DirichletL.Descent.RecursionParameters
+
+namespace OAI
+
+noncomputable section
+
+namespace SevenEighths.InverseMoment
+
+theorem actual_rank_depth_covers (Mmax cutoff:ℝ)(hcut:0<cutoff):
+    Mmax≤rankRowCap (actualDepth Mmax (cutoff/2)) cutoff := by
+  have hceil:=Nat.le_ceil (2*Mmax/(3*(cutoff/2)))
+  have hscaled:2*Mmax≤(⌈2*Mmax/(3*(cutoff/2))⌉₊:ℝ)*(3*(cutoff/2)):=
+    (div_le_iff₀ (by positivity:0<3*(cutoff/2))).mp hceil
+  unfold rankRowCap actualDepth
+  push_cast
+  nlinarith
+
+theorem actual_rank_depth_parameters (Mmax Fmax c eps:ℝ)
+    (hM:0≤Mmax)(hF:0≤Fmax)(hc:0<c)(heps:0<eps):
+    ∃cutoff eta:ℝ,0<cutoff ∧ 0<eta ∧ eta≤1 ∧ eta≤cutoff/32 ∧
+      cutoff≤Fmax+1 ∧ cutoff≤c/200 ∧ eta≤c/100000 ∧
+      let n:=actualDepth Mmax (cutoff/2);
+      0<n ∧ Mmax≤rankRowCap n cutoff ∧
+      ∀k:ℕ,k≤n→Fmax≤rankTotalCap k (Fmax+1) eta ∧
+        c/2≤rankMargin k c eta ∧ rankMargin k c eta≤c ∧
+        0≤rankLoss k eta ∧ rankLoss k eta≤eps/4 := by
+  let csmall:=min c 1
+  have hcs:0<csmall:=lt_min hc (by norm_num)
+  have hcc:csmall≤c:=min_le_left _ _
+  have hc1:csmall≤1:=min_le_right _ _
+  obtain ⟨cutoff,eta,hcut,heta,heta1,hetacut,hcutc,hetac,hbudgets⟩:=
+    actual_recursion_parameters Mmax Fmax csmall eps hM hF hcs heps
+  dsimp only at hbudgets
+  refine ⟨cutoff,eta,hcut,heta,heta1,hetacut,by linarith,by linarith,by linarith,?_⟩
+  dsimp only
+  refine ⟨actualDepth_pos _ _,actual_rank_depth_covers Mmax cutoff hcut,?_⟩
+  intro k hk
+  have hk':(k:ℝ)≤(actualDepth Mmax (cutoff/2):ℝ):=by exact_mod_cast hk
+  have hmono:=mul_le_mul_of_nonneg_right hk' heta.le
+  have hk0:0≤(k:ℝ):=Nat.cast_nonneg _
+  have hkE:0≤(k:ℝ)*eta:=mul_nonneg hk0 heta.le
+  rcases hbudgets with ⟨hmargin,hsize,hloss⟩
+  unfold rankTotalCap rankMargin rankLoss
+  refine ⟨?_,?_,?_,?_,?_⟩ <;> nlinarith
+
+theorem actual_rank_top_parameters (Mmax Fmax c eps:ℝ)
+    (hM:0≤Mmax)(hF:0≤Fmax)(hc:0<c)(heps:0<eps):
+    ∃(n:ℕ)(cutoff eta:ℝ),n=actualDepth Mmax (cutoff/2) ∧
+      0<n ∧ 0<cutoff ∧ 0<eta ∧ eta≤1 ∧ eta≤cutoff/32 ∧
+      cutoff≤Fmax+1 ∧ cutoff≤c/200 ∧ eta≤c/100000 ∧
+      Mmax≤rankRowCap n cutoff ∧ Fmax≤rankTotalCap n (Fmax+1) eta ∧
+      c/2≤rankMargin n c eta ∧ rankMargin n c eta≤c ∧
+      0≤rankLoss n eta ∧ rankLoss n eta<eps := by
+  obtain ⟨cutoff,eta,hcut,heta,heta1,hetacut,hcutL,hcutc,hetac,hn,hrow,hall⟩:=
+    actual_rank_depth_parameters Mmax Fmax c eps hM hF hc heps
+  have htop:=hall (actualDepth Mmax (cutoff/2)) le_rfl
+  refine ⟨actualDepth Mmax (cutoff/2),cutoff,eta,rfl,hn,hcut,heta,heta1,hetacut,
+    hcutL,hcutc,hetac,hrow,htop.1,htop.2.1,htop.2.2.1,htop.2.2.2.1,?_⟩
+  linarith [htop.2.2.2.2]
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankEnergyMonotone.lean

@@ -0,0 +1,30 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalRankExistenceData
+
+namespace OAI
+
+noncomputable section
+
+open scoped Classical BigOperators SchwartzMap
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CanonicalQuadraticSieve InverseInitialClippedColumns
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem canonical_rank_loss_le {ι σ:Type}[DecidableEq ι][DecidableEq σ]
+    (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+    (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+    (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i})
+    (pool:Finset ι)(base:O→*ℂ)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+    (W:𝓢(ℝ,ℂ))(Z M F z c eps eps' A:ℝ)(K degree:ℕ)
+    (hZ:1≤Z)(hA:0≤A)(he:eps≤eps')
+    (h:CanonicalRankMoments p hp hcop hg pool base slots lists a W Z M F z c eps A K degree):
+    CanonicalRankMoments p hp hcop hg pool base slots lists a W Z M F z c eps' A K degree :=by
+  intro Ψ hΨ m hm N V Mr Q hN hV hM hQ hMc hFc hmargin hnorm ss hss labels hlabels s
+  apply (h Ψ hΨ m hm N V Mr Q hN hV hM hQ hMc hFc hmargin hnorm ss hss labels hlabels s).trans
+  apply mul_le_mul_of_nonneg_right _ (by positivity)
+  exact mul_le_mul_of_nonneg_left (Real.rpow_le_rpow_of_exponent_le hZ (by linarith)) hA
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankExistence.lean

@@ -0,0 +1,44 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalRankExistenceInduction
+import OAI.NumberTheory.DirichletL.Inversion.CanonicalReferenceThreshold
+
+namespace OAI
+
+noncomputable section
+
+open scoped Classical BigOperators SchwartzMap
+namespace SevenEighths.InverseMoment
+
+theorem actual_rank_reference_cutoffs : RankReferenceCutoffs :=by
+  intro lo hi hlo hhi
+  obtain ⟨Vlog,Alog,hA,hAe,hcompact,hsupport,hbox,hone,hzero⟩:=
+    exists_canonical_reference_cutoff lo hi
+  exact ⟨Vlog,Alog,hbox,hone⟩
+
+theorem actual_rank_reference_thresholds : RankReferenceThresholds :=by
+  intro eta heta hi Alog window
+  exact eventually_canonical_reference_gates hi Alog window eta heta
+
+theorem canonical_rank_energy_exists
+    (L cstar cutoff eta:ℝ)(K:ℕ)
+    (hL:1≤L)(hcstar:0<cstar)(hcut:0<cutoff)(hcutL:cutoff≤L)
+    (hcutc:cutoff≤cstar/200)(heta:0<eta)(heta1:eta≤1)
+    (hetac:eta≤cstar/100000)(hetad:eta≤cutoff/32)
+    (n:ℕ)(W:𝓢(ℝ,ℂ))(lo hi:ℝ)(hlo:0<lo)(hhi:0≤hi)
+    (hsW:Function.support (W:ℝ→ℂ)⊆Set.Icc lo hi):
+    RankEnergyExists n L cstar cutoff eta K W :=
+  rank_energy_exists_all_of_references actual_rank_reference_cutoffs actual_rank_reference_thresholds
+    L cstar cutoff eta K hL hcstar hcut hcutL hcutc heta heta1 hetac hetad n W lo hi hlo hhi hsW
+
+theorem canonical_marked_energy_exists
+    (Mcap Fcap c eps:ℝ)(hM:0≤Mcap)(hF:0≤Fcap)(hc:0<c)(heps:0<eps)
+    (K:ℕ)(W:𝓢(ℝ,ℂ))(lo hi:ℝ)(hlo:0<lo)(hhi:0≤hi)
+    (hsW:Function.support (W:ℝ→ℂ)⊆Set.Icc lo hi):
+    CanonicalEnergyExists Mcap Fcap c eps (Fcap+1) K W :=
+  canonical_energy_exists_of_references actual_rank_reference_cutoffs actual_rank_reference_thresholds
+    Mcap Fcap c eps hM hF hc heps K W lo hi hlo hhi hsW
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankExistenceData.lean

@@ -0,0 +1,78 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalCompleteRankNormalized
+import OAI.NumberTheory.DirichletL.Descent.CanonicalCompleteBudget
+import OAI.NumberTheory.DirichletL.Descent.CanonicalRankPuncture
+
+namespace OAI
+
+noncomputable section
+
+open scoped Classical BigOperators SchwartzMap
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge CanonicalQuadraticSieve
+open CanonicalRowCompletion InverseInitialClippedColumns InverseReflectedPhase
+local notation "O"=>ActualEisensteinCubic.O
+
+def CompletePoolRankMoments (q D:ℕ) {σ:Type}[DecidableEq σ]
+    (slots:Finset σ)
+    (lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)))
+    (a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)→ℂ)
+    (base:O→*ℂ)(W:𝓢(ℝ,ℂ))(Z Mmax Fcap z c eps A:ℝ)(K degree:ℕ):Prop :=
+  let F:=InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D;
+  let hF:=InitialMeanSquare.outsideSquarefree_admissible (reflectionExcludedPrimes q) D (reflectionExcludedPrimes_bad q);
+  letI:∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=fun i=>by rw [poolPrimary_span F hF i];infer_instance;
+  CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF)
+    (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ base slots lists a W
+    Z Mmax Fcap z c eps A K degree
+
+def rankRowCap (n:ℕ)(cutoff:ℝ):ℝ:=3*((n:ℝ)-1)*cutoff/4
+
+def rankTotalCap (n:ℕ)(L eta:ℝ):ℝ:=L-15*(n:ℝ)*eta
+
+def rankMargin (n:ℕ)(cstar eta:ℝ):ℝ:=cstar/2+7*(n:ℝ)*eta
+
+def rankLoss (n:ℕ)(eta:ℝ):ℝ:=62*(n:ℝ)*eta
+
+def RankEnergyExists (n:ℕ)(L cstar cutoff eta:ℝ)(K:ℕ)(W:𝓢(ℝ,ℂ)):Prop :=
+  ∃degree:ℕ,∃B:ℝ,1≤B ∧
+    ∀q:ℕ,q≠0→∃C Z₀:ℝ,0<C ∧ 1<Z₀ ∧
+    ∀Z:ℝ,Z₀≤Z→∀D:ℕ,B*Z^L≤D→
+    ∀{σ:Type}[DecidableEq σ](slots:Finset σ),slots.card≤K→
+    ∀(lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)))
+      (H:σ→ℝ)(a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)→ℂ),
+      (slots:Set σ).PairwiseDisjoint lists→
+      (∀i∈slots,1≤H i)→(∀i∈slots,∀P∈lists i,(Ideal.absNorm P.val:ℝ)≤H i)→
+      (∀i∈slots,∀P∈lists i,‖a i P‖≤1)→
+    ∀z:ℝ,0≤z→(∏i∈slots,H i)≤Z^z→
+    ∀base:O→*ℂ,(∀u,‖base u‖≤1)→
+      CanonicalCoefficientClass.FactorsModulo (CanonicalCoefficientClass.fixedBaseConductor q) base→
+      CompletePoolRankMoments q D slots lists a base W Z (rankRowCap n cutoff)
+        (rankTotalCap n L eta) z (rankMargin n cstar eta) (rankLoss n eta) C K degree
+
+theorem rank_energy_exists_zero (L cstar cutoff eta:ℝ)(hcut:0<cutoff)(K:ℕ)(W:𝓢(ℝ,ℂ)):
+    RankEnergyExists 0 L cstar cutoff eta K W :=by
+  refine ⟨0,1,le_rfl,?_⟩
+  intro q hq
+  refine ⟨1,2,by norm_num,by norm_num,?_⟩
+  intro Z hZ D hD σ _ slots hslots lists H a hdis hH hP ha z hz hprod base hb hp
+  dsimp only [CompletePoolRankMoments]
+  let F:=InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D
+  have hF:=InitialMeanSquare.outsideSquarefree_admissible (reflectionExcludedPrimes q) D (reflectionExcludedPrimes_bad q)
+  let:∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=fun i=>by rw [poolPrimary_span F hF i];infer_instance
+  apply canonical_rank_negative
+  simp only [rankRowCap,Nat.cast_zero]
+  linarith
+
+theorem actual_rank_successor_caps (n:ℕ)(L cstar cutoff eta M F c:ℝ)
+    (hM:M≤rankRowCap (n+1) cutoff)(hF:F≤rankTotalCap (n+1) L eta)
+    (hc:rankMargin (n+1) cstar eta≤c):
+    M-3*cutoff/4≤rankRowCap n cutoff ∧ F+15*eta≤rankTotalCap n L eta ∧
+      rankMargin n cstar eta≤c-7*eta :=by
+  unfold rankRowCap rankTotalCap rankMargin at *
+  push_cast at *
+  constructor <;> first | linarith | constructor <;> linarith
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankExistenceInduction.lean

@@ -0,0 +1,60 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalRankExistenceSuccessor
+import OAI.NumberTheory.DirichletL.Descent.CanonicalRankDepthParameters
+import OAI.NumberTheory.DirichletL.Descent.CanonicalEnergyExistenceData
+
+namespace OAI
+
+noncomputable section
+
+open scoped Classical BigOperators SchwartzMap
+namespace SevenEighths.InverseMoment
+open CanonicalCubeSeparation
+
+def RankReferenceCutoffs:Prop :=
+  ∀lo hi:ℝ,0<lo→0≤hi→∃(Vlog:𝓢(ℝ,ℂ))(Alog:ℝ),
+    (∀x,Vlog x≠0→|x|≤Alog) ∧
+    (∀x,|x|≤columnWindowRadius lo hi→Vlog x=1)
+
+def RankReferenceThresholds:Prop :=
+  ∀eta:ℝ,0<eta→∀hi Alog window:ℝ,∃Zt:ℝ,1<Zt ∧ ∀Z:ℝ,Zt≤Z→
+    2≤Z ∧ 2≤Z^eta ∧ Real.exp 1≤Z^eta ∧ 1≤eta*Real.log Z ∧
+    hi≤Z^eta ∧ Real.exp Alog≤Z^eta ∧ Real.exp window≤Z^eta
+
+theorem rank_energy_exists_all_of_references
+    (href:RankReferenceCutoffs)(hthreshold:RankReferenceThresholds)
+    (L cstar cutoff eta:ℝ)(K:ℕ)
+    (hL:1≤L)(hcstar:0<cstar)(hcut:0<cutoff)(hcutL:cutoff≤L)
+    (hcutc:cutoff≤cstar/200)(heta:0<eta)(heta1:eta≤1)
+    (hetac:eta≤cstar/100000)(hetad:eta≤cutoff/32):
+    ∀n:ℕ,∀(W:𝓢(ℝ,ℂ))(lo hi:ℝ),0<lo→0≤hi→
+      Function.support (W:ℝ→ℂ)⊆Set.Icc lo hi→RankEnergyExists n L cstar cutoff eta K W :=by
+  intro n
+  induction n with
+  | zero =>
+      intro W lo hi hlo hhi hsW
+      exact rank_energy_exists_zero L cstar cutoff eta hcut K W
+  | succ n ih =>
+      intro W lo hi hlo hhi hsW
+      obtain ⟨Vlog,Alog,hbox,hone⟩:=href lo hi hlo hhi
+      exact rank_energy_exists_succ_of_reference n L cstar cutoff eta K hL hcstar hcut hcutL
+        hcutc heta heta1 hetac hetad ih W lo hi hlo hhi hsW Vlog Alog hbox hone
+        (fun window=>hthreshold eta heta hi Alog window)
+
+theorem canonical_energy_exists_of_references
+    (href:RankReferenceCutoffs)(hthreshold:RankReferenceThresholds)
+    (Mcap Fcap c eps:ℝ)(hM:0≤Mcap)(hF:0≤Fcap)(hc:0<c)(heps:0<eps)
+    (K:ℕ)(W:𝓢(ℝ,ℂ))(lo hi:ℝ)(hlo:0<lo)(hhi:0≤hi)
+    (hsW:Function.support (W:ℝ→ℂ)⊆Set.Icc lo hi):
+    CanonicalEnergyExists Mcap Fcap c eps (Fcap+1) K W :=by
+  obtain ⟨n,cutoff,eta,hn,hpos,hcut,heta,heta1,hetad,hcutL,hcutc,hetac,hrow,hcap,hmargin0,hmargin,hloss0,hloss⟩:=
+    actual_rank_top_parameters Mcap Fcap c eps hM hF hc heps
+  have he:=rank_energy_exists_all_of_references href hthreshold (Fcap+1) c cutoff eta K
+    (by linarith) hc hcut hcutL hcutc heta heta1 hetac hetad n W lo hi hlo hhi hsW
+  exact canonical_energy_of_rank n (Fcap+1) c cutoff eta Mcap Fcap c eps K W
+    hrow hcap hmargin hloss.le he
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankExistenceSuccessor.lean

@@ -0,0 +1,186 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalRankExistenceData
+import OAI.NumberTheory.DirichletL.Descent.CanonicalRankFamilyGates
+
+namespace OAI
+
+noncomputable section
+
+open scoped Classical BigOperators SchwartzMap ContDiff
+namespace SevenEighths.InverseMoment
+open MeasureTheory ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge CanonicalQuadraticSieve
+open CanonicalRowCompletion InverseInitialClippedColumns InverseReflectedPhase InverseTerminalWidths
+open CanonicalCubeSeparation CompletedHeight InverseMomentFirstSecondHeightCost
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem rank_energy_exists_succ_of_reference
+    (n:ℕ)(L cstar cutoff eta:ℝ)(K:ℕ)
+    (hL:1≤L)(hcstar:0<cstar)(hcut:0<cutoff)(hcutL:cutoff≤L)
+    (hcutc:cutoff≤cstar/200)(heta:0<eta)(heta1:eta≤1)
+    (hetac:eta≤cstar/100000)(hetad:eta≤cutoff/32)
+    (hIH:∀(W:𝓢(ℝ,ℂ))(lo hi:ℝ),0<lo→0≤hi→
+      Function.support (W:ℝ→ℂ)⊆Set.Icc lo hi→RankEnergyExists n L cstar cutoff eta K W)
+    (W:𝓢(ℝ,ℂ))(lo hi:ℝ)(hlo:0<lo)(hhi:0≤hi)
+    (hsW:Function.support (W:ℝ→ℂ)⊆Set.Icc lo hi)
+    (Vlog:𝓢(ℝ,ℂ))(Alog:ℝ)(hbox:∀x,Vlog x≠0→|x|≤Alog)
+    (hone:∀x,|x|≤columnWindowRadius lo hi→Vlog x=1)
+    (hlarge:∀window:ℝ,∃Zt:ℝ,1<Zt ∧ ∀Z:ℝ,Zt≤Z→
+      2≤Z ∧ 2≤Z^eta ∧ Real.exp 1≤Z^eta ∧ 1≤eta*Real.log Z ∧
+      hi≤Z^eta ∧ Real.exp Alog≤Z^eta ∧ Real.exp window≤Z^eta):
+    RankEnergyExists (n+1) L cstar cutoff eta K W :=by
+  have hL0:0≤L:=by linarith
+  have heF:0<firstPassEpsilon L eta:=by unfold firstPassEpsilon;positivity
+  have hem:0<sourceMassEpsilon L eta:=by unfold sourceMassEpsilon;positivity
+  obtain ⟨w11,w12,w21,w22,af1,bf1,af2,bf2,window,bw,ds,ha1,hab1,ha2,hab2,
+    hw11,hw12,hw21,hw22,hs11,hs12,hs21,hs22,hbw,hbA,hbexp,hstep⟩:=
+    actual_complete_normalized_rank_step lo hi hlo hhi W hsW (W.smooth ⊤) Vlog Alog hbox hone
+      L cstar eta eta 1 (sourceMassEpsilon L eta) (sourceMassEpsilon L eta) eta
+      hL hcstar heta heta1 hetac heta heta1 hem hem heta K
+  obtain ⟨J11,B11,hB11,ih11⟩:=hIH w11 af1 bf1 ha1 (by linarith) (subset_closure.trans hs11)
+  obtain ⟨J12,B12,hB12,ih12⟩:=hIH w12 af1 bf1 ha1 (by linarith) (subset_closure.trans hs12)
+  obtain ⟨J21,B21,hB21,ih21⟩:=hIH w21 af2 bf2 ha2 (by linarith) (subset_closure.trans hs21)
+  obtain ⟨J22,B22,hB22,ih22⟩:=hIH w22 af2 bf2 ha2 (by linarith) (subset_closure.trans hs22)
+  let J:=J11+J12+J21+J22
+  let dl:=2*(InverseClippingProfiles.momentOrder (firstDegree J)+(volume:Measure ℝ).integrablePower)
+  let Jout:=max ds dl
+  let B:=1+hi+B11+B12+B21+B22
+  have hB:1≤B:=by dsimp [B];linarith
+  have hb0:0≤B:=by linarith
+  have hhiB:hi≤B:=by dsimp [B];linarith
+  have hBB11:B11≤B:=by dsimp [B];linarith
+  have hBB12:B12≤B:=by dsimp [B];linarith
+  have hBB21:B21≤B:=by dsimp [B];linarith
+  have hBB22:B22≤B:=by dsimp [B];linarith
+  have hj11:J11≤J:=by dsimp [J];omega
+  have hj12:J12≤J:=by dsimp [J];omega
+  have hj21:J21≤J:=by dsimp [J];omega
+  have hj22:J22≤J:=by dsimp [J];omega
+  obtain ⟨Zt,hZt,hlarge⟩:=hlarge window
+  refine ⟨Jout,B,hB,?_⟩
+  intro q hq
+  obtain ⟨C11,Z11,hC11,hZ11,ih11⟩:=ih11 q hq
+  obtain ⟨C12,Z12,hC12,hZ12,ih12⟩:=ih12 q hq
+  obtain ⟨C21,Z21,hC21,hZ21,ih21⟩:=ih21 q hq
+  obtain ⟨C22,Z22,hC22,hZ22,ih22⟩:=ih22 q hq
+  obtain ⟨Cs,Cb,Zs,hCs,hCb,hZs,hstep⟩:=hstep (firstPassEpsilon L eta) eta heF heta J q hq
+  let A:=C11+C12+C21+C22
+  have hA:0≤A:=by dsimp [A];linarith
+  have hCA11:C11≤A:=by dsimp [A];linarith
+  have hCA12:C12≤A:=by dsimp [A];linarith
+  have hCA21:C21≤A:=by dsimp [A];linarith
+  have hCA22:C22≤A:=by dsimp [A];linarith
+  let C:=(Cs+Cb)*(1+A)
+  let Z₀:=Zs+Zt+Z11+Z12+Z21+Z22
+  have hC:0<C:=by dsimp [C];positivity
+  have hZ₀:1<Z₀:=by dsimp [Z₀];linarith
+  refine ⟨C,Z₀,hC,hZ₀,?_⟩
+  intro Z hZ D hD σ _ slots hslots lists H a hdis hH hP ha z hz hprod base hbase hperiod
+  have hZs':Zs≤Z:=by dsimp [Z₀] at hZ;linarith
+  have hZt':Zt≤Z:=by dsimp [Z₀] at hZ;linarith
+  have hZ11':Z11≤Z:=by dsimp [Z₀] at hZ;linarith
+  have hZ12':Z12≤Z:=by dsimp [Z₀] at hZ;linarith
+  have hZ21':Z21≤Z:=by dsimp [Z₀] at hZ;linarith
+  have hZ22':Z22≤Z:=by dsimp [Z₀] at hZ;linarith
+  obtain ⟨hZ2,h2,hExp,hlog,hhiZ,hAZ,hwin⟩:=hlarge Z hZt'
+  have hZ1:1<Z:=by linarith
+  have hZ0:0<Z:=by linarith
+  have hD11:B11*Z^L≤D:=(mul_le_mul_of_nonneg_right hBB11 (Real.rpow_nonneg hZ0.le _)).trans hD
+  have hD12:B12*Z^L≤D:=(mul_le_mul_of_nonneg_right hBB12 (Real.rpow_nonneg hZ0.le _)).trans hD
+  have hD21:B21*Z^L≤D:=(mul_le_mul_of_nonneg_right hBB21 (Real.rpow_nonneg hZ0.le _)).trans hD
+  have hD22:B22*Z^L≤D:=(mul_le_mul_of_nonneg_right hBB22 (Real.rpow_nonneg hZ0.le _)).trans hD
+  have m11:=ih11 Z hZ11' D hD11 slots hslots lists H a hdis hH hP ha z hz hprod base hbase hperiod
+  have m12:=ih12 Z hZ12' D hD12 slots hslots lists H a hdis hH hP ha z hz hprod base hbase hperiod
+  have m21:=ih21 Z hZ21' D hD21 slots hslots lists H a hdis hH hP ha z hz hprod base hbase hperiod
+  have m22:=ih22 Z hZ22' D hD22 slots hslots lists H a hdis hH hP ha z hz hprod base hbase hperiod
+  let F:=InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D
+  have hF:=InitialMeanSquare.outsideSquarefree_admissible (reflectionExcludedPrimes q) D (reflectionExcludedPrimes_bad q)
+  let:∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=fun i=>by rw [poolPrimary_span F hF i];infer_instance
+  dsimp only [CompletePoolRankMoments] at m11 m12 m21 m22 ⊢
+  intro Ψ hΨ m hm N V M Qwidth hN hV hM hQ hMc hFc hmargin hnorm ss hss labels hlabels theta
+  have hcap:N+V≤L:=by
+    unfold rankTotalCap at hFc
+    have hh:0≤15*((n+1:ℕ):ℝ)*eta:=by positivity
+    linarith
+  have hcm:0≤rankMargin (n+1) cstar eta:=by unfold rankMargin;positivity
+  obtain ⟨hNL,hVL,hMF,hQL,hzL,hwidth,hmargin',hmL,hpuncture⟩:=
+    actual_rank_state_gates m hm Z N V M Qwidth z (rankMargin (n+1) cstar eta) L
+      hZ1 hN hV hM hQ hz hcm hcap hmargin hnorm
+  obtain ⟨hΨnorm,hΨperiod⟩:=actual_rank_family_gates q base hbase hperiod Ψ hΨ
+  have hDparent:hi*Z^N≤D:=by
+    calc
+      _≤B*Z^L:=mul_le_mul hhiB (Real.rpow_le_rpow_of_exponent_le hZ1.le hNL)
+        (Real.rpow_nonneg hZ0.le _) hb0
+      _≤D:=hD
+  have hsscard:ss.card≤K:=(Finset.card_le_card hss).trans hslots
+  have hssdis:(ss:Set σ).PairwiseDisjoint lists:=by
+    intro i hi j hj hij
+    exact hdis (hss hi) (hss hj) hij
+  have hssH:∀i∈ss,1≤H i:=fun i hi=>hH i (hss hi)
+  have hssP:∀i∈ss,∀P∈lists i,(Ideal.absNorm P.val:ℝ)≤H i:=fun i hi=>hP i (hss hi)
+  have hssa:∀i∈ss,∀P∈lists i,‖a i P‖≤1:=fun i hi=>ha i (hss hi)
+  have hssprod:(∏i∈ss,H i)≤Z^z:=canonical_rank_subslot_cap slots ss H Z z hss hH hprod
+  obtain ⟨hsmallM,hsmallF,hsmallc⟩:=actual_rank_successor_caps n L cstar cutoff eta M (N+V)
+    (rankMargin (n+1) cstar eta) hMc hFc le_rfl
+  have lift (w:𝓢(ℝ,ℂ))(Cw:ℝ)(Jw:ℕ)(hCw:0≤Cw)(hCwA:Cw≤A)(hJw:Jw≤J)
+      (mw:CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+        (poolPrimary_good F hF) Finset.univ base slots lists a w Z (rankRowCap n cutoff)
+        (rankTotalCap n L eta) z (rankMargin n cstar eta) (rankLoss n eta) Cw K Jw):
+      CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+        (poolPrimary_good F hF) Finset.univ base ss lists a w Z (M-3*(cutoff/2)/2)
+        (N+V+15*eta) z (rankMargin (n+1) cstar eta-7*eta) (rankLoss n eta) A K J:=by
+    apply canonical_rank_subslots (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+      (poolPrimary_good F hF) Finset.univ base slots ss lists a w Z _ _ z _ _ A K J hss
+    apply canonical_rank_restrict (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+      (poolPrimary_good F hF) Finset.univ base slots lists a w Z
+      (M-3*(cutoff/2)/2) (rankRowCap n cutoff) (N+V+15*eta) (rankTotalCap n L eta)
+      z (rankMargin (n+1) cstar eta-7*eta) (rankMargin n cstar eta) (rankLoss n eta) A K J
+      (by linarith) hsmallF hsmallc
+    exact canonical_rank_height_constant (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF)
+      (poolPrimary_good F hF) Finset.univ base slots lists a w Z _ _ z _ _ Cw A K Jw J
+      hZ0 hCw hCwA hJw mw
+  have hechild:0≤rankLoss n eta:=by unfold rankLoss;positivity
+  obtain ⟨_,_,hpieta,hmass,hret,hprincipal0,hcost⟩:=actual_step_parameters L eta 0 0 (rankLoss n eta)
+    hL0 heta heta1 (by linarith) (by linarith) hechild
+  obtain ⟨hprincipal,hFirst,hFinal⟩:=actual_complete_step_cost L eta (rankLoss n eta) hL0 heta heta1 hechild
+  have hreserve:cstar/2≤rankMargin (n+1) cstar eta:=by
+    unfold rankMargin
+    exact le_add_of_nonneg_right (by positivity)
+  have hbound:=hstep m hm Z N V M z (rankMargin (n+1) cstar eta) cutoff (8*eta)
+    (rankLoss n eta) A (rankLoss n eta+58*eta) (rankLoss n eta+60*eta) theta
+    hZs' hZ2 h2 hExp hlog hN hV hM hcap hMF hzL hhiZ hAZ hwin hcut hcutL hcutc hetad hmL hmargin'
+    hreserve (by simpa only [hwidth] using hpuncture) (by positivity) hpieta hmass hmass hechild
+    (by linarith) hret hprincipal hcost (by linarith) hA
+    labels (fun I hI=>⟨⟨(hlabels I hI).1.1,(hlabels I hI).1.2.2⟩,(hlabels I hI).1.2.1,(hlabels I hI).2⟩)
+    D hDparent ss hsscard lists H hssdis hssH hssP hssprod base Ψ hΨ hΨnorm hΨperiod a hssa
+    (lift w11 C11 J11 hC11.le hCA11 hj11 m11) (lift w12 C12 J12 hC12.le hCA12 hj12 m12)
+    (lift w21 C21 J21 hC21.le hCA21 hj21 m21) (lift w22 C22 J22 hC22.le hCA22 hj22 m22)
+  have hnextLoss:rankLoss n eta+62*eta=rankLoss (n+1) eta:=by unfold rankLoss;push_cast;ring
+  have hlongexp:(rankLoss n eta+60*eta)+2*L*firstPassEpsilon L eta+eta≤rankLoss (n+1) eta:=by
+    simpa only [hnextLoss] using hFinal
+  have hloss0:0≤rankLoss (n+1) eta:=by unfold rankLoss;positivity
+  have hlong:Cb*(1+A)*(1+‖theta‖)^dl*
+      Z^(N+V+(rankLoss n eta+60*eta)+2*L*firstPassEpsilon L eta+eta)≤
+      Cb*(1+A)*(1+‖theta‖)^dl*Z^(N+V+rankLoss (n+1) eta):=by
+    apply mul_le_mul_of_nonneg_left _ (by positivity)
+    apply Real.rpow_le_rpow_of_exponent_le hZ1.le
+    linarith
+  have hh:=hbound.trans (add_le_add le_rfl hlong)
+  have hmrg:=actual_complete_height_merge ds dl Z (N+V) cstar (rankLoss (n+1) eta) Cs Cb A theta
+    hZ1.le hcstar.le hloss0 hCs.le hCb hA
+  have hpow:(1+‖theta‖)^Jout≤(1+‖theta‖)^(2*Jout):=
+    pow_le_pow_right₀ (by linarith [norm_nonneg theta]) (by omega)
+  have hf:childLogTest W theta=normTwistedSource W theta:=by
+    funext y
+    simp only [childLogTest,normTwistedSource,mul_comm]
+  rw [hf]
+  apply (hh.trans hmrg).trans
+  dsimp only [C,Jout]
+  have hx:=mul_le_mul_of_nonneg_right
+    (mul_le_mul_of_nonneg_left hpow (show 0≤(Cs+Cb)*(1+A) by positivity))
+    (Real.rpow_nonneg hZ0.le (N+V+rankLoss (n+1) eta))
+  convert hx using 1 ; ring
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankFamilyGates.lean

@@ -0,0 +1,89 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalRankPuncture
+import OAI.NumberTheory.DirichletL.Descent.CanonicalRankMonotone
+
+namespace OAI
+
+noncomputable section
+
+open scoped Classical BigOperators SchwartzMap
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CanonicalCoefficientClass InverseTerminalWidths
+open ConcretePrimeRowBridge CompletedGauss
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem actual_rank_family_period (q:ℕ)(base Ψ:O→*ℂ)
+    (hbase:FactorsModulo (fixedBaseConductor q) base)
+    (hΨ:IsBaseRayTwist base Ψ):
+    FactorsModulo (fixedBaseConductor q) Ψ := by
+  intro x y hxy
+  rcases hΨ with rfl|⟨χ,rfl⟩
+  · exact hbase x y hxy
+  · simp only [MonoidHom.mul_apply]
+    rw [hbase x y hxy]
+    congr 1
+    exact RayFourExpansion.rayCharacter_eq_of_mod_four χ x y
+      (Ideal.mem_span_singleton.mp (Ideal.mul_le_right hxy))
+
+theorem actual_rank_family_gates (q:ℕ)(base:O→*ℂ)
+    (hbase:∀x,‖base x‖≤1)(hperiod:FactorsModulo (fixedBaseConductor q) base):
+    ∀Ψ:O→*ℂ,IsBaseRayTwist base Ψ→
+      (∀x,‖Ψ x‖≤1) ∧ FactorsModulo (fixedBaseConductor q) Ψ := by
+  intro Ψ hΨ
+  exact ⟨hΨ.norm_le hbase,actual_rank_family_period q base Ψ hperiod hΨ⟩
+
+theorem actual_rank_norm_width (m:O)(Z Q:ℝ)(hZ:1<Z)
+    (hn:‖ConcreteTraceCRT.eisEmbedding m‖^2=Z^Q):
+    normWidth Z (Ideal.span {m})=Q := by
+  rw [eisEmbedding_norm_sq_eq_absNorm_span] at hn
+  rw [normWidth,hn,Real.logb_rpow (zero_lt_one.trans hZ) (ne_of_gt hZ)]
+
+theorem actual_rank_state_gates (m:O)(hm:m≠0)(Z N V M Q z c L:ℝ)
+    (hZ:1<Z)(hN:0≤N)(hV:0≤V)(hM:0≤M)(hQ:0≤Q)(hz:0≤z)(hc:0≤c)
+    (hcap:N+V≤L)(hmargin:CanonicalMargins (N+V) M Q z c)
+    (hn:‖ConcreteTraceCRT.eisEmbedding m‖^2=Z^Q):
+    N≤L ∧ V≤L ∧ M≤N+V ∧ Q≤L ∧ z≤L ∧
+      normWidth Z (Ideal.span {m})=Q ∧
+      CanonicalMargins (N+V) M (normWidth Z (Ideal.span {m})) z c ∧
+      (Ideal.absNorm (Ideal.span {m}:Ideal O):ℝ)≤Z^L ∧
+      (Ideal.absNorm (Ideal.span {m}:Ideal O).radical:ℝ)≤Z^Q := by
+  have hfirst:=hmargin.1
+  have hQcap:Q≤L:=by linarith
+  have he:=actual_rank_norm_width m Z Q hZ hn
+  refine ⟨by linarith,by linarith,by linarith,hQcap,by linarith,he,?_,?_,?_⟩
+  · rwa [he]
+  · rw [eisEmbedding_norm_sq_eq_absNorm_span] at hn
+    rw [hn]
+    exact Real.rpow_le_rpow_of_exponent_le hZ.le hQcap
+  · simpa only [he] using actual_rank_parent_puncture m hm Z hZ
+
+theorem canonical_rank_subslots {ι σ:Type}[DecidableEq ι][DecidableEq σ]
+    (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+    (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+    (hg:∀i,goodLambda∉Ideal.span {p i})
+    (pool:Finset ι)(base:O→*ℂ)(slots subslots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+    (W:𝓢(ℝ,ℂ))(Z M F z c eps A:ℝ)(K degree:ℕ)(hsub:subslots⊆slots)
+    (h:CanonicalRankMoments p hp hcop hg pool base slots lists a W Z M F z c eps A K degree):
+    CanonicalRankMoments p hp hcop hg pool base subslots lists a W Z M F z c eps A K degree := by
+  intro Ψ hΨ m hm N V Mr Qwidth hN hV hM hQ hMc hFc hmargin hnorm ss hss labels hlabels s
+  exact h Ψ hΨ m hm N V Mr Qwidth hN hV hM hQ hMc hFc hmargin hnorm ss
+    (hss.trans hsub) labels hlabels s
+
+theorem canonical_rank_subslot_product {σ:Type*}[DecidableEq σ]
+    (slots subslots:Finset σ)(H:σ→ℝ)(hsub:subslots⊆slots)
+    (hH:∀i∈slots,1≤H i):
+    (∏i∈subslots,H i)≤∏i∈slots,H i :=
+  Finset.prod_le_prod_of_subset_of_one_le₀ hsub
+    (fun i hi=>(zero_le_one: (0:ℝ)≤1).trans (hH i (hsub hi)))
+    (fun i hi _=>hH i hi)
+
+theorem canonical_rank_subslot_cap {σ:Type*}[DecidableEq σ]
+    (slots subslots:Finset σ)(H:σ→ℝ)(Z z:ℝ)(hsub:subslots⊆slots)
+    (hH:∀i∈slots,1≤H i)(hcap:(∏i∈slots,H i)≤Z^z):
+    (∏i∈subslots,H i)≤Z^z :=
+  (canonical_rank_subslot_product slots subslots H hsub hH).trans hcap
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankMoments.lean

@@ -0,0 +1,88 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalChildSupport
+import OAI.NumberTheory.DirichletL.Descent.FirstLabelCellStep
+
+namespace OAI
+
+noncomputable section
+open scoped Classical BigOperators SchwartzMap
+
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CanonicalQuadraticSieve
+open InverseInitialClippedColumns InverseSecondFibers InverseSecondSourceBlocks
+open CanonicalCoefficientClass InverseMomentFirstLabelCell InverseMomentFirstChildWindows InverseFirstGlobalCaps
+local notation "O"=>ActualEisensteinCubic.O
+variable {ι σ:Type}[DecidableEq ι][DecidableEq σ]
+variable (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+variable (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+variable (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i})
+
+def CanonicalRankMoments (pool:Finset ι)(base:O→*ℂ)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+    (W:𝓢(ℝ,ℂ))(Z Mmax Fcap z c eps A:ℝ)(K degree:ℕ):Prop :=
+  ∀(Ψ:O→*ℂ),IsBaseRayTwist base Ψ→∀(m:O),m≠0→∀N V M Qwidth:ℝ,
+    0≤N→0≤V→0≤M→0≤Qwidth→M≤Mmax→N+V≤Fcap→
+    CanonicalMargins (N+V) M Qwidth z c→
+    ‖ConcreteTraceCRT.eisEmbedding m‖^2=Z^Qwidth→
+    ∀(subslots:Finset σ),subslots⊆slots→∀labels:Finset (Ideal O),
+      (∀I∈labels,Admissible I ∧ (Ideal.absNorm I:ℝ)≤Z^V)→∀s:ℝ,
+    normalizedColumnEnergy p hp hcop hg pool Ψ m subslots lists a labels
+      (nonzeroChildFrequencyBall 1 (Z^M)) (secondLabelWeight K) (childLogTest W s) (Z^N) Z (N+V)≤
+      A*Z^(N+V+eps)*(1+‖s‖)^(2*degree)
+
+include hp in
+theorem canonical_rank_moments_children
+    (hc:∀i,ringChar (O⧸Ideal.span {p i})≠2)
+    (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1)
+    (pool:Finset ι)(Q:Finset (ι→₀ℕ))(k:SourceIndex)(l j:ℕ)(negative:Bool)
+    (base Ψ:O→*ℂ)(hΨ:IsBaseRayTwist base Ψ)(m:O)(hm:m≠0)
+    (slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)(ω₁ ω₂:𝓢(ℝ,ℂ))
+    (Z M r ell V eta tau window b cutoff Qwidth z c eps A:ℝ)(K degree:ℕ)
+    (hZ:1<Z)(heta:0≤eta)(hbin:2≤Z^eta)(hell:0≤ell)(hV:0≤V)
+    (hb:1≤b)(hbt:b≤Z^(6*eta))(hwindow:Real.exp window≤Z^(4*eta))
+    (_hd:0<cutoff)(hterminal:cutoff≤ell+V)(hsmall:eta≤cutoff/16)
+    (hparent:CanonicalMargins (r+3*ell+V) M Qwidth z c)
+    (hpuncture:(Ideal.absNorm (Ideal.span {m}:Ideal O).radical:ℝ)≤Z^Qwidth)
+    (hQ:∀v∈Q,‖ConcreteTraceCRT.eisEmbedding (primeProduct p v.support v)‖^2≤Z^(ell+eta))
+    (h₁:CanonicalRankMoments p hp hcop hg pool base slots lists a ω₁ Z (M-3*cutoff/2) (r+3*ell+V+15*eta) z (c-7*eta) eps A K degree)
+    (h₂:CanonicalRankMoments p hp hcop hg pool base slots lists a ω₂ Z (M-3*cutoff/2) (r+3*ell+V+15*eta) z (c-7*eta) eps A K degree):
+    ChildBounds p hp hcop hg pool Q k l j negative Ψ m slots lists a ω₁ ω₂
+      Z M r ell V eta tau window b eps A K degree :=by
+  intro ray core assigned hass
+  let S:=source p pool Q k l j negative assigned lists Z M r ell V eta tau window b
+  let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core
+  have hbase:IsBaseRayTwist base Ψ₀:=hΨ.firstCore _ _ _
+  have hstate:=source_state_bounds p hp pool Q k l j negative assigned lists Z M r ell V eta tau window b cutoff
+    hZ heta hbin hell hV hb hbt hwindow hterminal hsmall hQ
+  have hmargin:=source_child_margins p hp hpr pool Q k l j negative assigned lists Z M r ell V eta tau window b
+    m hm Qwidth z c hZ heta hbin hV hparent hpuncture hQ
+  have hlabels:=source_labels p hp pool Q k l j negative assigned lists Z M r ell V eta tau window b hZ heta hbin hQ
+  constructor
+  · intro zz d hdcell s J hJ γ hγ
+    have st:=hstate d hdcell
+    have mg:=hmargin d γ hγ
+    apply h₁ (secondRayMinus Ψ₀ zz) (hbase.secondMinus zz) (actualSecondInheritedRadicalPuncture m γ) mg.1
+      (max 0 (secondCellColumnExponent Z (columnScale Z r k l negative) d))
+      (actualCellLabelExponent Z (exponent Z (k 2)) (exponent Z j) eta d)
+      (actualCellRowExponent Z M ell (columnA Z k negative) (exponent Z l) V (exponent Z j) eta d)
+      (actualSecondPunctureWidth Z m γ) st.1 st.2.1 st.2.2.2.1 mg.2.1 (by linarith [st.2.2.2.2]) st.2.2.1 mg.2.2.2 mg.2.2.1
+      ((slots\assigned)\J) (Finset.sdiff_subset.trans Finset.sdiff_subset)
+      ((actualCellLabels p S d).filter Squarefree) ?_ s
+    intro I hI
+    exact ⟨actual_cell_labels_admissible p hp hg hc S d I hI,(hlabels.2 d I hI).2.2⟩
+  · intro zz d hdcell s J hJ γ hγ
+    have st:=hstate d hdcell
+    have mg:=hmargin d γ hγ
+    apply h₂ (secondRayPlus Ψ₀ zz) (hbase.secondPlus zz) (actualSecondInheritedRadicalPuncture m γ) mg.1
+      (max 0 (secondCellColumnExponent Z (columnScale Z r k l negative) d))
+      (actualCellLabelExponent Z (exponent Z (k 2)) (exponent Z j) eta d)
+      (actualCellRowExponent Z M ell (columnA Z k negative) (exponent Z l) V (exponent Z j) eta d)
+      (actualSecondPunctureWidth Z m γ) st.1 st.2.1 st.2.2.2.1 mg.2.1 (by linarith [st.2.2.2.2]) st.2.2.1 mg.2.2.2 mg.2.2.1
+      ((slots\assigned)\J) (Finset.sdiff_subset.trans Finset.sdiff_subset)
+      ((actualCellLabels p S d).filter Squarefree) ?_ s
+    intro I hI
+    exact ⟨actual_cell_labels_admissible p hp hg hc S d I hI,(hlabels.2 d I hI).2.2⟩
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankMonotone.lean

@@ -0,0 +1,55 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalRankMoments
+
+namespace OAI
+
+noncomputable section
+open scoped Classical BigOperators SchwartzMap
+
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic CanonicalQuadraticSieve InverseInitialClippedColumns
+local notation "O"=>ActualEisensteinCubic.O
+variable {ι σ:Type}[DecidableEq ι][DecidableEq σ]
+variable (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+variable (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+variable (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i})
+
+omit [DecidableEq σ] in
+theorem canonical_rank_negative (pool:Finset ι)(base:O→*ℂ)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+    (W:𝓢(ℝ,ℂ))(Z Mmax Fcap z c eps A:ℝ)(K degree:ℕ)(hM:Mmax<0):
+    CanonicalRankMoments p hp hcop hg pool base slots lists a W Z Mmax Fcap z c eps A K degree :=by
+  intro Ψ hΨ m hm N V M Qwidth hN hV hM0 hQ hMc
+  exfalso
+  linarith
+
+omit [DecidableEq σ] in
+theorem canonical_rank_restrict (pool:Finset ι)(base:O→*ℂ)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+    (W:𝓢(ℝ,ℂ))(Z M₁ M₂ F₁ F₂ z c₁ c₂ eps A:ℝ)(K degree:ℕ)
+    (hM:M₁≤M₂)(hF:F₁≤F₂)(hc:c₂≤c₁)
+    (h:CanonicalRankMoments p hp hcop hg pool base slots lists a W Z M₂ F₂ z c₂ eps A K degree):
+    CanonicalRankMoments p hp hcop hg pool base slots lists a W Z M₁ F₁ z c₁ eps A K degree :=by
+  intro Ψ hΨ m hm N V M Qwidth hN hV hM0 hQ hMc hFc hmargin hnorm ss hss labels hlabels s
+  have hmarg:CanonicalMargins (N+V) M Qwidth z c₂:=by
+    unfold CanonicalMargins at *
+    constructor <;> linarith [hmargin.1,hmargin.2]
+  exact h Ψ hΨ m hm N V M Qwidth hN hV hM0 hQ (hMc.trans hM) (hFc.trans hF) hmarg hnorm ss hss labels hlabels s
+
+omit [DecidableEq σ] in
+theorem canonical_rank_height_constant (pool:Finset ι)(base:O→*ℂ)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+    (W:𝓢(ℝ,ℂ))(Z M F z c eps A B:ℝ)(K degree J:ℕ)
+    (hZ:0<Z)(hA:0≤A)(hAB:A≤B)(hJ:degree≤J)
+    (h:CanonicalRankMoments p hp hcop hg pool base slots lists a W Z M F z c eps A K degree):
+    CanonicalRankMoments p hp hcop hg pool base slots lists a W Z M F z c eps B K J :=by
+  intro Ψ hΨ m hm N V Mr Qwidth hN hV hM0 hQ hMc hFc hmargin hnorm ss hss labels hlabels s
+  apply (h Ψ hΨ m hm N V Mr Qwidth hN hV hM0 hQ hMc hFc hmargin hnorm ss hss labels hlabels s).trans
+  have hB:0≤B:=hA.trans hAB
+  apply mul_le_mul
+  · exact mul_le_mul_of_nonneg_right hAB (Real.rpow_nonneg hZ.le _)
+  · exact pow_le_pow_right₀ (by linarith [norm_nonneg s]) (Nat.mul_le_mul_left 2 hJ)
+  · positivity
+  · positivity
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankPuncture.lean

@@ -0,0 +1,26 @@
+import OAI.NumberTheory.DirichletL.Descent.CanonicalCompleteRankNormalized
+
+namespace OAI
+
+noncomputable section
+
+namespace SevenEighths.InverseMoment
+open ActualEisensteinCubic InverseTerminalWidths
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem actual_rank_parent_puncture (m:O)(hm:m≠0)(Z:ℝ)(hZ:1<Z):
+    (Ideal.absNorm (Ideal.span {m}:Ideal O).radical:ℝ)≤Z^(normWidth Z (Ideal.span {m})) :=by
+  have hi:(Ideal.span {m}:Ideal O)≠0:=Ideal.span_singleton_eq_bot.not.mpr hm
+  have hn:0<(Ideal.absNorm (Ideal.span {m}:Ideal O):ℝ):=actual_ideal_norm_pos _ hi
+  have hle:Ideal.absNorm (Ideal.span {m}:Ideal O).radical≤Ideal.absNorm (Ideal.span {m}:Ideal O):=
+    Nat.le_of_dvd (Nat.pos_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr hi))
+      (Ideal.absNorm_dvd_absNorm_of_le Ideal.le_radical)
+  unfold normWidth
+  rw [Real.rpow_logb (by linarith:0<Z) (ne_of_gt hZ) hn]
+  exact_mod_cast hle
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalReopeningHeight.lean

@@ -0,0 +1,51 @@
+import OAI.NumberTheory.DirichletL.Descent.DescentHeight
+import OAI.NumberTheory.DirichletL.Descent.CanonicalLongSource
+
+namespace OAI
+
+noncomputable section
+open scoped Classical BigOperators SchwartzMap FourierTransform ContDiff
+
+namespace SevenEighths.InverseMoment
+open MeasureTheory CanonicalCubeSeparation FourierBridge JointLogSeparation CompletedHeight
+
+theorem reopening_coefficient_twist (W:ℝ→ℂ)(a b:ℝ)(ha:0<a)
+    (hs:Function.support W⊆Set.Icc a b)(hW:ContDiff ℝ ∞ W)(theta:ℝ)
+    (hT:ContDiff ℝ ∞ (normTwistedSource W theta)):
+    reopeningCoefficient (normTwistedSource W theta) a b ha
+      ((normTwistedSource_support W theta).trans hs) hT=
+      𝓕 (frequencyTwist (sourceLogProfile W a b ha hs hW) theta) :=by
+  unfold reopeningCoefficient
+  congr 1
+  ext x
+  simp only [sourceLogProfile_apply,frequencyTwist_apply,normTwistedSource,Real.log_exp]
+
+theorem reopening_twisted_moment (W:ℝ→ℂ)(a b:ℝ)(ha:0<a)
+    (hs:Function.support W⊆Set.Icc a b)(hW:ContDiff ℝ ∞ W)(J:ℕ):
+    ∃C:ℝ,0≤C ∧ ∀theta:ℝ,∀hT:ContDiff ℝ ∞ (normTwistedSource W theta),
+      (∫ξ:ℝ,‖reopeningCoefficient (normTwistedSource W theta) a b ha
+        ((normTwistedSource_support W theta).trans hs) hT ξ‖*(1+|ξ|)^J)≤
+      C*(1+‖theta‖)^(J+(volume:Measure ℝ).integrablePower) :=by
+  obtain ⟨C,hC,he⟩:=frequencyTwist_fourier_moment J (sourceLogProfile W a b ha hs hW)
+  refine ⟨C,hC,?_⟩
+  intro theta hT
+  rw [reopening_coefficient_twist W a b ha hs hW theta hT]
+  simpa only [Real.norm_eq_abs,mul_comm] using he theta
+
+theorem reopening_twisted_moment_squared (W:ℝ→ℂ)(a b:ℝ)(ha:0<a)
+    (hs:Function.support W⊆Set.Icc a b)(hW:ContDiff ℝ ∞ W)(J:ℕ):
+    ∃C:ℝ,0≤C ∧ ∀theta:ℝ,∀hT:ContDiff ℝ ∞ (normTwistedSource W theta),
+      (∫ξ:ℝ,‖reopeningCoefficient (normTwistedSource W theta) a b ha
+        ((normTwistedSource_support W theta).trans hs) hT ξ‖*(1+|ξ|)^J)^2≤
+      C*(1+‖theta‖)^(2*(J+(volume:Measure ℝ).integrablePower)) :=by
+  obtain ⟨C,hC,he⟩:=reopening_twisted_moment W a b ha hs hW J
+  refine ⟨C^2,sq_nonneg _,?_⟩
+  intro theta hT
+  have hh:=pow_le_pow_left₀ (integral_nonneg (fun ξ=>by positivity)) (he theta hT) 2
+  simpa only [mul_pow,←pow_mul,Nat.mul_comm] using hh
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/CanonicalShortFinite.lean

@@ -0,0 +1,108 @@
+import OAI.NumberTheory.DirichletL.Inversion.CanonicalShortAttachment
+import OAI.NumberTheory.DirichletL.Inversion.ReflectedShortNormalizedUniformDegree
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Classical ContDiff
+namespace SevenEighths.InverseCanonicalShortAttachment
+open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge
+open CanonicalQuadraticSieve InverseMoment InverseReflectedPhase InverseTerminalWidths CompletedHeight
+local notation "Eis"=>ActualEisensteinCubic.O
+universe u v
+theorem actual_complete_short_finite_uniform_degree
+    (lo hi : ℝ) (hlo : 0<lo) (W : ℝ→ℂ)
+    (hWs : Function.support W⊆Set.Icc lo hi) (hW : ContDiff ℝ ∞ W)
+    (L cstar eta : ℝ) (hL : 0≤L) (hcstar : 0<cstar) (heta : 0<eta)
+    (heta1 : eta≤1) (hetac : eta≤cstar/100000) (rmax K : ℕ) :
+    ∃ (degree : ℕ), ∀ (q:ℕ)(_hq:q≠0), ∃ (C Z₀ : ℝ),0<C ∧ 1<Z₀ ∧
+    ∀ {σ : Type v} [DecidableEq σ],
+    ∀ (m : Eis),m≠0 → ∀ (Z N V M z₀ margin hcut d : ℝ),
+      Z₀≤Z → 0≤N → 0≤V → 0≤M → M≤L → V≤L → z₀≤L → 0≤hcut → hcut≤L →
+      (Ideal.absNorm (Ideal.span {m}):ℝ)≤Z^L →
+      CanonicalMargins (N+V) M (normWidth Z (Ideal.span {m})) z₀ margin → cstar/2≤margin →
+      V≤d → hcut≤d+eta → d≤cstar/200 →
+    ∀ (labels : Finset (Ideal Eis)),
+      (∀f∈labels,Supported f ∧ Squarefree f ∧ (Ideal.absNorm f:ℝ)≤Z^V) →
+    ∀ (T : Finset Eis),(∀k∈T,k≠0 ∧ (Ideal.absNorm (Ideal.span {k}):ℝ)≤Z^M) →
+    ∀ D : ℕ,hi*Z^N≤D → ∀ slots : Finset σ,slots.card≤rmax →
+    ∀ (lists : σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)))
+      (H : σ→ℝ),
+      (slots:Set σ).Pairwise (fun j k=>Disjoint (lists j) (lists k)) →
+      (∀j∈slots,1≤H j) → (∀j∈slots,∀i∈lists j,(Ideal.absNorm i.val:ℝ)≤H j) →
+      (∏j∈slots,H j)≤Z^z₀ →
+    ∀ (Ψ : Eis→*ℂ),(∀n,‖Ψ n‖≤1) →
+      CanonicalCoefficientClass.FactorsModulo (CanonicalCoefficientClass.fixedBaseConductor q) Ψ →
+    ∀ (θ : ℝ)
+      (a : σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)→ℂ),
+      (∀j∈slots,∀i∈lists j,‖a j i‖≤1) →
+      let S:=reflectionExcludedPrimes q
+      let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+      let mark:=indexedIdealMark (fun i:primePool F=>i.val) slots lists a
+      Z^(-V)*(∑f∈labels,secondLabelWeight K f*∑k∈T,
+        ‖markedShortCompletedSum (rowTwist Ψ (m*excludedGenerator S) (idealGenerator f) k)
+          (normTwistedSource W θ) (Z^N) (Z^hcut) mark‖^2)≤
+        C*(1+‖θ‖)^degree*Z^(N+V-cstar/256) := by
+  obtain ⟨degree,hu⟩:=InverseShortCanonicalNormalization.canonical_short_normalized_energy_uniform_degree
+    lo hi hlo W hWs hW L cstar eta hL hcstar heta heta1 hetac rmax K
+  refine ⟨degree,?_⟩
+  intro q hq
+  obtain ⟨C,Z₀,hC,hZ₀,he⟩:=hu q hq
+  refine ⟨C,Z₀,hC,hZ₀,?_⟩
+  intro σ _ m hm Z N V M z₀ margin hcut d hZ hN hV hM hMc hVc hzc hcut0 hcutc
+    hRn hmargin hreserve hVd hcutd hd labels hlabels T hT D hD slots hcard lists H hdis hH1 hH hprod
+    Ψ hΨ hperiod θ a ha
+  dsimp only
+  let S:=reflectionExcludedPrimes q
+  let F:=InitialMeanSquare.outsideSquarefreeIdeals S D
+  have hF : ∀I∈F,Admissible I:=InitialMeanSquare.outsideSquarefree_admissible S D (reflectionExcludedPrimes_bad q)
+  let ilists:slots→Finset (Ideal Eis):=fun j=>idealLists F lists j.val
+  let iw:∀j,ilists j→ℂ:=fun j=>idealWeights F lists a j.val
+  have hp (j:slots) (P:Ideal Eis) (hP:P∈ilists j) := idealLists_prime_data F hF lists j.val P hP
+  have hcap : ∀j:slots,∀P∈ilists j,(Ideal.absNorm P:ℝ)≤H j.val := by
+    intro j P hP
+    obtain ⟨i,hi,rfl⟩:=Finset.mem_image.mp hP
+    exact hH j.val j.property i hi
+  have hw : ∀j:slots,∀P:ilists j,‖iw j P‖≤1 := by
+    intro j P
+    obtain ⟨i,hi,hh⟩:=Finset.mem_image.mp P.property
+    change ‖transportCoeff F a j.val P.val‖≤1
+    rw [←hh,transportCoeff_val]
+    exact ha j.val j.property i hi
+  have henergy:=he (σ:=slots) m hm Z N V M z₀ margin hcut d hZ hN hV hM hMc hVc hzc hcut0 hcutc
+    hRn hmargin hreserve hVd hcutd hd labels (fun f hf=>(hlabels f hf).2) T hT (by simpa using hcard)
+    ilists (fun j:slots=>H j.val) (idealLists_disjoint F slots lists hdis)
+    (fun j P hP=>(hp j P hP).1) (fun j P hP=>(hp j P hP).2.1)
+    (fun j P hP=>(hp j P hP).2.2.1) (fun j P hP=>(hp j P hP).2.2.2)
+    (fun j=>hH1 j.val j.property) hcap (by simpa only [Finset.prod_coe_sort] using hprod)
+    Ψ hΨ hperiod θ iw hw
+  have hz:0<Z:=zero_lt_one.trans (lt_of_lt_of_le hZ₀ hZ)
+  have hn:‖((Z^(-(N+V)/2):ℝ):ℂ)*((Real.sqrt (Z^N):ℝ):ℂ)‖^2=Z^(-V) := by
+    rw [norm_mul,mul_pow,Complex.norm_real,Real.norm_eq_abs,
+      abs_of_pos (Real.rpow_pos_of_pos hz _),Complex.norm_real,Real.norm_eq_abs,
+      abs_of_nonneg (Real.sqrt_nonneg _),Real.sq_sqrt (Real.rpow_nonneg hz.le _),
+      ←Real.rpow_mul_natCast hz.le,←Real.rpow_add hz]
+    congr 1
+    ring
+  have hmark:indexedIdealMark (fun i:primePool F=>i.val) slots lists a=tupleDivisibilityMark ilists iw:=
+    funext (indexed_mark_eq_tuple F slots lists a)
+  rw [hmark]
+  change Z^(-V)*(∑f∈labels,secondLabelWeight K f*∑k∈T,
+    ‖markedShortCompletedSum (rowTwist Ψ (ActualFiber.maskElement q m) (idealGenerator f) k)
+      (normTwistedSource W θ) (Z^N) (Z^hcut) (tupleDivisibilityMark ilists iw)‖^2)≤_
+  simp only [norm_mul,mul_pow] at henergy
+  have hn':‖((Z^(-(N+V)/2):ℝ):ℂ)‖^2*‖((Real.sqrt (Z^N):ℝ):ℂ)‖^2=Z^(-V):=by
+    simpa only [norm_mul,mul_pow] using hn
+  simp only [←mul_assoc,hn',←Finset.mul_sum] at henergy
+  convert henergy using 1
+  rw [Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intros
+  ring
+
+end SevenEighths.InverseCanonicalShortAttachment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/ChildCutoff.lean

@@ -0,0 +1,165 @@
+import OAI.NumberTheory.DirichletL.Descent.PoissonTails
+
+namespace OAI
+
+namespace SevenEighths.InverseMoment
+open scoped BigOperators Classical SchwartzMap
+open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic
+open ConcreteTraceCRT (eisEmbedding)
+noncomputable section
+local notation "Eis" => ActualEisensteinCubic.O
+
+def childFrequencyBall (a : Eis) (R : ℝ) : Finset Eis :=
+  (secondFrequencyCutoff (‖eisEmbedding a‖^2) R).filter
+    (fun k => ‖eisEmbedding (a*k)‖^2 ≤ R)
+
+lemma mem_childFrequencyBall (a : Eis) (ha : a ≠ 0) (R : ℝ) (k : Eis) :
+    k ∈ childFrequencyBall a R ↔ ‖eisEmbedding (a*k)‖^2 ≤ R := by
+  have hn : 0 < ‖eisEmbedding a‖^2 := sq_pos_of_pos
+    (norm_pos_iff.mpr (ConcreteTraceCRT.eisEmbedding_ne_zero ha))
+  simp only [childFrequencyBall, Finset.mem_filter]
+  refine ⟨fun h => h.2, fun h => ⟨?_,h⟩⟩
+  apply mem_secondFrequencyCutoff
+  apply (le_div_iff₀ hn).mpr
+  simpa only [map_mul, norm_mul, mul_pow, mul_comm] using h
+
+lemma outside_childFrequencyBall (a : Eis) (ha : a ≠ 0) (R : ℝ) (k : Eis)
+    (hk : k ∉ childFrequencyBall a R) : R < ‖eisEmbedding (a*k)‖^2 :=
+  lt_of_not_ge (fun h => hk ((mem_childFrequencyBall a ha R k).mpr h))
+
+def nonzeroChildFrequencyBall (a : Eis) (R : ℝ) : Finset Eis :=
+  (childFrequencyBall a R).erase 0
+
+lemma mem_nonzeroChildFrequencyBall (a : Eis) (ha : a ≠ 0) (R : ℝ) (k : Eis) :
+    k ∈ nonzeroChildFrequencyBall a R ↔
+      0 < ‖eisEmbedding (a*k)‖^2 ∧ ‖eisEmbedding (a*k)‖^2 ≤ R := by
+  have hn : 0 < ‖eisEmbedding (a*k)‖^2 ↔ k ≠ 0 := by
+    rw [sq_pos_iff, norm_ne_zero_iff]
+    constructor
+    · intro h hk; apply h; simp [hk]
+    · intro hk; exact ConcreteTraceCRT.eisEmbedding_ne_zero (mul_ne_zero ha hk)
+  simp only [nonzeroChildFrequencyBall, Finset.mem_erase,
+    mem_childFrequencyBall a ha, hn]
+
+lemma nonzeroChildFrequencyBall_empty (a : Eis) (ha : a ≠ 0) (R : ℝ) (hR : R < 1) :
+    nonzeroChildFrequencyBall a R = ∅ := by
+  apply Finset.eq_empty_iff_forall_notMem.mpr
+  intro k hk
+  have hm := (mem_nonzeroChildFrequencyBall a ha R k).mp hk
+  have hk0 : k ≠ 0 := by intro hk; simp [hk] at hm
+  exact (not_le_of_gt hR) ((EisensteinSchwartzPoisson.one_le_eisenstein_norm_sq
+    (a*k) (mul_ne_zero ha hk0)).trans hm.2)
+
+def childOuterRadius (Y A E X₁ X₂ H : ℝ) : ℝ := A*E*X₁*X₂*H/Y
+
+theorem childFrequencyBall_raw_tail {ι : Type*} [DecidableEq ι]
+    (p : ι → Eis) (hp : ∀ i, p i ≠ 0) (Y A E X₁ X₂ H : ℝ)
+    (hY : 0 < Y) (hA : 0 < A) (hE : 0 < E)
+    (hX₁ : 0 < X₁) (_hX₂ : 0 < X₂) (hH : 0 ≤ H)
+    (a e : Eis) (ha : a ≠ 0) (he : e ≠ 0)
+    (haA : ‖eisEmbedding a‖^2 ≤ A) (heE : ‖eisEmbedding e‖^2 ≤ E)
+    (S T : Finset ι) (hd : Disjoint S T)
+    (hS : primeProductNorm p S ≤ X₁) (hT : primeProductNorm p T ≤ X₂)
+    (k : Eis) (hk : k ∉ childFrequencyBall a (childOuterRadius Y A E X₁ X₂ H)) :
+    H ≤ (Y / (‖eisEmbedding e‖^2 *
+      ‖eisEmbedding (∏ i : activeSupport T S, p i.val)‖^2)) * ‖eisEmbedding k‖^2 := by
+  have haN : 0 < ‖eisEmbedding a‖^2 := sq_pos_of_pos
+    (norm_pos_iff.mpr (ConcreteTraceCRT.eisEmbedding_ne_zero ha))
+  have heN : 0 < ‖eisEmbedding e‖^2 := sq_pos_of_pos
+    (norm_pos_iff.mpr (ConcreteTraceCRT.eisEmbedding_ne_zero he))
+  have hden : ‖eisEmbedding a‖^2 * ‖eisEmbedding e‖^2 *
+      primeProductNorm p S * primeProductNorm p T ≤ A*E*X₁*X₂ := by
+    exact mul_le_mul (mul_le_mul (mul_le_mul haA heE heN.le hA.le)
+      hS (primeProductNorm_pos p hp S).le (mul_pos hA hE).le)
+      hT (primeProductNorm_pos p hp T).le (by positivity)
+  have hchild := (outside_childFrequencyBall a ha _ k hk).le
+  simp only [map_mul,norm_mul,mul_pow,childOuterRadius] at hchild
+  have hbound : H * (‖eisEmbedding a‖^2 * ‖eisEmbedding e‖^2 *
+      primeProductNorm p S * primeProductNorm p T) ≤
+      Y * (‖eisEmbedding a‖^2 * ‖eisEmbedding k‖^2) := by
+    calc
+      _ ≤ H*(A*E*X₁*X₂) := mul_le_mul_of_nonneg_left hden hH
+      _ ≤ _ := by nlinarith [(div_le_iff₀ hY).mp hchild]
+  have hcancel : H * (‖eisEmbedding e‖^2 * primeProductNorm p S *
+      primeProductNorm p T) ≤ Y * ‖eisEmbedding k‖^2 := by
+    apply (mul_le_mul_iff_right₀ haN).mp
+    nlinarith [hbound]
+  rw [active_norm_sq_disjoint p S T hd]
+  have hdpos : 0 < ‖eisEmbedding e‖^2 * (primeProductNorm p S * primeProductNorm p T) :=
+    mul_pos heN (mul_pos (primeProductNorm_pos p hp S) (primeProductNorm_pos p hp T))
+  rw [div_mul_eq_mul_div, le_div_iff₀ hdpos]
+  simpa only [mul_assoc] using hcancel
+
+theorem childFrequencyBall_remainder {ι : Type*} [DecidableEq ι]
+    (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal]
+    (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i})
+    (hinj : Function.Injective (fun i => Ideal.span {p i}))
+    (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) (order : ℕ) :
+    ∃ (s : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧
+      ∀ (W : 𝓢(ℝ, ℂ)) (Y A E X₁ X₂ H : ℝ),
+      0 < Y → 0 < A → 0 < E → 0 < X₁ → 0 < X₂ → 0 ≤ H →
+      ∀ (a e : Eis), a ≠ 0 → e ≠ 0 →
+      ‖eisEmbedding a‖^2 ≤ A → ‖eisEmbedding e‖^2 ≤ E →
+      ∀ (S T : Finset ι), Disjoint S T →
+      primeProductNorm p S ≤ X₁ → primeProductNorm p T ≤ X₂ →
+      let n := ∏ i : activeSupport T S, p i.val
+      let scale := Y / (‖eisEmbedding e‖^2 * ‖eisEmbedding n‖^2)
+      ‖∑' k : {k : Eis // k ∉ childFrequencyBall a (childOuterRadius Y A E X₁ X₂ H)},
+        secondPairRadialMode p hp hg hinj S T e k.val W Y‖ ≤
+      (Y / ‖eisEmbedding n‖) *
+        ((C * s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W) /
+          ((min 1 scale)^2 * (1+H)^order)) := by
+  obtain ⟨s,C,hC,hb⟩ := secondPairRadialMode_remainder p hp hg hinj hc order
+  refine ⟨s,C,hC,?_⟩
+  intro W Y A E X₁ X₂ H hY hA hE hX₁ hX₂ hH a e ha he haA heE S T hd hS hT
+  exact hb S T e he W Y H hY hH _
+    (fun k hk => childFrequencyBall_raw_tail p hp Y A E X₁ X₂ H hY hA hE hX₁ hX₂ hH
+      a e ha he haA heE S T hd hS hT k hk)
+
+theorem nonzeroChildFrequencyBall_absolute_tail {ι : Type*} [DecidableEq ι]
+    (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal]
+    (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i})
+    (hinj : Function.Injective (fun i => Ideal.span {p i}))
+    (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) (order : ℕ) :
+    ∃ (s : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧
+      ∀ (W : 𝓢(ℝ, ℂ)) (Y A E X₁ X₂ H : ℝ),
+      0 < Y → 0 < A → 0 < E → 0 < X₁ → 0 < X₂ → 0 ≤ H →
+      ∀ (a e : Eis), a ≠ 0 → e ≠ 0 →
+      ‖eisEmbedding a‖^2 ≤ A → ‖eisEmbedding e‖^2 ≤ E →
+      ∀ (S T : Finset ι), Disjoint S T →
+      primeProductNorm p S ≤ X₁ → primeProductNorm p T ≤ X₂ →
+      let n := ∏ i : activeSupport T S, p i.val
+      let scale := Y / (‖eisEmbedding e‖^2 * ‖eisEmbedding n‖^2)
+      (∑' k : {k : Eis // k ≠ 0 ∧ k ∉ nonzeroChildFrequencyBall a (childOuterRadius Y A E X₁ X₂ H)},
+        ‖secondPairRadialMode p hp hg hinj S T e k.val W Y‖) ≤
+      (Y / ‖eisEmbedding n‖) *
+        ((C * s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W) /
+          ((min 1 scale)^2 * (1+H)^order)) := by
+  obtain ⟨s,C,hC,hb⟩ := secondPairRadialMode_tail p hp hg hinj hc order
+  refine ⟨s,C,hC,?_⟩
+  intro W Y A E X₁ X₂ H hY hA hE hX₁ hX₂ hH a e ha he haA heE S T hd hS hT
+  dsimp only
+  let n := ∏ i : activeSupport T S, p i.val
+  let scale := Y / (‖eisEmbedding e‖^2 * ‖eisEmbedding n‖^2)
+  let small : Set Eis := {k | k ≠ 0 ∧ k ∉ nonzeroChildFrequencyBall a (childOuterRadius Y A E X₁ X₂ H)}
+  let large : Set Eis := {k | H ≤ scale * ‖eisEmbedding k‖^2}
+  have hmap : ∀ k : small, k.val ∈ large := by
+    intro k
+    apply childFrequencyBall_raw_tail p hp Y A E X₁ X₂ H hY hA hE hX₁ hX₂ hH
+      a e ha he haA heE S T hd hS hT k.val
+    intro hk
+    exact k.property.2 (Finset.mem_erase.mpr ⟨k.property.1,hk⟩)
+  let f : small → large := fun k => ⟨k.val,hmap k⟩
+  have hi : Function.Injective f := by
+    intro x y h; exact Subtype.ext (congrArg (fun z : large => z.val) h)
+  have hs := secondPairRadialMode_summable_norm p hp hg hinj hc S T e he W Y hY
+  calc
+    _ ≤ ∑' k : large, ‖secondPairRadialMode p hp hg hinj S T e k.val W Y‖ :=
+      (hs.subtype small).tsum_le_tsum_of_inj f hi (fun _ _ => norm_nonneg _)
+        (fun _ => le_rfl) (hs.subtype large)
+    _ ≤ _ := hb S T e he W Y H hY hH
+
+end
+end SevenEighths.InverseMoment
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/ClippedChild.lean

@@ -0,0 +1,68 @@
+import OAI.NumberTheory.DirichletL.Descent.ClippedUniform
+import OAI.NumberTheory.DirichletL.Descent.SecondCellPhysical
+import OAI.NumberTheory.DirichletL.Inversion.AmbientProfileTower
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff
+open MeasureTheory FourierBridge
+
+namespace SevenEighths.InverseMoment
+open InverseInitialClippedColumns JointLogSeparation InverseAmbientProfileTower
+open InverseSecondSourceBlocks
+local notation "O"=>ActualEisensteinCubic.O
+
+def secondChildHeight (right:Bool)(t:Ambient (Fin 6)):ℝ :=
+  if right then profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2 5
+  else -profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2 4
+
+theorem second_child_height_budget (J:ℕ)(right:Bool)(t:Ambient (Fin 6)):
+    (1+‖secondChildHeight right t‖)^J≤tripleHeight J t.1*coordinateHeight J t.2:=by
+  cases right
+  · have h:=pow_le_pow_left₀ (by positivity : 0≤1+‖inheritedLeft 4 t‖) (inheritedLeft_bound 4 t) J
+    rw [←ambientWeight_eq_pow] at h
+    simpa only [secondChildHeight,Bool.false_eq_true,ite_false,norm_neg,
+      second_inherited_left_eq,ambientWeight,tripleHeight,coordinateHeight] using h
+  · have h:=pow_le_pow_left₀ (by positivity : 0≤1+‖inheritedRight 5 t‖) (inheritedRight_bound 5 t) J
+    rw [←ambientWeight_eq_pow] at h
+    simpa only [secondChildHeight,ite_true,second_inherited_right_eq,norm_neg,
+      ambientWeight,tripleHeight,coordinateHeight] using h
+
+theorem canonical_actual_child_uniform
+    (W:ℝ→ℂ)(lo hi b:ℝ)(hlo:0<lo)(hb:1≤b)
+    (hs:Function.support W⊆Set.Icc lo hi)(hW:ContDiff ℝ ∞ W):
+    ∃(wFresh:𝓢(ℝ,ℂ))(af bf:ℝ),0<af ∧ af≤bf ∧ HasCompactSupport (wFresh:ℝ→ℂ) ∧
+      tsupport (wFresh:ℝ→ℂ)⊆Set.Icc af bf ∧
+      ∀J:ℕ,∃C:ℝ,0<C ∧ ∀{ι σ:Type*}[DecidableEq ι][DecidableEq σ]
+      (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+      (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+      (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i})
+      (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1)
+      (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+      (labels:Finset (Ideal O))(rows:Finset O)(D:Ideal O→ℝ)(_hD:∀f∈labels,0≤D f)
+      (Z X F E:ℝ)(d:BlockIndex)(right:Bool)(t:Ambient (Fin 6)),
+      1<Z→0<X→scales d 0*scales d 2≤b*X→0≤E→
+      (∀s,normalizedColumnEnergy p hp hcop hg pool Ψ m slots lists a labels rows D
+        (childLogTest wFresh s) (Z^(max 0 (secondCellColumnExponent Z X d))) Z F≤E*(1+‖s‖)^(2*J))→
+      normalizedColumnEnergy p hp hcop hg pool Ψ m slots lists a labels rows D
+        (clippedTest W (Z^(max 0 (secondCellColumnExponent Z X d)-secondCellColumnExponent Z X d))
+          (secondChildHeight right t)) (Z^(max 0 (secondCellColumnExponent Z X d))) Z F≤
+        C*E*(tripleHeight (2*J) t.1*coordinateHeight (2*J) t.2):=by
+  obtain ⟨wFresh,af,bf,haf,hab,hc,hsf,he⟩:=canonical_clipped_uniform W lo hi b hlo hb hs hW
+  refine ⟨wFresh,af,bf,haf,hab,hc,hsf,?_⟩
+  intro J
+  obtain ⟨C,hC,hbound⟩:=he J
+  refine ⟨C,hC,?_⟩
+  intro ι σ _ _ p hp _ hcop hg hpr pool Ψ m slots lists a labels rows D hD Z X F E d right t hZ hX hgeom hE hmoment
+  obtain ⟨hc1,hcb⟩:=second_cell_clipping_ratio Z X b d hZ hX hb hgeom
+  have hz:0<Z:=zero_lt_one.trans hZ
+  exact (hbound p hp hcop hg hpr pool Ψ m slots lists a labels rows D hD
+    _ (secondChildHeight right t) _ Z F E hc1 hcb (Real.rpow_pos_of_pos hz _) hE hmoment).trans
+      (mul_le_mul_of_nonneg_left (second_child_height_budget (2*J) right t) (mul_nonneg hC.le hE))
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/ClippedEnergy.lean

@@ -0,0 +1,92 @@
+import OAI.NumberTheory.DirichletL.Descent.ClippedFourier
+import OAI.NumberTheory.DirichletL.Moments.HeckeWindowEnergy
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff
+open MeasureTheory FourierBridge
+
+namespace SevenEighths.InverseMoment
+open InverseInitialClippedColumns InverseInitialOverlapFourier CompletedGauss
+local notation "O"=>ActualEisensteinCubic.O
+variable {ι σ:Type*}[DecidableEq ι]
+  (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+  (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+  (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i})
+
+theorem normalized_energy_vector
+    (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+    (labels:Finset (Ideal O))(rows:Finset O)(D:Ideal O→ℝ)(hD:∀f∈labels,0≤D f)
+    (W:ℝ→ℂ)(X Z F:ℝ):
+    (∑v:labels×rows,‖(Real.sqrt (D v.1):ℂ)*((Z^(-F/2):ℝ):ℂ)*
+      finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (primaryGenerator v.1) v.2 slots lists a W X‖^2)=
+    normalizedColumnEnergy p hp hcop hg pool Ψ m slots lists a labels rows D W X Z F:=by
+  unfold normalizedColumnEnergy
+  rw [Fintype.sum_prod_type,←Finset.sum_coe_sort labels]
+  apply Finset.sum_congr rfl
+  intro f hf
+  rw [←Finset.sum_coe_sort rows,Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro k hk
+  simp only [mul_assoc,norm_mul,mul_pow,Complex.norm_real,
+    Real.norm_of_nonneg (Real.sqrt_nonneg _),Real.sq_sqrt (hD f f.property)]
+
+theorem canonical_clipped_energy
+    (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1)
+    (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+    (labels:Finset (Ideal O))(rows:Finset O)(D:Ideal O→ℝ)(hD:∀f∈labels,0≤D f)
+    (W:ℝ→ℂ)(lo hi:ℝ)(hlo:0<lo)(hs:Function.support W⊆Set.Icc lo hi)(hW:ContDiff ℝ ∞ W)
+    (wFresh:ℝ→ℂ)(c θ X Z F E:ℝ)(J:ℕ)(hc:0<c)(hX:0<X)(hE:0≤E)
+    (hw:∀y,0<y→wFresh y*W (c*y)=W (c*y))
+    (he:∀s,normalizedColumnEnergy p hp hcop hg pool Ψ m slots lists a labels rows D
+      (childLogTest wFresh s) X Z F≤E*(1+‖s‖)^(2*J)):
+    normalizedColumnEnergy p hp hcop hg pool Ψ m slots lists a labels rows D
+      (clippedTest W c θ) X Z F≤
+      E*(1+‖θ‖)^(2*J)*(∫t:ℝ,(1+‖t‖)^J*‖(𝓕 (CubicReflectionKernel.logSchwartz W lo hi hlo hs hW)) t‖)^2:=by
+  let g:=CubicReflectionKernel.logSchwartz W lo hi hlo hs hW
+  let b:=density g (Real.log c)
+  let phi:labels×rows→ℝ→ℂ:=fun v t=>(Real.sqrt (D v.1):ℂ)*((Z^(-F/2):ℝ):ℂ)*
+    finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (primaryGenerator v.1) v.2 slots lists a
+      (childLogTest wFresh (θ+t)) X
+  have hint(v:labels×rows):Integrable (fun t:ℝ=>b t*phi v t):=by
+    convert (canonical_clipped_mode_integrable p hp hcop hg hpr pool Ψ m (primaryGenerator v.1) v.2
+      slots lists a g wFresh c θ X).const_mul ((Real.sqrt (D v.1):ℂ)*((Z^(-F/2):ℝ):ℂ)) using 1
+    funext t
+    dsimp [b,phi]
+    ring
+  have hbound(t:ℝ):(∑v:labels×rows,‖phi v t‖^2)≤
+      (E*(1+‖θ‖)^(2*J))*((1+‖t‖)^J)^2:=by
+    dsimp only [phi]
+    rw [normalized_energy_vector p hp hcop hg pool Ψ m slots lists a labels rows D hD]
+    apply (he (θ+t)).trans
+    have hb:1+‖θ+t‖≤(1+‖θ‖)*(1+‖t‖):=by
+      have hh:=norm_add_le θ t
+      nlinarith [mul_nonneg (norm_nonneg θ) (norm_nonneg t)]
+    calc
+      _≤E*((1+‖θ‖)*(1+‖t‖))^(2*J):=mul_le_mul_of_nonneg_left (pow_le_pow_left₀ (by positivity) hb _) hE
+      _= _:=by rw [mul_pow,pow_mul];ring
+  have hden:Integrable (fun t:ℝ=>(1+‖t‖)^J*‖b t‖):=by
+    simpa only [b,density_norm] using AnalyticBridge.schwartz_fourier_one_plus_integrable g J
+  have hh:=CenteredMomentHeckeWindowEnergy.finite_weighted_integral_energy b phi
+    (fun t:ℝ=>(1+‖t‖)^J) (by intro t;positivity)
+    (E*(1+‖θ‖)^(2*J)) (by positivity) hden hint hbound
+  have heq(v:labels×rows): (∫t:ℝ,b t*phi v t)=
+      (Real.sqrt (D v.1):ℂ)*((Z^(-F/2):ℝ):ℂ)*
+      finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (primaryGenerator v.1) v.2 slots lists a
+        (clippedTest W c θ) X:=by
+    rw [canonical_clipped_fourier p hp hcop hg hpr pool Ψ m (primaryGenerator v.1) v.2
+      slots lists a W lo hi hlo hs hW wFresh c θ X hc hX hw,←integral_const_mul]
+    apply integral_congr_ae
+    filter_upwards with t
+    dsimp [b,phi,g]
+    ring
+  simp_rw [heq] at hh
+  rw [normalized_energy_vector p hp hcop hg pool Ψ m slots lists a labels rows D hD] at hh
+  simpa only [b,density_norm,g] using hh
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/ClippedFourier.lean

@@ -0,0 +1,126 @@
+import OAI.NumberTheory.DirichletL.Inversion.InitialOverlapFourier
+import OAI.NumberTheory.DirichletL.Inversion.InitialClippedColumns
+import OAI.NumberTheory.DirichletL.Inversion.SecondChildWindows
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff
+open MeasureTheory FourierBridge
+
+namespace SevenEighths.InverseMoment
+open InverseInitialClippedColumns InverseInitialOverlapFourier SecondPassIntegration JointLogSeparation
+open ActualEisensteinCubic FirstPassCubeLabels CompletedGauss
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem clipped_fixed_window (W:ℝ→ℂ) (lo hi b:ℝ) (hlo:0<lo) (hb:1≤b)
+    (hW:Function.support W⊆Set.Icc lo hi):
+    ∃(wFresh:𝓢(ℝ,ℂ))(af bf:ℝ),0<af ∧ af≤bf ∧ HasCompactSupport (wFresh:ℝ→ℂ) ∧
+      tsupport (wFresh:ℝ→ℂ)⊆Set.Icc af bf ∧
+      ∀c,1≤c→c≤b→∀y,0<y→wFresh y*W (c*y)=W (c*y):=by
+  have hb0:0<b:=zero_lt_one.trans_le hb
+  let a:=lo/b
+  let B:=a+|hi|+1
+  have ha:0<a:=div_pos hlo hb0
+  obtain ⟨wFresh,hc,hone,hs⟩:=InverseSecondChildWindows.positive_cutoff a B ha (by dsimp [B];linarith [abs_nonneg hi])
+  refine ⟨wFresh,a/2,B+1,half_pos ha,by dsimp [B];linarith [abs_nonneg hi],hc,hs,?_⟩
+  intro c hc hcb y hy
+  by_cases hz:W (c*y)=0
+  · simp only [hz,mul_zero]
+  have hw:=hW hz
+  have hay:a≤y:=by
+    apply (div_le_iff₀ hb0).mpr
+    calc
+      lo≤c*y:=hw.1
+      _≤y*b:=by nlinarith
+  have hyhi:y≤hi:=le_trans (by nlinarith) hw.2
+  have hyB:y≤B:=by dsimp [B];linarith [le_abs_self hi]
+  rw [hone y ⟨hay,hyB⟩,one_mul]
+
+theorem clipped_test_fourier (W:ℝ→ℂ) (lo hi:ℝ) (hlo:0<lo)
+    (hs:Function.support W⊆Set.Icc lo hi) (hW:ContDiff ℝ ∞ W)
+    (wFresh:ℝ→ℂ)(c θ y:ℝ)(hc:0<c)(hy:0<y)(hwFresh:wFresh y*W (c*y)=W (c*y)):
+    clippedTest W c θ y =
+      ∫t:ℝ,density (CubicReflectionKernel.logSchwartz W lo hi hlo hs hW) (Real.log c) t *
+        childLogTest wFresh (θ+t) y:=by
+  let g:=CubicReflectionKernel.logSchwartz W lo hi hlo hs hW
+  change clippedTest W c θ y=∫t:ℝ,density g (Real.log c) t*childLogTest wFresh (θ+t) y
+  have he (t:ℝ):density g (Real.log c) t*childLogTest wFresh (θ+t) y=
+      ((𝓕 g) t*logPhase t (Real.log c+Real.log y))*(wFresh y*logPhase θ (Real.log y)):=by
+    simp only [density,childLogTest,logPhase_add_frequency,logPhase_add]
+    ring
+  simp_rw [he]
+  rw [integral_mul_const]
+  have hi':(∫t:ℝ,(𝓕 g) t*logPhase t (Real.log c+Real.log y))=W (c*y):=by
+    calc
+      _=(∫t:ℝ,logPhase t (Real.log c+Real.log y)*(𝓕 g) t):=by
+        apply integral_congr_ae
+        filter_upwards with t
+        ring
+      _=g (Real.log c+Real.log y):=(schwartz_logPhase_inversion g _).symm
+      _= _:=by
+        simp only [g,CubicReflectionKernel.logSchwartz_apply,Real.exp_add,Real.exp_log hc,Real.exp_log hy]
+  rw [hi']
+  unfold clippedTest childLogTest
+  calc
+    W (c*y)*logPhase θ (Real.log y)=(wFresh y*W (c*y))*logPhase θ (Real.log y):=by rw [hwFresh]
+    _= _:=by ring
+
+variable {ι σ:Type*}[DecidableEq ι]
+  (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+  (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+  (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i})
+
+theorem canonical_clipped_mode_integrable
+    (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1)
+    (pool:Finset ι)(Ψ:O→*ℂ)(m f k:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+    (g:𝓢(ℝ,ℂ))(wFresh:ℝ→ℂ)(c θ X:ℝ):
+    Integrable (fun t:ℝ=>density g (Real.log c) t*
+      finiteCanonicalMarkedRow p hp hcop hg pool Ψ m f k slots lists a (childLogTest wFresh (θ+t)) X):=by
+  simp_rw [finiteCanonicalMarkedRow_actual_columns p hp hcop hg hpr]
+  simp only [Finset.mul_sum]
+  apply integrable_finsetSum
+  intro U hU
+  convert fourier_phase_integrable g (Real.log c+Real.log (primeProductNorm p U/X))
+    (columnWeight (CanonicalRowCompletion.rowTwist Ψ m f k) (Ideal.span {∏i∈U,p i})*
+      primeMark slots lists a U*wFresh (primeProductNorm p U/X)*logPhase θ (Real.log (primeProductNorm p U/X))) using 1
+  funext t
+  simp only [density,childLogTest,logPhase_add_frequency,logPhase_add]
+  ring
+
+theorem canonical_clipped_fourier
+    (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1)
+    (pool:Finset ι)(Ψ:O→*ℂ)(m f k:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+    (W:ℝ→ℂ)(lo hi:ℝ)(hlo:0<lo)(hs:Function.support W⊆Set.Icc lo hi)(hW:ContDiff ℝ ∞ W)
+    (wFresh:ℝ→ℂ)(c θ X:ℝ)(hc:0<c)(hX:0<X)(hwFresh:∀y,0<y→wFresh y*W (c*y)=W (c*y)):
+    finiteCanonicalMarkedRow p hp hcop hg pool Ψ m f k slots lists a (clippedTest W c θ) X=
+      ∫t:ℝ,density (CubicReflectionKernel.logSchwartz W lo hi hlo hs hW) (Real.log c) t *
+        finiteCanonicalMarkedRow p hp hcop hg pool Ψ m f k slots lists a (childLogTest wFresh (θ+t)) X:=by
+  simp_rw [finiteCanonicalMarkedRow_actual_columns p hp hcop hg hpr]
+  simp only [Finset.mul_sum]
+  have hints (U:Finset ι):Integrable (fun t:ℝ=>
+      density (CubicReflectionKernel.logSchwartz W lo hi hlo hs hW) (Real.log c) t*
+      (columnWeight (CanonicalRowCompletion.rowTwist Ψ m f k) (Ideal.span {∏i∈U,p i})*
+        (primeMark slots lists a U*childLogTest wFresh (θ+t) (primeProductNorm p U/X)))):=by
+    convert fourier_phase_integrable (CubicReflectionKernel.logSchwartz W lo hi hlo hs hW)
+      (Real.log c+Real.log (primeProductNorm p U/X))
+      (columnWeight (CanonicalRowCompletion.rowTwist Ψ m f k) (Ideal.span {∏i∈U,p i})*
+        primeMark slots lists a U*wFresh (primeProductNorm p U/X)*logPhase θ (Real.log (primeProductNorm p U/X))) using 1
+    funext t
+    simp only [density,childLogTest,logPhase_add_frequency,logPhase_add]
+    ring
+  rw [integral_finsetSum _ (fun U _=>hints U)]
+  apply Finset.sum_congr rfl
+  intro U hU
+  rw [clipped_test_fourier W lo hi hlo hs hW wFresh c θ _ hc
+    (div_pos (FirstPassCubeLabels.primeProductNorm_pos p hp U) hX) (hwFresh _ (div_pos (FirstPassCubeLabels.primeProductNorm_pos p hp U) hX))]
+  rw [←integral_const_mul,←integral_const_mul]
+  apply integral_congr_ae
+  filter_upwards with t
+  ring
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI

lean/OAI/NumberTheory/DirichletL/Descent/ClippedUniform.lean

@@ -0,0 +1,48 @@
+import OAI.NumberTheory.DirichletL.Descent.ClippedEnergy
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff
+open MeasureTheory FourierBridge
+
+namespace SevenEighths.InverseMoment
+open InverseInitialClippedColumns
+local notation "O"=>ActualEisensteinCubic.O
+
+theorem canonical_clipped_uniform
+    (W:ℝ→ℂ)(lo hi b:ℝ)(hlo:0<lo)(hb:1≤b)
+    (hs:Function.support W⊆Set.Icc lo hi)(hW:ContDiff ℝ ∞ W):
+    ∃(wFresh:𝓢(ℝ,ℂ))(af bf:ℝ),0<af ∧ af≤bf ∧ HasCompactSupport (wFresh:ℝ→ℂ) ∧
+      tsupport (wFresh:ℝ→ℂ)⊆Set.Icc af bf ∧
+      ∀J:ℕ,∃C:ℝ,0<C ∧ ∀{ι σ:Type*}[DecidableEq ι][DecidableEq σ]
+      (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal]
+      (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i})))
+      (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i})
+      (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1)
+      (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)
+      (labels:Finset (Ideal O))(rows:Finset O)(D:Ideal O→ℝ)(_hD:∀f∈labels,0≤D f)
+      (c θ X Z F E:ℝ),1≤c→c≤b→0<X→0≤E→
+      (∀s,normalizedColumnEnergy p hp hcop hg pool Ψ m slots lists a labels rows D
+        (childLogTest wFresh s) X Z F≤E*(1+‖s‖)^(2*J))→
+      normalizedColumnEnergy p hp hcop hg pool Ψ m slots lists a labels rows D
+        (clippedTest W c θ) X Z F≤C*E*(1+‖θ‖)^(2*J):=by
+  obtain ⟨wFresh,af,bf,haf,hab,hc,hsf,hagree⟩:=clipped_fixed_window W lo hi b hlo hb hs
+  refine ⟨wFresh,af,bf,haf,hab,hc,hsf,?_⟩
+  intro J
+  let M:=(∫t:ℝ,(1+‖t‖)^J*‖(𝓕 (CubicReflectionKernel.logSchwartz W lo hi hlo hs hW)) t‖)^2
+  refine ⟨M+1,by dsimp [M];positivity,?_⟩
+  intro ι σ _ _ p hp _ hcop hg hpr pool Ψ m slots lists a labels rows D hD c θ X Z F E hc1 hcb hX hE he
+  have hh:=canonical_clipped_energy p hp hcop hg hpr pool Ψ m slots lists a labels rows D hD
+    W lo hi hlo hs hW wFresh c θ X Z F E J (zero_lt_one.trans_le hc1) hX hE
+    (hagree c hc1 hcb) he
+  apply hh.trans
+  change E*(1+‖θ‖)^(2*J)*M≤(M+1)*E*(1+‖θ‖)^(2*J)
+  have hn:0≤E*(1+‖θ‖)^(2*J):=by positivity
+  nlinarith
+
+end SevenEighths.InverseMoment
+
+end
+
+end OAI