Add lean source and binary files (part 17)

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Avoidance.lean

@@ -0,0 +1,188 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Ultrafilter
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+open Filter
+open scoped Topology
+universe u v
+variable {ι : Type*} {A : Type u} [CStarAlgebra A]
+local instance avoidanceLimitPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance avoidanceLimitStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+local instance avoidanceLimitOperatorPartialOrder (J : Type*) [NormedAddCommGroup J]
+    [InnerProductSpace ℂ J] [CompleteSpace J] :
+    PartialOrder (J →L[ℂ] J) := CStarAlgebra.spectralOrder _
+local instance avoidanceLimitOperatorStarOrderedRing (J : Type*) [NormedAddCommGroup J]
+    [InnerProductSpace ℂ J] [CompleteSpace J] :
+    StarOrderedRing (J →L[ℂ] J) := CStarAlgebra.spectralOrderedRing _
+variable {H : ι → Type v} [∀ i, NormedAddCommGroup (H i)]
+  [∀ i, InnerProductSpace ℂ (H i)] [∀ i, CompleteSpace (H i)]
+
+theorem four_limit_impossible (ω : Ultrafilter ι)
+    (π : ∀ i, A →⋆ₐ[ℂ] (H i →L[ℂ] H i)) (ξ : ∀ i, H i) (hξ : ∀ i, ‖ξ i‖ ≤ 1)
+    {X : A} (hX : 0 ≤ X) (B : Fin 4 → A)
+    (hV : ∀ᶠ i in (ω : Filter ι), (1/8 : ℝ) ≤ ‖π i (firstV X) (ξ i)‖)
+    (hD₁ : ∀ i, π i (B 0) * star (π i (B 0)) ≤ (1/2 : ℝ) • 1)
+    (hm₁ : ∀ i, π i (B 1 * star (B 1)) = π i (B 0 * star (B 0)))
+    (hc₁ : ∀ i, π i (B 0 * star (B 1)) = 0)
+    (hs₀ : ∀ i, π i (firstH X * star (B 0)) = π i (star (B 0)))
+    (hs₁ : ∀ i, π i (firstH X * star (B 1)) = π i (star (B 1)))
+    (hU : ∀ w : A, Tendsto (fun i => ‖π i (firstU X (B 0) * w * firstV X)‖)
+      (ω : Filter ι) (𝓝 0))
+    (hD₃ : ∀ i, π i (B 2) * star (π i (B 2)) ≤ (1/2 : ℝ) • 1)
+    (hc₃ : ∀ i, π i (star (B 2) * B 3) = 0)
+    (hm₃ : ∀ i, π i (star (B 2) * B 2) = π i (star (B 3) * B 3))
+    (hR : Tendsto (fun i => ‖π i (lastR X (B 0) (B 2))‖) (ω : Filter ι) (𝓝 0))
+    (hs₃ : ∀ i, π i (ramp (prospectiveDefect X (B 0)) 0 (1/2) * B 3) = π i (B 3)) : False := by
+  let ρ := limitRep ω π ξ hξ
+  let Ψ := rangeRestriction ρ (firstV X)
+  have hkill : ∀ a : A, Tendsto (fun i => ‖π i a‖) (ω : Filter ι) (𝓝 0) → Ψ a = 0 := by
+    intro a ha
+    have hz : ρ a = 0 := limitRep_annihilates ω π ξ hξ a ha
+    ext x
+    change (ρ a x : LimitHilbert ω π ξ hξ) = 0
+    rw [hz, zero_apply]
+  have hzero : ∀ a : A, (∀ i, π i a = 0) → Ψ a = 0 := by
+    intro a ha
+    apply hkill a
+    simp only [ha, norm_zero]
+    exact tendsto_const_nhds
+  have heq : ∀ a b : A, (∀ i, π i a = π i b) → Ψ a = Ψ b := by
+    intro a b hab
+    have hz := hzero (a-b) (fun i => by rw [map_sub, hab i, sub_self])
+    exact sub_eq_zero.mp (by simpa only [map_sub] using hz)
+  have hbound (j : Fin 4) (hj : ∀ i, π i (B j) * star (π i (B j)) ≤ (1/2 : ℝ) • 1) := by
+    have hz := hzero (cut (B j * star (B j)) (1/2)) (fun i => by
+      rw [map_cut_sa (π i) (.mul_star_self _) (by norm_num), map_mul, map_star]
+      exact cut_zero_of_le (mul_star_self_nonneg _) (by norm_num) (hj i))
+    rw [map_cut_sa (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ (IsSelfAdjoint.mul_star_self (B j)) (by norm_num : (0:ℝ) ≤ 1/2), map_mul, map_star] at hz
+    exact le_of_cut_zero (mul_star_self_nonneg _) (by norm_num) hz
+  have hψV : firstV (Ψ X) ≠ 0 := by
+    rw [← map_firstV (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ (.of_nonneg hX)]
+    exact rangeRestriction_nonzero ρ (firstV X) (.of_nonneg (cut_nonneg X _))
+      (limitRep_nonzero ω π ξ hξ (firstV X) (by norm_num : (0:ℝ) < 1/8) hV)
+  have hψU : firstU (Ψ X) (Ψ (B 0)) = 0 := by
+    rw [← map_firstU (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ (.of_nonneg hX)]
+    apply rangeRestriction_kills ρ (firstV X) (firstU X (B 0))
+    intro w
+    simpa only [map_mul] using limitRep_annihilates ω π ξ hξ _ (hU w)
+  apply four_fixed_impossible (map_nonneg Ψ hX) (fun i => Ψ (B i)) hψV
+    (hbound 0 hD₁) ?_ ?_ ?_ ?_ hψU (hbound 2 hD₃) ?_ ?_ ?_ ?_
+  · simpa only [map_mul, map_star] using heq _ _ hm₁
+  · simpa only [map_mul, map_star] using hzero _ hc₁
+  · simpa only [map_mul, map_star, map_firstH (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ (.of_nonneg hX)] using heq _ _ hs₀
+  · simpa only [map_mul, map_star, map_firstH (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ (.of_nonneg hX)] using heq _ _ hs₁
+  · simpa only [map_mul, map_star] using hzero _ hc₃
+  · simpa only [map_mul, map_star] using heq _ _ hm₃
+  · simpa only [map_lastR (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ (.of_nonneg hX)] using hkill _ hR
+  · have hp : IsSelfAdjoint (prospectiveDefect X (B 0)) :=
+      .of_nonneg (prospectiveDefect_nonneg X _)
+    simpa only [map_mul, map_ramp_sa (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ hp le_rfl, map_prospectiveDefect (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ (.of_nonneg hX)] using
+      heq _ _ hs₃
+
+end MainGap
+
+namespace MainGap
+universe u v
+open Filter
+open scoped Topology
+variable (A : Type u) [CStarAlgebra A]
+
+structure HilbertRep where
+  H : Type v
+  [normed : NormedAddCommGroup H]
+  [inner : InnerProductSpace ℂ H]
+  [complete : CompleteSpace H]
+  hom : A →⋆ₐ[ℂ] (H →L[ℂ] H)
+
+attribute [instance] HilbertRep.normed HilbertRep.inner HilbertRep.complete
+
+variable {A}
+local instance avoidancePartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance avoidanceStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+local instance avoidanceOperatorPartialOrder (J : Type*) [NormedAddCommGroup J]
+    [InnerProductSpace ℂ J] [CompleteSpace J] :
+    PartialOrder (J →L[ℂ] J) := CStarAlgebra.spectralOrder _
+local instance avoidanceOperatorStarOrderedRing (J : Type*) [NormedAddCommGroup J]
+    [InnerProductSpace ℂ J] [CompleteSpace J] :
+    StarOrderedRing (J →L[ℂ] J) := CStarAlgebra.spectralOrderedRing _
+
+theorem four_avoidance_unital {X : A} (hX : 0 ≤ X) (B : Fin 4 → A)
+    (hp : ∀ z : A, 0 ≤ z → z ∈ fourHer X → ProperlyInfinite z) :
+    ∃ T : Fin 4 → A, (∀ j, ‖T j‖ ≤ 1) ∧ (∀ j, T j ∈ fourHer X) ∧
+      ∀ R : HilbertRep.{u,v} A, (1/4 : ℝ) < ‖R.hom X‖ →
+        ¬ ∀ j, R.hom (T j) = R.hom (B j) := by
+  classical
+  by_contra! hbad
+  let F : ∀ i : FourIndex A, FourChoice.{v,u} X B i.2 (fourEta A i) :=
+    fun i => Classical.choice (fourChoice_nonempty hX B hp i.2 (fourEta_pos A i))
+  have hbad' : ∀ i : FourIndex A, ∃ R : HilbertRep.{u,v} A,
+      (1/4 : ℝ) < ‖R.hom X‖ ∧ ∀ j, R.hom ((F i).T j) = R.hom (B j) :=
+    fun i => hbad (F i).T (F i).contractive (F i).mem
+  choose R hRX hmatch using hbad'
+  let π := fun i => (R i).hom
+  change ∀ i j, π i ((F i).T j) = π i (B j) at hmatch
+  have hVbig : ∀ i, (1/8 : ℝ) < ‖π i (firstV X)‖ := by
+    intro i
+    have hn : ‖π i X - π i (firstV X)‖ ≤ (1/8 : ℝ) := by
+      rw [← map_sub]
+      exact (NonUnitalStarAlgHom.norm_apply_le (π i) _).trans
+        (norm_sub_cut_le hX (by norm_num))
+    have hm := norm_sub_norm_le (π i X) (π i (firstV X))
+    have hi := hRX i
+    change (1/4 : ℝ) < ‖π i X‖ at hi
+    linarith
+  choose ξ hξ hξV using fun i => (π i (firstV X)).exists_lt_apply_of_lt_opNorm (hVbig i)
+  have hnξ : ∀ i, ‖ξ i‖ ≤ 1 := fun i => (hξ i).le
+  have hEt := fourEta_ultra A
+  apply four_limit_impossible (fourUltra A) π ξ hnξ hX B
+    (Filter.Eventually.of_forall (fun i => (hξV i).le))
+    (fun i => (F i).first_bound (π i) hX (fourEta_pos A i) (hmatch i)) ?_ ?_ ?_ ?_ ?_
+    (fun i => (F i).last_bound (π i) hX (fourEta_pos A i) (hmatch i)) ?_ ?_ ?_ ?_
+  · intro i
+    have hm := congrArg (π i) (F i).first_equal
+    simpa only [map_mul, map_star, hmatch i] using hm
+  · intro i
+    have hm := congrArg (π i) (F i).first_cross
+    simpa only [map_mul, map_star, hmatch i, map_zero] using hm
+  · intro i
+    have hm := congrArg (π i) ((F i).first_support₀ hX)
+    simpa only [map_mul, map_star, hmatch i] using hm
+  · intro i
+    have hm := congrArg (π i) ((F i).first_support₁ hX)
+    simpa only [map_mul, map_star, hmatch i] using hm
+  · intro w
+    have hg : Tendsto (fun i : FourIndex A =>
+        Real.sqrt (2 * fourEta A i) * ‖CFC.sqrt (firstV X)‖ +
+          fourEta A i * ‖w‖ * ‖firstV X‖) (fourUltra A : Filter (FourIndex A)) (𝓝 0) := by
+      convert ((hEt.const_mul 2).sqrt.mul_const ‖CFC.sqrt (firstV X)‖).add
+        ((hEt.mul_const ‖w‖).mul_const ‖firstV X‖) using 1; norm_num
+    apply squeeze_zero' (Filter.Eventually.of_forall (fun i => norm_nonneg _)) ?_ hg
+    filter_upwards [fourUltra_le A (fourIndex_eventually_mem A w)] with i hi
+    exact represented_mixed_estimate (π i) (firstU_nonneg _ _) (cut_nonneg X _)
+      (fourEta_pos A i) hi ((F i).first_norm (π i) hX (fourEta_pos A i) (hmatch i)).le
+  · intro i
+    have hm := congrArg (π i) (F i).last_cross
+    simpa only [map_mul, map_star, hmatch i, map_zero] using hm
+  · intro i
+    have hm := congrArg (π i) (F i).last_equal
+    simpa only [map_mul, map_star, hmatch i] using hm
+  · have ht : Tendsto (fun i : FourIndex A => 4 * fourEta A i)
+        (fourUltra A : Filter (FourIndex A)) (𝓝 0) := by
+      simpa using hEt.const_mul 4
+    exact squeeze_zero' (Filter.Eventually.of_forall (fun i => norm_nonneg _))
+      (Filter.Eventually.of_forall (fun i =>
+        ((F i).last_norm_lt (π i) hX (fourEta_pos A i) (hmatch i)).le)) ht
+  · intro i
+    have hm := congrArg (π i) (F i).last_support
+    simpa only [map_mul, hmatch i] using hm
+
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/ChoicePairs.lean

@@ -0,0 +1,327 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Cutoffs
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+local instance choicePairsPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance choicePairsStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+lemma norm_sqrt_le_one {d : A} (hd : 0 ≤ d) (hn : ‖d‖ ≤ 1) : ‖CFC.sqrt d‖ ≤ 1 := by
+  have hh : ‖CFC.sqrt d‖ ^ 2 = ‖d‖ := by
+    rw [pow_two, ← CStarRing.norm_star_mul_self,
+      (IsSelfAdjoint.of_nonneg (CFC.sqrt_nonneg d)).star_eq, CFC.sqrt_mul_sqrt_self d hd]
+  nlinarith [norm_nonneg (CFC.sqrt d)]
+
+lemma fixed_left_of_modulus {b z : A} (h : b * (z * star z) = z * star z) : b*z=z := by
+  apply sub_eq_zero.mp
+  apply (CStarRing.mul_star_self_eq_zero_iff _).mp
+  have hs := congrArg star h
+  simp only [star_mul, star_star] at hs
+  calc
+    (b*z-z) * star (b*z-z) = b*(z*star z)*star b - (z*star z)*star b - b*(z*star z) + z*star z := by
+      simp only [star_sub, star_mul]; noncomm_ring
+    _ = 0 := by rw [h]; noncomm_ring
+
+lemma carrier_mem_Her {n : ℕ} {h v k : A} (S : OrthogonalSlots n h v)
+    (hv : v ∈ Her k) (i : Fin n) (e : Her h) (he : (e : A) ∈ Her k) :
+    S.carrier i e ∈ Her k := by
+  apply mem_Her_of_moduli
+  · exact Her_mono_of_mem hv (S.outer i i e e)
+  · rw [S.inner, ite_eq_left rfl]
+    exact (Her k).mul_mem ((Her k).star_mem' he) he
+
+theorem first_pair_choice {d v k : A} (hd : 0 ≤ d) (hv : 0 ≤ v)
+    (hdv : FiniteCuntzLE (diagonalCorner 2 d) (scalarCorner v))
+    (hdk : d ∈ Her k) (hvk : v ∈ Her k) {η : ℝ} (hη : 0 < η) :
+    ∃ T : Fin 2 → A,
+      (∀ i, ‖T i‖ ≤ 1) ∧ (∀ i, T i ∈ Her k) ∧
+      (∀ i j, T i * star (T j) = if i=j then ramp d η (2*η) else 0) ∧
+      (∀ i j, star (T i) * T j ∈ Her v) := by
+  let D := ramp d η (2*η)
+  have hDpos : 0 ≤ D := ramp_nonneg d (by linarith)
+  have hDmem : D ∈ Her (cut d η) := ramp_mem_Her_cut hd hη.le
+  let e : Her (cut d η) := ⟨CFC.sqrt D, sqrt_mem_Her hDmem hDpos⟩
+  obtain ⟨S⟩ := orthogonalSlots_of_comparison hd hv hdv hη
+  have hnorm : ‖(e : A)‖ ≤ 1 := norm_sqrt_le_one hDpos (norm_ramp_le_one d (by linarith))
+  have he : (e : A) ∈ Her k :=
+    Her_mono_of_mem hdk (Her_mono_of_mem (cut_mem_Her hd η) e.property)
+  have hsa : star (e : A) = (e : A) := (IsSelfAdjoint.of_nonneg (CFC.sqrt_nonneg D)).star_eq
+  refine ⟨fun i => star (S.carrier i e), ?_, ?_, ?_, ?_⟩
+  · intro i
+    rw [norm_star, S.norm_carrier]
+    exact hnorm
+  · intro i
+    exact (Her k).star_mem' (carrier_mem_Her S hvk i e he)
+  · intro i j
+    rw [star_star, S.inner, hsa]
+    split_ifs
+    · exact CFC.sqrt_mul_sqrt_self D hDpos
+    · rfl
+  · intro i j
+    rw [star_star]
+    exact S.outer i j e e
+
+theorem last_pair_choice {R k : A} (hR : 0 ≤ R) (hRk : R ∈ Her k)
+    {η : ℝ} (hη : 0 < η) (hp : ProperlyInfinite (cut R η)) :
+    ∃ T : Fin 2 → A,
+      (∀ i, ‖T i‖ ≤ 1) ∧ (∀ i, T i ∈ Her k) ∧
+      (∀ i j, star (T i) * T j = if i=j then ramp R (2*η) (4*η) * ramp R (2*η) (4*η) else 0) ∧
+      (∀ i j, T i * star (T j) ∈ Her (cut R η)) ∧
+      (∀ {B : Type*} [NonUnitalCStarAlgebra B] (π : A →⋆ₙₐ[ℂ] B),
+        4*η ≤ ‖π R‖ → ∀ i, ‖π (T i)‖ = 1) := by
+  let t := ramp R (2*η) (4*η)
+  have ht : t ∈ Her (cut (cut R η) η) := by
+    rw [cut_cut hR hη.le hη.le, ← two_mul η]
+    exact ramp_mem_Her_cut hR (by positivity)
+  let e : Her (cut (cut R η) η) := ⟨t, ht⟩
+  obtain ⟨S⟩ := hp.orthogonalSlots (cut_nonneg R η) 2 hη
+  have hcut : cut R η ∈ Her k := Her_mono_of_mem hRk (cut_mem_Her hR η)
+  have htk : t ∈ Her k := Her_mono_of_mem hRk
+    (Her_mono_of_mem (cut_mem_Her hR (2*η)) (ramp_mem_Her_cut hR (by positivity)))
+  refine ⟨fun i => S.carrier i e, ?_, ?_, ?_, (fun i j => S.outer i j e e), ?_⟩
+  · intro i
+    rw [S.norm_carrier]
+    exact norm_ramp_le_one R (by linarith)
+  · intro i
+    exact carrier_mem_Her S hcut i e htk
+  · intro i j
+    rw [S.inner, (IsSelfAdjoint.of_nonneg (ramp_nonneg R (by linarith : 2*η ≤ 4*η))).star_eq]
+  · intro B _ π hnorm i
+    let : PartialOrder B := CStarAlgebra.spectralOrder B
+    let : StarOrderedRing B := CStarAlgebra.spectralOrderedRing B
+    rw [S.represented_norm]
+    change ‖π (ramp R (2*η) (4*η))‖ = 1
+    rw [map_ramp π hR (by positivity)]
+    exact norm_ramp_eq_one (map_nonneg π hR) (by positivity) (by linarith) hnorm
+
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
+
+def firstSandwich (U V : A) (η : ℝ) (E : Finset A) : A :=
+  cut U η * (∑ w ∈ E, w * V * star w) * cut U η
+
+lemma firstSandwich_nonneg {U V : A} (hV : 0 ≤ V) (η : ℝ) (E : Finset A) :
+    0 ≤ firstSandwich U V η E := by
+  have hsum : 0 ≤ ∑ w ∈ E, w * V * star w :=
+    Finset.sum_nonneg (fun w _ => star_right_conjugate_nonneg hV w)
+  simpa only [firstSandwich, IsSelfAdjoint.of_nonneg (cut_nonneg U η) |>.star_eq] using
+    star_right_conjugate_nonneg hsum (cut U η)
+
+lemma firstSandwich_mem (U V : A) (η : ℝ) (E : Finset A) :
+    firstSandwich U V η E ∈ Her (cut U η) := by
+  simpa only [firstSandwich, IsSelfAdjoint.of_nonneg (cut_nonneg U η) |>.star_eq] using
+    sandwich_mem_Her (cut U η) (∑ w ∈ E, w * V * star w)
+
+lemma firstSandwich_two_cuntzLE {U V : A} (hV : ProperlyInfinite V)
+    (η : ℝ) (E : Finset A) :
+    FiniteCuntzLE (diagonalCorner 2 (firstSandwich U V η E)) (scalarCorner V) := by
+  have heq : firstSandwich U V η E =
+      ∑ w ∈ E, star (star w * cut U η) * V * (star w * cut U η) := by
+    simp only [firstSandwich, Finset.mul_sum, Finset.sum_mul, star_mul, star_star,
+      IsSelfAdjoint.of_nonneg (cut_nonneg U η) |>.star_eq]
+    apply Finset.sum_congr rfl
+    intro w _
+    noncomm_ring
+  rw [heq]
+  exact finsetSum_cuntzLE hV E _
+
+lemma norm_ramp_bound {d : A} (hd : 0 ≤ d) {η h : ℝ} (hη : 0 < η)
+    (hh0 : 0 ≤ h) (hh : h < 1) (hbound : ramp d η (2*η) ≤ h • (1 : A)) : ‖d‖ < 2*η := by
+  by_contra! hnorm
+  have hone := norm_ramp_eq_one hd hη.le (by linarith) hnorm
+  have hD := ramp_nonneg d (by linarith : η ≤ 2*η)
+  have hnle : ‖ramp d η (2*η)‖ ≤ h := by
+    exact (CStarAlgebra.norm_le_iff_le_algebraMap _ hh0 hD).mpr (by
+      simpa only [Algebra.algebraMap_eq_smul_one] using hbound)
+  linarith
+
+end MainGap
+
+namespace MainGap
+
+variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
+
+def scalingComplement (H : A) : A := CFC.sqrt (1 - H * H)
+
+def scalingIsometry (H r : A) : A := r + scalingComplement H
+
+def scalingDefect (H r : A) : A := 1 - scalingIsometry H r * star (scalingIsometry H r)
+
+lemma complement_nonneg {H : A} (hH : IsSelfAdjoint H) (hnorm : ‖H‖ ≤ 1) :
+    0 ≤ 1 - H * H := by
+  apply sub_nonneg.mpr
+  apply (CStarAlgebra.norm_le_one_iff_of_nonneg (H * H) ?_).mp
+  · calc
+      ‖H * H‖ = ‖H‖ ^ 2 := hH.norm_mul_self
+      _ ≤ 1 := (sq_le_one_iff₀ (norm_nonneg H)).mpr hnorm
+  · simpa only [hH.star_eq] using star_mul_self_nonneg H
+
+lemma scalingComplement_mul_self {H : A} (hH : IsSelfAdjoint H) (hnorm : ‖H‖ ≤ 1) :
+    scalingComplement H * scalingComplement H = 1 - H * H :=
+  CFC.sqrt_mul_sqrt_self _ (complement_nonneg hH hnorm)
+
+lemma scalingComplement_selfAdjoint (H : A) : IsSelfAdjoint (scalingComplement H) :=
+  IsSelfAdjoint.of_nonneg (CFC.sqrt_nonneg _)
+
+lemma scalingComplement_mul_eq_zero {H r : A} (hH : IsSelfAdjoint H)
+    (hnorm : ‖H‖ ≤ 1) (hHr : H * r = r) : scalingComplement H * r = 0 := by
+  apply (CStarRing.star_mul_self_eq_zero_iff _).mp
+  rw [star_mul, (scalingComplement_selfAdjoint H).star_eq]
+  calc
+    star r * scalingComplement H * (scalingComplement H * r) =
+        star r * (scalingComplement H * scalingComplement H) * r := by noncomm_ring
+    _ = star r * (1 - H * H) * r := by rw [scalingComplement_mul_self hH hnorm]
+    _ = 0 := by simp only [mul_sub, sub_mul, mul_one, mul_assoc, hHr, sub_self]
+
+lemma scalingIsometry_star_mul_self {H r : A} (hH : IsSelfAdjoint H)
+    (hnorm : ‖H‖ ≤ 1) (hHr : H * r = r) (hrr : star r * r = H * H) :
+    star (scalingIsometry H r) * scalingIsometry H r = 1 := by
+  have hbr := scalingComplement_mul_eq_zero hH hnorm hHr
+  have hrb : star r * scalingComplement H = 0 := by
+    simpa only [star_mul, star_zero, (scalingComplement_selfAdjoint H).star_eq] using
+      congrArg star hbr
+  simp only [scalingIsometry, star_add, (scalingComplement_selfAdjoint H).star_eq,
+    add_mul, mul_add, hbr, hrb, hrr, scalingComplement_mul_self hH hnorm]
+  noncomm_ring
+
+lemma scalingDefect_projection {H r : A} (hH : IsSelfAdjoint H)
+    (hnorm : ‖H‖ ≤ 1) (hHr : H * r = r) (hrr : star r * r = H * H) :
+    IsStarProjection (scalingDefect H r) := by
+  apply IsStarProjection.one_sub
+  constructor
+  · change (scalingIsometry H r * star (scalingIsometry H r)) *
+        (scalingIsometry H r * star (scalingIsometry H r)) =
+      scalingIsometry H r * star (scalingIsometry H r)
+    rw [mul_assoc, ← mul_assoc (star (scalingIsometry H r)),
+      scalingIsometry_star_mul_self hH hnorm hHr hrr, one_mul]
+  · exact IsSelfAdjoint.mul_star_self _
+
+lemma scalingDefect_fixes_second {H r₁ r₂ : A} (hH : IsSelfAdjoint H)
+    (hnorm : ‖H‖ ≤ 1) (hHr₂ : H * r₂ = r₂) (hcross : star r₁ * r₂ = 0) :
+    scalingDefect H r₁ * r₂ = r₂ := by
+  have hvr : star (scalingIsometry H r₁) * r₂ = 0 := by
+    simp only [scalingIsometry, star_add, add_mul,
+      (scalingComplement_selfAdjoint H).star_eq, hcross,
+      scalingComplement_mul_eq_zero hH hnorm hHr₂, add_zero]
+  simp only [scalingDefect, sub_mul, one_mul, mul_assoc, hvr, mul_zero, sub_zero]
+
+lemma scalingDefect_ne_zero {H r₁ r₂ : A} (hH : IsSelfAdjoint H)
+    (hnorm : ‖H‖ ≤ 1) (hHne : H ≠ 0) (hHr₂ : H * r₂ = r₂)
+    (hcross : star r₁ * r₂ = 0) (hr₂ : star r₂ * r₂ = H * H) :
+    scalingDefect H r₁ ≠ 0 := by
+  intro hP
+  have hr₂zero : r₂ = 0 := by
+    have := scalingDefect_fixes_second hH hnorm hHr₂ hcross
+    simpa only [hP, zero_mul, eq_comm] using this
+  apply hHne
+  apply (CStarRing.star_mul_self_eq_zero_iff H).mp
+  rw [hH.star_eq, ← hr₂, hr₂zero, star_zero, zero_mul]
+
+omit [PartialOrder A] [StarOrderedRing A] in
+lemma last_pair_kills_defect {P B₃ B₄ : A} {h : ℝ} (hh : h ≠ 0)
+    (hPB₄ : P * B₄ = B₄) (hcross : star B₃ * B₄ = 0)
+    (hmod : star B₃ * B₃ = star B₄ * B₄)
+    (hD : (B₃ * star B₃) * P = h • P) : P = 0 := by
+  have hB₄ : h • B₄ = 0 := by
+    calc
+      h • B₄ = (h • P) * B₄ := by rw [smul_mul_assoc, hPB₄]
+      _ = ((B₃ * star B₃) * P) * B₄ := by rw [hD]
+      _ = B₃ * (star B₃ * B₄) := by rw [mul_assoc, hPB₄, mul_assoc]
+      _ = 0 := by rw [hcross, mul_zero]
+  have hB₄zero : B₄ = 0 := (smul_eq_zero.mp hB₄).resolve_left hh
+  have hB₃zero : B₃ = 0 := (CStarRing.star_mul_self_eq_zero_iff B₃).mp (by
+    rw [hmod, hB₄zero, star_zero, zero_mul])
+  have hP : h • P = 0 := by simpa only [hB₃zero, zero_mul] using hD.symm
+  exact (smul_eq_zero.mp hP).resolve_left hh
+
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [CStarAlgebra A]
+local instance : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+def deficiency (d : A) : A := cfc (fun t : ℝ => max ((1/2 : ℝ)-t) 0) d
+
+def firstX (X : A) : A := cut X (1/16)
+def firstV (X : A) : A := cut X (1/8)
+def firstU (X B : A) : A := firstX X * deficiency (B * star B) *
+  deficiency (B * star B) * firstX X
+
+def firstH (X : A) : A := ramp X (3/32) (1/8)
+def firstK (X : A) : A := ramp X (3/64) (1/16)
+def firstR (X B : A) : A := (Real.sqrt 2) • (star B * firstH X)
+def prospectiveDefect (X B : A) : A :=
+  ramp (firstK X * scalingDefect (firstH X) (firstR X B) * firstK X) 0 1
+
+def lastX (X B : A) : A := cut (prospectiveDefect X B) (1/2)
+def lastR (X B₁ B₃ : A) : A := lastX X B₁ * deficiency (B₃ * star B₃) *
+  deficiency (B₃ * star B₃) * lastX X B₁
+
+def fourHer (X : A) : NonUnitalStarSubalgebra ℂ A := Her (cut X (1/32))
+
+lemma deficiency_nonneg (d : A) : 0 ≤ deficiency d := cfc_nonneg (fun _ _ => le_max_right _ _)
+lemma deficiency_selfAdjoint (d : A) : IsSelfAdjoint (deficiency d) := IsSelfAdjoint.cfc
+
+lemma squareSandwich_nonneg {x : A} (hx : IsSelfAdjoint x) (Q : A) (hQ : IsSelfAdjoint Q) :
+    0 ≤ x * Q * Q * x := by
+  have := star_mul_self_nonneg (Q*x)
+  simpa only [star_mul, hx.star_eq, hQ.star_eq, mul_assoc] using this
+
+lemma squareSandwich_mem {x : A} (hx : IsSelfAdjoint x) (Q : A) :
+    x * Q * Q * x ∈ Her x := by
+  simpa only [hx.star_eq, mul_assoc] using sandwich_mem_Her x (Q*Q)
+
+lemma cut_mem_cutHer {X : A} (hX : 0 ≤ X) {l u : ℝ} (hl : 0 ≤ l) (hlu : l ≤ u) :
+    cut X u ∈ Her (cut X l) := by
+  have heq : cut X u = cut (cut X l) (u-l) := by
+    rw [cut_cut hX hl (sub_nonneg.mpr hlu)]
+    congr 1
+    ring
+  rw [heq]
+  exact cut_mem_Her (cut_nonneg X l) _
+
+lemma firstX_mem {X : A} (hX : 0 ≤ X) : firstX X ∈ fourHer X :=
+  cut_mem_cutHer hX (by norm_num) (by norm_num)
+lemma firstV_mem {X : A} (hX : 0 ≤ X) : firstV X ∈ fourHer X :=
+  cut_mem_cutHer hX (by norm_num) (by norm_num)
+lemma firstU_nonneg (X B : A) : 0 ≤ firstU X B :=
+  squareSandwich_nonneg (.of_nonneg (cut_nonneg X _)) _ (deficiency_selfAdjoint _)
+lemma firstU_mem {X : A} (hX : 0 ≤ X) (B : A) : firstU X B ∈ fourHer X :=
+  Her_mono_of_mem (firstX_mem hX) (squareSandwich_mem (.of_nonneg (cut_nonneg X _)) _)
+
+lemma firstK_mem {X : A} (hX : 0 ≤ X) : firstK X ∈ fourHer X := by
+  exact Her_mono_of_mem (cut_mem_cutHer hX (by norm_num : (0:ℝ) ≤ 1/32)
+    (by norm_num : (1/32:ℝ) ≤ 3/64)) (ramp_mem_Her_cut hX (by norm_num))
+
+lemma prospectiveDefect_nonneg (X B : A) : 0 ≤ prospectiveDefect X B :=
+  ramp_nonneg _ (by norm_num)
+lemma prospectiveDefect_norm (X B : A) : ‖prospectiveDefect X B‖ ≤ 1 :=
+  norm_ramp_le_one _ (by norm_num)
+lemma prospectiveDefect_mem {X : A} (hX : 0 ≤ X) (B : A) :
+    prospectiveDefect X B ∈ fourHer X := by
+  change cfcₙ _ _ ∈ Her (cut X (1/32))
+  apply cfcₙ_mem (𝕜' := ℂ)
+  have h := Her_sandwich (firstK_mem hX) (scalingDefect (firstH X) (firstR X B))
+  simpa only [firstK, IsSelfAdjoint.of_nonneg (ramp_nonneg X (by norm_num : (3/64:ℝ) ≤ 1/16)) |>.star_eq] using h
+
+lemma lastX_nonneg (X B : A) : 0 ≤ lastX X B := cut_nonneg _ _
+lemma lastX_mem {X : A} (hX : 0 ≤ X) (B : A) : lastX X B ∈ fourHer X :=
+  Her_mono_of_mem (prospectiveDefect_mem hX B) (cut_mem_Her (prospectiveDefect_nonneg X B) _)
+lemma lastR_nonneg (X B₁ B₃ : A) : 0 ≤ lastR X B₁ B₃ :=
+  squareSandwich_nonneg (.of_nonneg (lastX_nonneg X B₁)) _ (deficiency_selfAdjoint _)
+lemma lastR_mem {X : A} (hX : 0 ≤ X) (B₁ B₃ : A) : lastR X B₁ B₃ ∈ fourHer X :=
+  Her_mono_of_mem (lastX_mem hX B₁) (squareSandwich_mem (.of_nonneg (lastX_nonneg X B₁)) _)
+
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/ClosedIdeal.lean

@@ -0,0 +1,83 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+variable {A : Type*} [CStarAlgebra A]
+
+def idealWords (v : A) : Set A := { z | ∃ x y : A, z = x * v * y }
+def idealSpan (v : A) : Submodule ℂ A := Submodule.span ℂ (idealWords v)
+
+lemma idealSpan_word (v x y : A) : x * v * y ∈ idealSpan v :=
+  Submodule.subset_span ⟨x, y, rfl⟩
+
+lemma idealSpan_left {v z : A} (hz : z ∈ idealSpan v) (a : A) : a * z ∈ idealSpan v := by
+  induction hz using Submodule.span_induction with
+  | mem z hz =>
+    obtain ⟨x, y, rfl⟩ := hz
+    simpa only [mul_assoc] using idealSpan_word v (a * x) y
+  | zero => simp
+  | add x y hx hy ihx ihy => simpa only [mul_add] using (idealSpan v).add_mem ihx ihy
+  | smul c x hx ih => simpa only [mul_smul_comm] using (idealSpan v).smul_mem c ih
+
+lemma idealSpan_right {v z : A} (hz : z ∈ idealSpan v) (a : A) : z * a ∈ idealSpan v := by
+  induction hz using Submodule.span_induction with
+  | mem z hz =>
+    obtain ⟨x, y, rfl⟩ := hz
+    simpa only [mul_assoc] using idealSpan_word v x (y * a)
+  | zero => simp
+  | add x y hx hy ihx ihy => simpa only [add_mul] using (idealSpan v).add_mem ihx ihy
+  | smul c x hx ih => simpa only [smul_mul_assoc] using (idealSpan v).smul_mem c ih
+
+lemma idealSpan_star {v z : A} (hv : IsSelfAdjoint v) (hz : z ∈ idealSpan v) :
+    star z ∈ idealSpan v := by
+  induction hz using Submodule.span_induction with
+  | mem z hz =>
+    obtain ⟨x, y, rfl⟩ := hz
+    simpa only [star_mul, hv.star_eq, mul_assoc] using idealSpan_word v (star y) (star x)
+  | zero => simp
+  | add x y hx hy ihx ihy => simpa only [star_add] using (idealSpan v).add_mem ihx ihy
+  | smul c x hx ih => simpa only [star_smul] using (idealSpan v).smul_mem (star c) ih
+
+def idealAlgebra (v : A) (hv : IsSelfAdjoint v) : NonUnitalStarSubalgebra ℂ A where
+  carrier := idealSpan v
+  zero_mem' := (idealSpan v).zero_mem
+  add_mem' := (idealSpan v).add_mem
+  smul_mem' := fun c _ hz => (idealSpan v).smul_mem c hz
+  mul_mem' := fun _ hy => idealSpan_left hy _
+  star_mem' := idealSpan_star hv
+
+def closedIdeal (v : A) (hv : IsSelfAdjoint v) : NonUnitalStarSubalgebra ℂ A :=
+  (idealAlgebra v hv).topologicalClosure
+
+lemma closedIdeal_closed (v : A) (hv : IsSelfAdjoint v) :
+    IsClosed (closedIdeal v hv : Set A) := isClosed_closure
+
+instance closedIdeal_complete (v : A) (hv : IsSelfAdjoint v) :
+    CompleteSpace (closedIdeal v hv) := (closedIdeal_closed v hv).completeSpace_coe
+
+lemma closedIdeal_word (v : A) (hv : IsSelfAdjoint v) (x y : A) :
+    x * v * y ∈ closedIdeal v hv := subset_closure (idealSpan_word v x y)
+
+lemma self_mem_closedIdeal (v : A) (hv : IsSelfAdjoint v) : v ∈ closedIdeal v hv := by
+  simpa using closedIdeal_word v hv 1 1
+
+lemma closedIdeal_left {v z : A} (hv : IsSelfAdjoint v) (hz : z ∈ closedIdeal v hv) (a : A) :
+    a * z ∈ closedIdeal v hv := by
+  refine (closedIdeal_closed v hv).preimage (continuous_const.mul continuous_id)
+    |>.closure_subset_iff.mpr (fun x hx => subset_closure (idealSpan_left hx a)) hz
+
+lemma closedIdeal_right {v z : A} (hv : IsSelfAdjoint v) (hz : z ∈ closedIdeal v hv) (a : A) :
+    z * a ∈ closedIdeal v hv := by
+  refine (closedIdeal_closed v hv).preimage (continuous_id.mul continuous_const)
+    |>.closure_subset_iff.mpr (fun x hx => subset_closure (idealSpan_right hx a)) hz
+
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Comparison.lean

@@ -0,0 +1,301 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Hereditary
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+
+local instance positivityOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance positivityStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+def FiniteCuntzLE {m n : ℕ} (d : CStarMatrix (Fin n) (Fin n) A)
+    (v : CStarMatrix (Fin m) (Fin m) A) : Prop :=
+  ∃ r : ℕ → CStarMatrix (Fin m) (Fin n) A,
+    Tendsto (fun j => (r j).conjTranspose * v * r j) atTop (𝓝 d)
+
+def scalarCorner (h : A) : CStarMatrix (Fin 1) (Fin 1) A :=
+  CStarMatrix.ofMatrix (fun _ _ => h)
+
+def doubleCorner (h : A) : CStarMatrix (Fin 2) (Fin 2) A :=
+  CStarMatrix.ofMatrix (Matrix.diagonal (fun _ => h))
+
+def ProperlyInfinite (h : A) : Prop :=
+  FiniteCuntzLE (doubleCorner h) (scalarCorner h)
+
+def PropertyP (A : Type*) [NonUnitalCStarAlgebra A] : Prop :=
+  ∀ h : A, 0 ≤ h → ProperlyInfinite h
+
+def Diagonalization (a b c : A) (ε : ℝ) : Prop :=
+  ∃ s t : A,
+    ‖star s * a * s - a‖ < ε ∧
+    ‖star t * b * t - b‖ < ε ∧
+    ‖star s * c * t‖ < ε
+
+def UnrestrictedDiagonalization (A : Type*) [NonUnitalCStarAlgebra A] : Prop :=
+  ∀ a b : A, 0 ≤ a → 0 ≤ b → ∀ c : A, ∀ ε : ℝ, 0 < ε →
+    Diagonalization a b c ε
+
+def StronglyPurelyInfinite (A : Type*) [NonUnitalCStarAlgebra A] : Prop :=
+  ∀ x y : A, 0 ≤ x → 0 ≤ y → ∀ ε : ℝ, 0 < ε →
+    Diagonalization (x * x) (y * y) (x * y) ε
+
+lemma matrix_mul_assoc {l m n k : ℕ} (x : CStarMatrix (Fin l) (Fin m) A)
+    (y : CStarMatrix (Fin m) (Fin n) A) (z : CStarMatrix (Fin n) (Fin k) A) :
+    (x * y) * z = x * (y * z) := Matrix.mul_assoc x y z
+
+lemma matrix_star_mul {l m n : ℕ} (x : CStarMatrix (Fin l) (Fin m) A)
+    (y : CStarMatrix (Fin m) (Fin n) A) :
+    (x * y).conjTranspose = y.conjTranspose * x.conjTranspose :=
+  Matrix.conjTranspose_mul x y
+
+lemma continuous_matrix_mul {X : Type*} [TopologicalSpace X] {l m n : ℕ}
+    {x : X → CStarMatrix (Fin l) (Fin m) A} {y : X → CStarMatrix (Fin m) (Fin n) A}
+    (hx : Continuous x) (hy : Continuous y) : Continuous (fun t => x t * y t) :=
+  hx.matrix_mul hy
+
+lemma continuous_matrix_star {X : Type*} [TopologicalSpace X] {l m : ℕ}
+    {x : X → CStarMatrix (Fin l) (Fin m) A} (hx : Continuous x) :
+    Continuous (fun t => (x t).conjTranspose) := by
+  change Continuous (fun t => Matrix.conjTranspose (x t))
+  fun_prop
+
+lemma finiteCuntzLE_iff_closure {m n : ℕ} (d : CStarMatrix (Fin n) (Fin n) A)
+    (v : CStarMatrix (Fin m) (Fin m) A) :
+    FiniteCuntzLE d v ↔ d ∈ closure (Set.range
+      (fun r : CStarMatrix (Fin m) (Fin n) A => r.conjTranspose * v * r)) := by
+  rw [mem_closure_iff_seq_limit]
+  constructor
+  · rintro ⟨r, hr⟩
+    exact ⟨_, fun j => ⟨r j, rfl⟩, hr⟩
+  · rintro ⟨x, hx, ht⟩
+    choose r hr using hx
+    exact ⟨r, by simpa only [hr] using ht⟩
+
+lemma FiniteCuntzLE.exists_approx {m n : ℕ} {d : CStarMatrix (Fin n) (Fin n) A}
+    {v : CStarMatrix (Fin m) (Fin m) A} (h : FiniteCuntzLE d v)
+    {ε : ℝ} (hε : 0 < ε) :
+    ∃ r : CStarMatrix (Fin m) (Fin n) A, ‖d - r.conjTranspose * v * r‖ < ε := by
+  rw [finiteCuntzLE_iff_closure, Metric.mem_closure_iff] at h
+  obtain ⟨x, ⟨r, rfl⟩, hr⟩ := h ε hε
+  exact ⟨r, by simpa only [dist_eq_norm] using hr⟩
+
+lemma finiteCuntzLE_of_forall_approx {m n : ℕ} {d : CStarMatrix (Fin n) (Fin n) A}
+    {v : CStarMatrix (Fin m) (Fin m) A}
+    (h : ∀ ε > 0, ∃ r : CStarMatrix (Fin m) (Fin n) A,
+      ‖d - r.conjTranspose * v * r‖ < ε) : FiniteCuntzLE d v := by
+  rw [finiteCuntzLE_iff_closure, Metric.mem_closure_iff]
+  intro ε hε
+  obtain ⟨r, hr⟩ := h ε hε
+  exact ⟨_, ⟨r, rfl⟩, by simpa only [dist_eq_norm] using hr⟩
+
+lemma FiniteCuntzLE.conjugate {l m n : ℕ} {d : CStarMatrix (Fin n) (Fin n) A}
+    {v : CStarMatrix (Fin m) (Fin m) A} (hdv : FiniteCuntzLE d v)
+    (x : CStarMatrix (Fin n) (Fin l) A) :
+    FiniteCuntzLE (x.conjTranspose * d * x) v := by
+  obtain ⟨r, hr⟩ := hdv
+  refine ⟨fun j => r j * x, ?_⟩
+  have hc : Continuous (fun d : CStarMatrix (Fin n) (Fin n) A =>
+      x.conjTranspose * d * x) :=
+    continuous_matrix_mul (continuous_matrix_mul continuous_const continuous_id) continuous_const
+  convert hc.continuousAt.tendsto.comp hr using 1
+  ext j
+  rw [matrix_star_mul]
+  simp only [Function.comp_apply, matrix_mul_assoc]
+
+lemma FiniteCuntzLE.trans {l m n : ℕ} {d : CStarMatrix (Fin n) (Fin n) A}
+    {v : CStarMatrix (Fin m) (Fin m) A} {w : CStarMatrix (Fin l) (Fin l) A}
+    (hdv : FiniteCuntzLE d v) (hvw : FiniteCuntzLE v w) : FiniteCuntzLE d w := by
+  rw [finiteCuntzLE_iff_closure] at hdv ⊢
+  apply closure_minimal _ isClosed_closure hdv
+  rintro _ ⟨x, rfl⟩
+  exact (finiteCuntzLE_iff_closure _ _).mp (hvw.conjugate x)
+
+lemma isClosed_finiteCuntzLE {m n : ℕ} (v : CStarMatrix (Fin m) (Fin m) A) :
+    IsClosed {d : CStarMatrix (Fin n) (Fin n) A | FiniteCuntzLE d v} := by
+  simp_rw [finiteCuntzLE_iff_closure]
+  exact isClosed_closure
+
+lemma FiniteCuntzLE.of_tendsto {m n : ℕ} {v : CStarMatrix (Fin m) (Fin m) A}
+    {d : ℕ → CStarMatrix (Fin n) (Fin n) A} {u : CStarMatrix (Fin n) (Fin n) A}
+    (hd : ∀ j, FiniteCuntzLE (d j) v) (ht : Tendsto d atTop (𝓝 u)) :
+    FiniteCuntzLE u v := (isClosed_finiteCuntzLE v).mem_of_tendsto ht (Eventually.of_forall hd)
+
+lemma FiniteCuntzLE.refl {n : ℕ} (v : CStarMatrix (Fin n) (Fin n) A) :
+    FiniteCuntzLE v v := by
+  let M := CStarMatrix (Fin n) (Fin n) A
+  let : PartialOrder M := CStarAlgebra.spectralOrder M
+  let : StarOrderedRing M := CStarAlgebra.spectralOrderedRing M
+  have hu := CStarAlgebra.increasingApproximateUnit M
+  apply finiteCuntzLE_of_forall_approx
+  intro ε hε
+  have hl : ∀ᶠ e : M in CStarAlgebra.approximateUnit M, ‖v - v * e‖ < ε / 2 := by
+    have ht := ((tendsto_const_nhds (x := v)).sub (hu.tendsto_mul_left v)).norm
+    simpa only [sub_self, norm_zero] using ht.eventually (Iio_mem_nhds (by simpa only [sub_self, norm_zero] using half_pos hε))
+  have hr : ∀ᶠ e : M in CStarAlgebra.approximateUnit M, ‖v - e * v‖ < ε / 2 := by
+    have ht := ((tendsto_const_nhds (x := v)).sub (hu.tendsto_mul_right v)).norm
+    simpa only [sub_self, norm_zero] using ht.eventually (Iio_mem_nhds (by simpa only [sub_self, norm_zero] using half_pos hε))
+  obtain ⟨e, hesa, hen, hel, her⟩ :=
+    (hu.eventually_star_eq.and (hu.eventually_norm.and (hl.and hr))).exists
+  refine ⟨e, ?_⟩
+  change ‖v - star e * v * e‖ < ε
+  rw [hesa]
+  calc
+    ‖v - e * v * e‖ = ‖(v - e * v) + e * (v - v * e)‖ := by rw [mul_sub, ← mul_assoc]; congr 1; abel
+    _ ≤ ‖v - e * v‖ + ‖e‖ * ‖v - v * e‖ :=
+      (norm_add_le _ _).trans (add_le_add_right (norm_mul_le _ _) _)
+    _ ≤ ‖v - e * v‖ + ‖v - v * e‖ := by nlinarith [norm_nonneg (v - v * e)]
+    _ < ε := by linarith
+
+def matrixBlock {m n p q : ℕ} (x : CStarMatrix (Fin m) (Fin n) A)
+    (y : CStarMatrix (Fin p) (Fin q) A) : CStarMatrix (Fin (m+p)) (Fin (n+q)) A :=
+  CStarMatrix.ofMatrix ((Matrix.fromBlocks (CStarMatrix.ofMatrix.symm x) 0 0 (CStarMatrix.ofMatrix.symm y)).submatrix
+    finSumFinEquiv.symm finSumFinEquiv.symm)
+
+lemma matrixBlock_mul {m n p q r s : ℕ}
+    (x : CStarMatrix (Fin m) (Fin n) A) (y : CStarMatrix (Fin p) (Fin q) A)
+    (u : CStarMatrix (Fin n) (Fin r) A) (v : CStarMatrix (Fin q) (Fin s) A) :
+    matrixBlock x y * matrixBlock u v = matrixBlock (x * u) (y * v) := by
+  apply CStarMatrix.ofMatrix.symm.injective
+  change (Matrix.fromBlocks (CStarMatrix.ofMatrix.symm x) 0 0 (CStarMatrix.ofMatrix.symm y)).submatrix
+      finSumFinEquiv.symm finSumFinEquiv.symm *
+    (Matrix.fromBlocks (CStarMatrix.ofMatrix.symm u) 0 0 (CStarMatrix.ofMatrix.symm v)).submatrix
+      finSumFinEquiv.symm finSumFinEquiv.symm =
+    (Matrix.fromBlocks (CStarMatrix.ofMatrix.symm x * CStarMatrix.ofMatrix.symm u) 0 0
+      (CStarMatrix.ofMatrix.symm y * CStarMatrix.ofMatrix.symm v)).submatrix _ _
+  rw [Matrix.submatrix_mul_equiv, Matrix.fromBlocks_multiply]
+  simp only [Matrix.zero_mul, Matrix.mul_zero, add_zero, zero_add]
+
+lemma matrixBlock_star {m n p q : ℕ}
+    (x : CStarMatrix (Fin m) (Fin n) A) (y : CStarMatrix (Fin p) (Fin q) A) :
+    (matrixBlock x y).conjTranspose = matrixBlock x.conjTranspose y.conjTranspose := by
+  apply CStarMatrix.ext
+  intro i j
+  change star (Matrix.fromBlocks (CStarMatrix.ofMatrix.symm x) 0 0 (CStarMatrix.ofMatrix.symm y) (finSumFinEquiv.symm j) (finSumFinEquiv.symm i)) = _
+  generalize hi : finSumFinEquiv.symm i = i'
+  generalize hj : finSumFinEquiv.symm j = j'
+  cases i' <;> cases j' <;> simp [matrixBlock, Matrix.fromBlocks, Matrix.submatrix, hi, hj]
+
+lemma continuous_matrixBlock {X : Type*} [TopologicalSpace X] {m n p q : ℕ}
+    {x : X → CStarMatrix (Fin m) (Fin n) A} {y : X → CStarMatrix (Fin p) (Fin q) A}
+    (hx : Continuous x) (hy : Continuous y) : Continuous (fun t => matrixBlock (x t) (y t)) := by
+  change Continuous (fun t => (Matrix.fromBlocks (CStarMatrix.ofMatrix.symm (x t)) 0 0
+      (CStarMatrix.ofMatrix.symm (y t))).submatrix finSumFinEquiv.symm finSumFinEquiv.symm)
+  apply continuous_pi
+  intro i
+  apply continuous_pi
+  intro j
+  change Continuous (fun t => Matrix.fromBlocks (CStarMatrix.ofMatrix.symm (x t)) 0 0
+      (CStarMatrix.ofMatrix.symm (y t)) (finSumFinEquiv.symm i) (finSumFinEquiv.symm j))
+  cases finSumFinEquiv.symm i with
+  | inl i' =>
+    cases finSumFinEquiv.symm j with
+    | inl j' =>
+      change Continuous (fun t => CStarMatrix.ofMatrix.symm (x t) i' j')
+      exact (continuous_apply j').comp ((continuous_apply i').comp hx)
+    | inr j' => exact continuous_const
+  | inr i' =>
+    cases finSumFinEquiv.symm j with
+    | inl j' => exact continuous_const
+    | inr j' =>
+      change Continuous (fun t => CStarMatrix.ofMatrix.symm (y t) i' j')
+      exact (continuous_apply j').comp ((continuous_apply i').comp hy)
+
+lemma tendsto_matrixBlock {X : Type*} {f : Filter X} {m n p q : ℕ}
+    {x : X → CStarMatrix (Fin m) (Fin n) A} {y : X → CStarMatrix (Fin p) (Fin q) A}
+    {u : CStarMatrix (Fin m) (Fin n) A} {v : CStarMatrix (Fin p) (Fin q) A}
+    (hx : Tendsto x f (𝓝 u)) (hy : Tendsto y f (𝓝 v)) :
+    Tendsto (fun t => matrixBlock (x t) (y t)) f (𝓝 (matrixBlock u v)) := by
+  change Tendsto (fun t => CStarMatrix.ofMatrix.symm (matrixBlock (x t) (y t))) f
+    (𝓝 (CStarMatrix.ofMatrix.symm (matrixBlock u v)))
+  apply tendsto_pi_nhds.mpr
+  intro i
+  apply tendsto_pi_nhds.mpr
+  intro j
+  change Tendsto (fun t => Matrix.fromBlocks (CStarMatrix.ofMatrix.symm (x t)) 0 0
+      (CStarMatrix.ofMatrix.symm (y t)) (finSumFinEquiv.symm i) (finSumFinEquiv.symm j)) f
+    (𝓝 (Matrix.fromBlocks (CStarMatrix.ofMatrix.symm u) 0 0
+      (CStarMatrix.ofMatrix.symm v) (finSumFinEquiv.symm i) (finSumFinEquiv.symm j)))
+  cases finSumFinEquiv.symm i with
+  | inl i' =>
+    cases finSumFinEquiv.symm j with
+    | inl j' => exact (hx.apply_nhds i').apply_nhds j'
+    | inr j' => exact tendsto_const_nhds
+  | inr i' =>
+    cases finSumFinEquiv.symm j with
+    | inl j' => exact tendsto_const_nhds
+    | inr j' => exact (hy.apply_nhds i').apply_nhds j'
+
+lemma matrixBlock_conjugate {m n p q : ℕ}
+    (r : CStarMatrix (Fin m) (Fin n) A) (s : CStarMatrix (Fin p) (Fin q) A)
+    (v : CStarMatrix (Fin m) (Fin m) A) (w : CStarMatrix (Fin p) (Fin p) A) :
+    (matrixBlock r s).conjTranspose * matrixBlock v w * matrixBlock r s =
+      matrixBlock (r.conjTranspose * v * r) (s.conjTranspose * w * s) := by
+  rw [matrixBlock_star, matrixBlock_mul, matrixBlock_mul]
+
+lemma FiniteCuntzLE.block {m n p q : ℕ}
+    {d : CStarMatrix (Fin n) (Fin n) A} {v : CStarMatrix (Fin m) (Fin m) A}
+    {d' : CStarMatrix (Fin q) (Fin q) A} {v' : CStarMatrix (Fin p) (Fin p) A}
+    (h : FiniteCuntzLE d v) (h' : FiniteCuntzLE d' v') :
+    FiniteCuntzLE (matrixBlock d d') (matrixBlock v v') := by
+  obtain ⟨r, hr⟩ := h
+  obtain ⟨s, hs⟩ := h'
+  refine ⟨fun j => matrixBlock (r j) (s j), ?_⟩
+  have heq : (fun j => (matrixBlock (r j) (s j)).conjTranspose *
+      matrixBlock v v' * matrixBlock (r j) (s j)) =
+      (fun j => matrixBlock ((r j).conjTranspose * v * r j)
+        ((s j).conjTranspose * v' * s j)) := by
+    funext j
+    exact matrixBlock_conjugate (r j) (s j) v v'
+  rw [heq]
+  exact tendsto_matrixBlock hr hs
+
+def diagonalCorner (n : ℕ) (h : A) : CStarMatrix (Fin n) (Fin n) A :=
+  CStarMatrix.ofMatrix (Matrix.diagonal (fun _ => h))
+
+lemma matrixBlock_diagonal (n m : ℕ) (h : A) :
+    matrixBlock (diagonalCorner n h) (diagonalCorner m h) = diagonalCorner (n+m) h := by
+  apply CStarMatrix.ext
+  intro i j
+  change (Matrix.fromBlocks (Matrix.diagonal (fun _ => h)) 0 0
+    (Matrix.diagonal (fun _ => h))).submatrix _ _ i j = _
+  rw [Matrix.fromBlocks_diagonal]
+  simp only [Matrix.submatrix_apply, Matrix.diagonal_apply, diagonalCorner,
+    CStarMatrix.ofMatrix_apply, Equiv.apply_eq_iff_eq]
+  split_ifs with hij
+  · cases finSumFinEquiv.symm i <;> rfl
+  · rfl
+
+lemma diagonalCorner_one (h : A) : diagonalCorner 1 h = scalarCorner h := by
+  ext i j
+  have hij : i = j := Subsingleton.elim _ _
+  change Matrix.diagonal (fun _ => h) i j = h
+  simp [Matrix.diagonal, hij]
+
+lemma ProperlyInfinite.finite_copies {h : A} (hh : ProperlyInfinite h) (n : ℕ) :
+    FiniteCuntzLE (diagonalCorner n h) (scalarCorner h) := by
+  induction n with
+  | zero =>
+    refine ⟨fun _ => 0, ?_⟩
+    have heq : (fun _ : ℕ => (0 : CStarMatrix (Fin 1) (Fin 0) A).conjTranspose *
+        scalarCorner h * (0 : CStarMatrix (Fin 1) (Fin 0) A)) = fun _ => diagonalCorner 0 h := by
+      funext j
+      apply CStarMatrix.ext
+      intro i
+      exact Fin.elim0 i
+    rw [heq]
+    exact tendsto_const_nhds
+  | succ n hn =>
+    have hblock := hn.block (FiniteCuntzLE.refl (scalarCorner h))
+    rw [← diagonalCorner_one h, matrixBlock_diagonal, matrixBlock_diagonal] at hblock
+    exact hblock.trans hh
+
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Compression.lean

@@ -0,0 +1,271 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Nonvanishing
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
+
+def cutInverseFn (δ t : ℝ) : ℝ := t/(max δ t)^2
+
+lemma continuous_cutInverseFn {δ : ℝ} (hδ : 0 < δ) : Continuous (cutInverseFn δ) := by
+  exact continuous_id.div (((continuous_const.max continuous_id).pow 2))
+    (fun t => pow_ne_zero _ (ne_of_gt (hδ.trans_le (le_max_left _ _))))
+
+lemma cutInverseFn_zero (δ : ℝ) : cutInverseFn δ 0=0 := by simp [cutInverseFn]
+
+def cutInverse (a : A) (δ : ℝ) : A := cfcₙ (cutInverseFn δ) a
+
+lemma cutInverseFn_bound {δ t : ℝ} (hδ : 0 < δ) (ht : 0 ≤ t) :
+    0 ≤ cutInverseFn δ t ∧ cutInverseFn δ t ≤ 1/δ := by
+  refine ⟨div_nonneg ht (sq_nonneg _), ?_⟩
+  by_cases htδ : t ≤ δ
+  · dsimp [cutInverseFn]
+    rw [max_eq_left htδ]
+    apply (div_le_iff₀ (sq_pos_of_pos hδ)).mpr
+    calc
+      t ≤ δ := htδ
+      _ = 1/δ*δ^2 := by field_simp
+  · have htpos : 0 < t := hδ.trans (lt_of_not_ge htδ)
+    have he : cutInverseFn δ t=1/t := by
+      dsimp [cutInverseFn]
+      rw [max_eq_right (le_of_not_ge htδ)]
+      field_simp
+    rw [he]
+    exact one_div_le_one_div_of_le hδ (le_of_not_ge htδ)
+
+lemma norm_cutInverse_le {a : A} (ha : 0 ≤ a) {δ : ℝ} (hδ : 0 < δ) :
+    ‖cutInverse a δ‖ ≤ 1/δ := by
+  apply norm_cfcₙ_le
+  intro t ht
+  have hb := cutInverseFn_bound hδ (quasispectrum_nonneg_of_nonneg a ha t ht)
+  rw [Real.norm_eq_abs, abs_of_nonneg hb.1]
+  exact hb.2
+
+lemma cut_mul_cutInverse {a : A} (ha : 0 ≤ a) {δ : ℝ} (hδ : 0 < δ) :
+    cut a δ * (cutInverse a δ * a) = cut a δ := by
+  have hc : Continuous (fun t : ℝ => max (t-δ) 0) := by fun_prop
+  have h0 : (fun t : ℝ => max (t-δ) 0) 0=0 := by
+    simp [max_eq_right (neg_nonpos.mpr hδ.le)]
+  have he : cutInverse a δ*a = cfcₙ (fun t : ℝ => cutInverseFn δ t*t) a := by
+    simpa only [id_eq, cfcₙ_id' ℝ a ha.isSelfAdjoint, cutInverse] using
+      (cfcₙ_mul (cutInverseFn δ) id a (continuous_cutInverseFn hδ).continuousOn
+        (cutInverseFn_zero δ) continuousOn_id rfl).symm
+  rw [he, cut, ← cfcₙ_mul (fun t : ℝ => max (t-δ) 0)
+    (fun t : ℝ => cutInverseFn δ t*t) a hc.continuousOn h0
+    ((continuous_cutInverseFn hδ).mul continuous_id).continuousOn (by simp [cutInverseFn_zero])]
+  apply cfcₙ_congr
+  intro t _
+  dsimp only
+  by_cases ht : t ≤ δ
+  · rw [max_eq_right (sub_nonpos.mpr ht), zero_mul]
+  · have ht0 : t ≠ 0 := ne_of_gt (hδ.trans (lt_of_not_ge ht))
+    dsimp [cutInverseFn]
+    rw [max_eq_right (le_of_not_ge ht)]
+    field_simp
+
+lemma Her_right_fixed_cutInverse {a x : A} (ha : 0 ≤ a) {δ : ℝ} (hδ : 0 < δ)
+    (hx : x ∈ Her (cut a δ)) : x*(cutInverse a δ*a)=x :=
+  Her_fixed_right (cut_nonneg a δ).isSelfAdjoint (cut_mul_cutInverse ha hδ) hx
+
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
+
+def HerCompression (p q c : A) (κ : ℝ) : Prop :=
+  ∀ x : A, x ∈ Her p → ∀ k : A, k ∈ Her q → ‖x*c*k‖ ≤ κ * ‖x‖ * ‖k‖
+
+lemma cut_sqrt_lower {d : A} (hd : 0 ≤ d) {δ : ℝ} (hδ : 0 ≤ δ) :
+    δ • cut d δ ≤ CFC.sqrt (cut d δ) * d * CFC.sqrt (cut d δ) := by
+  let f : ℝ → ℝ := fun t => max (t-δ) 0
+  have hf : Continuous f := (continuous_id.sub continuous_const).max continuous_const
+  have hf0 : f 0=0 := by simp [f, max_eq_right (neg_nonpos.mpr hδ)]
+  have hl : δ • cut d δ ≤ d * cut d δ := by
+    change δ • cfcₙ f d ≤ d * cfcₙ f d
+    have hu : cfcₙ (fun t => t*f t) d = d*cfcₙ f d := by
+      rw [cfcₙ_mul (fun t : ℝ => t) f d continuousOn_id rfl hf.continuousOn hf0]
+      exact congrArg (fun x => x*cfcₙ f d) (cfcₙ_id ℝ d hd.isSelfAdjoint)
+    rw [← cfcₙ_const_mul δ f d hf.continuousOn hf0, ← hu]
+    apply (cfcₙ_le_iff _ _ d (continuous_const.mul hf).continuousOn
+      (continuous_id.mul hf).continuousOn (by simp [hf0]) (by simp [hf0]) hd.isSelfAdjoint).mpr
+    intro t _
+    by_cases ht : δ ≤ t
+    · exact mul_le_mul_of_nonneg_right ht (le_max_right _ _)
+    · simp [f, max_eq_right (by linarith : t-δ ≤ 0)]
+  have hc : Commute (cut d δ) d := (Commute.refl d).cfcₙ_real f
+  have hs : Commute (CFC.sqrt (cut d δ)) d := hc.cfcₙ_nnreal NNReal.sqrt
+  calc
+    δ • cut d δ ≤ d * cut d δ := hl
+    _ = CFC.sqrt (cut d δ) * d * CFC.sqrt (cut d δ) := by
+      rw [hs.eq, mul_assoc, CFC.sqrt_mul_sqrt_self (cut d δ) (cut_nonneg d δ)]
+
+lemma norm_mul_factor_of_order {m z : A} {r : ℝ} (hr : 0 ≤ r)
+    (h : star (m*z) * (m*z) ≤ r^2 • (star z*z)) (b : A) :
+    ‖m*(z*b)‖ ≤ r*‖z*b‖ := by
+  have ho := star_left_conjugate_le_conjugate h b
+  have ht : star (m*(z*b))*(m*(z*b)) ≤ r^2 • (star (z*b)*(z*b)) := by
+    simpa only [star_mul, mul_assoc, mul_smul_comm, smul_mul_assoc] using ho
+  have hn := CStarAlgebra.norm_le_norm_of_le_of_nonneg ht (star_mul_self_nonneg _)
+  rw [CStarRing.norm_star_mul_self, norm_smul, Real.norm_eq_abs,
+    abs_of_nonneg (sq_nonneg r), CStarRing.norm_star_mul_self] at hn
+  apply (sq_le_sq₀ (norm_nonneg _) (mul_nonneg hr (norm_nonneg _))).mp
+  calc
+    ‖m*(z*b)‖^2 = ‖m*(z*b)‖*‖m*(z*b)‖ := pow_two _
+    _ ≤ r^2 * (‖z*b‖*‖z*b‖) := hn
+    _ = (r*‖z*b‖)^2 := by ring
+
+lemma norm_mul_Her_of_order {m z : A} {r : ℝ} (hr : 0 ≤ r)
+    (h : star (m*z) * (m*z) ≤ r^2 • (star z*z))
+    {k : A} (hk : k ∈ Her (z*star z)) : ‖m*k‖ ≤ r*‖k‖ := by
+  have hc : IsClosed {k : A | ‖m*k‖ ≤ r*‖k‖} := isClosed_le (by fun_prop) (by fun_prop)
+  apply closure_minimal (s := Set.range (fun b : A => (z*star z)*b*star (z*star z))) _ hc hk
+  rintro k ⟨b, rfl⟩
+  change ‖m*((z*star z)*b*star (z*star z))‖ ≤ r*‖(z*star z)*b*star (z*star z)‖
+  simpa only [star_mul, star_star, mul_assoc] using
+    norm_mul_factor_of_order hr h (star z*b*(z*star z))
+
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
+
+lemma conditional_defect_bounds {p y c : A} (hp : 0 ≤ p) (hy : 0 ≤ y)
+    (hpn : ‖p‖ ≤ 1) (hyn : ‖y‖ ≤ 1) (hcn : ‖c‖ ≤ 1) :
+    0 ≤ y*(1-star c*(p*p)*c)*y ∧
+    y*(1-star c*(p*p)*c)*y ≤ y*y ∧ y*y ≤ 1 := by
+  have hm : ‖p*c‖ ≤ 1 := (norm_mul_le _ _).trans (by nlinarith [norm_nonneg p, norm_nonneg c])
+  have hm₁ : star (p*c)*(p*c) ≤ 1 := by
+    apply (CStarAlgebra.norm_le_one_iff_of_nonneg _ (star_mul_self_nonneg _)).mp
+    rw [CStarRing.norm_star_mul_self]
+    nlinarith [norm_nonneg (p*c)]
+  have he : star (p*c)*(p*c) = star c*(p*p)*c := by
+    simp only [star_mul, hp.isSelfAdjoint.star_eq, mul_assoc]
+  have hn : 0 ≤ 1-star c*(p*p)*c := sub_nonneg.mpr (he ▸ hm₁)
+  have hl : 1-star c*(p*p)*c ≤ 1 := sub_le_self _ (he ▸ star_mul_self_nonneg (p*c))
+  refine ⟨?_, ?_, ?_⟩
+  · simpa only [hy.isSelfAdjoint.star_eq] using star_left_conjugate_nonneg hn y
+  · simpa only [hy.isSelfAdjoint.star_eq, mul_one] using star_left_conjugate_le_conjugate hl y
+  · apply (CStarAlgebra.norm_le_one_iff_of_nonneg _ ?_).mp
+    · rw [hy.isSelfAdjoint.norm_mul_self]
+      nlinarith [norm_nonneg y]
+    · simpa only [hy.isSelfAdjoint.star_eq] using star_mul_self_nonneg y
+
+lemma conditional_order_loss {p y c d : A} (hp : 0 ≤ p) (hy : 0 ≤ y)
+    (hd : 0 ≤ d) (_hyd : d ≤ y*y) (hy₂ : y*y ≤ 1)
+    (he : d=y*(1-star c*(p*p)*c)*y) {δ : ℝ} (hδ : 0 ≤ δ) :
+    let z := y*CFC.sqrt (cut d δ)
+    star ((p*c)*z)*((p*c)*z) ≤ (1-δ) • (star z*z) := by
+  let s := CFC.sqrt (cut d δ)
+  let z := y*s
+  have hs : IsSelfAdjoint s := (CFC.sqrt_nonneg _).isSelfAdjoint
+  have hZ : star z*z ≤ cut d δ := by
+    calc
+      star z*z = s*(y*y)*s := by
+        dsimp [z]
+        simp only [star_mul, hs.star_eq, hy.isSelfAdjoint.star_eq, mul_assoc]
+      _ ≤ s*1*s := by
+        simpa only [hs.star_eq] using star_left_conjugate_le_conjugate hy₂ s
+      _ = cut d δ := by
+        rw [mul_one]
+        exact CFC.sqrt_mul_sqrt_self (cut d δ) (cut_nonneg d δ)
+  have hδZ : δ • (star z*z) ≤ s*d*s :=
+    (smul_le_smul_of_nonneg_left hZ hδ).trans (cut_sqrt_lower hd hδ)
+  have hid : star ((p*c)*z)*((p*c)*z) = star z*z-s*d*s := by
+    dsimp [z]
+    rw [he]
+    simp only [star_mul, hp.isSelfAdjoint.star_eq, hy.isSelfAdjoint.star_eq, hs.star_eq]
+    noncomm_ring
+  change star ((p*c)*z)*((p*c)*z) ≤ (1-δ) • (star z*z)
+  rw [hid, sub_smul, one_smul]
+  exact sub_le_sub_left hδZ _
+
+lemma conditional_Her_loss {p y c : A} (hp : 0 ≤ p) (hy : 0 ≤ y)
+    (hpn : ‖p‖ ≤ 1) (hyn : ‖y‖ ≤ 1) (hcn : ‖c‖ ≤ 1)
+    {δ : ℝ} (hδ : 0 ≤ δ) (hδ₁ : δ ≤ 1) :
+    let d := y*(1-star c*(p*p)*c)*y
+    let q := y*cut d δ*y
+    ∀ k : A, k ∈ Her q → ‖p*c*k‖ ≤ Real.sqrt (1-δ) * ‖k‖ := by
+  let d := y*(1-star c*(p*p)*c)*y
+  let z := y*CFC.sqrt (cut d δ)
+  have hb := conditional_defect_bounds hp hy hpn hyn hcn
+  have hh : star ((p*c)*z)*((p*c)*z) ≤ (Real.sqrt (1-δ))^2 • (star z*z) := by
+    rw [Real.sq_sqrt (sub_nonneg.mpr hδ₁)]
+    exact conditional_order_loss hp hy hb.1 hb.2.1 hb.2.2 rfl hδ
+  have hq : z*star z=y*cut d δ*y := by
+    dsimp [z]
+    simp only [star_mul, hy.isSelfAdjoint.star_eq, (CFC.sqrt_nonneg (cut d δ)).isSelfAdjoint.star_eq]
+    calc
+      y*CFC.sqrt (cut d δ)*(CFC.sqrt (cut d δ)*y) =
+          y*(CFC.sqrt (cut d δ)*CFC.sqrt (cut d δ))*y := by simp only [mul_assoc]
+      _ = _ := by rw [CFC.sqrt_mul_sqrt_self (cut d δ) (cut_nonneg d δ)]
+  change ∀ k : A, k ∈ Her (y*cut d δ*y) → ‖p*c*k‖ ≤ Real.sqrt (1-δ)*‖k‖
+  intro k hk
+  exact norm_mul_Her_of_order (Real.sqrt_nonneg _) hh (hq.symm ▸ hk)
+
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
+
+lemma conditional_q_zero {p y c : A} (hp : 0 ≤ p) (hy : 0 ≤ y)
+    (hpn : ‖p‖ ≤ 1) (hyn : ‖y‖ ≤ 1) (hcn : ‖c‖ ≤ 1)
+    {δ : ℝ} (hδ : 0 < δ)
+    (hq : y*cut (y*(1-star c*(p*p)*c)*y) δ*y=0) :
+    ‖y*(1-star c*(p*p)*c)*y‖ ≤ δ := by
+  let d := y*(1-star c*(p*p)*c)*y
+  let h := cut d δ
+  let s := CFC.sqrt h
+  have hs : IsSelfAdjoint s := (CFC.sqrt_nonneg h).isSelfAdjoint
+  have hd := conditional_defect_bounds hp hy hpn hyn hcn
+  have hzz : (y*s)*star (y*s) = y*h*y := by
+    simp only [star_mul, hs.star_eq, hy.isSelfAdjoint.star_eq]
+    calc
+      y*s*(s*y)= y*(s*s)*y := by simp only [mul_assoc]
+      _ = y*h*y := by rw [show s*s=h from CFC.sqrt_mul_sqrt_self h (cut_nonneg d δ)]
+  have hz : y*s=0 := (CStarRing.mul_star_self_eq_zero_iff _).mp (hzz.trans hq)
+  have hl : δ • h ≤ 0 := by
+    calc
+      δ • h ≤ s*d*s := cut_sqrt_lower hd.1 hδ.le
+      _ ≤ s*(y*y)*s := by
+        simpa only [hs.star_eq] using star_left_conjugate_le_conjugate hd.2.1 s
+      _ = star (y*s)*(y*s) := by
+        simp only [star_mul, hs.star_eq, hy.isSelfAdjoint.star_eq, mul_assoc]
+      _ = 0 := by rw [hz, star_zero, mul_zero]
+  have hsm : δ • h=0 := le_antisymm hl (smul_nonneg hδ.le (cut_nonneg d δ))
+  have hh : h=0 := (smul_eq_zero.mp hsm).resolve_left (ne_of_gt hδ)
+  have hb := norm_sub_cut_le hd.1 hδ.le
+  change ‖d-h‖ ≤ δ at hb
+  simpa only [hh, sub_zero] using hb
+
+lemma compression_of_conditional_loss {p q c : A} (hp : 0 ≤ p) {τ r : ℝ}
+    (hτ : 0 < τ) (_hr : 0 ≤ r)
+    (h : ∀ k : A, k ∈ Her q → ‖p*c*k‖ ≤ r*‖k‖) :
+    HerCompression (ramp p τ 1) q c (r/τ) := by
+  intro x hx k hk
+  have hxH : x ∈ Her (cut p τ) :=
+    Her_mono_of_mem (ramp_mem_Her_cut hp hτ.le) hx
+  have hfix : x*(cutInverse p τ*p)=x := Her_right_fixed_cutInverse hp hτ hxH
+  have he : x*c*k = (x*cutInverse p τ)*(p*c*k) := by
+    calc
+      x*c*k = (x*(cutInverse p τ*p))*c*k := by rw [hfix]
+      _ = _ := by simp only [mul_assoc]
+  rw [he]
+  calc
+    ‖(x*cutInverse p τ)*(p*c*k)‖ ≤ ‖x*cutInverse p τ‖*‖p*c*k‖ := norm_mul_le _ _
+    _ ≤ (‖x‖*(1/τ))*(r*‖k‖) := by
+      apply mul_le_mul
+      · exact (norm_mul_le _ _).trans (mul_le_mul_of_nonneg_left (norm_cutInverse_le hp hτ) (norm_nonneg x))
+      · exact h k hk
+      · exact norm_nonneg _
+      · positivity
+    _ = (r/τ)*‖x‖*‖k‖ := by ring
+
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Cutoffs.lean

@@ -0,0 +1,343 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.OrthogonalSlots
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+section MoreHer
+variable [PartialOrder A] [StarOrderedRing A]
+
+omit [PartialOrder A] [StarOrderedRing A] in
+lemma norm_left_remainder_sq {e z : A} (he : IsSelfAdjoint e) :
+    ‖z - e * z‖ ^ 2 = ‖twoSidedRemainder e (z * star z)‖ := by
+  rw [pow_two, ← CStarRing.norm_self_mul_star]
+  congr 1
+  simp only [twoSidedRemainder, star_sub, star_mul, he.star_eq]
+  noncomm_ring
+
+omit [PartialOrder A] [StarOrderedRing A] in
+lemma norm_right_remainder_sq {e z : A} (he : IsSelfAdjoint e) :
+    ‖z - z * e‖ ^ 2 = ‖twoSidedRemainder e (star z * z)‖ := by
+  rw [← norm_star (z - z * e), star_sub, star_mul, he.star_eq,
+    norm_left_remainder_sq he, star_star]
+
+lemma norm_left_remainder_sq_le {e z b : A} (he : IsSelfAdjoint e)
+    (hen : ‖e‖ ≤ 1) (hle : z * star z ≤ b) :
+    ‖z - e * z‖ ^ 2 ≤ 2 * ‖b - e * b‖ := by
+  rw [norm_left_remainder_sq he]
+  exact (CStarAlgebra.norm_le_norm_of_le_of_nonneg
+    (twoSidedRemainder_mono he hle)
+    (twoSidedRemainder_nonneg he (mul_star_self_nonneg z))).trans
+      (norm_twoSidedRemainder_le hen b)
+
+lemma norm_right_remainder_sq_le {e z b : A} (he : IsSelfAdjoint e)
+    (hen : ‖e‖ ≤ 1) (hle : star z * z ≤ b) :
+    ‖z - z * e‖ ^ 2 ≤ 2 * ‖b - e * b‖ := by
+  rw [norm_right_remainder_sq he]
+  exact (CStarAlgebra.norm_le_norm_of_le_of_nonneg
+    (twoSidedRemainder_mono he hle)
+    (twoSidedRemainder_nonneg he (star_mul_self_nonneg z))).trans
+      (norm_twoSidedRemainder_le hen b)
+
+lemma mem_Her_of_moduli {h z : A} (hl : z * star z ∈ Her h)
+    (hr : star z * z ∈ Her h) : z ∈ Her h := by
+  let b := z * star z + star z * z
+  have hb : 0 ≤ b := add_nonneg (mul_star_self_nonneg z) (star_mul_self_nonneg z)
+  have hbh : b ∈ Her h := (Her h).add_mem hl hr
+  have hbl : z * star z ≤ b := le_add_of_nonneg_right (star_mul_self_nonneg z)
+  have hbr : star z * z ≤ b := le_add_of_nonneg_left (mul_star_self_nonneg z)
+  have hzc : z ∈ closure (Her h : Set A) := by
+    rw [Metric.mem_closure_iff]
+    intro ε hε
+    obtain ⟨e, he, hesa, hen, hs⟩ := Her_exists_approx_unit hb
+      (show 0 < ε^2 / 8 by positivity)
+    have hδ : 2 * ‖b - e * b‖ < (ε / 2)^2 := by linarith
+    have hle : ‖z - e * z‖ < ε / 2 := by
+      exact (sq_lt_sq₀ (norm_nonneg _) (by positivity)).mp
+        ((norm_left_remainder_sq_le hesa hen hbl).trans_lt hδ)
+    have hre : ‖z - z * e‖ < ε / 2 := by
+      exact (sq_lt_sq₀ (norm_nonneg _) (by positivity)).mp
+        ((norm_right_remainder_sq_le hesa hen hbr).trans_lt hδ)
+    refine ⟨e * z * e, ?_, ?_⟩
+    · change e * z * e ∈ Her h
+      simpa only [hesa.star_eq] using Her_sandwich (Her_mono_of_mem hbh he) z
+    · rw [dist_eq_norm]
+      have heq : z - e * z * e = (z - e * z) + e * (z - z * e) := by noncomm_ring
+      rw [heq]
+      calc
+        ‖(z - e * z) + e * (z - z * e)‖ ≤ ‖z - e * z‖ + ‖e * (z - z * e)‖ := norm_add_le _ _
+        _ ≤ ‖z - e * z‖ + ‖e‖ * ‖z - z * e‖ := by gcongr; exact norm_mul_le _ _
+        _ ≤ ‖z - e * z‖ + ‖z - z * e‖ := by nlinarith [norm_nonneg (z - z * e)]
+        _ < ε := by linarith
+  rwa [(isClosed_Her h).closure_eq] at hzc
+
+end MoreHer
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+section Ramps
+variable [PartialOrder A] [StarOrderedRing A]
+
+lemma norm_mem_quasispectrum_of_nonneg {a : A} (ha : 0 ≤ a) :
+    ‖a‖ ∈ quasispectrum ℝ a := by
+  simpa using quasispectrum.algebraMap_mem ℝ
+    (NonUnitalIsometricContinuousFunctionalCalculus.isGreatest_quasispectrum a ha).1
+
+def rampFn (l u t : ℝ) : ℝ := min 1 (max (t-l) 0 / (u-l))
+
+lemma continuous_rampFn (l u : ℝ) : Continuous (rampFn l u) :=
+  continuous_const.min (((continuous_id.sub continuous_const).max continuous_const).div_const _)
+
+lemma rampFn_nonneg {l u t : ℝ} (hlu : l ≤ u) : 0 ≤ rampFn l u t :=
+  le_min (by norm_num) (div_nonneg (le_max_right _ _) (sub_nonneg.mpr hlu))
+
+lemma rampFn_le_one (l u t : ℝ) : rampFn l u t ≤ 1 := min_le_left _ _
+
+lemma rampFn_zero {l u t : ℝ} (ht : t ≤ l) : rampFn l u t = 0 := by
+  simp only [rampFn, max_eq_right (sub_nonpos.mpr ht), zero_div, min_eq_right (by norm_num : (0:ℝ) ≤ 1)]
+
+lemma rampFn_one {l u t : ℝ} (hlu : l < u) (ht : u ≤ t) : rampFn l u t = 1 := by
+  apply min_eq_left
+  apply (le_div_iff₀ (sub_pos.mpr hlu)).mpr
+  rw [one_mul, max_eq_left (sub_nonneg.mpr (hlu.le.trans ht))]
+  linarith
+
+def ramp (a : A) (l u : ℝ) : A := cfcₙ (rampFn l u) a
+
+lemma ramp_nonneg (a : A) {l u : ℝ} (hlu : l ≤ u) : 0 ≤ ramp a l u :=
+  cfcₙ_nonneg (fun _ _ => rampFn_nonneg hlu)
+
+omit [PartialOrder A] [StarOrderedRing A] in
+lemma norm_ramp_le_one (a : A) {l u : ℝ} (hlu : l ≤ u) : ‖ramp a l u‖ ≤ 1 := by
+  apply norm_cfcₙ_le
+  intro t _
+  rw [Real.norm_eq_abs, abs_of_nonneg (rampFn_nonneg hlu)]
+  exact rampFn_le_one _ _ _
+
+lemma ramp_mem_Her_cut {a : A} (ha : 0 ≤ a) {l u : ℝ} (hl : 0 ≤ l) :
+    ramp a l u ∈ Her (cut a l) := by
+  have hcomp : ramp a l u = cfcₙ (fun t : ℝ => min 1 (t / (u-l))) (cut a l) := by
+    unfold ramp cut
+    exact cfcₙ_comp (fun t : ℝ => min 1 (t / (u-l))) (fun t : ℝ => max (t-l) 0) a
+      (continuous_const.min (continuous_id.div_const _)).continuousOn (by norm_num)
+      ((continuous_id.sub continuous_const).max continuous_const).continuousOn
+      (by simp [max_eq_right (neg_nonpos.mpr hl)]) (.of_nonneg ha)
+  rw [hcomp]
+  exact cfcₙ_mem (𝕜' := ℂ) _ (self_mem_Her (cut_nonneg a l))
+
+lemma norm_ramp_eq_one {a : A} (ha : 0 ≤ a) {l u : ℝ} (hl : 0 ≤ l)
+    (hlu : l < u) (hu : u ≤ ‖a‖) : ‖ramp a l u‖ = 1 := by
+  apply le_antisymm (norm_ramp_le_one a hlu.le)
+  have ht := norm_apply_le_norm_cfcₙ (rampFn l u) a
+    (norm_mem_quasispectrum_of_nonneg ha) (continuous_rampFn l u).continuousOn
+    (rampFn_zero hl) (.of_nonneg ha)
+  change 1 ≤ ‖cfcₙ (rampFn l u) a‖
+  simpa only [rampFn_one hlu hu, norm_one] using ht
+
+lemma map_ramp {B : Type*} [NonUnitalCStarAlgebra B] [PartialOrder B] [StarOrderedRing B]
+    (π : A →⋆ₙₐ[ℂ] B) {a : A} (ha : 0 ≤ a) {l u : ℝ} (hl : 0 ≤ l) :
+    π (ramp a l u) = ramp (π a) l u :=
+  π.map_cfcₙ (rampFn l u) a (continuous_rampFn l u).continuousOn (rampFn_zero hl)
+    (map_continuous π) (.of_nonneg ha) (.of_nonneg (map_nonneg π ha))
+
+lemma map_cut {B : Type*} [NonUnitalCStarAlgebra B] [PartialOrder B] [StarOrderedRing B]
+    (π : A →⋆ₙₐ[ℂ] B) {a : A} (ha : 0 ≤ a) {l : ℝ} (hl : 0 ≤ l) :
+    π (cut a l) = cut (π a) l :=
+  π.map_cfcₙ (fun t : ℝ => max (t-l) 0) a
+    ((continuous_id.sub continuous_const).max continuous_const).continuousOn
+    (by simp [max_eq_right (neg_nonpos.mpr hl)]) (map_continuous π)
+    (.of_nonneg ha) (.of_nonneg (map_nonneg π ha))
+
+lemma cut_cut {a : A} (ha : 0 ≤ a) {l u : ℝ} (hl : 0 ≤ l) (hu : 0 ≤ u) :
+    cut (cut a l) u = cut a (l+u) := by
+  let f : ℝ → ℝ := fun t => max (t-l) 0
+  let g : ℝ → ℝ := fun t => max (t-u) 0
+  have hcomp := cfcₙ_comp g f a
+    ((continuous_id.sub continuous_const).max continuous_const).continuousOn
+    (by simp [g, max_eq_right (neg_nonpos.mpr hu)])
+    ((continuous_id.sub continuous_const).max continuous_const).continuousOn
+    (by simp [f, max_eq_right (neg_nonpos.mpr hl)]) (.of_nonneg ha)
+  change cfcₙ g (cfcₙ f a) = _
+  rw [← hcomp]
+  apply cfcₙ_congr
+  intro t _
+  dsimp [f, g]
+  by_cases ht : l ≤ t
+  · rw [max_eq_left (sub_nonneg.mpr ht)]
+    congr 1
+    ring
+  · rw [max_eq_right (by linarith : t-l ≤ 0), zero_sub,
+      max_eq_right (neg_nonpos.mpr hu), max_eq_right (by linarith : t-(l+u) ≤ 0)]
+
+lemma norm_sub_cut_le {a : A} (ha : 0 ≤ a) {l : ℝ} (hl : 0 ≤ l) :
+    ‖a - cut a l‖ ≤ l := by
+  conv_lhs => arg 1; lhs; rw [← cfcₙ_id ℝ a (.of_nonneg ha)]
+  rw [cut, ← cfcₙ_sub id (fun t : ℝ => max (t-l) 0) a continuousOn_id rfl
+    ((continuous_id.sub continuous_const).max continuous_const).continuousOn
+    (by simp [max_eq_right (neg_nonpos.mpr hl)])]
+  apply norm_cfcₙ_le
+  intro t ht
+  have ht0 : 0 ≤ t := quasispectrum_nonneg_of_nonneg a ha t ht
+  dsimp only [id_eq]
+  rw [Real.norm_eq_abs, abs_le]
+  constructor
+  · have hh : max (t-l) 0 ≤ t := max_le (by linarith) ht0
+    linarith
+  · have hh := le_max_left (t-l) 0
+    linarith
+
+omit [StarOrderedRing A] in
+lemma ramp_mul_cut {a : A} (_ha : 0 ≤ a) {l u v : ℝ} (hl : 0 ≤ l)
+    (hlu : l < u) (huv : u ≤ v) : ramp a l u * cut a v = cut a v := by
+  have hv : 0 ≤ v := hl.trans (hlu.le.trans huv)
+  unfold ramp cut
+  rw [← cfcₙ_mul (rampFn l u) (fun t : ℝ => max (t-v) 0) a (continuous_rampFn l u).continuousOn (rampFn_zero hl)
+    ((continuous_id.sub continuous_const).max continuous_const).continuousOn
+    (by simp [max_eq_right (neg_nonpos.mpr hv)])]
+  apply cfcₙ_congr
+  intro t _
+  dsimp only
+  by_cases ht : v ≤ t
+  · rw [rampFn_one hlu (huv.trans ht), one_mul]
+  · rw [max_eq_right (by linarith : t-v ≤ 0), mul_zero]
+
+end Ramps
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+
+lemma Her_map {B : Type*} [NonUnitalCStarAlgebra B] (π : A →⋆ₙₐ[ℂ] B)
+    {h k : A} (hk : k ∈ Her h) : π k ∈ Her (π h) := by
+  have hc : IsClosed {k : A | π k ∈ Her (π h)} :=
+    (isClosed_Her (π h)).preimage (map_continuous π)
+  apply closure_minimal (s := Set.range (fun a : A => h * a * star h)) _ hc hk
+  rintro k ⟨a, rfl⟩
+  change π (h * a * star h) ∈ Her (π h)
+  simpa only [map_mul, map_star] using sandwich_mem_Her (π h) (π a)
+
+lemma Her_fixed_left {h t : A} (ht : t * h = h) {k : A} (hk : k ∈ Her h) : t * k = k := by
+  have hc : IsClosed {k : A | t * k = k} := isClosed_eq (by fun_prop) continuous_id
+  apply closure_minimal (s := Set.range (fun a : A => h * a * star h)) _ hc hk
+  rintro k ⟨a, rfl⟩
+  change t * (h * a * star h) = h * a * star h
+  simp only [← mul_assoc, ht]
+
+lemma Her_killed_left {h t : A} (ht : t * h = 0) {k : A} (hk : k ∈ Her h) : t * k = 0 := by
+  have hc : IsClosed {k : A | t * k = 0} := isClosed_eq (by fun_prop) continuous_const
+  apply closure_minimal (s := Set.range (fun a : A => h * a * star h)) _ hc hk
+  rintro k ⟨a, rfl⟩
+  change t * (h * a * star h) = 0
+  simp only [← mul_assoc, ht, zero_mul]
+
+lemma positive_kernel_factor [PartialOrder A] [StarOrderedRing A] {x Q z : A} (hx : 0 ≤ x) (hQ : IsSelfAdjoint Q)
+    (hz : Q * (x * Q * z) = 0) : x * Q * z = 0 := by
+  let s := CFC.sqrt x
+  have hs : IsSelfAdjoint s := .of_nonneg (CFC.sqrt_nonneg x)
+  have hss : s * s = x := CFC.sqrt_mul_sqrt_self x hx
+  have hzero : star (s * Q * z) * (s * Q * z) = 0 := by
+    rw [star_mul, star_mul, hs.star_eq, hQ.star_eq]
+    calc
+      star z * (Q * s) * (s * Q * z) = star z * (Q * ((s * s) * Q * z)) := by noncomm_ring
+      _ = 0 := by rw [hss, hz, mul_zero]
+  have hz' := (CStarRing.star_mul_self_eq_zero_iff _).mp hzero
+  rw [← hss, mul_assoc s s, mul_assoc s, hz', mul_zero]
+
+section UnitalCutBounds
+variable {B : Type*} [CStarAlgebra B] [PartialOrder B] [StarOrderedRing B]
+
+omit [PartialOrder B] [StarOrderedRing B] in
+lemma cut_eq_cfc (d : B) {ε : ℝ} (hε : 0 ≤ ε) :
+    cut d ε = cfc (fun t : ℝ => max (t - ε) 0) d := by
+  unfold cut
+  apply cfcₙ_eq_cfc
+  · exact ((continuous_id.sub continuous_const).max continuous_const).continuousOn
+  · simp [max_eq_right (neg_nonpos.mpr hε)]
+
+lemma continuous_reciprocalCutoff {η : ℝ} (hη : 0 < η) :
+    Continuous (fun t : ℝ => (max t η)⁻¹) := by
+  apply Continuous.inv₀ (continuous_id.max continuous_const)
+  intro t
+  exact ne_of_gt (hη.trans_le (le_max_right t η))
+
+omit [PartialOrder B] [StarOrderedRing B] in
+lemma cutoffHer_factor {x Q : B} (hx : IsSelfAdjoint x) (hQ : IsSelfAdjoint Q)
+    {η : ℝ} (hη : 0 < η) {k : B} (hk : k ∈ Her (cut (x * Q * Q * x) η)) :
+    ∃ z : B, k = x * Q * z := by
+  let U := x * Q * Q * x
+  let f : ℝ → ℝ := fun t => (max t η)⁻¹
+  have hU : IsSelfAdjoint U := by
+    change star (x * Q * Q * x) = x * Q * Q * x
+    simp only [star_mul, hx.star_eq, hQ.star_eq]
+    noncomm_ring
+  have hf : Continuous f := continuous_reciprocalCutoff hη
+  have hg : Continuous (fun t : ℝ => max (t - η) 0) :=
+    (continuous_id.sub continuous_const).max continuous_const
+  have hfix : (U * cfc f U) * cut U η = cut U η := by
+    rw [cut_eq_cfc U hη.le]
+    conv_lhs => lhs; lhs; rw [← cfc_id ℝ U hU]
+    rw [← cfc_mul _ _ U continuousOn_id hf.continuousOn]
+    simp only [id_eq]
+    have hif : ContinuousOn (fun t : ℝ => t * f t) (spectrum ℝ U) := (continuous_id.mul hf).continuousOn
+    rw [← cfc_mul _ _ U hif hg.continuousOn]
+    apply cfc_congr
+    intro t _
+    dsimp only
+    by_cases ht : η ≤ t
+    · simp only [f, max_eq_left ht, mul_inv_cancel₀ (ne_of_gt (hη.trans_le ht)), one_mul]
+    · rw [max_eq_right (by linarith : t - η ≤ 0), mul_zero]
+  have hfixk := Her_fixed_left hfix hk
+  refine ⟨Q * x * cfc f U * k, ?_⟩
+  calc
+    k = (U * cfc f U) * k := hfixk.symm
+    _ = x * Q * (Q * x * cfc f U * k) := by dsimp [U]; noncomm_ring
+
+lemma selfConsistent_cutoff_bound {x d : B} (hx : 0 ≤ x) (hd : 0 ≤ d)
+    {η h : ℝ} (hη : 0 < η) (hh : 0 ≤ h)
+    (hmem : d ∈ Her (cut (x * cfc (fun t : ℝ => max (h - t) 0) d *
+      cfc (fun t : ℝ => max (h - t) 0) d * x) η)) :
+    d ≤ h • (1 : B) := by
+  let Q := cfc (fun t : ℝ => max (h - t) 0) d
+  have hQ : IsSelfAdjoint Q := IsSelfAdjoint.cfc
+  have hq : Continuous (fun t : ℝ => max (h - t) 0) :=
+    (continuous_const.sub continuous_id).max continuous_const
+  have hk : Continuous (fun t : ℝ => max (t - h) 0) :=
+    (continuous_id.sub continuous_const).max continuous_const
+  have hkill : Q * cut d h = 0 := by
+    rw [cut_eq_cfc d hh]
+    change cfc (fun t : ℝ => max (h-t) 0) d * cfc (fun t : ℝ => max (t-h) 0) d = 0
+    rw [← cfc_mul _ _ d hq.continuousOn hk.continuousOn, ← cfc_zero d (R := ℝ)]
+    apply cfc_congr
+    intro t _
+    by_cases ht : h ≤ t
+    · simp [max_eq_right (by linarith : h - t ≤ 0)]
+    · simp [max_eq_right (by linarith : t - h ≤ 0)]
+  have hcutmem : cut d h ∈ Her (cut (x * Q * Q * x) η) :=
+    Her_mono_of_mem hmem (cut_mem_Her hd h)
+  obtain ⟨z, hz⟩ := cutoffHer_factor (.of_nonneg hx) hQ hη hcutmem
+  have hcutzero : cut d h = 0 := by
+    rw [hz]
+    exact positive_kernel_factor hx hQ (by rwa [← hz])
+  rw [cut_eq_cfc d hh, ← cfc_zero d (R := ℝ)] at hcutzero
+  have hzspec := eqOn_of_cfc_eq_cfc (ha := IsSelfAdjoint.of_nonneg hd) hcutzero
+  rw [← Algebra.algebraMap_eq_smul_one, ← cfc_const h d]
+  conv_lhs => rw [← cfc_id ℝ d (.of_nonneg hd)]
+  apply (cfc_le_iff _ _ d continuousOn_id continuousOn_const (.of_nonneg hd)).mpr
+  intro t ht
+  have hm : max (t - h) 0 = 0 := hzspec ht
+  have := le_max_left (t - h) 0
+  dsimp only [id_eq]
+  linarith
+
+end UnitalCutBounds
+
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Defect.lean

@@ -0,0 +1,275 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.FourChoices
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+variable {A : Type*} [CStarAlgebra A]
+local instance deficiencyOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance deficiencyStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+lemma deficiency_eq_sub {d : A} (hd : 0 ≤ d) (hb : d ≤ (1/2 : ℝ) • (1 : A)) :
+    deficiency d = (1/2 : ℝ) • (1 : A) - d := by
+  have hdsa : IsSelfAdjoint d := .of_nonneg hd
+  have hb' : cfc (fun t : ℝ => t) d ≤ cfc (fun _ : ℝ => (1/2 : ℝ)) d := by
+    rw [cfc_id' ℝ d hdsa, cfc_const (1/2 : ℝ) d hdsa, Algebra.algebraMap_eq_smul_one]
+    exact hb
+  have hs := (cfc_le_iff _ _ d continuousOn_id continuousOn_const hdsa).mp hb'
+  calc
+    deficiency d = cfc (fun t : ℝ => (1/2 : ℝ)-t) d := by
+      apply cfc_congr
+      intro t ht
+      exact max_eq_left (sub_nonneg.mpr (hs t ht))
+    _ = cfc (fun _ : ℝ => (1/2 : ℝ)) d - cfc (fun t : ℝ => t) d :=
+      cfc_sub _ _ d continuousOn_const continuousOn_id
+    _ = (1/2 : ℝ) • (1 : A) - d := by
+      rw [cfc_const (1/2 : ℝ) d hdsa, cfc_id' ℝ d hdsa, Algebra.algebraMap_eq_smul_one]
+
+lemma sandwich_zero_eigen {x d : A} (hx : 0 ≤ x) (hd : 0 ≤ d)
+    (hdle : d ≤ (1/2 : ℝ) • (1 : A))
+    (hU : x * deficiency d * deficiency d * x = 0) : d * x = (1/2 : ℝ) • x := by
+  have hQx : deficiency d * x = 0 := by
+    apply (CStarRing.star_mul_self_eq_zero_iff _).mp
+    simpa only [star_mul, IsSelfAdjoint.of_nonneg hx |>.star_eq,
+      deficiency_selfAdjoint d |>.star_eq, mul_assoc] using hU
+  rw [deficiency_eq_sub hd hdle, sub_mul, smul_mul_assoc, one_mul] at hQx
+  exact (sub_eq_zero.mp hQx).symm
+
+lemma Her_eigen_left {x d k : A} {h : ℝ} (hx : d*x=h•x) (hk : k ∈ Her x) :
+    d*k=h•k := by
+  have hz : (d-h • (1:A))*x=0 := by
+    simp only [sub_mul, smul_mul_assoc, one_mul, hx, sub_self]
+  have := Her_killed_left hz hk
+  simpa only [sub_mul, smul_mul_assoc, one_mul, sub_eq_zero] using this
+
+lemma firstH_mem_firstX {X : A} (hX : 0 ≤ X) : firstH X ∈ Her (firstX X) :=
+  Her_mono_of_mem (cut_mem_cutHer hX (by norm_num : (0:ℝ) ≤ 1/16)
+    (by norm_num : (1/16:ℝ) ≤ 3/32)) (ramp_mem_Her_cut hX (by norm_num))
+
+lemma firstK_fixes_H {X : A} (hX : 0 ≤ X) : firstK X * firstH X = firstH X :=
+  Her_fixed_left (ramp_mul_cut hX (by norm_num : (0:ℝ) ≤ 3/64)
+    (by norm_num : (3/64:ℝ) < 1/16) le_rfl) (firstH_mem_firstX hX)
+
+lemma firstR_fixed_left {X B : A} (hX : 0 ≤ X) (hB : star B * B ∈ Her (firstV X)) :
+    firstH X * firstR X B = firstR X B := by
+  have hstar : firstH X * star B = star B := by
+    apply fixed_left_of_modulus
+    simp only [star_star]
+    exact Her_fixed_left (firstH_fixes_V hX) hB
+  simp only [firstR, mul_smul_comm, ← mul_assoc, hstar]
+
+lemma firstR_inner {X B C : A} (hmod : B * star C = B * star B)
+    (hDH : B * star B * firstH X = (1/2 : ℝ) • firstH X) :
+    star (firstR X B) * firstR X C = firstH X * firstH X := by
+  have hH : star (firstH X) = firstH X := (IsSelfAdjoint.of_nonneg (ramp_nonneg X (by norm_num : (3/32:ℝ) ≤ 1/8))).star_eq
+  simp only [firstR, star_smul, star_trivial, star_mul, hH, star_star,
+    smul_mul_smul]
+  rw [Real.mul_self_sqrt (by norm_num : (0:ℝ) ≤ 2)]
+  calc
+    (2:ℝ) • ((firstH X * B) * (star C * firstH X)) =
+      (2:ℝ) • (firstH X * ((B * star C) * firstH X)) := by congr 1; noncomm_ring
+    _ = firstH X * firstH X := by rw [hmod, hDH, mul_smul_comm, smul_smul]; norm_num
+
+lemma firstR_orthogonal {X B C : A} (hcross : B * star C = 0) :
+    star (firstR X B) * firstR X C = 0 := by
+  simp only [firstR, star_smul, star_trivial, star_mul, star_star, smul_mul_smul]
+  calc
+    _ = (Real.sqrt 2 * Real.sqrt 2) • (star (firstH X) * (B * star C) * firstH X) := by
+      congr 1; noncomm_ring
+    _ = 0 := by rw [hcross, mul_zero, zero_mul, smul_zero]
+
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [CStarAlgebra A]
+local instance scalingDefectOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance scalingDefectStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+lemma ramp_projection {P : A} (hP : IsStarProjection P) {l u : ℝ} (hl : 0 ≤ l)
+    (hlu : l < u) (hu : u ≤ 1) : ramp P l u = P := by
+  conv_rhs => rw [← cfcₙ_id ℝ P hP.isSelfAdjoint]
+  apply cfcₙ_congr
+  intro t ht
+  rcases Set.mem_insert_iff.mp (hP.isIdempotentElem.quasispectrum_subset ℝ ht) with ht | ht
+  · subst t
+    exact rampFn_zero hl
+  · have ht : t = 1 := Set.mem_singleton_iff.mp ht
+    subst t
+    exact rampFn_one hlu hu
+
+lemma cut_projection {P : A} (hP : IsStarProjection P) {l : ℝ} (hl : 0 ≤ l) (hl1 : l ≤ 1) :
+    cut P l = (1-l) • P := by
+  conv_rhs => rw [← cfcₙ_id ℝ P hP.isSelfAdjoint]
+  rw [← cfcₙ_smul (1-l) id P continuousOn_id rfl]
+  apply cfcₙ_congr
+  intro t ht
+  rcases Set.mem_insert_iff.mp (hP.isIdempotentElem.quasispectrum_subset ℝ ht) with ht | ht
+  · subst t
+    simp [max_eq_right (neg_nonpos.mpr hl)]
+  · have ht : t = 1 := Set.mem_singleton_iff.mp ht
+    subst t
+    simp [max_eq_left (sub_nonneg.mpr hl1)]
+
+lemma scalingDefect_expansion {H r : A} (hH : IsSelfAdjoint H) (hnorm : ‖H‖ ≤ 1) :
+    scalingDefect H r = H*H-r*star r-r*scalingComplement H-scalingComplement H*star r := by
+  have hb := scalingComplement_mul_self hH hnorm
+  simp only [scalingDefect, scalingIsometry, star_add, scalingComplement_selfAdjoint H |>.star_eq,
+    add_mul, mul_add]
+  rw [hb]
+  noncomm_ring
+
+lemma scalingDefect_compress {H K r : A} (hH : IsSelfAdjoint H) (hK : IsSelfAdjoint K)
+    (hnorm : ‖H‖ ≤ 1) (hKH : K*H=H) (hHr : H*r=r) (hrK : r*K=r) :
+    K * scalingDefect H r * K = scalingDefect H r := by
+  have hHK : H*K=H := by
+    simpa only [star_mul, hH.star_eq, hK.star_eq] using congrArg star hKH
+  have hKr : K*r=r := by rw [← hHr, ← mul_assoc, hKH]
+  have hsrK : star r*K=star r := by
+    simpa only [star_mul, hK.star_eq, star_star] using congrArg star hKr
+  have hKsr : K*star r=star r := by
+    simpa only [star_mul, hK.star_eq, star_star] using congrArg star hrK
+  have hcomm : Commute K H := (show K*H=H*K by rw [hKH,hHK])
+  have hbcomm : Commute K (scalingComplement H) := by
+    exact ((Commute.one_right K).sub_right (hcomm.mul_right hcomm)).symm.cfcₙ_nnreal NNReal.sqrt |>.symm
+  have hleft : K * scalingDefect H r = scalingDefect H r := by
+    rw [scalingDefect_expansion hH hnorm]
+    simp only [mul_sub, ← mul_assoc, hKH, hKr]
+    rw [hbcomm.eq, mul_assoc, hKsr]
+  have hright : scalingDefect H r * K = scalingDefect H r := by
+    simpa only [star_mul, hK.star_eq, show star (scalingDefect H r) = scalingDefect H r from
+      ((IsSelfAdjoint.one A).sub (IsSelfAdjoint.mul_star_self _)).star_eq] using congrArg star hleft
+  rw [hleft, hright]
+
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [CStarAlgebra A]
+local instance fourFixedOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance fourFixedStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+theorem four_fixed_impossible {X : A} (hX : 0 ≤ X) (B : Fin 4 → A)
+    (hV : firstV X ≠ 0)
+    (hD : B 0 * star (B 0) ≤ (1/2 : ℝ) • (1 : A))
+    (hmod : B 1 * star (B 1) = B 0 * star (B 0))
+    (hcross : B 0 * star (B 1) = 0)
+    (hHB₀ : firstH X * star (B 0) = star (B 0))
+    (hHB₁ : firstH X * star (B 1) = star (B 1))
+    (hU : firstU X (B 0) = 0)
+    (hD₃ : B 2 * star (B 2) ≤ (1/2 : ℝ) • (1 : A))
+    (hc₃ : star (B 2) * B 3 = 0)
+    (hm₃ : star (B 2) * B 2 = star (B 3) * B 3)
+    (hR : lastR X (B 0) (B 2) = 0)
+    (hs₃ : ramp (prospectiveDefect X (B 0)) 0 (1/2) * B 3 = B 3) : False := by
+  have hH : IsSelfAdjoint (firstH X) := .of_nonneg (ramp_nonneg X (by norm_num))
+  have hK : IsSelfAdjoint (firstK X) := .of_nonneg (ramp_nonneg X (by norm_num))
+  have hHnorm : ‖firstH X‖ ≤ 1 := norm_ramp_le_one _ (by norm_num)
+  have hHne : firstH X ≠ 0 := by
+    intro hz
+    apply hV
+    simpa only [hz, zero_mul] using (firstH_fixes_V hX).symm
+  have hDx : (B 0 * star (B 0)) * firstX X = (1/2 : ℝ) • firstX X :=
+    sandwich_zero_eigen (cut_nonneg X _) (mul_star_self_nonneg _) hD hU
+  have hDH : (B 0 * star (B 0)) * firstH X = (1/2 : ℝ) • firstH X :=
+    Her_eigen_left hDx (firstH_mem_firstX hX)
+  have hρ₀ : star (firstR X (B 0)) * firstR X (B 0) = firstH X * firstH X :=
+    firstR_inner rfl hDH
+  have hρ₁ : star (firstR X (B 1)) * firstR X (B 1) = firstH X * firstH X :=
+    firstR_inner rfl (hmod ▸ hDH)
+  have hρc : star (firstR X (B 0)) * firstR X (B 1) = 0 := firstR_orthogonal hcross
+  have hHr₀ : firstH X * firstR X (B 0) = firstR X (B 0) := by
+    simp only [firstR, mul_smul_comm, ← mul_assoc, hHB₀]
+  have hHr₁ : firstH X * firstR X (B 1) = firstR X (B 1) := by
+    simp only [firstR, mul_smul_comm, ← mul_assoc, hHB₁]
+  let P := scalingDefect (firstH X) (firstR X (B 0))
+  have hP : IsStarProjection P := scalingDefect_projection hH hHnorm hHr₀ hρ₀
+  have hPne : P ≠ 0 := scalingDefect_ne_zero hH hHnorm hHne hHr₁ hρc hρ₁
+  have hKH : firstK X * firstH X = firstH X := firstK_fixes_H hX
+  have hHK : firstH X * firstK X = firstH X := by
+    simpa only [star_mul, hK.star_eq, hH.star_eq] using congrArg star hKH
+  have hrK : firstR X (B 0) * firstK X = firstR X (B 0) := by
+    simp only [firstR, smul_mul_assoc, mul_assoc, hHK]
+  have hP₀ : prospectiveDefect X (B 0) = P := by
+    change ramp (firstK X * P * firstK X) 0 1 = P
+    rw [scalingDefect_compress hH hK hHnorm hKH hHr₀ hrK]
+    exact ramp_projection hP (by norm_num) (by norm_num) le_rfl
+  have hx' : lastX X (B 0) = (1/2 : ℝ) • P := by
+    simp only [lastX, hP₀, cut_projection hP (by norm_num : (0:ℝ) ≤ 1/2)
+      (by norm_num : (1/2:ℝ) ≤ 1)]
+    norm_num
+  have hD₃x : (B 2 * star (B 2)) * lastX X (B 0) = (1/2 : ℝ) • lastX X (B 0) :=
+    sandwich_zero_eigen (lastX_nonneg X _) (mul_star_self_nonneg _) hD₃ hR
+  have hD₃P : (B 2 * star (B 2)) * P = (1/2 : ℝ) • P := by
+    rw [hx', mul_smul_comm, smul_comm] at hD₃x
+    exact (smul_right_injective A (by norm_num : (1/2 : ℝ) ≠ 0)) hD₃x
+  have hPB : P * B 3 = B 3 := by
+    rw [hP₀, ramp_projection hP (by norm_num) (by norm_num) (by norm_num)] at hs₃
+    exact hs₃
+  exact hPne (last_pair_kills_defect (by norm_num : (1/2 : ℝ) ≠ 0) hPB hc₃ hm₃ hD₃P)
+
+end MainGap
+
+namespace MainGap
+variable {A D : Type*} [CStarAlgebra A] [CStarAlgebra D]
+local instance defectSandwichOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance defectSandwichStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+local instance representedDefectOrder : PartialOrder D := CStarAlgebra.spectralOrder D
+local instance representedDefectStarOrder : StarOrderedRing D := CStarAlgebra.spectralOrderedRing D
+
+lemma firstSandwich_single_le {U V w : A} (hV : 0 ≤ V) (η : ℝ) {E : Finset A}
+    (hw : w ∈ E) :
+    (cut U η * w * CFC.sqrt V) * star (cut U η * w * CFC.sqrt V) ≤
+      firstSandwich U V η E := by
+  have hsum : w * V * star w ≤ ∑ v ∈ E, v * V * star v :=
+    Finset.single_le_sum (fun v _ => star_right_conjugate_nonneg hV v) hw
+  have h := conjugate_le_conjugate_of_nonneg hsum (cut_nonneg U η)
+  have heq : (cut U η * w * CFC.sqrt V) * star (cut U η * w * CFC.sqrt V) =
+      cut U η * (w * V * star w) * cut U η := by
+    simp only [star_mul, IsSelfAdjoint.of_nonneg (CFC.sqrt_nonneg V) |>.star_eq,
+      IsSelfAdjoint.of_nonneg (cut_nonneg U η) |>.star_eq]
+    calc
+      _ = cut U η * w * (CFC.sqrt V * CFC.sqrt V) * star w * cut U η := by noncomm_ring
+      _ = _ := by rw [CFC.sqrt_mul_sqrt_self V hV]; noncomm_ring
+  rw [heq]
+  exact h
+
+lemma represented_single_sq_le (π : A →⋆ₐ[ℂ] D) {U V w : A} (hV : 0 ≤ V)
+    (η : ℝ) {E : Finset A} (hw : w ∈ E) :
+    ‖π (cut U η * w * CFC.sqrt V)‖ ^ 2 ≤ ‖π (firstSandwich U V η E)‖ := by
+  have h := OrderHomClass.mono π (firstSandwich_single_le (U := U) hV η hw)
+  rw [map_mul, map_star] at h
+  simpa only [CStarRing.norm_self_mul_star, sq] using
+    CStarAlgebra.norm_le_norm_of_le_of_nonneg h (mul_star_self_nonneg _)
+
+lemma represented_mixed_estimate (π : A →⋆ₐ[ℂ] D) {U V w : A} (hU : 0 ≤ U) (hV : 0 ≤ V)
+    {η : ℝ} (hη : 0 < η) {E : Finset A} (hw : w ∈ E)
+    (hD : ‖π (firstSandwich U V η E)‖ ≤ 2*η) :
+    ‖π (U*w*V)‖ ≤ Real.sqrt (2*η) * ‖CFC.sqrt V‖ + η*‖w‖*‖V‖ := by
+  have hr : ‖π (cut U η * w * CFC.sqrt V)‖ ≤ Real.sqrt (2*η) := by
+    exact (Real.le_sqrt (norm_nonneg _) (by positivity)).mpr
+      ((represented_single_sq_le π hV η hw).trans hD)
+  have hsplit : U*w*V = (cut U η * w * CFC.sqrt V) * CFC.sqrt V +
+      (U-cut U η)*w*V := by
+    rw [mul_assoc (cut U η * w), CFC.sqrt_mul_sqrt_self V hV]
+    noncomm_ring
+  rw [hsplit, map_add]
+  apply norm_add_le _ _ |>.trans
+  apply add_le_add
+  · rw [map_mul]
+    exact (norm_mul_le _ _).trans (mul_le_mul hr (NonUnitalStarAlgHom.norm_apply_le π _) (norm_nonneg _) (by positivity))
+  · rw [map_mul, map_mul]
+    calc
+      ‖(π (U-cut U η) * π w) * π V‖ ≤ ‖π (U-cut U η)‖ * ‖π w‖ * ‖π V‖ :=
+        (norm_mul_le _ _).trans (mul_le_mul_of_nonneg_right (norm_mul_le _ _) (norm_nonneg _))
+      _ ≤ η*‖w‖*‖V‖ := mul_le_mul
+        (mul_le_mul ((NonUnitalStarAlgHom.norm_apply_le π _).trans (norm_sub_cut_le hU hη.le))
+          (NonUnitalStarAlgHom.norm_apply_le π w) (norm_nonneg _) hη.le)
+        (NonUnitalStarAlgHom.norm_apply_le π V) (norm_nonneg _) (by positivity)
+
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Diagonalization.lean

@@ -0,0 +1,106 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Signal
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+local instance boundedDiagonalizationPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance boundedDiagonalizationStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+theorem bounded_diagonalization (hP : PropertyP A) {a b : A} (ha : 0 ≤ a) (hb : 0 ≤ b)
+    (han : ‖a‖ ≤ 1) (hbn : ‖b‖ ≤ 1) (c : A) {δ ρ ζ : ℝ}
+    (hδ : 0 < δ) (hδhalf : δ < 1/2) (hρ : 0 < ρ) (hρδ : ρ ≤ 2*δ) (hζ : 0 < ζ) :
+    ∃ s t : A, ‖star s*a*s-a‖ < 2*δ+ρ ∧ ‖star t*b*t-b‖ < 2*δ+ρ ∧
+      ‖star s*c*t‖ < ζ ∧ ‖s‖ ≤ Real.sqrt δ⁻¹ ∧ ‖t‖ ≤ Real.sqrt δ⁻¹ := by
+  let M := max 1 ‖c‖
+  have hM1 : 1 ≤ M := le_max_left _ _
+  have hM : 0 < M := lt_of_lt_of_le zero_lt_one hM1
+  have hcn : ‖M⁻¹ • c‖ ≤ 1 := by
+    rw [norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hM)]
+    calc M⁻¹ * ‖c‖ ≤ M⁻¹ * M := mul_le_mul_of_nonneg_left (le_max_right _ _) (inv_nonneg.mpr hM.le)
+         _ = 1 := inv_mul_cancel₀ hM.ne'
+  obtain ⟨p,q,κ,hp0,hpn,hpH,hq0,hqn,hqH,hκ0,hκζ,hcomp,hps,hqs⟩ :=
+    iterated_separation hP (ramp_nonneg a (by linarith : δ ≤ 2*δ))
+      (norm_ramp_le_one a (by linarith : δ ≤ 2*δ))
+      (ramp_nonneg b (by linarith : δ ≤ 2*δ))
+      (norm_ramp_le_one b (by linarith : δ ≤ 2*δ)) hcn
+      (by positivity : 0 < δ*ζ/M)
+  obtain ⟨w,hw,hsn⟩ := signal_coefficient hP ha han hδ hδhalf hρ hρδ hpH hps
+  obtain ⟨z,hz,htn⟩ := signal_coefficient hP hb hbn hδ hδhalf hρ hρδ hqH hqs
+  refine ⟨p*w,q*z,hw,hz,?_,hsn,htn⟩
+  have hc : HerCompression p q c (M*κ) := by
+    intro x hx y hy
+    have hh := hcomp x hx y hy
+    rw [mul_smul_comm, smul_mul_assoc, norm_smul, Real.norm_eq_abs,
+      abs_of_pos (inv_pos.mpr hM)] at hh
+    have hh' := mul_le_mul_of_nonneg_left hh hM.le
+    calc ‖x*c*y‖ = M * (M⁻¹ * ‖x*c*y‖) := by rw [← mul_assoc, mul_inv_cancel₀ hM.ne', one_mul]
+         _ ≤ M*(κ*‖x‖*‖y‖) := hh'
+         _ = (M*κ)*‖x‖*‖y‖ := by ring
+  have hprod : ‖p*w‖*‖q*z‖ ≤ δ⁻¹ := by
+    calc ‖p*w‖*‖q*z‖ ≤ Real.sqrt δ⁻¹ * Real.sqrt δ⁻¹ :=
+            mul_le_mul hsn htn (norm_nonneg _) (Real.sqrt_nonneg _)
+         _ = δ⁻¹ := Real.mul_self_sqrt (inv_nonneg.mpr hδ.le)
+  calc
+    ‖star (p*w)*c*(q*z)‖ ≤ (M*κ)*‖p*w‖*‖q*z‖ :=
+      HerCompression.right_products (mul_nonneg hM.le hκ0) hp0 hq0 hc w z
+    _ = (M*κ)*(‖p*w‖*‖q*z‖) := by ring
+    _ ≤ (M*κ)*δ⁻¹ := mul_le_mul_of_nonneg_left hprod (mul_nonneg hM.le hκ0)
+    _ < ζ := by
+      rw [← div_eq_mul_inv]
+      apply (div_lt_iff₀ hδ).mpr
+      have hh := (lt_div_iff₀ hM).mp hκζ
+      nlinarith
+
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+local instance diagonalizationPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance diagonalizationStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+theorem individual_to_strong (hP : PropertyP A) : UnrestrictedDiagonalization A := by
+  intro a b ha hb c ε hε
+  let M := max 1 (max ‖a‖ ‖b‖)
+  have hM1 : 1 ≤ M := le_max_left _ _
+  have hM : 0 < M := lt_of_lt_of_le zero_lt_one hM1
+  have haM : ‖a‖ ≤ M := (le_max_left _ _).trans (le_max_right _ _)
+  have hbM : ‖b‖ ≤ M := (le_max_right _ _).trans (le_max_right _ _)
+  let δ := min (1/4 : ℝ) (ε/(8*M))
+  have hδ : 0 < δ := lt_min (by norm_num) (div_pos hε (mul_pos (by norm_num) hM))
+  have hδhalf : δ < 1/2 := (min_le_left _ _).trans_lt (by norm_num)
+  have hsmall : M*(2*δ+δ) < ε := by
+    have hh : δ ≤ ε/(8*M) := min_le_right _ _
+    have hh' := (le_div_iff₀ (by positivity : 0 < 8*M)).mp hh
+    nlinarith
+  have hn {x : A} (hx : ‖x‖ ≤ M) : ‖M⁻¹ • x‖ ≤ 1 := by
+    rw [norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hM)]
+    calc M⁻¹*‖x‖ ≤ M⁻¹*M := mul_le_mul_of_nonneg_left hx (inv_nonneg.mpr hM.le)
+         _ = 1 := inv_mul_cancel₀ hM.ne'
+  obtain ⟨s,t,hs,ht,hc,hsn,htn⟩ := bounded_diagonalization hP
+    (smul_nonneg (inv_nonneg.mpr hM.le) ha) (smul_nonneg (inv_nonneg.mpr hM.le) hb)
+    (hn haM) (hn hbM) c hδ hδhalf hδ (by linarith : δ ≤ 2*δ) hε
+  have hscale (x r : A) : M • (star r*(M⁻¹ • x)*r-(M⁻¹ • x)) = star r*x*r-x := by
+    simp only [mul_smul_comm, smul_mul_assoc, smul_sub, smul_smul,
+      mul_inv_cancel₀ hM.ne', one_smul]
+  refine ⟨s,t,?_,?_,hc⟩
+  · rw [← hscale a s, norm_smul, Real.norm_eq_abs, abs_of_pos hM]
+    exact (mul_lt_mul_of_pos_left hs hM).trans hsmall
+  · rw [← hscale b t, norm_smul, Real.norm_eq_abs, abs_of_pos hM]
+    exact (mul_lt_mul_of_pos_left ht hM).trans hsmall
+
+theorem individual_to_strong_spi (hP : PropertyP A) : StronglyPurelyInfinite A := by
+  intro x y hx hy ε hε
+  exact individual_to_strong hP (x*x) (y*y)
+    (by simpa only [hx.isSelfAdjoint.star_eq] using star_mul_self_nonneg x)
+    (by simpa only [hy.isSelfAdjoint.star_eq] using star_mul_self_nonneg y) (x*y) ε hε
+
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/FourChoices.lean

@@ -0,0 +1,266 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.ChoicePairs
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+variable {A : Type*} [CStarAlgebra A]
+local instance fourChoicesPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance fourChoicesStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+theorem finite_four_choices {X : A} (hX : 0 ≤ X) (B : Fin 4 → A)
+    (hp : ∀ z : A, 0 ≤ z → z ∈ fourHer X → ProperlyInfinite z)
+    (E : Finset A) {η : ℝ} (hη : 0 < η) :
+    ∃ T : Fin 4 → A,
+      (∀ i, ‖T i‖ ≤ 1) ∧ (∀ i, T i ∈ fourHer X) ∧
+      T 0 * star (T 0) = ramp (firstSandwich (firstU X (B 0)) (firstV X) η E) η (2*η) ∧
+      T 1 * star (T 1) = T 0 * star (T 0) ∧ T 0 * star (T 1) = 0 ∧
+      star (T 0) * T 0 ∈ Her (firstV X) ∧ star (T 1) * T 1 ∈ Her (firstV X) ∧
+      star (T 2) * T 3 = 0 ∧ star (T 2) * T 2 = star (T 3) * T 3 ∧
+      T 2 * star (T 2) ∈ Her (cut (lastR X (B 0) (B 2)) η) ∧
+      T 3 * star (T 3) ∈ Her (cut (lastR X (B 0) (B 2)) η) ∧
+      (∀ {D : Type*} [NonUnitalCStarAlgebra D] (π : A →⋆ₙₐ[ℂ] D),
+        4*η ≤ ‖π (lastR X (B 0) (B 2))‖ → ‖π (T 2)‖ = 1) := by
+  let U := firstU X (B 0)
+  let V := firstV X
+  let R := lastR X (B 0) (B 2)
+  let D₀ := firstSandwich U V η E
+  have hV : 0 ≤ V := cut_nonneg X _
+  have hVk : V ∈ fourHer X := firstV_mem hX
+  have hDk : D₀ ∈ fourHer X := Her_mono_of_mem (firstU_mem hX (B 0))
+    (Her_mono_of_mem (cut_mem_Her (firstU_nonneg X (B 0)) η) (firstSandwich_mem U V η E))
+  obtain ⟨T₀, hT₀norm, hT₀mem, hT₀mod, hT₀outer⟩ :=
+    first_pair_choice (firstSandwich_nonneg hV η E) hV
+      (firstSandwich_two_cuntzLE (hp V hV hVk) η E) hDk hVk hη
+  obtain ⟨T₂, hT₂norm, hT₂mem, hT₂mod, hT₂outer, hT₂rep⟩ :=
+    last_pair_choice (lastR_nonneg X (B 0) (B 2)) (lastR_mem hX _ _) hη
+      (hp (cut R η) (cut_nonneg R η)
+        (Her_mono_of_mem (lastR_mem hX _ _) (cut_mem_Her (lastR_nonneg X (B 0) (B 2)) η)))
+  refine ⟨![T₀ 0, T₀ 1, T₂ 0, T₂ 1], ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
+  · intro i; fin_cases i <;> first | exact hT₀norm _ | exact hT₂norm _
+  · intro i; fin_cases i <;> first | exact hT₀mem _ | exact hT₂mem _
+  · simpa using hT₀mod 0 0
+  · simpa using (hT₀mod 1 1).trans (hT₀mod 0 0).symm
+  · simpa using hT₀mod 0 1
+  · exact hT₀outer 0 0
+  · exact hT₀outer 1 1
+  · simpa using hT₂mod 0 1
+  · simpa using (hT₂mod 0 0).trans (hT₂mod 1 1).symm
+  · exact hT₂outer 0 0
+  · exact hT₂outer 1 1
+  · intro D _ π hR
+    exact hT₂rep π hR 0
+
+end MainGap
+
+namespace MainGap
+variable {A D : Type*} [CStarAlgebra A] [CStarAlgebra D]
+local instance fourChoicesMapDomainOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance fourChoicesMapDomainStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+local instance fourChoicesMapCodomainOrder : PartialOrder D := CStarAlgebra.spectralOrder D
+local instance fourChoicesMapCodomainStarOrder : StarOrderedRing D := CStarAlgebra.spectralOrderedRing D
+variable (π : A →⋆ₐ[ℂ] D)
+
+lemma map_cut_sa {a : A} (ha : IsSelfAdjoint a) {l : ℝ} (hl : 0 ≤ l) :
+    π (cut a l) = cut (π a) l :=
+  π.toNonUnitalStarAlgHom.map_cfcₙ (fun t : ℝ => max (t-l) 0) a
+    ((continuous_id.sub continuous_const).max continuous_const).continuousOn
+    (by simp [max_eq_right (neg_nonpos.mpr hl)]) (map_continuous π) ha (ha.map π)
+
+lemma map_ramp_sa {a : A} (ha : IsSelfAdjoint a) {l u : ℝ} (hl : 0 ≤ l) :
+    π (ramp a l u) = ramp (π a) l u :=
+  π.toNonUnitalStarAlgHom.map_cfcₙ (rampFn l u) a
+    (continuous_rampFn l u).continuousOn (rampFn_zero hl)
+    (map_continuous π) ha (ha.map π)
+
+lemma map_deficiency {d : A} (hd : IsSelfAdjoint d) :
+    π (deficiency d) = deficiency (π d) :=
+  π.map_cfc (fun t : ℝ => max (1/2-t) 0) d
+    ((continuous_const.sub continuous_id).max continuous_const).continuousOn
+    (map_continuous π) hd (hd.map π)
+
+lemma map_sqrt {a : A} (ha : 0 ≤ a) : π (CFC.sqrt a) = CFC.sqrt (π a) :=
+  π.toNonUnitalStarAlgHom.map_cfcₙ NNReal.sqrt a (by fun_prop) (by simp)
+    (map_continuous π) ha (map_nonneg π ha)
+
+lemma map_firstX {X : A} (hX : IsSelfAdjoint X) : π (firstX X) = firstX (π X) :=
+  map_cut_sa π hX (by norm_num)
+lemma map_firstV {X : A} (hX : IsSelfAdjoint X) : π (firstV X) = firstV (π X) :=
+  map_cut_sa π hX (by norm_num)
+lemma map_firstH {X : A} (hX : IsSelfAdjoint X) : π (firstH X) = firstH (π X) :=
+  map_ramp_sa π hX (by norm_num)
+lemma map_firstK {X : A} (hX : IsSelfAdjoint X) : π (firstK X) = firstK (π X) :=
+  map_ramp_sa π hX (by norm_num)
+
+lemma map_firstU {X : A} (hX : IsSelfAdjoint X) (B : A) :
+    π (firstU X B) = firstU (π X) (π B) := by
+  simp only [firstU, map_mul, map_firstX π hX,
+    map_deficiency π (.mul_star_self B), map_star]
+
+lemma map_firstR {X : A} (hX : IsSelfAdjoint X) (B : A) :
+    π (firstR X B) = firstR (π X) (π B) := by
+  change π ((Real.sqrt 2) • (star B * firstH X)) = _
+  calc
+    π ((Real.sqrt 2) • (star B * firstH X)) = (Real.sqrt 2) • π (star B * firstH X) :=
+      π.toAlgHom.map_smul_of_tower _ _
+    _ = firstR (π X) (π B) := by simp only [firstR, map_mul, map_star, map_firstH π hX]
+
+lemma map_scalingComplement {H : A} (hH : IsSelfAdjoint H) (hn : ‖H‖ ≤ 1) :
+    π (scalingComplement H) = scalingComplement (π H) := by
+  simp only [scalingComplement, map_sqrt π (complement_nonneg hH hn), map_sub, map_one, map_mul]
+
+lemma map_scalingDefect {H : A} (hH : IsSelfAdjoint H) (hn : ‖H‖ ≤ 1) (r : A) :
+    π (scalingDefect H r) = scalingDefect (π H) (π r) := by
+  simp only [scalingDefect, scalingIsometry, map_sub, map_mul, map_star, map_one, map_add,
+    map_scalingComplement π hH hn]
+
+lemma scalingDefect_selfAdjoint (H r : A) : IsSelfAdjoint (scalingDefect H r) :=
+  (IsSelfAdjoint.one A).sub (.mul_star_self _)
+
+lemma prospective_input_selfAdjoint (X B : A) :
+    IsSelfAdjoint (firstK X * scalingDefect (firstH X) (firstR X B) * firstK X) := by
+  have hK : IsSelfAdjoint (firstK X) := .of_nonneg (ramp_nonneg X (by norm_num))
+  rw [isSelfAdjoint_iff]
+  simp only [star_mul, hK.star_eq, scalingDefect_selfAdjoint _ _ |>.star_eq, mul_assoc]
+
+lemma map_prospectiveDefect {X : A} (hX : IsSelfAdjoint X) (B : A) :
+    π (prospectiveDefect X B) = prospectiveDefect (π X) (π B) := by
+  have hH : IsSelfAdjoint (firstH X) := .of_nonneg (ramp_nonneg X (by norm_num))
+  have hn : ‖firstH X‖ ≤ 1 := norm_ramp_le_one _ (by norm_num)
+  simp only [prospectiveDefect, map_ramp_sa π (prospective_input_selfAdjoint X B) le_rfl,
+    map_mul, map_firstK π hX, map_scalingDefect π hH hn, map_firstH π hX,
+    map_firstR π hX]
+
+lemma map_lastX {X : A} (hX : IsSelfAdjoint X) (B : A) :
+    π (lastX X B) = lastX (π X) (π B) := by
+  have hp : IsSelfAdjoint (prospectiveDefect X B) := .of_nonneg (ramp_nonneg _ (by norm_num))
+  rw [lastX, map_cut_sa π hp (by norm_num), map_prospectiveDefect π hX]
+  rfl
+
+lemma map_lastR {X : A} (hX : IsSelfAdjoint X) (B C : A) :
+    π (lastR X B C) = lastR (π X) (π B) (π C) := by
+  simp only [lastR, map_mul, map_lastX π hX,
+    map_deficiency π (.mul_star_self C), map_star]
+
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [CStarAlgebra A]
+local instance fourChoiceStructureOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance fourChoiceStructureStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+universe v
+
+structure FourChoice (X : A) (B : Fin 4 → A) (E : Finset A) (η : ℝ) where
+  T : Fin 4 → A
+  contractive : ∀ i, ‖T i‖ ≤ 1
+  mem : ∀ i, T i ∈ fourHer X
+  first_mod : T 0 * star (T 0) = ramp (firstSandwich (firstU X (B 0)) (firstV X) η E) η (2*η)
+  first_equal : T 1 * star (T 1) = T 0 * star (T 0)
+  first_cross : T 0 * star (T 1) = 0
+  outer₀ : star (T 0) * T 0 ∈ Her (firstV X)
+  outer₁ : star (T 1) * T 1 ∈ Her (firstV X)
+  last_cross : star (T 2) * T 3 = 0
+  last_equal : star (T 2) * T 2 = star (T 3) * T 3
+  outer₂ : T 2 * star (T 2) ∈ Her (cut (lastR X (B 0) (B 2)) η)
+  outer₃ : T 3 * star (T 3) ∈ Her (cut (lastR X (B 0) (B 2)) η)
+  last_norm : ∀ {D : Type v} [NonUnitalCStarAlgebra D] (π : A →⋆ₙₐ[ℂ] D),
+    4*η ≤ ‖π (lastR X (B 0) (B 2))‖ → ‖π (T 2)‖ = 1
+
+theorem fourChoice_nonempty {X : A} (hX : 0 ≤ X) (B : Fin 4 → A)
+    (hp : ∀ z : A, 0 ≤ z → z ∈ fourHer X → ProperlyInfinite z)
+    (E : Finset A) {η : ℝ} (hη : 0 < η) : Nonempty (FourChoice.{v, _} X B E η) := by
+  obtain ⟨T, h₁, h₂, h₃, h₄, h₅, h₆, h₇, h₈, h₉, h₁₀, h₁₁, h₁₂⟩ :=
+    finite_four_choices hX B hp E hη
+  exact ⟨⟨T, h₁, h₂, h₃, h₄, h₅, h₆, h₇, h₈, h₉, h₁₀, h₁₁, h₁₂⟩⟩
+
+lemma firstH_fixes_V {X : A} (hX : 0 ≤ X) : firstH X * firstV X = firstV X :=
+  ramp_mul_cut hX (by norm_num) (by norm_num) le_rfl
+
+namespace FourChoice
+variable {X : A} {B : Fin 4 → A} {E : Finset A} {η : ℝ} (F : FourChoice.{v, _} X B E η)
+
+lemma first_mem (hη : 0 < η) :
+    F.T 0 * star (F.T 0) ∈ Her (cut (firstU X (B 0)) η) := by
+  rw [F.first_mod]
+  exact Her_mono_of_mem (firstSandwich_mem _ _ η E)
+    (Her_mono_of_mem (cut_mem_Her (firstSandwich_nonneg (cut_nonneg X _) η E) η)
+      (ramp_mem_Her_cut (firstSandwich_nonneg (cut_nonneg X _) η E) hη.le))
+
+lemma first_support₀ (hX : 0 ≤ X) : firstH X * star (F.T 0) = star (F.T 0) := by
+  apply fixed_left_of_modulus
+  simp only [star_star]
+  exact Her_fixed_left (firstH_fixes_V hX) F.outer₀
+
+lemma first_support₁ (hX : 0 ≤ X) : firstH X * star (F.T 1) = star (F.T 1) := by
+  apply fixed_left_of_modulus
+  simp only [star_star]
+  exact Her_fixed_left (firstH_fixes_V hX) F.outer₁
+
+lemma last_support : ramp (prospectiveDefect X (B 0)) 0 (1/2) * F.T 3 = F.T 3 := by
+  apply fixed_left_of_modulus
+  apply Her_fixed_left (ramp_mul_cut (prospectiveDefect_nonneg X _)
+    le_rfl (by norm_num : (0:ℝ) < 1/2) le_rfl)
+  exact Her_mono_of_mem (squareSandwich_mem (.of_nonneg (lastX_nonneg X _)) _)
+    (Her_mono_of_mem (cut_mem_Her (lastR_nonneg X _ _) η) F.outer₃)
+
+variable {D : Type v} [CStarAlgebra D]
+local instance fourChoiceRepresentationOrder : PartialOrder D := CStarAlgebra.spectralOrder D
+local instance fourChoiceRepresentationStarOrder : StarOrderedRing D :=
+  CStarAlgebra.spectralOrderedRing D
+variable (π : A →⋆ₐ[ℂ] D) (hX : 0 ≤ X) (hη : 0 < η)
+  (hmatch : ∀ i, π (F.T i) = π (B i))
+
+include F hX hη hmatch in
+lemma first_bound : π (B 0) * star (π (B 0)) ≤ (1/2 : ℝ) • (1 : D) := by
+  have hm := Her_map π.toNonUnitalStarAlgHom (F.first_mem hη)
+  change π (F.T 0 * star (F.T 0)) ∈ Her (π (cut (firstU X (B 0)) η)) at hm
+  simp only [map_mul, map_star, hmatch] at hm
+  rw [map_cut_sa π (.of_nonneg (firstU_nonneg X (B 0))) hη.le,
+    map_firstU π (.of_nonneg hX)] at hm
+  exact selfConsistent_cutoff_bound (cut_nonneg (π X) _)
+    (mul_star_self_nonneg _) hη (by norm_num) hm
+
+include F hX hη hmatch in
+lemma last_bound : π (B 2) * star (π (B 2)) ≤ (1/2 : ℝ) • (1 : D) := by
+  have hm := Her_map π.toNonUnitalStarAlgHom F.outer₂
+  change π (F.T 2 * star (F.T 2)) ∈ Her (π (cut (lastR X (B 0) (B 2)) η)) at hm
+  simp only [map_mul, map_star, hmatch] at hm
+  rw [map_cut_sa π (.of_nonneg (lastR_nonneg X (B 0) (B 2))) hη.le,
+    map_lastR π (.of_nonneg hX)] at hm
+  exact selfConsistent_cutoff_bound (lastX_nonneg (π X) _)
+    (mul_star_self_nonneg _) hη (by norm_num) hm
+
+include F hX hη hmatch in
+lemma first_norm : ‖π (firstSandwich (firstU X (B 0)) (firstV X) η E)‖ < 2*η := by
+  have hpos : 0 ≤ firstSandwich (firstU X (B 0)) (firstV X) η E :=
+    firstSandwich_nonneg (cut_nonneg X _) η E
+  have hmod := congrArg π F.first_mod
+  rw [map_mul, map_star, hmatch, map_ramp_sa π (.of_nonneg hpos) hη.le] at hmod
+  apply norm_ramp_bound (map_nonneg π hpos)
+    hη (by norm_num : (0:ℝ) ≤ 1/2) (by norm_num : (1/2:ℝ) < 1)
+  rw [← hmod]
+  exact F.first_bound π hX hη hmatch
+
+include F hX hη hmatch in
+lemma last_norm_lt : ‖π (lastR X (B 0) (B 2))‖ < 4*η := by
+  by_contra! hn
+  have hone : ‖π (B 2)‖ = 1 := by
+    have ht : ‖π (F.T 2)‖ = 1 := F.last_norm π.toNonUnitalStarAlgHom hn
+    rwa [hmatch] at ht
+  have hle : ‖π (B 2) * star (π (B 2))‖ ≤ 1/2 := by
+    apply (CStarAlgebra.norm_le_iff_le_algebraMap _ (by norm_num : (0:ℝ) ≤ 1/2)
+      (mul_star_self_nonneg _)).mpr
+    simpa only [Algebra.algebraMap_eq_smul_one] using F.last_bound π hX hη hmatch
+  rw [CStarRing.norm_self_mul_star, hone] at hle
+  norm_num at hle
+
+end FourChoice
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Graph.lean

@@ -0,0 +1,639 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Avoidance
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+namespace OrthogonalSlots
+section GraphAlgebra
+variable {n : ℕ} {h v : A} (S : OrthogonalSlots n h v)
+
+def graphWord (R : Fin n → A) (hR : ∀ i (k : Her h), R i * (k : A) ∈ Her h)
+    (k : Her h) : A := ∑ i, S.carrier i ⟨R i * (k : A), hR i k⟩
+
+lemma graphWord_inner (R : Fin n → A) (hR : ∀ i (k : Her h), R i * (k : A) ∈ Her h)
+    (k l : Her h) :
+    star (S.graphWord R hR k) * S.graphWord R hR l =
+      star (k : A) * (∑ i, star (R i) * R i) * (l : A) := by
+  classical
+  simp only [graphWord, star_sum, Finset.sum_mul, Finset.mul_sum, S.inner]
+  simp only [Finset.sum_ite_eq', Finset.mem_univ, ite_true]
+  simp only [star_mul, mul_assoc]
+
+lemma graphWord_outer (R : Fin n → A) (hR : ∀ i (k : Her h), R i * (k : A) ∈ Her h)
+    (k l : Her h) : S.graphWord R hR k * star (S.graphWord R hR l) ∈ Her v := by
+  classical
+  simp only [graphWord, star_sum, Finset.sum_mul, Finset.mul_sum]
+  exact (Her v).sum_mem fun i _ => (Her v).sum_mem fun j _ => S.outer j i _ _
+
+lemma slot_graphWord (R : Fin n → A) (hR : ∀ i (k : Her h), R i * (k : A) ∈ Her h)
+    (i : Fin n) (k l : Her h) :
+    star (S.carrier i k) * S.graphWord R hR l = star (k : A) * R i * (l : A) := by
+  classical
+  simp only [graphWord, Finset.mul_sum, S.inner]
+  simp [mul_assoc]
+
+lemma graphWord_mul (R : Fin n → A) (hR : ∀ i (k : Her h), R i * (k : A) ∈ Her h)
+    (k l : Her h) : S.graphWord R hR (k*l) = S.graphWord R hR k * (l : A) := by
+  classical
+  simp only [graphWord, Finset.sum_mul]
+  apply Finset.sum_congr rfl
+  intro i hi
+  have he : (⟨R i * ((k*l : Her h) : A), hR i (k*l)⟩ : Her h) =
+      ⟨R i * (k : A), hR i k⟩ * l := by apply Subtype.ext; exact (mul_assoc _ _ _).symm
+  rw [he, S.mul]
+
+end GraphAlgebra
+end OrthogonalSlots
+
+section UnitalGraph
+variable {D : Type*} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+omit [PartialOrder D] [StarOrderedRing D] in
+lemma cfc_mul_mem_Her {h q : D} (hq : q ∈ Her h) (hqa : IsSelfAdjoint q)
+    (f : ℝ → ℝ) (hf : Continuous f) {k : D} (hk : k ∈ Her h) :
+    cfc f q * k ∈ Her h := by
+  have hm : cfcₙ (fun x => f x - f 0) q ∈ Her h := cfcₙ_mem (𝕜' := ℂ) _ hq
+  have he : cfcₙ (fun x => f x - f 0) q = cfc f q - (f 0) • (1 : D) := by
+    rw [cfcₙ_eq_cfc (f := fun x => f x - f 0) (a := q) ((hf.sub continuous_const).continuousOn) (by simp),
+      cfc_sub f (fun _ => f 0) q hf.continuousOn continuous_const.continuousOn,
+      cfc_const _ q hqa, Algebra.algebraMap_eq_smul_one]
+  have he' : cfc f q = cfcₙ (fun x => f x - f 0) q + (f 0) • (1 : D) := by rw [he]; abel
+  rw [he', add_mul, smul_mul_assoc, one_mul]
+  exact (Her h).add_mem ((Her h).mul_mem hm hk) (real_smul_mem_Her hk _)
+
+def graphComplement (S : Fin 4 → D) : D :=
+  cfc (fun t : ℝ => Real.sqrt ((15-t)/16)) (∑ i, star (S i)*S i)
+
+lemma graphComplement_nonneg (S : Fin 4 → D) : 0 ≤ graphComplement S :=
+  cfc_nonneg fun _ _ => Real.sqrt_nonneg _
+
+lemma graphComplement_mul_self (S : Fin 4 → D) (hS : ∀ i, ‖S i‖ ≤ 1) :
+    graphComplement S * graphComplement S =
+      (15/16 : ℝ) • (1 : D) - (1/16 : ℝ) • (∑ i, star (S i)*S i) := by
+  rcases subsingleton_or_nontrivial D with hD | hD
+  · exact Subsingleton.elim _ _
+  let q := ∑ i, star (S i)*S i
+  have hq : 0 ≤ q := Finset.sum_nonneg fun i _ => star_mul_self_nonneg _
+  have hn : ‖q‖ ≤ 4 := by
+    calc
+      ‖q‖ ≤ ∑ i, ‖star (S i)*S i‖ := norm_sum_le _ _
+      _ ≤ ∑ _i : Fin 4, (1 : ℝ) := by
+        apply Finset.sum_le_sum
+        intro i hi
+        rw [CStarRing.norm_star_mul_self]
+        simpa using mul_self_le_mul_self (norm_nonneg _) (hS i)
+      _ = 4 := by simp
+  have hc : Continuous (fun t : ℝ => Real.sqrt ((15-t)/16)) := by fun_prop
+  change cfc _ q * cfc _ q = _
+  rw [← cfc_mul _ _ q hc.continuousOn hc.continuousOn]
+  have he : cfc (fun t : ℝ => Real.sqrt ((15-t)/16) * Real.sqrt ((15-t)/16)) q =
+      cfc (fun t : ℝ => 15/16 - (1/16)*t) q := by
+    apply cfc_congr
+    intro t ht
+    have ht' : t ≤ 4 := (Real.le_norm_self t).trans ((spectrum.norm_le_norm_of_mem ht).trans hn)
+    dsimp only
+    rw [Real.mul_self_sqrt (by linarith : 0 ≤ (15-t)/16)]
+    ring
+  rw [he, cfc_sub (fun _ : ℝ => 15/16) (fun t : ℝ => (1/16)*t) q,
+    cfc_const _ q hq.isSelfAdjoint, cfc_const_mul (1/16 : ℝ) (fun t : ℝ => t) q,
+    cfc_id' ℝ q hq.isSelfAdjoint, Algebra.algebraMap_eq_smul_one]
+
+lemma graphComplement_mul_mem {h : D} (S : Fin 4 → D) (hS : ∀ i, S i ∈ Her h)
+    {k : D} (hk : k ∈ Her h) : graphComplement S * k ∈ Her h := by
+  apply cfc_mul_mem_Her ?_ ?_ _ (by fun_prop) hk
+  · exact (Her h).sum_mem fun i _ => (Her h).mul_mem (StarMemClass.star_mem (s := Her h) (hS i)) (hS i)
+  · exact (Finset.sum_nonneg fun i _ => star_mul_self_nonneg (S i)).isSelfAdjoint
+
+def graphCoeffs (T : Fin 4 → D) : Fin 6 → D :=
+  ![(1/4 : ℝ) • 1, (1/4 : ℝ) • T 0, (1/4 : ℝ) • T 1,
+    (1/4 : ℝ) • T 2, (1/4 : ℝ) • T 3, graphComplement T]
+
+lemma graphCoeffs_inner (T : Fin 4 → D) (hT : ∀ i, ‖T i‖ ≤ 1) :
+    ∑ i, star (graphCoeffs T i) * graphCoeffs T i = 1 := by
+  classical
+  rw [Fin.sum_univ_six]
+  dsimp [graphCoeffs]
+  simp only [star_smul, star_trivial, star_one, smul_mul_assoc, mul_smul_comm,
+    smul_smul, one_mul]
+  rw [(graphComplement_nonneg T).isSelfAdjoint.star_eq,
+    graphComplement_mul_self T hT, Fin.sum_univ_four]
+  module
+
+lemma graphCoeffs_mem {h : D} (T : Fin 4 → D) (hT : ∀ i, T i ∈ Her h)
+    (i : Fin 6) (k : Her h) : graphCoeffs T i * (k : D) ∈ Her h := by
+  fin_cases i <;> dsimp [graphCoeffs] <;> try simp only [smul_mul_assoc, one_mul]
+  · exact real_smul_mem_Her k.property _
+  · exact real_smul_mem_Her ((Her h).mul_mem (hT 0) k.property) _
+  · exact real_smul_mem_Her ((Her h).mul_mem (hT 1) k.property) _
+  · exact real_smul_mem_Her ((Her h).mul_mem (hT 2) k.property) _
+  · exact real_smul_mem_Her ((Her h).mul_mem (hT 3) k.property) _
+  · exact graphComplement_mul_mem T hT k.property
+
+end UnitalGraph
+lemma Her_fixed_right {h t : A} (hh : IsSelfAdjoint h) (ht : h * t = h)
+    {k : A} (hk : k ∈ Her h) : k * t = k := by
+  have he : star t * h = h := by
+    simpa only [star_mul, hh.star_eq] using congrArg star ht
+  have hs := Her_fixed_left he (StarMemClass.star_mem (s := Her h) hk)
+  simpa only [star_mul, star_star] using congrArg star hs
+
+def graphInverseFn (t : ℝ) : ℝ := t / (max (1/32 : ℝ) t)^2
+
+lemma continuous_graphInverseFn : Continuous graphInverseFn := by
+  apply Continuous.div continuous_id
+    (((continuous_const : Continuous (fun _ : ℝ => (1/32 : ℝ))).max continuous_id).pow 2)
+  intro t
+  exact pow_ne_zero _ (ne_of_gt (lt_of_lt_of_le (by norm_num : (0:ℝ)<1/32) (le_max_left _ _)))
+
+lemma graphInverseFn_zero : graphInverseFn 0 = 0 := by simp [graphInverseFn]
+
+def graphInverse (X : A) : A := cfcₙ graphInverseFn X
+
+section InverseOrder
+variable [PartialOrder A] [StarOrderedRing A]
+
+omit [PartialOrder A] [StarOrderedRing A] in
+lemma graphInverse_mem {h X : A} (hX : X ∈ Her h) : graphInverse X ∈ Her h :=
+  cfcₙ_mem (𝕜' := ℂ) _ hX
+
+lemma cut_mul_graphInverse {X : A} (hX : 0 ≤ X) :
+    cut X (1/32) * (X * graphInverse X) = cut X (1/32) := by
+  have hc : Continuous (fun t : ℝ => max (t-1/32) 0) := by fun_prop
+  have h0 : (fun t : ℝ => max (t-1/32) 0) 0 = 0 := by norm_num
+  have he : X * graphInverse X = cfcₙ (fun t : ℝ => t * graphInverseFn t) X := by
+    simpa only [id_eq, cfcₙ_id' ℝ X hX.isSelfAdjoint, graphInverse] using
+      (cfcₙ_mul id graphInverseFn X continuousOn_id rfl
+        continuous_graphInverseFn.continuousOn graphInverseFn_zero).symm
+  rw [he, cut, ← cfcₙ_mul (fun t : ℝ => max (t-1/32) 0)
+    (fun t : ℝ => t * graphInverseFn t) X hc.continuousOn h0
+    (continuous_id.mul continuous_graphInverseFn).continuousOn (by simp)]
+  apply cfcₙ_congr
+  intro t ht
+  dsimp only
+  by_cases h : t ≤ 1/32
+  · rw [max_eq_right (sub_nonpos.mpr h), zero_mul]
+  · have ht0 : t ≠ 0 := ne_of_gt (lt_trans (by norm_num) (lt_of_not_ge h))
+    dsimp [graphInverseFn]
+    rw [max_eq_right (le_of_not_ge h)]
+    field_simp
+
+lemma right_fixed_by_graphInverse {X S : A} (hX : 0 ≤ X)
+    (hS : S ∈ Her (cut X (1/32))) : S * (X * graphInverse X) = S :=
+  Her_fixed_right (cut_nonneg X (1/32)).isSelfAdjoint (cut_mul_graphInverse hX) hS
+
+lemma map_graphInverse {B : Type*} [NonUnitalCStarAlgebra B] [PartialOrder B] [StarOrderedRing B]
+    (π : A →⋆ₙₐ[ℂ] B) {X : A} (hX : 0 ≤ X) :
+    π (graphInverse X) = graphInverse (π X) :=
+  π.map_cfcₙ graphInverseFn X continuous_graphInverseFn.continuousOn graphInverseFn_zero
+    (map_continuous π) hX.isSelfAdjoint (map_nonneg π hX).isSelfAdjoint
+
+end InverseOrder
+section GraphDefect
+variable {D : Type*} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+lemma positive_mul_zero_of_conjugate_zero {a x : D} (ha : 0 ≤ a)
+    (hz : star x * a * x = 0) : a * x = 0 := by
+  have hr : CFC.sqrt a * x = 0 := by
+    apply (CStarRing.star_mul_self_eq_zero_iff _).mp
+    calc
+      star (CFC.sqrt a * x) * (CFC.sqrt a * x) =
+          star x * (CFC.sqrt a * CFC.sqrt a) * x := by
+        simp only [star_mul, (CFC.sqrt_nonneg a).isSelfAdjoint.star_eq, mul_assoc]
+      _ = 0 := by rw [CFC.sqrt_mul_sqrt_self a ha, hz]
+  rw [← CFC.sqrt_mul_sqrt_self a ha, mul_assoc, hr, mul_zero]
+
+lemma positive_fixed_of_square_fixed {p x : D} (hp : 0 ≤ p)
+    (he : p * p * x = x) : p * x = x := by
+  have hi : IsUnit ((1 : D) + p) := CStarAlgebra.isUnit_of_le 1 (le_add_of_nonneg_right hp)
+  apply hi.mul_left_cancel
+  simp only [add_mul, one_mul, ← mul_assoc, he]
+  exact add_comm _ _
+
+lemma sqrt_fixed_of_fixed {p x : D} (hp : 0 ≤ p) (he : p*x=x) : CFC.sqrt p*x=x := by
+  apply positive_fixed_of_square_fixed (CFC.sqrt_nonneg _)
+  rwa [CFC.sqrt_mul_sqrt_self p hp]
+
+lemma star_mul_le_one_of_norm_le_one {x : D} (hx : ‖x‖ ≤ 1) : star x * x ≤ 1 := by
+  apply (CStarAlgebra.norm_le_one_iff_of_nonneg _ (star_mul_self_nonneg x)).mp
+  rw [CStarRing.norm_star_mul_self]
+  simpa using mul_self_le_mul_self (norm_nonneg _) hx
+
+lemma graph_defect_forces {p c y : D} (hp : 0 ≤ p) (hpn : ‖p‖ ≤ 1)
+    (hcn : ‖c‖ ≤ 1) (hy : 0 ≤ y)
+    (hd : y * (1 - star c * (p*p) * c) * y = 0) :
+    p * (c*y) = c*y ∧ star c * c * y = y := by
+  have hp2 : 0 ≤ 1 - p*p := sub_nonneg.mpr (by
+    simpa only [hp.isSelfAdjoint.star_eq] using star_mul_le_one_of_norm_le_one hpn)
+  have hc2 : 0 ≤ 1 - star c*c := sub_nonneg.mpr (star_mul_le_one_of_norm_le_one hcn)
+  have h₁ : 0 ≤ y*(1-star c*c)*y := by
+    simpa only [hy.isSelfAdjoint.star_eq] using star_left_conjugate_nonneg hc2 y
+  have h₂ : 0 ≤ star (c*y)*(1-p*p)*(c*y) := star_left_conjugate_nonneg hp2 _
+  have he : y*(1-star c*c)*y + star (c*y)*(1-p*p)*(c*y) = 0 := by
+    calc
+      _ = y * (1 - star c * (p*p) * c) * y := by
+        simp only [star_mul, hy.isSelfAdjoint.star_eq]; noncomm_ring
+      _ = 0 := hd
+  have hz₁ : y*(1-star c*c)*y = 0 := le_antisymm ((le_add_of_nonneg_right h₂).trans_eq he) h₁
+  have hz₂ : star (c*y)*(1-p*p)*(c*y) = 0 := le_antisymm ((le_add_of_nonneg_left h₁).trans_eq he) h₂
+  have hcfix := positive_mul_zero_of_conjugate_zero hc2
+    (show star y*(1-star c*c)*y=0 by simpa only [hy.isSelfAdjoint.star_eq] using hz₁)
+  have hpfix := positive_mul_zero_of_conjugate_zero hp2 hz₂
+  have hec : star c*c*y=y := by
+    apply Eq.symm
+    apply sub_eq_zero.mp
+    simpa only [sub_mul, one_mul] using hcfix
+  have hep : p*p*(c*y)=c*y := by
+    apply Eq.symm
+    apply sub_eq_zero.mp
+    simpa only [sub_mul, one_mul] using hpfix
+  exact ⟨positive_fixed_of_square_fixed hp hep, hec⟩
+
+lemma norm_conjugate_eq_of_isometric_on {c y : D} (hy : 0 ≤ y)
+    (hc : star c*c*y=y) : ‖c*y*star c‖=‖y‖ := by
+  have hs := Her_fixed_left hc (sqrt_mem_Her (self_mem_Her hy) hy)
+  have he : c*y*star c = (c*CFC.sqrt y)*star (c*CFC.sqrt y) := by
+    simp only [star_mul, (CFC.sqrt_nonneg y).isSelfAdjoint.star_eq]
+    rw [show c*y*star c = c * (CFC.sqrt y * CFC.sqrt y) * star c by rw [CFC.sqrt_mul_sqrt_self y hy]]
+    simp only [mul_assoc]
+  rw [he, CStarRing.norm_self_mul_star, ← CStarRing.norm_star_mul_self]
+  congr 1
+  calc
+    star (c*CFC.sqrt y)*(c*CFC.sqrt y) = CFC.sqrt y*(star c*c*CFC.sqrt y) := by
+      simp only [star_mul, (CFC.sqrt_nonneg y).isSelfAdjoint.star_eq, mul_assoc]
+    _ = y := by rw [hs, CFC.sqrt_mul_sqrt_self y hy]
+
+end GraphDefect
+
+section GraphConstruction
+variable {D : Type*} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+variable {h a t : D} (V : OrthogonalSlots 6 h a) (ht : 0 ≤ t) (htH : t ∈ Her h)
+
+def graphSlot (i : Fin 6) : D := V.carrier i ⟨t, htH⟩
+
+def graphZ (T : Fin 4 → D) (hT : ∀ i, T i ∈ Her h) : D :=
+  V.graphWord (graphCoeffs T) (graphCoeffs_mem T hT) ⟨CFC.sqrt t, sqrt_mem_Her htH ht⟩
+
+def graphP (T : Fin 4 → D) (hT : ∀ i, T i ∈ Her h) : D :=
+  graphZ V ht htH T hT * star (graphZ V ht htH T hT)
+
+lemma graphZ_inner (T : Fin 4 → D) (hT : ∀ i, T i ∈ Her h) (hn : ∀ i, ‖T i‖ ≤ 1) :
+    star (graphZ V ht htH T hT) * graphZ V ht htH T hT = t := by
+  rw [graphZ, V.graphWord_inner, graphCoeffs_inner T hn]
+  simpa only [mul_one, (CFC.sqrt_nonneg t).isSelfAdjoint.star_eq] using CFC.sqrt_mul_sqrt_self t ht
+
+lemma graphP_nonneg (T : Fin 4 → D) (hT : ∀ i, T i ∈ Her h) : 0 ≤ graphP V ht htH T hT :=
+  mul_star_self_nonneg _
+
+lemma graphP_mem (T : Fin 4 → D) (hT : ∀ i, T i ∈ Her h) : graphP V ht htH T hT ∈ Her a :=
+  V.graphWord_outer _ _ _ _
+
+lemma graphP_represented_norm {E : Type*} [NonUnitalCStarAlgebra E]
+    (π : D →⋆ₙₐ[ℂ] E) (T : Fin 4 → D) (hT : ∀ i, T i ∈ Her h) (hn : ∀ i, ‖T i‖ ≤ 1) :
+    ‖π (graphP V ht htH T hT)‖ = ‖π t‖ := by
+  rw [graphP, map_mul, map_star, CStarRing.norm_self_mul_star,
+    ← CStarRing.norm_star_mul_self, ← map_star, ← map_mul, graphZ_inner V ht htH T hT hn]
+
+include ht in
+lemma slot_sandwich_mem (i j : Fin 6) (F : D) :
+    star (graphSlot V htH i) * F * graphSlot V htH j ∈ Her h := by
+  let r : Her h := ⟨CFC.sqrt t, sqrt_mem_Her htH ht⟩
+  have he : (⟨t, htH⟩ : Her h) = r*r := by
+    apply Subtype.ext
+    exact (CFC.sqrt_mul_sqrt_self t ht).symm
+  have hWi : graphSlot V htH i = V.carrier i r * CFC.sqrt t := by rw [graphSlot, he, V.mul]
+  have hWj : graphSlot V htH j = V.carrier j r * CFC.sqrt t := by rw [graphSlot, he, V.mul]
+  rw [hWi, hWj, star_mul, (CFC.sqrt_nonneg t).isSelfAdjoint.star_eq]
+  have hm := Her_sandwich (sqrt_mem_Her htH ht) (star (V.carrier i r) * F * V.carrier j r)
+  simpa only [(CFC.sqrt_nonneg t).isSelfAdjoint.star_eq, mul_assoc] using hm
+
+def graphX (F : D) : D := (16 : ℝ) • (star (graphSlot V htH 0) * F * graphSlot V htH 0)
+
+def graphB (F : D) (i : Fin 4) : D := (16 : ℝ) •
+  (star (graphSlot V htH i.castSucc.succ) * F * graphSlot V htH 0 * graphInverse (graphX V htH F))
+
+lemma graphX_nonneg {F : D} (hF : 0 ≤ F) : 0 ≤ graphX V htH F :=
+  smul_nonneg (by norm_num) (star_left_conjugate_nonneg hF _)
+
+include ht in
+lemma graphX_mem (F : D) : graphX V htH F ∈ Her h :=
+  real_smul_mem_Her (slot_sandwich_mem V ht htH 0 0 F) _
+
+include ht in
+lemma graphB_mem (F : D) (i : Fin 4) : graphB V htH F i ∈ Her h :=
+  real_smul_mem_Her ((Her h).mul_mem (slot_sandwich_mem V ht htH _ _ F)
+    (graphInverse_mem (graphX_mem V ht htH F))) _
+
+lemma graphSlot0_Z (T : Fin 4 → D) (hT : ∀ i, T i ∈ Her h) :
+    star (graphSlot V htH 0) * graphZ V ht htH T hT = (1/4 : ℝ) • (t * CFC.sqrt t) := by
+  rw [graphSlot, graphZ, V.slot_graphWord]
+  simp [graphCoeffs, ht.isSelfAdjoint.star_eq]
+
+lemma graphSlot_Z (T : Fin 4 → D) (hT : ∀ i, T i ∈ Her h) (i : Fin 4) :
+    star (graphSlot V htH i.castSucc.succ) * graphZ V ht htH T hT =
+      (1/4 : ℝ) • (t * T i * CFC.sqrt t) := by
+  rw [graphSlot, graphZ, V.slot_graphWord]
+  have he : graphCoeffs T i.castSucc.succ = (1/4 : ℝ) • T i := by fin_cases i <;> rfl
+  rw [he, ht.isSelfAdjoint.star_eq, mul_smul_comm, smul_mul_assoc]
+
+lemma norm_compression_eq_of_fixed {z F : D} (hF : 0 ≤ F) (hfix : z*star z*F=F) :
+    ‖star z*F*z‖=‖F‖ := by
+  have hs := Her_fixed_left hfix (sqrt_mem_Her (self_mem_Her hF) hF)
+  calc
+    ‖star z*F*z‖ = ‖star (CFC.sqrt F*z)*(CFC.sqrt F*z)‖ := by
+      congr 1
+      simp only [star_mul, (CFC.sqrt_nonneg F).isSelfAdjoint.star_eq]
+      calc
+        star z*F*z = star z*(CFC.sqrt F*CFC.sqrt F)*z := by rw [CFC.sqrt_mul_sqrt_self F hF]
+        _ = _ := by noncomm_ring
+    _ = ‖(CFC.sqrt F*z)*star (CFC.sqrt F*z)‖ := by
+      rw [CStarRing.norm_star_mul_self, CStarRing.norm_self_mul_star]
+    _ = ‖F‖ := by
+      congr 1
+      calc
+        (CFC.sqrt F*z)*star (CFC.sqrt F*z) = CFC.sqrt F*(z*star z*CFC.sqrt F) := by
+          simp only [star_mul, (CFC.sqrt_nonneg F).isSelfAdjoint.star_eq, mul_assoc]
+        _ = F := by rw [hs, CFC.sqrt_mul_sqrt_self F hF]
+
+theorem graph_failure (htn : ‖t‖ ≤ 1) (c y : D) (hy : 0 ≤ y) (hcn : ‖c‖ ≤ 1)
+    (T : Fin 4 → D) (hT : ∀ i, T i ∈ Her h) (hTn : ∀ i, ‖T i‖ ≤ 1)
+    (hTX : ∀ i, T i ∈ Her (cut (graphX V htH (c*y*star c)) (1/32)))
+    (hd : y * (1-star c*(graphP V ht htH T hT * graphP V ht htH T hT)*c)*y=0) :
+    ‖graphX V htH (c*y*star c)‖=‖y‖ ∧ ∀ i, graphB V htH (c*y*star c) i = T i := by
+  let z := graphZ V ht htH T hT
+  let p := z*star z
+  let F := c*y*star c
+  let H₀ := star z*F*z
+  have hp : 0 ≤ p := mul_star_self_nonneg z
+  have hpn : ‖p‖ ≤ 1 := by
+    change ‖graphP V ht htH T hT‖ ≤ 1
+    change ‖z*star z‖ ≤ 1
+    rw [CStarRing.norm_self_mul_star, ← CStarRing.norm_star_mul_self]
+    change ‖star (graphZ V ht htH T hT)*graphZ V ht htH T hT‖ ≤ 1
+    rw [graphZ_inner V ht htH T hT hTn]
+    exact htn
+  have hz : star z*z=t := graphZ_inner V ht htH T hT hTn
+  have hdf : y*(1-star c*(p*p)*c)*y=0 := hd
+  obtain ⟨hpc,hcc⟩ := graph_defect_forces hp hpn hcn hy hdf
+  have hF : 0 ≤ F := star_right_conjugate_nonneg hy c
+  have hFH : 0 ≤ H₀ := star_left_conjugate_nonneg hF z
+  have hpF : p*F=F := by
+    change p*(c*y*star c)=c*y*star c
+    rw [← mul_assoc, hpc]
+  have hFp : F*p=F := by
+    simpa only [star_mul, hF.isSelfAdjoint.star_eq, hp.isSelfAdjoint.star_eq] using congrArg star hpF
+  have heF : F=z*H₀*star z := by
+    calc
+      F = p*F*p := by rw [hpF,hFp]
+      _ = z*H₀*star z := by dsimp [p,H₀]; noncomm_ring
+  have htH₀ : t*H₀=H₀ := by
+    calc
+      t*H₀ = star z*(p*F)*z := by rw [← hz]; dsimp [H₀,p]; noncomm_ring
+      _ = H₀ := by rw [hpF]
+  have hH₀t : H₀*t=H₀ := by
+    simpa only [star_mul, hFH.isSelfAdjoint.star_eq, ht.isSelfAdjoint.star_eq] using congrArg star htH₀
+  have hrH₀ : CFC.sqrt t*H₀=H₀ := sqrt_fixed_of_fixed ht htH₀
+  have hH₀r : H₀*CFC.sqrt t=H₀ := by
+    simpa only [star_mul, hFH.isSelfAdjoint.star_eq, (CFC.sqrt_nonneg t).isSelfAdjoint.star_eq]
+      using congrArg star hrH₀
+  have hW₀ : star (graphSlot V htH 0)*z=(1/4 : ℝ) • (t*CFC.sqrt t) :=
+    graphSlot0_Z V ht htH T hT
+  have hzW : star z*graphSlot V htH 0=(1/4 : ℝ) • (CFC.sqrt t*t) := by
+    simpa only [star_mul, star_star, star_smul, star_trivial,
+      ht.isSelfAdjoint.star_eq, (CFC.sqrt_nonneg t).isSelfAdjoint.star_eq] using congrArg star hW₀
+  have hW (i : Fin 6) : star (graphSlot V htH i)*F*graphSlot V htH 0 =
+      (star (graphSlot V htH i)*z)*H₀*(star z*graphSlot V htH 0) := by
+    rw [heF]; noncomm_ring
+  have hXeq : graphX V htH F=H₀ := by
+    rw [graphX, hW 0, hW₀, hzW]
+    simp only [smul_mul_assoc, mul_smul_comm, smul_smul]
+    rw [show (t*CFC.sqrt t)*H₀*(CFC.sqrt t*t)=H₀ by
+      rw [mul_assoc t (CFC.sqrt t) H₀, hrH₀, htH₀, ← mul_assoc, hH₀r, hH₀t]]
+    norm_num
+  have hX : 0 ≤ graphX V htH F := graphX_nonneg V htH hF
+  refine ⟨?_, fun i => ?_⟩
+  · rw [hXeq, norm_compression_eq_of_fixed hF hpF, norm_conjugate_eq_of_isometric_on hy hcc]
+  · have hTi := hTX i
+    change T i ∈ Her (cut (graphX V htH F) (1/32)) at hTi
+    have htX : t*graphX V htH F=graphX V htH F := by rw [hXeq]; exact htH₀
+    have htT : t*T i=T i := Her_fixed_left htX (Her_mono_of_mem (cut_mem_Her hX _) hTi)
+    have hright := right_fixed_by_graphInverse hX hTi
+    change graphB V htH F i=T i
+    rw [graphB, hW i.castSucc.succ, graphSlot_Z V ht htH T hT i, hzW]
+    simp only [smul_mul_assoc, mul_smul_comm, smul_smul]
+    have he : (t*T i*CFC.sqrt t)*H₀*(CFC.sqrt t*t)*graphInverse (graphX V htH F) = T i := by
+      calc
+        _ = (t*T i)*H₀*graphInverse (graphX V htH F) := by
+          rw [mul_assoc (t*T i) (CFC.sqrt t) H₀, hrH₀,
+            mul_assoc (t*T i) H₀ (CFC.sqrt t*t), ← mul_assoc H₀,
+            hH₀r, hH₀t]
+        _ = T i := by rw [htT, ← hXeq, mul_assoc]; exact hright
+    rw [he]
+    norm_num
+
+end GraphConstruction
+
+section AbstractMeasurements
+variable {D : Type*} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+def measurementX (w F : D) : D := (16 : ℝ) • (star w*F*w)
+def measurementB (w : Fin 6 → D) (F : D) (i : Fin 4) : D :=
+  (16 : ℝ) • (star (w i.castSucc.succ)*F*w 0*graphInverse (measurementX (w 0) F))
+
+theorem graph_failure_of_identities {t z : D} (ht : 0 ≤ t) (htn : ‖t‖ ≤ 1)
+    (w : Fin 6 → D) (hz : star z*z=t) (T : Fin 4 → D)
+    (hW₀ : star (w 0)*z=(1/4 : ℝ) • (t*CFC.sqrt t))
+    (hWi : ∀ i : Fin 4, star (w i.castSucc.succ)*z=(1/4 : ℝ) • (t*T i*CFC.sqrt t))
+    (c y : D) (hy : 0 ≤ y) (hcn : ‖c‖ ≤ 1)
+    (hTX : ∀ i, T i ∈ Her (cut (measurementX (w 0) (c*y*star c)) (1/32)))
+    (hd : y*(1-star c*((z*star z)*(z*star z))*c)*y=0) :
+    ‖measurementX (w 0) (c*y*star c)‖=‖y‖ ∧ ∀ i, measurementB w (c*y*star c) i=T i := by
+  let p := z*star z
+  let F := c*y*star c
+  let H₀ := star z*F*z
+  have hp : 0 ≤ p := mul_star_self_nonneg z
+  have hpn : ‖p‖ ≤ 1 := by
+    change ‖z*star z‖ ≤ 1
+    rw [CStarRing.norm_self_mul_star, ← CStarRing.norm_star_mul_self, hz]
+    exact htn
+  have hdf : y*(1-star c*(p*p)*c)*y=0 := hd
+  obtain ⟨hpc,hcc⟩ := graph_defect_forces hp hpn hcn hy hdf
+  have hF : 0 ≤ F := star_right_conjugate_nonneg hy c
+  have hFH : 0 ≤ H₀ := star_left_conjugate_nonneg hF z
+  have hpF : p*F=F := by
+    change p*(c*y*star c)=c*y*star c
+    rw [← mul_assoc, hpc]
+  have hFp : F*p=F := by
+    simpa only [star_mul, hF.isSelfAdjoint.star_eq, hp.isSelfAdjoint.star_eq] using congrArg star hpF
+  have heF : F=z*H₀*star z := by
+    calc
+      F = p*F*p := by rw [hpF,hFp]
+      _ = z*H₀*star z := by dsimp [p,H₀]; noncomm_ring
+  have htH₀ : t*H₀=H₀ := by
+    calc
+      t*H₀ = star z*(p*F)*z := by rw [← hz]; dsimp [H₀,p]; noncomm_ring
+      _ = H₀ := by rw [hpF]
+  have hH₀t : H₀*t=H₀ := by
+    simpa only [star_mul, hFH.isSelfAdjoint.star_eq, ht.isSelfAdjoint.star_eq] using congrArg star htH₀
+  have hrH₀ : CFC.sqrt t*H₀=H₀ := sqrt_fixed_of_fixed ht htH₀
+  have hH₀r : H₀*CFC.sqrt t=H₀ := by
+    simpa only [star_mul, hFH.isSelfAdjoint.star_eq, (CFC.sqrt_nonneg t).isSelfAdjoint.star_eq]
+      using congrArg star hrH₀
+  have hzW : star z*w 0=(1/4 : ℝ) • (CFC.sqrt t*t) := by
+    simpa only [star_mul, star_star, star_smul, star_trivial,
+      ht.isSelfAdjoint.star_eq, (CFC.sqrt_nonneg t).isSelfAdjoint.star_eq] using congrArg star hW₀
+  have hW (i : Fin 6) : star (w i)*F*w 0 =
+      (star (w i)*z)*H₀*(star z*w 0) := by
+    rw [heF]; noncomm_ring
+  have hXeq : measurementX (w 0) F=H₀ := by
+    rw [measurementX, hW 0, hW₀, hzW]
+    simp only [smul_mul_assoc, mul_smul_comm, smul_smul]
+    rw [show (t*CFC.sqrt t)*H₀*(CFC.sqrt t*t)=H₀ by
+      rw [mul_assoc t (CFC.sqrt t) H₀, hrH₀, htH₀, ← mul_assoc, hH₀r, hH₀t]]
+    norm_num
+  have hX : 0 ≤ measurementX (w 0) F := smul_nonneg (by norm_num) (star_left_conjugate_nonneg hF (w 0))
+  refine ⟨?_, fun i => ?_⟩
+  · rw [hXeq, norm_compression_eq_of_fixed hF hpF, norm_conjugate_eq_of_isometric_on hy hcc]
+  · have hTi := hTX i
+    change T i ∈ Her (cut (measurementX (w 0) F) (1/32)) at hTi
+    have htX : t*measurementX (w 0) F=measurementX (w 0) F := by rw [hXeq]; exact htH₀
+    have htT : t*T i=T i := Her_fixed_left htX (Her_mono_of_mem (cut_mem_Her hX _) hTi)
+    have hright := right_fixed_by_graphInverse hX hTi
+    change measurementB w F i=T i
+    rw [measurementB, hW i.castSucc.succ, hWi i, hzW]
+    simp only [smul_mul_assoc, mul_smul_comm, smul_smul]
+    have he : (t*T i*CFC.sqrt t)*H₀*(CFC.sqrt t*t)*graphInverse (measurementX (w 0) F) = T i := by
+      calc
+        _ = (t*T i)*H₀*graphInverse (measurementX (w 0) F) := by
+          rw [mul_assoc (t*T i) (CFC.sqrt t) H₀, hrH₀,
+            mul_assoc (t*T i) H₀ (CFC.sqrt t*t), ← mul_assoc H₀,
+            hH₀r, hH₀t]
+        _ = T i := by rw [htT, ← hXeq, mul_assoc]; exact hright
+    rw [he]
+    norm_num
+
+end AbstractMeasurements
+
+section RepresentedGraph
+variable {D E : Type*} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+  [CStarAlgebra E] [PartialOrder E] [StarOrderedRing E]
+variable (π : D →⋆ₐ[ℂ] E) {h a t : D} (V : OrthogonalSlots 6 h a)
+  (ht : 0 ≤ t) (htH : t ∈ Her h)
+
+omit [PartialOrder D] [StarOrderedRing D] [PartialOrder E] [StarOrderedRing E] in
+lemma graph_map_real_smul (r : ℝ) (x : D) : π (r • x) = r • π x :=
+  π.toAlgHom.map_smul_of_tower r x
+
+lemma graph_map_inverse {X : D} (hX : 0 ≤ X) :
+    π (graphInverse X)=graphInverse (π X) := map_graphInverse π.toNonUnitalStarAlgHom hX
+
+omit [PartialOrder D] [StarOrderedRing D] [PartialOrder E] [StarOrderedRing E] in
+lemma graphX_map (F : D) : π (graphX V htH F) =
+    measurementX (π (graphSlot V htH 0)) (π F) := by
+  simp only [graphX, measurementX, graph_map_real_smul π, map_mul, map_star]
+
+lemma graphB_map {F : D} (hF : 0 ≤ F) (i : Fin 4) : π (graphB V htH F i) =
+    measurementB (fun j => π (graphSlot V htH j)) (π F) i := by
+  simp only [graphB, measurementB, graph_map_real_smul π, map_mul, map_star,
+    graph_map_inverse π (graphX_nonneg V htH hF), graphX_map]
+
+theorem graph_failure_represented (htn : ‖t‖ ≤ 1) (c y : D) (hy : 0 ≤ y) (hcn : ‖c‖ ≤ 1)
+    (T : Fin 4 → D) (hT : ∀ i, T i ∈ Her h) (hTn : ∀ i, ‖T i‖ ≤ 1)
+    (hTX : ∀ i, T i ∈ Her (cut (graphX V htH (c*y*star c)) (1/32)))
+    (hd : π (y * (1-star c*(graphP V ht htH T hT * graphP V ht htH T hT)*c)*y)=0) :
+    ‖π (graphX V htH (c*y*star c))‖=‖π y‖ ∧
+      ∀ i, π (graphB V htH (c*y*star c) i) = π (T i) := by
+  have hF : 0 ≤ c*y*star c := star_right_conjugate_nonneg hy c
+  have hm : π (CFC.sqrt t)=CFC.sqrt (π t) :=
+    π.toNonUnitalStarAlgHom.map_cfcₙ NNReal.sqrt t (by fun_prop) (by simp)
+      (map_continuous π) ht (map_nonneg π ht)
+  have hc := graph_failure_of_identities (map_nonneg π ht)
+    ((NonUnitalStarAlgHom.norm_apply_le π t).trans htn)
+    (fun j => π (graphSlot V htH j)) (z := π (graphZ V ht htH T hT))
+    (by simpa only [map_mul, map_star] using congrArg π (graphZ_inner V ht htH T hT hTn))
+    (fun i => π (T i))
+    (by simpa only [map_mul, map_star, graph_map_real_smul π, hm] using
+      (congrArg π (graphSlot0_Z V ht htH T hT)))
+    (fun i => by simpa only [map_mul, map_star, graph_map_real_smul π, hm] using
+      (congrArg π (graphSlot_Z V ht htH T hT i)))
+    (π c) (π y) (map_nonneg π hy)
+    ((NonUnitalStarAlgHom.norm_apply_le π c).trans hcn) (fun i => ?_) ?_
+  · simpa only [graphX_map, graphB_map π V htH hF, map_mul, map_star] using hc
+  · have hmem := Her_map π.toNonUnitalStarAlgHom (hTX i)
+    have hh := cut_map π.toNonUnitalStarAlgHom (graphX V htH (c*y*star c)) (1/32)
+      (graphX_nonneg V htH hF).isSelfAdjoint (by norm_num)
+    change π (T i) ∈ Her (π (cut (graphX V htH (c*y*star c)) (1/32))) at hmem
+    change cut (π (graphX V htH (c*y*star c))) (1/32) =
+      π (cut (graphX V htH (c*y*star c)) (1/32)) at hh
+    rw [← hh] at hmem
+    simpa only [graphX_map, map_mul, map_star] using hmem
+  · simpa only [graphP, map_mul, map_star, map_sub, map_one] using hd
+
+end RepresentedGraph
+
+end MainGap
+
+namespace MainGap
+universe u v
+variable {A : Type u} [CStarAlgebra A]
+local instance graphNonvanishingOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance graphNonvanishingStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+local instance graphOperatorOrder (J : Type*) [NormedAddCommGroup J] [InnerProductSpace ℂ J] [CompleteSpace J] :
+    PartialOrder (J →L[ℂ] J) := CStarAlgebra.spectralOrder _
+local instance graphOperatorStarOrder (J : Type*) [NormedAddCommGroup J] [InnerProductSpace ℂ J] [CompleteSpace J] :
+    StarOrderedRing (J →L[ℂ] J) := CStarAlgebra.spectralOrderedRing _
+
+theorem graph_nonvanishing {a y c : A} (ha : 0 ≤ a) (hy : 0 ≤ y) (hcn : ‖c‖ ≤ 1)
+    (hp : ∀ z : A, 0 ≤ z → z ∈ Her a → ProperlyInfinite z) :
+    ∃ p : A, 0 ≤ p ∧ ‖p‖ ≤ 1 ∧ p ∈ Her a ∧
+      (∀ R : HilbertRep.{u,v} A, (1/2 : ℝ) < ‖R.hom a‖ → ‖R.hom p‖=1) ∧
+      (∀ R : HilbertRep.{u,v} A, R.hom (y*(1-star c*(p*p)*c)*y)=0 → ‖R.hom y‖ ≤ (1/4 : ℝ)) := by
+  classical
+  obtain ⟨V⟩ := (hp a ha (self_mem_Her ha)).orthogonalSlots ha 6 (by norm_num : (0:ℝ)<1/8)
+  let t := ramp a (1/4) (1/2)
+  have ht : 0 ≤ t := ramp_nonneg a (by norm_num)
+  have htn : ‖t‖ ≤ 1 := norm_ramp_le_one a (by norm_num)
+  have htH : t ∈ Her (cut a (1/8)) := by
+    have hcut : cut a (1/4) ∈ Her (cut a (1/8)) := by
+      have hh := cut_mem_Her (cut_nonneg a (1/8)) (1/8)
+      rw [cut_cut ha (by norm_num) (by norm_num)] at hh
+      convert hh using 1; norm_num
+    exact Her_mono_of_mem hcut (ramp_mem_Her_cut ha (by norm_num))
+  let F := c*y*star c
+  have hF : 0 ≤ F := star_right_conjugate_nonneg hy c
+  let X := graphX V htH F
+  let B := graphB V htH F
+  have hX : 0 ≤ X := graphX_nonneg V htH hF
+  have hXH : X ∈ Her (cut a (1/8)) := graphX_mem V ht htH F
+  have hfour : fourHer X ≤ Her (cut a (1/8)) :=
+    Her_mono_of_mem (Her_mono_of_mem hXH (cut_mem_Her hX (1/32)))
+  obtain ⟨T,hTn,hTX,havoid⟩ := four_avoidance_unital.{u,v} hX B (fun z hz hzm =>
+    hp z hz (Her_mono_of_mem (cut_mem_Her ha (1/8)) (hfour hzm)))
+  have hT : ∀ i, T i ∈ Her (cut a (1/8)) := fun i => hfour (hTX i)
+  let p := graphP V ht htH T hT
+  have hpn : ‖p‖ ≤ 1 := by
+    have he := graphP_represented_norm V ht htH (NonUnitalStarAlgHom.id ℂ A) T hT hTn
+    change ‖p‖=‖t‖ at he
+    rw [he]
+    exact htn
+  refine ⟨p, graphP_nonneg V ht htH T hT, hpn, graphP_mem V ht htH T hT, ?_, ?_⟩
+  · intro R hRa
+    change ‖R.hom.toNonUnitalStarAlgHom (graphP V ht htH T hT)‖=1
+    rw [graphP_represented_norm V ht htH R.hom.toNonUnitalStarAlgHom T hT hTn]
+    change ‖R.hom (ramp a (1/4) (1/2))‖=1
+    rw [map_ramp_sa R.hom ha.isSelfAdjoint (by norm_num)]
+    exact norm_ramp_eq_one (map_nonneg R.hom ha) (by norm_num) (by norm_num) hRa.le
+  · intro R hd
+    by_contra! hRy
+    obtain ⟨hRX,hB⟩ := graph_failure_represented R.hom V ht htH htn c y hy hcn T hT hTn hTX hd
+    exact havoid R (by rw [hRX]; exact hRy)
+      (fun i => (hB i).symm)
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Hereditary.lean

@@ -0,0 +1,613 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+
+def sandwichAlgebra (h : A) : NonUnitalStarSubalgebra ℂ A where
+  carrier := Set.range (fun a : A => h * a * star h)
+  zero_mem' := ⟨0, by simp⟩
+  add_mem' := by
+    rintro _ _ ⟨a, rfl⟩ ⟨b, rfl⟩
+    exact ⟨a + b, by simp [mul_add, add_mul]⟩
+  mul_mem' := by
+    rintro _ _ ⟨a, rfl⟩ ⟨b, rfl⟩
+    exact ⟨a * star h * h * b, by simp only [mul_assoc]⟩
+  smul_mem' := by
+    rintro c _ ⟨a, rfl⟩
+    exact ⟨c • a, by simp only [mul_smul_comm, smul_mul_assoc]⟩
+  star_mem' := by
+    rintro _ ⟨a, rfl⟩
+    exact ⟨star a, by simp only [star_mul, star_star, mul_assoc]⟩
+
+def Her (h : A) : NonUnitalStarSubalgebra ℂ A := (sandwichAlgebra h).topologicalClosure
+
+lemma mem_Her_iff {h a : A} : a ∈ Her h ↔
+    a ∈ closure (Set.range (fun b : A => h * b * star h)) := Iff.rfl
+
+lemma isClosed_Her (h : A) : IsClosed (Her h : Set A) := isClosed_closure
+
+instance (h : A) : IsClosed (Her h : Set A) := isClosed_Her h
+
+lemma sandwich_mem_Her (h a : A) : h * a * star h ∈ Her h :=
+  subset_closure ⟨a, rfl⟩
+
+instance (h : A) : CompleteSpace (Her h) := (isClosed_Her h).completeSpace_coe
+
+def sandwichMap (h : A) : A →ₗ[ℂ] Her h where
+  toFun a := ⟨h * a * star h, sandwich_mem_Her h a⟩
+  map_add' a b := Subtype.ext (by
+    change h * (a + b) * star h = h * a * star h + h * b * star h
+    simp only [mul_add, add_mul])
+  map_smul' c a := Subtype.ext (by
+    change h * (c • a) * star h = c • (h * a * star h)
+    simp only [mul_smul_comm, smul_mul_assoc])
+
+@[simp] lemma sandwichMap_val (h a : A) : (sandwichMap h a : A) = h * a * star h := rfl
+
+lemma sandwichMap_dense (h : A) : DenseRange (sandwichMap h) := by
+  intro a
+  rw [closure_subtype]
+  have heq : Subtype.val '' Set.range (sandwichMap h) =
+      Set.range (fun b : A => h * b * star h) := by
+    ext b
+    constructor
+    · rintro ⟨k, ⟨c, rfl⟩, rfl⟩
+      exact ⟨c, rfl⟩
+    · rintro ⟨c, rfl⟩
+      exact ⟨sandwichMap h c, ⟨c, rfl⟩, rfl⟩
+  rw [heq]
+  exact a.property
+
+lemma norm_mul_eq_of_star_mul_eq {z h : A} (hzh : star z * z = star h * h) (a : A) :
+    ‖z * a‖ = ‖h * a‖ := by
+  apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
+  simp only [pow_two, ← CStarRing.norm_star_mul_self, star_mul]
+  congr 1
+  calc
+    star a * star z * (z * a) = star a * (star z * z) * a := by noncomm_ring
+    _ = star a * (star h * h) * a := by rw [hzh]
+    _ = star a * star h * (h * a) := by noncomm_ring
+
+def carrierNumerator (z h : A) : A →ₗ[ℂ] A where
+  toFun a := z * a * star h
+  map_add' a b := by simp only [mul_add, add_mul]
+  map_smul' c a := by simp only [mul_smul_comm, smul_mul_assoc, RingHom.id_apply]
+
+def carrier (z h : A) : Her h →L[ℂ] A :=
+  (carrierNumerator z h).extendOfNorm (sandwichMap h)
+
+lemma carrier_on_sandwich {z h : A} (hzh : star z * z = star h * h) (a : A) :
+    carrier z h (sandwichMap h a) = z * a * star h := by
+  apply LinearMap.extendOfNorm_eq (sandwichMap_dense h)
+  refine ⟨1, fun b => ?_⟩
+  change ‖z * b * star h‖ ≤ 1 * ‖h * b * star h‖
+  rw [one_mul, mul_assoc, mul_assoc, norm_mul_eq_of_star_mul_eq hzh]
+
+lemma carrier_norm {z h : A} (hzh : star z * z = star h * h) (k : Her h) :
+    ‖carrier z h k‖ = ‖(k : A)‖ := by
+  refine (sandwichMap_dense h).induction_on k (isClosed_eq (by fun_prop) (by fun_prop)) ?_
+  intro a
+  rw [carrier_on_sandwich hzh, sandwichMap_val, mul_assoc, mul_assoc,
+    norm_mul_eq_of_star_mul_eq hzh]
+
+lemma carrier_inner {z h : A} (hzh : star z * z = star h * h) (k l : Her h) :
+    star (carrier z h k) * carrier z h l = star (k : A) * (l : A) := by
+  refine (sandwichMap_dense h).induction_on k (isClosed_eq (by fun_prop) (by fun_prop)) ?_
+  intro a
+  refine (sandwichMap_dense h).induction_on l (isClosed_eq (by fun_prop) (by fun_prop)) ?_
+  intro b
+  simp only [carrier_on_sandwich hzh, sandwichMap_val, star_mul, star_star]
+  calc
+    h * (star a * star z) * (z * b * star h) =
+        h * star a * (star z * z) * b * star h := by noncomm_ring
+    _ = h * star a * (star h * h) * b * star h := by rw [hzh]
+    _ = h * (star a * star h) * (h * b * star h) := by noncomm_ring
+
+lemma carrier_mul {z h : A} (hzh : star z * z = star h * h) (k l : Her h) :
+    carrier z h (k * l) = carrier z h k * (l : A) := by
+  refine (sandwichMap_dense h).induction_on k (isClosed_eq (by fun_prop) (by fun_prop)) ?_
+  intro a
+  refine (sandwichMap_dense h).induction_on l (isClosed_eq (by fun_prop) (by fun_prop)) ?_
+  intro b
+  have heq : sandwichMap h a * sandwichMap h b =
+      sandwichMap h (a * star h * h * b) := Subtype.ext (by
+        change (h * a * star h) * (h * b * star h) =
+          h * (a * star h * h * b) * star h
+        simp only [mul_assoc])
+  rw [heq, carrier_on_sandwich hzh, carrier_on_sandwich hzh, sandwichMap_val]
+  simp only [mul_assoc]
+
+lemma norm_mul_star_eq_of_star_mul_eq {z h : A} (hzh : star z * z = star h * h) (a : A) :
+    ‖a * star z‖ = ‖a * star h‖ := by
+  calc
+    ‖a * star z‖ = ‖star (a * star z)‖ := (norm_star _).symm
+    _ = ‖z * star a‖ := by rw [star_mul, star_star]
+    _ = ‖h * star a‖ := norm_mul_eq_of_star_mul_eq hzh _
+    _ = ‖star (a * star h)‖ := by rw [star_mul, star_star]
+    _ = ‖a * star h‖ := norm_star _
+
+lemma norm_sandwich_eq {z h : A} (hzh : star z * z = star h * h) (a : A) :
+    ‖z * a * star z‖ = ‖h * a * star h‖ := by
+  rw [norm_mul_star_eq_of_star_mul_eq hzh, mul_assoc, mul_assoc,
+    norm_mul_eq_of_star_mul_eq hzh]
+
+def conjugationNumerator (z : A) : A →ₗ[ℂ] A where
+  toFun a := z * a * star z
+  map_add' a b := by simp only [mul_add, add_mul]
+  map_smul' c a := by simp only [mul_smul_comm, smul_mul_assoc, RingHom.id_apply]
+
+def conjugation (z h : A) : Her h →L[ℂ] A :=
+  (conjugationNumerator z).extendOfNorm (sandwichMap h)
+
+lemma conjugation_on_sandwich {z h : A} (hzh : star z * z = star h * h) (a : A) :
+    conjugation z h (sandwichMap h a) = z * a * star z := by
+  apply LinearMap.extendOfNorm_eq (sandwichMap_dense h)
+  refine ⟨1, fun b => ?_⟩
+  change ‖z * b * star z‖ ≤ 1 * ‖h * b * star h‖
+  rw [one_mul, norm_sandwich_eq hzh]
+
+lemma conjugation_norm {z h : A} (hzh : star z * z = star h * h) (k : Her h) :
+    ‖conjugation z h k‖ = ‖(k : A)‖ := by
+  refine (sandwichMap_dense h).induction_on k (isClosed_eq (by fun_prop) (by fun_prop)) ?_
+  intro a
+  rw [conjugation_on_sandwich hzh, sandwichMap_val, norm_sandwich_eq hzh]
+
+lemma conjugation_mem {z h : A} (hzh : star z * z = star h * h) (k : Her h) :
+    conjugation z h k ∈ Her z := by
+  refine (sandwichMap_dense h).induction_on k
+    ((isClosed_Her z).preimage (conjugation z h).continuous) ?_
+  intro a
+  rw [conjugation_on_sandwich hzh]
+  exact sandwich_mem_Her z a
+
+lemma conjugation_mul {z h : A} (hzh : star z * z = star h * h) (k l : Her h) :
+    conjugation z h (k * l) = conjugation z h k * conjugation z h l := by
+  refine (sandwichMap_dense h).induction_on k (isClosed_eq (by fun_prop) (by fun_prop)) ?_
+  intro a
+  refine (sandwichMap_dense h).induction_on l (isClosed_eq (by fun_prop) (by fun_prop)) ?_
+  intro b
+  have heq : sandwichMap h a * sandwichMap h b =
+      sandwichMap h (a * star h * h * b) := Subtype.ext (by
+        change (h * a * star h) * (h * b * star h) =
+          h * (a * star h * h * b) * star h
+        simp only [mul_assoc])
+  rw [heq, conjugation_on_sandwich hzh, conjugation_on_sandwich hzh,
+    conjugation_on_sandwich hzh]
+  calc
+    z * (a * star h * h * b) * star z = z * a * (star h * h) * b * star z := by
+      noncomm_ring
+    _ = z * a * (star z * z) * b * star z := by rw [hzh]
+    _ = (z * a * star z) * (z * b * star z) := by noncomm_ring
+
+lemma carrier_outer {z h : A} (hzh : star z * z = star h * h) (k l : Her h) :
+    carrier z h k * star (carrier z h l) = conjugation z h (k * star l) := by
+  refine (sandwichMap_dense h).induction_on k (isClosed_eq (by fun_prop) (by fun_prop)) ?_
+  intro a
+  refine (sandwichMap_dense h).induction_on l (isClosed_eq (by fun_prop) (by fun_prop)) ?_
+  intro b
+  have heq : sandwichMap h a * star (sandwichMap h b) =
+      sandwichMap h (a * star h * h * star b) := Subtype.ext (by
+        change (h * a * star h) * star (h * b * star h) =
+          h * (a * star h * h * star b) * star h
+        simp only [star_mul, star_star, mul_assoc])
+  rw [heq, carrier_on_sandwich hzh, carrier_on_sandwich hzh, conjugation_on_sandwich hzh]
+  simp only [star_mul, star_star, mul_assoc]
+
+lemma conjugation_star {z h : A} (hzh : star z * z = star h * h) (k : Her h) :
+    conjugation z h (star k) = star (conjugation z h k) := by
+  refine (sandwichMap_dense h).induction_on k
+    (isClosed_eq ((conjugation z h).continuous.comp continuous_star)
+      (continuous_star.comp (conjugation z h).continuous)) ?_
+  intro a
+  have heq : star (sandwichMap h a) = sandwichMap h (star a) := Subtype.ext (by
+    change star (h * a * star h) = h * star a * star h
+    simp only [star_mul, star_star, mul_assoc])
+  rw [heq, conjugation_on_sandwich hzh, conjugation_on_sandwich hzh]
+  simp only [star_mul, star_star, mul_assoc]
+
+def transportHom {z h : A} (hzh : star z * z = star h * h) : Her h →⋆ₙₐ[ℂ] A :=
+  { (conjugation z h).toLinearMap with
+    map_zero' := map_zero (conjugation z h)
+    map_mul' := conjugation_mul hzh
+    map_star' := conjugation_star hzh }
+
+lemma transportHom_injective {z h : A} (hzh : star z * z = star h * h) :
+    Function.Injective (transportHom hzh) := by
+  intro k l heq
+  apply sub_eq_zero.mp
+  apply Subtype.val_injective
+  apply norm_eq_zero.mp
+  rw [← conjugation_norm hzh]
+  change ‖transportHom hzh (k - l)‖ = 0
+  rw [map_sub, heq, sub_self, norm_zero]
+
+lemma transport_represented_norm {B : Type*} [NonUnitalCStarAlgebra B]
+    (π : A →⋆ₙₐ[ℂ] B) {z h : A} (hzh : star z * z = star h * h) (k : Her h) :
+    ‖π (transportHom hzh k)‖ = ‖π (k : A)‖ := by
+  refine (sandwichMap_dense h).induction_on k (isClosed_eq (by fun_prop) (by fun_prop)) ?_
+  intro a
+  change ‖π (conjugation z h (sandwichMap h a))‖ = ‖π (h * a * star h)‖
+  rw [conjugation_on_sandwich hzh]
+  simp only [map_mul, map_star]
+  apply norm_sandwich_eq
+  simpa only [map_mul, map_star] using congrArg π hzh
+
+lemma Her_sandwich {h k : A} (hk : k ∈ Her h) (a : A) : k * a * star k ∈ Her h := by
+  let k' : Her h := ⟨k, hk⟩
+  change (k' : A) * a * star (k' : A) ∈ Her h
+  refine (sandwichMap_dense h).induction_on k'
+    ((isClosed_Her h).preimage (by fun_prop)) ?_
+  intro b
+  change (h * b * star h) * a * star (h * b * star h) ∈ Her h
+  convert sandwich_mem_Her h (b * star h * a * h * star b) using 1
+  simp only [star_mul, star_star, mul_assoc]
+
+lemma Her_mono_of_mem {h k : A} (hk : k ∈ Her h) : Her k ≤ Her h := by
+  apply closure_minimal _ (isClosed_Her h)
+  rintro _ ⟨a, rfl⟩
+  exact Her_sandwich hk a
+
+lemma Her_mul_le (h k : A) : Her (h * k) ≤ Her h := by
+  apply closure_minimal _ (isClosed_Her h)
+  rintro _ ⟨a, rfl⟩
+  change (h * k) * a * star (h * k) ∈ Her h
+  convert sandwich_mem_Her h (k * a * star k) using 1
+  simp only [star_mul, mul_assoc]
+
+structure RegularTransport (h v : A) where
+  carrier : Her h →L[ℂ] A
+  hom : Her h →⋆ₙₐ[ℂ] A
+  inner : ∀ k l : Her h, star (carrier k) * carrier l = star (k : A) * (l : A)
+  outer : ∀ k l : Her h, carrier k * star (carrier l) = hom (k * star l)
+  mul : ∀ k l : Her h, carrier (k * l) = carrier k * (l : A)
+  image : ∀ k : Her h, hom k ∈ Her v
+
+namespace RegularTransport
+variable {h v : A} (T : RegularTransport h v)
+
+def restrict {k : A} (T : RegularTransport k v) (hle : Her h ≤ Her k) :
+    RegularTransport h v := by
+  let ι : Her h →⋆ₙₐ[ℂ] Her k := NonUnitalStarSubalgebra.inclusion hle
+  let i : Her h →L[ℂ] Her k := {
+    toFun := ι
+    map_add' := map_add ι
+    map_smul' := map_smul ι
+    cont := by fun_prop }
+  exact {
+    carrier := T.carrier.comp i
+    hom := T.hom.comp ι
+    inner := fun a b => T.inner (ι a) (ι b)
+    outer := fun a b => by
+      change T.carrier (ι a) * star (T.carrier (ι b)) = T.hom (ι (a * star b))
+      rw [map_mul, map_star]
+      exact T.outer (ι a) (ι b)
+    mul := fun a b => by
+      change T.carrier (ι (a * b)) = T.carrier (ι a) * (b : A)
+      rw [map_mul]
+      exact T.mul (ι a) (ι b)
+    image := fun a => T.image (ι a) }
+
+lemma carrier_represented_norm {B : Type*} [NonUnitalCStarAlgebra B]
+    (π : A →⋆ₙₐ[ℂ] B) (k : Her h) : ‖π (T.carrier k)‖ = ‖π (k : A)‖ := by
+  apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
+  simp only [pow_two, ← CStarRing.norm_star_mul_self, ← map_star, ← map_mul, T.inner]
+
+lemma represented_norm {B : Type*} [NonUnitalCStarAlgebra B]
+    (π : A →⋆ₙₐ[ℂ] B) (k : Her h) : ‖π (T.hom k)‖ = ‖π (k : A)‖ := by
+  apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
+  calc
+    ‖π (T.hom k)‖ ^ 2 = ‖π (T.hom (star k * k))‖ := by
+      simp only [map_mul, map_star, CStarRing.norm_star_mul_self, pow_two]
+    _ = ‖π (T.carrier (star k) * star (T.carrier (star k)))‖ := by
+      rw [T.outer, star_star]
+    _ = ‖π (T.carrier (star k))‖ ^ 2 := by
+      simp only [map_mul, map_star, CStarRing.norm_self_mul_star, pow_two]
+    _ = ‖π (star (k : A))‖ ^ 2 := by
+      rw [T.carrier_represented_norm, StarMemClass.coe_star]
+    _ = ‖π (k : A)‖ ^ 2 := by rw [map_star, norm_star]
+
+lemma norm_hom (k : Her h) : ‖T.hom k‖ = ‖(k : A)‖ :=
+  T.represented_norm (NonUnitalStarAlgHom.id ℂ A) k
+
+lemma injective : Function.Injective T.hom := by
+  intro k l hkl
+  apply sub_eq_zero.mp
+  apply Subtype.val_injective
+  apply norm_eq_zero.mp
+  rw [← T.norm_hom, map_sub, hkl, sub_self, norm_zero]
+
+end RegularTransport
+
+section Order
+variable [PartialOrder A] [StarOrderedRing A]
+
+lemma mul_star_mem_Her (h : A) : h * star h ∈ Her h := by
+  apply (isClosed_Her h).mem_of_tendsto
+    (((CStarAlgebra.increasingApproximateUnit A).tendsto_mul_left h).mul_const (star h))
+  exact Filter.Eventually.of_forall (sandwich_mem_Her h)
+
+lemma sqrt_mem_Her {h k : A} (hk : k ∈ Her h) (hkpos : 0 ≤ k) : CFC.sqrt k ∈ Her h := by
+  rw [CFC.sqrt_eq_real_sqrt k hkpos]
+  exact cfcₙ_mem (𝕜' := ℂ) Real.sqrt hk
+
+lemma self_mem_Her {h : A} (hh : 0 ≤ h) : h ∈ Her h := by
+  have hm : h * h ∈ Her h := by
+    simpa only [IsSelfAdjoint.of_nonneg hh |>.star_eq] using mul_star_mem_Her h
+  simpa only [CFC.sqrt_mul_self h hh] using
+    sqrt_mem_Her hm (by simpa only [IsSelfAdjoint.of_nonneg hh |>.star_eq] using
+      star_mul_self_nonneg h)
+
+lemma sqrt_Her_eq {h : A} (hh : 0 ≤ h) : Her (CFC.sqrt h) = Her h := by
+  apply le_antisymm
+  · exact Her_mono_of_mem (sqrt_mem_Her (self_mem_Her hh) hh)
+  · apply Her_mono_of_mem
+    have ht := self_mem_Her (CFC.sqrt_nonneg h)
+    have hm : CFC.sqrt h * CFC.sqrt h ∈ Her (CFC.sqrt h) := (Her (CFC.sqrt h)).mul_mem ht ht
+    rwa [CFC.sqrt_mul_sqrt_self h hh] at hm
+
+def twoSidedRemainder (e a : A) : A := a - e * a - a * e + e * a * e
+
+lemma twoSidedRemainder_as_square {e a : A} (he : IsSelfAdjoint e) (ha : 0 ≤ a) :
+    twoSidedRemainder e a =
+      (CFC.sqrt a - e * CFC.sqrt a) * star (CFC.sqrt a - e * CFC.sqrt a) := by
+  have hs : star (CFC.sqrt a) = CFC.sqrt a := (IsSelfAdjoint.of_nonneg (CFC.sqrt_nonneg a)).star_eq
+  simp only [star_sub, star_mul, he.star_eq, hs]
+  calc
+    twoSidedRemainder e a = a - e * a - a * e + e * a * e := rfl
+    _ = (CFC.sqrt a * CFC.sqrt a) - e * (CFC.sqrt a * CFC.sqrt a) -
+        (CFC.sqrt a * CFC.sqrt a) * e + e * (CFC.sqrt a * CFC.sqrt a) * e := by
+      rw [CFC.sqrt_mul_sqrt_self a ha]
+    _ = _ := by noncomm_ring
+
+lemma twoSidedRemainder_nonneg {e a : A} (he : IsSelfAdjoint e) (ha : 0 ≤ a) :
+    0 ≤ twoSidedRemainder e a := by
+  rw [twoSidedRemainder_as_square he ha]
+  exact mul_star_self_nonneg _
+
+lemma twoSidedRemainder_mono {e a b : A} (he : IsSelfAdjoint e) (hab : a ≤ b) :
+    twoSidedRemainder e a ≤ twoSidedRemainder e b := by
+  apply sub_nonneg.mp
+  convert twoSidedRemainder_nonneg he (sub_nonneg.mpr hab) using 1
+  simp only [twoSidedRemainder]
+  noncomm_ring
+
+omit [PartialOrder A] [StarOrderedRing A] in
+lemma norm_twoSidedRemainder_le {e : A} (he : ‖e‖ ≤ 1) (b : A) :
+    ‖twoSidedRemainder e b‖ ≤ 2 * ‖b - e * b‖ := by
+  have heq : twoSidedRemainder e b = (b - e * b) - (b - e * b) * e := by
+    simp only [twoSidedRemainder]
+    noncomm_ring
+  rw [heq]
+  calc
+    ‖(b - e * b) - (b - e * b) * e‖ ≤ ‖b - e * b‖ + ‖(b - e * b) * e‖ := norm_sub_le _ _
+    _ ≤ ‖b - e * b‖ + ‖b - e * b‖ * ‖e‖ := by gcongr; exact norm_mul_le _ _
+    _ ≤ 2 * ‖b - e * b‖ := by nlinarith [norm_nonneg (b - e * b)]
+
+lemma norm_sqrt_remainder_sq_le {e a b : A} (he : IsSelfAdjoint e) (hen : ‖e‖ ≤ 1)
+    (ha : 0 ≤ a) (hab : a ≤ b) :
+    ‖CFC.sqrt a - e * CFC.sqrt a‖ ^ 2 ≤ 2 * ‖b - e * b‖ := by
+  calc
+    ‖CFC.sqrt a - e * CFC.sqrt a‖ ^ 2 = ‖twoSidedRemainder e a‖ := by
+      rw [twoSidedRemainder_as_square he ha, CStarRing.norm_self_mul_star, pow_two]
+    _ ≤ ‖twoSidedRemainder e b‖ :=
+      CStarAlgebra.norm_le_norm_of_le_of_nonneg (twoSidedRemainder_mono he hab)
+        (twoSidedRemainder_nonneg he ha)
+    _ ≤ 2 * ‖b - e * b‖ := norm_twoSidedRemainder_le hen b
+
+lemma norm_compression_error_le {e a : A} (he : IsSelfAdjoint e) (hen : ‖e‖ ≤ 1)
+    (ha : 0 ≤ a) :
+    ‖a - e * a * e‖ ≤ 2 * ‖CFC.sqrt a - e * CFC.sqrt a‖ * ‖CFC.sqrt a‖ := by
+  have ha' : IsSelfAdjoint a := .of_nonneg ha
+  have hstar : ‖a - a * e‖ = ‖a - e * a‖ := by
+    rw [← norm_star (a - a * e), star_sub, star_mul, he.star_eq, ha'.star_eq]
+  have heq : a - e * a * e = (a - e * a) + e * (a - a * e) := by noncomm_ring
+  have hbound : ‖a - e * a‖ ≤ ‖CFC.sqrt a - e * CFC.sqrt a‖ * ‖CFC.sqrt a‖ := by
+    calc
+      ‖a - e * a‖ = ‖(CFC.sqrt a - e * CFC.sqrt a) * CFC.sqrt a‖ := by
+        rw [sub_mul, mul_assoc e, CFC.sqrt_mul_sqrt_self a ha]
+      _ ≤ _ := norm_mul_le _ _
+  calc
+    ‖a - e * a * e‖ = ‖(a - e * a) + e * (a - a * e)‖ := congrArg norm heq
+    _ ≤ ‖a - e * a‖ + ‖e * (a - a * e)‖ := norm_add_le _ _
+    _ ≤ ‖a - e * a‖ + ‖e‖ * ‖a - a * e‖ := by gcongr; exact norm_mul_le _ _
+    _ ≤ 2 * ‖a - e * a‖ := by rw [hstar]; nlinarith [norm_nonneg (a - e * a)]
+    _ ≤ _ := by nlinarith
+
+lemma norm_compression_error_sq_le {e a b : A} (he : IsSelfAdjoint e) (hen : ‖e‖ ≤ 1)
+    (ha : 0 ≤ a) (hab : a ≤ b) :
+    ‖a - e * a * e‖ ^ 2 ≤ 8 * ‖a‖ * ‖b - e * b‖ := by
+  have hsa : IsSelfAdjoint (CFC.sqrt a) := .of_nonneg (CFC.sqrt_nonneg _)
+  have hsq : ‖CFC.sqrt a‖ ^ 2 = ‖a‖ := by
+    rw [← hsa.norm_mul_self, CFC.sqrt_mul_sqrt_self a ha]
+  calc
+    ‖a - e * a * e‖ ^ 2 ≤
+        (2 * ‖CFC.sqrt a - e * CFC.sqrt a‖ * ‖CFC.sqrt a‖) ^ 2 :=
+      (sq_le_sq₀ (norm_nonneg _) (by positivity)).mpr (norm_compression_error_le he hen ha)
+    _ = 4 * ‖a‖ * ‖CFC.sqrt a - e * CFC.sqrt a‖ ^ 2 := by rw [← hsq]; ring
+    _ ≤ 4 * ‖a‖ * (2 * ‖b - e * b‖) := by
+      gcongr
+      exact norm_sqrt_remainder_sq_le he hen ha hab
+    _ = _ := by ring
+
+lemma Her_exists_approx_unit {b : A} (hb : 0 ≤ b) {δ : ℝ} (hδ : 0 < δ) :
+    ∃ e : A, e ∈ Her b ∧ IsSelfAdjoint e ∧ ‖e‖ ≤ 1 ∧ ‖b - e * b‖ < δ := by
+  let b' : Her b := ⟨b, self_mem_Her hb⟩
+  let : PartialOrder (Her b) := CStarAlgebra.spectralOrder (Her b)
+  let : StarOrderedRing (Her b) := CStarAlgebra.spectralOrderedRing (Her b)
+  have hunit := CStarAlgebra.increasingApproximateUnit (Her b)
+  have ht : Tendsto (fun e : Her b => ‖b' - e * b'‖)
+      (CStarAlgebra.approximateUnit (Her b)) (𝓝 (0 : ℝ)) := by
+    simpa only [sub_self, norm_zero] using
+      ((tendsto_const_nhds (x := b')).sub (hunit.tendsto_mul_right b')).norm
+  have hsmall : ∀ᶠ e : Her b in CStarAlgebra.approximateUnit (Her b), ‖b' - e * b'‖ < δ :=
+    ht.eventually (Iio_mem_nhds hδ)
+  obtain ⟨e, hn, hp, hs⟩ := (hunit.eventually_norm.and (hunit.eventually_nonneg.and hsmall)).exists
+  refine ⟨e, e.property, ?_, hn, hs⟩
+  change star (e : A) = (e : A)
+  have he := congrArg (fun x : Her b => (x : A)) (IsSelfAdjoint.of_nonneg hp |>.star_eq)
+  exact he
+
+lemma mem_Her_of_nonneg_le {a b : A} (ha : 0 ≤ a) (hab : a ≤ b) : a ∈ Her b := by
+  have hb : 0 ≤ b := ha.trans hab
+  have hc : a ∈ closure (Her b : Set A) := by
+    rw [Metric.mem_closure_iff]
+    intro ε hε
+    have hden : 0 < 8 * ‖a‖ + 1 := by positivity
+    have hδ : 0 < ε ^ 2 / (8 * ‖a‖ + 1) := div_pos (sq_pos_of_pos hε) hden
+    obtain ⟨e, he, hesa, hen, hesmall⟩ := Her_exists_approx_unit hb hδ
+    refine ⟨e * a * e, ?_, ?_⟩
+    · change e * a * e ∈ Her b
+      simpa only [hesa.star_eq] using Her_sandwich he a
+    · rw [dist_eq_norm]
+      have hsq := norm_compression_error_sq_le hesa hen ha hab
+      have hp : (8 * ‖a‖ + 1) * ‖b - e * b‖ < ε ^ 2 := by
+        have ht := mul_lt_mul_of_pos_left hesmall hden
+        rwa [mul_div_cancel₀ _ (ne_of_gt hden)] at ht
+      have hfinal : ‖a - e * a * e‖ ^ 2 < ε ^ 2 := by
+        nlinarith [norm_nonneg (b - e * b)]
+      exact (sq_lt_sq₀ (norm_nonneg _) hε.le).mp hfinal
+  rwa [(isClosed_Her b).closure_eq] at hc
+
+lemma Her_mono {a b : A} (ha : 0 ≤ a) (hab : a ≤ b) : Her a ≤ Her b :=
+  Her_mono_of_mem (mem_Her_of_nonneg_le ha hab)
+
+omit [PartialOrder A] [StarOrderedRing A] in
+lemma real_smul_mem_Her {h a : A} (ha : a ∈ Her h) (r : ℝ) : r • a ∈ Her h := by
+  change r • a ∈ (Her h).toSubmodule
+  simpa only [Complex.coe_smul] using (Her h).smul_mem (r : ℂ) ha
+
+lemma smul_Her_eq {h : A} (hh : 0 ≤ h) {r : ℝ} (hr : 0 < r) :
+    Her (r • h) = Her h := by
+  apply le_antisymm
+  · exact Her_mono_of_mem (real_smul_mem_Her (self_mem_Her hh) r)
+  · apply Her_mono_of_mem
+    have hm := real_smul_mem_Her (self_mem_Her (smul_nonneg hr.le hh)) r⁻¹
+    simpa only [smul_smul, inv_mul_cancel₀ (ne_of_gt hr), one_smul] using hm
+
+lemma square_Her_eq {h : A} (hh : 0 ≤ h) : Her (h * h) = Her h := by
+  have hm : 0 ≤ h * h := by
+    simpa only [(IsSelfAdjoint.of_nonneg hh).star_eq] using star_mul_self_nonneg h
+  simpa only [CFC.sqrt_mul_self h hh] using (sqrt_Her_eq hm).symm
+
+lemma Her_eq_of_order_bounds {a b : A} (ha : 0 ≤ a) (hb : 0 ≤ b)
+    {r R : ℝ} (hr : 0 < r) (hR : 0 < R) (hl : r • a ≤ b) (hu : b ≤ R • a) :
+    Her b = Her a := by
+  apply le_antisymm
+  · simpa only [smul_Her_eq ha hR] using Her_mono hb hu
+  · simpa only [smul_Her_eq ha hr] using Her_mono (smul_nonneg hr.le ha) hl
+
+def cut (d : A) (ε : ℝ) : A := cfcₙ (fun t : ℝ => max (t - ε) 0) d
+
+lemma cut_nonneg (d : A) (ε : ℝ) : 0 ≤ cut d ε := by
+  exact cfcₙ_nonneg (fun _ _ => le_max_right _ _)
+
+lemma cut_mem_Her {d : A} (hd : 0 ≤ d) (ε : ℝ) : cut d ε ∈ Her d := by
+  exact cfcₙ_mem (𝕜' := ℂ) _ (self_mem_Her hd)
+
+lemma cut_sandwich_lower {d : A} (hd : IsSelfAdjoint d) {ε : ℝ} (hε : 0 ≤ ε) :
+    ε • (cut d ε * cut d ε) ≤ cut d ε * d * cut d ε := by
+  let f : ℝ → ℝ := fun t => max (t - ε) 0
+  have hf : Continuous f := (continuous_id.sub continuous_const).max continuous_const
+  have hf0 : f 0 = 0 := by simp [f, max_eq_right (neg_nonpos.mpr hε)]
+  have hid : cfcₙ (fun t : ℝ => t) d = d := cfcₙ_id ℝ d hd
+  have hl : cfcₙ (fun t => ε * (f t * f t)) d = ε • (cut d ε * cut d ε) := by
+    rw [cfcₙ_const_mul ε (fun t => f t * f t) d (hf.mul hf).continuousOn
+      (by simp [hf0]), cfcₙ_mul f f d hf.continuousOn hf0 hf.continuousOn hf0]
+    rfl
+  have hu : cfcₙ (fun t => f t * t * f t) d = cut d ε * d * cut d ε := by
+    rw [cfcₙ_mul (fun t => f t * t) f d (hf.mul continuous_id).continuousOn
+      (by simp [hf0]) hf.continuousOn hf0,
+      cfcₙ_mul f (fun t => t) d hf.continuousOn hf0 continuousOn_id rfl, hid]
+    rfl
+  rw [← hl, ← hu]
+  apply (cfcₙ_le_iff _ _ d (continuous_const.mul (hf.mul hf)).continuousOn
+    ((hf.mul continuous_id).mul hf).continuousOn (by simp [hf0]) (by simp [hf0]) hd).mpr
+  intro t _
+  by_cases ht : ε ≤ t
+  · calc
+      ε * (f t * f t) ≤ t * (f t * f t) :=
+        mul_le_mul_of_nonneg_right ht (mul_self_nonneg _)
+      _ = f t * t * f t := by ring
+  · simp [f, max_eq_right (by linarith : t - ε ≤ 0)]
+
+lemma cut_transport_lower {d v s : A} (hd : 0 ≤ d) (hv : 0 ≤ v)
+    {ε : ℝ} (hε : 0 ≤ ε) :
+    (ε - ‖d - star s * v * s‖) • (cut d ε * cut d ε) ≤
+      cut d ε * (star s * v * s) * cut d ε := by
+  let h := cut d ε
+  have hh : IsSelfAdjoint h := .of_nonneg (cut_nonneg d ε)
+  have hb : IsSelfAdjoint (d - star s * v * s) :=
+    (IsSelfAdjoint.of_nonneg hd).sub (.of_nonneg (star_left_conjugate_nonneg hv s))
+  have hbound : h * d * h - h * (star s * v * s) * h ≤
+      ‖d - star s * v * s‖ • (h * h) := by
+    simpa only [hh.star_eq, mul_sub, sub_mul] using
+      CStarAlgebra.star_left_conjugate_le_norm_smul h (d - star s * v * s) hb
+  calc
+    (ε - ‖d - star s * v * s‖) • (h * h) =
+        ε • (h * h) - ‖d - star s * v * s‖ • (h * h) := sub_smul _ _ _
+    _ ≤ h * d * h - ‖d - star s * v * s‖ • (h * h) :=
+      sub_le_sub_right (cut_sandwich_lower (.of_nonneg hd) hε) _
+    _ ≤ h * (star s * v * s) * h := (sub_le_comm).mp hbound
+
+theorem regularTransport_of_approx {d v s : A} (hd : 0 ≤ d) (hv : 0 ≤ v)
+    {ε : ℝ} (hε : 0 < ε) (hs : ‖d - star s * v * s‖ < ε) :
+    Nonempty (RegularTransport (cut d ε) v) := by
+  let h := cut d ε
+  let z := CFC.sqrt v * s * h
+  have hhpos : 0 ≤ h := cut_nonneg d ε
+  have hh : IsSelfAdjoint h := .of_nonneg hhpos
+  have hvroot : IsSelfAdjoint (CFC.sqrt v) := .of_nonneg (CFC.sqrt_nonneg v)
+  have hzz : star z * z = h * (star s * v * s) * h := by
+    simp only [z, star_mul, hh.star_eq, hvroot.star_eq]
+    calc
+      h * (star s * CFC.sqrt v) * (CFC.sqrt v * s * h) =
+          h * (star s * (CFC.sqrt v * CFC.sqrt v) * s) * h := by noncomm_ring
+      _ = _ := by rw [CFC.sqrt_mul_sqrt_self v hv]
+  have hspos : 0 ≤ star s * v * s := star_left_conjugate_nonneg hv s
+  have hh2pos : 0 ≤ h * h := by simpa only [hh.star_eq] using star_mul_self_nonneg h
+  have hl : (ε - ‖d - star s * v * s‖) • (h * h) ≤ star z * z := by
+    rw [hzz]
+    exact cut_transport_lower hd hv hε.le
+  have hu : star z * z ≤ (‖star s * v * s‖ + 1) • (h * h) := by
+    rw [hzz]
+    calc
+      h * (star s * v * s) * h ≤ ‖star s * v * s‖ • (h * h) := by
+        simpa only [hh.star_eq] using
+          CStarAlgebra.star_left_conjugate_le_norm_smul h (star s * v * s) (.of_nonneg hspos)
+      _ ≤ _ := smul_le_smul_of_nonneg_right (by linarith) hh2pos
+  have heq : Her (star z * z) = Her h := by
+    rw [Her_eq_of_order_bounds hh2pos (star_mul_self_nonneg z)
+      (sub_pos.mpr hs) (by positivity) hl hu, square_Her_eq hhpos]
+  let q := CFC.sqrt (star z * z)
+  have hq : star z * z = star q * q := by
+    rw [(IsSelfAdjoint.of_nonneg (CFC.sqrt_nonneg (star z * z))).star_eq]
+    exact (CFC.sqrt_mul_sqrt_self _ (star_mul_self_nonneg z)).symm
+  have hqHer : Her q = Her h := (sqrt_Her_eq (star_mul_self_nonneg z)).trans heq
+  have hrange : Her z ≤ Her v := by
+    calc
+      Her z = Her (CFC.sqrt v * (s * h)) := by simp only [z, mul_assoc]
+      _ ≤ Her (CFC.sqrt v) := Her_mul_le _ _
+      _ = Her v := sqrt_Her_eq hv
+  let T : RegularTransport q v := {
+    carrier := carrier z q
+    hom := transportHom hq
+    inner := carrier_inner hq
+    outer := carrier_outer hq
+    mul := carrier_mul hq
+    image := fun k => hrange (conjugation_mem hq k) }
+  exact ⟨T.restrict hqHer.ge⟩
+
+end Order
+
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/IdealComparison.lean

@@ -0,0 +1,164 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.ClosedIdeal
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.IdealDetection
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+variable {A : Type*} [CStarAlgebra A]
+local instance idealComparisonPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance idealComparisonStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+lemma ScalarCuntzLE.conjugate_scalar {u v : A} (h : ScalarCuntzLE u v) (x : A) :
+    ScalarCuntzLE (star x * u * x) v := by
+  have hc : Continuous (fun z : A => star x * z * x) := by fun_prop
+  have hm := image_closure_subset_closure_image hc ⟨u, h, rfl⟩
+  apply closure_mono (s := (fun z : A => star x * z * x) ''
+      Set.range (fun w : A => star w * v * w)) _ hm
+  rintro _ ⟨_, ⟨w, rfl⟩, rfl⟩
+  exact ⟨w * x, by simp only [star_mul, mul_assoc]⟩
+
+lemma scalarCuntzLE_left_square (x z : A) :
+    ScalarCuntzLE (star (x * z) * (x * z)) (star z * z) := by
+  have hnorm : star x * x ≤ (‖x‖ ^ 2 + 1) • (1 : A) := by
+    apply (CStarAlgebra.star_mul_le_algebraMap_norm_sq (a := x)).trans
+    rw [Algebra.algebraMap_eq_smul_one]
+    exact smul_le_smul_of_nonneg_right (by linarith) (zero_le_one : (0 : A) ≤ 1)
+  have h := star_left_conjugate_le_conjugate hnorm z
+  have hh : star (x * z) * (x * z) ≤ (‖x‖ ^ 2 + 1) • (star z * z) := by
+    simpa only [star_mul, mul_assoc, mul_smul_comm, smul_mul_assoc, mul_one] using h
+  exact (scalarCuntzLE_of_order (star_mul_self_nonneg _) hh).trans
+    (scalarCuntzLE_smul (star_mul_self_nonneg _) (by positivity))
+
+lemma scalarCuntzLE_add_of_proper {u w v : A} (hv : ProperlyInfinite v)
+    (hu : ScalarCuntzLE u v) (hw : ScalarCuntzLE w v) : ScalarCuntzLE (u + w) v := by
+  have h := ((scalarCuntzLE_iff_finite _ _).mp hu).block
+    ((scalarCuntzLE_iff_finite _ _).mp hw)
+  have heq : matrixBlock (scalarCorner v) (scalarCorner v) = doubleCorner v := by
+    rw [← diagonalCorner_one v, matrixBlock_diagonal]
+    rfl
+  rw [heq] at h
+  have hh := h.trans hv
+  let Y : CStarMatrix (Fin 2) (Fin 1) A := CStarMatrix.ofMatrix (fun _ _ => 1)
+  have hy : Y.conjTranspose * matrixBlock (scalarCorner u) (scalarCorner w) * Y =
+      scalarCorner (u + w) := by
+    apply CStarMatrix.ext
+    intro i j
+    fin_cases i
+    fin_cases j
+    simp only [CStarMatrix.mul_apply, Fin.sum_univ_two]
+    rw [Fin.sum_univ_two]
+    change ((star (1 : A) * u + star 1 * 0) * 1 +
+      (star 1 * 0 + star 1 * w) * 1) = u + w
+    simp
+  exact (scalarCuntzLE_iff_finite _ _).mpr (by simpa only [hy] using hh.conjugate Y)
+
+lemma square_add_le (x y : A) :
+    star (x + y) * (x + y) ≤ (2 : ℝ) • (star x * x + star y * y) := by
+  have hh := star_mul_self_nonneg (x - y)
+  have heq : (2 : ℝ) • (star x * x + star y * y) - star (x + y) * (x + y) =
+      star (x - y) * (x - y) := by
+    simp only [star_add, star_sub, two_smul]
+    noncomm_ring
+  rw [← sub_nonneg, heq]
+  exact hh
+
+lemma square_comparison_add {x y v : A} (hv : ProperlyInfinite v)
+    (hx : ScalarCuntzLE (star x * x) v) (hy : ScalarCuntzLE (star y * y) v) :
+    ScalarCuntzLE (star (x + y) * (x + y)) v := by
+  exact (scalarCuntzLE_of_order (star_mul_self_nonneg _) (square_add_le x y)).trans
+    ((scalarCuntzLE_smul (add_nonneg (star_mul_self_nonneg _) (star_mul_self_nonneg _))
+      (by norm_num : (0 : ℝ) < 2)).trans (scalarCuntzLE_add_of_proper hv hx hy))
+
+lemma idealSpan_square_comparison {v z : A} (hv : 0 ≤ v) (hpi : ProperlyInfinite v)
+    (hz : z ∈ idealSpan v) : ScalarCuntzLE (star z * z) v := by
+  induction hz using Submodule.span_induction with
+  | mem z hz =>
+    obtain ⟨x, y, rfl⟩ := hz
+    have hvv : ScalarCuntzLE (star v * v) v := by
+      apply scalarCuntzLE_of_mem_Her (star_mul_self_nonneg _) hv
+      rw [hv.isSelfAdjoint.star_eq]
+      exact mul_mem (self_mem_Her hv) (self_mem_Her hv)
+    have hh := ((scalarCuntzLE_left_square x v).trans hvv).conjugate_scalar y
+    simpa only [star_mul, mul_assoc] using hh
+  | zero =>
+    exact subset_closure ⟨0, by simp⟩
+  | add x y hx hy ihx ihy => exact square_comparison_add hpi ihx ihy
+  | smul c x hx ih =>
+    have hh := (scalarCuntzLE_left_square (c • (1 : A)) x).trans ih
+    simpa only [smul_mul_assoc, one_mul] using hh
+
+theorem closedIdeal_comparison {u v : A} (hu : 0 ≤ u) (hv : 0 ≤ v)
+    (hpi : ProperlyInfinite v) (h : u ∈ closedIdeal v hv.isSelfAdjoint) :
+    ScalarCuntzLE u v := by
+  let J := closedIdeal v hv.isSelfAdjoint
+  have hs : CFC.sqrt u ∈ J := by
+    rw [CFC.sqrt_eq_real_sqrt u hu]
+    let : IsClosed (J : Set A) := closedIdeal_closed v hv.isSelfAdjoint
+    exact cfcₙ_mem (𝕜' := ℂ) Real.sqrt h
+  have hc : Continuous (fun x : A => star x * x) := by fun_prop
+  have hh := image_closure_subset_closure_image hc ⟨CFC.sqrt u, hs, rfl⟩
+  simp only [(CFC.sqrt_nonneg u).isSelfAdjoint.star_eq, CFC.sqrt_mul_sqrt_self u hu] at hh
+  apply isClosed_closure.closure_subset_iff.mpr _ hh
+  rintro _ ⟨x, hx, rfl⟩
+  exact idealSpan_square_comparison hv hpi hx
+
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+local instance idealComparisonNonUnitalPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance idealComparisonNonUnitalStarOrderedRing : StarOrderedRing A :=
+  CStarAlgebra.spectralOrderedRing A
+
+lemma scalarCuntzLE_of_inr {u v : A} (hv : 0 ≤ v)
+    (h : ScalarCuntzLE (Unitization.inr u : Unitization ℂ A) (Unitization.inr v)) :
+    ScalarCuntzLE u v := by
+  let V : Unitization ℂ A := Unitization.inr v
+  have hc : IsClosed {z : Unitization ℂ A | ScalarCuntzLE z.snd v} :=
+    isClosed_closure.preimage Unitization.continuous_snd
+  apply closure_minimal (s := Set.range (fun w : Unitization ℂ A => star w * V * w)) _ hc h
+  rintro _ ⟨w, rfl⟩
+  change ScalarCuntzLE (star w * V * w).snd v
+  let hau := CStarAlgebra.increasingApproximateUnit A
+  let x := CFC.sqrt v
+  have hxx : star x * x = v := by
+    rw [(CFC.sqrt_nonneg v).isSelfAdjoint.star_eq, CFC.sqrt_mul_sqrt_self v]
+  have ht : Tendsto (fun e : A => star (x * e) * (x * e))
+      (CStarAlgebra.approximateUnit A) (𝓝 v) := by
+    simpa only [hxx] using (hau.tendsto_mul_left x).star.mul (hau.tendsto_mul_left x)
+  have hti := (Unitization.continuous_inr (𝕜 := ℂ)).tendsto v |>.comp ht
+  have htfinal : Tendsto
+      (fun e : A => (star w * (Unitization.inr (star (x*e)*(x*e)) : Unitization ℂ A) * w).snd)
+      (CStarAlgebra.approximateUnit A) (𝓝 (star w * V * w).snd) :=
+    Unitization.continuous_snd.tendsto _ |>.comp (tendsto_const_nhds.mul hti |>.mul tendsto_const_nhds)
+  apply isClosed_closure.mem_of_tendsto htfinal
+  apply Filter.Eventually.of_forall
+  intro e
+  let r : A := ((Unitization.inr e : Unitization ℂ A) * w).snd
+  have hr : (Unitization.inr r : Unitization ℂ A) = Unitization.inr e * w := by
+    have he := Unitization.inl_fst_add_inr_snd_eq ((Unitization.inr e : Unitization ℂ A) * w)
+    simpa [r] using he
+  have heq : (star w * (Unitization.inr (star (x*e)*(x*e)) : Unitization ℂ A) * w).snd =
+      star r * v * r := by
+    apply Unitization.inr_injective (R := ℂ)
+    have hs : (Unitization.inr (star r * v * r) : Unitization ℂ A) =
+        star w * Unitization.inr (star (x*e)*(x*e)) * w := by
+      simp only [Unitization.inr_mul, Unitization.inr_star, hr, star_mul]
+      have hx := congrArg (Unitization.inr : A → Unitization ℂ A) hxx
+      simp only [Unitization.inr_mul, Unitization.inr_star] at hx
+      simp only [mul_assoc] at hx ⊢
+      rw [← hx]
+      simp only [mul_assoc]
+    rw [← hs]
+    rfl
+  exact heq ▸ subset_closure ⟨r, rfl⟩
+
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/IdealDetection.lean

@@ -0,0 +1,192 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.PositiveFunctional
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Separation
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+universe u
+variable {A : Type u} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
+
+def compressedPositive (f : A →ₚ[ℂ] ℂ) (u : A) : A →ₚ[ℂ] ℂ where
+  toFun a := f (star u * a * u)
+  map_add' a b := by simp only [mul_add, add_mul, map_add]
+  map_smul' c a := by simp only [mul_smul_comm, smul_mul_assoc, map_smul, RingHom.id_apply]
+  monotone' := fun _ _ hab => f.monotone (star_left_conjugate_le_conjugate hab _)
+
+lemma compressedPositive_norm (f : A →ₚ[ℂ] ℂ) (hf : ∀ a, ‖f a‖ ≤ ‖a‖)
+    {u : A} (hu : ‖u‖ ≤ 1) (a : A) : ‖compressedPositive f u a‖ ≤ ‖a‖ := by
+  calc
+    ‖compressedPositive f u a‖ ≤ ‖star u * a * u‖ := hf _
+    _ ≤ ‖u‖ * ‖a‖ * ‖u‖ := by
+      grw [norm_mul_le, norm_mul_le, norm_star]
+    _ ≤ 1 * ‖a‖ * 1 := by gcongr
+    _ = ‖a‖ := by ring
+
+lemma compressedPositive_square (f : A →ₚ[ℂ] ℂ) (u a : A) :
+    compressedPositive f u (star a * a) = f (star (a * u) * (a * u)) := by
+  change f (star u * (star a * a) * u) = _
+  simp only [star_mul, mul_assoc]
+
+lemma norm_one_sub_positive_contraction {e : A} (he : 0 ≤ e) (hen : ‖e‖ ≤ 1) :
+    ‖1 - e‖ ≤ 1 := by
+  have he1 : e ≤ 1 := (CStarAlgebra.norm_le_one_iff_of_nonneg e he).mp hen
+  exact (CStarAlgebra.norm_le_one_iff_of_nonneg (1 - e) (sub_nonneg.mpr he1)).mpr
+    (sub_le_self _ he)
+
+lemma exists_rep_killing_ideal (J : NonUnitalStarSubalgebra ℂ A)
+    (hJ : IsClosed (J : Set A))
+    (hleft : ∀ a : A, ∀ z ∈ J, a * z ∈ J)
+    (hright : ∀ a : A, ∀ z ∈ J, z * a ∈ J)
+    {a : A} (ha : a ∉ J) :
+    ∃ R : HilbertRep.{u,u} A, (∀ z ∈ J, R.hom z = 0) ∧ R.hom a ≠ 0 := by
+  classical
+  have : Nontrivial A := ⟨⟨a, 0, fun h => ha (h.symm ▸ J.zero_mem)⟩⟩
+  have : CompleteSpace J := hJ.completeSpace_coe
+  let : PartialOrder J := CStarAlgebra.spectralOrder J
+  let : StarOrderedRing J := CStarAlgebra.spectralOrderedRing J
+  have hau := CStarAlgebra.increasingApproximateUnit J
+  let I := {e : J // @LE.le J (CStarAlgebra.spectralOrder J).toLE 0 e ∧ ‖e‖ ≤ 1}
+  let F : Filter I := Filter.comap Subtype.val (CStarAlgebra.approximateUnit J)
+  have : F.NeBot := Filter.NeBot.comap_of_range_mem inferInstance (by
+    filter_upwards [hau.eventually_nonneg.and hau.eventually_norm] with e he
+    exact ⟨⟨e, he⟩, rfl⟩)
+  let ω := Ultrafilter.of F
+  have hω : (ω : Filter I) ≤ F := Ultrafilter.of_le F
+  have hunit (z : J) : Tendsto (fun e : I => (z : A) * (1 - (e.val : A)))
+      (ω : Filter I) (𝓝 0) := by
+    have hh := (continuous_subtype_val.tendsto z).comp
+      (hau.tendsto_mul_left z |>.comp (Filter.tendsto_comap.mono_left hω))
+    have hz := (tendsto_const_nhds (x := (z : A))).sub hh
+    convert hz using 1 <;> simp only [mul_sub, mul_one, sub_self]
+    rfl
+  have hadef : a ∉ closure (J : Set A) := by rwa [hJ.closure_eq]
+  rw [Metric.mem_closure_iff] at hadef
+  push Not at hadef
+  obtain ⟨r, hr, hdist⟩ := hadef
+  have hlower (e : I) : r ≤ ‖a * (1 - (e.val : A))‖ := by
+    have hh := hdist (a * (e.val : A)) (hleft a _ e.val.property)
+    simpa only [dist_eq_norm, mul_sub, mul_one] using hh
+  have hen (e : I) : ‖1 - (e.val : A)‖ ≤ 1 := by
+    apply norm_one_sub_positive_contraction
+    · obtain ⟨b, hb⟩ := CStarAlgebra.nonneg_iff_eq_star_mul_self.mp e.property.1
+      have hm := congrArg (fun z : J => (z : A)) hb
+      change (e.val : A) = star (b : A) * (b : A) at hm
+      rw [hm]
+      exact star_mul_self_nonneg _
+    · exact e.property.2
+  have hex (e : I) := exists_norming_positive (A := A)
+    (star_mul_self_nonneg (a * (1 - (e.val : A))))
+  choose f hf hfa using hex
+  let g (e : I) := compressedPositive (f e) (1 - (e.val : A))
+  have hg (e : I) (z : A) : ‖g e z‖ ≤ ‖z‖ := compressedPositive_norm (f e) (hf e) (hen e) z
+  let L := ultraPositive ω g hg
+  have hL (z : A) (hz : z ∈ J) : L.gnsStarAlgHom z = 0 := by
+    change L.gnsNonUnitalStarAlgHom z = 0
+    apply gns_zero_of_sandwich
+    intro b
+    apply ultraPositive_eq_zero_of_tendsto
+    have hlim := (hunit ⟨z * b, hright b z hz⟩).norm
+    apply squeeze_zero_norm (fun e => ?_) (by simpa only [norm_zero, mul_zero] using hlim.mul hlim)
+    calc
+      ‖g e (star (z * b) * (z * b))‖ =
+          ‖f e (star ((z * b) * (1 - (e.val : A))) * ((z * b) * (1 - (e.val : A))))‖ := by
+        change ‖compressedPositive (f e) (1 - (e.val : A)) (star (z * b) * (z * b))‖ = _
+        rw [compressedPositive_square]
+      _ ≤ ‖star ((z * b) * (1 - (e.val : A))) * ((z * b) * (1 - (e.val : A)))‖ := hf e _
+      _ = _ := CStarRing.norm_star_mul_self
+  have hnon : L (star a * a) ≠ 0 := by
+    have hv (e : I) : g e (star a * a) = (‖a * (1 - (e.val : A))‖ ^ 2 : ℝ) := by
+      change compressedPositive (f e) (1 - (e.val : A)) (star a * a) = _
+      rw [compressedPositive_square, hfa e, CStarRing.norm_star_mul_self, pow_two]
+    have hb : (r ^ 2 : ℂ) ≤ L (star a * a) :=
+      ge_of_tendsto' (tendsto_ultraPositive ω g hg _) (fun e => by
+        rw [hv e]
+        exact_mod_cast pow_le_pow_left₀ hr.le (hlower e) 2)
+    intro heq
+    rw [heq] at hb
+    have : r ^ 2 ≤ 0 := by exact_mod_cast hb
+    nlinarith
+  exact ⟨⟨L.GNS, L.gnsStarAlgHom⟩, hL, gnsStar_nonzero_of_value L a hnon⟩
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+local instance idealDetectionOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance idealDetectionStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+def ScalarCuntzLE (u v : A) : Prop :=
+  u ∈ closure (Set.range (fun w : A => star w * v * w))
+
+lemma scalarCuntzLE_iff_finite (u v : A) :
+    ScalarCuntzLE u v ↔ FiniteCuntzLE (scalarCorner u) (scalarCorner v) := by
+  let E : A ≃⋆ₐ[ℂ] CStarMatrix (Fin 1) (Fin 1) A :=
+    CStarMatrix.toOneByOne (Fin 1) ℂ A
+  have hc : Continuous E := (StarAlgEquiv.isometry E).continuous
+  have hci : Continuous E.symm := (StarAlgEquiv.isometry E.symm).continuous
+  rw [finiteCuntzLE_iff_closure]
+  change u ∈ closure (Set.range (fun w : A => star w * v * w)) ↔
+    E u ∈ closure (Set.range (fun w : CStarMatrix (Fin 1) (Fin 1) A =>
+      star w * E v * w))
+  constructor
+  · intro h
+    apply closure_mono (s := E '' Set.range (fun w : A => star w * v * w)) _
+      (image_closure_subset_closure_image hc ⟨u, h, rfl⟩)
+    rintro _ ⟨_, ⟨w, rfl⟩, rfl⟩
+    exact ⟨E w, by simp [map_star]⟩
+  · intro h
+    have hh := image_closure_subset_closure_image hci ⟨E u, h, rfl⟩
+    simp only [StarAlgEquiv.symm_apply_apply] at hh
+    apply closure_mono (s := E.symm '' Set.range (fun w => star w * E v * w)) _ hh
+    rintro _ ⟨_, ⟨w, rfl⟩, rfl⟩
+    exact ⟨E.symm w, by simp [map_star]⟩
+
+lemma ScalarCuntzLE.exists_approx {u v : A} (h : ScalarCuntzLE u v)
+    {ε : ℝ} (hε : 0 < ε) : ∃ w : A, ‖star w * v * w - u‖ < ε := by
+  obtain ⟨_, ⟨w, rfl⟩, hw⟩ := Metric.mem_closure_iff.mp h ε hε
+  exact ⟨w, by simpa only [dist_eq_norm, norm_sub_rev] using hw⟩
+
+lemma ScalarCuntzLE.trans {u v w : A} (h : ScalarCuntzLE u v)
+    (h' : ScalarCuntzLE v w) : ScalarCuntzLE u w :=
+  (scalarCuntzLE_iff_finite _ _).mpr
+    (((scalarCuntzLE_iff_finite _ _).mp h).trans ((scalarCuntzLE_iff_finite _ _).mp h'))
+
+lemma scalarCuntzLE_of_mem_Her {u v : A} (hu : 0 ≤ u) (hv : 0 ≤ v)
+    (h : u ∈ Her v) : ScalarCuntzLE u v := by
+  have hs := sqrt_mem_Her h hu
+  have hc : Continuous (fun z : A => star z * z) := by fun_prop
+  have hm := image_closure_subset_closure_image hc ⟨CFC.sqrt u, hs, rfl⟩
+  simp only [(CFC.sqrt_nonneg u).isSelfAdjoint.star_eq, CFC.sqrt_mul_sqrt_self u hu] at hm
+  apply closure_mono (s := (fun z : A => star z * z) ''
+      Set.range (fun w : A => v * w * star v)) _ hm
+  rintro _ ⟨_, ⟨w, rfl⟩, rfl⟩
+  refine ⟨CFC.sqrt v * w * v, ?_⟩
+  have hsv := (CFC.sqrt_nonneg v).isSelfAdjoint.star_eq
+  have hsq := CFC.sqrt_mul_sqrt_self v hv
+  simp only [star_mul, hv.isSelfAdjoint.star_eq, hsv, mul_assoc]
+  have hh : CFC.sqrt v * v * CFC.sqrt v = v * v := by
+    calc
+      _ = CFC.sqrt v * (CFC.sqrt v * CFC.sqrt v) * CFC.sqrt v :=
+        congrArg (fun t => CFC.sqrt v * t * CFC.sqrt v) hsq.symm
+      _ = (CFC.sqrt v * CFC.sqrt v) * (CFC.sqrt v * CFC.sqrt v) := by noncomm_ring
+      _ = v * v := by rw [hsq]
+  calc
+    _ = v * star w * (CFC.sqrt v * v * CFC.sqrt v) * w * v := by noncomm_ring
+    _ = _ := by rw [hh]; noncomm_ring
+
+lemma scalarCuntzLE_of_order {u v : A} (hu : 0 ≤ u) (h : u ≤ v) :
+    ScalarCuntzLE u v := scalarCuntzLE_of_mem_Her hu (hu.trans h) (mem_Her_of_nonneg_le hu h)
+
+lemma scalarCuntzLE_smul {v : A} (hv : 0 ≤ v) {K : ℝ} (hK : 0 < K) :
+    ScalarCuntzLE (K • v) v := by
+  apply scalarCuntzLE_of_mem_Her (smul_nonneg hK.le hv) hv
+  exact real_smul_mem_Her (self_mem_Her hv) K
+
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Main.lean

@@ -0,0 +1,56 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Diagonalization
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.MatrixEntries
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap.Manuscript
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+local instance positivityOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance positivityStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+def CuntzLE (d v : Stable.Stabilization A) : Prop :=
+  ∃ r : ℕ → Stable.Stabilization A,
+    Tendsto (fun j => star (r j) * v * r j) atTop (𝓝 d)
+
+def ProperlyInfinite (h : A) : Prop :=
+  CuntzLE ((⟦⟨2, MainGap.doubleCorner h⟩⟧ : Stable.Algebraic A) : Stable.Stabilization A)
+    ((⟦⟨1, MainGap.scalarCorner h⟩⟧ : Stable.Algebraic A) : Stable.Stabilization A)
+
+def PropertyP (A : Type*) [NonUnitalCStarAlgebra A] : Prop :=
+  ∀ h : A, 0 ≤ h → ProperlyInfinite h
+
+lemma finiteCuntzLE_of_stable {m n : ℕ} (d : Stable.Mat A n) (v : Stable.Mat A m)
+    (h : CuntzLE (Stable.corner n d) (Stable.corner m v)) : MainGap.FiniteCuntzLE d v := by
+  obtain ⟨r,hr⟩ := h
+  refine ⟨fun j => Stable.block m n (r j), ?_⟩
+  have ht := (Stable.continuous_block (A := A) n n).continuousAt.tendsto.comp hr
+  simpa only [Function.comp_def, Stable.block_conjugate, Stable.block_corner_self] using ht
+
+lemma PropertyP.finite (hP : PropertyP A) : MainGap.PropertyP A := by
+  intro h hh
+  exact finiteCuntzLE_of_stable _ _ (hP h hh)
+
+theorem individual_to_strong (hP : PropertyP A) : MainGap.UnrestrictedDiagonalization A :=
+  MainGap.individual_to_strong hP.finite
+
+theorem individual_to_strong_spi (hP : PropertyP A) : MainGap.StronglyPurelyInfinite A :=
+  MainGap.individual_to_strong_spi hP.finite
+
+theorem individual_to_strong_main (hP : PropertyP A) :
+    (∀ a b : A, 0 ≤ a → 0 ≤ b → ∀ c : A, ∀ ε : ℝ, 0 < ε →
+      ∃ s t : A,
+        ‖star s * a * s - a‖ < ε ∧
+        ‖star t * b * t - b‖ < ε ∧
+        ‖star s * c * t‖ < ε) ∧
+    MainGap.StronglyPurelyInfinite A := by
+  exact ⟨individual_to_strong hP, individual_to_strong_spi hP⟩
+
+end MainGap.Manuscript
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/MatrixEntries.lean

@@ -0,0 +1,166 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Stabilization
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap.Stable
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+local instance matrixEntryOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance matrixEntryStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+local instance algebraicTopology' : TopologicalSpace (Algebraic A) :=
+  (inferInstance : PseudoMetricSpace (Algebraic A)).toUniformSpace.toTopologicalSpace
+
+def paddedEntry (i j n : ℕ) (x : Mat A n) : A :=
+  if hi : i < n then if hj : j < n then x ⟨i,hi⟩ ⟨j,hj⟩ else 0 else 0
+
+lemma paddedEntry_pad (i j : ℕ) {n m : ℕ} (h : n ≤ m) (x : Mat A n) :
+    paddedEntry i j m (pad h x) = paddedEntry i j n x := by
+  by_cases hi : i < n <;> by_cases hj : j < n
+  · have hi' := lt_of_lt_of_le hi h
+    have hj' := lt_of_lt_of_le hj h
+    simp [paddedEntry, hi, hj, hi', hj', pad_entry]
+  · by_cases hi' : i < m <;> by_cases hj' : j < m <;>
+      simp [paddedEntry, hi, hj, hi', hj', pad_entry]
+  · by_cases hi' : i < m <;> by_cases hj' : j < m <;>
+      simp [paddedEntry, hi, hi', hj', pad_entry]
+  · by_cases hi' : i < m <;> by_cases hj' : j < m <;>
+      simp [paddedEntry, hi, hi', hj', pad_entry]
+
+def entryAlgLinear (i j : ℕ) : Algebraic A →ₗ[ℂ] A where
+  toFun := DirectLimit.lift _ (paddedEntry i j) (fun _ _ h x => (paddedEntry_pad i j h x).symm)
+  map_add' := DirectLimit.induction₂ _ fun n x y => by
+    rw [DirectLimit.add_def]
+    change paddedEntry i j n (x+y) = paddedEntry i j n x + paddedEntry i j n y
+    by_cases hi : i < n <;> by_cases hj : j < n <;> simp [paddedEntry, hi, hj]
+  map_smul' c := DirectLimit.induction _ fun n x => by
+    rw [DirectLimit.smul_def]
+    change paddedEntry i j n (c • x) = c • paddedEntry i j n x
+    by_cases hi : i < n <;> by_cases hj : j < n <;> simp [paddedEntry, hi, hj]
+
+@[simp] lemma entryAlgLinear_corner (i j n : ℕ) (x : Mat A n) :
+    entryAlgLinear i j (cornerAlg n x) = paddedEntry i j n x := rfl
+
+lemma norm_entryAlgLinear_le (i j : ℕ) (x : Algebraic A) :
+    ‖entryAlgLinear i j x‖ ≤ ‖x‖ := by
+  induction x using DirectLimit.induction with
+  | ih n x =>
+    change ‖paddedEntry i j n x‖ ≤ ‖x‖
+    by_cases hi : i < n <;> by_cases hj : j < n
+    · simpa [paddedEntry, hi, hj] using
+        (CStarMatrix.norm_entry_le_norm (M := x) (i := ⟨i,hi⟩) (j := ⟨j,hj⟩))
+    all_goals simp [paddedEntry, hi, hj]
+
+def entryAlg (i j : ℕ) : Algebraic A →L[ℂ] A :=
+  (entryAlgLinear i j).mkContinuous 1 (fun x => by simpa using norm_entryAlgLinear_le i j x)
+
+def entry (i j : ℕ) : Stabilization A → A :=
+  UniformSpace.Completion.extension (entryAlg (A := A) i j)
+
+lemma continuous_entry (i j : ℕ) : Continuous (entry (A := A) i j) :=
+  UniformSpace.Completion.continuous_extension
+
+@[simp] lemma entry_coe (i j : ℕ) (x : Algebraic A) :
+    entry i j (x : Stabilization A) = entryAlg (A := A) i j x := by
+  unfold entry
+  exact UniformSpace.Completion.extension_coe (f := (entryAlg (A := A) i j))
+    (ContinuousLinearMap.uniformContinuous (entryAlg (A := A) i j)) x
+
+@[simp] lemma entry_corner (i j n : ℕ) (x : Mat A n) :
+    entry i j (corner n x) = paddedEntry i j n x := by
+  rw [corner_apply, entry_coe]
+  rfl
+
+def block (m n : ℕ) (x : Stabilization A) : CStarMatrix (Fin m) (Fin n) A :=
+  CStarMatrix.ofMatrix fun i j => entry i.val j.val x
+
+@[simp] lemma block_apply (m n : ℕ) (x : Stabilization A) (i : Fin m) (j : Fin n) :
+    block m n x i j = entry i.val j.val x := rfl
+
+lemma continuous_block (m n : ℕ) : Continuous (block (A := A) m n) := by
+  exact continuous_pi fun i => continuous_pi fun j => (continuous_entry i.val j.val)
+
+@[simp] lemma block_corner_self (n : ℕ) (x : Mat A n) : block n n (corner n x) = x := by
+  ext i j
+  simp only [block_apply, entry_corner, paddedEntry, dite_eq_left i.isLt, dite_eq_left j.isLt]
+
+end MainGap.Stable
+
+namespace MainGap.Stable
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+local instance blockConjugateOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance blockConjugateStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+local instance algebraicTopology'' : TopologicalSpace (Algebraic A) :=
+  (inferInstance : PseudoMetricSpace (Algebraic A)).toUniformSpace.toTopologicalSpace
+
+lemma paddedEntry_star (i j n : ℕ) (x : Mat A n) :
+    paddedEntry i j n (star x) = star (paddedEntry j i n x) := by
+  by_cases hi : i < n <;> by_cases hj : j < n <;>
+    simp [paddedEntry, hi, hj, CStarMatrix.star_apply]
+
+lemma paddedEntry_mul (i j n : ℕ) (x y : Mat A n) :
+    paddedEntry i j n (x*y) =
+      ∑ k : Fin n, paddedEntry i k.val n x * paddedEntry k.val j n y := by
+  by_cases hi : i < n <;> by_cases hj : j < n <;>
+    simp [paddedEntry, hi, hj, CStarMatrix.mul_apply]
+
+lemma paddedEntry_conjugate (i j : ℕ) {m N : ℕ} (h : m ≤ N)
+    (z : Mat A N) (v : Mat A m) :
+    paddedEntry i j N (star z * pad h v * z) =
+      ∑ q : Fin m, ∑ p : Fin m,
+        star (paddedEntry p.val i N z) * v p q * paddedEntry q.val j N z := by
+  classical
+  simp only [paddedEntry_mul, paddedEntry_star, paddedEntry_pad]
+  rw [← sum_pad h (fun q : Fin m => ∑ p : Fin m,
+      star (paddedEntry p.val i N z) * v p q * paddedEntry q.val j N z)]
+  apply Finset.sum_congr rfl
+  intro q _
+  by_cases hq : q.val < m
+  · rw [dite_eq_left hq, Finset.sum_mul]
+    rw [← sum_pad h (fun p : Fin m =>
+      star (paddedEntry p.val i N z) * v p ⟨q,hq⟩ * paddedEntry q.val j N z)]
+    apply Finset.sum_congr rfl
+    intro p _
+    by_cases hp : p.val < m <;> simp [paddedEntry, hp, hq]
+  · simp [paddedEntry, hq]
+
+lemma block_conjugate_corner {m N : ℕ} (h : m ≤ N) (n : ℕ)
+    (v : Mat A m) (z : Mat A N) :
+    block n n (star (corner N z) * corner m v * corner N z) =
+      (block m n (corner N z)).conjTranspose * v * block m n (corner N z) := by
+  rw [← corner_pad h v]
+  have he : star (corner N z) * corner N (pad h v) * corner N z =
+      corner N (star z * pad h v * z) := by rw [map_mul, map_mul, map_star]
+  rw [he]
+  ext i j
+  simp only [block_apply, entry_corner, CStarMatrix.mul_apply,
+    CStarMatrix.conjTranspose_apply, Finset.sum_mul]
+  exact paddedEntry_conjugate i.val j.val h z v
+
+lemma block_conjugate (m n : ℕ) (v : Mat A m) (x : Stabilization A) :
+    block n n (star x * corner m v * x) =
+      (block m n x).conjTranspose * v * block m n x := by
+  refine UniformSpace.Completion.induction_on x ?_ ?_
+  · apply isClosed_eq
+    · exact (continuous_block n n).comp ((continuous_star.mul continuous_const).mul continuous_id)
+    · have hc : Continuous (fun x : Stabilization A => (block m n x).conjTranspose) := by
+        change Continuous (fun x : Stabilization A =>
+          fun i j => star (block m n x j i))
+        exact continuous_pi fun i => continuous_pi fun j =>
+          continuous_star.comp (continuous_entry j.val i.val)
+      exact (hc.matrix_mul continuous_const).matrix_mul (continuous_block m n)
+  · intro z
+    induction z using DirectLimit.induction with
+    | ih k z =>
+      change block n n (star (corner k z) * corner m v * corner k z) =
+        (block m n (corner k z)).conjTranspose * v * block m n (corner k z)
+      rw [← corner_pad (le_max_right m k) z]
+      exact block_conjugate_corner (le_max_left m k) n v _
+
+end MainGap.Stable
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Nonvanishing.lean

@@ -0,0 +1,138 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Graph
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+universe u v
+variable {A : Type u} [CStarAlgebra A]
+local instance nonvanishingPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance nonvanishingStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+local instance nonvanishingOperatorPartialOrder (J : Type*)
+    [NormedAddCommGroup J] [InnerProductSpace ℂ J] [CompleteSpace J] :
+    PartialOrder (J →L[ℂ] J) := CStarAlgebra.spectralOrder _
+local instance nonvanishingOperatorStarOrderedRing (J : Type*)
+    [NormedAddCommGroup J] [InnerProductSpace ℂ J] [CompleteSpace J] :
+    StarOrderedRing (J →L[ℂ] J) := CStarAlgebra.spectralOrderedRing _
+lemma cut_eq_zero_of_norm_le {a : A} (ha : 0 ≤ a) {l : ℝ} (hl : ‖a‖ ≤ l) :
+    cut a l = 0 := by
+  apply norm_eq_zero.mp
+  apply le_antisymm _ (norm_nonneg _)
+  change ‖cfcₙ (fun t : ℝ => max (t-l) 0) a‖ ≤ 0
+  apply norm_cfcₙ_le
+  intro r hr
+  have hb := NonUnitalIsometricContinuousFunctionalCalculus.norm_quasispectrum_le a hr
+    ha.isSelfAdjoint
+  have hb' : |r| ≤ ‖a‖ := by simpa only [Real.norm_eq_abs] using hb
+  have ht : r ≤ l := (le_abs_self r).trans (hb'.trans hl)
+  rw [max_eq_right (sub_nonpos.mpr ht), norm_zero]
+
+theorem quantitative_nonvanishing {d y : A} (hy : 0 ≤ y)
+    (h : ∀ R : HilbertRep.{u,u} A, R.hom d=0 → ‖R.hom y‖ ≤ (1/4 : ℝ)) :
+    ∃ δ : ℝ, 0 < δ ∧ δ < 1 ∧ ∀ R : HilbertRep.{u,u} A,
+      (3/8 : ℝ) < ‖R.hom y‖ → δ < ‖R.hom d‖ := by
+  classical
+  by_contra! hh
+  let η : ℕ → ℝ := fun n => 1 / ((n : ℝ)+2)
+  have hηpos (n : ℕ) : 0 < η n := by dsimp [η]; positivity
+  have hηlt (n : ℕ) : η n < 1 := by
+    dsimp [η]
+    apply (div_lt_one (by positivity)).mpr
+    linarith [Nat.cast_nonneg (α := ℝ) n]
+  have hbad (n : ℕ) : ∃ R : HilbertRep.{u,u} A,
+      (3/8 : ℝ) < ‖R.hom y‖ ∧ ‖R.hom d‖ ≤ η n := hh (η n) (hηpos n) (hηlt n)
+  choose R hRy hRd using hbad
+  let π := fun n => (R n).hom
+  let a := cut y (5/16)
+  have ha : ∀ n, (1/16 : ℝ) < ‖π n a‖ := by
+    intro n
+    have h₁ : ‖π n y - π n a‖ ≤ (5/16 : ℝ) := by
+      rw [← map_sub]
+      exact (NonUnitalStarAlgHom.norm_apply_le (π n) _).trans
+        (norm_sub_cut_le hy (by norm_num))
+    have h₂ := norm_sub_norm_le (π n y) (π n a)
+    have h₃ := hRy n
+    change (3/8 : ℝ) < ‖π n y‖ at h₃
+    linarith
+  choose ξ hξ hξa using fun n => (π n a).exists_lt_apply_of_lt_opNorm (ha n)
+  have hnξ : ∀ n, ‖ξ n‖ ≤ 1 := fun n => (hξ n).le
+  let ω : Ultrafilter ℕ := Ultrafilter.of atTop
+  have hω : (ω : Filter ℕ) ≤ atTop := Ultrafilter.of_le _
+  have hη : Tendsto η (ω : Filter ℕ) (𝓝 0) := by
+    have he : η = fun n : ℕ => 1 / (((n+1 : ℕ) : ℝ)+1) := by
+      funext n
+      dsimp [η]
+      push_cast
+      congr 1; ring
+    rw [he]
+    exact ((tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).comp
+      (tendsto_add_atTop_nat 1)).mono_left hω
+  let ρ : HilbertRep.{u,u} A := ⟨LimitHilbert ω π ξ hnξ, limitRep ω π ξ hnξ⟩
+  have hd₀ : ρ.hom d=0 := limitRep_annihilates ω π ξ hnξ d
+    (squeeze_zero (fun n => norm_nonneg _) hRd hη)
+  have han : ρ.hom a ≠ 0 := limitRep_nonzero ω π ξ hnξ a (by norm_num : (0:ℝ)<1/16)
+    (Filter.Eventually.of_forall (fun n => (hξa n).le))
+  apply han
+  change ρ.hom (cut y (5/16))=0
+  rw [map_cut_sa ρ.hom hy.isSelfAdjoint (by norm_num)]
+  exact cut_eq_zero_of_norm_le (map_nonneg ρ.hom hy) ((h ρ hd₀).trans (by norm_num))
+
+theorem quantitative_nonvanishing_general {d y : A} (hy : 0 ≤ y)
+    {s s' : ℝ} (hs : 0 ≤ s) (hss : s < s')
+    (h : ∀ R : HilbertRep.{u,u} A, R.hom d=0 → ‖R.hom y‖ ≤ s) :
+    ∃ δ : ℝ, 0 < δ ∧ δ < 1 ∧ ∀ R : HilbertRep.{u,u} A,
+      s' < ‖R.hom y‖ → δ < ‖R.hom d‖ := by
+  classical
+  by_contra! hh
+  let η : ℕ → ℝ := fun n => 1 / ((n : ℝ)+2)
+  have hηpos (n : ℕ) : 0 < η n := by dsimp [η]; positivity
+  have hηlt (n : ℕ) : η n < 1 := by
+    dsimp [η]
+    apply (div_lt_one (by positivity)).mpr
+    linarith [Nat.cast_nonneg (α := ℝ) n]
+  have hbad (n : ℕ) : ∃ R : HilbertRep.{u,u} A,
+      s' < ‖R.hom y‖ ∧ ‖R.hom d‖ ≤ η n := hh (η n) (hηpos n) (hηlt n)
+  choose R hRy hRd using hbad
+  let π := fun n => (R n).hom
+  let a := cut y ((s+s')/2)
+  have ha : ∀ n, ((s'-s)/2) < ‖π n a‖ := by
+    intro n
+    have h₁ : ‖π n y - π n a‖ ≤ ((s+s')/2) := by
+      rw [← map_sub]
+      exact (NonUnitalStarAlgHom.norm_apply_le (π n) _).trans
+        (norm_sub_cut_le hy (by linarith))
+    have h₂ := norm_sub_norm_le (π n y) (π n a)
+    have h₃ := hRy n
+    change s' < ‖π n y‖ at h₃
+    linarith
+  choose ξ hξ hξa using fun n => (π n a).exists_lt_apply_of_lt_opNorm (ha n)
+  have hnξ : ∀ n, ‖ξ n‖ ≤ 1 := fun n => (hξ n).le
+  let ω : Ultrafilter ℕ := Ultrafilter.of atTop
+  have hω : (ω : Filter ℕ) ≤ atTop := Ultrafilter.of_le _
+  have hη : Tendsto η (ω : Filter ℕ) (𝓝 0) := by
+    have he : η = fun n : ℕ => 1 / (((n+1 : ℕ) : ℝ)+1) := by
+      funext n
+      dsimp [η]
+      push_cast
+      congr 1; ring
+    rw [he]
+    exact ((tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).comp
+      (tendsto_add_atTop_nat 1)).mono_left hω
+  let ρ : HilbertRep.{u,u} A := ⟨LimitHilbert ω π ξ hnξ, limitRep ω π ξ hnξ⟩
+  have hd₀ : ρ.hom d=0 := limitRep_annihilates ω π ξ hnξ d
+    (squeeze_zero (fun n => norm_nonneg _) hRd hη)
+  have han : ρ.hom a ≠ 0 := limitRep_nonzero ω π ξ hnξ a (by linarith : (0:ℝ)<(s'-s)/2)
+    (Filter.Eventually.of_forall (fun n => (hξa n).le))
+  apply han
+  change ρ.hom (cut y ((s+s')/2))=0
+  rw [map_cut_sa ρ.hom hy.isSelfAdjoint (by linarith)]
+  exact cut_eq_zero_of_norm_le (map_nonneg ρ.hom hy) ((h ρ hd₀).trans (by linarith))
+
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/OrthogonalSlots.lean

@@ -0,0 +1,395 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Comparison
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+open scoped CStarAlgebra
+local instance orthogonalSlotsPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance orthogonalSlotsStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+local instance orthogonalSlotsMatrixIsScalarTower (n : ℕ) :
+    IsScalarTower ℝ (CStarMatrix (Fin n) (Fin n) A)
+    (CStarMatrix (Fin n) (Fin n) A) where
+  smul_assoc r x y := CStarMatrix.smul_mul r x y
+local instance orthogonalSlotsMatrixSMulCommClass (n : ℕ) :
+    SMulCommClass ℝ (CStarMatrix (Fin n) (Fin n) A)
+    (CStarMatrix (Fin n) (Fin n) A) where
+  smul_comm r x y := (CStarMatrix.mul_smul x r y).symm
+
+lemma cut_map {B : Type*} [NonUnitalCStarAlgebra B]
+    (f : A →⋆ₙₐ[ℂ] B) (a : A) (ε : ℝ) (ha : IsSelfAdjoint a) (hε : 0 ≤ ε) :
+    cut (f a) ε = f (cut a ε) :=
+  (f.map_cfcₙ (q := IsSelfAdjoint) (fun t : ℝ => max (t-ε) 0) a
+    (hf₀ := by simp [hε]) (ha := ha)).symm
+
+def entry {n : ℕ} (i j : Fin n) (a : A) : CStarMatrix (Fin n) (Fin n) A :=
+  CStarMatrix.ofMatrix (Matrix.single i j a)
+
+@[simp] lemma entry_apply {n : ℕ} (i j k l : Fin n) (a : A) :
+    entry i j a k l = if i = k ∧ j = l then a else 0 := rfl
+
+@[simp] lemma entry_mul {n : ℕ} (i j k : Fin n) (a b : A) :
+    entry i j a * entry j k b = entry i k (a * b) :=
+  Matrix.single_mul_single_same a i j k b
+
+lemma entry_mul_of_ne {n : ℕ} (i j k l : Fin n) (a b : A) (h : j ≠ k) :
+    entry i j a * entry k l b = 0 :=
+  Matrix.single_mul_single_of_ne a i j k h b
+
+@[simp] lemma star_entry {n : ℕ} (i j : Fin n) (a : A) :
+    star (entry i j a) = entry j i (star a) := by
+  apply CStarMatrix.ext
+  intro k l
+  change star (Matrix.single i j a l k) = Matrix.single j i (star a) k l
+  simp only [Matrix.single_apply]
+  split_ifs <;> simp_all
+
+@[simp] lemma entry_add {n : ℕ} (i j : Fin n) (a b : A) :
+    entry i j (a+b) = entry i j a + entry i j b := Matrix.single_add _ _ _ _
+
+@[simp] lemma entry_smul {n : ℕ} (i j : Fin n) (c : ℂ) (a : A) :
+    entry i j (c • a) = c • entry i j a := (Matrix.smul_single _ _ _ _).symm
+
+@[simp] lemma entry_zero {n : ℕ} (i j : Fin n) : entry i j (0 : A) = 0 :=
+  Matrix.single_zero _ _
+
+def cornerHom {n : ℕ} (i : Fin n) : A →⋆ₙₐ[ℂ] CStarMatrix (Fin n) (Fin n) A where
+  toFun := entry i i
+  map_zero' := entry_zero i i
+  map_add' := entry_add i i
+  map_mul' := fun a b => (entry_mul i i i a b).symm
+  map_smul' := entry_smul i i
+  map_star' := fun a => (star_entry i i a).symm
+
+lemma diagonalCorner_mul {n : ℕ} (a b : A) :
+    diagonalCorner n (a*b) = diagonalCorner n a * diagonalCorner n b := by
+  exact congrArg CStarMatrix.ofMatrix (Matrix.diagonal_mul_diagonal (fun _ => a) (fun _ => b)).symm
+
+lemma star_diagonalCorner {n : ℕ} (a : A) :
+    star (diagonalCorner n a) = diagonalCorner n (star a) := by
+  apply CStarMatrix.ext
+  intro i j
+  change star (Matrix.diagonal (fun _ => a) j i) = Matrix.diagonal (fun _ => star a) i j
+  simp only [Matrix.diagonal_apply]
+  split_ifs <;> simp_all
+
+def diagonalHom (n : ℕ) : A →⋆ₙₐ[ℂ] CStarMatrix (Fin n) (Fin n) A where
+  toFun := diagonalCorner n
+  map_zero' := by ext i j; simp [diagonalCorner]
+  map_add' a b := by ext i j; simp [diagonalCorner, Matrix.diagonal_apply]; split_ifs <;> simp
+  map_mul' := diagonalCorner_mul
+  map_smul' c a := by ext i j; simp [diagonalCorner, Matrix.diagonal_apply]
+  map_star' := fun a => star_diagonalCorner a |>.symm
+
+lemma corner_cut {n : ℕ} (i : Fin n) (a : A) (ε : ℝ) (ha : IsSelfAdjoint a) (hε : 0 ≤ ε) :
+    cut (entry i i a) ε = entry i i (cut a ε) := by
+  exact cut_map (cornerHom i) a ε ha hε
+
+lemma diagonal_cut (n : ℕ) (a : A) (ε : ℝ) (ha : IsSelfAdjoint a) (hε : 0 ≤ ε) :
+    cut (diagonalCorner n a) ε = diagonalCorner n (cut a ε) := by
+  exact cut_map (diagonalHom n) a ε ha hε
+
+lemma continuous_entry {n : ℕ} (i j : Fin n) : Continuous (entry (A := A) i j) := by
+  change Continuous (fun a : A => (Matrix.single i j a : Matrix (Fin n) (Fin n) A))
+  apply continuous_pi; intro k
+  apply continuous_pi; intro l
+  change Continuous (fun a : A => if i = k ∧ j = l then a else 0)
+  split_ifs
+  · exact continuous_id
+  · exact continuous_const
+
+lemma entry_mem_diagonalHer {n : ℕ} (i j : Fin n) {h a : A} (ha : a ∈ Her h) :
+    entry i j a ∈ Her (diagonalCorner n h) := by
+  refine closure_minimal (s := Set.range (fun b : A => h*b*star h))
+    (t := {b | entry i j b ∈ Her (diagonalCorner n h)}) ?_ ?_ ha
+  · rintro _ ⟨b, rfl⟩
+    have heq : entry i j (h*b*star h) =
+        diagonalCorner n h * entry i j b * star (diagonalCorner n h) := by
+      rw [star_diagonalCorner]
+      apply CStarMatrix.ext
+      intro k l
+      change Matrix.single i j (h*b*star h) k l =
+        ((Matrix.diagonal (fun _ : Fin n => h) * Matrix.single i j b *
+          Matrix.diagonal (fun _ : Fin n => star h)) : Matrix (Fin n) (Fin n) A) k l
+      simp only [Matrix.mul_diagonal, Matrix.diagonal_mul, Matrix.single_apply]
+      split_ifs <;> simp
+    change entry i j (h*b*star h) ∈ Her _
+    rw [heq]
+    exact sandwich_mem_Her _ _
+  · exact (isClosed_Her _).preimage (continuous_entry i j)
+
+lemma cornerHer_entries {n : ℕ} (i : Fin n) {h : A}
+    {a : CStarMatrix (Fin n) (Fin n) A} (ha : a ∈ Her (entry i i h))
+    (j k : Fin n) : a j k ∈ Her h ∧ (j ≠ i ∨ k ≠ i → a j k = 0) := by
+  refine closure_minimal (s := Set.range (fun b => entry i i h * b * star (entry i i h)))
+    (t := {b | b j k ∈ Her h ∧ (j ≠ i ∨ k ≠ i → b j k = 0)}) ?_ ?_ ha
+  · rintro _ ⟨b, rfl⟩
+    have heq : entry i i h * b * star (entry i i h) = entry i i (h*b i i*star h) := by
+      rw [star_entry]
+      exact Matrix.single_mul_mul_single i i i i h (CStarMatrix.ofMatrix.symm b) (star h)
+    change (entry i i h * b * star (entry i i h)) j k ∈ Her h ∧
+      (j ≠ i ∨ k ≠ i → (entry i i h * b * star (entry i i h)) j k = 0)
+    rw [heq, entry_apply]
+    split_ifs with heq
+    · refine ⟨sandwich_mem_Her h _, ?_⟩
+      intro hjk
+      rcases hjk with hj | hk
+      · exact (hj heq.1.symm).elim
+      · exact (hk heq.2.symm).elim
+    · exact ⟨(Her h).zero_mem, by simp⟩
+  · apply IsClosed.inter
+    · exact (isClosed_Her _).preimage (by fun_prop)
+    · by_cases hjk : j ≠ i ∨ k ≠ i
+      · change IsClosed {b : CStarMatrix (Fin n) (Fin n) A | j ≠ i ∨ k ≠ i → b j k = 0}
+        simpa only [hjk, true_implies] using
+          (isClosed_eq (show Continuous (fun a : CStarMatrix (Fin n) (Fin n) A => a j k) by fun_prop)
+          continuous_const)
+      · simp only [hjk, false_implies]
+        exact isClosed_univ
+
+def rowMatrix {n : ℕ} (i : Fin n) (r : CStarMatrix (Fin 1) (Fin n) A) :
+    CStarMatrix (Fin n) (Fin n) A :=
+  CStarMatrix.ofMatrix (fun j k => if j = i then r 0 k else 0)
+
+lemma rowMatrix_conjugate {n : ℕ} (i : Fin n)
+    (r : CStarMatrix (Fin 1) (Fin n) A) (v : A) :
+    star (rowMatrix i r) * entry i i v * rowMatrix i r =
+      r.conjTranspose * scalarCorner v * r := by
+  apply CStarMatrix.ext
+  intro j k
+  change (∑ l : Fin n, (∑ p : Fin n,
+      star (if p = i then r 0 j else 0) * (if i = p ∧ i = l then v else 0)) *
+      (if l = i then r 0 k else 0)) =
+    ∑ l : Fin 1, (∑ p : Fin 1, star (r p j) * v) * r l k
+  simp [mul_ite]
+
+lemma finiteCuntzLE_corner_approx {n : ℕ} (i : Fin n) {d : CStarMatrix (Fin n) (Fin n) A}
+    {v : A} (hdv : FiniteCuntzLE d (scalarCorner v)) {ε : ℝ} (hε : 0 < ε) :
+    ∃ s : CStarMatrix (Fin n) (Fin n) A, ‖d - star s * entry i i v * s‖ < ε := by
+  obtain ⟨r, hr⟩ := hdv.exists_approx hε
+  exact ⟨rowMatrix i r, by rwa [rowMatrix_conjugate]⟩
+
+lemma regularTransport_diagonal {n : ℕ} (i : Fin n) {d v : A} (hd : 0 ≤ d) (hv : 0 ≤ v)
+    (hdv : FiniteCuntzLE (diagonalCorner n d) (scalarCorner v)) {ε : ℝ} (hε : 0 < ε) :
+    Nonempty (RegularTransport (diagonalCorner n (cut d ε)) (entry i i v)) := by
+  obtain ⟨s, hs⟩ := finiteCuntzLE_corner_approx i hdv hε
+  have hd' : 0 ≤ diagonalCorner n d := map_nonneg (diagonalHom n) hd
+  have hv' : 0 ≤ entry i i v := map_nonneg (cornerHom i) hv
+  have ht := regularTransport_of_approx hd' hv' hε hs
+  rwa [diagonal_cut n d ε (.of_nonneg hd) hε.le] at ht
+
+lemma row_zero_of_self_star {n : ℕ} (M : CStarMatrix (Fin n) (Fin n) A) (i : Fin n)
+    (hi : (M * star M) i i = 0) (j : Fin n) : M i j = 0 := by
+  have hs : ∑ k : Fin n, M i k * star (M i k) = 0 := hi
+  have hnonneg : ∀ k ∈ (Finset.univ : Finset (Fin n)), 0 ≤ M i k * star (M i k) :=
+    fun k _ => mul_star_self_nonneg _
+  have hzero := ((Finset.sum_eq_zero_iff_of_nonneg hnonneg).mp hs) j (Finset.mem_univ j)
+  apply norm_eq_zero.mp
+  have hn : ‖M i j‖ * ‖M i j‖ = 0 := by rw [← CStarRing.norm_self_mul_star, hzero, norm_zero]
+  nlinarith [norm_nonneg (M i j)]
+
+lemma col_zero_of_star_self {n : ℕ} (M : CStarMatrix (Fin n) (Fin n) A) (i : Fin n)
+    (hi : (star M * M) i i = 0) (j : Fin n) : M j i = 0 := by
+  have h := row_zero_of_self_star (star M) i (by simpa only [star_star] using hi) j
+  change star (M j i) = 0 at h
+  exact star_eq_zero.mp h
+
+def entryHer {n : ℕ} {h : A} (i j : Fin n) (k : Her h) : Her (diagonalCorner n h) :=
+  ⟨entry i j (k : A), entry_mem_diagonalHer i j k.property⟩
+
+@[simp] lemma entryHer_val {n : ℕ} {h : A} (i j : Fin n) (k : Her h) :
+    (entryHer i j k : CStarMatrix (Fin n) (Fin n) A) = entry i j (k : A) := rfl
+
+namespace RegularTransport
+variable {n : ℕ} {h v : A} (i₀ : Fin n)
+    (T : RegularTransport (diagonalCorner n h) (entry i₀ i₀ v))
+
+lemma carrier_entryHer (i : Fin n) (k : Her h) :
+    T.carrier (entryHer i i₀ k) =
+      entry i₀ i₀ ((T.carrier (entryHer i i₀ k)) i₀ i₀) := by
+  let M := T.carrier (entryHer i i₀ k)
+  have hrow (j : Fin n) (hj : j ≠ i₀) : ∀ l, M j l = 0 := by
+    apply row_zero_of_self_star
+    have hout := T.outer (entryHer i i₀ k) (entryHer i i₀ k)
+    have hm := T.image (entryHer i i₀ k * star (entryHer i i₀ k))
+    rw [← hout] at hm
+    exact (cornerHer_entries i₀ hm j j).2 (Or.inl hj)
+  have hcol (j : Fin n) (hj : j ≠ i₀) : ∀ l, M l j = 0 := by
+    apply col_zero_of_star_self
+    have hin := T.inner (entryHer i i₀ k) (entryHer i i₀ k)
+    simp only [entryHer_val, star_entry, entry_mul] at hin
+    have he := congrArg (fun a : CStarMatrix (Fin n) (Fin n) A => a j j) hin
+    simpa only [entry_apply, ne_comm.mp hj, false_and, ite_false] using he
+  apply CStarMatrix.ext
+  intro j l
+  change M j l = (entry i₀ i₀ (M i₀ i₀)) j l
+  rw [entry_apply]
+  by_cases hj : j = i₀
+  · subst j
+    by_cases hl : l = i₀
+    · subst l; simp
+    · simp only [true_and, ne_comm.mp hl, ite_false]
+      exact hcol l hl i₀
+  · simp only [ne_comm.mp hj, false_and, ite_false]
+    exact hrow j hj l
+
+def slot (i : Fin n) (k : Her h) : A := T.carrier (entryHer i i₀ k) i₀ i₀
+
+lemma slot_inner (i j : Fin n) (k l : Her h) :
+    star (T.slot i₀ i k) * T.slot i₀ j l =
+      if i = j then star (k : A) * (l : A) else 0 := by
+  have hin := T.inner (entryHer i i₀ k) (entryHer j i₀ l)
+  rw [T.carrier_entryHer i₀ i k, T.carrier_entryHer i₀ j l] at hin
+  simp only [entryHer_val, star_entry, entry_mul] at hin
+  change entry i₀ i₀ (star (T.slot i₀ i k) * T.slot i₀ j l) = _ at hin
+  by_cases hij : i = j
+  · subst j
+    rw [entry_mul] at hin
+    have he := congrArg (fun a : CStarMatrix (Fin n) (Fin n) A => a i₀ i₀) hin
+    simpa only [entry_apply, and_self, ite_true] using he
+  · rw [entry_mul_of_ne _ _ _ _ _ _ hij] at hin
+    have he := congrArg (fun a : CStarMatrix (Fin n) (Fin n) A => a i₀ i₀) hin
+    simpa only [entry_apply, and_self, ite_true, hij, ite_false, CStarMatrix.zero_apply] using he
+
+lemma slot_outer_mem (i j : Fin n) (k l : Her h) :
+    T.slot i₀ i k * star (T.slot i₀ j l) ∈ Her v := by
+  have hout := T.outer (entryHer i i₀ k) (entryHer j i₀ l)
+  have hm := T.image (entryHer i i₀ k * star (entryHer j i₀ l))
+  rw [← hout, T.carrier_entryHer i₀ i k, T.carrier_entryHer i₀ j l,
+    star_entry, entry_mul] at hm
+  simpa only [slot, entry_apply, and_self, ite_true] using (cornerHer_entries i₀ hm i₀ i₀).1
+
+lemma slot_mul (i : Fin n) (k l : Her h) :
+    T.slot i₀ i (k*l) = T.slot i₀ i k * (l : A) := by
+  have heq : entryHer i i₀ (k*l) = entryHer i i₀ k * entryHer i₀ i₀ l := by
+    apply Subtype.ext
+    exact (entry_mul i i₀ i₀ (k : A) (l : A)).symm
+  have ht := T.mul (entryHer i i₀ k) (entryHer i₀ i₀ l)
+  rw [← heq, T.carrier_entryHer i₀ i (k*l), T.carrier_entryHer i₀ i k, entryHer_val,
+    entry_mul] at ht
+  simpa only [slot, entry_apply, and_self, ite_true] using
+    congrArg (fun a : CStarMatrix (Fin n) (Fin n) A => a i₀ i₀) ht
+
+lemma slot_add (i : Fin n) (k l : Her h) :
+    T.slot i₀ i (k+l) = T.slot i₀ i k + T.slot i₀ i l := by
+  have heq : entryHer i i₀ (k+l) = entryHer i i₀ k + entryHer i i₀ l := by
+    apply Subtype.ext
+    exact entry_add i i₀ (k : A) (l : A)
+  simp only [slot, heq, map_add, CStarMatrix.add_apply]
+
+lemma slot_smul (i : Fin n) (c : ℂ) (k : Her h) :
+    T.slot i₀ i (c • k) = c • T.slot i₀ i k := by
+  have heq : entryHer i i₀ (c • k) = c • entryHer i i₀ k := by
+    apply Subtype.ext
+    exact entry_smul i i₀ c (k : A)
+  simp only [slot, heq, map_smul, CStarMatrix.smul_apply]
+
+lemma continuous_slot (i : Fin n) : Continuous (T.slot i₀ i) := by
+  have he : Continuous (fun k : Her h => entryHer i i₀ k) := by
+    apply Continuous.subtype_mk
+    exact (continuous_entry i i₀).comp continuous_subtype_val
+  change Continuous (fun k : Her h => T.carrier (entryHer i i₀ k) i₀ i₀)
+  exact (continuous_apply i₀).comp ((continuous_apply i₀).comp (T.carrier.continuous.comp he))
+
+def slotCLM (i : Fin n) : Her h →L[ℂ] A where
+  toFun := T.slot i₀ i
+  map_add' := T.slot_add i₀ i
+  map_smul' := T.slot_smul i₀ i
+  cont := T.continuous_slot i₀ i
+
+end RegularTransport
+
+structure OrthogonalSlots (n : ℕ) (h v : A) where
+  carrier : Fin n → Her h →L[ℂ] A
+  inner : ∀ i j k l, star (carrier i k) * carrier j l =
+    if i = j then star (k : A) * (l : A) else 0
+  outer : ∀ i j k l, carrier i k * star (carrier j l) ∈ Her v
+  mul : ∀ i k l, carrier i (k*l) = carrier i k * (l : A)
+
+theorem orthogonalSlots_of_comparison {n : ℕ} {d v : A} (hd : 0 ≤ d) (hv : 0 ≤ v)
+    (hdv : FiniteCuntzLE (diagonalCorner n d) (scalarCorner v)) {ε : ℝ} (hε : 0 < ε) :
+    Nonempty (OrthogonalSlots n (cut d ε) v) := by
+  by_cases hn : n = 0
+  · subst n
+    exact ⟨{
+      carrier := fun i => Fin.elim0 i
+      inner := fun i => Fin.elim0 i
+      outer := fun i => Fin.elim0 i
+      mul := fun i => Fin.elim0 i }⟩
+  · let i₀ : Fin n := ⟨0, Nat.pos_of_ne_zero hn⟩
+    obtain ⟨T⟩ := regularTransport_diagonal i₀ hd hv hdv hε
+    exact ⟨{
+      carrier := T.slotCLM i₀
+      inner := T.slot_inner i₀
+      outer := T.slot_outer_mem i₀
+      mul := T.slot_mul i₀ }⟩
+
+theorem ProperlyInfinite.orthogonalSlots {d : A} (hd : 0 ≤ d) (hp : ProperlyInfinite d)
+    (n : ℕ) {ε : ℝ} (hε : 0 < ε) : Nonempty (OrthogonalSlots n (cut d ε) d) :=
+  orthogonalSlots_of_comparison hd hd (hp.finite_copies n) hε
+
+namespace OrthogonalSlots
+variable {n : ℕ} {h v : A} (S : OrthogonalSlots n h v)
+
+lemma represented_norm {B : Type*} [NonUnitalCStarAlgebra B]
+    (π : A →⋆ₙₐ[ℂ] B) (i : Fin n) (k : Her h) :
+    ‖π (S.carrier i k)‖ = ‖π (k : A)‖ := by
+  apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
+  simp only [pow_two, ← CStarRing.norm_star_mul_self, ← map_star, ← map_mul,
+    S.inner, ite_true]
+
+lemma norm_carrier (i : Fin n) (k : Her h) : ‖S.carrier i k‖ = ‖(k : A)‖ :=
+  S.represented_norm (NonUnitalStarAlgHom.id ℂ A) i k
+
+end OrthogonalSlots
+
+section FiniteSum
+
+lemma FiniteCuntzLE.double {d v : A}
+    (hdv : FiniteCuntzLE (scalarCorner d) (scalarCorner v)) :
+    FiniteCuntzLE (doubleCorner d) (doubleCorner v) := by
+  have hh := hdv.block hdv
+  rw [← diagonalCorner_one d, ← diagonalCorner_one v, matrixBlock_diagonal,
+    matrixBlock_diagonal] at hh
+  exact hh
+
+lemma finiteSum_cuntzLE {v : A} (hv : ProperlyInfinite v) {n : ℕ} (r : Fin n → A) :
+    FiniteCuntzLE (scalarCorner (∑ i, star (r i) * v * r i)) (scalarCorner v) := by
+  let x : CStarMatrix (Fin n) (Fin 1) A := CStarMatrix.ofMatrix (fun i _ => r i)
+  have hcomp : x.conjTranspose * diagonalCorner n v * x =
+      scalarCorner (∑ i, star (r i) * v * r i) := by
+    ext i j
+    change (∑ k : Fin n, (∑ l : Fin n, star (r l) *
+      (if l = k then v else 0)) * r k) = _
+    simp only [mul_ite, mul_zero, Finset.sum_ite_eq', Finset.mem_univ, ite_true]
+    rfl
+  rw [← hcomp]
+  exact (hv.finite_copies n).conjugate x
+
+lemma finiteSum_two_cuntzLE {v : A} (hv : ProperlyInfinite v) {n : ℕ} (r : Fin n → A) :
+    FiniteCuntzLE (diagonalCorner 2 (∑ i, star (r i) * v * r i)) (scalarCorner v) :=
+  (finiteSum_cuntzLE hv r).double.trans hv
+
+lemma finsetSum_cuntzLE {v : A} (hv : ProperlyInfinite v) {ι : Type*}
+    (E : Finset ι) (r : ι → A) :
+    FiniteCuntzLE (diagonalCorner 2 (∑ i ∈ E, star (r i) * v * r i)) (scalarCorner v) := by
+  classical
+  let e : Fin (Fintype.card E) ≃ E := (Fintype.equivFin E).symm
+  have hsum : (∑ i : Fin (Fintype.card E), star (r (e i)) * v * r (e i)) =
+      ∑ i ∈ E, star (r i) * v * r i := by
+    calc
+      _ = ∑ i : E, star (r i) * v * r i := Equiv.sum_comp e _
+      _ = _ := by simpa using (Finset.sum_attach E (fun i => star (r i) * v * r i))
+  rw [← hsum]
+  exact finiteSum_two_cuntzLE hv _
+
+end FiniteSum
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/PositiveFunctional.lean

@@ -0,0 +1,94 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+variable {A : Type*} [CStarAlgebra A]
+variable [PartialOrder A] [StarOrderedRing A]
+
+lemma norm_add_one_of_nonneg [Nontrivial A] {d : A} (hd : 0 ≤ d) :
+    ‖d + 1‖ = ‖d‖ + 1 := by
+  apply le_antisymm
+  · simpa using norm_add_le d 1
+  have hh := norm_apply_le_norm_cfc (fun t : ℝ => t + 1) d
+    (CStarAlgebra.norm_mem_spectrum_of_nonneg d hd)
+  have he : cfc (fun t : ℝ => t + 1) d = d + 1 := by
+    rw [cfc_add_const (1 : ℝ) (fun t : ℝ => t) d, cfc_id' ℝ d, map_one]
+  simpa only [he, Real.norm_eq_abs, abs_of_nonneg (by positivity : 0 ≤ ‖d‖ + 1)] using hh
+
+lemma real_norm_one_positive (F : A →L[ℝ] ℝ) (hF : ‖F‖ ≤ 1) (h1 : F 1 = 1)
+    {h : A} (hh : 0 ≤ h) : 0 ≤ F h := by
+  have hu : h ≤ algebraMap ℝ A ‖h‖ :=
+    IsSelfAdjoint.le_algebraMap_norm_self h (.of_nonneg hh)
+  have hp : 0 ≤ algebraMap ℝ A ‖h‖ - h := sub_nonneg.mpr hu
+  have hb : ‖algebraMap ℝ A ‖h‖ - h‖ ≤ ‖h‖ :=
+    (CStarAlgebra.norm_le_iff_le_algebraMap _ (norm_nonneg _) hp).2 (sub_le_self _ hh)
+  have he := F.le_opNorm (algebraMap ℝ A ‖h‖ - h)
+  have hx : F (algebraMap ℝ A ‖h‖ - h) = ‖h‖ - F h := by
+    rw [map_sub, Algebra.algebraMap_eq_smul_one, map_smul, h1, smul_eq_mul, mul_one]
+  have : F (algebraMap ℝ A ‖h‖ - h) ≤ ‖h‖ :=
+    (le_abs_self _).trans (he.trans ((mul_le_mul_of_nonneg_right hF (norm_nonneg _)).trans
+      (by simpa using hb)))
+  linarith
+
+def realPartCLM : A →L[ℝ] A :=
+  ((selfAdjoint.submodule ℝ A).subtype.comp (realPart : A →ₗ[ℝ] selfAdjoint A)).mkContinuous 1
+    (fun a => by
+      change ‖(realPart a : A)‖ ≤ 1 * ‖a‖
+      simpa using realPart.norm_le a)
+
+omit [PartialOrder A] [StarOrderedRing A] in
+@[simp] lemma realPartCLM_apply (a : A) : realPartCLM a = (realPart a : A) := rfl
+
+omit [PartialOrder A] [StarOrderedRing A] in
+lemma norm_realPartCLM : ‖(realPartCLM : A →L[ℝ] A)‖ ≤ 1 := by
+  apply ContinuousLinearMap.opNorm_le_bound _ zero_le_one
+  intro a
+  simpa using realPart.norm_le a
+
+lemma exists_norming_positive [Nontrivial A] {d : A} (hd : 0 ≤ d) :
+    ∃ f : A →ₚ[ℂ] ℂ, (∀ a, ‖f a‖ ≤ ‖a‖) ∧ f d = (‖d‖ : ℂ) := by
+  obtain ⟨F, hF, hFd⟩ := exists_dual_vector'' ℝ (d + 1)
+  have hFa (a : A) : F a ≤ ‖a‖ :=
+    (le_abs_self _).trans ((F.le_opNorm a).trans
+      (by simpa using mul_le_mul_of_nonneg_right hF (norm_nonneg a)))
+  have h1 : F 1 = 1 := by
+    rw [map_add, norm_add_one_of_nonneg hd] at hFd
+    simp only [RCLike.ofReal_real_eq_id, id_eq] at hFd
+    have h1' := hFa 1
+    have hd' := hFa d
+    simp only [norm_one] at h1'
+    linarith
+  have hFd' : F d = ‖d‖ := by
+    rw [map_add, norm_add_one_of_nonneg hd, h1] at hFd
+    simpa only [RCLike.ofReal_real_eq_id, id_eq, add_left_inj] using hFd
+  let G : A →L[ℝ] ℝ := F.comp realPartCLM
+  let H : A →L[ℂ] ℂ := StrongDual.extendRCLike G
+  have hG : ‖G‖ ≤ 1 := (ContinuousLinearMap.opNorm_comp_le _ _).trans
+    ((mul_le_mul hF norm_realPartCLM (norm_nonneg _) zero_le_one).trans (by norm_num))
+  have hH (a : A) (ha : IsSelfAdjoint a) : H a = (F a : ℂ) := by
+    simp [H, StrongDual.extendRCLike_apply, G, ha.coe_realPart, realPart_I_smul,
+      ha.imaginaryPart]
+  let f : A →ₚ[ℂ] ℂ :=
+    { H.toLinearMap with
+      monotone' := fun a b hab => by
+        have hn : 0 ≤ H (b - a) := by
+          rw [hH _ (.of_nonneg (sub_nonneg.mpr hab))]
+          exact_mod_cast real_norm_one_positive F hF h1 (sub_nonneg.mpr hab)
+        change H a ≤ H b
+        simpa only [map_sub, sub_nonneg] using hn }
+  refine ⟨f, fun a => ?_, ?_⟩
+  · change ‖H a‖ ≤ ‖a‖
+    exact (H.le_opNorm a).trans (by
+      simpa [H] using mul_le_mul_of_nonneg_right hG (norm_nonneg a))
+  · change H d = _
+    rw [hH d (.of_nonneg hd), hFd']
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Products.lean

@@ -0,0 +1,287 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Shrinking
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+local instance boundedSlotsOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance boundedSlotsStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+lemma cut_le_self {a : A} (ha : 0 ≤ a) {δ : ℝ} (hδ : 0 ≤ δ) : cut a δ ≤ a := by
+  have he : cfcₙ (fun t : ℝ => t) a = a := cfcₙ_id ℝ a ha.isSelfAdjoint
+  conv_rhs => rw [← he]
+  change cfcₙ (fun t : ℝ => max (t-δ) 0) a ≤ cfcₙ (fun t : ℝ => t) a
+  exact cfcₙ_mono (fun t ht => max_le (by linarith) (quasispectrum_nonneg_of_nonneg a ha t ht))
+    ((continuous_id.sub continuous_const).max continuous_const).continuousOn
+    continuousOn_id (by simp [max_eq_right (neg_nonpos.mpr hδ)]) rfl
+
+lemma norm_cut_le {a : A} (ha : 0 ≤ a) {δ : ℝ} (hδ : 0 ≤ δ) : ‖cut a δ‖ ≤ ‖a‖ :=
+  CStarAlgebra.norm_le_norm_of_le_of_nonneg (cut_le_self ha hδ) (cut_nonneg a δ)
+
+lemma cutInverse_nonneg {a : A} (ha : 0 ≤ a) {δ : ℝ} (hδ : 0 < δ) :
+    0 ≤ cutInverse a δ := by
+  apply cfcₙ_nonneg
+  intro t ht
+  exact (cutInverseFn_bound hδ (quasispectrum_nonneg_of_nonneg a ha t ht)).1
+
+lemma fixed_of_outer_fixed {F r : A} (h : F*(r*star r)=r*star r) : F*r=r := by
+  apply sub_eq_zero.mp
+  apply (CStarRing.mul_star_self_eq_zero_iff _).mp
+  have hs : r*star r*star F = r*star r := by
+    simpa only [star_mul, star_star, mul_assoc] using congrArg star h
+  calc
+    (F*r-r)*star (F*r-r) = F*(r*star r)*star F - F*(r*star r) - r*star r*star F+r*star r := by
+      simp only [star_sub, star_mul]
+      noncomm_ring
+    _ = 0 := by rw [h, hs]; noncomm_ring
+
+lemma cutInverse_fixed_carrier {a r : A} (ha : 0 ≤ a) {δ : ℝ} (hδ : 0 < δ)
+    (hr : r*star r ∈ Her (cut a δ)) : (cutInverse a δ*a)*r=r := by
+  have hFsa : IsSelfAdjoint (cutInverse a δ*a) := by
+    have hcomm : Commute (cutInverse a δ) a := (Commute.refl a).cfcₙ_real (cutInverseFn δ)
+    exact (IsSelfAdjoint.commute_iff (cutInverse_nonneg ha hδ).isSelfAdjoint ha.isSelfAdjoint).mp hcomm
+  have ht := Her_right_fixed_cutInverse ha hδ hr
+  have hs : (cutInverse a δ*a)*(r*star r)=r*star r := by
+    simpa only [star_mul, star_star, hFsa.star_eq] using congrArg star ht
+  exact fixed_of_outer_fixed hs
+
+theorem bounded_two_slots (hp : PropertyP A) {d : A} (hd : 0 ≤ d) {δ : ℝ} (hδ : 0 < δ) :
+    ∃ s : Fin 2 → A,
+      (∀ i j, star (s i)*d*s j = if i=j then cut d (δ+δ) else 0) ∧
+      (∀ i, ‖s i‖ ≤ Real.sqrt (1/δ) * Real.sqrt ‖d‖) := by
+  let h := cut d δ
+  let k := cut h δ
+  have hh : 0 ≤ h := cut_nonneg d δ
+  have hk : 0 ≤ k := cut_nonneg h δ
+  obtain ⟨S⟩ := (hp h hh).orthogonalSlots hh 2 hδ
+  let z : Her k := ⟨CFC.sqrt k, sqrt_mem_Her (self_mem_Her hk) hk⟩
+  let r := fun i => S.carrier i z
+  let v := CFC.sqrt (cutInverse d δ)
+  have hv : 0 ≤ cutInverse d δ := cutInverse_nonneg hd hδ
+  have hvr : ∀ i, (cutInverse d δ*d)*r i=r i := fun i =>
+    cutInverse_fixed_carrier hd hδ (S.outer i i z z)
+  have hvd : star v*d*v=cutInverse d δ*d := by
+    have hc : Commute v d := by
+      exact ((Commute.refl d).cfcₙ_real (cutInverseFn δ)).cfcₙ_nnreal NNReal.sqrt
+    rw [(CFC.sqrt_nonneg (cutInverse d δ)).isSelfAdjoint.star_eq]
+    calc
+      v*d*v = v*v*d := by rw [mul_assoc, ← hc.eq, ← mul_assoc]
+      _ = cutInverse d δ*d := by rw [show v*v=cutInverse d δ from CFC.sqrt_mul_sqrt_self _ hv]
+  refine ⟨fun i => v*r i, ?_, ?_⟩
+  · intro i j
+    calc
+      star (v*r i)*d*(v*r j) = star (r i)*(star v*d*v)*r j := by simp only [star_mul]; noncomm_ring
+      _ = star (r i)*r j := by rw [hvd, mul_assoc, hvr]
+      _ = if i=j then cut d (δ+δ) else 0 := by
+        rw [S.inner]
+        have he : k=cut d (δ+δ) := cut_cut hd hδ.le hδ.le
+        change (if i=j then star (CFC.sqrt k)*CFC.sqrt k else 0) = if i=j then cut d (δ+δ) else 0
+        rw [(CFC.sqrt_nonneg k).isSelfAdjoint.star_eq, CFC.sqrt_mul_sqrt_self _ hk, he]
+  · intro i
+    calc
+      ‖v*r i‖ ≤ ‖v‖*‖r i‖ := norm_mul_le _ _
+      _ ≤ Real.sqrt (1/δ) * Real.sqrt ‖d‖ := by
+        apply mul_le_mul
+        · rw [CFC.norm_sqrt _ hv]
+          exact Real.sqrt_le_sqrt (norm_cutInverse_le hd hδ)
+        · rw [S.norm_carrier, CFC.norm_sqrt _ hk]
+          exact Real.sqrt_le_sqrt ((norm_cut_le hh hδ.le).trans (norm_cut_le hd hδ.le))
+        · exact norm_nonneg _
+        · positivity
+end MainGap
+
+namespace MainGap
+open scoped ENNReal
+variable {I : Type*} {E : I → Type*} [∀ i, NonUnitalCStarAlgebra (E i)]
+local instance productFactorOrder (i : I) : PartialOrder (E i) := CStarAlgebra.spectralOrder _
+local instance productFactorStarOrder (i : I) : StarOrderedRing (E i) := CStarAlgebra.spectralOrderedRing _
+local instance boundedProductOrder : PartialOrder (lp E ∞) := CStarAlgebra.spectralOrder _
+local instance boundedProductStarOrder : StarOrderedRing (lp E ∞) := CStarAlgebra.spectralOrderedRing _
+
+def lpEval (i : I) : lp E ∞ →⋆ₙₐ[ℂ] E i where
+  toFun f := f i
+  map_zero' := rfl
+  map_add' _ _ := rfl
+  map_mul' _ _ := rfl
+  map_smul' _ _ := rfl
+  map_star' _ := rfl
+
+@[simp] lemma lpEval_apply (i : I) (f : lp E ∞) : lpEval i f=f i := rfl
+
+def lpBuild (f : ∀ i, E i) (M : ℝ) (h : ∀ i, ‖f i‖ ≤ M) : lp E ∞ :=
+  ⟨f, memℓp_infty ⟨M, by rintro t ⟨i,rfl⟩; exact h i⟩⟩
+
+@[simp] lemma lpBuild_apply (f : ∀ i, E i) (M : ℝ) (h : ∀ i, ‖f i‖ ≤ M) (i : I) :
+    lpBuild f M h i = f i := rfl
+
+lemma lp_nonneg_iff (d : lp E ∞) : 0 ≤ d ↔ ∀ i, 0 ≤ d i := by
+  constructor
+  · intro hd i
+    exact map_nonneg (lpEval i) hd
+  · intro hd
+    let v := lpBuild (fun i => CFC.sqrt (d i)) (Real.sqrt ‖d‖) (fun i => by
+      rw [CFC.norm_sqrt (d i) (hd i)]
+      exact Real.sqrt_le_sqrt (lp.norm_apply_le_norm ENNReal.top_ne_zero d i))
+    have he : star v*v=d := by
+      ext i
+      change star (CFC.sqrt (d i))*CFC.sqrt (d i)=d i
+      rw [(CFC.sqrt_nonneg _).isSelfAdjoint.star_eq, CFC.sqrt_mul_sqrt_self _ (hd i)]
+    rw [← he]
+    exact star_mul_self_nonneg v
+
+theorem propertyP_lp (hp : ∀ i, PropertyP (E i)) : PropertyP (lp E ∞) := by
+  intro d hd
+  apply finiteCuntzLE_of_forall_approx
+  intro ε hε
+  let δ := ε/4
+  have hδ : 0 < δ := by dsimp [δ]; positivity
+  have hd' : ∀ i, 0 ≤ d i := (lp_nonneg_iff d).mp hd
+  choose s hs hn using fun i => bounded_two_slots (hp i) (hd' i) hδ
+  have hb (i : I) (j : Fin 2) :
+      ‖s i j‖ ≤ Real.sqrt (1/δ)*Real.sqrt ‖d‖ :=
+    (hn i j).trans (mul_le_mul_of_nonneg_left
+      (Real.sqrt_le_sqrt (lp.norm_apply_le_norm ENNReal.top_ne_zero d i)) (Real.sqrt_nonneg _))
+  let S : Fin 2 → lp E ∞ := fun j => lpBuild (fun i => s i j) _ (fun i => hb i j)
+  let R : CStarMatrix (Fin 1) (Fin 2) (lp E ∞) := CStarMatrix.ofMatrix (fun _ j => S j)
+  have he : R.conjTranspose * scalarCorner d * R = doubleCorner (cut d (δ+δ)) := by
+    apply CStarMatrix.ext
+    intro j k
+    apply lp.ext
+    funext i
+    change ((∑ l : Fin 1, (∑ m : Fin 1, star (R m j)*scalarCorner d m l)*R l k) i) =
+      (Matrix.diagonal (fun _ : Fin 2 => cut d (δ+δ)) j k) i
+    simp only [Fin.sum_univ_one]
+    change star (s i j)*d i*s i k=(if j=k then cut d (δ+δ) else 0) i
+    rw [hs i j k]
+    split_ifs with hjk
+    · exact (map_cut (lpEval i) hd (show 0 ≤ δ+δ by positivity)).symm
+    · rfl
+  refine ⟨R,?_⟩
+  rw [he]
+  change ‖diagonalHom 2 d - diagonalHom 2 (cut d (δ+δ))‖ < ε
+  rw [← map_sub]
+  exact ((NonUnitalStarAlgHom.norm_apply_le (diagonalHom (A := lp E ∞) 2) _).trans
+    (norm_sub_cut_le hd (by positivity))).trans_lt (by dsimp [δ]; linarith)
+
+end MainGap
+
+namespace MainGap
+open scoped ENNReal
+variable {I : Type*} {E : I → Type*} [∀ i, NonUnitalCStarAlgebra (E i)] [DecidableEq I]
+
+lemma lp_single_mem_Her (i : I) {p : lp E ∞} {x : E i} (hx : x ∈ Her (p i)) :
+    lp.single ∞ i x ∈ Her p := by
+  have hc : IsClosed {x : E i | lp.single ∞ i x ∈ Her p} :=
+    (isClosed_Her p).preimage (lp.isometry_single i).continuous
+  apply closure_minimal (s := Set.range (fun b : E i => p i*b*star (p i))) _ hc hx
+  rintro x ⟨b,rfl⟩
+  change lp.single ∞ i (p i*b*star (p i)) ∈ Her p
+  have he : lp.single ∞ i (p i*b*star (p i)) = p*lp.single ∞ i b*star p := by
+    apply lp.ext
+    funext j
+    by_cases hj : j=i
+    · subst j
+      change lp.single ∞ i (p i*b*star (p i)) i = p i*lp.single ∞ i b i*star (p i)
+      simp only [lp.single_apply_self]
+    · change lp.single ∞ i (p i*b*star (p i)) j = p j*lp.single ∞ i b j*star (p j)
+      rw [lp.single_apply_ne _ _ _ hj, lp.single_apply_ne _ _ _ hj, mul_zero, zero_mul]
+  rw [he]
+  exact sandwich_mem_Her p _
+
+lemma HerCompression.lp_eval {p q c : lp E ∞} {κ : ℝ}
+    (h : HerCompression p q c κ) (i : I) : HerCompression (p i) (q i) (c i) κ := by
+  intro x hx k hk
+  have hi := h _ (lp_single_mem_Her i hx) _ (lp_single_mem_Her i hk)
+  have he : lp.single ∞ i x*c*lp.single ∞ i k = lp.single ∞ i (x*c i*k) := by
+    apply lp.ext
+    funext j
+    by_cases hj : j=i
+    · subst j
+      change lp.single ∞ i x i*c i*lp.single ∞ i k i=lp.single ∞ i (x*c i*k) i
+      simp only [lp.single_apply_self]
+    · change lp.single ∞ i x j*c j*lp.single ∞ i k j=lp.single ∞ i (x*c i*k) j
+      rw [lp.single_apply_ne _ _ _ hj, lp.single_apply_ne _ _ _ hj,
+        lp.single_apply_ne _ _ _ hj, zero_mul, mul_zero]
+  rw [he, lp.norm_single (by simp : (0 : ℝ≥0∞)<∞),
+    lp.norm_single (by simp : (0 : ℝ≥0∞)<∞),
+    lp.norm_single (by simp : (0 : ℝ≥0∞)<∞)] at hi
+  exact hi
+end MainGap
+
+namespace MainGap
+open scoped ENNReal
+universe u
+variable {A : Type u} [NonUnitalCStarAlgebra A]
+local instance sequenceFactorOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance sequenceFactorStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+local instance boundedSequenceOrder : PartialOrder (lp (fun _ : ℕ => A) ∞) := CStarAlgebra.spectralOrder _
+local instance boundedSequenceStarOrder : StarOrderedRing (lp (fun _ : ℕ => A) ∞) := CStarAlgebra.spectralOrderedRing _
+
+lemma NormSignal.lp_eval {a p : lp (fun _ : ℕ => A) ∞} (h : NormSignal a p) (i : ℕ) :
+    NormSignal (a i) (p i) := by
+  intro R hR
+  let S : HilbertRep.{u,u} (Unitization ℂ (lp (fun _ : ℕ => A) ∞)) :=
+    { R with hom := R.hom.comp (Unitization.starMap (lpEval i)) }
+  have he (x : lp (fun _ : ℕ => A) ∞) :
+      S.hom (x : Unitization ℂ (lp (fun _ : ℕ => A) ∞)) =
+        R.hom (x i : Unitization ℂ A) := by
+    simp [S]
+  have hr : (1/2:ℝ)<‖S.hom (a : Unitization ℂ (lp (fun _ : ℕ => A) ∞))‖ := by
+    rwa [he]
+  have ht := h S hr
+  rwa [he] at ht
+
+theorem uniform_shrinking (hp : PropertyP A) :
+    ∃ θ : ℝ, 0 < θ ∧ θ < 1 ∧
+      ∀ a y c : A, 0 ≤ a → ‖a‖ ≤ 1 → 0 ≤ y → ‖y‖ ≤ 1 → ‖c‖ ≤ 1 →
+        ∃ p q : A, 0 ≤ p ∧ ‖p‖ ≤ 1 ∧ p ∈ Her a ∧
+          0 ≤ q ∧ ‖q‖ ≤ 1 ∧ q ∈ Her y ∧
+          HerCompression p q c θ ∧ NormSignal a p ∧ NormSignal y q := by
+  classical
+  by_contra hn
+  push Not at hn
+  let θ : ℕ → ℝ := fun n => 1-1/((n:ℝ)+2)
+  have hθ0 (n : ℕ) : 0 < θ n := by
+    dsimp [θ]
+    have h : (1:ℝ)/((n:ℝ)+2)<1 := (div_lt_one (by positivity)).mpr (by linarith [Nat.cast_nonneg (α := ℝ) n])
+    linarith
+  have hθ1 (n : ℕ) : θ n < 1 := by
+    dsimp [θ]
+    have : 0 < (1:ℝ)/((n:ℝ)+2) := by positivity
+    linarith
+  choose a y c ha han hy hyn hcn hfail using fun n => hn (θ n) (hθ0 n) (hθ1 n)
+  let a' : lp (fun _ : ℕ => A) ∞ := lpBuild a 1 han
+  let y' : lp (fun _ : ℕ => A) ∞ := lpBuild y 1 hyn
+  let c' : lp (fun _ : ℕ => A) ∞ := lpBuild c 1 hcn
+  have ha' : 0 ≤ a' := (lp_nonneg_iff a').mpr ha
+  have hy' : 0 ≤ y' := (lp_nonneg_iff y').mpr hy
+  have hyn' : ‖y'‖ ≤ 1 := lp.norm_le_of_forall_le (by norm_num) hyn
+  have hcn' : ‖c'‖ ≤ 1 := lp.norm_le_of_forall_le (by norm_num) hcn
+  obtain ⟨p,q,κ,hp0,hpn,hpH,hq0,hqn,hqH,hκ0,hκ1,hcomp,hps,hqs⟩ :=
+    shrinking_nonunital (propertyP_lp (fun _ : ℕ => hp)) ha' hy' hyn' hcn'
+  obtain ⟨n,hnκ⟩ := exists_nat_gt (1/(1-κ))
+  have hκθ : κ ≤ θ n := by
+    have hn2 : 1/(1-κ) < (n:ℝ)+2 := by linarith
+    have hmul : (1:ℝ) < ((n:ℝ)+2)*(1-κ) := (div_lt_iff₀ (by linarith)).mp hn2
+    have hdiv : 1/((n:ℝ)+2) < 1-κ := (div_lt_iff₀ (by positivity)).mpr (by nlinarith)
+    dsimp [θ]; linarith
+  apply hfail n (p n) (q n)
+  · exact (lp_nonneg_iff p).mp hp0 n
+  · exact (lp.norm_apply_le_norm ENNReal.top_ne_zero p n).trans hpn
+  · exact Her_map (lpEval n) hpH
+  · exact (lp_nonneg_iff q).mp hq0 n
+  · exact (lp.norm_apply_le_norm ENNReal.top_ne_zero q n).trans hqn
+  · exact Her_map (lpEval n) hqH
+  · intro x hx k hk
+    exact ((hcomp.lp_eval n) x hx k hk).trans (by gcongr)
+  · exact hps.lp_eval n
+  · exact hqs.lp_eval n
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Representation.lean

@@ -0,0 +1,273 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+
+section Ultra
+variable {ι : Type*} (ω : Ultrafilter ι)
+
+lemma exists_complex_ultralimit (z : ι → ℂ) (R : ℝ) (hz : ∀ i, ‖z i‖ ≤ R) :
+    ∃ c : ℂ, Tendsto z (ω : Filter ι) (𝓝 c) := by
+  obtain ⟨c, _, hc⟩ := (isCompact_closedBall (0 : ℂ) R).ultrafilter_le_nhds
+    (ω.map z) (by
+      rw [Ultrafilter.coe_map, Filter.le_principal_iff]
+      change ∀ᶠ i in (ω : Filter ι), z i ∈ Metric.closedBall 0 R
+      exact Filter.Eventually.of_forall (fun i => by simpa using hz i))
+  exact ⟨c, by
+    change Filter.map z (ω : Filter ι) ≤ 𝓝 c
+    simpa only [Ultrafilter.coe_map] using hc⟩
+
+variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A]
+variable (f : ι → A →ₚ[ℂ] ℂ) (hf : ∀ i a, ‖f i a‖ ≤ ‖a‖)
+
+def ultraValue (a : A) : ℂ :=
+  (exists_complex_ultralimit ω (fun i => f i a) ‖a‖ (fun i => hf i a)).choose
+
+lemma tendsto_ultraValue (a : A) :
+    Tendsto (fun i => f i a) (ω : Filter ι) (𝓝 (ultraValue ω f hf a)) :=
+  (exists_complex_ultralimit ω (fun i => f i a) ‖a‖ (fun i => hf i a)).choose_spec
+
+def ultraPositive : A →ₚ[ℂ] ℂ where
+  toFun := ultraValue ω f hf
+  map_add' a b := by
+    apply tendsto_nhds_unique (tendsto_ultraValue ω f hf (a + b))
+    simpa only [map_add] using (tendsto_ultraValue ω f hf a).add
+      (tendsto_ultraValue ω f hf b)
+  map_smul' c a := by
+    apply tendsto_nhds_unique (tendsto_ultraValue ω f hf (c • a))
+    simpa only [map_smul, RingHom.id_apply] using (tendsto_ultraValue ω f hf a).const_smul c
+  monotone' := by
+    intro a b hab
+    exact le_of_tendsto_of_tendsto (tendsto_ultraValue ω f hf a)
+      (tendsto_ultraValue ω f hf b) (Filter.Eventually.of_forall fun i => (f i).monotone hab)
+
+lemma tendsto_ultraPositive (a : A) :
+    Tendsto (fun i => f i a) (ω : Filter ι) (𝓝 (ultraPositive ω f hf a)) :=
+  tendsto_ultraValue ω f hf a
+
+lemma ultraPositive_norm_le (a : A) : ‖ultraPositive ω f hf a‖ ≤ ‖a‖ :=
+  le_of_tendsto' (tendsto_ultraPositive ω f hf a).norm (fun i => hf i a)
+
+lemma ultraPositive_eq_zero_of_tendsto {a : A}
+    (ha : Tendsto (fun i => f i a) (ω : Filter ι) (𝓝 0)) :
+    ultraPositive ω f hf a = 0 :=
+  tendsto_nhds_unique (tendsto_ultraPositive ω f hf a) ha
+end Ultra
+
+section GNS
+variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
+variable (f : A →ₚ[ℂ] ℂ)
+
+lemma gns_zero_of_sandwich (a : A)
+    (ha : ∀ b : A, f (star (a * b) * (a * b)) = 0) :
+    f.gnsNonUnitalStarAlgHom a = 0 := by
+  ext x
+  induction x using UniformSpace.Completion.induction_on with
+  | hp => exact isClosed_eq (f.gnsNonUnitalStarAlgHom a).continuous continuous_const
+  | ih b =>
+    rw [zero_apply, ← norm_eq_zero]
+    rw [f.gnsNonUnitalStarAlgHom_apply_coe, UniformSpace.Completion.norm_coe]
+    change ‖f.toPreGNS (a * f.ofPreGNS b)‖ = 0
+    rw [f.preGNS_norm_def]
+    simp only [f.ofPreGNS_toPreGNS, ha, Complex.zero_re, Real.sqrt_zero]
+
+lemma gnsStar_nonzero_of_value {B : Type*} [CStarAlgebra B] [PartialOrder B]
+    [StarOrderedRing B] (g : B →ₚ[ℂ] ℂ) (a : B)
+    (ha : g (star a * a) ≠ 0) : g.gnsStarAlgHom a ≠ 0 := by
+  intro h
+  have hx := congrArg (fun T : g.GNS →L[ℂ] g.GNS => T
+    (↑(g.toPreGNS 1) : g.GNS)) h
+  have hn := congrArg norm hx
+  change ‖g.gnsNonUnitalStarAlgHom a (↑(g.toPreGNS 1) : g.GNS)‖ = ‖(0 : g.GNS)‖ at hn
+  rw [g.gnsNonUnitalStarAlgHom_apply_coe, UniformSpace.Completion.norm_coe] at hn
+  have hab : ‖g.toPreGNS a‖ = 0 := by
+    simp only [norm_zero] at hn
+    change ‖g.toPreGNS (a * 1)‖ = 0 at hn
+    simpa using hn
+  have hh := g.preGNS_norm_sq (g.toPreGNS a)
+  rw [hab] at hh
+  apply ha
+  simpa using hh.symm
+end GNS
+
+section Vector
+variable {A H : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
+variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+variable (π : A →⋆ₐ[ℂ] (H →L[ℂ] H)) (ξ : H)
+
+def vectorPositive : A →ₚ[ℂ] ℂ where
+  toFun a := ⟪ξ, π a ξ⟫_ℂ
+  map_add' a b := by simp
+  map_smul' c a := by simp
+  monotone' := by
+    intro a b hab
+    rw [← sub_nonneg, ← inner_sub_right, ← sub_apply, ← map_sub]
+    exact ContinuousLinearMap.nonneg_iff_isPositive.mp
+      (map_nonneg π (sub_nonneg.mpr hab)) |>.inner_nonneg_right ξ
+
+lemma vectorPositive_norm_le (hξ : ‖ξ‖ ≤ 1) (a : A) :
+    ‖vectorPositive π ξ a‖ ≤ ‖a‖ := by
+  calc
+    ‖vectorPositive π ξ a‖ ≤ ‖ξ‖ * ‖π a ξ‖ := norm_inner_le_norm ξ (π a ξ)
+    _ ≤ ‖ξ‖ * (‖a‖ * ‖ξ‖) := mul_le_mul_of_nonneg_left
+      ((π a).le_opNorm ξ |>.trans (mul_le_mul_of_nonneg_right
+        (NonUnitalStarAlgHom.norm_apply_le π a) (norm_nonneg ξ))) (norm_nonneg ξ)
+    _ ≤ 1 * (‖a‖ * 1) := mul_le_mul hξ
+      (mul_le_mul_of_nonneg_left hξ (norm_nonneg a)) (by positivity) (by positivity)
+    _ = ‖a‖ := by ring
+
+lemma vectorPositive_star_mul (a : A) :
+    vectorPositive π ξ (star a * a) = (‖π a ξ‖ ^ 2 : ℝ) := by
+  change ⟪ξ, π (star a * a) ξ⟫_ℂ = _
+  rw [map_mul, map_star, mul_apply_eq_comp, ContinuousLinearMap.star_eq_adjoint,
+    ContinuousLinearMap.adjoint_inner_right, inner_self_eq_norm_sq_to_K, Complex.ofReal_pow]
+  rfl
+end Vector
+
+section LimitRep
+variable {ι A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
+variable {H : ι → Type*} [∀ i, NormedAddCommGroup (H i)]
+  [∀ i, InnerProductSpace ℂ (H i)] [∀ i, CompleteSpace (H i)]
+variable (ω : Ultrafilter ι) (π : ∀ i, A →⋆ₐ[ℂ] (H i →L[ℂ] H i))
+  (ξ : ∀ i, H i) (hξ : ∀ i, ‖ξ i‖ ≤ 1)
+
+def limitFunctional : A →ₚ[ℂ] ℂ :=
+  ultraPositive ω (fun i => vectorPositive (π i) (ξ i))
+    (fun i => vectorPositive_norm_le (π i) (ξ i) (hξ i))
+
+abbrev LimitHilbert := (limitFunctional ω π ξ hξ).GNS
+
+def limitRep : A →⋆ₐ[ℂ] (LimitHilbert ω π ξ hξ →L[ℂ] LimitHilbert ω π ξ hξ) :=
+  (limitFunctional ω π ξ hξ).gnsStarAlgHom
+
+lemma limitFunctional_tendsto (a : A) :
+    Tendsto (fun i => vectorPositive (π i) (ξ i) a) (ω : Filter ι)
+      (𝓝 (limitFunctional ω π ξ hξ a)) := tendsto_ultraPositive _ _ _ _
+
+lemma limitRep_annihilates (a : A)
+    (ha : Tendsto (fun i => ‖π i a‖) (ω : Filter ι) (𝓝 0)) :
+    limitRep ω π ξ hξ a = 0 := by
+  change (limitFunctional ω π ξ hξ).gnsNonUnitalStarAlgHom a = 0
+  apply gns_zero_of_sandwich
+  intro b
+  apply ultraPositive_eq_zero_of_tendsto
+  have hh : Tendsto (fun i => ‖π i (a * b) (ξ i)‖) (ω : Filter ι) (𝓝 0) := by
+    apply squeeze_zero (fun i => norm_nonneg _) (fun i => ?_)
+      (show Tendsto (fun i => ‖π i a‖ * ‖b‖) (ω : Filter ι) (𝓝 0) by
+        simpa using ha.mul_const ‖b‖)
+    have hmul : ‖π i (a * b)‖ ≤ ‖π i a‖ * ‖b‖ := by
+      rw [map_mul]
+      exact (norm_mul_le _ _).trans (mul_le_mul_of_nonneg_left
+        (NonUnitalStarAlgHom.norm_apply_le (π i) b) (norm_nonneg _))
+    calc
+      ‖π i (a * b) (ξ i)‖ ≤ ‖π i (a * b)‖ * ‖ξ i‖ := (π i (a * b)).le_opNorm _
+      _ ≤ (‖π i a‖ * ‖b‖) * 1 := mul_le_mul hmul (hξ i) (norm_nonneg _) (by positivity)
+      _ = ‖π i a‖ * ‖b‖ := mul_one _
+  simpa only [vectorPositive_star_mul, zero_pow (by decide : 2 ≠ 0), Complex.ofReal_zero]
+    using (hh.pow 2).ofReal
+
+lemma limitRep_nonzero (a : A) {δ : ℝ} (hδ : 0 < δ)
+    (ha : ∀ᶠ i in (ω : Filter ι), δ ≤ ‖π i a (ξ i)‖) :
+    limitRep ω π ξ hξ a ≠ 0 := by
+  apply gnsStar_nonzero_of_value
+  have hlim := (Complex.continuous_re.tendsto _).comp
+    (limitFunctional_tendsto ω π ξ hξ (star a * a))
+  have hle : δ ^ 2 ≤ (limitFunctional ω π ξ hξ (star a * a)).re := by
+    apply ge_of_tendsto hlim
+    filter_upwards [ha] with i hi
+    simp only [Function.comp_apply, vectorPositive_star_mul, Complex.ofReal_re]
+    exact pow_le_pow_left₀ hδ.le hi 2
+  intro hf
+  rw [hf, Complex.zero_re] at hle
+  nlinarith [sq_pos_of_pos hδ]
+end LimitRep
+end MainGap
+
+noncomputable section
+open scoped Topology ComplexOrder InnerProductSpace
+namespace MainGap
+
+variable {A H : Type*} [CStarAlgebra A]
+variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+variable (π : A →⋆ₐ[ℂ] (H →L[ℂ] H)) (v : A)
+
+def generatedRange : Submodule ℂ H :=
+  (Submodule.span ℂ {x | ∃ a : A, ∃ y : H, x = π a (π v y)}).topologicalClosure
+
+instance : CompleteSpace (generatedRange π v) := by
+  unfold generatedRange
+  infer_instance
+
+lemma range_mem_generatedRange (y : H) : π v y ∈ generatedRange π v := by
+  apply Submodule.le_topologicalClosure
+  apply Submodule.subset_span
+  exact ⟨1, y, by simp⟩
+
+lemma generatedRange_invariant (a : A) :
+    ∀ x ∈ generatedRange π v, π a x ∈ generatedRange π v := by
+  change generatedRange π v ≤ (generatedRange π v).comap (π a).toLinearMap
+  apply Submodule.topologicalClosure_minimal
+  · apply Submodule.span_le.mpr
+    rintro x ⟨b, y, rfl⟩
+    apply Submodule.le_topologicalClosure
+    apply Submodule.subset_span
+    exact ⟨a * b, y, by simp⟩
+  · exact (Submodule.isClosed_topologicalClosure _).preimage (π a).continuous
+
+def rangeRestriction : A →⋆ₐ[ℂ] (generatedRange π v →L[ℂ] generatedRange π v) where
+  toFun a := (π a).restrict (generatedRange_invariant π v a)
+  map_one' := by ext x; simp [ContinuousLinearMap.restrict]
+  map_mul' a b := by ext x; simp [ContinuousLinearMap.restrict]
+  map_add' a b := by ext x; simp [ContinuousLinearMap.restrict]
+  commutes' c := by ext x; simp [ContinuousLinearMap.restrict, Algebra.algebraMap_eq_smul_one]
+  map_zero' := by ext x; simp [ContinuousLinearMap.restrict]
+  map_star' a := by
+    change (π (star a)).restrict (generatedRange_invariant π v (star a)) =
+      ContinuousLinearMap.adjoint ((π a).restrict (generatedRange_invariant π v a))
+    apply (ContinuousLinearMap.eq_adjoint_iff _ _).mpr
+    intro x y
+    change ⟪π (star a) (x : H), (y : H)⟫_ℂ = ⟪(x : H), π a (y : H)⟫_ℂ
+    rw [map_star, ContinuousLinearMap.star_eq_adjoint,
+      ContinuousLinearMap.adjoint_inner_left]
+
+@[simp]
+lemma rangeRestriction_apply (a : A) (x : generatedRange π v) :
+    ((rangeRestriction π v a x : generatedRange π v) : H) = π a (x : H) := rfl
+
+lemma rangeRestriction_kills (u : A) (hu : ∀ a : A, π u * π a * π v = 0) :
+    rangeRestriction π v u = 0 := by
+  have hle : generatedRange π v ≤ (π u).ker := by
+    apply Submodule.topologicalClosure_minimal
+    · apply Submodule.span_le.mpr
+      rintro x ⟨a, y, rfl⟩
+      change π u (π a (π v y)) = 0
+      have := congrArg (fun T : H →L[ℂ] H => T y) (hu a)
+      simpa using this
+    · exact (π u).isClosed_ker
+  ext x
+  exact hle x.property
+
+lemma rangeRestriction_nonzero (hv : IsSelfAdjoint v) (hne : π v ≠ 0) :
+    rangeRestriction π v v ≠ 0 := by
+  intro h
+  apply hne
+  apply (CStarRing.star_mul_self_eq_zero_iff (π v)).mp
+  have hv' : IsSelfAdjoint (π v) := hv.map π
+  rw [hv'.star_eq]
+  ext y
+  have hy := congrArg (fun T : generatedRange π v →L[ℂ] generatedRange π v =>
+    T ⟨π v y, range_mem_generatedRange π v y⟩) h
+  have := congrArg (fun x : generatedRange π v => (x : H)) hy
+  simpa using this
+
+end MainGap
+
+end
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Separation.lean

@@ -0,0 +1,114 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Products
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+universe u
+variable {A : Type u} [NonUnitalCStarAlgebra A]
+local instance separationPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance separationStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+lemma ramp_mem_Her {a : A} (ha : 0 ≤ a) {l u : ℝ} (hl : 0 ≤ l) :
+    ramp a l u ∈ Her a :=
+  Her_mono_of_mem (cut_mem_Her ha l) (ramp_mem_Her_cut ha hl)
+
+lemma NormSignal.cutoff_ramp {a p : A} (h : NormSignal a p) (hp : 0 ≤ p) :
+    NormSignal a (ramp p (1/2) 1) := by
+  intro R hR
+  let π := R.hom.toNonUnitalStarAlgHom.comp (Unitization.inrNonUnitalStarAlgHom ℂ A)
+  change ‖π (ramp p (1/2) 1)‖=1
+  rw [map_ramp π hp (by norm_num : (0:ℝ)≤1/2)]
+  apply norm_ramp_eq_one (map_nonneg π hp) (by norm_num) (by norm_num)
+  exact (h R hR).symm.le
+
+lemma HerCompression.mono {p q c : A} {κ τ : ℝ} (h : HerCompression p q c κ)
+    (hκτ : κ ≤ τ) : HerCompression p q c τ := by
+  intro x hx k hk
+  exact (h x hx k hk).trans (by gcongr)
+
+lemma iteration_step {p q c : A} {r θ : ℝ} (hp : 0 ≤ p) (hq : 0 ≤ q)
+    (hr : 0 < r) (_h : HerCompression p q c r)
+    {p' q' : A} (hp'H : p' ∈ Her (ramp p (1/2) 1))
+    (hq'H : q' ∈ Her (ramp q (1/2) 1))
+    (h' : HerCompression p' q'
+      (r⁻¹ • (ramp p (1/4) (1/2)*c*ramp q (1/4) (1/2))) θ) :
+    HerCompression p' q' c (r*θ) := by
+  have hpg : ramp p (1/4) (1/2)*cut p (1/2)=cut p (1/2) :=
+    ramp_mul_cut hp (by norm_num) (by norm_num) le_rfl
+  have hqg : ramp q (1/4) (1/2)*cut q (1/2)=cut q (1/2) :=
+    ramp_mul_cut hq (by norm_num) (by norm_num) le_rfl
+  have hpg' : cut p (1/2)*ramp p (1/4) (1/2)=cut p (1/2) := by
+    simpa only [star_mul, (cut_nonneg p (1/2)).isSelfAdjoint.star_eq,
+      (ramp_nonneg p (by norm_num : (1/4:ℝ)≤1/2)).isSelfAdjoint.star_eq] using congrArg star hpg
+  intro x hx k hk
+  have hxcut : x ∈ Her (cut p (1/2)) :=
+    Her_mono_of_mem (ramp_mem_Her_cut hp (by norm_num : (0:ℝ)≤1/2))
+      (Her_mono_of_mem hp'H hx)
+  have hkcut : k ∈ Her (cut q (1/2)) :=
+    Her_mono_of_mem (ramp_mem_Her_cut hq (by norm_num : (0:ℝ)≤1/2))
+      (Her_mono_of_mem hq'H hk)
+  have hxg := Her_fixed_right (cut_nonneg p (1/2)).isSelfAdjoint hpg' hxcut
+  have hgk := Her_fixed_left hqg hkcut
+  have he : x*(r⁻¹ • (ramp p (1/4) (1/2)*c*ramp q (1/4) (1/2)))*k =
+      r⁻¹ • (x*c*k) := by
+    rw [mul_smul_comm, smul_mul_assoc]
+    congr 1
+    simp only [mul_assoc, ← mul_assoc x (ramp p (1/4) (1/2)), hxg, hgk]
+  have hb := h' x hx k hk
+  rw [he, norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hr)] at hb
+  have hbr := mul_le_mul_of_nonneg_left hb hr.le
+  simpa only [← mul_assoc, mul_inv_cancel₀ hr.ne', one_mul] using hbr
+
+theorem iterated_separation (hp : PropertyP A) {a b c : A} (ha : 0 ≤ a) (han : ‖a‖ ≤ 1)
+    (hb : 0 ≤ b) (hbn : ‖b‖ ≤ 1) (hcn : ‖c‖ ≤ 1) {ζ : ℝ} (hζ : 0 < ζ) :
+    ∃ (p q : A) (κ : ℝ), 0 ≤ p ∧ ‖p‖ ≤ 1 ∧ p ∈ Her a ∧
+      0 ≤ q ∧ ‖q‖ ≤ 1 ∧ q ∈ Her b ∧ 0 ≤ κ ∧ κ < ζ ∧
+      HerCompression p q c κ ∧ NormSignal a p ∧ NormSignal b q := by
+  obtain ⟨θ,hθ0,hθ1,huniform⟩ := uniform_shrinking hp
+  have hi : ∀ n : ℕ, ∃ p q : A, 0 ≤ p ∧ ‖p‖ ≤ 1 ∧ p ∈ Her a ∧
+      0 ≤ q ∧ ‖q‖ ≤ 1 ∧ q ∈ Her b ∧
+      HerCompression p q c (θ^(n+1)) ∧ NormSignal a p ∧ NormSignal b q := by
+    intro n
+    induction n with
+    | zero => simpa only [Nat.zero_add, pow_one] using huniform a b c ha han hb hbn hcn
+    | succ n ih =>
+      obtain ⟨p,q,hp0,hpn,hpH,hq0,hqn,hqH,hcomp,hps,hqs⟩ := ih
+      let f : A → A := fun p => ramp p (1/2) 1
+      let g : A → A := fun p => ramp p (1/4) (1/2)
+      let r := θ^(n+1)
+      have hr : 0 < r := pow_pos hθ0 _
+      have hgH (p : A) (hp : 0 ≤ p) : g p ∈ Her p := ramp_mem_Her hp (by norm_num)
+      have hgn (p : A) : ‖g p‖ ≤ 1 := norm_ramp_le_one p (by norm_num)
+      have hf0 (p : A) : 0 ≤ f p := ramp_nonneg p (by norm_num)
+      have hfn (p : A) : ‖f p‖ ≤ 1 := norm_ramp_le_one p (by norm_num)
+      have hc' : ‖r⁻¹ • (g p*c*g q)‖ ≤ 1 := by
+        rw [norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hr)]
+        have hh : ‖g p*c*g q‖ ≤ r := (hcomp _ (hgH p hp0) _ (hgH q hq0)).trans (by
+          calc r*‖g p‖*‖g q‖ ≤ r*1*1 := by gcongr <;> apply hgn
+               _ = r := by ring)
+        calc r⁻¹*‖g p*c*g q‖ ≤ r⁻¹*r := mul_le_mul_of_nonneg_left hh (inv_nonneg.mpr hr.le)
+             _ = 1 := inv_mul_cancel₀ hr.ne'
+      obtain ⟨p',q',hp'0,hp'n,hp'H,hq'0,hq'n,hq'H,hcomp',hps',hqs'⟩ :=
+        huniform (f p) (f q) (r⁻¹ • (g p*c*g q)) (hf0 p) (hfn p) (hf0 q) (hfn q) hc'
+      refine ⟨p',q',hp'0,hp'n,?_,hq'0,hq'n,?_,?_,?_,?_⟩
+      · exact Her_mono_of_mem hpH (Her_mono_of_mem (ramp_mem_Her hp0 (by norm_num)) hp'H)
+      · exact Her_mono_of_mem hqH (Her_mono_of_mem (ramp_mem_Her hq0 (by norm_num)) hq'H)
+      · have hh := iteration_step hp0 hq0 hr hcomp hp'H hq'H hcomp'
+        simpa only [r, pow_succ] using hh
+      · intro R hR
+        exact hps' R (by rw [hps.cutoff_ramp hp0 R hR]; norm_num)
+      · intro R hR
+        exact hqs' R (by rw [hqs.cutoff_ramp hq0 R hR]; norm_num)
+  obtain ⟨n,hn⟩ := exists_pow_lt_of_lt_one hζ hθ1
+  obtain ⟨p,q,hp0,hpn,hpH,hq0,hqn,hqH,hcomp,hps,hqs⟩ := hi n
+  refine ⟨p,q,θ^(n+1),hp0,hpn,hpH,hq0,hqn,hqH,(pow_pos hθ0 _).le,?_,hcomp,hps,hqs⟩
+  exact (by rw [pow_succ]; nlinarith [pow_pos hθ0 n] : θ^(n+1)≤θ^n).trans_lt hn
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Shrinking.lean

@@ -0,0 +1,244 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Compression
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+universe u v
+variable {A : Type u} [CStarAlgebra A]
+local instance shrinkingPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance shrinkingStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+local instance shrinkingOperatorPartialOrder (J : Type*) [NormedAddCommGroup J]
+    [InnerProductSpace ℂ J] [CompleteSpace J] :
+    PartialOrder (J →L[ℂ] J) := CStarAlgebra.spectralOrder _
+local instance shrinkingOperatorStarOrderedRing (J : Type*) [NormedAddCommGroup J]
+    [InnerProductSpace ℂ J] [CompleteSpace J] :
+    StarOrderedRing (J →L[ℂ] J) := CStarAlgebra.spectralOrderedRing _
+
+theorem conditional_shrinking {a y c p : A} (_ha : 0 ≤ a) (hy : 0 ≤ y)
+    (hp : 0 ≤ p) (hpn : ‖p‖ ≤ 1) (hyn : ‖y‖ ≤ 1) (hcn : ‖c‖ ≤ 1)
+    (hpH : p ∈ Her a)
+    (hsignal : ∀ R : HilbertRep.{u,u} A, (1/2:ℝ)<‖R.hom a‖ → ‖R.hom p‖=1)
+    (hvan : ∀ R : HilbertRep.{u,u} A,
+      R.hom (y*(1-star c*(p*p)*c)*y)=0 → ‖R.hom y‖ ≤ (1/4:ℝ)) :
+    ∃ (p₁ q₁ : A) (κ : ℝ), 0 ≤ p₁ ∧ ‖p₁‖ ≤ 1 ∧ p₁ ∈ Her a ∧
+      0 ≤ q₁ ∧ ‖q₁‖ ≤ 1 ∧ q₁ ∈ Her y ∧ 0 ≤ κ ∧ κ < 1 ∧
+      HerCompression p₁ q₁ c κ ∧
+      (∀ R : HilbertRep.{u,u} A, (1/2:ℝ)<‖R.hom a‖ → ‖R.hom p₁‖=1) ∧
+      (∀ R : HilbertRep.{u,u} A, (1/2:ℝ)<‖R.hom y‖ → ‖R.hom q₁‖=1) := by
+  obtain ⟨δ,hδ,hδ₁,hquant⟩ := quantitative_nonvanishing hy hvan
+  let d := y*(1-star c*(p*p)*c)*y
+  have hd : 0 ≤ d := (conditional_defect_bounds hp hy hpn hyn hcn).1
+  let q := y*cut d δ*y
+  have hq : 0 ≤ q := by
+    simpa only [hy.isSelfAdjoint.star_eq] using star_left_conjugate_nonneg (cut_nonneg d δ) y
+  have hqH : q ∈ Her y := by
+    simpa only [hy.isSelfAdjoint.star_eq] using sandwich_mem_Her y (cut d δ)
+  have hqvan (R : HilbertRep.{u,u} A) (hz : R.hom q=0) : ‖R.hom y‖ ≤ (3/8:ℝ) := by
+    have hqzero : R.hom y * cut (R.hom y*(1-star (R.hom c)*(R.hom p*R.hom p)*R.hom c)*R.hom y) δ * R.hom y=0 := by
+      change R.hom (y*cut d δ*y)=0 at hz
+      rw [map_mul, map_mul, map_cut_sa R.hom hd.isSelfAdjoint hδ.le] at hz
+      simpa only [d, map_mul, map_sub, map_one, map_star] using hz
+    have hb := conditional_q_zero (map_nonneg R.hom hp) (map_nonneg R.hom hy)
+      ((NonUnitalStarAlgHom.norm_apply_le R.hom p).trans hpn)
+      ((NonUnitalStarAlgHom.norm_apply_le R.hom y).trans hyn)
+      ((NonUnitalStarAlgHom.norm_apply_le R.hom c).trans hcn) hδ hqzero
+    have hb' : ‖R.hom d‖ ≤ δ := by
+      simpa only [d, map_mul, map_sub, map_one, map_star] using hb
+    by_contra! hRy
+    exact (not_lt_of_ge hb') (hquant R hRy)
+  obtain ⟨δ',hδ',hδ'₁,hquant'⟩ := quantitative_nonvanishing_general hy
+    (by norm_num : (0:ℝ)≤3/8) (by norm_num : (3/8:ℝ)<1/2) hqvan
+  let r := Real.sqrt (1-δ)
+  have hr : 0 ≤ r := Real.sqrt_nonneg _
+  have hr₁ : r < 1 := by
+    apply (Real.sqrt_lt' (by norm_num : (0:ℝ)<1)).mpr
+    linarith
+  let τ := (r+1)/2
+  have hτ : 0 < τ := by dsimp [τ]; linarith
+  have hrτ : r < τ := by dsimp [τ]; linarith
+  have hτ₁ : τ < 1 := by dsimp [τ]; linarith
+  let p₁ := ramp p τ 1
+  let q₁ := ramp q (δ'/2) δ'
+  have hp₁ : 0 ≤ p₁ := ramp_nonneg p hτ₁.le
+  have hq₁ : 0 ≤ q₁ := ramp_nonneg q (by linarith)
+  have hq₁H : q₁ ∈ Her q :=
+    Her_mono_of_mem (cut_mem_Her hq (δ'/2)) (ramp_mem_Her_cut hq (by positivity))
+  refine ⟨p₁,q₁,r/τ,hp₁,norm_ramp_le_one p hτ₁.le,?_,hq₁,
+    norm_ramp_le_one q (by linarith),Her_mono_of_mem hqH hq₁H,
+    div_nonneg hr hτ.le,(div_lt_one hτ).mpr hrτ,?_,?_,?_⟩
+  · exact Her_mono_of_mem hpH (Her_mono_of_mem (cut_mem_Her hp τ) (ramp_mem_Her_cut hp hτ.le))
+  · have hcomp := compression_of_conditional_loss hp hτ hr (conditional_Her_loss hp hy hpn hyn hcn hδ.le hδ₁.le)
+    intro x hx k hk
+    exact hcomp x hx k (Her_mono_of_mem hq₁H hk)
+  · intro R hRa
+    change ‖R.hom (ramp p τ 1)‖=1
+    rw [map_ramp_sa R.hom hp.isSelfAdjoint hτ.le]
+    exact norm_ramp_eq_one (map_nonneg R.hom hp) hτ.le hτ₁ (by rw [hsignal R hRa])
+  · intro R hRy
+    change ‖R.hom (ramp q (δ'/2) δ')‖=1
+    rw [map_ramp_sa R.hom hq.isSelfAdjoint (by positivity)]
+    exact norm_ramp_eq_one (map_nonneg R.hom hq) (by positivity) (by linarith) (hquant' R hRy).le
+
+theorem shrinking_unital_local {a y c : A} (ha : 0 ≤ a) (hy : 0 ≤ y)
+    (hyn : ‖y‖ ≤ 1) (hcn : ‖c‖ ≤ 1)
+    (hp : ∀ z : A, 0 ≤ z → z ∈ Her a → ProperlyInfinite z) :
+    ∃ (p q : A) (κ : ℝ), 0 ≤ p ∧ ‖p‖ ≤ 1 ∧ p ∈ Her a ∧
+      0 ≤ q ∧ ‖q‖ ≤ 1 ∧ q ∈ Her y ∧ 0 ≤ κ ∧ κ < 1 ∧
+      HerCompression p q c κ ∧
+      (∀ R : HilbertRep.{u,u} A, (1/2:ℝ)<‖R.hom a‖ → ‖R.hom p‖=1) ∧
+      (∀ R : HilbertRep.{u,u} A, (1/2:ℝ)<‖R.hom y‖ → ‖R.hom q‖=1) := by
+  obtain ⟨p,hpp,hpn,hpH,hsignal,hvan⟩ := graph_nonvanishing.{u,u} ha hy hcn hp
+  exact conditional_shrinking ha hy hpp hpn hyn hcn hpH hsignal hvan
+
+end MainGap
+
+namespace MainGap
+variable {A B : Type*} [NonUnitalCStarAlgebra A] [NonUnitalCStarAlgebra B]
+
+def matrixMap (π : A →⋆ₙₐ[ℂ] B) {m n : ℕ} (x : CStarMatrix (Fin m) (Fin n) A) :
+    CStarMatrix (Fin m) (Fin n) B := CStarMatrix.ofMatrix (fun i j => π (x i j))
+
+lemma matrixMap_mul (π : A →⋆ₙₐ[ℂ] B) {l m n : ℕ}
+    (x : CStarMatrix (Fin l) (Fin m) A) (y : CStarMatrix (Fin m) (Fin n) A) :
+    matrixMap π (x*y)=matrixMap π x * matrixMap π y := by
+  ext i j
+  change π (∑ k, x i k * y k j) = ∑ k, π (x i k) * π (y k j)
+  simp only [map_sum, map_mul]
+
+lemma matrixMap_star (π : A →⋆ₙₐ[ℂ] B) {m n : ℕ}
+    (x : CStarMatrix (Fin m) (Fin n) A) :
+    matrixMap π x.conjTranspose=(matrixMap π x).conjTranspose := by
+  ext i j
+  change π (star (x j i)) = star (π (x j i))
+  exact map_star π _
+
+lemma continuous_matrixMap (π : A →⋆ₙₐ[ℂ] B) {m n : ℕ} :
+    Continuous (matrixMap π : CStarMatrix (Fin m) (Fin n) A → CStarMatrix (Fin m) (Fin n) B) := by
+  apply continuous_pi
+  intro i
+  apply continuous_pi
+  intro j
+  exact (map_continuous π).comp ((continuous_apply j).comp (continuous_apply i))
+
+lemma FiniteCuntzLE.map (π : A →⋆ₙₐ[ℂ] B) {m n : ℕ}
+    {d : CStarMatrix (Fin n) (Fin n) A} {v : CStarMatrix (Fin m) (Fin m) A}
+    (h : FiniteCuntzLE d v) : FiniteCuntzLE (matrixMap π d) (matrixMap π v) := by
+  obtain ⟨r,ht⟩ := h
+  refine ⟨fun j => matrixMap π (r j), ?_⟩
+  have he := (continuous_matrixMap π).continuousAt.tendsto.comp ht
+  change Tendsto (fun j => matrixMap π ((r j).conjTranspose * v * r j)) atTop (𝓝 (matrixMap π d)) at he
+  simpa only [matrixMap_mul, matrixMap_star] using he
+
+lemma ProperlyInfinite.map (π : A →⋆ₙₐ[ℂ] B) {h : A} (hh : ProperlyInfinite h) :
+    ProperlyInfinite (π h) := by
+  have he := FiniteCuntzLE.map π hh
+  have hdouble : matrixMap π (doubleCorner h)=doubleCorner (π h) := by
+    ext i j
+    change π (if i=j then h else 0) = if i=j then π h else 0
+    split_ifs <;> simp
+  have hsingle : matrixMap π (scalarCorner h)=scalarCorner (π h) := rfl
+  change FiniteCuntzLE _ _
+  rwa [hdouble, hsingle] at he
+
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+local instance shrinkingHerPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance shrinkingHerStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+local instance shrinkingHerUnitizationPartialOrder : PartialOrder (Unitization ℂ A) :=
+  CStarAlgebra.spectralOrder _
+local instance shrinkingHerUnitizationStarOrderedRing : StarOrderedRing (Unitization ℂ A) :=
+  CStarAlgebra.spectralOrderedRing _
+
+lemma unitization_Her {a : A} {z : Unitization ℂ A}
+    (hz : z ∈ Her (a : Unitization ℂ A)) : z.fst=0 ∧ z.snd ∈ Her a := by
+  have hc : IsClosed {z : Unitization ℂ A | z.fst=0 ∧ z.snd ∈ Her a} :=
+    (isClosed_eq Unitization.continuous_fst continuous_const).inter
+      ((isClosed_Her a).preimage Unitization.continuous_snd)
+  apply closure_minimal (s := Set.range (fun b : Unitization ℂ A =>
+    (a : Unitization ℂ A)*b*star (a : Unitization ℂ A))) _ hc hz
+  rintro z ⟨b,rfl⟩
+  constructor
+  · simp
+  · change ((a : Unitization ℂ A)*b*star (a : Unitization ℂ A)).snd ∈ Her a
+    have he : ((a : Unitization ℂ A)*b*star (a : Unitization ℂ A)).snd =
+        b.fst • (a*star a) + a*b.snd*star a := by
+      simp [Unitization.snd_mul, Unitization.fst_mul, add_mul, smul_mul_assoc]
+    rw [he]
+    exact (Her a).add_mem ((Her a).smul_mem b.fst (mul_star_mem_Her a)) (sandwich_mem_Her a b.snd)
+
+lemma unitization_inr_snd_of_Her {a : A} {z : Unitization ℂ A}
+    (hz : z ∈ Her (a : Unitization ℂ A)) : (z.snd : Unitization ℂ A)=z := by
+  have he := Unitization.inl_fst_add_inr_snd_eq z
+  simpa only [(unitization_Her hz).1, Unitization.inl_zero, zero_add] using he
+
+lemma unitization_proper_hereditary (hp : PropertyP A) {a : A}
+    {z : Unitization ℂ A} (hz : 0 ≤ z) (hzH : z ∈ Her (a : Unitization ℂ A)) :
+    ProperlyInfinite z := by
+  have he := unitization_inr_snd_of_Her hzH
+  have hz' : 0 ≤ z.snd := Unitization.inr_nonneg_iff.mp (he.symm ▸ hz)
+  have hh := (hp z.snd hz').map (Unitization.inrNonUnitalStarAlgHom ℂ A)
+  change ProperlyInfinite (z.snd : Unitization ℂ A) at hh
+  rwa [he] at hh
+
+end MainGap
+
+namespace MainGap
+universe u
+variable {A : Type u} [NonUnitalCStarAlgebra A]
+local instance shrinkingNonunitalPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance shrinkingNonunitalStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+local instance shrinkingNonunitalUnitizationPartialOrder : PartialOrder (Unitization ℂ A) :=
+  CStarAlgebra.spectralOrder _
+local instance shrinkingNonunitalUnitizationStarOrderedRing : StarOrderedRing (Unitization ℂ A) :=
+  CStarAlgebra.spectralOrderedRing _
+
+def NormSignal (a p : A) : Prop :=
+  ∀ R : HilbertRep.{u,u} (Unitization ℂ A), (1/2:ℝ)<‖R.hom (a : Unitization ℂ A)‖ →
+    ‖R.hom (p : Unitization ℂ A)‖=1
+
+theorem shrinking_nonunital (hp : PropertyP A) {a y c : A} (ha : 0 ≤ a) (hy : 0 ≤ y)
+    (hyn : ‖y‖ ≤ 1) (hcn : ‖c‖ ≤ 1) :
+    ∃ (p q : A) (κ : ℝ), 0 ≤ p ∧ ‖p‖ ≤ 1 ∧ p ∈ Her a ∧
+      0 ≤ q ∧ ‖q‖ ≤ 1 ∧ q ∈ Her y ∧ 0 ≤ κ ∧ κ < 1 ∧
+      HerCompression p q c κ ∧ NormSignal a p ∧ NormSignal y q := by
+  obtain ⟨p,q,κ,hp0,hpn,hpH,hq0,hqn,hqH,hκ0,hκ1,hcomp,hps,hqs⟩ :=
+    shrinking_unital_local (Unitization.inr_nonneg_iff.mpr ha)
+      (Unitization.inr_nonneg_iff.mpr hy)
+      (by simpa only [Unitization.norm_inr] using hyn : ‖(y : Unitization ℂ A)‖ ≤ 1)
+      (by simpa only [Unitization.norm_inr] using hcn : ‖(c : Unitization ℂ A)‖ ≤ 1)
+      (fun z hz hzH => unitization_proper_hereditary hp hz hzH)
+  have hep := unitization_inr_snd_of_Her hpH
+  have heq := unitization_inr_snd_of_Her hqH
+  refine ⟨p.snd,q.snd,κ,Unitization.inr_nonneg_iff.mp (hep.symm ▸ hp0),?_,
+    (unitization_Her hpH).2,Unitization.inr_nonneg_iff.mp (heq.symm ▸ hq0),?_,
+    (unitization_Her hqH).2,hκ0,hκ1,?_,?_,?_⟩
+  · have hn : ‖p.snd‖=‖p‖ := by simpa only [Unitization.norm_inr] using congrArg norm hep
+    rwa [hn]
+  · have hn : ‖q.snd‖=‖q‖ := by simpa only [Unitization.norm_inr] using congrArg norm heq
+    rwa [hn]
+  · intro x hx k hk
+    have hx' := Her_map (Unitization.inrNonUnitalStarAlgHom ℂ A) hx
+    have hk' := Her_map (Unitization.inrNonUnitalStarAlgHom ℂ A) hk
+    change (x : Unitization ℂ A) ∈ Her (p.snd : Unitization ℂ A) at hx'
+    change (k : Unitization ℂ A) ∈ Her (q.snd : Unitization ℂ A) at hk'
+    rw [hep] at hx'
+    rw [heq] at hk'
+    have hb := hcomp _ hx' _ hk'
+    simpa only [← Unitization.inr_mul, Unitization.norm_inr] using hb
+  · intro R hRa
+    rw [hep]
+    exact hps R hRa
+  · intro R hRy
+    rw [heq]
+    exact hqs R hRy
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Signal.lean

@@ -0,0 +1,200 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.IdealComparison
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+local instance signalCutPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance signalCutStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+lemma Her_cut_lower {a : A} (ha : 0 ≤ a) {δ : ℝ} (hδ : 0 ≤ δ)
+    {p : A} (hp : p ∈ Her (cut a δ)) :
+    δ • (star p * p) ≤ star p * a * p := by
+  have hc : IsClosed {p : A | δ • (star p * p) ≤ star p * a * p} :=
+    isClosed_le (by fun_prop) (by fun_prop)
+  apply closure_minimal (s := Set.range (fun w : A => cut a δ * w * star (cut a δ))) _ hc hp
+  rintro _ ⟨w, rfl⟩
+  change δ • (star (cut a δ * w * star (cut a δ)) *
+      (cut a δ * w * star (cut a δ))) ≤
+    star (cut a δ * w * star (cut a δ)) * a * (cut a δ * w * star (cut a δ))
+  have hh := star_left_conjugate_le_conjugate (cut_sandwich_lower ha.isSelfAdjoint hδ)
+    (w * cut a δ)
+  simpa only [star_mul, (cut_nonneg a δ).isSelfAdjoint.star_eq,
+    mul_smul_comm, smul_mul_assoc, mul_assoc] using hh
+
+lemma norm_cut_le_sub {a : A} (ha : 0 ≤ a) {M δ : ℝ} (han : ‖a‖ ≤ M)
+    (hδ : δ ≤ M) : ‖cut a δ‖ ≤ M - δ := by
+  apply norm_cfcₙ_le
+  intro t ht
+  have htM : t ≤ M := (le_abs_self t).trans
+    ((NonUnitalIsometricContinuousFunctionalCalculus.norm_quasispectrum_le a ht ha.isSelfAdjoint).trans han)
+  rw [Real.norm_eq_abs, abs_of_nonneg (le_max_right _ _)]
+  exact max_le (by linarith) (sub_nonneg.mpr hδ)
+
+lemma cut_eq_zero_of_norm_le_nonunital {a : A} (ha : 0 ≤ a) {δ : ℝ} (haδ : ‖a‖ ≤ δ) :
+    cut a δ = 0 := by
+  apply norm_eq_zero.mp
+  exact le_antisymm (by simpa using norm_cut_le_sub ha haδ le_rfl) (norm_nonneg _)
+
+end MainGap
+
+namespace MainGap
+universe u
+variable {A : Type u} [NonUnitalCStarAlgebra A]
+local instance signalComparisonPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance signalComparisonStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+local instance signalOperatorPartialOrder (H : Type*) [NormedAddCommGroup H]
+    [InnerProductSpace ℂ H] [CompleteSpace H] :
+    PartialOrder (H →L[ℂ] H) := CStarAlgebra.spectralOrder _
+local instance signalOperatorStarOrderedRing (H : Type*) [NormedAddCommGroup H]
+    [InnerProductSpace ℂ H] [CompleteSpace H] :
+    StarOrderedRing (H →L[ℂ] H) := CStarAlgebra.spectralOrderedRing _
+
+lemma signal_cut_comparison (hP : PropertyP A) {a p : A} (ha : 0 ≤ a) {δ : ℝ}
+    (hδ : 0 < δ) (hpH : p ∈ Her (ramp a δ (2*δ)))
+    (hsignal : NormSignal (ramp a δ (2*δ)) p) :
+    ScalarCuntzLE (cut a (2*δ)) (star p * a * p) := by
+  let v := star p * a * p
+  have hv : 0 ≤ v := star_left_conjugate_nonneg ha p
+  let V : Unitization ℂ A := Unitization.inr v
+  have hV : 0 ≤ V := Unitization.inr_nonneg_iff.mpr hv
+  let J := closedIdeal V hV.isSelfAdjoint
+  have hcut : (Unitization.inr (cut a (2*δ)) : Unitization ℂ A) ∈ J := by
+    by_contra hh
+    obtain ⟨R,hRJ,hRcut⟩ := exists_rep_killing_ideal J
+      (closedIdeal_closed V hV.isSelfAdjoint)
+      (fun x z hz => closedIdeal_left hV.isSelfAdjoint hz x)
+      (fun x z hz => closedIdeal_right hV.isSelfAdjoint hz x) hh
+    let π := R.hom.toNonUnitalStarAlgHom.comp (Unitization.inrNonUnitalStarAlgHom ℂ A)
+    have hvzero : π v = 0 := hRJ V (self_mem_closedIdeal V hV.isSelfAdjoint)
+    have hlower := Her_cut_lower ha hδ.le
+      (Her_mono_of_mem (ramp_mem_Her_cut ha hδ.le) hpH)
+    have hpos := map_nonneg π (sub_nonneg.mpr hlower)
+    have hsmul (r : ℝ) (z : A) : π (r • z)=r • π z :=
+      LinearMapClass.map_smul_of_tower π r z
+    change 0 ≤ π (v - δ • (star p * p)) at hpos
+    rw [map_sub, hvzero, hsmul, map_mul, map_star] at hpos
+    have hz : δ • (star (π p) * π p) = 0 :=
+      le_antisymm (by simpa only [zero_sub, neg_nonneg] using hpos)
+        (smul_nonneg hδ.le (star_mul_self_nonneg _))
+    have hpzero : π p = 0 := (CStarRing.star_mul_self_eq_zero_iff _).mp
+      ((smul_eq_zero.mp hz).resolve_left hδ.ne')
+    have hnorm : 2*δ < ‖π a‖ := by
+      by_contra! hn
+      apply hRcut
+      change π (cut a (2*δ)) = 0
+      rw [map_cut π ha (by positivity), cut_eq_zero_of_norm_le (map_nonneg π ha) hn]
+    have hramp : ‖π (ramp a δ (2*δ))‖ = 1 := by
+      rw [map_ramp π ha hδ.le]
+      exact norm_ramp_eq_one (map_nonneg π ha) hδ.le (by linarith) hnorm.le
+    have hpn := hsignal R (by change (1/2:ℝ) < ‖π (ramp a δ (2*δ))‖; rw [hramp]; norm_num)
+    change ‖π p‖ = 1 at hpn
+    rw [hpzero, norm_zero] at hpn
+    norm_num at hpn
+  apply scalarCuntzLE_of_inr hv
+  exact closedIdeal_comparison (Unitization.inr_nonneg_iff.mpr (cut_nonneg _ _)) hV
+    ((hP v hv).map (Unitization.inrNonUnitalStarAlgHom ℂ A)) hcut
+
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+local instance signalCoefficientPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance signalCoefficientStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+lemma signal_coefficient (hP : PropertyP A) {a p : A} (ha : 0 ≤ a) (han : ‖a‖ ≤ 1)
+    {δ ρ : ℝ} (hδ : 0 < δ) (hδhalf : δ < 1/2) (hρ : 0 < ρ) (hρδ : ρ ≤ 2*δ)
+    (hpH : p ∈ Her (ramp a δ (2*δ))) (hsignal : NormSignal (ramp a δ (2*δ)) p) :
+    ∃ w : A, ‖star (p*w)*a*(p*w)-a‖ < 2*δ+ρ ∧
+      ‖p*w‖ ≤ Real.sqrt δ⁻¹ := by
+  have hcomp := signal_cut_comparison hP ha hδ hpH hsignal
+  obtain ⟨w,hw⟩ := hcomp.exists_approx hρ
+  have hw' : ‖star (p*w)*a*(p*w) - cut a (2*δ)‖ < ρ := by
+    simpa only [star_mul, mul_assoc] using hw
+  refine ⟨w, ?_, ?_⟩
+  · calc
+      ‖star (p*w)*a*(p*w)-a‖ ≤
+          ‖star (p*w)*a*(p*w)-cut a (2*δ)‖ + ‖cut a (2*δ)-a‖ := by simpa only [dist_eq_norm] using dist_triangle (star (p*w)*a*(p*w)) (cut a (2*δ)) a
+      _ < ρ + 2*δ := add_lt_add_of_lt_of_le hw'
+        (by simpa only [norm_sub_rev] using norm_sub_cut_le ha (by positivity : 0 ≤ 2*δ))
+      _ = 2*δ+ρ := by ring
+  · have hlower := star_left_conjugate_le_conjugate
+      (Her_cut_lower ha hδ.le (Her_mono_of_mem (ramp_mem_Her_cut ha hδ.le) hpH)) w
+    have hlower' : δ • (star (p*w)*(p*w)) ≤ star (p*w)*a*(p*w) := by
+      simpa only [star_mul, mul_smul_comm, smul_mul_assoc, mul_assoc] using hlower
+    have hn := CStarAlgebra.norm_le_norm_of_le_of_nonneg hlower'
+      (smul_nonneg hδ.le (star_mul_self_nonneg (p*w)))
+    simp only [norm_smul, Real.norm_eq_abs, abs_of_pos hδ, CStarRing.norm_star_mul_self] at hn
+    have hupper : ‖star (p*w)*a*(p*w)‖ < 1 := by
+      calc
+        ‖star (p*w)*a*(p*w)‖ ≤
+            ‖star (p*w)*a*(p*w)-cut a (2*δ)‖ + ‖cut a (2*δ)‖ := norm_le_norm_sub_add _ _
+        _ < ρ + (1-2*δ) := add_lt_add_of_lt_of_le hw'
+          (norm_cut_le_sub ha han (by linarith))
+        _ ≤ 1 := by linarith
+    have hsq : ‖p*w‖ ^ 2 ≤ δ⁻¹ := by
+      have hh : δ * (‖p*w‖ ^ 2) ≤ 1 := by nlinarith
+      have hh' := (le_inv_mul_iff₀ hδ).mpr hh
+      simpa only [mul_one] using hh'
+    have hsqrt := Real.sq_sqrt (inv_nonneg.mpr hδ.le)
+    nlinarith [Real.sqrt_nonneg δ⁻¹, norm_nonneg (p*w)]
+
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+local instance signalProductsPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance signalProductsStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+lemma HerCompression.right_products {p q c : A} {κ : ℝ} (hκ : 0 ≤ κ)
+    (hp : 0 ≤ p) (hq : 0 ≤ q) (h : HerCompression p q c κ) (w z : A) :
+    ‖star (p*w) * c * (q*z)‖ ≤ κ * ‖p*w‖ * ‖q*z‖ := by
+  let : PartialOrder (Her p) := CStarAlgebra.spectralOrder _
+  let : StarOrderedRing (Her p) := CStarAlgebra.spectralOrderedRing _
+  let : PartialOrder (Her q) := CStarAlgebra.spectralOrder _
+  let : StarOrderedRing (Her q) := CStarAlgebra.spectralOrderedRing _
+  let ap := CStarAlgebra.increasingApproximateUnit (Her p)
+  let aq := CStarAlgebra.increasingApproximateUnit (Her q)
+  let pp : Her p := ⟨p, self_mem_Her hp⟩
+  let qq : Her q := ⟨q, self_mem_Her hq⟩
+  have htp : Tendsto (fun e : Her p => (e : A) * (p*w))
+      (CStarAlgebra.approximateUnit (Her p)) (𝓝 (p*w)) := by
+    have hh := ((continuous_subtype_val.tendsto pp).comp (ap.tendsto_mul_right pp)).mul
+      (tendsto_const_nhds (x := w))
+    change Tendsto (fun e : Her p => ((e : A) * p) * w) _ (𝓝 (p*w)) at hh
+    simpa only [mul_assoc] using hh
+  have htq : Tendsto (fun e : Her q => (e : A) * (q*z))
+      (CStarAlgebra.approximateUnit (Her q)) (𝓝 (q*z)) := by
+    have hh := ((continuous_subtype_val.tendsto qq).comp (aq.tendsto_mul_right qq)).mul
+      (tendsto_const_nhds (x := z))
+    change Tendsto (fun e : Her q => ((e : A) * q) * z) _ (𝓝 (q*z)) at hh
+    simpa only [mul_assoc] using hh
+  have ht := ((htp.comp tendsto_fst).star.mul (tendsto_const_nhds (x := c))).mul
+    (htq.comp tendsto_snd)
+  apply le_of_tendsto ht.norm
+  filter_upwards [ap.eventually_norm.prod_mk aq.eventually_norm] with ef hef
+  rcases ef with ⟨e,f⟩
+  change ‖star ((e : A)*(p*w))*c*((f : A)*(q*z))‖ ≤ _
+  have he : ‖(e : A)‖ ≤ 1 := hef.1
+  have hf : ‖(f : A)‖ ≤ 1 := hef.2
+  calc
+    ‖star ((e : A)*(p*w))*c*((f : A)*(q*z))‖ =
+        ‖star (p*w) * (star (e : A)*c*(f : A)) * (q*z)‖ := by
+      simp only [star_mul, mul_assoc]
+    _ ≤ ‖p*w‖ * ‖star (e : A)*c*(f : A)‖ * ‖q*z‖ := by
+      grw [norm_mul_le, norm_mul_le, norm_star]
+    _ ≤ ‖p*w‖ * (κ*‖(e : A)‖*‖(f : A)‖) * ‖q*z‖ := by
+      gcongr
+      simpa only [norm_star] using h (star (e : A)) (star_mem e.property) (f : A) f.property
+    _ ≤ ‖p*w‖ * (κ*1*1) * ‖q*z‖ := by gcongr
+    _ = κ * ‖p*w‖ * ‖q*z‖ := by ring
+
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Stabilization.lean

@@ -0,0 +1,275 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap.Stable
+variable {A : Type*} [NonUnitalCStarAlgebra A]
+local instance positivityOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance positivityStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+abbrev Mat (A : Type*) (n : ℕ) := CStarMatrix (Fin n) (Fin n) A
+
+def pad {n m : ℕ} (_ : n ≤ m) (x : Mat A n) : Mat A m :=
+  CStarMatrix.ofMatrix fun i j =>
+    if hi : i.val < n then if hj : j.val < n then x ⟨i,hi⟩ ⟨j,hj⟩ else 0 else 0
+
+@[simp] lemma pad_entry {n m : ℕ} (h : n ≤ m) (x : Mat A n) (i j : Fin m) :
+    pad h x i j = (if hi : i.val < n then if hj : j.val < n then x ⟨i,hi⟩ ⟨j,hj⟩ else 0 else 0) := rfl
+
+@[simp] lemma pad_apply {n m : ℕ} (h : n ≤ m) (x : Mat A n) (i j : Fin n) :
+    pad h x (Fin.castLE h i) (Fin.castLE h j) = x i j := by simp [pad_entry]
+
+lemma sum_pad {n m : ℕ} (h : n ≤ m) {B : Type*} [AddCommMonoid B] (f : Fin n → B) :
+    ∑ k : Fin m, (if hk : k.val < n then f ⟨k,hk⟩ else 0) = ∑ k : Fin n, f k := by
+  classical
+  symm
+  apply Finset.sum_bij_ne_zero (fun i _ _ => Fin.castLE h i)
+  · simp
+  · intro i _ _ j _ _ hij
+    exact Fin.ext (congrArg (fun k : Fin m => k.val) hij)
+  · intro j _ hj0
+    have hj : j.val < n := by
+      by_contra hn
+      simp [hn] at hj0
+    exact ⟨⟨j,hj⟩, Finset.mem_univ _, by simpa [hj] using hj0, rfl⟩
+  · intro i _ _
+    simp
+
+lemma pad_mul {n m : ℕ} (h : n ≤ m) (x y : Mat A n) :
+    pad h (x*y) = pad h x * pad h y := by
+  ext i j
+  by_cases hi : i.val < n <;> by_cases hj : j.val < n
+  · simp only [pad_entry, dite_eq_left hi, dite_eq_left hj,
+      CStarMatrix.mul_apply]
+    rw [← sum_pad h (fun k => x ⟨i,hi⟩ k * y k ⟨j,hj⟩)]
+    apply Finset.sum_congr rfl
+    intro k _
+    by_cases hk : k.val < n <;> simp [hk]
+  · simp [pad_entry, hi, hj, CStarMatrix.mul_apply]
+  · simp [pad_entry, hi, CStarMatrix.mul_apply]
+  · simp [pad_entry, hi, CStarMatrix.mul_apply]
+
+def padHom {n m : ℕ} (h : n ≤ m) : Mat A n →⋆ₙₐ[ℂ] Mat A m where
+  toFun := pad h
+  map_zero' := by ext i j; simp [pad_entry]
+  map_add' x y := by ext i j; by_cases hi : i.val < n <;> by_cases hj : j.val < n <;> simp [pad_entry, hi, hj]
+  map_mul' := pad_mul h
+  map_smul' c x := by ext i j; by_cases hi : i.val < n <;> by_cases hj : j.val < n <;> simp [pad_entry, hi, hj]
+  map_star' x := by ext i j; by_cases hi : i.val < n <;> by_cases hj : j.val < n <;> simp [pad_entry, hi, hj, CStarMatrix.star_apply]
+
+lemma pad_injective {n m : ℕ} (h : n ≤ m) : Function.Injective (pad (A := A) h) := by
+  intro x y hxy
+  ext i j
+  have hh := congrArg (fun z : Mat A m => z (Fin.castLE h i) (Fin.castLE h j)) hxy
+  simpa using hh
+
+lemma norm_pad {n m : ℕ} (h : n ≤ m) (x : Mat A n) : ‖pad h x‖ = ‖x‖ :=
+  NonUnitalStarAlgHom.norm_map (padHom h) (pad_injective h) x
+
+lemma pad_self (n : ℕ) (x : Mat A n) : pad le_rfl x = x := by
+  ext i j
+  simp [pad_entry]
+
+lemma pad_pad {n m k : ℕ} (h : n ≤ m) (h' : m ≤ k) (x : Mat A n) :
+    pad h' (pad h x) = pad (h.trans h') x := by
+  ext i j
+  by_cases hi : i.val < n <;> by_cases hj : j.val < n
+  · have hi' : i.val < m := lt_of_lt_of_le hi h
+    have hj' : j.val < m := lt_of_lt_of_le hj h
+    simp [pad_entry, hi, hj, hi', hj']
+  · by_cases hi' : i.val < m <;> by_cases hj' : j.val < m <;> simp [pad_entry, hi, hj, hi', hj']
+  · by_cases hi' : i.val < m <;> by_cases hj' : j.val < m <;> simp [pad_entry, hi, hi', hj']
+  · by_cases hi' : i.val < m <;> by_cases hj' : j.val < m <;> simp [pad_entry, hi, hi', hj']
+
+instance pad_directedSystem : DirectedSystem (Mat A) (fun _ _ h => padHom h) where
+  map_self := fun {_} x => pad_self _ x
+  map_map := fun {_ _ _} h h' x => pad_pad h h' x
+
+abbrev Algebraic (A : Type*) [NonUnitalCStarAlgebra A] :=
+  DirectLimit (Mat A) (fun _ _ h => padHom h)
+
+local instance matLinear (n m : ℕ) :
+    LinearMapClass (Mat A n →⋆ₙₐ[ℂ] Mat A m) ℂ (Mat A n) (Mat A m) where
+  map_add f x y := f.map_add x y
+  map_smulₛₗ f c x := f.map_smul c x
+
+instance : Module ℂ (Algebraic A) := DirectLimit.instModule
+
+instance : Norm (Algebraic A) where
+  norm := DirectLimit.lift _ (fun _ x => ‖x‖) (fun _ _ h x => (norm_pad h x).symm)
+
+@[simp] lemma norm_mk (n : ℕ) (x : Mat A n) :
+    ‖(⟦⟨n,x⟩⟧ : Algebraic A)‖ = ‖x‖ := rfl
+
+lemma normedCore : NormedSpace.Core ℂ (Algebraic A) where
+  norm_nonneg := DirectLimit.induction _ fun n x => norm_nonneg x
+  norm_smul c := DirectLimit.induction _ fun n x => by
+    rw [DirectLimit.smul_def, norm_mk, norm_mk, norm_smul]
+  norm_triangle := DirectLimit.induction₂ _ fun n x y => by
+    rw [DirectLimit.add_def, norm_mk, norm_mk, norm_mk]
+    exact norm_add_le x y
+  norm_eq_zero_iff := DirectLimit.induction _ fun n x => by
+    rw [norm_mk, norm_eq_zero]
+    constructor
+    · rintro rfl
+      exact (DirectLimit.zero_def (f := fun _ _ h => padHom (A := A) h) n).symm
+    · intro h
+      apply pad_injective (le_rfl : n ≤ n)
+      have hi := DirectLimit.mk_injective (fun _ _ h => padHom (A := A) h) (fun _ _ h => pad_injective h) n
+      exact congrArg (pad le_rfl) (hi (h.trans (DirectLimit.zero_def (f := fun _ _ h => padHom (A := A) h) n)))
+
+instance : NormedAddCommGroup (Algebraic A) := .ofCore (𝕜 := ℂ) (normedCore (A := A))
+instance : NormedSpace ℂ (Algebraic A) := .ofCore (normedCore (A := A))
+instance : NonUnitalNormedRing (Algebraic A) where
+  dist_eq _ _ := rfl
+  norm_mul_le := DirectLimit.induction₂ _ fun n x y => by
+    rw [DirectLimit.mul_def, norm_mk, norm_mk, norm_mk]
+    exact norm_mul_le x y
+instance : CStarRing (Algebraic A) where
+  norm_mul_self_le := DirectLimit.induction _ fun n x => by
+    rw [DirectLimit.star_def, DirectLimit.mul_def, norm_mk, norm_mk]
+    exact CStarRing.norm_mul_self_le x
+
+def cornerAlg (n : ℕ) : Mat A n →⋆ₙₐ[ℂ] Algebraic A where
+  __ := DirectLimit.NonUnitalAlgebra.of (Mat A) (fun _ _ h => padHom h) n
+  map_star' _ := rfl
+
+@[simp] lemma cornerAlg_apply (n : ℕ) (x : Mat A n) :
+    cornerAlg n x = (⟦⟨n,x⟩⟧ : Algebraic A) := rfl
+
+lemma cornerAlg_isometry (n : ℕ) : Isometry (cornerAlg (A := A) n) :=
+  AddMonoidHomClass.isometry_of_norm (cornerAlg n) (fun _ => rfl)
+
+abbrev Stabilization (A : Type*) [NonUnitalCStarAlgebra A] := UniformSpace.Completion (Algebraic A)
+
+local instance algebraicTopology : TopologicalSpace (Algebraic A) :=
+  (inferInstance : PseudoMetricSpace (Algebraic A)).toUniformSpace.toTopologicalSpace
+
+open UniformSpace
+open UniformSpace.Completion
+
+instance : Mul (Stabilization A) :=
+  ⟨Function.curry <| (isDenseInducing_coe.prodMap isDenseInducing_coe).extend
+    ((↑) ∘ Function.uncurry (· * · : Algebraic A → Algebraic A → Algebraic A))⟩
+
+@[simp, norm_cast] lemma coe_mul_stable (x y : Algebraic A) :
+    ((x*y : Algebraic A) : Stabilization A) = (x : Stabilization A) * (y : Stabilization A) :=
+  ((isDenseInducing_coe.prodMap isDenseInducing_coe).extend_eq
+    ((continuous_coe _).comp continuous_mul) (x,y)).symm
+
+instance : ContinuousMul (Stabilization A) where
+  continuous_mul := by
+    let m := (AddMonoidHom.mul : Algebraic A →+ Algebraic A →+ Algebraic A).compr₂ toCompl
+    have hh : Continuous fun p : Algebraic A × Algebraic A => m p.1 p.2 :=
+      (continuous_coe _).comp continuous_mul
+    have di : IsDenseInducing (toCompl : Algebraic A → Stabilization A) := isDenseInducing_coe
+    exact di.extend_Z_bilin di hh
+
+instance : NonUnitalRing (Stabilization A) where
+  __ : AddCommGroup (Stabilization A) := inferInstance
+  zero_mul x := Completion.induction_on x (isClosed_eq (by fun_prop) continuous_const)
+    fun x => by rw [← coe_zero, ← coe_mul_stable, zero_mul]
+  mul_zero x := Completion.induction_on x (isClosed_eq (by fun_prop) continuous_const)
+    fun x => by rw [← coe_zero, ← coe_mul_stable, mul_zero]
+  mul_assoc x y z := Completion.induction_on₃ x y z
+    (isClosed_eq (by fun_prop) (by fun_prop)) fun x y z => by
+      rw [← coe_mul_stable, ← coe_mul_stable, ← coe_mul_stable, ← coe_mul_stable, mul_assoc]
+  left_distrib x y z := Completion.induction_on₃ x y z
+    (isClosed_eq (by fun_prop) (by fun_prop)) fun x y z => by
+      rw [← coe_add, ← coe_mul_stable, ← coe_mul_stable, ← coe_mul_stable, ← coe_add, mul_add]
+  right_distrib x y z := Completion.induction_on₃ x y z
+    (isClosed_eq (by fun_prop) (by fun_prop)) fun x y z => by
+      rw [← coe_add, ← coe_mul_stable, ← coe_mul_stable, ← coe_mul_stable, ← coe_add, add_mul]
+
+instance : NonUnitalNormedRing (Stabilization A) where
+  dist_eq := dist_eq_norm_neg_add
+  norm_mul_le x y := Completion.induction_on₂ x y
+    (isClosed_le (by fun_prop) (by fun_prop)) fun x y => by
+      simpa only [← coe_mul_stable, norm_coe] using norm_mul_le x y
+
+instance : Star (Stabilization A) := ⟨Completion.map (star : Algebraic A → Algebraic A)⟩
+
+@[simp, norm_cast] lemma coe_star_stable (x : Algebraic A) :
+    ((star x : Algebraic A) : Stabilization A) = star (x : Stabilization A) :=
+  (Completion.map_coe star_isometry.uniformContinuous x).symm
+
+instance : ContinuousStar (Stabilization A) where
+  continuous_star := Completion.continuous_map
+
+instance : StarRing (Stabilization A) where
+  star_involutive x := Completion.induction_on x
+    (isClosed_eq (by fun_prop) continuous_id) fun x => by
+      rw [← coe_star_stable, ← coe_star_stable, star_star]
+  star_add x y := Completion.induction_on₂ x y
+    (isClosed_eq (by fun_prop) (by fun_prop)) fun x y => by
+      rw [← coe_add, ← coe_star_stable, ← coe_star_stable, ← coe_star_stable, ← coe_add, star_add]
+  star_mul x y := Completion.induction_on₂ x y
+    (isClosed_eq (by fun_prop) (by fun_prop)) fun x y => by
+      rw [← coe_mul_stable, ← coe_star_stable, ← coe_star_stable, ← coe_star_stable,
+        ← coe_mul_stable, star_mul]
+
+instance : CStarRing (Stabilization A) where
+  norm_mul_self_le x := Completion.induction_on x
+    (isClosed_le (by fun_prop) (by fun_prop)) fun x => by
+      simpa only [← coe_star_stable, ← coe_mul_stable, norm_coe] using CStarRing.norm_mul_self_le x
+
+instance : IsScalarTower ℂ (Stabilization A) (Stabilization A) where
+  smul_assoc c x y := by
+    change (c • x) * y = c • (x*y)
+    refine Completion.induction_on₂ x y ?_ ?_
+    · exact isClosed_eq ((continuous_fst.const_smul c).mul continuous_snd)
+        ((continuous_fst.mul continuous_snd).const_smul c)
+    · intro x y
+      rw [← coe_smul, ← coe_mul_stable, ← coe_mul_stable, ← coe_smul, smul_mul_assoc]
+
+instance : SMulCommClass ℂ (Stabilization A) (Stabilization A) where
+  smul_comm c x y := by
+    change c • (x*y) = x * (c • y)
+    refine Completion.induction_on₂ x y ?_ ?_
+    · exact isClosed_eq ((continuous_fst.mul continuous_snd).const_smul c)
+        (continuous_fst.mul (continuous_snd.const_smul c))
+    · intro x y
+      rw [← coe_mul_stable, ← coe_smul, ← coe_smul, ← coe_mul_stable, mul_smul_comm]
+
+instance : StarModule ℂ (Stabilization A) where
+  star_smul c x := by
+    refine Completion.induction_on x ?_ ?_
+    · exact isClosed_eq (continuous_star.comp (continuous_const_smul c))
+        (continuous_star.const_smul (star c))
+    · intro x
+      rw [← coe_smul, ← coe_star_stable, ← coe_star_stable, ← coe_smul, star_smul]
+
+@[instance_reducible] def stabilizationCStarAlgebra : NonUnitalCStarAlgebra (Stabilization A) where
+
+def corner (n : ℕ) : Mat A n →⋆ₙₐ[ℂ] Stabilization A where
+  toFun x := (cornerAlg n x : Stabilization A)
+  map_zero' := by rw [map_zero, coe_zero]
+  map_add' x y := by simp [map_add, coe_add]
+  map_mul' x y := by simp [map_mul]
+  map_smul' c x := by simp [map_smul, coe_smul]
+  map_star' x := by simp [map_star]
+
+@[simp] lemma corner_apply (n : ℕ) (x : Mat A n) :
+    corner n x = (cornerAlg n x : Stabilization A) := rfl
+
+lemma norm_corner (n : ℕ) (x : Mat A n) : ‖corner n x‖ = ‖x‖ := by
+  rw [corner_apply, norm_coe, cornerAlg_apply, norm_mk]
+
+lemma corner_isometry (n : ℕ) : Isometry (corner (A := A) n) :=
+  AddMonoidHomClass.isometry_of_norm (corner n) (norm_corner n)
+
+lemma corner_pad {n m : ℕ} (h : n ≤ m) (x : Mat A n) :
+    corner m (pad h x) = corner n x := by
+  change ((⟦⟨m,padHom h x⟩⟧ : Algebraic A) : Stabilization A) =
+    ((⟦⟨n,x⟩⟧ : Algebraic A) : Stabilization A)
+  rw [DirectLimit.mk_apply]
+
+end MainGap.Stable
+
+end
+
+end OAI

lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Ultrafilter.lean

@@ -0,0 +1,75 @@
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Representation
+import OAI.Analysis.CStarAlgebra.PureInfiniteness.Defect
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace MainGap
+variable (A : Type*)
+abbrev FourIndex := ℕ × Finset A
+
+def fourEta (i : FourIndex A) : ℝ := 1 / ((i.1 : ℝ)+1)
+
+lemma fourEta_pos (i : FourIndex A) : 0 < fourEta A i := by
+  unfold fourEta
+  positivity
+
+lemma fourEta_tendsto : Tendsto (fourEta A) atTop (𝓝 0) := by
+  have h : Tendsto (fun n : ℕ => 1 / ((n:ℝ)+1)) atTop (𝓝 0) := by
+    simpa using (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ))
+  have hf : Tendsto (fun i : FourIndex A => i.1) atTop atTop := by
+    apply tendsto_atTop.mpr
+    intro n
+    filter_upwards [eventually_ge_atTop (n, (∅ : Finset A))] with i hi
+    exact hi.1
+  exact h.comp hf
+
+lemma fourIndex_eventually_mem (w : A) : ∀ᶠ i : FourIndex A in atTop, w ∈ i.2 := by
+  classical
+  filter_upwards [eventually_ge_atTop ((0:ℕ), ({w} : Finset A))] with i hi
+  exact hi.2 (Finset.mem_singleton_self w)
+
+noncomputable def fourUltra : Ultrafilter (FourIndex A) := by
+  classical
+  exact Ultrafilter.of atTop
+
+lemma fourUltra_le : (fourUltra A : Filter (FourIndex A)) ≤ atTop := by
+  classical
+  exact Ultrafilter.of_le atTop
+
+lemma fourEta_ultra : Tendsto (fourEta A) (fourUltra A : Filter (FourIndex A)) (𝓝 0) :=
+  (fourEta_tendsto A).mono_left (fourUltra_le A)
+end MainGap
+
+namespace MainGap
+variable {A : Type*} [CStarAlgebra A]
+local instance ultrafilterPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
+local instance ultrafilterStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
+
+lemma cut_zero_of_le {d : A} (hd : 0 ≤ d) {h : ℝ} (hh : 0 ≤ h)
+    (hle : d ≤ h • (1:A)) : cut d h = 0 := by
+  have hdsa : IsSelfAdjoint d := .of_nonneg hd
+  have hle' : cfc (fun t : ℝ => t) d ≤ cfc (fun _ : ℝ => h) d := by
+    rw [cfc_id' ℝ d hdsa, cfc_const h d hdsa, Algebra.algebraMap_eq_smul_one]
+    exact hle
+  have hs := (cfc_le_iff _ _ d continuousOn_id continuousOn_const hdsa).mp hle'
+  rw [cut_eq_cfc d hh, ← cfc_zero d (R := ℝ)]
+  apply cfc_congr
+  intro t ht
+  exact max_eq_right (sub_nonpos.mpr (hs t ht))
+
+lemma le_of_cut_zero {d : A} (hd : 0 ≤ d) {h : ℝ} (hh : 0 ≤ h)
+    (hz : cut d h = 0) : d ≤ h • (1:A) := by
+  have hn := norm_sub_cut_le hd hh
+  rw [hz, sub_zero] at hn
+  simpa only [Algebra.algebraMap_eq_smul_one] using
+    (CStarAlgebra.norm_le_iff_le_algebraMap d hh hd).mp hn
+
+end MainGap
+
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/HighProjection.lean

@@ -0,0 +1,174 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.ThomasFermi.FirstFiber
+
+namespace OAI
+
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+namespace Coulomb
+
+section
+variable {A B ι : Type*} [MeasurableSpace A] [MeasurableSpace B]
+    {μ : Measure A} {ν : Measure B} [SigmaFinite μ] [SigmaFinite ν]
+    (v : ι → A → ℂ) (hv : ∀ i, MemLp (v i) 2 μ)
+    (ho : ∀ i j, (∫ a, star (v i a) * v j a ∂μ) = if i = j then (1 : ℂ) else 0)
+
+omit [MeasurableSpace B] [SigmaFinite μ] in
+include hv ho in
+lemma fiberContract_lowProjection (s : Finset ι) (f : B × A → ℂ) (a : ι) (y : B) :
+    fiberContract (μ := μ) (v a) (lowProjection (μ := μ) v s f) y =
+      if a ∈ s then fiberContract (μ := μ) (v a) f y else 0 := by
+  classical
+  dsimp only [lowProjection, fiberContract]
+  rw [show (fun x => star (v a x) * ∑ i ∈ s,
+        (∫ z, star (v i z) * f (y,z) ∂μ) * v i x) =
+      (fun x => ∑ i ∈ s, (∫ z, star (v i z) * f (y,z) ∂μ) * (star (v a x) * v i x)) from by
+    funext x
+    rw [Finset.mul_sum]
+    apply Finset.sum_congr rfl
+    intro i _
+    ring]
+  rw [integral_finsetSum s (fun i _ => (integrable_star_mul (hv a) (hv i)).const_mul _)]
+  simp only [integral_const_mul, ho, mul_ite, mul_one, mul_zero]
+  rw [Finset.sum_ite_eq]
+
+noncomputable def highProjection (s : Finset ι) (f : B × A → ℂ) : B × A → ℂ :=
+  f - lowProjection (μ := μ) v s f
+
+include hv in
+lemma highProjection_memLp (s : Finset ι) {f : B × A → ℂ}
+    (hf : MemLp f 2 (ν.prod μ)) :
+    MemLp (highProjection (μ := μ) v s f) 2 (ν.prod μ) := by
+  have hp : MemLp (lowProjection (μ := μ) v s f) 2 (ν.prod μ) :=
+    lowProjection_memLp v hv s hf
+  change MemLp (f - lowProjection (μ := μ) v s f) 2 (ν.prod μ)
+  exact hf.sub hp
+
+include hv ho in
+lemma fiberContract_highProjection (s : Finset ι) {f : B × A → ℂ}
+    (hf : MemLp f 2 (ν.prod μ)) (a : ι) :
+    fiberContract (μ := μ) (v a) (highProjection (μ := μ) v s f) =ᵐ[ν]
+      fun y => if a ∈ s then 0 else fiberContract (μ := μ) (v a) f y := by
+  classical
+  filter_upwards [memLp_fiber_ae hf] with y hy
+  have hp : MemLp (fun x => lowProjection (μ := μ) v s f (y,x)) 2 μ :=
+    orbital_sum_memLp v hv s (fun i => fiberContract (μ := μ) (v i) f y)
+  change (∫ x, star (v a x) * (f (y,x) - lowProjection (μ := μ) v s f (y,x)) ∂μ) = _
+  simp only [mul_sub]
+  rw [integral_sub (integrable_star_mul (hv a) hy) (integrable_star_mul (hv a) hp)]
+  change fiberContract (μ := μ) (v a) f y -
+    fiberContract (μ := μ) (v a) (lowProjection (μ := μ) v s f) y = _
+  rw [fiberContract_lowProjection v hv ho]
+  split_ifs <;> simp only [sub_self, sub_zero]
+
+include hv ho in
+lemma fiberContract_finite_bessel (s : Finset ι) {f : B × A → ℂ}
+    (hf : MemLp f 2 (ν.prod μ)) :
+    ∑ i ∈ s, (∫ y, ‖fiberContract (μ := μ) (v i) f y‖^2 ∂ν) ≤
+      ∫ z, ‖f z‖^2 ∂(ν.prod μ) := by
+  rw [← integral_finsetSum s (fun i _ => (fiberContract_memLp (hv i) hf).norm.integrable_sq)]
+  rw [integral_prod _ hf.norm.integrable_sq]
+  apply integral_mono_ae
+    (integrable_finsetSum s (fun i _ => (fiberContract_memLp (hv i) hf).norm.integrable_sq))
+    hf.norm.integrable_sq.integral_prod_left
+  filter_upwards [memLp_fiber_ae hf] with y hy
+  have H := (orbital_orthonormal v hv ho).sum_inner_products_le (s := s) (hy.toLp _)
+  simpa only [inner_toLp_complex, norm_toLp_sq_complex, fiberContract] using H
+
+include hv ho in
+lemma fiberContract_norm_summable {f : B × A → ℂ} (hf : MemLp f 2 (ν.prod μ)) :
+    Summable (fun i => ∫ y, ‖fiberContract (μ := μ) (v i) f y‖^2 ∂ν) :=
+  summable_of_sum_le (fun _ => integral_nonneg fun _ => sq_nonneg _)
+    (fun s => fiberContract_finite_bessel v hv ho s hf)
+
+end
+
+noncomputable def firstUnfiber {A : Type*} {n : ℕ} (f : (Fin n → A) × A → ℂ)
+    (x : Fin (n+1) → A) : ℂ := f (Fin.tail x, x 0)
+
+lemma firstFiber_firstUnfiber {A : Type*} {n : ℕ} (f : (Fin n → A) × A → ℂ) :
+    firstFiber (firstUnfiber f) = f := by
+  funext z
+  simp only [firstFiber, firstUnfiber, Fin.tail_cons, Fin.cons_zero]
+
+lemma firstUnfiber_memLp {A : Type*} [MeasurableSpace A] {μ : Measure A} [SigmaFinite μ]
+    {n : ℕ} {f : (Fin n → A) × A → ℂ}
+    (hf : MemLp f 2 ((Measure.pi fun _ : Fin n => μ).prod μ)) :
+    MemLp (firstUnfiber f) 2 (Measure.pi fun _ => μ) := by
+  let e := (MeasurableEquiv.piFinSuccAbove (fun _ : Fin (n+1) => A) 0).trans
+    (MeasurableEquiv.prodComm : A × (Fin n → A) ≃ᵐ (Fin n → A) × A)
+  have he : MeasurePreserving e (Measure.pi fun _ => μ)
+      ((Measure.pi fun _ : Fin n => μ).prod μ) :=
+    (measurePreserving_piFinSuccAbove (fun _ => μ) 0).trans Measure.measurePreserving_swap
+  have heq : ∀ x : Fin (n+1) → A, e x = (Fin.tail x, x 0) := by
+    intro x
+    rfl
+  change MemLp (fun x : Fin (n+1) → A => f (Fin.tail x, x 0)) 2 (Measure.pi fun _ => μ)
+  simpa only [Function.comp_def, heq] using hf.comp_measurePreserving he
+
+lemma firstUnfiber_norm_sq {A : Type*} [MeasurableSpace A] {μ : Measure A} [SigmaFinite μ]
+    {n : ℕ} (f : (Fin n → A) × A → ℂ) :
+    (∫ x, ‖firstUnfiber f x‖^2 ∂(Measure.pi fun _ => μ)) =
+      ∫ z, ‖f z‖^2 ∂((Measure.pi fun _ : Fin n => μ).prod μ) := by
+  let e := (MeasurableEquiv.piFinSuccAbove (fun _ : Fin (n+1) => A) 0).trans
+    (MeasurableEquiv.prodComm : A × (Fin n → A) ≃ᵐ (Fin n → A) × A)
+  have he : MeasurePreserving e (Measure.pi fun _ => μ)
+      ((Measure.pi fun _ : Fin n => μ).prod μ) :=
+    (measurePreserving_piFinSuccAbove (fun _ => μ) 0).trans Measure.measurePreserving_swap
+  exact he.integral_comp' (fun z => ‖f z‖^2)
+
+lemma scalarCoefficient_congr {A ι : Type*} [MeasurableSpace A] {μ : Measure A}
+    {n : ℕ} {f g : (Fin n → A) → ℂ} (he : f =ᵐ[Measure.pi fun _ => μ] g)
+    (v : ι → A → ℂ) (b : Fin n → ι) :
+    scalarCoefficient (μ := μ) f v b = scalarCoefficient (μ := μ) g v b := by
+  apply integral_congr_ae
+  filter_upwards [he] with x hx
+  rw [hx]
+
+variable {A ι : Type*} [MeasurableSpace A] {μ : Measure A} [SigmaFinite μ]
+    (v : ι → A → ℂ) (hv : ∀ i, MemLp (v i) 2 μ)
+    (ho : ∀ i j, (∫ a, star (v i a) * v j a ∂μ) = if i = j then (1 : ℂ) else 0)
+
+include hv ho in
+lemma scalarCoefficient_highFirst {n : ℕ} {f : (Fin (n+1) → A) → ℂ}
+    (hf : MemLp f 2 (Measure.pi fun _ => μ)) (s : Finset ι) (b : Fin (n+1) → ι) :
+    scalarCoefficient (μ := μ) (firstUnfiber (highProjection (μ := μ) v s (firstFiber f))) v b =
+      if b 0 ∈ s then 0 else scalarCoefficient (μ := μ) f v b := by
+  classical
+  have hff := firstFiber_memLp hf
+  have hh := highProjection_memLp v hv s hff
+  have hu := firstUnfiber_memLp hh
+  have hb : Fin.cons (b 0) (Fin.tail b) = b := by
+    ext i
+    exact Fin.cases rfl (fun j => rfl) i
+  rw [← hb, scalarCoefficient_contract _ hu v hv, scalarCoefficient_contract f hf v hv]
+  change scalarCoefficient (μ := μ)
+    (fiberContract (μ := μ) (v (b 0)) (firstFiber (firstUnfiber
+      (highProjection (μ := μ) v s (firstFiber f))))) v (Fin.tail b) = _
+  rw [firstFiber_firstUnfiber]
+  rw [scalarCoefficient_congr (fiberContract_highProjection v hv ho s hff (b 0))]
+  by_cases hs : b 0 ∈ s
+  · simp only [Fin.cons_zero, hs, ite_true, scalarCoefficient, mul_zero, integral_zero]
+  · simp only [Fin.cons_zero, hs, ite_false]
+    rfl
+
+include hv ho in
+lemma highProjection_norm_spectrum [Countable ι] (hc : CompleteOrbitals μ v)
+    {n : ℕ} {f : (Fin (n+1) → A) → ℂ}
+    (hf : MemLp f 2 (Measure.pi fun _ => μ)) (s : Finset ι) :
+    (∫ z, ‖highProjection (μ := μ) v s (firstFiber f) z‖^2
+      ∂((Measure.pi fun _ : Fin n => μ).prod μ)) =
+      ∑' b, if b 0 ∈ s then 0 else ‖scalarCoefficient (μ := μ) f v b‖^2 := by
+  rw [← firstUnfiber_norm_sq]
+  have hh := highProjection_memLp v hv s (firstFiber_memLp hf)
+  rw [← scalarCoefficient_parseval _ (firstUnfiber_memLp hh) v hv ho hc]
+  apply tsum_congr
+  intro b
+  rw [scalarCoefficient_highFirst v hv ho hf s b]
+  split_ifs <;> norm_num
+
+end Coulomb
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/IntegrableIntegralAeTendsto.lean

@@ -0,0 +1,199 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.FormDomain.Translate
+
+namespace OAI
+
+section
+section
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+namespace Coulomb
+
+lemma integrable_and_integral_le_of_ae_tendsto {A : Type*} [MeasurableSpace A]
+    {μ : Measure A} {F : ℕ → A → ℝ} {f : A → ℝ} {u : ℕ → ℝ} {C : ℝ}
+    (hF : ∀ n, Integrable (F n) μ) (hFn : ∀ n x, 0 ≤ F n x)
+    (hfn : ∀ x, 0 ≤ f x)
+    (ht : ∀ᵐ x ∂μ, Tendsto (fun n => F n x) atTop (𝓝 (f x)))
+    (hb : ∀ n, (∫ x, F n x ∂μ) ≤ u n) (hu : Tendsto u atTop (𝓝 C)) :
+    Integrable f μ ∧ (∫ x, f x ∂μ) ≤ C := by
+  have hmeas : AEStronglyMeasurable f μ :=
+    aestronglyMeasurable_of_tendsto_ae _ (fun n => (hF n).1) ht
+  have hfat : (∫⁻ x, ENNReal.ofReal (f x) ∂μ) ≤ ENNReal.ofReal C := by
+    calc
+      _ = ∫⁻ x, liminf (fun n => ENNReal.ofReal (F n x)) atTop ∂μ := by
+        apply lintegral_congr_ae
+        filter_upwards [ht] with x hx
+        exact ((ENNReal.continuous_ofReal.tendsto _).comp hx).liminf_eq.symm
+      _ ≤ liminf (fun n => ∫⁻ x, ENNReal.ofReal (F n x) ∂μ) atTop :=
+        lintegral_liminf_le' (fun n => (hF n).aemeasurable.ennreal_ofReal)
+      _ ≤ liminf (fun n => ENNReal.ofReal (u n)) atTop := by
+        apply liminf_le_liminf (hv := isBoundedUnder_of ⟨0, fun _ => bot_le⟩)
+          (hu := (isBoundedUnder_of ⟨⊤, fun _ => le_top⟩).isCoboundedUnder_ge)
+        exact Eventually.of_forall fun n => by
+          rw [← ofReal_integral_eq_lintegral_ofReal (hF n) (Eventually.of_forall (hFn n))]
+          exact ENNReal.ofReal_le_ofReal (hb n)
+      _ = ENNReal.ofReal C := ((ENNReal.continuous_ofReal.tendsto _).comp hu).liminf_eq
+  have hf : Integrable f μ := by
+    refine ⟨hmeas, ?_⟩
+    rw [hasFiniteIntegral_iff_norm]
+    simp_rw [Real.norm_eq_abs, abs_of_nonneg (hfn _)]
+    exact hfat.trans_lt ENNReal.ofReal_lt_top
+  refine ⟨hf, ?_⟩
+  have hC : 0 ≤ C := ge_of_tendsto' hu fun n => (integral_nonneg (hFn n)).trans (hb n)
+  apply (ENNReal.ofReal_le_ofReal_iff hC).mp
+  rwa [ofReal_integral_eq_lintegral_ofReal hf (Eventually.of_forall hfn)]
+
+lemma pi_exhaustion {A : Type*} {s : ℕ → Set A} (hs : Monotone s)
+    (hU : (⋃ k, s k) = univ) (n : ℕ) :
+    (⋃ k, (univ.pi fun _ : Fin n => s k)) = univ := by
+  ext z
+  simp only [mem_iUnion, mem_univ_pi, mem_univ, iff_true]
+  have hx (i : Fin n) : ∃ k, z i ∈ s k := by
+    have hi : z i ∈ ⋃ k, s k := by rw [hU]; trivial
+    simpa only [mem_iUnion] using hi
+  choose k hk using hx
+  refine ⟨Finset.univ.sup k, fun i => hs (Finset.le_sup (f := k) (Finset.mem_univ i)) (hk i)⟩
+
+lemma density_power_exhaustion {A : Type*} [MeasurableSpace A] {μ : Measure A}
+    [SigmaFinite μ] {n : ℕ} {f : (Fin (n+1) → A) → ℂ}
+    (hf : MemLp f 2 (Measure.pi fun _ => μ)) {s : ℕ → Set A}
+    (hs : ∀ k, MeasurableSet (s k)) (hmono : Monotone s) (hU : (⋃ k, s k) = univ)
+    {p : ℝ} (hp : 0 < p) {u : ℕ → ℝ} {C : ℝ}
+    (hi : ∀ k, Integrable (fun x => (firstParticleDensity (μ := μ.restrict (s k)) f x)^p)
+      (μ.restrict (s k)))
+    (hb : ∀ k, (∫ x, (firstParticleDensity (μ := μ.restrict (s k)) f x)^p ∂(μ.restrict (s k))) ≤ u k)
+    (hu : Tendsto u atTop (𝓝 C)) :
+    Integrable (fun x => (firstParticleDensity (μ := μ) f x)^p) μ ∧
+    (∫ x, (firstParticleDensity (μ := μ) f x)^p ∂μ) ≤ C := by
+  let F (k : ℕ) : A → ℝ := (s k).indicator
+    (fun x => (firstParticleDensity (μ := μ.restrict (s k)) f x)^p)
+  have hdn {ν : Measure A} (x : A) : 0 ≤ firstParticleDensity (μ := ν) f x :=
+    mul_nonneg (by positivity) (integral_nonneg (fun _ => sq_nonneg _))
+  have hn (k) (x) : 0 ≤ F k x :=
+    indicator_nonneg (fun _ _ => Real.rpow_nonneg (hdn _) p) x
+  apply integrable_and_integral_le_of_ae_tendsto
+    (F := F) (u := u) (fun k => (integrable_indicator_iff (hs k)).mpr (hi k)) hn
+    (fun x => Real.rpow_nonneg (hdn x) p)
+    ?_ (fun k => by simpa only [F, integral_indicator (hs k)] using hb k) hu
+  have hslice := (firstFiber_memLp hf).norm.integrable_sq.prod_left_ae
+  filter_upwards [hslice] with x hx
+  have hset : (⋃ k, (univ.pi fun _ : Fin n => s k)) = univ := pi_exhaustion hmono hU n
+  have hlim := tendsto_setIntegral_of_monotone
+    (fun k => MeasurableSet.univ_pi (fun _ : Fin n => hs k))
+    (fun k l hkl z hz i _ => hmono hkl (hz i (mem_univ i)))
+    (f := fun y => ‖firstFiber f (y,x)‖^2) (μ := Measure.pi fun _ : Fin n => μ)
+    (by simpa only [hset, integrableOn_univ] using hx)
+  simp only [hset, Measure.restrict_univ, Measure.restrict_pi_pi] at hlim
+  have hd : Tendsto (fun k => firstParticleDensity (μ := μ.restrict (s k)) f x) atTop
+      (𝓝 (firstParticleDensity (μ := μ) f x)) := hlim.const_mul _
+  have hpw := hd.rpow_const (Or.inr hp.le)
+  have hex : ∃ k, x ∈ s k := by
+    have hi : x ∈ ⋃ k, s k := by rw [hU]; trivial
+    simpa only [mem_iUnion] using hi
+  obtain ⟨k,hk⟩ := hex
+  apply hpw.congr'
+  filter_upwards [eventually_ge_atTop k] with l hl
+  simp only [F, indicator_of_mem (hmono hl hk)]
+
+end Coulomb
+
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+namespace Coulomb
+
+lemma spinCubeEquiv_full_measurePreserving (n : ℕ) :
+    MeasurePreserving (spinCubeEquiv n) (Measure.pi fun _ : Fin n => spinSpaceMeasure)
+      (Measure.count.prod volume) := by
+  have h1 := measurePreserving_arrowProdEquivProdArrow (Fin 2) (Fin 3 → ℝ) (Fin n)
+    (fun _ => Measure.count) (fun _ => volume)
+  rw [measure_pi_count] at h1
+  have h2 := (MeasurePreserving.id (Measure.count : Measure (Spins n))).prod
+    (measurePreserving_const_uncurry (I := Fin n) (J := Fin 3) (volume : Measure ℝ))
+  exact h2.comp h1
+
+lemma H1Vector.spinSpace_memLp {n : ℕ} (ψ : H1Vector n) :
+    MemLp (fun sx : Spins n × ((Fin n × Fin 3) → ℝ) =>
+      ψ.value sx.1 (WithLp.toLp 2 sx.2)) 2 (Measure.count.prod volume) := by
+  have hi (s : Spins n) : MemLp (fun t : Spins n => if t = s then (1:ℂ) else 0) 2 Measure.count := by
+    apply MemLp.of_bound (by fun_prop) 1
+    exact ae_of_all _ (fun t => by split_ifs <;> norm_num)
+  have H := memLp_finsetSum Finset.univ (fun (s : Spins n) _ => tensorPair_memLp (hi s)
+    ((ψ.value_L2 s).comp_measurePreserving (PiLp.volume_preserving_toLp _)))
+  convert H using 1
+  funext sx
+  simp only [ite_mul, one_mul, zero_mul]
+  simp
+
+lemma H1Vector.cubeState_full_memLp {n : ℕ} (ψ : H1Vector n) :
+    MemLp (cubeState ψ) 2 (Measure.pi fun _ : Fin n => spinSpaceMeasure) :=
+  ψ.spinSpace_memLp.comp_measurePreserving (spinCubeEquiv_full_measurePreserving n)
+
+lemma cubeState_full_mass {n : ℕ} (ψ : H1Vector n) :
+    (∫ z, ‖cubeState ψ z‖^2 ∂(Measure.pi fun _ : Fin n => spinSpaceMeasure)) = mass ψ := by
+  change (∫ z, ‖ψ.value ((spinCubeEquiv n) z).1 (WithLp.toLp 2 ((spinCubeEquiv n) z).2)‖^2
+    ∂(Measure.pi fun _ : Fin n => spinSpaceMeasure)) = mass ψ
+  rw [(spinCubeEquiv_full_measurePreserving n).integral_comp'
+    (fun sx => ‖ψ.value sx.1 (WithLp.toLp 2 sx.2)‖^2)]
+  rw [integral_prod _ ψ.spinSpace_memLp.norm.integrable_sq, integral_count]
+  unfold mass
+  apply Finset.sum_congr rfl
+  intro s _
+  exact (show MeasurePreserving (MeasurableEquiv.toLp 2 ((Fin n × Fin 3) → ℝ)) volume volume from
+    PiLp.volume_preserving_toLp _).integral_comp' (fun x => ‖ψ.value s x‖^2)
+
+lemma centeredSpinCube_monotone : Monotone centeredSpinCube := by
+  intro R S hRS x hx
+  simp only [centeredSpinCube, mem_prod, mem_univ, true_and, mem_univ_pi, mem_Ioc] at *
+  intro i
+  obtain ⟨h1,h2⟩ := hx i
+  constructor <;> linarith
+
+lemma centeredSpinCube_exhaustion : (⋃ k : ℕ, centeredSpinCube (k+1)) = univ := by
+  ext x
+  simp only [mem_iUnion, mem_univ, iff_true]
+  obtain ⟨k,hk⟩ := exists_nat_gt (‖x.2‖ : ℝ)
+  refine ⟨k, ?_⟩
+  simp only [centeredSpinCube, mem_prod, mem_univ, true_and, mem_univ_pi, mem_Ioc]
+  intro i
+  have hi : |x.2 i| ≤ ‖x.2‖ := by simpa only [Real.norm_eq_abs] using norm_le_pi_norm x.2 i
+  have h := abs_le.mp hi
+  constructor <;> linarith
+
+theorem global_spin_density_power_bound {n : ℕ} (ψ : H1Vector (n+1))
+    (hψ : Antisymmetric ψ) (hm : mass ψ ≤ 1) :
+    Integrable (fun x => (firstParticleDensity (μ := spinSpaceMeasure) (cubeState ψ) x)^(5/3:ℝ))
+      spinSpaceMeasure ∧
+    (∫ x, (firstParticleDensity (μ := spinSpaceMeasure) (cubeState ψ) x)^(5/3:ℝ)
+      ∂spinSpaceMeasure) ≤ (8192/(3*Real.pi^2))*kinetic ψ := by
+  apply density_power_exhaustion ψ.cubeState_full_memLp
+    (s := fun k : ℕ => centeredSpinCube (k+1)) (fun k => centeredSpinCube_measurable _)
+    (fun k l h => centeredSpinCube_monotone (by exact_mod_cast Nat.add_le_add_right h 1))
+    centeredSpinCube_exhaustion (by norm_num : (0:ℝ) < 5/3)
+    (u := fun k : ℕ => (64/(k+1:ℝ)^2)*((n+1:ℕ):ℝ)+(8192/(3*Real.pi^2))*kinetic ψ)
+    (fun k => (centered_density_power_bound ψ hψ hm (by positivity : (0:ℝ)<k+1)).1)
+    (fun k => (centered_density_power_bound ψ hψ hm (by positivity : (0:ℝ)<k+1)).2)
+  have ht : Tendsto (fun k : ℕ => (k:ℝ)+1) atTop atTop :=
+    Filter.tendsto_atTop_add_const_right atTop 1 tendsto_natCast_atTop_atTop
+  have hi := ((tendsto_inv_atTop_zero (𝕜 := ℝ)).comp ((tendsto_pow_atTop (α := ℝ) (by norm_num : (2 : ℕ) ≠ 0)).comp ht)).const_mul 64
+  convert (hi.mul_const ((n+1:ℕ):ℝ)).add_const ((8192/(3*Real.pi^2))*kinetic ψ) using 1 <;>
+    simp [Function.comp_apply, div_eq_mul_inv]
+
+end Coulomb
+
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+
+end
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/IntegrableTsumSummableNormIntegral.lean

@@ -0,0 +1,124 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.FormDomain.L2MeasureInclusion
+
+namespace OAI
+
+noncomputable section
+
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set
+open scoped BigOperators ENNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open scoped Classical
+open scoped BigOperators ComplexConjugate
+open scoped Classical
+open scoped Classical
+open MeasureTheory Set Filter
+open scoped Classical ENNReal NNReal ComplexConjugate
+open MeasureTheory Set Filter Module Module.End TopologicalSpace Function
+open scoped Classical ComplexConjugate
+open MeasureTheory Set Filter Module Module.End TopologicalSpace Function
+open scoped Classical ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+namespace Coulomb
+variable {Y ι : Type*} [MeasurableSpace Y] [Countable ι]
+
+lemma integrable_tsum_of_summable_norm_integral {ν : Measure Y} {F : ι → Y → ℝ}
+    (hF : ∀ i, Integrable (F i) ν) (hs : Summable (fun i => ∫ y, ‖F i y‖ ∂ν)) :
+    Integrable (fun y => ∑' i, F i y) ν ∧ ∀ᵐ y ∂ν, Summable (fun i => F i y) := by
+  let f : ι → Lp ℝ 1 ν := fun i => (hF i).toL1 (F i)
+  have hn (i : ι) : ‖f i‖ = ∫ y, ‖F i y‖ ∂ν := by
+    rw [Integrable.norm_toL1_eq_lintegral_norm]
+    exact (integral_eq_lintegral_of_nonneg_ae (Filter.Eventually.of_forall (fun _ => norm_nonneg _))
+      (hF i).norm.aestronglyMeasurable).symm
+  have he : ∑' i, ‖f i‖ₑ ≠ ⊤ := by
+    apply tsum_enorm_ne_top_iff_summable_norm.mpr
+    simpa only [hn] using hs
+  have ha : ∀ᵐ y ∂ν, ∀ i, f i y = F i y := ae_all_iff.mpr (fun i => (hF i).coeFn_toL1)
+  have hb := Lp.hasSum_coeFn_tsum he
+  have hc : (fun y => ∑' i, F i y) =ᵐ[ν] (∑' i, f i : Lp ℝ 1 ν) := by
+    filter_upwards [ha, hb] with y hy hz
+    simpa only [hy] using hz.tsum_eq
+  refine ⟨(L1.integrable_coeFn (∑' i, f i)).congr hc.symm, ?_⟩
+  filter_upwards [ha, hb] with y hy hz
+  simpa only [hy] using hz.summable
+
+lemma l2_weighted_density_integrable {ν : Measure Y} (u : ι → Lp ℂ 2 ν) (w : ι → ℝ)
+    (hw : ∀ i, 0 ≤ w i) (hs : Summable (fun i => w i * ‖u i‖^2)) :
+    Integrable (fun y => ∑' i, w i * ‖u i y‖^2) ν ∧
+      ∀ᵐ y ∂ν, Summable (fun i => w i * ‖u i y‖^2) := by
+  apply integrable_tsum_of_summable_norm_integral
+  · intro i
+    exact ((Lp.memLp (u i)).integrable_norm_pow (by norm_num : (2:ℕ) ≠ 0)).const_mul _
+  · simpa only [Real.norm_eq_abs, abs_of_nonneg (mul_nonneg (hw _) (sq_nonneg _)),
+      integral_const_mul, ← l2_norm_sq] using hs
+
+lemma l2_weighted_density_hasSum {ν : Measure Y} (u : ι → Lp ℂ 2 ν) (w : ι → ℝ)
+    (hw : ∀ i, 0 ≤ w i) {s : ℝ} (hs : HasSum (fun i => w i * ‖u i‖^2) s) :
+    (∫ y, ∑' i, w i * ‖u i y‖^2 ∂ν) = s := by
+  have hi (i : ι) : Integrable (fun y => w i * ‖u i y‖^2) ν :=
+    ((Lp.memLp (u i)).integrable_norm_pow (by norm_num : (2:ℕ) ≠ 0)).const_mul (w i)
+  have hn : Summable (fun i => ∫ y, ‖w i * ‖u i y‖^2‖ ∂ν) := by
+    simpa only [Real.norm_eq_abs, abs_of_nonneg (mul_nonneg (hw _) (sq_nonneg _)),
+      integral_const_mul, ← l2_norm_sq] using hs.summable
+  have h := hasSum_integral_of_summable_integral_norm hi hn
+  simp only [integral_const_mul, ← l2_norm_sq] at h
+  exact h.unique hs
+end Coulomb
+
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/JoinSpins.lean

@@ -0,0 +1,227 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.FieldAnalysis.BlockIndex
+
+namespace OAI
+
+noncomputable section
+
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set
+open scoped BigOperators ENNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+namespace Coulomb
+def joinSpins (m k : ℕ) : Spins m × Spins k ≃ Spins (m+k) where
+  toFun := fun s => Fin.addCases s.1 s.2
+  invFun := fun s => (s ∘ Fin.castAdd k, s ∘ Fin.natAdd m)
+  left_inv := by
+    intro s
+    ext i <;> simp
+  right_inv := by
+    intro s
+    funext i
+    refine Fin.addCases ?_ ?_ i <;> intro j <;> simp [Function.comp_def]
+
+lemma joinSpins_left (m k : ℕ) (s : Spins m) (t : Spins k) :
+    (joinSpins m k (s,t)) ∘ Fin.castAdd k = s := by
+  funext i
+  simp [joinSpins, Function.comp_def]
+lemma joinSpins_right (m k : ℕ) (s : Spins m) (t : Spins k) :
+    (joinSpins m k (s,t)) ∘ Fin.natAdd m = t := by
+  funext i
+  simp [joinSpins, Function.comp_def]
+
+lemma sum_joinSpins {m k : ℕ} (F : Spins (m+k) → ℝ) :
+    (∑ s, F s) = ∑ s : Spins m, ∑ t : Spins k, F (joinSpins m k (s,t)) := by
+  rw [← Equiv.sum_comp (joinSpins m k), Fintype.sum_prod_type]
+
+lemma sum_configurationBlocks {m k : ℕ} (F : Fin (m+k) × Fin 3 → ℝ) :
+    (∑ a, F a) = (∑ a : Fin m × Fin 3, F (Fin.castAdd k a.1,a.2)) +
+      (∑ a : Fin k × Fin 3, F (Fin.natAdd m a.1,a.2)) := by
+  simp only [Fintype.sum_prod_type]
+  exact Fin.sum_univ_add _
+
+lemma tensorValue_square_integral {m k : ℕ} (u : H1Vector m) (v : H1Vector k)
+    (s : Spins (m+k)) :
+    (∫ x, ‖tensorValue u v s x‖^2) =
+      (∫ x, ‖u.value (s ∘ Fin.castAdd k) x‖^2)*
+        (∫ y, ‖v.value (s ∘ Fin.natAdd m) y‖^2) := by
+  rw [← (joinConfiguration_measurePreserving m k).integral_comp'
+    (fun x => ‖tensorValue u v s x‖^2)]
+  change (∫ z : Configuration m × Configuration k,
+    ‖tensorValue u v s (joinConfiguration m k z)‖^2 ∂(volume.prod volume)) = _
+  simp_rw [tensorValue_join, norm_mul, mul_pow]
+  exact integral_prod_mul (μ := volume) (ν := volume)
+    (fun x : Configuration m => ‖u.value (s ∘ Fin.castAdd k) x‖^2)
+    (fun y : Configuration k => ‖v.value (s ∘ Fin.natAdd m) y‖^2)
+
+lemma tensorGradient_square_integral_left {m k : ℕ} (u : H1Vector m) (v : H1Vector k)
+    (s : Spins (m+k)) (a : Fin m × Fin 3) :
+    (∫ x, ‖tensorGradient u v s (Fin.castAdd k a.1,a.2) x‖^2) =
+      (∫ x, ‖u.gradient (s ∘ Fin.castAdd k) a x‖^2)*
+        (∫ y, ‖v.value (s ∘ Fin.natAdd m) y‖^2) := by
+  rw [← (joinConfiguration_measurePreserving m k).integral_comp'
+    (fun x => ‖tensorGradient u v s (Fin.castAdd k a.1,a.2) x‖^2)]
+  change (∫ z : Configuration m × Configuration k,
+    ‖tensorGradient u v s (Fin.castAdd k a.1,a.2) (joinConfiguration m k z)‖^2
+      ∂(volume.prod volume)) = _
+  simp_rw [tensorGradient_join_left, norm_mul, mul_pow]
+  exact integral_prod_mul (μ := volume) (ν := volume)
+    (fun x : Configuration m => ‖u.gradient (s ∘ Fin.castAdd k) a x‖^2)
+    (fun y : Configuration k => ‖v.value (s ∘ Fin.natAdd m) y‖^2)
+
+lemma tensorGradient_square_integral_right {m k : ℕ} (u : H1Vector m) (v : H1Vector k)
+    (s : Spins (m+k)) (a : Fin k × Fin 3) :
+    (∫ x, ‖tensorGradient u v s (Fin.natAdd m a.1,a.2) x‖^2) =
+      (∫ x, ‖u.value (s ∘ Fin.castAdd k) x‖^2)*
+        (∫ y, ‖v.gradient (s ∘ Fin.natAdd m) a y‖^2) := by
+  rw [← (joinConfiguration_measurePreserving m k).integral_comp'
+    (fun x => ‖tensorGradient u v s (Fin.natAdd m a.1,a.2) x‖^2)]
+  change (∫ z : Configuration m × Configuration k,
+    ‖tensorGradient u v s (Fin.natAdd m a.1,a.2) (joinConfiguration m k z)‖^2
+      ∂(volume.prod volume)) = _
+  simp_rw [tensorGradient_join_right, norm_mul, mul_pow]
+  exact integral_prod_mul (μ := volume) (ν := volume)
+    (fun x : Configuration m => ‖u.value (s ∘ Fin.castAdd k) x‖^2)
+    (fun y : Configuration k => ‖v.gradient (s ∘ Fin.natAdd m) a y‖^2)
+
+lemma mass_tensor {m k : ℕ} (u : H1Vector m) (v : H1Vector k) :
+    mass (u.tensor v) = mass u*mass v := by
+  change (∑ s, ∫ x, ‖tensorValue u v s x‖^2) = _
+  simp_rw [tensorValue_square_integral]
+  rw [sum_joinSpins]
+  simp only [joinSpins_left, joinSpins_right, mass, Finset.sum_mul, Finset.mul_sum]
+  exact Finset.sum_comm
+
+lemma kinetic_tensor {m k : ℕ} (u : H1Vector m) (v : H1Vector k) :
+    kinetic (u.tensor v) = kinetic u*mass v+mass u*kinetic v := by
+  change (1/2:ℝ)*(∑ s, ∑ a, ∫ x, ‖tensorGradient u v s a x‖^2) = _
+  simp_rw [sum_configurationBlocks, tensorGradient_square_integral_left,
+    tensorGradient_square_integral_right]
+  rw [sum_joinSpins]
+  simp only [joinSpins_left, joinSpins_right]
+  simp only [mass, kinetic, Finset.sum_add_distrib]
+  simp_rw [← Finset.mul_sum, ← Finset.sum_mul]
+  rw [← Finset.sum_mul_sum]
+  ring
+end Coulomb
+
+open scoped Classical
+namespace Coulomb
+def blockHom (m k : ℕ) :
+    (Equiv.Perm (Fin m) × Equiv.Perm (Fin k)) →* Equiv.Perm (Fin (m+k)) :=
+  ((finSumFinEquiv : Fin m ⊕ Fin k ≃ Fin (m+k)).permCongrHom).toMonoidHom.comp
+    (Equiv.Perm.sumCongrHom (Fin m) (Fin k))
+
+def blockGroup (m k : ℕ) : Subgroup (Equiv.Perm (Fin (m+k))) := (blockHom m k).range
+
+lemma blockHom_left {m k : ℕ} (p : Equiv.Perm (Fin m)) (q : Equiv.Perm (Fin k)) (i : Fin m) :
+    blockHom m k (p,q) (Fin.castAdd k i) = Fin.castAdd k (p i) := by
+  change finSumFinEquiv ((Equiv.sumCongr p q) (finSumFinEquiv.symm (Fin.castAdd k i))) = _
+  simp [← finSumFinEquiv_apply_left]
+
+lemma blockHom_right {m k : ℕ} (p : Equiv.Perm (Fin m)) (q : Equiv.Perm (Fin k)) (i : Fin k) :
+    blockHom m k (p,q) (Fin.natAdd m i) = Fin.natAdd m (q i) := by
+  change finSumFinEquiv ((Equiv.sumCongr p q) (finSumFinEquiv.symm (Fin.natAdd m i))) = _
+  simp [← finSumFinEquiv_apply_right]
+
+lemma blockHom_sign {m k : ℕ} (p : Equiv.Perm (Fin m)) (q : Equiv.Perm (Fin k)) :
+    (blockHom m k (p,q)).sign = p.sign*q.sign := by
+  change (finSumFinEquiv.permCongr (Equiv.sumCongr p q)).sign = _
+  rw [Equiv.Perm.sign_permCongr, Equiv.Perm.sign_sumCongr]
+
+lemma blockHom_injective (m k : ℕ) : Function.Injective (blockHom m k) :=
+  (finSumFinEquiv.permCongrHom.injective).comp Equiv.Perm.sumCongrHom_injective
+
+lemma card_blockGroup (m k : ℕ) :
+    Fintype.card (blockGroup m k) = Nat.factorial m*Nat.factorial k := by
+  rw [show Fintype.card (blockGroup m k) =
+      Fintype.card (Equiv.Perm (Fin m) × Equiv.Perm (Fin k)) from
+    Fintype.card_eq.mpr ⟨(Equiv.ofInjective (blockHom m k) (blockHom_injective m k)).symm⟩]
+  simp [Fintype.card_prod, Fintype.card_perm]
+
+lemma mem_blockGroup_of_no_crossing {m k : ℕ} (r : Equiv.Perm (Fin (m+k)))
+    (hr : ∀ i : Fin m, ∃ j : Fin m, r (Fin.castAdd k i) = Fin.castAdd k j) :
+    r ∈ blockGroup m k := by
+  let t : Equiv.Perm (Fin m ⊕ Fin k) := finSumFinEquiv.symm.permCongr r
+  have ht : Set.MapsTo t (Set.range Sum.inl) (Set.range Sum.inl) := by
+    rintro _ ⟨i, rfl⟩
+    rcases hr i with ⟨j,hj⟩
+    refine ⟨j, ?_⟩
+    change Sum.inl j = finSumFinEquiv.symm (r (finSumFinEquiv (Sum.inl i)))
+    rw [finSumFinEquiv_apply_left, hj]
+    simp [← finSumFinEquiv_apply_left]
+  rcases Equiv.Perm.mem_sumCongrHom_range_of_perm_mapsTo_inl ht with ⟨pq,hpq⟩
+  refine ⟨pq, ?_⟩
+  apply finSumFinEquiv.symm.permCongr.injective
+  change finSumFinEquiv.symm.permCongr
+    (finSumFinEquiv.permCongr (Equiv.Perm.sumCongrHom (Fin m) (Fin k) pq)) = _
+  rw [← Equiv.permCongr_symm, Equiv.symm_apply_apply]
+  exact hpq
+
+lemma exists_crossing_of_not_mem {m k : ℕ} (r : Equiv.Perm (Fin (m+k)))
+    (hr : r ∉ blockGroup m k) :
+    ∃ i : Fin m, ∃ j : Fin k, r (Fin.castAdd k i) = Fin.natAdd m j := by
+  have hn : ¬ ∀ i : Fin m, ∃ j : Fin m, r (Fin.castAdd k i) = Fin.castAdd k j :=
+    fun h => hr (mem_blockGroup_of_no_crossing r h)
+  push Not at hn
+  rcases hn with ⟨i,hi⟩
+  refine ⟨i, ?_⟩
+  have hcases := Fin.addCases (motive := fun z : Fin (m+k) =>
+    (∃ j : Fin k, z = Fin.natAdd m j) ∨ ∃ j : Fin m, z = Fin.castAdd k j)
+    (fun j => Or.inr ⟨j,rfl⟩) (fun j => Or.inl ⟨j,rfl⟩) (r (Fin.castAdd k i))
+  rcases hcases with h|⟨j,hj⟩
+  · exact h
+  · exact (hi j hj).elim
+end Coulomb
+
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/LeftPotential.lean

@@ -0,0 +1,225 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.Propagation.NuclearPotential
+
+namespace OAI
+
+noncomputable section
+
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set
+open scoped BigOperators ENNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open scoped Classical
+open scoped BigOperators ComplexConjugate
+open scoped Classical
+namespace Coulomb
+def leftPotential {m k : ℕ} (W : Configuration m → ℝ) (x : Configuration (m+k)) : ℝ :=
+  W ((joinConfiguration m k).symm x).1
+def rightPotential {m k : ℕ} (W : Configuration k → ℝ) (x : Configuration (m+k)) : ℝ :=
+  W ((joinConfiguration m k).symm x).2
+
+def crossEnergy {m k : ℕ} (u : H1Vector m) (v : H1Vector k) : ℝ :=
+  potentialEnergy (fun x => crossPotential ((joinConfiguration m k).symm x).1
+    ((joinConfiguration m k).symm x).2) (u.tensor v)
+
+lemma tensor_leftPotential_integrable {m k : ℕ} (u : H1Vector m) (v : H1Vector k)
+    (W : Configuration m → ℝ) (hW : ∀ s, Integrable (fun x => W x*‖u.value s x‖^2))
+    (s : Spins (m+k)) :
+    Integrable (fun x => leftPotential W x*‖(u.tensor v).value s x‖^2) := by
+  have hp : Integrable (fun z : Configuration m × Configuration k =>
+      (W z.1*‖u.value (s ∘ Fin.castAdd k) z.1‖^2)*‖v.value (s ∘ Fin.natAdd m) z.2‖^2)
+      (volume.prod volume) :=
+    (hW (s ∘ Fin.castAdd k)).mul_prod ((v.value_L2 (s ∘ Fin.natAdd m)).norm.integrable_sq)
+  have H := (joinConfiguration_symm_measurePreserving m k).integrable_comp_of_integrable hp
+  apply H.congr
+  filter_upwards [] with x
+  change (W _*‖u.value _ _‖^2)*‖v.value _ _‖^2 = W _*‖u.value _ _*v.value _ _‖^2
+  rw [norm_mul,mul_pow,mul_assoc]
+  rfl
+
+lemma tensor_rightPotential_integrable {m k : ℕ} (u : H1Vector m) (v : H1Vector k)
+    (W : Configuration k → ℝ) (hW : ∀ s, Integrable (fun x => W x*‖v.value s x‖^2))
+    (s : Spins (m+k)) :
+    Integrable (fun x => rightPotential W x*‖(u.tensor v).value s x‖^2) := by
+  have hp : Integrable (fun z : Configuration m × Configuration k =>
+      ‖u.value (s ∘ Fin.castAdd k) z.1‖^2*(W z.2*‖v.value (s ∘ Fin.natAdd m) z.2‖^2))
+      (volume.prod volume) :=
+    ((u.value_L2 (s ∘ Fin.castAdd k)).norm.integrable_sq).mul_prod (hW (s ∘ Fin.natAdd m))
+  have H := (joinConfiguration_symm_measurePreserving m k).integrable_comp_of_integrable hp
+  apply H.congr
+  filter_upwards [] with x
+  change ‖u.value _ _‖^2*(W _*‖v.value _ _‖^2) = W _*‖u.value _ _*v.value _ _‖^2
+  rw [norm_mul,mul_pow,mul_left_comm]
+  rfl
+
+lemma potentialEnergy_tensor_left {m k : ℕ} (u : H1Vector m) (v : H1Vector k)
+    (W : Configuration m → ℝ) :
+    potentialEnergy (leftPotential W) (u.tensor v) = potentialEnergy W u*mass v := by
+  have hi (s : Spins (m+k)) : (∫ x, leftPotential W x*‖(u.tensor v).value s x‖^2) =
+      (∫ x, W x*‖u.value (s ∘ Fin.castAdd k) x‖^2)*
+        (∫ y, ‖v.value (s ∘ Fin.natAdd m) y‖^2) := by
+    rw [← (joinConfiguration_measurePreserving m k).integral_comp'
+      (fun x => leftPotential W x*‖(u.tensor v).value s x‖^2)]
+    change (∫ z : Configuration m × Configuration k,
+      leftPotential W (joinConfiguration m k z)*‖tensorValue u v s (joinConfiguration m k z)‖^2
+        ∂(volume.prod volume)) = _
+    simp only [leftPotential, ContinuousLinearEquiv.symm_apply_apply, tensorValue_join,norm_mul,mul_pow,← mul_assoc]
+    exact integral_prod_mul (μ := volume) (ν := volume)
+      (fun x : Configuration m => W x*‖u.value (s ∘ Fin.castAdd k) x‖^2)
+      (fun y : Configuration k => ‖v.value (s ∘ Fin.natAdd m) y‖^2)
+  unfold potentialEnergy mass
+  rw [sum_joinSpins]
+  simp_rw [hi, joinSpins_left, joinSpins_right]
+  rw [Finset.sum_mul_sum]
+
+lemma potentialEnergy_tensor_right {m k : ℕ} (u : H1Vector m) (v : H1Vector k)
+    (W : Configuration k → ℝ) :
+    potentialEnergy (rightPotential W) (u.tensor v) = mass u*potentialEnergy W v := by
+  have hi (s : Spins (m+k)) : (∫ x, rightPotential W x*‖(u.tensor v).value s x‖^2) =
+      (∫ x, ‖u.value (s ∘ Fin.castAdd k) x‖^2)*
+        (∫ y, W y*‖v.value (s ∘ Fin.natAdd m) y‖^2) := by
+    rw [← (joinConfiguration_measurePreserving m k).integral_comp'
+      (fun x => rightPotential W x*‖(u.tensor v).value s x‖^2)]
+    change (∫ z : Configuration m × Configuration k,
+      rightPotential W (joinConfiguration m k z)*‖tensorValue u v s (joinConfiguration m k z)‖^2
+        ∂(volume.prod volume)) = _
+    simp only [rightPotential, ContinuousLinearEquiv.symm_apply_apply,tensorValue_join,norm_mul,mul_pow]
+    simp_rw [mul_left_comm (W _) (‖u.value _ _‖^2)]
+    exact integral_prod_mul (μ := volume) (ν := volume)
+      (fun x : Configuration m => ‖u.value (s ∘ Fin.castAdd k) x‖^2)
+      (fun y : Configuration k => W y*‖v.value (s ∘ Fin.natAdd m) y‖^2)
+  unfold potentialEnergy mass
+  rw [sum_joinSpins]
+  simp_rw [hi, joinSpins_left, joinSpins_right]
+  rw [Finset.sum_mul_sum]
+
+lemma potentialEnergy_add {n : ℕ} (u : H1Vector n) (V W : Configuration n → ℝ)
+    (hV : ∀ s, Integrable (fun x => V x*‖u.value s x‖^2))
+    (hW : ∀ s, Integrable (fun x => W x*‖u.value s x‖^2)) :
+    potentialEnergy (fun x => V x+W x) u = potentialEnergy V u+potentialEnergy W u := by
+  simp only [potentialEnergy,add_mul]
+  simp_rw [integral_add (hV _) (hW _)]
+  rw [Finset.sum_add_distrib]
+
+lemma nuclearPotential_split {M m k : ℕ} (S : Nuclei M) (x : Configuration (m+k)) :
+    nuclearPotential S x = leftPotential (nuclearPotential S) x+
+      rightPotential (nuclearPotential S) x := by
+  have H := nuclearPotential_join S ((joinConfiguration m k).symm x).1 ((joinConfiguration m k).symm x).2
+  simpa only [Prod.mk.eta,ContinuousLinearEquiv.apply_symm_apply,leftPotential,rightPotential] using H
+
+lemma pairPotential_split {m k : ℕ} (x : Configuration (m+k)) :
+    pairPotential x = leftPotential pairPotential x+rightPotential pairPotential x+
+      crossPotential ((joinConfiguration m k).symm x).1 ((joinConfiguration m k).symm x).2 := by
+  have H := pairPotential_join ((joinConfiguration m k).symm x).1 ((joinConfiguration m k).symm x).2
+  simpa only [Prod.mk.eta,ContinuousLinearEquiv.apply_symm_apply,leftPotential,rightPotential] using H
+
+lemma nuclearEnergy_tensor {M m k : ℕ} (S : Nuclei M) (u : H1Vector m) (v : H1Vector k) :
+    nuclearEnergy S (u.tensor v) = nuclearEnergy S u*mass v+mass u*nuclearEnergy S v := by
+  change potentialEnergy (nuclearPotential S) (u.tensor v) = _
+  rw [show (nuclearPotential S : Configuration (m+k) → ℝ) = fun x =>
+      leftPotential (nuclearPotential S) x+rightPotential (nuclearPotential S) x
+      from funext (nuclearPotential_split S)]
+  have h1 : ∀ s, Integrable (fun x => leftPotential (nuclearPotential S) x*‖(u.tensor v).value s x‖^2) :=
+    tensor_leftPotential_integrable u v (nuclearPotential S) (u.nuclear_integrable S)
+  have h2 : ∀ s, Integrable (fun x => rightPotential (nuclearPotential S) x*‖(u.tensor v).value s x‖^2) :=
+    tensor_rightPotential_integrable u v (nuclearPotential S) (v.nuclear_integrable S)
+  rw [potentialEnergy_add _ _ _ h1 h2,
+      potentialEnergy_tensor_left,potentialEnergy_tensor_right]
+  rfl
+
+lemma tensor_crossPotential_integrable {m k : ℕ} (u : H1Vector m) (v : H1Vector k)
+    (s : Spins (m+k)) : Integrable (fun x =>
+      crossPotential ((joinConfiguration m k).symm x).1 ((joinConfiguration m k).symm x).2 *
+        ‖(u.tensor v).value s x‖^2) := by
+  have H := ((u.tensor v).pair_integrable s).sub
+    ((tensor_leftPotential_integrable u v pairPotential u.pair_integrable s).add
+      (tensor_rightPotential_integrable u v pairPotential v.pair_integrable s))
+  convert H using 1
+  funext x
+  change _ = pairPotential x*_-(_+_)
+  rw [pairPotential_split]
+  ring
+
+lemma pairEnergy_tensor {m k : ℕ} (u : H1Vector m) (v : H1Vector k) :
+    pairEnergy (u.tensor v) = pairEnergy u*mass v+mass u*pairEnergy v+crossEnergy u v := by
+  change potentialEnergy pairPotential (u.tensor v) = _
+  rw [show (pairPotential : Configuration (m+k) → ℝ) = fun x =>
+      (leftPotential pairPotential x+rightPotential pairPotential x)+
+      crossPotential ((joinConfiguration m k).symm x).1 ((joinConfiguration m k).symm x).2
+      from funext pairPotential_split]
+  have h1 := tensor_leftPotential_integrable u v pairPotential u.pair_integrable
+  have h2 := tensor_rightPotential_integrable u v pairPotential v.pair_integrable
+  have h12 : ∀ s, Integrable (fun x => (leftPotential pairPotential x+rightPotential pairPotential x)*
+      ‖(u.tensor v).value s x‖^2) := by
+    intro s
+    apply ((h1 s).add (h2 s)).congr
+    filter_upwards [] with x
+    exact (add_mul _ _ _).symm
+  rw [potentialEnergy_add _ _ _ h12
+      (tensor_crossPotential_integrable u v),
+      potentialEnergy_add _ _ _ h1 h2,potentialEnergy_tensor_left,potentialEnergy_tensor_right]
+  rfl
+
+lemma form_wedge {M m k : ℕ} (S : Nuclei M) (u : H1Vector m) (v : H1Vector k)
+    (hu : Antisymmetric u) (hv : Antisymmetric v) (A B : Set Space)
+    (hsu : SpatiallySupported u A) (hsv : SpatiallySupported v B)
+    (hA : IsClosed A) (hB : IsClosed B) (hAB : Disjoint A B) :
+    form S (u.wedge v) = form S u*mass v+mass u*form S v+crossEnergy u v := by
+  unfold form
+  rw [kinetic_wedge u v hu hv A B hsu hsv hA hB hAB,
+    nuclearEnergy_wedge_tensor S u v hu hv A B hsu hsv hAB,
+    pairEnergy_wedge_tensor u v hu hv A B hsu hsv hAB,nuclearEnergy_tensor,pairEnergy_tensor]
+  ring
+end Coulomb
+
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/LipschitzTestEnergy.lean

@@ -0,0 +1,150 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.ThomasFermi.TFCountTest
+import OAI.Analysis.CoulombRadii.FieldAnalysis.PoissonInterior
+import OAI.Analysis.CoulombRadii.Packets.LipschitzMollifier
+
+namespace OAI
+
+noncomputable section
+
+section
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology ContDiff
+namespace Coulomb
+open NeutralAtom (dirPartial coordinateLaplacian axis)
+
+lemma smooth_test_energy_identity {χ : Space → ℝ} (hχ : ContDiff ℝ ∞ χ)
+    (hc : HasCompactSupport χ) :
+    (∫ x, testCharge χ x*χ x)=
+      (4*Real.pi)⁻¹*∑ a : Fin 3, ∫ x, (dirPartial χ (axis a) x)^2 := by
+  have hp (v : Space) : ContDiff ℝ ∞ (dirPartial χ v) :=
+    NeutralAtom.contDiff_partial (by simpa using hχ) v
+  have hpc (v : Space) := NeutralAtom.hasCompactSupport_partial hc v
+  have hpp (v : Space) : ContDiff ℝ ∞ (dirPartial (dirPartial χ v) v) :=
+    NeutralAtom.contDiff_partial (by simpa using hp v) v
+  have hcross (v : Space) : Integrable (fun x : Space => (dirPartial χ v x)^2) (volume : Measure Space) := by
+    have hh : HasCompactSupport (fun x => dirPartial χ v x*dirPartial χ v x) := (hpc v).mul_right
+    have hc : Continuous (fun x : Space => (dirPartial χ v x)^2) := (hp v).continuous.pow 2
+    exact hc.integrable_of_hasCompactSupport (μ := (volume : Measure Space)) (by simpa only [pow_two] using hh)
+  have hsecond (v : Space) : Integrable (fun x => χ x*dirPartial (dirPartial χ v) v x) :=
+    (hχ.continuous.mul (hpp v).continuous).integrable_of_hasCompactSupport hc.mul_right
+  have hprod (v : Space) : Integrable (fun x => χ x*dirPartial χ v x) :=
+    (hχ.continuous.mul (hp v).continuous).integrable_of_hasCompactSupport hc.mul_right
+  have hibp (v : Space) : (∫ x, χ x*dirPartial (dirPartial χ v) v x)=
+      -(∫ x, (dirPartial χ v x)^2) := by
+    simpa only [dirPartial,pow_two] using
+      (integral_mul_fderiv_eq_neg_fderiv_mul_of_integrable
+        (by simpa only [pow_two,dirPartial] using hcross v) (hsecond v) (hprod v)
+        (fun x _ => hχ.differentiable (by simp) x)
+        (fun x _ => (hp v).differentiable (by simp) x))
+  have he : (fun x => testCharge χ x*χ x)=
+      (fun x => -(4*Real.pi)⁻¹*∑ a : Fin 3, χ x*dirPartial (dirPartial χ (axis a)) (axis a) x) := by
+    funext x
+    rw [testCharge,NeutralAtom.coordinateLaplacian_eq_partials
+      ((hχ.of_le (by exact WithTop.coe_le_coe.mpr le_top)).contDiffAt),←Finset.mul_sum]
+    ring
+  rw [he,integral_const_mul,integral_finsetSum _ (fun a _ => hsecond (axis a))]
+  simp_rw [hibp]
+  rw [Finset.sum_neg_distrib]
+  ring
+
+lemma smooth_test_energy_le {χ : Space → ℝ} {A R : ℝ} (hA : 0≤A)
+    (hχ : ContDiff ℝ ∞ χ) (y : Space)
+    (hs : tsupport χ⊆Metric.closedBall y R)
+    (hL : ∀ z v, |χ z-χ v|≤A*‖z-v‖) :
+    (∫ x, testCharge χ x*χ x)≤
+      (4*Real.pi)⁻¹*(3*(volume (Metric.closedBall y R)).toReal*A^2) := by
+  have hc : HasCompactSupport χ := (isCompact_closedBall y R).of_isClosed_subset (isClosed_tsupport χ) hs
+  rw [smooth_test_energy_identity hχ hc]
+  apply mul_le_mul_of_nonneg_left _ (by positivity)
+  have hsingle (a : Fin 3) : (∫ x, (dirPartial χ (axis a) x)^2)≤
+      (volume (Metric.closedBall y R)).toReal*A^2 := by
+    have hd (x : Space) : |dirPartial χ (axis a) x|≤A := by
+      have hd := norm_fderiv_le_of_lip' ℝ (f := χ) (x₀ := x) hA (Eventually.of_forall (fun z => by
+        simpa only [Real.norm_eq_abs] using hL z x))
+      have ha : ‖axis a‖=1 := by simp [axis]
+      have hh := (fderiv ℝ χ x).le_opNorm (axis a)
+      rw [ha,mul_one] at hh
+      exact (show |dirPartial χ (axis a) x|≤‖fderiv ℝ χ x‖ from hh).trans hd
+    have hout (x : Space) (hx : x∉Metric.closedBall y R) : (dirPartial χ (axis a) x)^2=0 := by
+      rw [image_eq_zero_of_notMem_tsupport (fun hh => hx (hs (NeutralAtom.tsupport_dirPartial_subset χ _ hh)))]
+      norm_num
+    rw [←setIntegral_eq_integral_of_forall_compl_eq_zero hout]
+    have hh := norm_setIntegral_le_of_norm_le_const (μ := volume)
+      (isCompact_closedBall y R).measure_lt_top (fun z _ => show ‖(dirPartial χ (axis a) z)^2‖≤A^2 by
+        rw [Real.norm_of_nonneg (sq_nonneg _)]
+        simpa only [sq_abs] using (sq_le_sq₀ (abs_nonneg _) hA).2 (hd z))
+    exact (le_abs_self _).trans (by simpa only [Real.norm_eq_abs,Measure.real,mul_comm] using hh)
+  have HH := Finset.sum_le_sum (s := Finset.univ) (fun a _ => hsingle a)
+  simpa [mul_assoc] using HH
+
+end Coulomb
+
+end
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology ContDiff
+namespace Coulomb
+
+theorem raw_coulomb_lipschitz_test {Ω : Set Space} (hΩ : MeasurableSet Ω)
+    [IsFiniteMeasure (volume.restrict Ω)] {σ K : Space → ℝ} {A B R : ℝ}
+    (hσ : MemLp σ TFExponent (volume.restrict Ω)) (hσs : ∀ x∉Ω, σ x=0)
+    (hA : 0≤A) (hR : 0<R) (y : Space)
+    (hB : ∀ x, |K x|≤B) (hK : ∀ x, R<‖x-y‖ → K x=0)
+    (hL : ∀ z v, |K z-K v|≤A*‖z-v‖)
+    (hball : Metric.closedBall y (2*R)⊆Ω) :
+    (∫ x, σ x*K x)^2≤coulombBilinear σ σ*
+      ((4*Real.pi)⁻¹*(3*(volume (Metric.closedBall y (2*R))).toReal*A^2)) := by
+  let ε : ℕ → ℝ := fun n => R*(1/((n:ℝ)+1))
+  have hε (n : ℕ) : 0<ε n := by dsimp [ε]; positivity
+  have hεR (n : ℕ) : ε n≤R := by
+    dsimp [ε]
+    apply mul_le_of_le_one_right hR.le
+    exact (div_le_one (by positivity)).2 (by linarith [Nat.cast_nonneg (α := ℝ) n])
+  have hεt : Tendsto ε atTop (𝓝 0) := by
+    simpa only [mul_zero] using tendsto_one_div_add_atTop_nhds_zero_nat.const_mul R
+  choose χ hsm hsp hLip happ using
+    (fun n => NeutralAtom.exists_smooth_lipschitz_approx K hA (hε n) y hK hL)
+  have hiΩ : Integrable σ (volume.restrict Ω) := hσ.integrable (by norm_num [TFExponent])
+  have hind : Ω.indicator σ=σ := by
+    funext x
+    by_cases hx : x∈Ω
+    · exact indicator_of_mem hx σ
+    · rw [indicator_of_notMem hx,hσs x hx]
+  have hi : Integrable σ := by
+    have hh := (integrable_indicator_iff hΩ).2 hiΩ
+    rwa [hind] at hh
+  have hpoint (x : Space) : Tendsto (fun n => χ n x) atTop (𝓝 (K x)) := by
+    apply tendsto_iff_dist_tendsto_zero.mpr
+    have hh : Tendsto (fun n => A*ε n) atTop (𝓝 0) := by simpa using hεt.const_mul A
+    exact squeeze_zero (fun n => dist_nonneg) (fun n => by simpa only [Real.dist_eq] using happ n x) hh
+  have hdom (n : ℕ) (x : Space) : |χ n x|≤B+A*R := by
+    calc
+      _≤|χ n x-K x|+|K x| := by simpa only [sub_add_cancel] using abs_add_le (χ n x-K x) (K x)
+      _≤A*ε n+B := add_le_add (happ n x) (hB x)
+      _≤_ := by have hh := mul_le_mul_of_nonneg_left (hεR n) hA; linarith
+  have hconv : Tendsto (fun n => ∫ x, σ x*χ n x) atTop (𝓝 (∫ x, σ x*K x)) := by
+    apply tendsto_integral_of_dominated_convergence (fun x => ‖σ x‖*(B+A*R))
+    · intro n
+      exact hi.aestronglyMeasurable.mul (hsm n).continuous.aestronglyMeasurable
+    · exact hi.norm.mul_const _
+    · intro n
+      filter_upwards [] with x
+      rw [norm_mul,Real.norm_eq_abs (χ n x)]
+      exact mul_le_mul_of_nonneg_left (hdom n x) (norm_nonneg _)
+    · filter_upwards [] with x
+      exact tendsto_const_nhds.mul (hpoint x)
+  have hQ := raw_coulomb_nonneg hΩ hσ hσs
+  apply le_of_tendsto (hconv.pow 2)
+  filter_upwards [] with n
+  have hsp' : tsupport (χ n)⊆Metric.closedBall y (2*R) :=
+    (hsp n).trans (Metric.closedBall_subset_closedBall (by linarith [hεR n]))
+  have hc : HasCompactSupport (χ n) := (isCompact_closedBall y (2*R)).of_isClosed_subset
+    (isClosed_tsupport _) hsp'
+  exact (raw_coulomb_smooth_test hΩ (hsm n) hc (hsp'.trans hball) hσ hσs).trans
+    (mul_le_mul_of_nonneg_left (smooth_test_energy_le hA (hsm n) y hsp' (hLip n)) hQ)
+
+end Coulomb
+
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/LowProjection.lean

@@ -0,0 +1,53 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.FieldAnalysis.TsumFixed
+
+namespace OAI
+
+section
+section
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+namespace Coulomb
+section LowProjection
+variable {A B ι : Type*} [MeasurableSpace A] [MeasurableSpace B]
+    {μ : Measure A} {ν : Measure B} [SigmaFinite μ] [SigmaFinite ν]
+    (v : ι → A → ℂ) (hv : ∀ i, MemLp (v i) 2 μ)
+
+noncomputable def lowProjection (s : Finset ι) (f : B × A → ℂ) (z : B × A) : ℂ :=
+  ∑ i ∈ s, fiberContract (μ := μ) (v i) f z.1 * v i z.2
+
+include hv in
+lemma lowProjection_memLp (s : Finset ι) {f : B × A → ℂ} (hf : MemLp f 2 (ν.prod μ)) :
+    MemLp (lowProjection (μ := μ) v s f) 2 (ν.prod μ) :=
+  memLp_finsetSum s (fun i _ => tensorPair_memLp (fiberContract_memLp (hv i) hf) (hv i))
+
+include hv in
+lemma lowProjection_tail_memLp (s : Finset ι) {f : B × A → ℂ}
+    (hf : MemLp f 2 (ν.prod μ)) (x : A) :
+    MemLp (fun y => lowProjection (μ := μ) v s f (y,x)) 2 ν :=
+  memLp_finsetSum s (fun i _ => (fiberContract_memLp (hv i) hf).mul_const (v i x))
+
+include hv in
+lemma lowProjection_eq_contract (s : Finset ι) {f : B × A → ℂ}
+    (hf : MemLp f 2 (ν.prod μ)) (x : A) :
+    (fun y => lowProjection (μ := μ) v s f (y,x)) =ᵐ[ν]
+      fiberContract (μ := μ) (lowOrbital v s x) f := by
+  filter_upwards [memLp_fiber_ae hf] with y hy
+  unfold lowProjection fiberContract lowOrbital
+  rw [show (fun a => star (∑ i ∈ s, star (v i x) * v i a) * f (y,a)) =
+      (fun a => ∑ i ∈ s, (star (v i a) * f (y,a)) * v i x) from by
+    funext a
+    simp only [star_sum, star_mul, star_star, Finset.sum_mul]
+    apply Finset.sum_congr rfl
+    intro i _
+    ring]
+  rw [integral_finsetSum s (fun i _ => (integrable_star_mul (hv i) hy).mul_const (v i x))]
+  simp only [integral_mul_const]
+
+end LowProjection
+end Coulomb
+
+end
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/MeridianMap.lean

@@ -0,0 +1,520 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.Localization.TruncatedCoulomb
+
+namespace OAI
+
+noncomputable section
+
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set
+open scoped BigOperators ENNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open scoped Classical
+open scoped BigOperators ComplexConjugate
+open scoped Classical
+open scoped Classical
+open MeasureTheory Set Filter
+open scoped Classical ENNReal NNReal ComplexConjugate
+open MeasureTheory Set Filter Module Module.End TopologicalSpace Function
+open scoped Classical ComplexConjugate
+open MeasureTheory Set Filter Module Module.End TopologicalSpace Function
+open scoped Classical ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Filter
+open scoped ENNReal NNReal FourierTransform SchwartzMap LineDeriv ComplexConjugate
+open scoped LineDeriv
+open MeasureTheory Set Metric
+open scoped ENNReal NNReal RealInnerProductSpace
+open MeasureTheory Set Metric Filter
+open scoped ENNReal NNReal RealInnerProductSpace Convolution
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open MeasureTheory Set Filter
+open scoped Classical SchwartzMap FourierTransform ENNReal NNReal ComplexConjugate Pointwise
+open MeasureTheory Set Filter
+open scoped Classical SchwartzMap FourierTransform ENNReal NNReal Pointwise
+open MeasureTheory Set Filter
+open scoped Classical SchwartzMap FourierTransform ENNReal NNReal Pointwise
+open MeasureTheory Set Filter
+open scoped Classical SchwartzMap ENNReal NNReal Pointwise
+open MeasureTheory Set Filter
+open scoped Classical SchwartzMap FourierTransform ENNReal NNReal Pointwise
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Classical SchwartzMap Pointwise
+namespace Coulomb
+noncomputable def meridianMap (p : ℝ × ℝ) : ℝ × ℝ := (Real.sqrt (p.1^2-p.2^2), p.2)
+def meridianDomain : Set (ℝ × ℝ) := {p | |p.2| < p.1}
+lemma meridianDomain_measurable : MeasurableSet meridianDomain :=
+  measurableSet_lt (measurable_snd.abs) measurable_fst
+lemma meridian_radicand_pos {p : ℝ × ℝ} (hp : p ∈ meridianDomain) : 0 < p.1^2-p.2^2 := by
+  change |p.2| < p.1 at hp
+  have h0 := abs_nonneg p.2
+  nlinarith [sq_abs p.2]
+noncomputable def meridianDeriv (p : ℝ × ℝ) : (ℝ × ℝ) →L[ℝ] (ℝ × ℝ) :=
+  (Matrix.toLin (.finTwoProd ℝ) (.finTwoProd ℝ)
+    !![p.1 / Real.sqrt (p.1^2-p.2^2), -p.2 / Real.sqrt (p.1^2-p.2^2); 0, 1]).toContinuousLinearMap
+lemma meridian_hasFDeriv {p : ℝ × ℝ} (hp : p ∈ meridianDomain) :
+    HasFDerivAt meridianMap (meridianDeriv p) p := by
+  have hf : HasFDerivAt (fun q : ℝ × ℝ => q.1) (ContinuousLinearMap.fst ℝ ℝ ℝ) p := hasFDerivAt_fst
+  have hg : HasFDerivAt (fun q : ℝ × ℝ => q.2) (ContinuousLinearMap.snd ℝ ℝ ℝ) p := hasFDerivAt_snd
+  have hh := (Real.hasDerivAt_sqrt (meridian_radicand_pos hp).ne').comp_hasFDerivAt p
+    ((hf.pow 2).sub (hg.pow 2))
+  have h := hh.prodMk (hasFDerivAt_snd (𝕜:=ℝ) (E:=ℝ) (F:=ℝ))
+  unfold meridianDeriv
+  rw [Matrix.toLin_finTwoProd_toContinuousLinearMap]
+  apply h.congr_fderiv
+  ext <;> simp [div_eq_mul_inv] <;> ring
+lemma meridian_det (p : ℝ × ℝ) : (meridianDeriv p).det = p.1 / Real.sqrt (p.1^2-p.2^2) := by
+  simp [meridianDeriv, LinearMap.det_toContinuousLinearMap, LinearMap.det_toLin,
+    Matrix.det_fin_two_of]
+lemma meridianMap_injOn : InjOn meridianMap meridianDomain := by
+  intro p hp q hq he
+  have h1 : Real.sqrt (p.1^2-p.2^2) = Real.sqrt (q.1^2-q.2^2) := congrArg Prod.fst he
+  have h2 : p.2 = q.2 := by simpa [meridianMap] using congrArg Prod.snd he
+  have hp0 := meridian_radicand_pos hp
+  have hq0 := meridian_radicand_pos hq
+  rw [Real.sqrt_inj hp0.le hq0.le] at h1
+  have hpp : 0 < p.1 := (abs_nonneg p.2).trans_lt hp
+  have hqq : 0 < q.1 := (abs_nonneg q.2).trans_lt hq
+  apply Prod.ext _ h2
+  rw [h2] at h1
+  nlinarith
+lemma meridian_image : meridianMap '' meridianDomain = Ioi (0:ℝ) ×ˢ (univ : Set ℝ) := by
+  ext q
+  constructor
+  · rintro ⟨p, hp, rfl⟩
+    exact ⟨Real.sqrt_pos.mpr (meridian_radicand_pos hp), mem_univ _⟩
+  · rintro ⟨hq, _⟩
+    change 0 < q.1 at hq
+    refine ⟨(Real.sqrt (q.1^2+q.2^2), q.2), ?_, ?_⟩
+    · change |q.2| < Real.sqrt (q.1^2+q.2^2)
+      rw [Real.lt_sqrt (abs_nonneg _)]
+      nlinarith [sq_abs q.2, sq_pos_of_pos hq]
+    · apply Prod.ext
+      · dsimp [meridianMap]
+        rw [Real.sq_sqrt (by positivity), add_sub_cancel_right, Real.sqrt_sq hq.le]
+      · rfl
+
+lemma meridian_lintegral (f : ℝ × ℝ → ℝ≥0∞) :
+    (∫⁻ q in Ioi (0:ℝ) ×ˢ (univ : Set ℝ), ENNReal.ofReal q.1 * f q) =
+      ∫⁻ p in meridianDomain, ENNReal.ofReal p.1 * f (meridianMap p) := by
+  rw [← meridian_image, lintegral_image_eq_lintegral_abs_det_fderiv_mul volume
+    meridianDomain_measurable (fun p hp => (meridian_hasFDeriv hp).hasFDerivWithinAt) meridianMap_injOn]
+  apply setLIntegral_congr_fun meridianDomain_measurable
+  intro p hp
+  have hr := meridian_radicand_pos hp
+  have hs := Real.sqrt_pos.mpr hr
+  have hp0 : 0 < p.1 := (abs_nonneg p.2).trans_lt hp
+  dsimp only
+  rw [meridian_det, abs_of_pos (div_pos hp0 hs)]
+  change ENNReal.ofReal (p.1 / Real.sqrt (p.1^2-p.2^2)) *
+    (ENNReal.ofReal (Real.sqrt (p.1^2-p.2^2)) * f _) = _
+  rw [← mul_assoc, ← ENNReal.ofReal_mul (div_pos hp0 hs).le, div_mul_cancel₀ _ hs.ne']
+
+lemma plane_radial_lintegral (F : ℝ → ℝ≥0∞) (hF : Measurable F) :
+    (∫⁻ q : ℝ × ℝ, F (Real.sqrt (q.1^2+q.2^2))) =
+      ENNReal.ofReal (2*Real.pi) * ∫⁻ r in Ioi (0:ℝ), ENNReal.ofReal r * F r := by
+  rw [← lintegral_comp_polarCoord_symm]
+  have hpoint (p : ℝ × ℝ) (hp : p ∈ polarCoord.target) :
+      Real.sqrt ((polarCoord.symm p).1^2+(polarCoord.symm p).2^2) = p.1 := by
+    have hr : 0 < p.1 := hp.1
+    dsimp [polarCoord]
+    rw [show (p.1 * Real.cos p.2)^2 + (p.1 * Real.sin p.2)^2 = p.1^2 from by
+      nlinarith [Real.sin_sq_add_cos_sq p.2]]
+    exact Real.sqrt_sq hr.le
+  calc
+    _ = ∫⁻ p in polarCoord.target, ENNReal.ofReal p.1 * F p.1 := by
+      apply setLIntegral_congr_fun polarCoord.open_target.measurableSet
+      intro p hp
+      simp only [smul_eq_mul, hpoint p hp]
+    _ = _ := by
+      change (∫⁻ p : ℝ × ℝ in Ioi (0:ℝ) ×ˢ Ioo (-Real.pi) Real.pi,
+        ENNReal.ofReal p.1 * F p.1) = _
+      rw [Measure.volume_eq_prod, ← Measure.prod_restrict, lintegral_prod]
+      · simp only [lintegral_const, Measure.restrict_apply_univ, Real.volume_Ioo, sub_neg_eq_add]
+        rw [show Real.pi + Real.pi = 2*Real.pi by ring, lintegral_mul_const]
+        · exact mul_comm _ _
+        · exact measurable_id.ennreal_ofReal.mul hF
+      · exact ((measurable_fst.ennreal_ofReal).mul (hF.comp measurable_fst)).aemeasurable
+
+lemma axisymmetric_lintegral (F : ℝ × ℝ → ℝ≥0∞) (hF : Measurable F) :
+    (∫⁻ z : ℝ, ∫⁻ q : ℝ × ℝ, F (Real.sqrt (z^2+q.1^2+q.2^2), z)) =
+      ENNReal.ofReal (2*Real.pi) *
+        ∫⁻ p in meridianDomain, ENNReal.ofReal p.1 * F p := by
+  have hp (z : ℝ) := plane_radial_lintegral
+    (fun r => F (Real.sqrt (z^2+r^2), z))
+    (hF.comp (((measurable_const.add (measurable_id.pow_const 2)).sqrt).prodMk measurable_const))
+  have he (z : ℝ) : (∫⁻ q : ℝ × ℝ, F (Real.sqrt (z^2+q.1^2+q.2^2), z)) =
+      ENNReal.ofReal (2*Real.pi) *
+        ∫⁻ r in Ioi (0:ℝ), ENNReal.ofReal r * F (Real.sqrt (r^2+z^2), z) := by
+    convert hp z using 1
+    · apply lintegral_congr
+      intro q
+      rw [Real.sq_sqrt (by positivity)]
+      congr 3
+      ring
+    · congr 1
+      apply lintegral_congr
+      intro r
+      rw [add_comm (z^2) (r^2)]
+  simp_rw [he]
+  rw [lintegral_const_mul _ (by fun_prop)]
+  congr 1
+  have hm : Measurable (fun p : ℝ × ℝ => ENNReal.ofReal p.1 * F (Real.sqrt (p.1^2+p.2^2), p.2)) := by
+    exact measurable_fst.ennreal_ofReal.mul
+      (hF.comp (((measurable_fst.pow_const 2).add (measurable_snd.pow_const 2)).sqrt.prodMk measurable_snd))
+  rw [← lintegral_lintegral_swap hm.aemeasurable]
+  rw [← lintegral_prod _ hm.aemeasurable]
+  rw [show (volume.restrict (Ioi (0:ℝ))).prod volume =
+    (volume : Measure (ℝ × ℝ)).restrict (Ioi (0:ℝ) ×ˢ univ) from by
+      rw [Measure.volume_eq_prod, ← Measure.prod_restrict, Measure.restrict_univ]]
+  rw [meridian_lintegral]
+  apply setLIntegral_congr_fun meridianDomain_measurable
+  intro p hp
+  dsimp [meridianMap]
+  rw [Real.sq_sqrt (meridian_radicand_pos hp).le, sub_add_cancel,
+    Real.sqrt_sq ((abs_nonneg p.2).trans_lt hp).le]
+
+lemma meridian_lintegral_iterated (F : ℝ × ℝ → ℝ≥0∞) (hF : Measurable F) :
+    (∫⁻ p in meridianDomain, ENNReal.ofReal p.1 * F p) =
+      ∫⁻ s in Ioi (0:ℝ), ∫⁻ z in Ioo (-s) s, ENNReal.ofReal s * F (s,z) := by
+  have hm : Measurable (meridianDomain.indicator (fun p : ℝ × ℝ => ENNReal.ofReal p.1 * F p)) :=
+    (measurable_fst.ennreal_ofReal.mul hF).indicator meridianDomain_measurable
+  rw [← lintegral_indicator meridianDomain_measurable, Measure.volume_eq_prod,
+    lintegral_prod _ hm.aemeasurable, ← lintegral_indicator measurableSet_Ioi]
+  apply lintegral_congr
+  intro s
+  by_cases hs : 0 < s
+  · rw [Set.indicator_of_mem (show s ∈ Ioi (0:ℝ) from hs), ← lintegral_indicator measurableSet_Ioo]
+    apply lintegral_congr
+    intro z
+    have he : (s,z) ∈ meridianDomain ↔ z ∈ Ioo (-s) s := by
+      change |z| < s ↔ -s < z ∧ z < s
+      exact abs_lt
+    by_cases hz : z ∈ Ioo (-s) s <;> simp [Set.indicator, he, hz]
+  · rw [Set.indicator_of_notMem (show s ∉ Ioi (0:ℝ) from hs)]
+    simp [Set.indicator, ENNReal.ofReal_eq_zero.mpr (le_of_not_gt hs)]
+
+noncomputable def tripleSpaceEquiv : (ℝ × (ℝ × ℝ)) ≃ᵐ Space :=
+  ((MeasurableEquiv.refl ℝ).prodCongr (MeasurableEquiv.piFinTwo (fun _ => ℝ)).symm).trans
+    (((MeasurableEquiv.piFinSuccAbove (fun _ : Fin 3 => ℝ) 0).symm).trans
+      (MeasurableEquiv.toLp 2 (Fin 3 → ℝ)))
+lemma tripleSpaceEquiv_apply (p : ℝ × (ℝ × ℝ)) :
+    tripleSpaceEquiv p = WithLp.toLp 2 ![p.1,p.2.1,p.2.2] := by
+  ext i
+  fin_cases i <;> rfl
+lemma tripleSpaceEquiv_preserving : MeasurePreserving tripleSpaceEquiv volume volume := by
+  have h1 := (MeasurePreserving.id (volume : Measure ℝ)).prod
+    ((volume_preserving_piFinTwo (fun _ => ℝ)).symm _)
+  have h2 := (volume_preserving_piFinSuccAbove (fun _ : Fin 3 => ℝ) 0).symm _
+  have h3 := (EuclideanSpace.volume_preserving_symm_measurableEquiv_toLp (Fin 3)).symm _
+  exact h3.comp (h2.comp h1)
+lemma norm_tripleSpaceEquiv (p : ℝ × (ℝ × ℝ)) :
+    ‖tripleSpaceEquiv p‖ = Real.sqrt (p.1^2 + p.2.1^2+p.2.2^2) := by
+  rw [tripleSpaceEquiv_apply, EuclideanSpace.norm_eq]
+  simp [Fin.sum_univ_succ, Real.norm_eq_abs, sq_abs, add_assoc]
+lemma axisymmetric_space_lintegral (F : ℝ × ℝ → ℝ≥0∞) (hF : Measurable F) :
+    (∫⁻ x : Space, F (‖x‖, x 0)) = ENNReal.ofReal (2*Real.pi) *
+      ∫⁻ p in meridianDomain, ENNReal.ofReal p.1 * F p := by
+  rw [← tripleSpaceEquiv_preserving.lintegral_comp_emb tripleSpaceEquiv.measurableEmbedding,
+    Measure.volume_eq_prod, lintegral_prod]
+  · simp only [norm_tripleSpaceEquiv]
+    have he (p : ℝ × (ℝ × ℝ)) : tripleSpaceEquiv p 0 = p.1 := by
+      rw [tripleSpaceEquiv_apply]; rfl
+    simp_rw [he]
+    exact axisymmetric_lintegral F hF
+  · have hm : Measurable (fun x : Space => F (‖x‖, x 0)) :=
+      hF.comp (measurable_norm.prodMk (PiLp.continuous_apply 2 (fun _ : Fin 3 => ℝ) 0).measurable)
+    exact (hm.comp tripleSpaceEquiv.measurable).aemeasurable
+
+lemma angular_coulomb_integral {r s : ℝ} (hr : 0 < r) (hs : 0 < s) :
+    (1/2:ℝ) * (∫ u in (-1:ℝ)..1, (r^2+s^2-2*r*s*u)^(-(1/2):ℝ)) = (max r s)⁻¹ := by
+  have H := intervalIntegral.mul_integral_comp_sub_mul (f := fun x : ℝ => x^(-(1/2):ℝ))
+    (a := -1) (b := 1) (2*r*s) (r^2+s^2)
+  have h1 : r^2+s^2-(2*r*s)*1 = (r-s)^2 := by ring
+  have h2 : r^2+s^2-(2*r*s)*(-1) = (r+s)^2 := by ring
+  rw [h1, h2, integral_rpow (Or.inl (by norm_num : (-1:ℝ) < -(1/2)))] at H
+  norm_num only [show (-(1/2):ℝ)+1 = 1/2 by norm_num] at H
+  simp_rw [← Real.sqrt_eq_rpow, Real.sqrt_sq_eq_abs] at H
+  rw [abs_of_pos (add_pos hr hs)] at H
+  rcases le_total r s with h | h
+  · rw [max_eq_right h, abs_of_nonpos (sub_nonpos.mpr h)] at *
+    field_simp
+    nlinarith
+  · rw [max_eq_left h, abs_of_nonneg (sub_nonneg.mpr h)] at *
+    field_simp
+    nlinarith
+
+lemma affine_halfpower_intervalIntegrable (d c a b : ℝ) (hc : c ≠ 0) :
+    IntervalIntegrable (fun z => (d-c*z)^(-(1/2):ℝ)) volume a b := by
+  have H := ((intervalIntegral.intervalIntegrable_rpow'
+    (a:=d-c*a) (b:=d-c*b) (by norm_num : (-1:ℝ) < -(1/2))).comp_sub_left d).comp_mul_left (c:=c)
+  convert H using 1 <;> field_simp <;> ring
+
+lemma meridian_coulomb_integral {r s : ℝ} (hr : 0 < r) (hs : 0 < s) :
+    (∫ z in (-s)..s, (r^2+s^2-2*r*z)^(-(1/2):ℝ)) = 2*s*(max r s)⁻¹ := by
+  have H := intervalIntegral.integral_comp_mul_left (a:=(-1:ℝ)) (b:=1)
+    (c:=s) (fun z => (r^2+s^2-2*r*z)^(-(1/2):ℝ)) hs.ne'
+  have he (u : ℝ) : r^2+s^2-2*r*(s*u) = r^2+s^2-2*r*s*u := by ring
+  simp_rw [he] at H
+  simp only [mul_neg_one, mul_one, smul_eq_mul] at H
+  have A := angular_coulomb_integral hr hs
+  rw [H] at A
+  have hsi : s*s⁻¹ = 1 := mul_inv_cancel₀ hs.ne'
+  calc
+    _ = s * (s⁻¹ * ∫ z in (-s)..s, (r^2+s^2-2*r*z)^(-(1/2):ℝ)) := by rw [← mul_assoc, hsi, one_mul]
+    _ = _ := by nlinarith
+
+lemma meridian_coulomb_lintegral {r s : ℝ} (hr : 0 < r) (hs : 0 < s) :
+    (∫⁻ z in Ioo (-s) s, ENNReal.ofReal ((r^2+s^2-2*r*z)^(-(1/2):ℝ))) =
+      ENNReal.ofReal (2*s*(max r s)⁻¹) := by
+  have hab : -s ≤ s := by linarith
+  have hi := (intervalIntegrable_iff_integrableOn_Ioo_of_le hab).mp
+    (affine_halfpower_intervalIntegrable (r^2+s^2) (2*r) (-s) s (by positivity))
+  rw [← ofReal_integral_eq_lintegral_ofReal hi]
+  · rw [setIntegral_congr_set Ioo_ae_eq_Ioc, ← intervalIntegral.integral_of_le hab,
+      meridian_coulomb_integral hr hs]
+  · filter_upwards [ae_restrict_mem measurableSet_Ioo] with z hz
+    exact Real.rpow_nonneg (by nlinarith [sq_nonneg (r-s), hz.2]) _
+
+lemma norm_axis_sub_rpow (r : ℝ) (x : Space) :
+    ‖EuclideanSpace.single 0 r - x‖⁻¹ =
+      (r^2+‖x‖^2-2*r*x 0)^(-(1/2):ℝ) := by
+  have he : ‖EuclideanSpace.single 0 r - x‖^2 = r^2+‖x‖^2-2*r*x 0 := by
+    rw [norm_sub_sq_real]
+    simp [EuclideanSpace.inner_single_left, Real.norm_eq_abs, sq_abs]
+    ring
+  rw [← he, Real.rpow_neg (sq_nonneg _) (1/2:ℝ), ← Real.sqrt_eq_rpow,
+    Real.sqrt_sq (norm_nonneg _)]
+
+lemma radial_axis_coulomb_lintegral (F : ℝ → ℝ≥0∞) (hF : Measurable F)
+    {r : ℝ} (hr : 0 < r) :
+    (∫⁻ x : Space, ENNReal.ofReal ‖EuclideanSpace.single 0 r-x‖⁻¹ * F ‖x‖) =
+      ENNReal.ofReal (4*Real.pi) *
+        ∫⁻ s in Ioi (0:ℝ), ENNReal.ofReal (s^2*(max r s)⁻¹) * F s := by
+  simp_rw [norm_axis_sub_rpow]
+  have hm : Measurable (fun p : ℝ × ℝ =>
+      ENNReal.ofReal ((r^2+p.1^2-2*r*p.2)^(-(1/2):ℝ)) * F p.1) := by fun_prop
+  rw [axisymmetric_space_lintegral _ hm, meridian_lintegral_iterated _ hm]
+  have he (s : ℝ) (hs : s ∈ Ioi (0:ℝ)) :
+      (∫⁻ z in Ioo (-s) s, ENNReal.ofReal s *
+        (ENNReal.ofReal ((r^2+s^2-2*r*z)^(-(1/2):ℝ)) * F s)) =
+      ENNReal.ofReal 2 * (ENNReal.ofReal (s^2*(max r s)⁻¹) * F s) := by
+    change 0 < s at hs
+    rw [lintegral_const_mul _ (by fun_prop), lintegral_mul_const _ (by fun_prop),
+      meridian_coulomb_lintegral hr hs]
+    calc
+      _ = ENNReal.ofReal (s*(2*s*(max r s)⁻¹))*F s := by
+        rw [← mul_assoc, ← ENNReal.ofReal_mul hs.le]
+      _ = ENNReal.ofReal (2*(s^2*(max r s)⁻¹))*F s := by congr 2; ring
+      _ = _ := by rw [ENNReal.ofReal_mul (by norm_num : (0:ℝ) ≤ 2), mul_assoc]
+  rw [setLIntegral_congr_fun measurableSet_Ioi he, lintegral_const_mul _ (by fun_prop),
+    ← mul_assoc, ← ENNReal.ofReal_mul (by positivity)]
+  congr 2
+  ring
+
+lemma radial_space_lintegral (F : ℝ → ℝ≥0∞) (hF : Measurable F) :
+    (∫⁻ x : Space, F ‖x‖) = ENNReal.ofReal (4*Real.pi) *
+      ∫⁻ s in Ioi (0:ℝ), ENNReal.ofReal (s^2) * F s := by
+  have hm : Measurable (fun p : ℝ × ℝ => F p.1) := hF.comp measurable_fst
+  rw [axisymmetric_space_lintegral _ hm, meridian_lintegral_iterated _ hm]
+  have he (s : ℝ) (hs : s ∈ Ioi (0:ℝ)) :
+      (∫⁻ z in Ioo (-s) s, ENNReal.ofReal s * F s) =
+      ENNReal.ofReal 2 * (ENNReal.ofReal (s^2) * F s) := by
+    change 0 < s at hs
+    simp only [lintegral_const, Measure.restrict_apply_univ, Real.volume_Ioo]
+    rw [show s- -s = 2*s by ring, mul_comm (ENNReal.ofReal s * F s),
+      ← mul_assoc, ← ENNReal.ofReal_mul (by positivity), ← mul_assoc,
+      ← ENNReal.ofReal_mul (by norm_num)]
+    congr 2
+    ring
+  rw [setLIntegral_congr_fun measurableSet_Ioi he, lintegral_const_mul _ (by fun_prop),
+    ← mul_assoc, ← ENNReal.ofReal_mul (by positivity)]
+  congr 2
+  ring
+
+lemma radial_coulomb_lintegral (F : ℝ → ℝ≥0∞) (hF : Measurable F)
+    {x : Space} (hx : x ≠ 0) :
+    (∫⁻ y : Space, ENNReal.ofReal ‖x-y‖⁻¹ * F ‖y‖) =
+      ENNReal.ofReal (4*Real.pi) *
+        ∫⁻ s in Ioi (0:ℝ), ENNReal.ofReal (s^2*(max ‖x‖ s)⁻¹) * F s := by
+  let v : Space := EuclideanSpace.single 0 ‖x‖
+  let E := (ℝ ∙ (v-x))ᗮ.reflection
+  have hv : ‖v‖ = ‖x‖ := by simp [v]
+  have hE : E v = x := Submodule.reflection_sub hv
+  calc
+    _ = ∫⁻ y : Space, ENNReal.ofReal ‖x-E y‖⁻¹ * F ‖E y‖ :=
+      (E.measurePreserving.lintegral_comp_emb E.toHomeomorph.measurableEmbedding _).symm
+    _ = ∫⁻ y : Space, ENNReal.ofReal ‖v-y‖⁻¹ * F ‖y‖ := by
+      apply lintegral_congr
+      intro y
+      rw [← hE, ← E.map_sub, E.norm_map, E.norm_map]
+    _ = _ := radial_axis_coulomb_lintegral F hF (norm_pos_iff.mpr hx)
+
+lemma radial_coulomb_lintegral_le (F : ℝ → ℝ≥0∞) (hF : Measurable F)
+    {x : Space} (hx : x ≠ 0) :
+    (∫⁻ y : Space, ENNReal.ofReal ‖x-y‖⁻¹ * F ‖y‖) ≤
+      ENNReal.ofReal ‖x‖⁻¹ * ∫⁻ y : Space, F ‖y‖ := by
+  calc
+    _ = ENNReal.ofReal (4*Real.pi) *
+        ∫⁻ s in Ioi (0:ℝ), ENNReal.ofReal (s^2*(max ‖x‖ s)⁻¹) * F s :=
+      radial_coulomb_lintegral F hF hx
+    _ ≤ ENNReal.ofReal (4*Real.pi) *
+        ∫⁻ s in Ioi (0:ℝ), ENNReal.ofReal (‖x‖⁻¹*s^2) * F s := by
+      apply mul_le_mul_right
+      apply setLIntegral_mono' measurableSet_Ioi
+      intro s _
+      apply mul_le_mul_left
+      apply ENNReal.ofReal_le_ofReal
+      nlinarith [mul_le_mul_of_nonneg_left
+        (inv_anti₀ (norm_pos_iff.mpr hx) (le_max_left ‖x‖ s)) (sq_nonneg s)]
+    _ = _ := by
+      rw [radial_space_lintegral F hF]
+      simp_rw [ENNReal.ofReal_mul (inv_nonneg.mpr (norm_nonneg x)), mul_assoc]
+      rw [lintegral_const_mul _ (by fun_prop)]
+      ac_rfl
+
+lemma radial_coulomb_lintegral_eq (F : ℝ → ℝ≥0∞) (hF : Measurable F)
+    {R : ℝ} (hFR : ∀ s, R < s → F s = 0)
+    {x : Space} (hx : x ≠ 0) (hRx : R ≤ ‖x‖) :
+    (∫⁻ y : Space, ENNReal.ofReal ‖x-y‖⁻¹ * F ‖y‖) =
+      ENNReal.ofReal ‖x‖⁻¹ * ∫⁻ y : Space, F ‖y‖ := by
+  calc
+    _ = ENNReal.ofReal (4*Real.pi) *
+        ∫⁻ s in Ioi (0:ℝ), ENNReal.ofReal (s^2*(max ‖x‖ s)⁻¹) * F s :=
+      radial_coulomb_lintegral F hF hx
+    _ = ENNReal.ofReal (4*Real.pi) *
+        ∫⁻ s in Ioi (0:ℝ), ENNReal.ofReal (‖x‖⁻¹*s^2) * F s := by
+      congr 1
+      apply setLIntegral_congr_fun measurableSet_Ioi
+      intro s _
+      dsimp only
+      by_cases hs : R < s
+      · simp [hFR s hs]
+      · rw [max_eq_left ((le_of_not_gt hs).trans hRx), mul_comm (s^2)]
+    _ = _ := by
+      rw [radial_space_lintegral F hF]
+      simp_rw [ENNReal.ofReal_mul (inv_nonneg.mpr (norm_nonneg x)), mul_assoc]
+      rw [lintegral_const_mul _ (by fun_prop)]
+      ac_rfl
+
+lemma space_axis_continuous : Continuous (fun s : ℝ => (EuclideanSpace.single (0 : Fin 3) s : Space)) := by
+  apply (PiLp.continuous_toLp 2 (fun _ : Fin 3 => ℝ)).comp
+  apply continuous_pi
+  intro i
+  simp only [Pi.single_apply]
+  split <;> fun_prop
+
+lemma radial_coulomb_integral_le {f : Space → ℝ} (hf : Integrable f)
+    (hm : Measurable f) (hf0 : ∀ y, 0 ≤ f y) {M : ℝ} (hfM : ∀ y, f y ≤ M)
+    (hrad : ∀ y, f y = f (EuclideanSpace.single 0 ‖y‖))
+    {x : Space} (hx : x ≠ 0) :
+    (∫ y, coulombKernel (x-y) * f y) ≤ coulombKernel x * ∫ y, f y := by
+  let F : ℝ → ℝ≥0∞ := fun s => ENNReal.ofReal (f (EuclideanSpace.single 0 s))
+  have hmF : Measurable F := (hm.comp space_axis_continuous.measurable).ennreal_ofReal
+  have he (y : Space) : F ‖y‖ = ENNReal.ofReal (f y) := congrArg ENNReal.ofReal (hrad y).symm
+  have H := radial_coulomb_lintegral_le F hmF hx
+  simp_rw [he] at H
+  have hi := coulomb_convolution_integrable hf hm hf0 hfM (by norm_num : (0:ℝ) < 1) x
+  have hp (y : Space) : 0 ≤ coulombKernel (x-y)*f y := mul_nonneg (coulombKernel_nonneg _) (hf0 _)
+  have hI := ofReal_integral_eq_lintegral_ofReal hi (Filter.Eventually.of_forall hp)
+  have hmass := ofReal_integral_eq_lintegral_ofReal hf (Filter.Eventually.of_forall hf0)
+  simp_rw [ENNReal.ofReal_mul (coulombKernel_nonneg _)] at hI
+  change ENNReal.ofReal (∫ y, coulombKernel (x-y)*f y) =
+    ∫⁻ y, ENNReal.ofReal ‖x-y‖⁻¹*ENNReal.ofReal (f y) at hI
+  rw [← hI, ← hmass, ← ENNReal.ofReal_mul (inv_nonneg.mpr (norm_nonneg _))] at H
+  exact (ENNReal.ofReal_le_ofReal_iff (mul_nonneg (coulombKernel_nonneg x) (integral_nonneg hf0))).mp H
+
+lemma radial_coulomb_integral_eq {f : Space → ℝ} (hf : Integrable f)
+    (hm : Measurable f) (hf0 : ∀ y, 0 ≤ f y) {M : ℝ} (hfM : ∀ y, f y ≤ M)
+    (hrad : ∀ y, f y = f (EuclideanSpace.single 0 ‖y‖))
+    {R : ℝ} (hR : 0 ≤ R) (hfs : ∀ y, R < ‖y‖ → f y = 0)
+    {x : Space} (hx : x ≠ 0) (hRx : R ≤ ‖x‖) :
+    (∫ y, coulombKernel (x-y) * f y) = coulombKernel x * ∫ y, f y := by
+  let F : ℝ → ℝ≥0∞ := fun s => ENNReal.ofReal (f (EuclideanSpace.single 0 s))
+  have hmF : Measurable F := (hm.comp space_axis_continuous.measurable).ennreal_ofReal
+  have he (y : Space) : F ‖y‖ = ENNReal.ofReal (f y) := congrArg ENNReal.ofReal (hrad y).symm
+  have hs : ∀ s, R < s → F s = 0 := by
+    intro s hs
+    have hsp : 0 < s := hR.trans_lt hs
+    have h := hfs (EuclideanSpace.single 0 s) (by simpa [Real.norm_eq_abs, abs_of_pos hsp] using hs)
+    simp only [F, h, ENNReal.ofReal_zero]
+  have H := radial_coulomb_lintegral_eq F hmF hs hx hRx
+  simp_rw [he] at H
+  have hi := coulomb_convolution_integrable hf hm hf0 hfM (by norm_num : (0:ℝ) < 1) x
+  have hp (y : Space) : 0 ≤ coulombKernel (x-y)*f y := mul_nonneg (coulombKernel_nonneg _) (hf0 _)
+  have hI := ofReal_integral_eq_lintegral_ofReal hi (Filter.Eventually.of_forall hp)
+  have hmass := ofReal_integral_eq_lintegral_ofReal hf (Filter.Eventually.of_forall hf0)
+  simp_rw [ENNReal.ofReal_mul (coulombKernel_nonneg _)] at hI
+  change ENNReal.ofReal (∫ y, coulombKernel (x-y)*f y) =
+    ∫⁻ y, ENNReal.ofReal ‖x-y‖⁻¹*ENNReal.ofReal (f y) at hI
+  rw [← hI, ← hmass, ← ENNReal.ofReal_mul (inv_nonneg.mpr (norm_nonneg _))] at H
+  change ENNReal.ofReal (∫ y, coulombKernel (x-y)*f y) =
+    ENNReal.ofReal (coulombKernel x * ∫ y, f y) at H
+  have H' := congrArg ENNReal.toReal H
+  simpa only [ENNReal.toReal_ofReal (integral_nonneg hp),
+    ENNReal.toReal_ofReal (mul_nonneg (coulombKernel_nonneg x) (integral_nonneg hf0))] using H'
+
+end Coulomb
+
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Classical SchwartzMap Pointwise
+
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/MinimizerMidpointControl.lean

@@ -0,0 +1,83 @@
+import Mathlib
+
+namespace OAI
+
+section
+section
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+namespace Coulomb
+lemma exists_minimizer_of_midpoint_control {E : Type*} [NormedAddCommGroup E]
+    [NormedSpace ℝ E] [CompleteSpace E] {S : Set E} (hS : IsClosed S) (hne : S.Nonempty)
+    (hm : ∀ f ∈ S, ∀ g ∈ S, (1/2:ℝ) • (f+g) ∈ S)
+    {J : E → ℝ} (hJ : Continuous J) (hb : BddBelow (J '' S))
+    (hconv : ∀ f ∈ S, ∀ g ∈ S, J ((1/2:ℝ) • (f+g)) ≤ (J f+J g)/2)
+    (hR : ∀ a : ℝ, ∃ R : ℝ, 0 < R ∧ ∀ f ∈ S, J f ≤ a → ‖f‖ ≤ R)
+    (hgap : ∀ R : ℝ, 0 < R → ∃ C : ℝ, 0 < C ∧
+      ∀ f ∈ S, ∀ g ∈ S, ‖f‖ ≤ R → ‖g‖ ≤ R →
+        ‖f-g‖^(5/3:ℝ) ≤ C * ((J f+J g)/2 - J ((1/2:ℝ) • (f+g)))^(5/6:ℝ)) :
+    ∃ f ∈ S, ∀ g ∈ S, J f ≤ J g := by
+  let I := sInf (J '' S)
+  obtain ⟨u, hu, hulim, huS⟩ := exists_seq_tendsto_sInf (hne.image J) hb
+  choose f hfS hfu using huS
+  obtain ⟨R,hR0,hRb⟩ := hR (u 0)
+  have hfR (n : ℕ) : ‖f n‖ ≤ R := hRb _ (hfS n) (by rw [hfu]; exact hu (Nat.zero_le n))
+  obtain ⟨C,hC,hCb⟩ := hgap R hR0
+  have hlow {g : E} (hg : g ∈ S) : I ≤ J g := csInf_le hb ⟨g,hg,rfl⟩
+  have huI (n : ℕ) : 0 ≤ u n-I := by have := hlow (hfS n); rw [hfu] at this; linarith
+  have hwlim : Tendsto (fun n => C*(u n-I)^(5/6:ℝ)) atTop (𝓝 0) := by
+    have hl : Tendsto (fun n => u n-I) atTop (𝓝 (0:ℝ)) := by
+      simpa only [I,sub_self] using hulim.sub_const I
+    have hlr := hl.rpow_const (p := (5/6:ℝ)) (Or.inr (by norm_num))
+    simpa using hlr.const_mul C
+  have hcauchy : CauchySeq f := by
+    rw [Metric.cauchySeq_iff]
+    intro ε hε
+    have hεp : 0 < ε^(5/3:ℝ) := Real.rpow_pos_of_pos hε _
+    obtain ⟨N,hN⟩ := eventually_atTop.mp (hwlim.eventually (gt_mem_nhds hεp))
+    refine ⟨N,fun m hm' n hn' => ?_⟩
+    have hmid := hlow (hm _ (hfS m) _ (hfS n))
+    have hg0 : 0 ≤ (J (f m)+J (f n))/2-J ((1/2:ℝ) • (f m+f n)) := by
+      exact sub_nonneg.mpr (hconv _ (hfS m) _ (hfS n))
+    have hgup : (J (f m)+J (f n))/2-J ((1/2:ℝ) • (f m+f n)) ≤ u N-I := by
+      have hum := hu hm'
+      have hun := hu hn'
+      rw [← hfu m] at hum
+      rw [← hfu n] at hun
+      linarith
+    have H := (hCb _ (hfS m) _ (hfS n) (hfR m) (hfR n)).trans
+      (mul_le_mul_of_nonneg_left (Real.rpow_le_rpow hg0 hgup (by norm_num : (0:ℝ)≤5/6)) hC.le)
+    have Hlt := H.trans_lt (hN N le_rfl)
+    have hd : ‖f m-f n‖ < ε := (Real.rpow_lt_rpow_iff (norm_nonneg _) hε.le (by norm_num : (0:ℝ)<5/3)).mp Hlt
+    simpa only [dist_eq_norm] using hd
+  obtain ⟨g,hg⟩ := cauchySeq_tendsto_of_complete hcauchy
+  have hgS : g ∈ S := hS.mem_of_tendsto hg (Eventually.of_forall hfS)
+  have hJI : J g = I := by
+    apply tendsto_nhds_unique (hJ.continuousAt.tendsto.comp hg)
+    simpa only [Function.comp_def,hfu] using hulim
+  exact ⟨g,hgS,fun x hx => by rw [hJI]; exact hlow hx⟩
+end Coulomb
+
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+
+end
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/ModulatedRealDerivativeNorm.lean

@@ -0,0 +1,113 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.FieldAnalysis.Space
+
+namespace OAI
+
+noncomputable section
+
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set
+open scoped BigOperators ENNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open scoped Classical
+open scoped BigOperators ComplexConjugate
+open scoped Classical
+open scoped Classical
+open MeasureTheory Set Filter
+open scoped Classical ENNReal NNReal ComplexConjugate
+open MeasureTheory Set Filter Module Module.End TopologicalSpace Function
+open scoped Classical ComplexConjugate
+open MeasureTheory Set Filter Module Module.End TopologicalSpace Function
+open scoped Classical ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Filter
+open scoped ENNReal NNReal FourierTransform SchwartzMap LineDeriv ComplexConjugate
+open scoped LineDeriv
+namespace Coulomb
+lemma modulated_real_derivative_norm (G : Space → ℝ) (hG : Differentiable ℝ G)
+    (y p x a : Space) :
+    ‖fderiv ℝ (fun z : Space => Complex.exp ((2*Real.pi*inner ℝ z p : ℝ)*Complex.I) *
+      (G (z-y) : ℂ)) x a‖^2 =
+      (2*Real.pi*inner ℝ a p)^2 * G (x-y)^2 + (fderiv ℝ G (x-y) a)^2 := by
+  have hθ := ((Complex.ofRealCLM.hasFDerivAt.comp x
+    (((innerSL ℝ).flip p).hasFDerivAt.const_mul (2*Real.pi)))).mul_const Complex.I
+  have hq := Complex.ofRealCLM.hasFDerivAt.comp x
+    ((hG (x-y)).hasFDerivAt.comp x ((hasFDerivAt_id x).sub_const y))
+  have H := congrArg (fun L : Space →L[ℝ] ℂ => L a) (hθ.cexp.mul hq).fderiv
+  have hd : fderiv ℝ (fun z : Space => Complex.exp ((2*Real.pi*inner ℝ z p : ℝ)*Complex.I) *
+      (G (z-y) : ℂ)) x a =
+      Complex.exp ((2*Real.pi*inner ℝ x p : ℝ)*Complex.I) *
+        ((fderiv ℝ G (x-y) a : ℂ) + (2*Real.pi*inner ℝ a p*G (x-y) : ℝ)*Complex.I) := by
+    calc
+      _ = _ := H
+      _ = _ := by
+        simp only [add_apply, smul_apply,
+          ContinuousLinearMap.comp_apply, Function.comp_apply, id_eq,
+          ContinuousLinearMap.id_apply,
+          Complex.ofRealCLM_apply, ContinuousLinearMap.flip_apply, innerSL_apply_apply,
+          smul_eq_mul, Complex.ofReal_mul, Complex.ofReal_ofNat]
+        ring
+  rw [hd, norm_mul, Complex.norm_exp]
+  simp only [Complex.mul_re, Complex.ofReal_re, Complex.I_im, mul_one,
+    Complex.ofReal_im, Complex.I_re, mul_zero, sub_zero, Real.exp_zero, one_mul]
+  rw [Complex.sq_norm]
+  simp [Complex.normSq_apply]
+  ring
+end Coulomb
+
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/NearCoulombFiveHalves.lean

@@ -0,0 +1,211 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.Localization.TruncatedCoulomb
+
+namespace OAI
+
+noncomputable section
+
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set
+open scoped BigOperators ENNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open scoped Classical
+open scoped BigOperators ComplexConjugate
+open scoped Classical
+open scoped Classical
+open MeasureTheory Set Filter
+open scoped Classical ENNReal NNReal ComplexConjugate
+open MeasureTheory Set Filter Module Module.End TopologicalSpace Function
+open scoped Classical ComplexConjugate
+open MeasureTheory Set Filter Module Module.End TopologicalSpace Function
+open scoped Classical ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Filter
+open scoped ENNReal NNReal FourierTransform SchwartzMap LineDeriv ComplexConjugate
+open scoped LineDeriv
+open MeasureTheory Set Metric
+open scoped ENNReal NNReal RealInnerProductSpace
+open MeasureTheory Set Metric Filter
+open scoped ENNReal NNReal RealInnerProductSpace Convolution
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open MeasureTheory Set Filter
+open scoped Classical SchwartzMap FourierTransform ENNReal NNReal ComplexConjugate Pointwise
+open MeasureTheory Set Filter
+open scoped Classical SchwartzMap FourierTransform ENNReal NNReal Pointwise
+open MeasureTheory Set Filter
+open scoped Classical SchwartzMap FourierTransform ENNReal NNReal Pointwise
+open MeasureTheory Set Filter
+open scoped Classical SchwartzMap ENNReal NNReal Pointwise
+open MeasureTheory Set Filter
+open scoped Classical SchwartzMap FourierTransform ENNReal NNReal Pointwise
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Classical SchwartzMap Pointwise
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Classical SchwartzMap Pointwise
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Classical SchwartzMap Pointwise
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Classical SchwartzMap Pointwise
+namespace Coulomb
+
+lemma density_memLp_fiveThirds (ρ : Space → ℝ) (hp : ∀ x, 0 ≤ ρ x) (hm : Measurable ρ)
+    (ht : Integrable (fun x => ρ x^(5/3:ℝ))) : MemLp ρ (5/3:ℝ≥0∞) := by
+  apply (integrable_norm_rpow_iff hm.aestronglyMeasurable (by norm_num : (5/3:ℝ≥0∞) ≠ 0)
+    (ENNReal.div_ne_top (by norm_num) (by norm_num) : (5/3:ℝ≥0∞) ≠ ⊤)).mp
+  simpa only [ENNReal.toReal_div,ENNReal.toReal_ofNat,Real.norm_of_nonneg (hp _)] using ht
+
+lemma compact_density_integrable (ρ : Space → ℝ) (hp : ∀ x, 0 ≤ ρ x) (hm : Measurable ρ)
+    (ht : Integrable (fun x => ρ x^(5/3:ℝ))) (K : Set Space) (hK : IsCompact K)
+    (hs : ∀ x, x ∉ K → ρ x = 0) : Integrable ρ := by
+  let : IsFiniteMeasure (volume.restrict K) := isFiniteMeasure_restrict.mpr hK.measure_lt_top.ne
+  have hLp : MemLp ρ (5/3:ℝ≥0∞) (volume.restrict K) :=
+    (density_memLp_fiveThirds ρ hp hm ht).mono_measure Measure.restrict_le_self
+  have hI := hLp.integrable (by
+    rw [ENNReal.le_div_iff_mul_le (Or.inl (by norm_num)) (Or.inl (by norm_num))]
+    norm_num : (1:ℝ≥0∞) ≤ 5/3)
+  exact IntegrableOn.integrable_of_forall_notMem_eq_zero hI hs
+
+noncomputable def nearCoulombFiveHalves (x : Space) : ℝ :=
+  (Metric.ball (0:Space) 1).indicator (fun y => coulombKernel y^(5/2:ℝ)) x
+
+lemma nearCoulombFiveHalves_integrable : Integrable nearCoulombFiveHalves := by
+  apply IntegrableOn.integrable_indicator _ measurableSet_ball
+  apply integrableOn_ball_of_norm_le_rpow (C := 1) (α := 5/2) (by simp [Space]) (by norm_num [Space])
+  · filter_upwards [] with x
+    rw [Real.norm_of_nonneg (Real.rpow_nonneg (coulombKernel_nonneg x) _),one_mul]
+    change (‖x‖⁻¹)^(5/2:ℝ) ≤ ‖x‖^(-(5/2:ℝ))
+    rw [Real.inv_rpow (norm_nonneg x),Real.rpow_neg (norm_nonneg x)]
+  · exact (coulombKernel_measurable.pow_const _).aestronglyMeasurable
+
+lemma nearCoulombFiveHalves_nonneg (x : Space) : 0 ≤ nearCoulombFiveHalves x :=
+  Set.indicator_nonneg (fun y _ => Real.rpow_nonneg (coulombKernel_nonneg y) _) x
+
+lemma density_coulomb_integrand_bound (ρ : Space → ℝ) (hp : ∀ x, 0 ≤ ρ x) (x y : Space) :
+    coulombKernel (x-y)*ρ y ≤ nearCoulombFiveHalves (x-y) + ρ y^(5/3:ℝ) + ρ y := by
+  by_cases h : x-y ∈ Metric.ball (0:Space) 1
+  · rw [nearCoulombFiveHalves,Set.indicator_of_mem h]
+    have HY := Real.young_inequality_of_nonneg (coulombKernel_nonneg (x-y)) (hp y)
+      (show (5/2:ℝ).HolderConjugate (5/3:ℝ) from ⟨by norm_num,by norm_num,by norm_num⟩)
+    have H1 := Real.rpow_nonneg (coulombKernel_nonneg (x-y)) (5/2:ℝ)
+    have H2 := Real.rpow_nonneg (hp y) (5/3:ℝ)
+    linarith [hp y]
+  · rw [nearCoulombFiveHalves,Set.indicator_of_notMem h,zero_add]
+    have hn : (1:ℝ) ≤ ‖x-y‖ := by simpa [Metric.mem_ball,dist_zero_right] using h
+    have hk : coulombKernel (x-y) ≤ 1 := by simpa [coulombKernel] using inv_anti₀ (by norm_num : (0:ℝ)<1) hn
+    have H := mul_le_mul_of_nonneg_right hk (hp y)
+    linarith [Real.rpow_nonneg (hp y) (5/3:ℝ)]
+
+lemma density_coulomb_integrable (ρ : Space → ℝ) (hp : ∀ x, 0 ≤ ρ x) (hm : Measurable ρ)
+    (hi : Integrable ρ) (ht : Integrable (fun x => ρ x^(5/3:ℝ))) (x : Space) :
+    Integrable (fun y => coulombKernel (x-y)*ρ y) := by
+  apply (((nearCoulombFiveHalves_integrable.comp_sub_left x).add ht).add hi).mono'
+    (((coulombKernel_measurable.comp (measurable_const.sub measurable_id)).mul hm).aestronglyMeasurable)
+  filter_upwards [] with y
+  change ‖coulombKernel (x-y)*ρ y‖ ≤ nearCoulombFiveHalves (x-y) + ρ y^(5/3:ℝ) + ρ y
+  rw [Real.norm_of_nonneg (mul_nonneg (coulombKernel_nonneg _) (hp y))]
+  exact density_coulomb_integrand_bound ρ hp x y
+
+lemma density_coulomb_bound (ρ : Space → ℝ) (hp : ∀ x, 0 ≤ ρ x) (hm : Measurable ρ)
+    (hi : Integrable ρ) (ht : Integrable (fun x => ρ x^(5/3:ℝ))) (x : Space) :
+    (∫ y, coulombKernel (x-y)*ρ y) ≤
+      (∫ y, nearCoulombFiveHalves y) + (∫ y, ρ y^(5/3:ℝ)) + ∫ y, ρ y := by
+  calc
+    _ ≤ ∫ y, nearCoulombFiveHalves (x-y) + ρ y^(5/3:ℝ) + ρ y :=
+      integral_mono (density_coulomb_integrable ρ hp hm hi ht x)
+        (((nearCoulombFiveHalves_integrable.comp_sub_left x).add ht).add hi)
+        (density_coulomb_integrand_bound ρ hp x)
+    _ = _ := by
+      have HA := integral_add ((nearCoulombFiveHalves_integrable.comp_sub_left x).add ht) hi
+      have HB := integral_add (nearCoulombFiveHalves_integrable.comp_sub_left x) ht
+      simp only [Pi.add_apply] at HA HB
+      rw [HA,HB,integral_sub_left_eq_self]
+
+lemma density_coulomb_pair_integrable (ρ : Space → ℝ) (hp : ∀ x, 0 ≤ ρ x) (hm : Measurable ρ)
+    (hi : Integrable ρ) (ht : Integrable (fun x => ρ x^(5/3:ℝ))) :
+    Integrable (fun xy : Space × Space => coulombKernel (xy.1-xy.2)*(ρ xy.1*ρ xy.2)) := by
+  have hm' : Measurable (fun xy : Space × Space => coulombKernel (xy.1-xy.2)*(ρ xy.1*ρ xy.2)) :=
+    (coulombKernel_measurable.comp (measurable_fst.sub measurable_snd)).mul
+      ((hm.comp measurable_fst).mul (hm.comp measurable_snd))
+  apply (integrable_prod_iff hm'.aestronglyMeasurable).mpr
+  constructor
+  · filter_upwards [] with x
+    apply ((density_coulomb_integrable ρ hp hm hi ht x).const_mul (ρ x)).congr
+    filter_upwards [] with y
+    ring
+  · let C := (∫ y, nearCoulombFiveHalves y) + (∫ y, ρ y^(5/3:ℝ)) + ∫ y, ρ y
+    apply (hi.mul_const C).mono' hm'.aestronglyMeasurable.norm.integral_prod_right'
+    filter_upwards [] with x
+    rw [Real.norm_of_nonneg (integral_nonneg (fun y => norm_nonneg _))]
+    have he : (∫ y, ‖coulombKernel (x-y)*(ρ x*ρ y)‖) =
+        ρ x*(∫ y, coulombKernel (x-y)*ρ y) := by
+      rw [← integral_const_mul]
+      apply integral_congr_ae
+      filter_upwards [] with y
+      rw [Real.norm_of_nonneg (mul_nonneg (coulombKernel_nonneg _) (mul_nonneg (hp _) (hp _)))]
+      ring
+    rw [he]
+    exact mul_le_mul_of_nonneg_left (density_coulomb_bound ρ hp hm hi ht x) (hp x)
+end Coulomb
+
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Classical SchwartzMap Pointwise
+
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/NewtonInterior.lean

@@ -0,0 +1,179 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.FieldAnalysis.TailClosure
+
+namespace OAI
+
+section
+section
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+noncomputable section
+namespace Coulomb
+
+lemma radial_coulomb_lintegral_inner (F : ℝ → ℝ≥0∞) (hF : Measurable F)
+    {R : ℝ} (hs : ∀ s, s < R → F s=0) {x : Space} (hxR : ‖x‖ ≤ R) :
+    (∫⁻ y : Space, ENNReal.ofReal ‖x-y‖⁻¹*F ‖y‖)=
+      ∫⁻ y : Space, ENNReal.ofReal ‖y‖⁻¹*F ‖y‖ := by
+  by_cases hx : x=0
+  · simp only [hx,zero_sub,norm_neg]
+  rw [radial_coulomb_lintegral F hF hx,
+    radial_space_lintegral (fun s => ENNReal.ofReal s⁻¹*F s) (by fun_prop)]
+  congr 1
+  apply setLIntegral_congr_fun measurableSet_Ioi
+  intro s hs0
+  dsimp only
+  by_cases hR : R ≤ s
+  · rw [max_eq_right (hxR.trans hR),ENNReal.ofReal_mul (sq_nonneg s),mul_assoc]
+  · simp only [hs s (not_le.mp hR),mul_zero]
+
+lemma radial_coulomb_integral_inner {f : Space → ℝ} (hf : Integrable f)
+    (hm : Measurable f) (hf0 : ∀ y, 0 ≤ f y) {M : ℝ} (hfM : ∀ y, f y ≤ M)
+    (hrad : ∀ y, f y=f (EuclideanSpace.single 0 ‖y‖))
+    {R : ℝ} (hfs : ∀ y, ‖y‖ < R → f y=0) {x : Space} (hxR : ‖x‖ ≤ R) :
+    (∫ y, coulombKernel (x-y)*f y)=∫ y, coulombKernel y*f y := by
+  by_cases hx : x=0
+  · simp only [hx,zero_sub,coulombKernel,norm_neg]
+  let F : ℝ → ℝ≥0∞ := fun s => if 0 ≤ s then ENNReal.ofReal (f (EuclideanSpace.single 0 s)) else 0
+  have hmF : Measurable F := Measurable.ite measurableSet_Ici
+    ((hm.comp space_axis_continuous.measurable).ennreal_ofReal) measurable_const
+  have he (y : Space) : F ‖y‖=ENNReal.ofReal (f y) := by
+    simp only [F,ite_eq_left (norm_nonneg y),←hrad y]
+  have hs : ∀ s, s < R → F s=0 := by
+    intro s hs
+    by_cases hs0 : 0 ≤ s
+    · have HH := hfs (EuclideanSpace.single 0 s) (by simpa [Real.norm_eq_abs,abs_of_nonneg hs0] using hs)
+      simp only [F,ite_eq_left hs0,HH,ENNReal.ofReal_zero]
+    · simp only [F,ite_eq_right hs0]
+  have H := radial_coulomb_lintegral_inner F hmF hs hxR
+  simp_rw [he] at H
+  have hi := coulomb_convolution_integrable hf hm hf0 hfM (by norm_num : (0:ℝ) < 1) x
+  have hi0 := coulomb_convolution_integrable hf hm hf0 hfM (by norm_num : (0:ℝ) < 1) 0
+  simp only [zero_sub,coulombKernel,norm_neg] at hi0
+  change Integrable (fun y => coulombKernel y*f y) at hi0
+  have hp (y : Space) : 0 ≤ coulombKernel (x-y)*f y := mul_nonneg (coulombKernel_nonneg _) (hf0 _)
+  have hp0 (y : Space) : 0 ≤ coulombKernel y*f y := mul_nonneg (coulombKernel_nonneg _) (hf0 _)
+  have hI := ofReal_integral_eq_lintegral_ofReal hi (Eventually.of_forall hp)
+  have hI0 := ofReal_integral_eq_lintegral_ofReal hi0 (Eventually.of_forall hp0)
+  simp_rw [ENNReal.ofReal_mul (coulombKernel_nonneg _)] at hI hI0
+  change ENNReal.ofReal (∫ y, coulombKernel (x-y)*f y)=∫⁻ y, ENNReal.ofReal ‖x-y‖⁻¹*ENNReal.ofReal (f y) at hI
+  change ENNReal.ofReal (∫ y, coulombKernel y*f y)=∫⁻ y, ENNReal.ofReal ‖y‖⁻¹*ENNReal.ofReal (f y) at hI0
+  rw [←hI,←hI0] at H
+  have H' := congrArg ENNReal.toReal H
+  simpa only [ENNReal.toReal_ofReal (integral_nonneg hp),ENNReal.toReal_ofReal (integral_nonneg hp0)] using H'
+
+end Coulomb
+end
+
+end
+section
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+noncomputable section
+namespace Coulomb
+
+def radialShell (h : ℝ) : Set Space := Metric.ball 0 (2*h) \ Metric.ball 0 h
+
+def radialShellDensity (h : ℝ) : Space → ℝ := (radialShell h).indicator (fun _ => 1)
+
+lemma measurableSet_radialShell (h : ℝ) : MeasurableSet (radialShell h) :=
+  measurableSet_ball.diff measurableSet_ball
+lemma radialShellDensity_measurable (h : ℝ) : Measurable (radialShellDensity h) :=
+  measurable_const.indicator (measurableSet_radialShell h)
+lemma radialShellDensity_nonneg (h : ℝ) (z : Space) : 0 ≤ radialShellDensity h z :=
+  Set.indicator_nonneg (fun _ _ => zero_le_one) z
+lemma radialShellDensity_le (h : ℝ) (z : Space) : radialShellDensity h z ≤ 1 :=
+  Set.indicator_le_self' (fun _ _ => zero_le_one) z
+lemma radialShellDensity_integrable (h : ℝ) : Integrable (radialShellDensity h) := by
+  apply (integrable_indicator_iff (measurableSet_radialShell h)).mpr
+  exact integrableOn_const (C:=(1:ℝ)) (measure_ne_top_of_subset sdiff_subset measure_ball_lt_top.ne)
+
+lemma radialShellDensity_mass {h : ℝ} (hh : 0 < h) :
+    (∫ z, radialShellDensity h z)=(28*Real.pi/3)*h^3 := by
+  unfold radialShellDensity radialShell
+  rw [integral_indicator (measurableSet_ball.diff measurableSet_ball),integral_const,measureReal_restrict_apply_univ,smul_eq_mul,mul_one,
+    measureReal_sdiff (Metric.ball_subset_ball (by linarith)) measurableSet_ball measure_ball_lt_top.ne,
+    volume_real_ball_three (2*h) (by positivity),volume_real_ball_three h hh.le]
+  ring
+
+lemma radialShellDensity_radial (h : ℝ) (z : Space) :
+    radialShellDensity h z=radialShellDensity h (EuclideanSpace.single 0 ‖z‖) := by
+  simp only [radialShellDensity,radialShell,Set.indicator_apply,Set.mem_sdiff,Metric.mem_ball,dist_zero_right,
+    PiLp.norm_single,Real.norm_eq_abs,abs_of_nonneg (norm_nonneg z)]
+
+lemma radialShellDensity_zero_inner {h : ℝ} {z : Space} (hz : ‖z‖ < h) :
+    radialShellDensity h z=0 := by
+  apply Set.indicator_of_notMem
+  exact fun hmem => hmem.2 (by simpa only [Metric.mem_ball,dist_zero_right] using hz)
+
+lemma radialShell_coulomb_integrable (h : ℝ) (x : Space) :
+    Integrable (fun y => coulombKernel (x-y)*radialShellDensity h y) :=
+  coulomb_convolution_integrable (radialShellDensity_integrable h) (radialShellDensity_measurable h)
+    (radialShellDensity_nonneg h) (radialShellDensity_le h) (by norm_num : (0:ℝ) < 1) x
+
+def radialShellMoment (h : ℝ) : ℝ := ∫ y, coulombKernel y*radialShellDensity h y
+
+lemma radialShellMoment_integrable (h : ℝ) :
+    Integrable (fun y => coulombKernel y*radialShellDensity h y) := by
+  simpa only [zero_sub,coulombKernel,norm_neg] using radialShell_coulomb_integrable h 0
+
+lemma radialShell_coulomb_inner {h : ℝ} {x : Space} (hx : ‖x‖ ≤ h) :
+    (∫ y, coulombKernel (x-y)*radialShellDensity h y)=radialShellMoment h :=
+  radial_coulomb_integral_inner (radialShellDensity_integrable h) (radialShellDensity_measurable h)
+    (radialShellDensity_nonneg h) (radialShellDensity_le h) (radialShellDensity_radial h)
+    (fun _ hz => radialShellDensity_zero_inner hz) hx
+
+lemma radialShellMoment_lower {h : ℝ} (hh : 0 < h) :
+    (∫ y, radialShellDensity h y)/(2*h) ≤ radialShellMoment h := by
+  rw [div_eq_mul_inv,mul_comm,←integral_const_mul]
+  apply integral_mono ((radialShellDensity_integrable h).const_mul _) (radialShellMoment_integrable h)
+  intro y
+  by_cases hy : y∈radialShell h
+  · have hn : ‖y‖ < 2*h := by simpa only [Metric.mem_ball,dist_zero_right] using hy.1
+    have hn0 : 0 < ‖y‖ := by
+      have H : h ≤ ‖y‖ := by simpa only [Metric.mem_ball,dist_zero_right,not_lt] using hy.2
+      exact hh.trans_le H
+    exact mul_le_mul_of_nonneg_right ((inv_le_inv₀ (by positivity) hn0).mpr hn.le) (radialShellDensity_nonneg h y)
+  · simp only [radialShellDensity,indicator_of_notMem hy,mul_zero,le_refl]
+
+lemma radialShellMoment_pos {h : ℝ} (hh : 0 < h) : 0 < radialShellMoment h := by
+  have H := radialShellMoment_lower hh
+  rw [radialShellDensity_mass hh] at H
+  exact lt_of_lt_of_le (by positivity) H
+
+lemma atomicInnerField_shell_average {J n : ℕ} (S : Nuclei J)
+    (hatom : ∀ i, S.position i=0) (ψ : H1Vector n) {h : ℝ} (_ : 0 < h) :
+    (∫ y, atomicInnerField S ψ h y*radialShellDensity h y)=
+      (totalCharge S-expectedPopulation ψ (Metric.ball 0 h))*radialShellMoment h := by
+  have hAttr : Integrable (fun y => attraction S y*radialShellDensity h y) := by
+    simp_rw [attraction_atomic S hatom,div_eq_mul_inv,mul_assoc]
+    exact (radialShellMoment_integrable h).const_mul (totalCharge S)
+  have hCore := restrictedCorePotential_mul_integrable ψ (A:=Metric.ball 0 h) measurableSet_ball _ (radialShellDensity_integrable h)
+  simp only [atomicInnerField,sub_mul]
+  rw [integral_sub hAttr hCore,restrictedCorePotential_fubini ψ measurableSet_ball _ (radialShellDensity_integrable h)]
+  have ha : (∫ y, attraction S y*radialShellDensity h y)=totalCharge S*radialShellMoment h := by
+    simp_rw [attraction_atomic S hatom,div_eq_mul_inv,mul_assoc]
+    exact integral_const_mul _ _
+  rw [ha]
+  have hc : (∑ s : Spins n, ∑ i : Fin n, ∫ x, if position x i∈Metric.ball 0 h then
+      (∫ y, coulombKernel (position x i-y)*radialShellDensity h y)*‖ψ.value s x‖^2 else 0)=
+      expectedPopulation ψ (Metric.ball 0 h)*radialShellMoment h := by
+    rw [expectedPopulation]
+    simp only [Finset.sum_mul,←integral_mul_const]
+    apply Finset.sum_congr rfl; intro s hs
+    apply Finset.sum_congr rfl; intro i hi
+    apply integral_congr_ae
+    filter_upwards [] with x
+    by_cases hx : position x i∈Metric.ball 0 h
+    · have hn : ‖position x i‖ ≤ h := (by simpa only [Metric.mem_ball,dist_zero_right] using hx : ‖position x i‖ < h).le
+      rw [ite_eq_left hx,integral_mul_const,radialShell_coulomb_inner hn,indicator_of_mem hx]
+      ring
+    · simp only [ite_eq_right hx,indicator_of_notMem hx,zero_mul]
+  rw [hc]
+
+end Coulomb
+end
+
+end
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/NewtonSubmean.lean

@@ -0,0 +1,160 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.Packets.CoulombKernel
+import OAI.Analysis.CoulombRadii.FieldAnalysis.FarSubmean
+
+namespace OAI
+
+noncomputable section
+
+section
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical
+namespace Coulomb
+
+lemma ballCloud_coulomb_le {a M : ℝ} (ha : 0<a) (hM : 0≤M) (y x : Space) (hxy : x≠y) :
+    (∫ z, coulombKernel (x-z)*ballCloud y a M z) ≤ M*coulombKernel (x-y) := by
+  have he : (∫ z, coulombKernel (x-z)*ballCloud y a M z) =
+      ∫ z, coulombKernel ((x-y)-z)*uniformBall a M z := by
+    rw [← integral_sub_right_eq_self (fun z => coulombKernel ((x-y)-z)*uniformBall a M z) y]
+    apply integral_congr_ae
+    filter_upwards [] with z
+    change coulombKernel (x-z)*uniformBall a M (z-y) = _
+    rw [show (x-y)-(z-y)=x-z by abel]
+  rw [he]
+  have H := radial_coulomb_integral_le (uniformBall_integrable a M) (uniformBall_measurable a M)
+    (uniformBall_nonneg ha hM) (uniformBall_le ha hM) (uniformBall_radial a M) (sub_ne_zero.mpr hxy)
+  simpa only [uniformBall_mass ha,mul_comm M] using H
+
+lemma potentialOf_ballCloud_integrable {ρ : Space → ℝ} (hi : Integrable ρ) (hm : Measurable ρ)
+    {a : ℝ} (ha : 0<a) (y : Space) :
+    Integrable (fun z => NeutralAtom.potentialOf ρ z*ballCloud y a 1 z) := by
+  have H := (coulomb_pair_integrable hi hm (ballCloud_integrable a 1 y) (ballCloud_measurable a 1 y)
+    (fun z => by
+      change ‖uniformBall a 1 (z-y)‖ ≤ _
+      rw [Real.norm_eq_abs,abs_of_nonneg (uniformBall_nonneg ha zero_le_one (z-y))]
+      exact uniformBall_le ha zero_le_one (z-y))).integral_prod_right
+  apply H.congr
+  filter_upwards [] with z
+  simp only [NeutralAtom.potentialOf,←integral_mul_const]
+  apply integral_congr_ae
+  filter_upwards [] with x
+  change ρ x*ballCloud y a 1 z*coulombKernel (x-z) = coulombKernel (z-x)*ρ x*ballCloud y a 1 z
+  rw [coulombKernel_sub_comm x z]
+  ring
+
+lemma potentialOf_ballCloud_le {ρ : Space → ℝ} (hi : Integrable ρ) (hm : Measurable ρ)
+    (hp : ∀ x, 0≤ρ x) {a : ℝ} (ha : 0<a) (y : Space)
+    (hK : Integrable (fun x => coulombKernel (y-x)*ρ x)) :
+    (∫ z, NeutralAtom.potentialOf ρ z*ballCloud y a 1 z) ≤ NeutralAtom.potentialOf ρ y := by
+  have H := coulomb_pair_integrable hi hm (ballCloud_integrable a 1 y) (ballCloud_measurable a 1 y)
+    (fun z => by
+      change ‖uniformBall a 1 (z-y)‖ ≤ _
+      rw [Real.norm_eq_abs,abs_of_nonneg (uniformBall_nonneg ha zero_le_one (z-y))]
+      exact uniformBall_le ha zero_le_one (z-y))
+  have he : (∫ z, NeutralAtom.potentialOf ρ z*ballCloud y a 1 z) =
+      ∫ x, ∫ z, ρ x*ballCloud y a 1 z*coulombKernel (x-z) := by
+    rw [integral_integral_swap H]
+    apply integral_congr_ae
+    filter_upwards [] with z
+    simp only [NeutralAtom.potentialOf,←integral_mul_const]
+    apply integral_congr_ae
+    filter_upwards [] with x
+    change coulombKernel (z-x)*ρ x*ballCloud y a 1 z = ρ x*ballCloud y a 1 z*coulombKernel (x-z)
+    rw [coulombKernel_sub_comm z x]
+    ring
+  rw [he]
+  apply integral_mono_ae H.integral_prod_left hK
+  filter_upwards [volume.ae_ne y] with x hxy
+  have hh := mul_le_mul_of_nonneg_left (ballCloud_coulomb_le ha zero_le_one y x hxy) (hp x)
+  simpa only [←integral_const_mul,one_mul,coulombKernel_sub_comm y x,mul_left_comm,mul_comm,mul_assoc] using hh
+
+lemma screenedPotential_ballCloud_submean {J k : ℕ} (S : Nuclei J) (u : H1Vector k)
+    {A : Set Space} (hu : SpatiallySupported u A)
+    {ρ : Space → ℝ} (hi : Integrable ρ) (hm : Measurable ρ) (hp : ∀ x, 0≤ρ x)
+    {a : ℝ} (ha : 0<a) (y : Space)
+    (hcore : ∀ z ∈ A, a≤‖z-y‖) (hnuc : ∀ j, a≤‖S.position j-y‖)
+    (hK : Integrable (fun x => coulombKernel (y-x)*ρ x)) :
+    coreScreenedField S u y-NeutralAtom.potentialOf ρ y ≤
+      ∫ z, (coreScreenedField S u z-NeutralAtom.potentialOf ρ z)*ballCloud y a 1 z := by
+  have hc : Integrable (fun z => coreScreenedField S u z*ballCloud y a 1 z) := by
+    apply ((attraction_ballCloud_integrable S ha y).sub
+      (coreCoulombPotential_mul_integrable u _ (ballCloud_integrable a 1 y))).congr
+    filter_upwards [] with z
+    change attraction S z*ballCloud y a 1 z-coreCoulombPotential u z*ballCloud y a 1 z = _
+    rw [coreScreenedField,sub_mul]
+  simp_rw [sub_mul]
+  rw [integral_sub hc (potentialOf_ballCloud_integrable hi hm ha y),
+    coreScreenedField_ballCloud S u hu ha zero_le_one y hcore hnuc,one_mul]
+  linarith [potentialOf_ballCloud_le hi hm hp ha y hK]
+
+end Coulomb
+
+end
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical
+namespace Coulomb
+
+lemma closedBall_ae_ball (y : Space) (a : ℝ) :
+    Metric.closedBall y a =ᵐ[volume] Metric.ball y a := by
+  filter_upwards [(measure_eq_zero_iff_ae_notMem).mp (Measure.addHaar_sphere volume y a)] with x hx
+  apply propext
+  simp only [Metric.mem_closedBall,Metric.mem_ball,Metric.mem_sphere] at *
+  exact ⟨fun h => lt_of_le_of_ne h hx,le_of_lt⟩
+
+lemma integral_ballCloud (F : Space → ��) (y : Space) (a : ℝ) :
+    (∫ x, F x*ballCloud y a 1 x) =
+      (4*Real.pi/3*a^3)⁻¹*(∫ x in Metric.closedBall y a, F x) := by
+  have he : (fun x => F x*ballCloud y a 1 x) =
+      (Metric.ball y a).indicator (fun x => F x*(4*Real.pi/3*a^3)⁻¹) := by
+    funext x
+    have hd : x-y∈Metric.ball (0:Space) a ↔ x∈Metric.ball y a := by
+      simp only [Metric.mem_ball,dist_eq_norm,sub_zero]
+    by_cases hx : x∈Metric.ball y a
+    · simp only [ballCloud,uniformBall,indicator_of_mem hx,indicator_of_mem (hd.mpr hx),one_div]
+    · simp only [ballCloud,uniformBall,indicator_of_notMem hx,indicator_of_notMem (not_congr hd |>.mpr hx),mul_zero]
+  rw [he,integral_indicator measurableSet_ball,integral_mul_const,
+    ←setIntegral_congr_set (closedBall_ae_ball y a),mul_comm]
+
+lemma integral_closedBall_affine (F : Space → ℝ) (y : Space) {a : ℝ} (ha : 0<a) (r : ℝ) :
+    (∫ z in Metric.closedBall (0:Space) r, F (y+a • z)) =
+      (a^3)⁻¹*(∫ x in Metric.closedBall y (a*r), F x) := by
+  let g := (Metric.closedBall y (a*r)).indicator F
+  have he (z : Space) : g (y+a • z) =
+      (Metric.closedBall (0:Space) r).indicator (fun x => F (y+a • x)) z := by
+    have hz : y+a • z∈Metric.closedBall y (a*r) ↔ z∈Metric.closedBall (0:Space) r := by
+      simp only [Metric.mem_closedBall,dist_eq_norm,add_sub_cancel_left,norm_smul,
+        Real.norm_eq_abs,abs_of_pos ha,sub_zero]
+      exact mul_le_mul_iff_right₀ ha
+    by_cases h : z∈Metric.closedBall (0:Space) r
+    · simp only [g,indicator_of_mem h,indicator_of_mem (hz.mpr h)]
+    · simp only [g,indicator_of_notMem h,indicator_of_notMem (not_congr hz |>.mpr h)]
+  have hh := Measure.integral_comp_smul_of_nonneg volume (fun x => g (y+x)) a (hR:=ha.le)
+  simp only [Space,finrank_euclideanSpace_fin,smul_eq_mul] at hh
+  simp_rw [he] at hh
+  rw [integral_indicator measurableSet_closedBall,integral_add_left_eq_self] at hh
+  simpa only [g,integral_indicator measurableSet_closedBall] using hh
+
+lemma volume_closedBall_three (y : Space) {r : ℝ} (hr : 0≤r) :
+    volume.real (Metric.closedBall y r) = 4*Real.pi/3*r^3 := by
+  rw [Measure.addHaar_real_closedBall_eq_addHaar_real_ball,
+    Measure.addHaar_real_ball_center,volume_real_ball_three r hr]
+
+lemma submean_affine {F : Space → ℝ} (y : Space) {a : ℝ} (ha : 0<a)
+    (hm : F y ≤ ∫ x, F x*ballCloud y (2*a) 1 x) :
+    volume.real (Metric.closedBall (0:Space) 2)*(a^4*F y) ≤
+      ∫ z in Metric.closedBall (0:Space) 2, a^4*F (y+a • z) := by
+  rw [integral_ballCloud] at hm
+  rw [integral_const_mul,integral_closedBall_affine F y ha,volume_closedBall_three _ (by norm_num)]
+  have hV : 0<4*Real.pi/3*(2*a)^3 := by positivity
+  have hi : (4*Real.pi/3*(2*a)^3)*F y ≤ (∫ x in Metric.closedBall y (2*a), F x) := by
+    have hh := mul_le_mul_of_nonneg_left hm hV.le
+    simpa only [←mul_assoc,mul_inv_cancel₀ hV.ne',one_mul] using hh
+  have hh := mul_le_mul_of_nonneg_left hi (show 0≤a^4*(a^3)⁻¹ by positivity)
+  rw [show a*2=2*a by ring]
+  convert hh using 1 <;> first | rfl | field_simp [ha.ne']
+
+end Coulomb
+
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/NormSqSumCosets.lean

@@ -0,0 +1,245 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.FieldAnalysis.PermuteJoinBlock
+
+namespace OAI
+
+noncomputable section
+
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set
+open scoped BigOperators ENNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open scoped Classical
+open scoped BigOperators ComplexConjugate
+open scoped Classical
+namespace Coulomb
+lemma norm_sq_sum_cosets {G : Type*} [Group G] [Fintype G]
+    (H : Subgroup G) (f : G → ℂ)
+    (hc : ∀ p q, conj (f p)*f q = if p⁻¹*q ∈ H then ((‖f p‖^2 : ℝ) : ℂ) else 0) :
+    ‖∑ p, f p‖^2 = (Fintype.card H : ℝ)*∑ p, ‖f p‖^2 := by
+  apply Complex.ofReal_injective
+  push_cast
+  rw [← Complex.conj_mul', map_sum, Finset.sum_mul]
+  simp_rw [Finset.mul_sum, hc]
+  have hi (p : G) :
+      (∑ q : G, if p⁻¹*q ∈ H then ((‖f p‖^2 : ℝ) : ℂ) else (0:ℂ)) =
+        (Fintype.card H : ℂ)*(‖f p‖^2 : ℝ) := by
+    rw [← Equiv.sum_comp (Equiv.mulLeft p)]
+    change (∑ r : G, if p⁻¹*(p*r) ∈ H then ((‖f p‖^2 : ℝ) : ℂ) else 0) = _
+    simp only [inv_mul_cancel_left]
+    rw [← Finset.sum_filter]
+    simp [Fintype.card_subtype]
+  simp_rw [hi]
+  push_cast
+  rfl
+
+lemma signed_coset_correlation {G : Type*} [Group G] [Fintype G]
+    (χ : G →* ℂ) (hχ : ∀ p, χ p*χ p = 1) (hχr : ∀ p, conj (χ p) = χ p)
+    (H : Subgroup G) (f : G → ℂ)
+    (hc : ∀ p h, h ∈ H → f (p*h) = χ h*f p)
+    (hz : ∀ p q, p⁻¹*q ∉ H → conj (f p)*f q = 0) (p q : G) :
+    conj (χ p*f p)*(χ q*f q) =
+      if p⁻¹*q ∈ H then ((‖χ p*f p‖^2 : ℝ) : ℂ) else 0 := by
+  by_cases h : p⁻¹*q ∈ H
+  · rw [ite_eq_left h]
+    have hq : q = p*(p⁻¹*q) := by group
+    have hf := hc p (p⁻¹*q) h
+    rw [← hq] at hf
+    rw [hf]
+    conv_lhs => arg 2; arg 1; rw [hq, map_mul]
+    have he : χ p * χ (p⁻¹*q) * (χ (p⁻¹*q)*f p) = χ p*f p := by
+      rw [mul_assoc, ← mul_assoc (χ (p⁻¹*q)), hχ, one_mul]
+    rw [he, Complex.conj_mul']
+    push_cast
+    rfl
+  · rw [ite_eq_right h, map_mul, hχr]
+    calc
+      _ = χ p*χ q*(conj (f p)*f q) := by ring
+      _ = 0 := by rw [hz p q h, mul_zero]
+
+lemma norm_sq_signed_sum_cosets {G : Type*} [Group G] [Fintype G]
+    (χ : G →* ℂ) (hχ : ∀ p, χ p*χ p = 1) (hχr : ∀ p, conj (χ p) = χ p)
+    (H : Subgroup G) (f : G → ℂ)
+    (hc : ∀ p h, h ∈ H → f (p*h) = χ h*f p)
+    (hz : ∀ p q, p⁻¹*q ∉ H → conj (f p)*f q = 0) :
+    ‖∑ p, χ p*f p‖^2 = (Fintype.card H : ℝ)*∑ p, ‖f p‖^2 := by
+  rw [norm_sq_sum_cosets H (fun p => χ p*f p)
+    (signed_coset_correlation χ hχ hχr H f hc hz)]
+  congr 1
+  apply Finset.sum_congr rfl
+  intro p _
+  have hn : ‖χ p‖^2 = 1 := by
+    have H := congrArg norm (hχ p)
+    simpa [norm_mul, pow_two] using H
+  rw [norm_mul, mul_pow, hn, one_mul]
+lemma permutation_mul_value {n : ℕ} (u : H1Vector n) (p q : Equiv.Perm (Fin n))
+    (s : Spins n) (x : Configuration n) :
+    (u.permutation (p*q)).value s x = ((u.permutation q).permutation p).value s x := by
+  simp only [permutation_value, permute_mul]
+  rfl
+lemma permutation_mul_gradient {n : ℕ} (u : H1Vector n) (p q : Equiv.Perm (Fin n))
+    (s : Spins n) (a : Fin n × Fin 3) (x : Configuration n) :
+    (u.permutation (p*q)).gradient s a x = ((u.permutation q).permutation p).gradient s a x := by
+  simp only [permutation_gradient, permute_mul]
+  rfl
+
+lemma permutation_value_covariance {n : ℕ} (u : H1Vector n) (h : Equiv.Perm (Fin n))
+    (c : ℂ) (hc : ∀ s, (u.permutation h).value s =ᵐ[volume] fun x => c*u.value s x)
+    (p : Equiv.Perm (Fin n)) (s : Spins n) :
+    (u.permutation (p*h)).value s =ᵐ[volume] fun x => c*(u.permutation p).value s x := by
+  have H := (permute_measurePreserving p).quasiMeasurePreserving.ae (hc (s ∘ p))
+  filter_upwards [H] with x hx
+  rw [permutation_mul_value, permutation_value, permutation_value]
+  exact hx
+
+lemma permutation_gradient_covariance {n : ℕ} (u : H1Vector n) (h : Equiv.Perm (Fin n))
+    (c : ℂ) (hc : ∀ s, (u.permutation h).value s =ᵐ[volume] fun x => c*u.value s x)
+    (p : Equiv.Perm (Fin n)) (s : Spins n) (a : Fin n × Fin 3) :
+    (u.permutation (p*h)).gradient s a =ᵐ[volume]
+      fun x => c*(u.permutation p).gradient s a x := by
+  have hg := H1Vector.gradient_congr_ae (u.permutation h) (u.scale c) hc
+    (s ∘ p) (p.symm a.1,a.2)
+  have H := (permute_measurePreserving p).quasiMeasurePreserving.ae hg
+  filter_upwards [H] with x hx
+  rw [permutation_mul_gradient]
+  simpa only [permutation_gradient, H1Vector.scale] using hx
+
+def complexSign (n : ℕ) : Equiv.Perm (Fin n) →* ℂ where
+  toFun := fun p => ((p.sign : ℤ) : ℂ)
+  map_one' := by simp
+  map_mul' := by intro p q; simp
+
+lemma complexSign_sq {n : ℕ} (p : Equiv.Perm (Fin n)) : complexSign n p*complexSign n p = 1 :=
+  sign_complex_sq p
+lemma complexSign_real {n : ℕ} (p : Equiv.Perm (Fin n)) : conj (complexSign n p) = complexSign n p := by
+  simp [complexSign]
+
+lemma fullAntisymmetrize_gradient {n : ℕ} (u : H1Vector n) (s : Spins n)
+    (a : Fin n × Fin 3) (x : Configuration n) :
+    u.fullAntisymmetrize.gradient s a x =
+      ∑ p : Equiv.Perm (Fin n), complexSign n p*(u.permutation p).gradient s a x := rfl
+
+lemma separated_fullAntisymmetrize_value_sq {m k : ℕ} (u : H1Vector m) (v : H1Vector k)
+    (hu : Antisymmetric u) (hv : Antisymmetric v) (A B : Set Space)
+    (hsu : SpatiallySupported u A) (hsv : SpatiallySupported v B) (hAB : Disjoint A B)
+    (s : Spins (m+k)) :
+    ∀ᵐ x ∂volume, ‖(u.tensor v).fullAntisymmetrize.value s x‖^2 =
+      (Fintype.card (blockGroup m k) : ℝ)*
+        ∑ p : Equiv.Perm (Fin (m+k)), ‖((u.tensor v).permutation p).value s x‖^2 := by
+  have hc : ∀ᵐ x ∂volume, ∀ p : Equiv.Perm (Fin (m+k)), ∀ h : Equiv.Perm (Fin (m+k)),
+      h ∈ blockGroup m k →
+      ((u.tensor v).permutation (p*h)).value s x =
+        complexSign (m+k) h*((u.tensor v).permutation p).value s x := by
+    apply ae_all_iff.2
+    intro p
+    apply ae_all_iff.2
+    intro h
+    by_cases hh : h ∈ blockGroup m k
+    · exact (permutation_value_covariance (u.tensor v) h _
+        (tensor_block_covariance u v hu hv h hh) p s).mono (fun x hx _ => hx)
+    · exact Filter.Eventually.of_forall (fun x h => (hh h).elim)
+  have hz : ∀ᵐ x ∂volume, ∀ p q : Equiv.Perm (Fin (m+k)), p⁻¹*q ∉ blockGroup m k →
+      conj (((u.tensor v).permutation p).value s x)*((u.tensor v).permutation q).value s x = 0 := by
+    apply ae_all_iff.2
+    intro p
+    apply ae_all_iff.2
+    intro q
+    by_cases h : p⁻¹*q ∈ blockGroup m k
+    · exact Filter.Eventually.of_forall (fun x hn => (hn h).elim)
+    · exact (configSupported_value_orthogonal (u.tensor v) (blockRegion m k A B)
+        (tensor_configSupported u v A B hsu hsv) p q
+        (blockRegion_orbit_disjoint hAB p q h) s).mono (fun x hx _ => hx)
+  filter_upwards [hc,hz] with x hx hy
+  change ‖∑ p : Equiv.Perm (Fin (m+k)), complexSign (m+k) p*
+    ((u.tensor v).permutation p).value s x‖^2 = _
+  exact norm_sq_signed_sum_cosets (complexSign (m+k)) complexSign_sq complexSign_real
+    (blockGroup m k) (fun p => ((u.tensor v).permutation p).value s x) hx hy
+
+lemma separated_fullAntisymmetrize_gradient_sq {m k : ℕ} (u : H1Vector m) (v : H1Vector k)
+    (hu : Antisymmetric u) (hv : Antisymmetric v) (A B : Set Space)
+    (hsu : SpatiallySupported u A) (hsv : SpatiallySupported v B)
+    (hA : IsClosed A) (hB : IsClosed B) (hAB : Disjoint A B)
+    (s : Spins (m+k)) (a : Fin (m+k) × Fin 3) :
+    ∀ᵐ x ∂volume, ‖(u.tensor v).fullAntisymmetrize.gradient s a x‖^2 =
+      (Fintype.card (blockGroup m k) : ℝ)*
+        ∑ p : Equiv.Perm (Fin (m+k)), ‖((u.tensor v).permutation p).gradient s a x‖^2 := by
+  have hc : ∀ᵐ x ∂volume, ∀ p : Equiv.Perm (Fin (m+k)), ∀ h : Equiv.Perm (Fin (m+k)),
+      h ∈ blockGroup m k →
+      ((u.tensor v).permutation (p*h)).gradient s a x =
+        complexSign (m+k) h*((u.tensor v).permutation p).gradient s a x := by
+    apply ae_all_iff.2
+    intro p
+    apply ae_all_iff.2
+    intro h
+    by_cases hh : h ∈ blockGroup m k
+    · exact (permutation_gradient_covariance (u.tensor v) h _
+        (tensor_block_covariance u v hu hv h hh) p s a).mono (fun x hx _ => hx)
+    · exact Filter.Eventually.of_forall (fun x h => (hh h).elim)
+  have hz : ∀ᵐ x ∂volume, ∀ p q : Equiv.Perm (Fin (m+k)), p⁻¹*q ∉ blockGroup m k →
+      conj (((u.tensor v).permutation p).gradient s a x)*((u.tensor v).permutation q).gradient s a x = 0 := by
+    apply ae_all_iff.2
+    intro p
+    apply ae_all_iff.2
+    intro q
+    by_cases h : p⁻¹*q ∈ blockGroup m k
+    · exact Filter.Eventually.of_forall (fun x hn => (hn h).elim)
+    · exact (configSupported_gradient_orthogonal (u.tensor v) (blockRegion m k A B)
+        (tensor_configSupported u v A B hsu hsv) (isClosed_blockRegion hA hB) p q
+        (blockRegion_orbit_disjoint hAB p q h) s a).mono (fun x hx _ => hx)
+  filter_upwards [hc,hz] with x hx hy
+  rw [fullAntisymmetrize_gradient]
+  exact norm_sq_signed_sum_cosets (complexSign (m+k)) complexSign_sq complexSign_real
+    (blockGroup m k) (fun p => ((u.tensor v).permutation p).gradient s a x) hx hy
+end Coulomb
+
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/Occupancy.lean

@@ -0,0 +1,206 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.Packets.OrbitalKernel
+
+namespace OAI
+
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+namespace Coulomb
+noncomputable def occupancy (b : Bool) : ℝ := if b then 1 else 0
+noncomputable def bernoulliWeight {ι : Type*} [Fintype ι] (lam : ι → ℝ) (w : ι → Bool) : ℝ :=
+  ∏ i, if w i then lam i else 1-lam i
+lemma bernoulliWeight_nonneg {ι : Type*} [Fintype ι] (lam : ι → ℝ)
+    (hl : ∀ i, 0 ≤ lam i) (hu : ∀ i, lam i ≤ 1) (w : ι → Bool) :
+    0 ≤ bernoulliWeight lam w := by
+  apply Finset.prod_nonneg
+  intro i _
+  split_ifs
+  · exact hl i
+  · exact sub_nonneg.mpr (hu i)
+lemma bernoulli_product_mean {ι : Type*} [Fintype ι] (lam : ι → ℝ) (f : ι → Bool → ℝ) :
+    (∑ w : ι → Bool, bernoulliWeight lam w * ∏ i, f i (w i)) =
+      ∏ i, ((1-lam i)*f i false+lam i*f i true) := by
+  simp only [bernoulliWeight,←Finset.prod_mul_distrib]
+  rw [←Fintype.prod_sum (fun i b => (if b then lam i else 1-lam i)*f i b)]
+  apply Finset.prod_congr rfl
+  intro i _
+  simp [add_comm]
+lemma bernoulliWeight_sum {ι : Type*} [Fintype ι] (lam : ι → ℝ) :
+    ∑ w : ι → Bool, bernoulliWeight lam w = 1 := by
+  simpa using bernoulli_product_mean lam (fun _ _ => 1)
+lemma bernoulli_forced_mean {ι : Type*} [Fintype ι] (lam : ι → ℝ) (s : Finset ι) :
+    (∑ w : ι → Bool, bernoulliWeight lam w * ∏ i ∈ s,occupancy (w i)) = ∏ i ∈ s,lam i := by
+  have he (w : ι → Bool) : (∏ i ∈ s,occupancy (w i)) = ∏ i,if i ∈ s then occupancy (w i) else 1 := by
+    rw [Finset.prod_ite]
+    simp
+  simp_rw [he]
+  rw [bernoulli_product_mean lam (fun i b => if i ∈ s then occupancy b else 1)]
+  have hp (i : ι) : (1-lam i)*(if i ∈ s then occupancy false else 1)+
+      lam i*(if i ∈ s then occupancy true else 1) = if i ∈ s then lam i else 1 := by
+    by_cases hs : i ∈ s <;> simp [hs,occupancy]
+  simp_rw [hp]
+  rw [Finset.prod_ite]
+  simp
+lemma bernoulli_one_mean {ι : Type*} [Fintype ι] (lam : ι → ℝ) (i : ι) :
+    (∑ w : ι → Bool,bernoulliWeight lam w*occupancy (w i)) = lam i := by
+  simpa using bernoulli_forced_mean lam {i}
+lemma bernoulli_two_mean {ι : Type*} [Fintype ι] (lam : ι → ℝ) {i j : ι} (hij : i ≠ j) :
+    (∑ w : ι → Bool,bernoulliWeight lam w*(occupancy (w i)*occupancy (w j))) = lam i*lam j := by
+  simpa [hij] using bernoulli_forced_mean lam {i,j}
+lemma bernoulli_linear_mean {ι : Type*} [Fintype ι] (lam a : ι → ℝ) :
+    (∑ w : ι → Bool,bernoulliWeight lam w*(∑ i,occupancy (w i)*a i)) = ∑ i,lam i*a i := by
+  simp only [Finset.mul_sum]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro i _
+  simp only [←mul_assoc,←Finset.sum_mul,bernoulli_one_mean]
+lemma bernoulli_pair_mean {ι : Type*} [Fintype ι] (lam : ι → ℝ) (d : ι → ι → ℝ)
+    (hd : ∀ i, d i i = 0) :
+    (∑ w : ι → Bool,bernoulliWeight lam w*(∑ i,∑ j,occupancy (w i)*occupancy (w j)*d i j)) =
+      ∑ i,∑ j,lam i*lam j*d i j := by
+  simp only [Finset.mul_sum]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro i _
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro j _
+  by_cases hij : i=j
+  · subst j; simp [hd]
+  · calc
+      _ = (∑ w : ι → Bool,bernoulliWeight lam w*(occupancy (w i)*occupancy (w j)))*d i j := by
+        rw [Finset.sum_mul]
+        apply Finset.sum_congr rfl
+        intro w _
+        ring
+      _ = _ := by rw [bernoulli_two_mean lam hij]
+
+noncomputable def occupiedIndex {ι : Type*} [Fintype ι] (w : ι → Bool) :
+    Fin (Fintype.card {i // w i = true}) ↪ ι :=
+  (Fintype.equivFin {i // w i = true}).symm.toEmbedding.trans (Function.Embedding.subtype _)
+
+lemma sum_occupiedIndex {ι R : Type*} [Fintype ι] [AddCommMonoid R]
+    (w : ι → Bool) (f : ι → R) :
+    (∑ a, f (occupiedIndex w a)) = ∑ i, if w i then f i else 0 := by
+  classical
+  rw [show (∑ a, f (occupiedIndex w a)) = ∑ a : {i // w i = true}, f a by
+    exact Equiv.sum_comp (Fintype.equivFin {i // w i = true}).symm (fun a => f a)]
+  rw [← Finset.sum_subtype (Finset.univ.filter (fun i => w i = true)) (by simp) f,
+    Finset.sum_filter]
+
+lemma sum_occupiedIndex_real {ι : Type*} [Fintype ι] (w : ι → Bool) (f : ι → ℝ) :
+    (∑ a, f (occupiedIndex w a)) = ∑ i, occupancy (w i) * f i := by
+  rw [sum_occupiedIndex]
+  apply Finset.sum_congr rfl
+  intro i _
+  cases w i <;> simp [occupancy]
+
+noncomputable def slaterPairEntry {A ι : Type*} [MeasurableSpace A] (μ : Measure A)
+    (v : ι → A → ℂ) (W : A → A → ℝ) (i j : ι) : ℝ :=
+  (∫ xy : A × A, (W xy.1 xy.2 : ℂ) *
+      ((star (v i xy.1)*v i xy.1)*(star (v j xy.2)*v j xy.2)) ∂(μ.prod μ)).re -
+  (∫ xy : A × A, (W xy.1 xy.2 : ℂ) *
+      ((star (v i xy.1)*v j xy.1)*(star (v j xy.2)*v i xy.2)) ∂(μ.prod μ)).re
+
+lemma slaterPairEntry_self {A ι : Type*} [MeasurableSpace A] (μ : Measure A)
+    (v : ι → A → ℂ) (W : A → A → ℝ) (i : ι) : slaterPairEntry μ v W i i = 0 := by
+  simp [slaterPairEntry]
+
+lemma slaterWave_two_body_exact {A : Type*} [MeasurableSpace A] {μ : Measure A}
+    [SigmaFinite μ] {n : ℕ} (v : Fin n → A → ℂ) (W : A → A → ℝ)
+    (hv : ∀ i, MemLp (v i) 2 μ)
+    (ho : ∀ a b, (∫ x, star (v a x)*v b x ∂μ) = if a = b then (1:ℂ) else 0)
+    (hW : ∀ a b c d, Integrable (fun xy : A × A => (W xy.1 xy.2 : ℂ) *
+      ((star (v a xy.1)*v c xy.1)*(star (v b xy.2)*v d xy.2))) (μ.prod μ)) :
+    (∫ x : Fin n → A, (∑ i, ∑ j ∈ Finset.univ.erase i, W (x i) (x j)) *
+      ‖slaterWave v x‖^2 ∂(Measure.pi fun _ => μ)) = ∑ i, ∑ j, slaterPairEntry μ v W i j := by
+  have H := determinant_two_body_integral v (fun x y => (W x y : ℂ)) hv ho hW
+  simp only [complex_star_mul_self, ← Complex.ofReal_sum, ← Complex.ofReal_mul,
+    integral_complex_ofReal] at H
+  have HR := congrArg Complex.re H
+  simp only [Complex.ofReal_re, Complex.mul_re, Complex.natCast_re, Complex.natCast_im,
+    zero_mul, sub_zero, Complex.re_sum, Complex.sub_re] at HR
+  have hn : (0:ℝ) < n.factorial := Nat.cast_pos.mpr (Nat.factorial_pos n)
+  have he (x : Fin n → A) : (∑ i, ∑ j ∈ Finset.univ.erase i, W (x i) (x j)) *
+      ‖slaterWave v x‖^2 = (n.factorial : ℝ)⁻¹ *
+        ((∑ i, ∑ j ∈ Finset.univ.erase i, W (x i) (x j)) * ‖determinantWave v x‖^2) := by
+    simp only [slaterWave, norm_mul, mul_pow, norm_inv, Complex.norm_real, Real.norm_eq_abs,
+      abs_of_nonneg (Real.sqrt_nonneg _), inv_pow, Real.sq_sqrt hn.le]
+    ring
+  simp_rw [he]
+  rw [integral_const_mul, HR, ← mul_assoc, inv_mul_cancel₀ hn.ne', one_mul]
+  simp only [slaterPairEntry, complex_star_mul_self, ← Complex.ofReal_mul,
+    integral_complex_ofReal, Complex.ofReal_re]
+
+lemma bernoulli_slater_pair_mean {A ι : Type*} [MeasurableSpace A] [Fintype ι]
+    {μ : Measure A} [SigmaFinite μ] (v : ι → A → ℂ) (W : A → A → ℝ)
+    (lam : ι → ℝ) (hv : ∀ i, MemLp (v i) 2 μ)
+    (ho : ∀ a b, (∫ x, star (v a x)*v b x ∂μ) = if a = b then (1:ℂ) else 0)
+    (hW : ∀ a b c d, Integrable (fun xy : A × A => (W xy.1 xy.2 : ℂ) *
+      ((star (v a xy.1)*v c xy.1)*(star (v b xy.2)*v d xy.2))) (μ.prod μ)) :
+    (∑ w : ι → Bool, bernoulliWeight lam w *
+      (∫ x : Fin (Fintype.card {i // w i = true}) → A,
+        (∑ i, ∑ j ∈ Finset.univ.erase i, W (x i) (x j)) *
+        ‖slaterWave (fun a => v (occupiedIndex w a)) x‖^2 ∂(Measure.pi fun _ => μ))) =
+      ∑ i, ∑ j, lam i * lam j * slaterPairEntry μ v W i j := by
+  classical
+  have he (w : ι → Bool) := slaterWave_two_body_exact
+    (fun a => v (occupiedIndex w a)) W (fun a => hv _) (fun a b => by
+      simp only [ho, (occupiedIndex w).injective.eq_iff])
+    (fun a b c d => hW _ _ _ _)
+  simp_rw [he]
+  have hs (w : ι → Bool) :
+      (∑ a, ∑ b, slaterPairEntry μ (fun a => v (occupiedIndex w a)) W a b) =
+      ∑ i, ∑ j, occupancy (w i)*occupancy (w j)*slaterPairEntry μ v W i j := by
+    change (∑ a, ∑ b, slaterPairEntry μ v W (occupiedIndex w a) (occupiedIndex w b)) = _
+    rw [sum_occupiedIndex_real w (fun i => ∑ b, slaterPairEntry μ v W i (occupiedIndex w b))]
+    simp_rw [sum_occupiedIndex_real, Finset.mul_sum, mul_assoc]
+  simp_rw [hs]
+  exact bernoulli_pair_mean lam _ (slaterPairEntry_self μ v W)
+end Coulomb
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/OuterJoinConfiguration.lean

@@ -0,0 +1,546 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.FieldAnalysis.RetainedFinePower
+
+namespace OAI
+
+noncomputable section
+
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set
+open scoped BigOperators ENNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open scoped Classical
+open scoped BigOperators ComplexConjugate
+open scoped Classical
+open scoped Classical
+open MeasureTheory Set Filter
+open scoped Classical ENNReal NNReal ComplexConjugate
+open MeasureTheory Set Filter Module Module.End TopologicalSpace Function
+open scoped Classical ComplexConjugate
+open MeasureTheory Set Filter Module Module.End TopologicalSpace Function
+open scoped Classical ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Filter
+open scoped ENNReal NNReal FourierTransform SchwartzMap LineDeriv ComplexConjugate
+open scoped LineDeriv
+open MeasureTheory Set Metric
+open scoped ENNReal NNReal RealInnerProductSpace
+open MeasureTheory Set Metric Filter
+open scoped ENNReal NNReal RealInnerProductSpace Convolution
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open MeasureTheory Set Filter
+open scoped Classical SchwartzMap FourierTransform ENNReal NNReal ComplexConjugate Pointwise
+open MeasureTheory Set Filter
+open scoped Classical SchwartzMap FourierTransform ENNReal NNReal Pointwise
+open MeasureTheory Set Filter
+open scoped Classical SchwartzMap FourierTransform ENNReal NNReal Pointwise
+open MeasureTheory Set Filter
+open scoped Classical SchwartzMap ENNReal NNReal Pointwise
+open MeasureTheory Set Filter
+open scoped Classical SchwartzMap FourierTransform ENNReal NNReal Pointwise
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Classical SchwartzMap Pointwise
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Classical SchwartzMap Pointwise
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Classical SchwartzMap Pointwise
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Classical SchwartzMap Pointwise
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Classical SchwartzMap Pointwise
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Classical SchwartzMap Pointwise
+open MeasureTheory Set
+open scoped BigOperators ENNReal
+open MeasureTheory Set
+open scoped BigOperators Matrix
+open MeasureTheory Set
+open scoped BigOperators Matrix ENNReal
+open MeasureTheory Set Filter
+open scoped BigOperators ENNReal NNReal Classical
+open MeasureTheory Set
+open scoped BigOperators ENNReal
+open MeasureTheory Set
+open scoped BigOperators Matrix
+open MeasureTheory Set Filter
+open scoped BigOperators ENNReal NNReal Classical
+open MeasureTheory Set Filter
+open scoped BigOperators ENNReal NNReal Classical
+open MeasureTheory Set Filter
+open scoped BigOperators ENNReal NNReal Classical
+namespace Coulomb
+
+def outerJoinConfiguration (m k : ℕ) :
+    (Configuration m × Configuration k) ≃L[ℝ] Configuration (k+m) :=
+  (ContinuousLinearEquiv.prodComm ℝ (Configuration m) (Configuration k)).trans
+    (joinConfiguration k m)
+lemma outerJoinConfiguration_apply (m k : ℕ) (x : Configuration m) (y : Configuration k) :
+    outerJoinConfiguration m k (x,y) = joinConfiguration k m (y,x) := rfl
+lemma outerJoinConfiguration_measurePreserving (m k : ℕ) :
+    MeasurePreserving (outerJoinConfiguration m k).toHomeomorph.toMeasurableEquiv
+      (volume.prod volume) volume :=
+  (joinConfiguration_measurePreserving k m).comp Measure.measurePreserving_swap
+lemma outerJoinConfiguration_right_single (m k : ℕ) (a : Fin k × Fin 3) :
+    outerJoinConfiguration m k (0, EuclideanSpace.single a 1) =
+      EuclideanSpace.single (Fin.castAdd m a.1,a.2) 1 := by
+  ext ⟨i,b⟩
+  refine Fin.addCases ?_ ?_ i
+  · intro j
+    rw [outerJoinConfiguration_apply, joinConfiguration_left]
+    simp [PiLp.single_apply, Prod.ext_iff]
+  · intro j
+    rw [outerJoinConfiguration_apply, joinConfiguration_right]
+    simp only [PiLp.single_apply, PiLp.zero_apply, Prod.mk.injEq]
+    split_ifs with h
+    · have := congrArg (fun z : Fin (k+m) => z.val) h.1
+      simp only [Fin.val_castAdd, Fin.val_natAdd] at this
+      omega
+    · rfl
+abbrev outerAppend {m k : ℕ} (s : Spins m) (t : Spins k) : Spins (k+m) := Fin.append t s
+noncomputable def outerAppendEquiv (m k : ℕ) : Spins m × Spins k ≃ Spins (k+m) :=
+  (Equiv.prodComm _ _).trans (Fin.appendEquiv k m)
+noncomputable def outerPerm (m : ℕ) {k : ℕ} (p : Equiv.Perm (Fin k)) :
+    Equiv.Perm (Fin (k+m)) :=
+  finSumFinEquiv.permCongr (Equiv.sumCongr p (Equiv.refl (Fin m)))
+lemma outerPerm_left (m : ℕ) {k : ℕ} (p : Equiv.Perm (Fin k)) (i : Fin k) :
+    outerPerm m p (Fin.castAdd m i) = Fin.castAdd m (p i) := by simp [outerPerm]
+lemma outerPerm_right (m : ℕ) {k : ℕ} (p : Equiv.Perm (Fin k)) (i : Fin m) :
+    outerPerm m p (Fin.natAdd k i) = Fin.natAdd k i := by simp [outerPerm]
+lemma outerPerm_sign (m : ℕ) {k : ℕ} (p : Equiv.Perm (Fin k)) :
+    (outerPerm m p).sign = p.sign := by simp [outerPerm, Equiv.Perm.sign_sumCongr]
+lemma append_outerPerm {m k : ℕ} (s : Spins m) (t : Spins k) (p : Equiv.Perm (Fin k)) :
+    outerAppend s t ∘ outerPerm m p = outerAppend s (t ∘ p) := by
+  funext i
+  refine Fin.addCases ?_ ?_ i
+  · intro j; simp [outerAppend, outerPerm_left]
+  · intro j; simp [outerAppend, outerPerm_right]
+lemma permute_outer_join {m k : ℕ} (p : Equiv.Perm (Fin k)) (x : Configuration m)
+    (y : Configuration k) :
+    permute (outerPerm m p) (outerJoinConfiguration m k (x,y)) =
+      outerJoinConfiguration m k (x, permute p y) := by
+  rw [outerJoinConfiguration_apply, outerJoinConfiguration_apply]
+  ext ⟨i,b⟩
+  refine Fin.addCases ?_ ?_ i
+  · intro j
+    change joinConfiguration k m (y,x) (outerPerm m p (Fin.castAdd m j),b) = _
+    rw [outerPerm_left, joinConfiguration_left, joinConfiguration_left]
+    rfl
+  · intro j
+    change joinConfiguration k m (y,x) (outerPerm m p (Fin.natAdd k j),b) = _
+    rw [outerPerm_right, joinConfiguration_right, joinConfiguration_right]
+lemma H1Vector.weak_partial_outerJoin {m k : ℕ} (ψ : H1Vector (k+m))
+    (s : Spins (k+m)) (a : Fin k × Fin 3) :
+    ∀ (η : Configuration m × Configuration k → ℝ), ContDiff ℝ (⊤ : ℕ∞) η →
+      HasCompactSupport η →
+      (∫ z, ψ.value s (outerJoinConfiguration m k z) *
+        (fderiv ℝ η z (0, EuclideanSpace.single a 1) : ℂ) ∂(volume.prod volume)) =
+      -(∫ z, ψ.gradient s (Fin.castAdd m a.1, a.2) (outerJoinConfiguration m k z) *
+        (η z : ℂ) ∂(volume.prod volume)) := by
+  apply weak_directional_change (outerJoinConfiguration m k) (outerJoinConfiguration_measurePreserving m k)
+    (0, EuclideanSpace.single a 1)
+  rw [outerJoinConfiguration_right_single]
+  exact ψ.weak_partial s (Fin.castAdd m a.1, a.2)
+
+lemma H1Vector.outer_slices_H1 {m k : ℕ} (ψ : H1Vector (k+m)) (s : Spins m) :
+    ∀ᵐ x ∂(volume : Measure (Configuration m)),
+      (∀ t : Spins k, MemLp (fun y => ψ.value (outerAppend s t) (outerJoinConfiguration m k (x,y))) 2 volume) ∧
+      (∀ (t : Spins k) (a : Fin k × Fin 3),
+        MemLp (fun y => ψ.gradient (outerAppend s t) (Fin.castAdd m a.1,a.2)
+          (outerJoinConfiguration m k (x,y))) 2 volume ∧
+        ∀ (φ : Configuration k → ℝ), ContDiff ℝ (⊤ : ℕ∞) φ → HasCompactSupport φ →
+        (∫ y, ψ.value (outerAppend s t) (outerJoinConfiguration m k (x,y)) *
+          (fderiv ℝ φ y (EuclideanSpace.single a 1) : ℂ)) =
+        -(∫ y, ψ.gradient (outerAppend s t) (Fin.castAdd m a.1,a.2)
+          (outerJoinConfiguration m k (x,y)) * (φ y : ℂ))) := by
+  have hV (t : Spins k) := (ψ.value_L2 (outerAppend s t)).comp_measurePreserving
+    (outerJoinConfiguration_measurePreserving m k)
+  have hG (t : Spins k) (a : Fin k × Fin 3) :=
+    (ψ.partial_L2 (outerAppend s t) (Fin.castAdd m a.1,a.2)).comp_measurePreserving
+      (outerJoinConfiguration_measurePreserving m k)
+  have hval : ∀ᵐ x ∂(volume : Measure (Configuration m)),
+      ∀ t : Spins k, MemLp (fun y => ψ.value (outerAppend s t) (outerJoinConfiguration m k (x,y))) 2 volume :=
+    ae_all_iff.mpr (fun t => memLp_fiber_ae
+      (f := fun z : Configuration m × Configuration k =>
+        ψ.value (outerAppend s t) (outerJoinConfiguration m k z)) (hV t))
+  have hgrad := fun (t : Spins k) (a : Fin k × Fin 3) =>
+    weak_slice (hV t) (hG t a) (EuclideanSpace.single a 1)
+      (ψ.weak_partial_outerJoin (outerAppend s t) a)
+  have hall := ae_all_iff.mpr (fun t => ae_all_iff.mpr (hgrad t))
+  filter_upwards [hval, hall] with x hx hall
+  exact ⟨hx, fun t a => (hall t a).2⟩
+
+def H1Vector.OuterSliceRegular {m k : ℕ} (ψ : H1Vector (k+m)) (s : Spins m)
+    (x : Configuration m) : Prop :=
+      (∀ t : Spins k, MemLp (fun y => ψ.value (outerAppend s t) (outerJoinConfiguration m k (x,y))) 2 volume) ∧
+      (∀ (t : Spins k) (a : Fin k × Fin 3),
+        MemLp (fun y => ψ.gradient (outerAppend s t) (Fin.castAdd m a.1,a.2)
+          (outerJoinConfiguration m k (x,y))) 2 volume ∧
+        ∀ (φ : Configuration k → ℝ), ContDiff ℝ (⊤ : ℕ∞) φ → HasCompactSupport φ →
+        (∫ y, ψ.value (outerAppend s t) (outerJoinConfiguration m k (x,y)) *
+          (fderiv ℝ φ y (EuclideanSpace.single a 1) : ℂ)) =
+        -(∫ y, ψ.gradient (outerAppend s t) (Fin.castAdd m a.1,a.2)
+          (outerJoinConfiguration m k (x,y)) * (φ y : ℂ)))
+
+lemma H1Vector.outerSliceRegular_ae {m k : ℕ} (ψ : H1Vector (k+m)) (s : Spins m) :
+    ∀ᵐ x ∂volume, ψ.OuterSliceRegular s x := ψ.outer_slices_H1 s
+
+noncomputable def H1Vector.outerSlice {m k : ℕ} (ψ : H1Vector (k+m)) (s : Spins m)
+    (x : Configuration m) : H1Vector k := by
+  classical
+  exact if h : ψ.OuterSliceRegular s x then
+    { value := fun t y => ψ.value (outerAppend s t) (outerJoinConfiguration m k (x,y))
+      gradient := fun t a y => ψ.gradient (outerAppend s t) (Fin.castAdd m a.1,a.2)
+        (outerJoinConfiguration m k (x,y))
+      value_L2 := h.1
+      partial_L2 := fun t a => (h.2 t a).1
+      weak_partial := fun t a => (h.2 t a).2 }
+  else H1Vector.zero k
+
+lemma H1Vector.outerSlice_value {m k : ℕ} (ψ : H1Vector (k+m)) (s : Spins m)
+    {x : Configuration m} (hx : ψ.OuterSliceRegular s x) (t : Spins k) (y : Configuration k) :
+    (ψ.outerSlice s x).value t y = ψ.value (outerAppend s t) (outerJoinConfiguration m k (x,y)) := by
+  simp [H1Vector.outerSlice, hx]
+
+lemma H1Vector.outerSlice_gradient {m k : ℕ} (ψ : H1Vector (k+m)) (s : Spins m)
+    {x : Configuration m} (hx : ψ.OuterSliceRegular s x) (t : Spins k) (a : Fin k × Fin 3)
+    (y : Configuration k) :
+    (ψ.outerSlice s x).gradient t a y =
+      ψ.gradient (outerAppend s t) (Fin.castAdd m a.1,a.2) (outerJoinConfiguration m k (x,y)) := by
+  simp [H1Vector.outerSlice, hx]
+
+lemma mass_outerSlice_ae {m k : ℕ} (ψ : H1Vector (k+m)) (s : Spins m) :
+    (fun x => mass (ψ.outerSlice s x)) =ᵐ[volume]
+      fun x => ∑ t : Spins k, ∫ y, ‖ψ.value (outerAppend s t) (outerJoinConfiguration m k (x,y))‖^2 := by
+  filter_upwards [ψ.outerSliceRegular_ae s] with x hx
+  simp only [mass, ψ.outerSlice_value s hx]
+
+lemma mass_outerSlice_integrable {m k : ℕ} (ψ : H1Vector (k+m)) (s : Spins m) :
+    Integrable (fun x => mass (ψ.outerSlice s x)) := by
+  apply Integrable.congr _ (mass_outerSlice_ae ψ s).symm
+  apply integrable_finsetSum
+  intro t _
+  have h := ((ψ.value_L2 (outerAppend s t)).comp_measurePreserving
+    (outerJoinConfiguration_measurePreserving m k)).integrable_norm_pow (p := 2) (by decide)
+  exact h.integral_prod_left
+
+lemma integral_mass_outerSlice {m k : ℕ} (ψ : H1Vector (k+m)) :
+    (∑ s : Spins m, ∫ x, mass (ψ.outerSlice s x)) = mass ψ := by
+  calc
+    _ = ∑ s : Spins m, ∑ t : Spins k, ∫ z, ‖ψ.value (outerAppend s t) z‖^2 := by
+      apply Finset.sum_congr rfl
+      intro s _
+      rw [integral_congr_ae (mass_outerSlice_ae ψ s), integral_finsetSum]
+      · apply Finset.sum_congr rfl
+        intro t _
+        have h := ((ψ.value_L2 (outerAppend s t)).comp_measurePreserving
+          (outerJoinConfiguration_measurePreserving m k)).integrable_norm_pow (p := 2) (by decide)
+        change Integrable (fun z : Configuration m × Configuration k =>
+          ‖ψ.value (outerAppend s t) (outerJoinConfiguration m k z)‖^2) (volume.prod volume) at h
+        rw [← integral_prod _ h]
+        exact (outerJoinConfiguration_measurePreserving m k).integral_comp'
+          (fun z => ‖ψ.value (outerAppend s t) z‖^2)
+      · intro t _
+        exact (((ψ.value_L2 (outerAppend s t)).comp_measurePreserving
+          (outerJoinConfiguration_measurePreserving m k)).integrable_norm_pow
+            (p := 2) (by decide)).integral_prod_left
+    _ = mass ψ := by
+      rw [← Fintype.sum_prod_type (f := fun st : Spins m × Spins k =>
+        ∫ z, ‖ψ.value (outerAppend st.1 st.2) z‖^2)]
+      exact Fintype.sum_equiv (outerAppendEquiv m k) _ _ (fun _ => rfl)
+
+lemma H1Vector.outerSlice_antisymmetric {m k : ℕ} (ψ : H1Vector (k+m)) (s : Spins m)
+    (hψ : ∀ (p : Equiv.Perm (Fin k)) (t : Spins k),
+      ∀ᵐ z ∂volume, ψ.value (outerAppend s t ∘ outerPerm m p) (permute (outerPerm m p) z) =
+        (((outerPerm m p).sign : ℤ) : ℂ) * ψ.value (outerAppend s t) z) :
+    ∀ᵐ x ∂volume, Antisymmetric (ψ.outerSlice s x) := by
+  have h (p : Equiv.Perm (Fin k)) (t : Spins k) :=
+    Measure.ae_ae_of_ae_prod ((outerJoinConfiguration_measurePreserving m k).quasiMeasurePreserving.ae (hψ p t))
+  have hall := ae_all_iff.mpr (fun p => ae_all_iff.mpr (h p))
+  filter_upwards [ψ.outerSliceRegular_ae s, hall] with x hx hxA
+  intro p t
+  filter_upwards [hxA p t] with y hy
+  change ψ.value (outerAppend s t ∘ outerPerm m p)
+      (permute (outerPerm m p) (outerJoinConfiguration m k (x,y))) =
+    (((outerPerm m p).sign : ℤ) : ℂ) * ψ.value (outerAppend s t)
+      (outerJoinConfiguration m k (x,y)) at hy
+  simpa only [ψ.outerSlice_value s hx, append_outerPerm, outerPerm_sign, permute_outer_join] using hy
+
+lemma Antisymmetric.outerSlice {m k : ℕ} {ψ : H1Vector (k+m)} (hψ : Antisymmetric ψ)
+    (s : Spins m) : ∀ᵐ x ∂volume, Antisymmetric (ψ.outerSlice s x) :=
+  ψ.outerSlice_antisymmetric s (fun p t => hψ (outerPerm m p) (outerAppend s t))
+
+lemma kinetic_outerSlice_ae {m k : ℕ} (ψ : H1Vector (k+m)) (s : Spins m) :
+    (fun x => kinetic (ψ.outerSlice s x)) =ᵐ[volume]
+      fun x => (1/2 : ℝ) * ∑ t : Spins k, ∑ a : Fin k × Fin 3,
+        ∫ y, ‖ψ.gradient (outerAppend s t) (Fin.castAdd m a.1,a.2)
+          (outerJoinConfiguration m k (x,y))‖^2 := by
+  filter_upwards [ψ.outerSliceRegular_ae s] with x hx
+  simp only [kinetic, ψ.outerSlice_gradient s hx]
+
+lemma kinetic_outerSlice_integrable {m k : ℕ} (ψ : H1Vector (k+m)) (s : Spins m) :
+    Integrable (fun x => kinetic (ψ.outerSlice s x)) := by
+  apply Integrable.congr _ (kinetic_outerSlice_ae ψ s).symm
+  apply Integrable.const_mul
+  apply integrable_finsetSum
+  intro t _
+  apply integrable_finsetSum
+  intro a _
+  exact (((ψ.partial_L2 (outerAppend s t) (Fin.castAdd m a.1,a.2)).comp_measurePreserving
+    (outerJoinConfiguration_measurePreserving m k)).integrable_norm_pow (p := 2) (by decide)).integral_prod_left
+
+lemma integral_kinetic_outerSlice {m k : ℕ} (ψ : H1Vector (k+m)) :
+    (∑ s : Spins m, ∫ x, kinetic (ψ.outerSlice s x)) =
+      (1/2 : ℝ) * ∑ st : Spins (k+m), ∑ a : Fin k × Fin 3,
+        ∫ z, ‖ψ.gradient st (Fin.castAdd m a.1,a.2) z‖^2 := by
+  have hs (s : Spins m) : (∫ x, kinetic (ψ.outerSlice s x)) =
+      (1/2 : ℝ) * ∑ t : Spins k, ∑ a : Fin k × Fin 3,
+        ∫ z, ‖ψ.gradient (outerAppend s t) (Fin.castAdd m a.1,a.2) z‖^2 := by
+    rw [integral_congr_ae (kinetic_outerSlice_ae ψ s), integral_const_mul]
+    congr 1
+    have hi (t : Spins k) (a : Fin k × Fin 3) :
+        Integrable (fun z : Configuration m × Configuration k =>
+          ‖ψ.gradient (outerAppend s t) (Fin.castAdd m a.1,a.2) (outerJoinConfiguration m k z)‖^2)
+          (volume.prod volume) :=
+      ((ψ.partial_L2 (outerAppend s t) (Fin.castAdd m a.1,a.2)).comp_measurePreserving
+        (outerJoinConfiguration_measurePreserving m k)).integrable_norm_pow (p := 2) (by decide)
+    rw [integral_finsetSum _ (fun t _ => integrable_finsetSum _ (fun a _ => (hi t a).integral_prod_left))]
+    apply Finset.sum_congr rfl
+    intro t _
+    rw [integral_finsetSum _ (fun a _ => (hi t a).integral_prod_left)]
+    apply Finset.sum_congr rfl
+    intro a _
+    rw [← integral_prod _ (hi t a)]
+    exact (outerJoinConfiguration_measurePreserving m k).integral_comp'
+      (fun z => ‖ψ.gradient (outerAppend s t) (Fin.castAdd m a.1,a.2) z‖^2)
+  simp_rw [hs]
+  rw [← Finset.mul_sum, ← Fintype.sum_prod_type (f := fun st : Spins m × Spins k =>
+    ∑ a : Fin k × Fin 3, ∫ z, ‖ψ.gradient (outerAppend st.1 st.2) (Fin.castAdd m a.1,a.2) z‖^2)]
+  congr 1
+  exact Fintype.sum_equiv (outerAppendEquiv m k) _ _ (fun _ => rfl)
+
+lemma potentialForm_outerSlice_ae {m k : ℕ} (ψ : H1Vector (k+m)) (s : Spins m)
+    (V : Configuration k → ℝ) :
+    (fun x => potentialForm V (ψ.outerSlice s x)) =ᵐ[volume]
+      fun x => ∑ t : Spins k, ∫ y, V y * ‖ψ.value (outerAppend s t) (outerJoinConfiguration m k (x,y))‖^2 := by
+  filter_upwards [ψ.outerSliceRegular_ae s] with x hx
+  simp only [potentialForm, ψ.outerSlice_value s hx]
+
+lemma potentialForm_outerSlice_integrable {m k : ℕ} (ψ : H1Vector (k+m)) (s : Spins m)
+    (V : Configuration k → ℝ)
+    (hV : ∀ t : Spins k, Integrable (fun z => V ((outerJoinConfiguration m k).symm z).2 *
+      ‖ψ.value (outerAppend s t) z‖^2)) :
+    Integrable (fun x => potentialForm V (ψ.outerSlice s x)) := by
+  apply Integrable.congr _ (potentialForm_outerSlice_ae ψ s V).symm
+  apply integrable_finsetSum
+  intro t _
+  have H := ((outerJoinConfiguration_measurePreserving m k).integrable_comp_emb
+    (outerJoinConfiguration m k).toHomeomorph.toMeasurableEquiv.measurableEmbedding).mpr (hV t)
+  have H' : Integrable (fun z : Configuration m × Configuration k =>
+      V z.2 * ‖ψ.value (outerAppend s t) (outerJoinConfiguration m k z)‖^2) (volume.prod volume) := by
+    change Integrable (fun z : Configuration m × Configuration k =>
+      V ((outerJoinConfiguration m k).symm (outerJoinConfiguration m k z)).2 *
+        ‖ψ.value (outerAppend s t) (outerJoinConfiguration m k z)‖^2) (volume.prod volume) at H
+    simpa only [ContinuousLinearEquiv.symm_apply_apply] using H
+  exact H'.integral_prod_left
+
+lemma integral_potentialForm_outerSlice {m k : ℕ} (ψ : H1Vector (k+m))
+    (V : Configuration k → ℝ)
+    (hV : ∀ st : Spins (k+m), Integrable (fun z => V ((outerJoinConfiguration m k).symm z).2 *
+      ‖ψ.value st z‖^2)) :
+    (∑ s : Spins m, ∫ x, potentialForm V (ψ.outerSlice s x)) =
+      ∑ st : Spins (k+m), ∫ z, V ((outerJoinConfiguration m k).symm z).2 * ‖ψ.value st z‖^2 := by
+  have hs (s : Spins m) : (∫ x, potentialForm V (ψ.outerSlice s x)) =
+      ∑ t : Spins k, ∫ z, V ((outerJoinConfiguration m k).symm z).2 * ‖ψ.value (outerAppend s t) z‖^2 := by
+    rw [integral_congr_ae (potentialForm_outerSlice_ae ψ s V)]
+    have hi (t : Spins k) : Integrable (fun z : Configuration m × Configuration k =>
+        V z.2 * ‖ψ.value (outerAppend s t) (outerJoinConfiguration m k z)‖^2) (volume.prod volume) := by
+      have H := ((outerJoinConfiguration_measurePreserving m k).integrable_comp_emb
+        (outerJoinConfiguration m k).toHomeomorph.toMeasurableEquiv.measurableEmbedding).mpr
+        (hV (outerAppend s t))
+      change Integrable (fun z : Configuration m × Configuration k =>
+        V ((outerJoinConfiguration m k).symm (outerJoinConfiguration m k z)).2 *
+          ‖ψ.value (outerAppend s t) (outerJoinConfiguration m k z)‖^2) (volume.prod volume) at H
+      simpa only [ContinuousLinearEquiv.symm_apply_apply] using H
+    rw [integral_finsetSum _ (fun t _ => (hi t).integral_prod_left)]
+    apply Finset.sum_congr rfl
+    intro t _
+    rw [← integral_prod _ (hi t)]
+    have H := (outerJoinConfiguration_measurePreserving m k).integral_comp'
+        (fun z => V ((outerJoinConfiguration m k).symm z).2 * ‖ψ.value (outerAppend s t) z‖^2)
+    change (∫ z : Configuration m × Configuration k,
+        V ((outerJoinConfiguration m k).symm (outerJoinConfiguration m k z)).2 *
+          ‖ψ.value (outerAppend s t) (outerJoinConfiguration m k z)‖^2 ∂volume.prod volume) = _ at H
+    simpa only [ContinuousLinearEquiv.symm_apply_apply] using H
+  simp_rw [hs]
+  rw [← Fintype.sum_prod_type (f := fun st : Spins m × Spins k =>
+    ∫ z, V ((outerJoinConfiguration m k).symm z).2 * ‖ψ.value (outerAppend st.1 st.2) z‖^2)]
+  exact Fintype.sum_equiv (outerAppendEquiv m k) _ _ (fun _ => rfl)
+
+lemma outerJoinConfiguration_symm_snd (m k : ℕ) (z : Configuration (k+m)) :
+    ((outerJoinConfiguration m k).symm z).2 = ((joinConfiguration k m).symm z).1 := rfl
+lemma outer_finePower_integrable {m k : ℕ} {b : ℝ} (hb : 0 < b)
+    (r : Configuration k → Finset (Fin k)) (hr : ∀ i, MeasurableSet {x | i ∈ r x})
+    (ψ : H1Vector (k+m)) (st : Spins (k+m)) :
+    Integrable (fun z => retainedFinePower b r ((outerJoinConfiguration m k).symm z).2 *
+      ‖ψ.value st z‖^2) := by
+  have hw : Integrable (fun z => ‖ψ.value st z‖^2) :=
+    (ψ.value_L2 st).integrable_norm_pow (p:=2) (by decide)
+  apply (hw.const_mul (((k:ℝ)*(b⁻¹)^3)^(2/3:ℝ)*k)).mono'
+  · exact ((retainedFinePower_measurable b r hr).comp
+      (measurable_snd.comp (outerJoinConfiguration m k).symm.continuous.measurable)).aestronglyMeasurable.mul hw.aestronglyMeasurable
+  · exact Eventually.of_forall fun z => by
+      rw [Real.norm_of_nonneg (mul_nonneg (retainedFinePower_nonneg ..) (sq_nonneg _))]
+      exact mul_le_mul_of_nonneg_right (retainedFinePower_bound hb r _) (sq_nonneg _)
+
+theorem outer_block_retained_fine_kinetic_lower {m k : ℕ} (ψ : H1Vector (k+m))
+    (hψ : ∀ (s : Spins m) (p : Equiv.Perm (Fin k)) (t : Spins k),
+      ∀ᵐ z ∂volume, ψ.value (outerAppend s t ∘ outerPerm m p) (permute (outerPerm m p) z) =
+        (((outerPerm m p).sign : ℤ) : ℂ) * ψ.value (outerAppend s t) z)
+    {b : ℝ} (hb : 0 < b) (r : Configuration k → Finset (Fin k))
+    (hr : ∀ i, MeasurableSet {x | i ∈ r x}) :
+    thomasFermiCoefficient * potentialForm
+      (fun z => retainedFinePower b r ((outerJoinConfiguration m k).symm z).2) ψ -
+      ((b⁻¹)^2 * ((Real.pi^2/2)*neumannBoundary) * (k:ℝ)^(4/3:ℝ)) * mass ψ ≤ outerKinetic (m:=k) (k:=m) ψ := by
+  let C := (b⁻¹)^2 * ((Real.pi^2/2)*neumannBoundary) * (k:ℝ)^(4/3:ℝ)
+  have hs (s : Spins m) :
+      thomasFermiCoefficient * (∫ x, potentialForm (retainedFinePower b r) (ψ.outerSlice s x)) -
+        C * (∫ x, mass (ψ.outerSlice s x)) ≤ ∫ x, kinetic (ψ.outerSlice s x) := by
+    rw [←integral_const_mul, ←integral_const_mul,
+      ←integral_sub ((potentialForm_outerSlice_integrable ψ s _ (fun t => outer_finePower_integrable hb r hr ψ (outerAppend s t))).const_mul _)
+        ((mass_outerSlice_integrable ψ s).const_mul C)]
+    apply integral_mono_ae
+      (((potentialForm_outerSlice_integrable ψ s _ (fun t => outer_finePower_integrable hb r hr ψ (outerAppend s t))).const_mul _).sub
+        ((mass_outerSlice_integrable ψ s).const_mul C)) (kinetic_outerSlice_integrable ψ s)
+    exact (ψ.outerSlice_antisymmetric s (hψ s)).mono fun x hx =>
+      retained_fine_kinetic_lower_all (ψ.outerSlice s x) hx hb r hr
+  have H := Finset.sum_le_sum (s:=Finset.univ) (fun s _ => hs s)
+  simp only [Finset.sum_sub_distrib, ←Finset.mul_sum] at H
+  rw [integral_potentialForm_outerSlice ψ _ (outer_finePower_integrable hb r hr ψ),
+    integral_mass_outerSlice, integral_kinetic_outerSlice] at H
+  exact H
+lemma ae_outer_block_position_injective (m k : ℕ) :
+    ∀ᵐ z : Configuration (k+m), Function.Injective (position ((outerJoinConfiguration m k).symm z).2) := by
+  filter_upwards [ae_position_injective (k+m)] with z hz
+  intro i j hij
+  have h : Fin.castAdd m i = Fin.castAdd m j := hz (by simpa only [outerJoinConfiguration_symm_snd, position_split_left] using hij)
+  exact Fin.ext (congrArg (fun z : Fin (k+m) => z.val) h)
+
+lemma ae_outer_fine_pair_bound {m k : ℕ} {b : ℝ} (hb : 0 < b)
+    (r : Configuration k → Finset (Fin k)) :
+    ∀ᵐ z : Configuration (k+m),
+      retainedFineCoulomb b r ((outerJoinConfiguration m k).symm z).2 ≤
+        pairPotential ((outerJoinConfiguration m k).symm z).2 + ((2*Real.pi+1)/(2*b))*k := by
+  filter_upwards [ae_outer_block_position_injective m k] with z hz
+  have h := retained_fine_pair_lower hb (r ((outerJoinConfiguration m k).symm z).2)
+    (position ((outerJoinConfiguration m k).symm z).2) hz
+  have hc : ((r ((outerJoinConfiguration m k).symm z).2).card : ℝ) ≤ k := by
+    exact_mod_cast (show (r ((outerJoinConfiguration m k).symm z).2).card ≤ k by simpa using Finset.card_le_univ (r ((outerJoinConfiguration m k).symm z).2))
+  have hC : 0 ≤ (2*Real.pi+1)/(2*b) := by positivity
+  have hh := mul_le_mul_of_nonneg_left hc hC
+  change retainedFineCoulomb b r ((outerJoinConfiguration m k).symm z).2 -
+    ((2*Real.pi+1)/(2*b))*(r ((outerJoinConfiguration m k).symm z).2).card ≤
+      pairPotential ((outerJoinConfiguration m k).symm z).2 at h
+  linarith
+
+lemma outer_fineCoulomb_integrable {m k : ℕ} {b : ℝ} (hb : 0 < b)
+    (r : Configuration k → Finset (Fin k)) (hr : ∀ i, MeasurableSet {x | i ∈ r x})
+    (ψ : H1Vector (k+m)) (st : Spins (k+m)) :
+    Integrable (fun z => retainedFineCoulomb b r ((outerJoinConfiguration m k).symm z).2 *
+      ‖ψ.value st z‖^2) := by
+  have hw : Integrable (fun z => ‖ψ.value st z‖^2) :=
+    (ψ.value_L2 st).integrable_norm_pow (p:=2) (by decide)
+  apply ((ψ.outer_pair_integrable st).add (hw.const_mul (((2*Real.pi+1)/(2*b))*k))).mono'
+  · exact ((retainedFineCoulomb_measurable b r hr).comp
+      (measurable_snd.comp (outerJoinConfiguration m k).symm.continuous.measurable)).aestronglyMeasurable.mul hw.aestronglyMeasurable
+  · filter_upwards [ae_outer_fine_pair_bound (m:=m) hb r] with z hz
+    rw [Real.norm_of_nonneg (mul_nonneg (retainedFineCoulomb_nonneg ..) (sq_nonneg _))]
+    simpa only [add_mul, Pi.add_apply, outerJoinConfiguration_symm_snd] using mul_le_mul_of_nonneg_right hz (sq_nonneg ‖ψ.value st z‖)
+
+theorem outer_block_retained_fine_pair_lower {m k : ℕ} (ψ : H1Vector (k+m))
+    {b : ℝ} (hb : 0 < b) (r : Configuration k → Finset (Fin k))
+    (hr : ∀ i, MeasurableSet {x | i ∈ r x}) :
+    potentialForm (fun z => retainedFineCoulomb b r ((outerJoinConfiguration m k).symm z).2) ψ -
+      (((2*Real.pi+1)/(2*b))*k)*mass ψ ≤
+    potentialForm (fun z => pairPotential ((outerJoinConfiguration m k).symm z).2) ψ :=
+  sub_le_iff_le_add.mpr (potentialForm_le_add_const ψ (outer_fineCoulomb_integrable hb r hr ψ)
+    ψ.outer_pair_integrable (ae_outer_fine_pair_bound hb r))
+
+theorem outer_block_retained_fine_energy_lower {m k : ℕ} (ψ : H1Vector (k+m))
+    (hψ : ∀ (s : Spins m) (p : Equiv.Perm (Fin k)) (t : Spins k),
+      ∀ᵐ z ∂volume, ψ.value (outerAppend s t ∘ outerPerm m p) (permute (outerPerm m p) z) =
+        (((outerPerm m p).sign : ℤ) : ℂ) * ψ.value (outerAppend s t) z)
+    {b : ℝ} (hb : 0 < b) (r : Configuration k → Finset (Fin k))
+    (hr : ∀ i, MeasurableSet {x | i ∈ r x}) :
+    thomasFermiCoefficient * potentialForm
+      (fun z => retainedFinePower b r ((outerJoinConfiguration m k).symm z).2) ψ +
+    potentialForm (fun z => retainedFineCoulomb b r ((outerJoinConfiguration m k).symm z).2) ψ -
+      (((b⁻¹)^2 * ((Real.pi^2/2)*neumannBoundary) * (k:ℝ)^(4/3:ℝ)) +
+        ((2*Real.pi+1)/(2*b))*k)*mass ψ ≤
+      outerKinetic (m:=k) (k:=m) ψ + potentialForm (fun z => pairPotential ((outerJoinConfiguration m k).symm z).2) ψ := by
+  have h1 := outer_block_retained_fine_kinetic_lower ψ hψ hb r hr
+  have h2 := outer_block_retained_fine_pair_lower ψ hb r hr
+  linarith
+end Coulomb
+
+open MeasureTheory Set Filter
+open scoped BigOperators ENNReal NNReal Classical
+
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/PairRegroup.lean

@@ -0,0 +1,94 @@
+import Mathlib
+
+namespace OAI
+
+section
+section
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+namespace Coulomb
+noncomputable def pairRegroup {A B C D : Type*} [MeasurableSpace A] [MeasurableSpace B]
+    [MeasurableSpace C] [MeasurableSpace D] : (A × B) × (C × D) ≃ᵐ (A × C) × (B × D) where
+  toFun p := ((p.1.1,p.2.1),(p.1.2,p.2.2))
+  invFun p := ((p.1.1,p.2.1),(p.1.2,p.2.2))
+  left_inv _ := rfl
+  right_inv _ := rfl
+  measurable_toFun := by change Measurable (fun p : (A × B) × (C × D) => ((p.1.1,p.2.1),(p.1.2,p.2.2))); fun_prop
+  measurable_invFun := by change Measurable (fun p : (A × C) × (B × D) => ((p.1.1,p.2.1),(p.1.2,p.2.2))); fun_prop
+lemma pairRegroup_measurePreserving {A B C D : Type*} [MeasurableSpace A] [MeasurableSpace B]
+    [MeasurableSpace C] [MeasurableSpace D] (μa : Measure A) (μb : Measure B)
+    (μc : Measure C) (μd : Measure D) [SFinite μa] [SFinite μb] [SFinite μc] [SFinite μd] :
+    MeasurePreserving (pairRegroup : (A×B)×(C×D) ≃ᵐ (A×C)×(B×D))
+      ((μa.prod μb).prod (μc.prod μd)) ((μa.prod μc).prod (μb.prod μd)) := by
+  have h1 := measurePreserving_prodAssoc μa μb (μc.prod μd)
+  have h2 := (MeasurePreserving.id μa).prod (measurePreserving_prodAssoc μb μc μd).symm
+  have h3 := (MeasurePreserving.id μa).prod
+    ((Measure.measurePreserving_swap (μ := μb) (ν := μc)).prod (MeasurePreserving.id μd))
+  have h4 := (MeasurePreserving.id μa).prod (measurePreserving_prodAssoc μc μb μd)
+  have h5 := (measurePreserving_prodAssoc μa μc (μb.prod μd)).symm
+  exact h5.comp (h4.comp (h3.comp (h2.comp h1)))
+
+lemma integrable_finite_count_prod {S E F : Type*} [Fintype S] [MeasurableSpace S]
+    [MeasurableSingletonClass S] [MeasurableSpace E] [NormedAddCommGroup F]
+    [NormedSpace ℝ F] {μ : Measure E} (f : S × E → F)
+    (hf : ∀ s, Integrable (fun x => f (s,x)) μ) : Integrable f (Measure.count.prod μ) := by
+  rw [Measure.prod, Measure.count,
+    Measure.bind_sum _ _ (measurable_of_countable _).aemeasurable]
+  simp only [Measure.dirac_bind (measurable_of_countable _)]
+  refine integrable_sum_measure (fun spin => ?_) (hasSum_fintype _).summable
+  exact (measurableEmbedding_prodMk_left spin).integrable_map_iff.mpr (hf spin)
+
+lemma integral_finite_count_prod {S E F : Type*} [Fintype S] [MeasurableSpace S]
+    [MeasurableSingletonClass S] [MeasurableSpace E] [NormedAddCommGroup F]
+    [NormedSpace ℝ F] [CompleteSpace F] {μ : Measure E} [SFinite μ] (f : S × E → F)
+    (hf : ∀ s, Integrable (fun x => f (s,x)) μ) :
+    (∫ sx, f sx ∂(Measure.count.prod μ)) = ∑ s, ∫ x, f (s,x) ∂μ := by
+  rw [integral_prod _ (integrable_finite_count_prod f hf), integral_count]
+lemma count_prod_count {S T : Type*} [Countable S] [Countable T] [MeasurableSpace S]
+    [MeasurableSpace T] [MeasurableSingletonClass S] [MeasurableSingletonClass T] :
+    (Measure.count : Measure S).prod (Measure.count : Measure T) = Measure.count := by
+  apply Measure.ext_of_singleton
+  intro st
+  rw [← singleton_prod_singleton, Measure.prod_prod]
+  simp
+end Coulomb
+
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+
+end
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/PatchNegativeMean.lean

@@ -0,0 +1,75 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.FieldAnalysis.CorePointMeasurable
+import OAI.Analysis.CoulombRadii.Variational.WeightedNegative
+
+namespace OAI
+
+section
+section
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+noncomputable section
+namespace Coulomb
+
+theorem exists_patch_negative_mean_bound :
+    ∃ C : ℝ, 0<C ∧ ∀ {J n : ℕ} (S : Nuclei J) (T : RecordedEnsemble n)
+    {a b t r : ℝ} (ha : 0<a) (hb : 0<b) (hsmall : 18*b≤a)
+    (ht : t∈Set.Icc (5*a) (6*a)) (y : Space)
+    (hn : ∀ j, 20*a≤‖S.position j-y‖),
+    T.CoreSupported {z | t≤‖z-y‖} → 0≤r → r≤a → C*(r/a)≤1/2 →
+    ∀ (χ : Space → ℝ) (K M : ℝ), 0≤K → 0<M → Measurable χ →
+    (∀ z, 0≤χ z ∧ χ z≤K) → (∀ z, χ z≠0 → ‖z-y‖≤r) →
+    (∀ p s, ∀ᵐ x, mass ((T.vector p).coreSlice s x)≠0 →
+      M≤∫ z, retainedFineDensity b (patchRetained y t b x) (position x) z*χ z) →
+    (∀ p s, Integrable (fun x => mass ((T.vector p).coreSlice s x)*
+      max (-patchTFScreenedField S ((T.vector p).coreSlice s x).normalized ha hb ht.2 y hn y) 0)) ∧
+    (∑ p, sliceExpectation (T.vector p) (fun s x =>
+      max (-patchTFScreenedField S ((T.vector p).coreSlice s x).normalized ha hb ht.2 y hn y) 0))≤
+      (2*K/M)*(∑ p, sliceExpectation (T.vector p) (patchSliceTFGap S (T.vector p) ha hb ht.2 y hn))+
+      (2*(C*(r/a))*(a^4)⁻¹)*T.totalMass := by
+  obtain ⟨C,hC,H⟩ := exists_patch_negative_center_bound
+  refine ⟨C,hC,?_⟩
+  intro J n S T a b t r ha hb hsmall ht y hn hcs hr hra hθ χ K M hK hM hχm hχ hs hmass
+  let Y := fun p s x => max (-patchTFScreenedField S ((T.vector p).coreSlice s x).normalized ha hb ht.2 y hn y) 0
+  let G := fun p s x => patchSliceTFGap S (T.vector p) ha hb ht.2 y hn s x
+  let A := 2*K/M
+  let d := 2*(C*(r/a))*(a^4)⁻¹
+  have hcs' (p : T.index) (s : Spins (T.out p)) : ∀ᵐ x,
+      SpatiallySupported ((T.vector p).coreSlice s x).normalized {z | t≤‖z-y‖} :=
+    ((hcs p).coreSlice s).mono (fun _ hx => hx.normalized)
+  have hGi (p : T.index) (s : Spins (T.out p)) :
+      Integrable (fun x => mass ((T.vector p).coreSlice s x)*G p s x) :=
+    patchSliceTFGap_weight_integrable S (T.vector p) ha hb ht.2 y hn s (hcs' p s)
+  have hYm (p : T.index) (s : Spins (T.out p)) : AEStronglyMeasurable (Y p s) volume :=
+    (patchTFScreenedField_slice_aestronglyMeasurable S (T.vector p) s ha hb ht.2 y hn y).neg.sup aestronglyMeasurable_const
+  have hY0 (p : T.index) (s : Spins (T.out p)) : ∀ᵐ x, 0≤Y p s x :=
+    Eventually.of_forall (fun _ => le_max_right _ _)
+  have hbound (p : T.index) (s : Spins (T.out p)) : ∀ᵐ x,
+      mass ((T.vector p).coreSlice s x)≠0 → Y p s x≤A*G p s x+d := by
+    filter_upwards [hcs' p s,hmass p s] with x hx hm
+    intro hw
+    apply H S ((T.vector p).coreSlice s x).normalized ha hb hsmall ht y hx hn hr hra hθ x χ K M hK hM
+      (Eventually.of_forall hχ) _ hs (hm hw)
+    exact (retainedFineDensity_integrable hb _ _).mul_bdd hχm.aestronglyMeasurable
+      (Eventually.of_forall (fun z => by rw [Real.norm_of_nonneg (hχ z).1]; exact (hχ z).2))
+  have hYi (p : T.index) (s : Spins (T.out p)) :
+      Integrable (fun x => mass ((T.vector p).coreSlice s x)*Y p s x) :=
+    NeutralAtom.weighted_nonneg_integrable_of_le (mass_coreSlice_integrable (T.vector p) s)
+      (Eventually.of_forall (fun _ => mass_nonneg _)) (hYm p s) (hY0 p s) (hGi p s) (hbound p s)
+  refine ⟨hYi,?_⟩
+  have hmean (p : T.index) : sliceExpectation (T.vector p) (Y p)≤
+      A*sliceExpectation (T.vector p) (G p)+d*mass (T.vector p) := by
+    have HH := Finset.sum_le_sum (s := Finset.univ) (fun s _ =>
+      NeutralAtom.weighted_integral_le (mass_coreSlice_integrable (T.vector p) s)
+        (Eventually.of_forall (fun _ => mass_nonneg _)) (hYm p s) (hY0 p s) (hGi p s) (hbound p s))
+    simpa only [Finset.sum_add_distrib,←Finset.mul_sum,integral_mass_coreSlice,sliceExpectation] using HH
+  have HH := Finset.sum_le_sum (s := Finset.univ) (fun p _ => hmean p)
+  simpa only [Finset.sum_add_distrib,←Finset.mul_sum,RecordedEnsemble.totalMass,Y,G,A,d] using HH
+
+end Coulomb
+end
+
+end
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/PatchRawTransfer.lean

@@ -0,0 +1,69 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.FieldAnalysis.CoulombTransfer
+import OAI.Analysis.CoulombRadii.Packets.FineNear
+
+namespace OAI
+
+section
+section
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+noncomputable section
+namespace Coulomb
+
+lemma sqrt_young (x : ℝ) (hx : 0≤x) {ε : ℝ} (hε : 0<ε) :
+    Real.sqrt x≤ε+x/(4*ε) := by
+  have h := sq_nonneg (Real.sqrt x-2*ε)
+  rw [sub_sq,Real.sq_sqrt hx] at h
+  have he : x/(4*ε)*(4*ε)=x := div_mul_cancel₀ _ (by positivity)
+  apply (mul_le_mul_iff_of_pos_right (show 0<4*ε by positivity)).mp
+  nlinarith
+
+theorem patch_raw_field_transfer {J m k : ℕ} (S : Nuclei J) (u : H1Vector (m+k))
+    {a b t r : ℝ} (ha : 0<a) (hb : 0<b) (hsmall : 18*b≤a)
+    (ht : t∈Set.Icc (5*a) (6*a)) (y : Space)
+    (hn : ∀ j, 20*a≤‖S.position j-y‖) (hr : 0<r) (hra : r≤a)
+    (spin : Spins m) (x : Configuration m)
+    (hcs : SpatiallySupported (u.coreSlice spin x).normalized {z | t≤‖z-y‖})
+    (hxy : ∀ i,position x i≠y) :
+    |(coreScreenedField S (u.coreSlice spin x).normalized y-nuclearPotential (unitNucleus y) x)-
+      patchTFScreenedField S (u.coreSlice spin x).normalized ha hb ht.2 y hn y|≤
+      Real.sqrt ((5/r)*patchSliceTFGap S u ha hb ht.2 y hn spin x)+
+      nearPotential y (r+2*b) x+nearPotential y (2*b) x+
+      ((deletedLabels (patchRetained y t b) x).card:ℝ)/a+
+      ((tfInteriorConstant thomasFermiKineticConstant/
+        (thomasFermiKineticConstant*(5/3:ℝ)))^(3/2:ℝ)/a^6)*(2*Real.pi*r^2) := by
+  let σ := retainedFineDensity b (patchRetained y t b x) (position x)
+  let W := coreTFField S (u.coreSlice spin x).normalized measurableSet_ball ha
+    (patch_nucleus_separation S ha hb ht.2 y hn)
+  have hf := patch_potential_transfer S u ha hb hsmall ht y hn hr hra spin x hcs
+  have hn' := retainedFine_near_le hb y r (patchRetained y t b x) x hxy
+  have hdiff := patchFine_raw_deficit (t := t) hb ha (by linarith [ht.1]) y x hxy
+  have ht' := abs_sub_le (nuclearPotential (unitNucleus y) x) (NeutralAtom.potentialOf σ y)
+    (tfPotential (localTFMinimizer measurableSet_ball W) y)
+  rw [abs_of_nonneg hdiff.1] at ht'
+  have he : |(coreScreenedField S (u.coreSlice spin x).normalized y-nuclearPotential (unitNucleus y) x)-
+      patchTFScreenedField S (u.coreSlice spin x).normalized ha hb ht.2 y hn y|=
+      |nuclearPotential (unitNucleus y) x-tfPotential (localTFMinimizer measurableSet_ball W) y| := by
+    unfold patchTFScreenedField
+    rw [show (coreScreenedField S (u.coreSlice spin x).normalized y-nuclearPotential (unitNucleus y) x)-
+        (coreScreenedField S (u.coreSlice spin x).normalized y-tfPotential
+        (localTFMinimizer measurableSet_ball W) y)=
+        -(nuclearPotential (unitNucleus y) x-tfPotential (localTFMinimizer measurableSet_ball W) y) by ring,
+      abs_neg]
+  rw [he]
+  have heint : (∫ z in Metric.ball y r,σ z*coulombKernel (y-z))=
+      (∫ z in Metric.ball y r,coulombKernel (y-z)*σ z) := by
+    apply integral_congr_ae
+    exact Eventually.of_forall (fun z => mul_comm _ _)
+  dsimp only [σ,W] at ht' heint
+  dsimp only at hf
+  rw [heint] at hf
+  linarith
+end Coulomb
+end
+
+end
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/PermOrCompSwapOffTwo.lean

@@ -0,0 +1,275 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.FieldAnalysis.DeterminantWave
+
+namespace OAI
+
+section
+section
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+namespace Coulomb
+
+lemma perm_eq_or_comp_swap_of_eq_off_two {α : Type*} [DecidableEq α]
+    (p q : Equiv.Perm α) (i j : α) (_hij : i ≠ j)
+    (h : ∀ k, k ≠ i → k ≠ j → p k = q k) :
+    q = p ∨ q = p * Equiv.swap i j := by
+  by_cases hi : p i = q i
+  · left
+    symm
+    apply perm_eq_of_eq_off p q j
+    intro k hkj
+    by_cases hki : k = i
+    · simpa only [hki] using hi
+    · exact h k hki hkj
+  · right
+    have hki : q.symm (p i) ≠ i := by
+      intro he
+      apply hi
+      simpa only [he] using (q.apply_symm_apply (p i)).symm
+    have hkj : q.symm (p i) = j := by
+      by_contra he
+      have H : p (q.symm (p i)) = p i := (h _ hki he).trans (q.apply_symm_apply _)
+      exact hki (p.injective H)
+    have hji : p i = q j := by simpa only [hkj] using (q.apply_symm_apply (p i)).symm
+    have hE : p = q * Equiv.swap i j := by
+      apply perm_eq_of_eq_off p (q * Equiv.swap i j) j
+      intro k hkj'
+      by_cases hki' : k = i
+      · subst k
+        simpa only [Equiv.Perm.mul_apply, Equiv.swap_apply_left] using hji
+      · simpa only [Equiv.Perm.mul_apply, Equiv.swap_apply_of_ne_of_ne hki' hkj'] using h k hki' hkj'
+    rw [hE, mul_assoc, Equiv.swap_mul_self, mul_one]
+
+lemma perm_mul_swap_ne {α : Type*} [DecidableEq α] (p : Equiv.Perm α)
+    (i j : α) (hij : i ≠ j) : p * Equiv.swap i j ≠ p := by
+  intro h
+  have H := congrArg (fun r : Equiv.Perm α => r i) h
+  simp only [Equiv.Perm.mul_apply, Equiv.swap_apply_left] at H
+  exact hij (p.injective H).symm
+
+lemma permutation_second_minor {α : Type*} [Fintype α] [DecidableEq α]
+    (p q : Equiv.Perm α) (i j : α) (hij : i ≠ j) :
+    (∏ k ∈ (Finset.univ.erase i).erase j, if p k = q k then (1 : ℂ) else 0) =
+      (if q = p then 1 else 0) + (if q = p * Equiv.swap i j then 1 else 0) := by
+  by_cases h1 : q = p
+  · subst q
+    simp [Ne.symm (perm_mul_swap_ne p i j hij)]
+  by_cases h2 : q = p * Equiv.swap i j
+  · rw [ite_eq_right h1, ite_eq_left h2, zero_add]
+    apply Finset.prod_eq_one
+    intro k hk
+    obtain ⟨hkj,hki,_⟩ := Finset.mem_erase.mp hk |>.imp_right Finset.mem_erase.mp
+    simp only [h2, Equiv.Perm.mul_apply, Equiv.swap_apply_of_ne_of_ne hki hkj, ite_true]
+  · rw [ite_eq_right h1, ite_eq_right h2, zero_add]
+    obtain ⟨k,hki,hkj,hk⟩ : ∃ k, k ≠ i ∧ k ≠ j ∧ p k ≠ q k := by
+      by_contra he
+      have h := perm_eq_or_comp_swap_of_eq_off_two p q i j hij (fun k hki hkj => by
+        by_contra hk
+        exact he ⟨k,hki,hkj,hk⟩)
+      exact h.elim h1 h2
+    exact Finset.prod_eq_zero (Finset.mem_erase.mpr ⟨hkj,Finset.mem_erase.mpr ⟨hki,Finset.mem_univ _⟩⟩)
+      (ite_eq_right hk)
+
+lemma sign_star_mul_swap {n : ℕ} (p : Equiv.Perm (Fin n)) (i j : Fin n) (hij : i ≠ j) :
+    star (((p.sign : ℤ) : ℂ)) * ((((p * Equiv.swap i j).sign : ℤ) : ℂ)) = -1 := by
+  rw [map_mul, Equiv.Perm.sign_swap hij]
+  simp only [Units.val_mul, Units.val_neg, Units.val_one, Int.cast_mul, Int.cast_neg,
+    Int.cast_one, ← mul_assoc, sign_star_mul, one_mul]
+
+lemma pair_minor_trace {n : ℕ} (K : Fin n → Fin n → Fin n → Fin n → ℂ)
+    (p : Equiv.Perm (Fin n)) (i j : Fin n) (hij : i ≠ j) :
+    (∑ q : Equiv.Perm (Fin n), star (((p.sign : ℤ) : ℂ)) * (((q.sign : ℤ) : ℂ)) *
+        (K (p i) (p j) (q i) (q j) *
+          ∏ k ∈ (Finset.univ.erase i).erase j, if p k = q k then (1:ℂ) else 0)) =
+      K (p i) (p j) (p i) (p j) - K (p i) (p j) (p j) (p i) := by
+  simp_rw [permutation_second_minor p _ i j hij, mul_add, Finset.sum_add_distrib]
+  have h1 : (∑ q : Equiv.Perm (Fin n), star (((p.sign : ℤ) : ℂ)) * (((q.sign : ℤ) : ℂ)) *
+      (K (p i) (p j) (q i) (q j) * (if q = p then 1 else 0))) = K (p i) (p j) (p i) (p j) := by
+    rw [Finset.sum_eq_single p]
+    · simp only [ite_true, mul_one, sign_star_mul, one_mul]
+    · intro q _ hq
+      simp only [ite_eq_right hq, mul_zero]
+    · simp
+  have h2 : (∑ q : Equiv.Perm (Fin n), star (((p.sign : ℤ) : ℂ)) * (((q.sign : ℤ) : ℂ)) *
+      (K (p i) (p j) (q i) (q j) * (if q = p * Equiv.swap i j then 1 else 0))) =
+        -K (p i) (p j) (p j) (p i) := by
+    rw [Finset.sum_eq_single (p * Equiv.swap i j)]
+    · simp only [ite_true, mul_one, sign_star_mul_swap p i j hij, neg_one_mul,
+        Equiv.Perm.mul_apply, Equiv.swap_apply_left, Equiv.swap_apply_right]
+    · intro q _ hq
+      simp only [ite_eq_right hq, mul_zero]
+    · simp
+  rw [h1,h2,sub_eq_add_neg]
+
+lemma pair_trace_reindex {n : ℕ} (K : Fin n → Fin n → Fin n → Fin n → ℂ)
+    (p : Equiv.Perm (Fin n)) :
+    (∑ i, ∑ j ∈ Finset.univ.erase i,
+      (K (p i) (p j) (p i) (p j) - K (p i) (p j) (p j) (p i))) =
+      ∑ i, ∑ j, (K i j i j - K i j j i) := by
+  have he (i : Fin n) : (∑ j ∈ Finset.univ.erase i,
+      (K (p i) (p j) (p i) (p j) - K (p i) (p j) (p j) (p i))) =
+      ∑ j, (K (p i) (p j) (p i) (p j) - K (p i) (p j) (p j) (p i)) := by
+    rw [Finset.sum_erase_eq_sub (Finset.mem_univ i)]
+    simp only [sub_self, sub_zero]
+  simp_rw [he]
+  have hi (i : Fin n) : (∑ j, (K (p i) (p j) (p i) (p j) - K (p i) (p j) (p j) (p i))) =
+      ∑ j, (K (p i) j (p i) j - K (p i) j j (p i)) :=
+    Equiv.sum_comp p (fun j => K (p i) j (p i) j - K (p i) j j (p i))
+  simp_rw [hi]
+  exact Equiv.sum_comp p (fun i => ∑ j, (K i j i j - K i j j i))
+
+lemma slater_two_body_trace_algebra {n : ℕ} (K : Fin n → Fin n → Fin n → Fin n → ℂ) :
+    (∑ p : Equiv.Perm (Fin n), ∑ q : Equiv.Perm (Fin n),
+      star (((p.sign : ℤ) : ℂ)) * (((q.sign : ℤ) : ℂ)) *
+        ∑ i, ∑ j ∈ Finset.univ.erase i,
+          K (p i) (p j) (q i) (q j) *
+            ∏ k ∈ (Finset.univ.erase i).erase j, if p k = q k then (1:ℂ) else 0) =
+      (n.factorial : ℂ) * ∑ i, ∑ j, (K i j i j - K i j j i) := by
+  have hp (p : Equiv.Perm (Fin n)) :
+      (∑ q : Equiv.Perm (Fin n), star (((p.sign : ℤ) : ℂ)) * (((q.sign : ℤ) : ℂ)) *
+        ∑ i, ∑ j ∈ Finset.univ.erase i,
+          K (p i) (p j) (q i) (q j) *
+            ∏ k ∈ (Finset.univ.erase i).erase j, if p k = q k then (1:ℂ) else 0) =
+      ∑ i, ∑ j, (K i j i j - K i j j i) := by
+    simp_rw [Finset.mul_sum]
+    rw [Finset.sum_comm]
+    calc
+      _ = ∑ i, ∑ j ∈ Finset.univ.erase i,
+          (K (p i) (p j) (p i) (p j) - K (p i) (p j) (p j) (p i)) := by
+        apply Finset.sum_congr rfl
+        intro i _
+        rw [Finset.sum_comm]
+        apply Finset.sum_congr rfl
+        intro j hj
+        exact pair_minor_trace K p i j (Finset.mem_erase.mp hj).1.symm
+      _ = _ := pair_trace_reindex K p
+  simp_rw [hp]
+  simp only [Finset.sum_const, Finset.card_univ, Fintype.card_perm, Fintype.card_fin,
+    nsmul_eq_mul]
+
+end Coulomb
+
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+namespace Coulomb
+
+noncomputable def pairIndexEquiv {I : Type*} [DecidableEq I] (i j : I) (hij : i ≠ j) :
+    Fin 2 ≃ {k : I // k = i ∨ k = j} where
+  toFun b := if b = 0 then ⟨i, Or.inl rfl⟩ else ⟨j, Or.inr rfl⟩
+  invFun k := if k.1 = i then 0 else 1
+  left_inv b := by fin_cases b <;> simp [Ne.symm hij]
+  right_inv k := by
+    rcases k with ⟨k,hk | hk⟩ <;> subst k <;> simp [Ne.symm hij]
+
+noncomputable def pairSelectedEquiv {I A : Type*} [DecidableEq I] [MeasurableSpace A]
+    (i j : I) (hij : i ≠ j) : ({k : I // k = i ∨ k = j} → A) ≃ᵐ (A × A) :=
+  (MeasurableEquiv.piCongrLeft (fun _ : {k : I // k = i ∨ k = j} => A)
+    (pairIndexEquiv i j hij)).symm.trans MeasurableEquiv.finTwoArrow
+
+noncomputable def pairSplit {I A : Type*} [DecidableEq I] [MeasurableSpace A]
+    (i j : I) (hij : i ≠ j) : (I → A) ≃ᵐ (A × A) × ({k : I // ¬ (k = i ∨ k = j)} → A) :=
+  (MeasurableEquiv.piEquivPiSubtypeProd (fun _ : I => A) (fun k => k = i ∨ k = j)).trans
+    ((pairSelectedEquiv i j hij).prodCongr (MeasurableEquiv.refl _))
+
+lemma pairSplit_first {I A : Type*} [DecidableEq I] [MeasurableSpace A]
+    (i j : I) (hij : i ≠ j) (x : I → A) : ((pairSplit i j hij) x).1.1 = x i := by
+  change x ((pairIndexEquiv i j hij) 0).1 = x i
+  simp [pairIndexEquiv]
+
+lemma pairSplit_second {I A : Type*} [DecidableEq I] [MeasurableSpace A]
+    (i j : I) (hij : i ≠ j) (x : I → A) : ((pairSplit i j hij) x).1.2 = x j := by
+  change x ((pairIndexEquiv i j hij) 1).1 = x j
+  simp [pairIndexEquiv]
+
+lemma pairSplit_rest {I A : Type*} [DecidableEq I] [MeasurableSpace A]
+    (i j : I) (hij : i ≠ j) (x : I → A) (k : {k : I // ¬ (k = i ∨ k = j)}) :
+    ((pairSplit i j hij) x).2 k = x k := rfl
+
+lemma pairSplit_measurePreserving {I A : Type*} [Fintype I] [DecidableEq I] [MeasurableSpace A]
+    (μ : Measure A) [SigmaFinite μ] (i j : I) (hij : i ≠ j) :
+    MeasurePreserving (pairSplit (A := A) i j hij) (Measure.pi fun _ => μ)
+      ((μ.prod μ).prod (Measure.pi fun _ => μ)) := by
+  have hp : MeasurePreserving (pairSelectedEquiv (A := A) i j hij)
+      (Measure.pi fun _ => μ) (μ.prod μ) :=
+    (measurePreserving_finTwoArrow μ).comp
+      ((measurePreserving_piCongrLeft (fun _ => μ) (pairIndexEquiv i j hij)).symm)
+  exact (hp.prod (MeasurePreserving.id _)).comp
+    (measurePreserving_piEquivPiSubtypeProd (fun _ => μ) (fun k => k = i ∨ k = j))
+
+lemma prod_erase_pair {I : Type*} [Fintype I] [DecidableEq I] (i j : I) (hij : i ≠ j)
+    (f : I → ℂ) :
+    (∏ k, f k) = (f i * f j) * ∏ k : {k : I // ¬ (k = i ∨ k = j)}, f k := by
+  rw [← Finset.mul_prod_erase Finset.univ f (Finset.mem_univ i),
+    ← Finset.mul_prod_erase (Finset.univ.erase i) f (Finset.mem_erase.mpr ⟨Ne.symm hij, Finset.mem_univ j⟩),
+    ← mul_assoc]
+  congr 1
+  exact Finset.prod_subtype ((Finset.univ.erase i).erase j) (fun k => by simp [and_comm]) f
+
+lemma pair_weight_tensor_integrable {I A : Type*} [Fintype I] [DecidableEq I]
+    [MeasurableSpace A] {μ : Measure A} [SigmaFinite μ] (i j : I) (hij : i ≠ j)
+    (f : I → A → ℂ) (w : A → A → ℂ) (hf : ∀ k, Integrable (f k) μ)
+    (hw : Integrable (fun ab : A × A => w ab.1 ab.2 * (f i ab.1 * f j ab.2)) (μ.prod μ)) :
+    Integrable (fun x : I → A => w (x i) (x j) * ∏ k, f k (x k)) (Measure.pi fun _ => μ) := by
+  have hR : Integrable (fun x : {k : I // ¬ (k = i ∨ k = j)} → A => ∏ k : {k : I // ¬ (k = i ∨ k = j)}, f k (x k))
+      (Measure.pi fun _ => μ) := Integrable.fintype_prod (fun k => hf k)
+  have h := (pairSplit_measurePreserving μ i j hij).integrable_comp_of_integrable (hw.mul_prod hR)
+  convert h using 1
+  funext x
+  simp only [Function.comp_apply, pairSplit_first, pairSplit_second, pairSplit_rest,
+    prod_erase_pair i j hij]
+  ring
+
+lemma pair_weight_tensor_integral {I A : Type*} [Fintype I] [DecidableEq I]
+    [MeasurableSpace A] {μ : Measure A} [SigmaFinite μ] (i j : I) (hij : i ≠ j)
+    (f : I → A → ℂ) (w : A → A → ℂ) :
+    (∫ x : I → A, w (x i) (x j) * ∏ k, f k (x k) ∂(Measure.pi fun _ => μ)) =
+      (∫ ab : A × A, w ab.1 ab.2 * (f i ab.1 * f j ab.2) ∂(μ.prod μ)) *
+        ∏ k ∈ (Finset.univ.erase i).erase j, ∫ a, f k a ∂μ := by
+  have he (x : I → A) : w (x i) (x j) * ∏ k, f k (x k) =
+      (w ((pairSplit i j hij) x).1.1 ((pairSplit i j hij) x).1.2 *
+        (f i ((pairSplit i j hij) x).1.1 * f j ((pairSplit i j hij) x).1.2)) *
+          ∏ k : {k : I // ¬ (k = i ∨ k = j)}, f k (((pairSplit i j hij) x).2 k) := by
+    simp only [pairSplit_first, pairSplit_second, pairSplit_rest, prod_erase_pair i j hij]
+    ring
+  simp_rw [he]
+  rw [(pairSplit_measurePreserving μ i j hij).integral_comp'
+    (fun z => (w z.1.1 z.1.2 * (f i z.1.1 * f j z.1.2)) * ∏ k : {k : I // ¬ (k = i ∨ k = j)}, f k (z.2 k)),
+    integral_prod_mul (fun ab : A × A => w ab.1 ab.2 * (f i ab.1 * f j ab.2))
+      (fun x : {k : I // ¬ (k = i ∨ k = j)} → A => ∏ k, f k.1 (x k)),
+    integral_fintype_prod_eq_prod]
+  congr 1
+  exact (Finset.prod_subtype ((Finset.univ.erase i).erase j) (fun k => by simp [and_comm]) (fun k => ∫ a, f k a ∂μ)).symm
+
+end Coulomb
+
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+
+end
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/PermuteJoinBlock.lean

@@ -0,0 +1,234 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.FormDomain.Pullback
+import OAI.Analysis.CoulombRadii.FieldAnalysis.JoinSpins
+
+namespace OAI
+
+noncomputable section
+
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set
+open scoped BigOperators ENNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open scoped Classical
+namespace Coulomb
+lemma permute_join_block {m k : ℕ} (p : Equiv.Perm (Fin m)) (q : Equiv.Perm (Fin k))
+    (x : Configuration m) (y : Configuration k) :
+    permute (blockHom m k (p,q)) (joinConfiguration m k (x,y)) =
+      joinConfiguration m k (permute p x, permute q y) := by
+  ext ⟨i,b⟩
+  refine Fin.addCases ?_ ?_ i
+  · intro j
+    change joinConfiguration m k (x,y) (blockHom m k (p,q) (Fin.castAdd k j),b) = _
+    rw [blockHom_left, joinConfiguration_left, joinConfiguration_left]
+    rfl
+  · intro j
+    change joinConfiguration m k (x,y) (blockHom m k (p,q) (Fin.natAdd m j),b) = _
+    rw [blockHom_right, joinConfiguration_right, joinConfiguration_right]
+    rfl
+
+lemma spins_block_left {m k : ℕ} (p : Equiv.Perm (Fin m)) (q : Equiv.Perm (Fin k))
+    (s : Spins (m+k)) :
+    (s ∘ blockHom m k (p,q)) ∘ Fin.castAdd k = (s ∘ Fin.castAdd k) ∘ p := by
+  funext i
+  simp [Function.comp_def, blockHom_left]
+lemma spins_block_right {m k : ℕ} (p : Equiv.Perm (Fin m)) (q : Equiv.Perm (Fin k))
+    (s : Spins (m+k)) :
+    (s ∘ blockHom m k (p,q)) ∘ Fin.natAdd m = (s ∘ Fin.natAdd m) ∘ q := by
+  funext i
+  simp [Function.comp_def, blockHom_right]
+
+lemma tensor_block_covariance {m k : ℕ} (u : H1Vector m) (v : H1Vector k)
+    (hu : Antisymmetric u) (hv : Antisymmetric v)
+    (h : Equiv.Perm (Fin (m+k))) (hh : h ∈ blockGroup m k) (s : Spins (m+k)) :
+    (u.tensor v).permutation h |>.value s =ᵐ[volume]
+      fun x => ((h.sign : ℤ) : ℂ)*(u.tensor v).value s x := by
+  rcases hh with ⟨⟨p,q⟩,rfl⟩
+  have H1 : ∀ᵐ z : Configuration m × Configuration k ∂(volume.prod volume),
+      u.value ((s ∘ Fin.castAdd k) ∘ p) (permute p z.1) =
+        ((p.sign : ℤ) : ℂ)*u.value (s ∘ Fin.castAdd k) z.1 :=
+    Measure.quasiMeasurePreserving_fst.ae (hu p (s ∘ Fin.castAdd k))
+  have H2 : ∀ᵐ z : Configuration m × Configuration k ∂(volume.prod volume),
+      v.value ((s ∘ Fin.natAdd m) ∘ q) (permute q z.2) =
+        ((q.sign : ℤ) : ℂ)*v.value (s ∘ Fin.natAdd m) z.2 :=
+    Measure.quasiMeasurePreserving_snd.ae (hv q (s ∘ Fin.natAdd m))
+  have H1' := (joinConfiguration_symm_measurePreserving m k).quasiMeasurePreserving.ae H1
+  have H2' := (joinConfiguration_symm_measurePreserving m k).quasiMeasurePreserving.ae H2
+  filter_upwards [H1',H2'] with x hx hy
+  obtain ⟨⟨x,y⟩,rfl⟩ := (joinConfiguration m k).surjective x
+  have hez : (joinConfiguration m k).symm.toHomeomorph.toMeasurableEquiv
+      ((joinConfiguration m k) (x,y)) = (x,y) :=
+    (joinConfiguration m k).symm_apply_apply (x,y)
+  rw [hez] at hx hy
+  change u.value ((s ∘ Fin.castAdd k) ∘ p) (permute p x) =
+    ((p.sign : ℤ) : ℂ)*u.value (s ∘ Fin.castAdd k) x at hx
+  change v.value ((s ∘ Fin.natAdd m) ∘ q) (permute q y) =
+    ((q.sign : ℤ) : ℂ)*v.value (s ∘ Fin.natAdd m) y at hy
+  rw [permutation_value]
+  change tensorValue u v (s ∘ blockHom m k (p,q))
+    (permute (blockHom m k (p,q)) (joinConfiguration m k (x,y))) =
+    (((blockHom m k (p,q)).sign : ℤ) : ℂ)*tensorValue u v s (joinConfiguration m k (x,y))
+  rw [permute_join_block, tensorValue_join, tensorValue_join, spins_block_left,
+    spins_block_right, blockHom_sign, hx, hy]
+  push_cast
+  ring
+lemma position_join_left {m k : ℕ} (x : Configuration m) (y : Configuration k) (i : Fin m) :
+    position (joinConfiguration m k (x,y)) (Fin.castAdd k i) = position x i := by
+  ext b
+  exact joinConfiguration_left m k x y i b
+lemma position_join_right {m k : ℕ} (x : Configuration m) (y : Configuration k) (i : Fin k) :
+    position (joinConfiguration m k (x,y)) (Fin.natAdd m i) = position y i := by
+  ext b
+  exact joinConfiguration_right m k x y i b
+
+lemma position_split_left {m k : ℕ} (x : Configuration (m+k)) (i : Fin m) :
+    position ((joinConfiguration m k).symm x).1 i = position x (Fin.castAdd k i) := by
+  obtain ⟨⟨y,z⟩,rfl⟩ := (joinConfiguration m k).surjective x
+  rw [ContinuousLinearEquiv.symm_apply_apply, position_join_left]
+lemma position_split_right {m k : ℕ} (x : Configuration (m+k)) (i : Fin k) :
+    position ((joinConfiguration m k).symm x).2 i = position x (Fin.natAdd m i) := by
+  obtain ⟨⟨y,z⟩,rfl⟩ := (joinConfiguration m k).surjective x
+  rw [ContinuousLinearEquiv.symm_apply_apply, position_join_right]
+
+def blockRegion (m k : ℕ) (A B : Set Space) : Set (Configuration (m+k)) :=
+  {x | (∀ i : Fin m, position x (Fin.castAdd k i) ∈ A) ∧
+    (∀ j : Fin k, position x (Fin.natAdd m j) ∈ B)}
+
+lemma blockRegion_split {m k : ℕ} (A B : Set Space) (x : Configuration (m+k)) :
+    x ∈ blockRegion m k A B ↔
+      ((joinConfiguration m k).symm x).1 ∈ allPositions A ∧
+      ((joinConfiguration m k).symm x).2 ∈ allPositions B := by
+  simp only [blockRegion, allPositions, Set.mem_ofPred_eq, position_split_left,
+    position_split_right]
+
+lemma isClosed_blockRegion {m k : ℕ} {A B : Set Space} (hA : IsClosed A) (hB : IsClosed B) :
+    IsClosed (blockRegion m k A B) := by
+  have he : blockRegion m k A B =
+      (⋂ i : Fin m, (fun x => position x (Fin.castAdd k i)) ⁻¹' A) ∩
+      (⋂ j : Fin k, (fun x => position x (Fin.natAdd m j)) ⁻¹' B) := by
+    ext x
+    simp [blockRegion]
+  rw [he]
+  exact (isClosed_iInter (fun i => hA.preimage (continuous_position _))).inter
+    (isClosed_iInter (fun j => hB.preimage (continuous_position _)))
+
+lemma tensor_configSupported {m k : ℕ} (u : H1Vector m) (v : H1Vector k) (A B : Set Space)
+    (hu : SpatiallySupported u A) (hv : SpatiallySupported v B) :
+    ConfigSupported (u.tensor v) (blockRegion m k A B) := by
+  intro s
+  have H1 : ∀ᵐ z : Configuration m × Configuration k ∂(volume.prod volume),
+      z.1 ∉ allPositions A → u.value (s ∘ Fin.castAdd k) z.1 = 0 :=
+    Measure.quasiMeasurePreserving_fst.ae (hu (s ∘ Fin.castAdd k))
+  have H2 : ∀ᵐ z : Configuration m × Configuration k ∂(volume.prod volume),
+      z.2 ∉ allPositions B → v.value (s ∘ Fin.natAdd m) z.2 = 0 :=
+    Measure.quasiMeasurePreserving_snd.ae (hv (s ∘ Fin.natAdd m))
+  have H1' := (joinConfiguration_symm_measurePreserving m k).quasiMeasurePreserving.ae H1
+  have H2' := (joinConfiguration_symm_measurePreserving m k).quasiMeasurePreserving.ae H2
+  filter_upwards [H1',H2'] with x hx hy
+  intro hn
+  change u.value _ _ * v.value _ _ = 0
+  change ((joinConfiguration m k).symm x).1 ∉ allPositions A →
+    u.value (s ∘ Fin.castAdd k) ((joinConfiguration m k).symm x).1 = 0 at hx
+  change ((joinConfiguration m k).symm x).2 ∉ allPositions B →
+    v.value (s ∘ Fin.natAdd m) ((joinConfiguration m k).symm x).2 = 0 at hy
+  by_cases ha : ((joinConfiguration m k).symm x).1 ∈ allPositions A
+  · have hb : ((joinConfiguration m k).symm x).2 ∉ allPositions B :=
+      fun h => hn ((blockRegion_split A B x).2 ⟨ha,h⟩)
+    rw [hy hb, mul_zero]
+  · rw [hx ha, zero_mul]
+
+lemma blockRegion_orbit_disjoint {m k : ℕ} {A B : Set Space} (hAB : Disjoint A B)
+    (p q : Equiv.Perm (Fin (m+k))) (hpq : p⁻¹*q ∉ blockGroup m k)
+    (x : Configuration (m+k)) :
+    ¬ (permute p x ∈ blockRegion m k A B ∧ permute q x ∈ blockRegion m k A B) := by
+  rcases exists_crossing_of_not_mem (p⁻¹*q) hpq with ⟨i,j,hij⟩
+  intro ⟨hp,hq⟩
+  have he : q (Fin.castAdd k i) = p (Fin.natAdd m j) := by
+    have H := congrArg p hij
+    simpa using H
+  have ha := hq.1 i
+  have hb := hp.2 j
+  rw [position_permute, he] at ha
+  rw [position_permute] at hb
+  exact Set.disjoint_left.1 hAB ha hb
+
+lemma configSupported_value_orthogonal {n : ℕ} (u : H1Vector n) (R : Set (Configuration n))
+    (hu : ConfigSupported u R) (p q : Equiv.Perm (Fin n))
+    (hR : ∀ x, ¬(permute p x ��� R ∧ permute q x ∈ R)) (s : Spins n) :
+    ∀ᵐ x ∂volume, star ((u.permutation p).value s x)*(u.permutation q).value s x = 0 := by
+  have hp := (permute_measurePreserving p).quasiMeasurePreserving.ae (hu (s ∘ p))
+  have hq := (permute_measurePreserving q).quasiMeasurePreserving.ae (hu (s ∘ q))
+  filter_upwards [hp,hq] with x hx hy
+  rw [permutation_value, permutation_value]
+  by_cases hpx : permute p x ∈ R
+  · rw [hy (fun h => hR x ⟨hpx,h⟩), mul_zero]
+  · rw [hx hpx, star_zero, zero_mul]
+
+lemma configSupported_gradient_orthogonal {n : ℕ} (u : H1Vector n) (R : Set (Configuration n))
+    (hu : ConfigSupported u R) (hclosed : IsClosed R) (p q : Equiv.Perm (Fin n))
+    (hR : ∀ x, ¬(permute p x ∈ R ∧ permute q x ∈ R)) (s : Spins n) (a : Fin n × Fin 3) :
+    ∀ᵐ x ∂volume, star ((u.permutation p).gradient s a x)*(u.permutation q).gradient s a x = 0 := by
+  have hp := (permute_measurePreserving p).quasiMeasurePreserving.ae
+    (hu.gradient hclosed (s ∘ p) (p.symm a.1,a.2))
+  have hq := (permute_measurePreserving q).quasiMeasurePreserving.ae
+    (hu.gradient hclosed (s ∘ q) (q.symm a.1,a.2))
+  filter_upwards [hp,hq] with x hx hy
+  rw [permutation_gradient, permutation_gradient]
+  by_cases hpx : permute p x ∈ R
+  · rw [hy (fun h => hR x ⟨hpx,h⟩), mul_zero]
+  · rw [hx hpx, star_zero, zero_mul]
+end Coulomb
+
+open scoped BigOperators ComplexConjugate
+
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/PhaseRegion.lean

@@ -0,0 +1,221 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.FieldAnalysis.Space
+
+namespace OAI
+
+noncomputable section
+
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set
+open scoped BigOperators ENNReal Classical NNReal ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology
+open MeasureTheory Set
+open scoped BigOperators ENNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal ContDiff
+open scoped Classical
+open scoped BigOperators ComplexConjugate
+open scoped Classical
+open scoped Classical
+open MeasureTheory Set Filter
+open scoped Classical ENNReal NNReal ComplexConjugate
+open MeasureTheory Set Filter Module Module.End TopologicalSpace Function
+open scoped Classical ComplexConjugate
+open MeasureTheory Set Filter Module Module.End TopologicalSpace Function
+open scoped Classical ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal BigOperators Classical Topology SchwartzMap FourierTransform ComplexConjugate
+open MeasureTheory Filter
+open scoped ENNReal NNReal FourierTransform SchwartzMap LineDeriv ComplexConjugate
+open scoped LineDeriv
+open MeasureTheory Set Metric
+open scoped ENNReal NNReal RealInnerProductSpace
+namespace Coulomb
+
+lemma volume_real_ball_three (r : ℝ) (hr : 0 ≤ r) :
+    (volume : Measure Space).real (ball 0 r) = 4*Real.pi/3*r^3 := by
+  rw [measureReal_def, EuclideanSpace.volume_ball_fin_three, ENNReal.toReal_mul,
+    ENNReal.toReal_pow, ENNReal.toReal_ofReal hr, ENNReal.toReal_ofReal (by positivity)]
+  ring
+
+lemma integral_ball_norm_sq_three (r : ℝ) (hr : 0 ≤ r) :
+    (∫ p : Space in ball 0 r, ‖p‖^2) = 4*Real.pi/5*r^5 := by
+  have he : (fun p : Space => (ball 0 r).indicator (fun p => ‖p‖^2) p) =
+      fun p : Space => (Iio r).indicator (fun t : ℝ => t^2) ‖p‖ := by
+    ext p
+    simp only [Set.indicator, mem_ball, dist_zero_right, mem_Iio]
+  rw [← integral_indicator measurableSet_ball, he,
+    integral_fun_norm_addHaar volume]
+  simp only [Space, finrank_euclideanSpace_fin, Nat.reduceSub,
+    nsmul_eq_mul, smul_eq_mul]
+  have hf : (fun t : ℝ => t^2 * (Iio r).indicator (fun s : ℝ => s^2) t) =
+      (Iio r).indicator (fun t : ℝ => t^4) := by
+    ext t
+    by_cases ht : t < r <;> simp [Set.indicator, ht]
+    ring
+  rw [hf, integral_indicator measurableSet_Iio, Measure.restrict_restrict measurableSet_Iio]
+  have hs : Iio r ∩ Ioi (0 : ℝ) = Ioo 0 r := by ext t; simp; tauto
+  rw [hs, ← integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le hr,
+    integral_pow, volume_real_ball_three 1 (by norm_num)]
+  norm_num
+  ring
+
+lemma integrableOn_ball_norm_sq_three (r : ℝ) :
+    IntegrableOn (fun p : Space => ‖p‖^2) (ball 0 r) := by
+  exact (continuous_norm.pow 2).continuousOn.integrableOn_compact
+    (isCompact_closedBall (0 : Space) r) |>.mono_set ball_subset_closedBall
+
+noncomputable def phaseRegion (R : Space → ℝ) : Set (Space × Space) :=
+  {yp | ‖yp.2‖ < R yp.1}
+noncomputable def phaseMeasure (R : Space → ℝ) : Measure (Space × Space) :=
+  (volume.prod volume).restrict (phaseRegion R)
+lemma phaseRegion_measurable {R : Space → ℝ} (hR : Measurable R) :
+    MeasurableSet (phaseRegion R) := by
+  exact measurableSet_lt measurable_snd.norm (hR.comp measurable_fst)
+lemma phaseMeasure_le (R : Space → ℝ) : phaseMeasure R ≤ volume.prod volume :=
+  Measure.restrict_le_self
+
+lemma phaseMeasure_lintegral {R : Space → ℝ} (hR : Measurable R)
+    (f : Space × Space → ℝ≥0∞) (hf : Measurable f) :
+    (∫⁻ yp, f yp ∂phaseMeasure R) = ∫⁻ y : Space, ∫⁻ p in ball 0 (R y), f (y,p) := by
+  rw [phaseMeasure, ← lintegral_indicator (phaseRegion_measurable hR),
+    lintegral_prod _ (hf.indicator (phaseRegion_measurable hR)).aemeasurable]
+  apply lintegral_congr
+  intro y
+  rw [← lintegral_indicator measurableSet_ball]
+  apply lintegral_congr
+  intro p
+  by_cases hnorm : ‖p‖ < R y <;> simp [phaseRegion, Set.indicator, hnorm]
+
+lemma phaseMeasure_mass {R : Space → ℝ} (hR : Measurable R) :
+    phaseMeasure R univ = ∫⁻ y : Space,
+      ENNReal.ofReal (R y)^3 * ENNReal.ofReal (Real.pi*4/3) := by
+  rw [← lintegral_one, phaseMeasure_lintegral hR _ measurable_const]
+  simp
+
+lemma phaseMeasure_lintegral_momentum {R : Space → ℝ} (hR : Measurable R)
+    (hRp : ∀ y, 0 ≤ R y) :
+    (∫⁻ yp, ENNReal.ofReal (‖yp.2‖^2) ∂phaseMeasure R) =
+      ∫⁻ y : Space, ENNReal.ofReal (4*Real.pi/5*R y^5) := by
+  rw [phaseMeasure_lintegral hR _ (by fun_prop)]
+  apply lintegral_congr
+  intro y
+  rw [← ofReal_integral_eq_lintegral_ofReal (integrableOn_ball_norm_sq_three (R y))
+    (Filter.Eventually.of_forall (fun p => sq_nonneg _)), integral_ball_norm_sq_three _ (hRp y)]
+
+lemma phaseMeasure_momentum_memLp {R : Space → ℝ} (hR : Measurable R)
+    (hRp : ∀ y, 0 ≤ R y) (hI : Integrable (fun y => R y^5)) :
+    MemLp (fun yp : Space × Space => yp.2) 2 (phaseMeasure R) := by
+  apply (memLp_two_iff_integrable_sq_norm (by fun_prop)).mpr
+  refine ⟨by fun_prop, ?_⟩
+  rw [hasFiniteIntegral_iff_ofReal (Filter.Eventually.of_forall (fun yp => sq_nonneg _)),
+    phaseMeasure_lintegral_momentum hR hRp,
+    ← ofReal_integral_eq_lintegral_ofReal (hI.const_mul (4*Real.pi/5))
+      (Filter.Eventually.of_forall (fun y => mul_nonneg (by positivity) (pow_nonneg (hRp y) _)))]
+  exact ENNReal.ofReal_lt_top
+
+lemma phaseMeasure_real_momentum {R : Space → ℝ} (hR : Measurable R)
+    (hRp : ∀ y, 0 ≤ R y) :
+    (∫ yp, ‖yp.2‖^2 ∂phaseMeasure R) = 4*Real.pi/5 * ∫ y : Space, R y^5 := by
+  rw [integral_eq_lintegral_of_nonneg_ae (Filter.Eventually.of_forall (fun yp => sq_nonneg _))
+    (by fun_prop), phaseMeasure_lintegral_momentum hR hRp,
+    ← integral_eq_lintegral_of_nonneg_ae
+      (Filter.Eventually.of_forall (fun y => mul_nonneg (by positivity) (pow_nonneg (hRp y) _))) (by fun_prop), integral_const_mul]
+
+noncomputable def fermiRadius (ρ : Space → ℝ) (y : Space) : ℝ :=
+  (3/(8*Real.pi)*ρ y) ^ (1/3 : ℝ)
+lemma fermiRadius_nonneg (ρ : Space → ℝ) (hρ : ∀ y, 0 ≤ ρ y) (y : Space) :
+    0 ≤ fermiRadius ρ y := Real.rpow_nonneg (mul_nonneg (by positivity) (hρ y)) _
+lemma fermiRadius_cube (ρ : Space → ℝ) (hρ : ∀ y, 0 ≤ ρ y) (y : Space) :
+    fermiRadius ρ y ^ 3 = 3/(8*Real.pi)*ρ y := by
+  rw [fermiRadius, ← Real.rpow_mul_natCast (mul_nonneg (by positivity) (hρ y))]
+  norm_num
+lemma fermiRadius_fifth (ρ : Space → ℝ) (hρ : ∀ y, 0 ≤ ρ y) (y : Space) :
+    fermiRadius ρ y ^ 5 = (3/(8*Real.pi))^(5/3 : ℝ) * ρ y^(5/3 : ℝ) := by
+  rw [fermiRadius, ← Real.rpow_mul_natCast (mul_nonneg (by positivity) (hρ y)), Real.mul_rpow (by positivity) (hρ y)]
+  norm_num
+lemma fermiRadius_measurable (ρ : Space → ℝ) (hρ : Measurable ρ) :
+    Measurable (fermiRadius ρ) := by
+  unfold fermiRadius
+  fun_prop
+lemma fermiRadius_ball_mass (ρ : Space → ℝ) (hρ : ∀ y, 0 ≤ ρ y) (y : Space) :
+    (volume : Measure Space) (ball 0 (fermiRadius ρ y)) = ENNReal.ofReal (ρ y/2) := by
+  rw [EuclideanSpace.volume_ball_fin_three, ← ENNReal.ofReal_pow (fermiRadius_nonneg ρ hρ y),
+    ← ENNReal.ofReal_mul (pow_nonneg (fermiRadius_nonneg ρ hρ y) _), fermiRadius_cube ρ hρ y]
+  congr 1
+  field_simp
+  ring
+
+lemma fermiMeasure_mass (ρ : Space → ℝ) (hρ : ∀ y, 0 ≤ ρ y) (hm : Measurable ρ)
+    (hI : Integrable ρ) :
+    phaseMeasure (fermiRadius ρ) univ = ENNReal.ofReal ((∫ y : Space, ρ y)/2) := by
+  rw [← lintegral_one, phaseMeasure_lintegral (fermiRadius_measurable ρ hm) _ measurable_const]
+  simp only [lintegral_one, Measure.restrict_apply_univ, fermiRadius_ball_mass ρ hρ]
+  rw [← ofReal_integral_eq_lintegral_ofReal (hI.div_const 2)
+    (Filter.Eventually.of_forall (fun y => div_nonneg (hρ y) (by norm_num))), integral_div]
+
+lemma fermiMeasure_finite (ρ : Space → ℝ) (hρ : ∀ y, 0 ≤ ρ y) (hm : Measurable ρ)
+    (hI : Integrable ρ) : IsFiniteMeasure (phaseMeasure (fermiRadius ρ)) := by
+  constructor
+  rw [fermiMeasure_mass ρ hρ hm hI]
+  exact ENNReal.ofReal_lt_top
+
+lemma fermiMeasure_momentum_memLp (ρ : Space → ℝ) (hρ : ∀ y, 0 ≤ ρ y)
+    (hm : Measurable ρ) (hI : Integrable (fun y => ρ y^(5/3 : ℝ))) :
+    MemLp (fun yp : Space × Space => yp.2) 2 (phaseMeasure (fermiRadius ρ)) := by
+  apply phaseMeasure_momentum_memLp (fermiRadius_measurable ρ hm) (fermiRadius_nonneg ρ hρ)
+  simp only [fermiRadius_fifth ρ hρ]
+  exact hI.const_mul _
+end Coulomb
+
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/PhysicalPoisson.lean

@@ -0,0 +1,165 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.Packets.CoulombKernel
+import OAI.Analysis.CoulombRadii.Screening.CoreScreenedField
+
+namespace OAI
+
+section
+section
+open MeasureTheory Set Filter
+open scoped BigOperators ENNReal NNReal Classical Topology ContDiff
+noncomputable section
+namespace Coulomb
+
+lemma coreCoulombPotential_continuousOn {k : ℕ} (u : H1Vector k)
+    {A : Set Space} (hu : SpatiallySupported u A) {y : Space} {r t : ℝ}
+    (hrt : r<t) (hsep : ∀ a∈A, t ≤ ‖a-y‖) :
+    ContinuousOn (coreCoulombPotential u) (Metric.closedBall y r) := by
+  let d := t-r
+  have hd : 0<d := sub_pos.mpr hrt
+  let G : Space → ℝ := fun z => ∑ s : Spins k, ∑ i : Fin k,
+    ∫ x, (max d ‖position x i-z‖)⁻¹*‖u.value s x‖^2
+  have hG : Continuous G := by
+    apply continuous_finsetSum
+    intro s hs
+    apply continuous_finsetSum
+    intro i hi
+    apply MeasureTheory.continuous_of_dominated (bound := fun x => d⁻¹*‖u.value s x‖^2)
+    · intro z
+      exact (((measurable_const.max ((continuous_position i).measurable.sub measurable_const).norm).inv).aestronglyMeasurable).mul
+        ((u.value_L2 s).aestronglyMeasurable.norm.pow 2)
+    · intro z
+      filter_upwards [] with x
+      rw [Real.norm_of_nonneg (mul_nonneg (inv_nonneg.mpr (le_max_left _ _ |>.trans' hd.le)) (sq_nonneg _))]
+      exact mul_le_mul_of_nonneg_right (inv_anti₀ hd (le_max_left _ _)) (sq_nonneg _)
+    · exact ((u.value_L2 s).norm.integrable_sq).const_mul _
+    · filter_upwards [] with x
+      exact (((continuous_const.max (continuous_const.sub continuous_id).norm).inv₀
+        (fun z => ne_of_gt (hd.trans_le (le_max_left _ _)))).mul continuous_const)
+  apply hG.continuousOn.congr
+  intro z hz
+  unfold coreCoulombPotential G
+  apply Finset.sum_congr rfl
+  intro s hs
+  apply Finset.sum_congr rfl
+  intro i hi
+  apply integral_congr_ae
+  filter_upwards [hu s] with x hx
+  by_cases he : u.value s x=0
+  · simp [he]
+  · have ha : position x i∈A := (by_contra (fun hn => he (hx hn)) : x∈allPositions A) i
+    have hz' : ‖z-y‖ ≤ r := by simpa only [Metric.mem_closedBall,dist_eq_norm] using hz
+    have htri : ‖position x i-y‖ ≤ ‖position x i-z‖+‖z-y‖ := by
+      simpa only [dist_eq_norm] using dist_triangle (position x i) z y
+    have hdist : d ≤ ‖position x i-z‖ := by dsimp [d]; linarith [hsep _ ha]
+    simp only [max_eq_right hdist,coulombKernel]
+
+lemma coreCoulombPotential_weak_harmonic {k : ℕ} (u : H1Vector k)
+    {A U : Set Space} (hu : SpatiallySupported u A) (hdis : Disjoint A U) :
+    NeutralAtom.HasWeakLaplacian (coreCoulombPotential u) U (fun _ => 0) := by
+  intro φ hφ hc ht
+  have hi : Integrable (NeutralAtom.coordinateLaplacian φ) :=
+    (NeutralAtom.continuous_coordinateLaplacian (hφ.of_le (by exact WithTop.coe_le_coe.mpr le_top))).integrable_of_hasCompactSupport
+      (NeutralAtom.hasCompactSupport_coordinateLaplacian hc)
+  rw [coreCoulombPotential_fubini u _ hi]
+  simp only [zero_mul,integral_zero]
+  apply Finset.sum_eq_zero
+  intro s hs
+  apply Finset.sum_eq_zero
+  intro i hi
+  apply integral_eq_zero_of_ae
+  filter_upwards [hu s] with x hx
+  by_cases he : u.value s x=0
+  · simp [he]
+  · have ha : position x i∈A := (by_contra (fun hn => he (hx hn)) : x∈allPositions A) i
+    have hn : position x i∉tsupport φ := fun h => Set.disjoint_left.mp hdis ha (ht h)
+    have HH := NeutralAtom.integral_translated_coulombKernel_laplacian hφ hc (position x i)
+    have heq : (∫ z, coulombKernel (position x i-z)*NeutralAtom.coordinateLaplacian φ z)=0 := by
+      simp_rw [coulombKernel_sub_comm (position x i)]
+      change (∫ z, NeutralAtom.coulombKernel (z-position x i)*NeutralAtom.coordinateLaplacian φ z)=0
+      rw [HH,image_eq_zero_of_notMem_tsupport hn]
+      ring
+    simp only [heq,zero_mul,Pi.zero_apply]
+
+lemma attraction_weak_harmonic {J : ℕ} (S : Nuclei J) {U : Set Space}
+    (hsep : ∀ j, S.position j∉U) :
+    NeutralAtom.HasWeakLaplacian (attraction S) U (fun _ => 0) := by
+  intro φ hφ hc ht
+  have hL := NeutralAtom.continuous_coordinateLaplacian
+    (hφ.of_le (by exact WithTop.coe_le_coe.mpr le_top))
+  have hLc := NeutralAtom.hasCompactSupport_coordinateLaplacian hc
+  have hts : tsupport (NeutralAtom.coordinateLaplacian φ) ⊆ tsupport φ := by
+    apply closure_minimal _ (isClosed_tsupport _)
+    intro x hx
+    by_contra hn
+    exact hx (NeutralAtom.coordinateLaplacian_eq_zero_of_notMem_tsupport hn)
+  have hi (j : Fin J) : Integrable (fun x => coulombKernel (x-S.position j)*NeutralAtom.coordinateLaplacian φ x) := by
+    apply NeutralAtom.integrable_mul_compact_of_continuousAt _ hL hLc
+    intro x hx
+    have hn : x-S.position j≠0 := sub_ne_zero.mpr (fun he => hsep j (he ▸ ht (hts hx)))
+    exact ((continuous_id.sub continuous_const).norm.continuousAt).inv₀ (norm_ne_zero_iff.mpr hn)
+  simp only [attraction,Finset.sum_mul,mul_assoc]
+  rw [integral_finsetSum _ (fun j _ => (hi j).const_mul _)]
+  simp only [zero_mul,integral_zero]
+  apply Finset.sum_eq_zero
+  intro j hj
+  rw [integral_const_mul]
+  change S.charge j*(∫ x, NeutralAtom.coulombKernel (x-S.position j)*NeutralAtom.coordinateLaplacian φ x)=0
+  rw [NeutralAtom.integral_translated_coulombKernel_laplacian hφ hc,
+    image_eq_zero_of_notMem_tsupport (fun h => hsep j (ht h))]
+  ring
+
+lemma attraction_continuousOn {J : ℕ} (S : Nuclei J) {U : Set Space}
+    (hsep : ∀ j, S.position j∉U) : ContinuousOn (attraction S) U := by
+  change ContinuousOn (fun x => ∑ j : Fin J, S.charge j * ‖x-S.position j‖⁻¹) U
+  apply continuousOn_finsetSum
+  intro j hj
+  refine continuousOn_const.mul ?_
+  refine ((continuous_id.sub continuous_const).norm.continuousOn).inv₀ ?_
+  intro x hx
+  exact norm_ne_zero_iff.mpr (sub_ne_zero.mpr (fun he => hsep j ((show x=S.position j from he) ▸ hx)))
+
+lemma coreScreenedField_continuousOn {J k : ℕ} (S : Nuclei J) (u : H1Vector k)
+    {A : Set Space} (hu : SpatiallySupported u A) {y : Space} {r t : ℝ}
+    (hrt : r<t) (hsep : ∀ a∈A, t ≤ ‖a-y‖)
+    (hnuc : ∀ j, S.position j∉Metric.closedBall y r) :
+    ContinuousOn (coreScreenedField S u) (Metric.closedBall y r) :=
+  (attraction_continuousOn S hnuc).sub (coreCoulombPotential_continuousOn u hu hrt hsep)
+
+lemma coreScreenedField_weak_harmonic {J k : ℕ} (S : Nuclei J) (u : H1Vector k)
+    {A U : Set Space} (hu : SpatiallySupported u A) (hdis : Disjoint A U)
+    (hnuc : ∀ j, S.position j∉U) :
+    NeutralAtom.HasWeakLaplacian (coreScreenedField S u) U (fun _ => 0) := by
+  intro φ hφ hc ht
+  have hL := NeutralAtom.continuous_coordinateLaplacian
+    (hφ.of_le (by exact WithTop.coe_le_coe.mpr le_top))
+  have hLc := NeutralAtom.hasCompactSupport_coordinateLaplacian hc
+  have hi : Integrable (NeutralAtom.coordinateLaplacian φ) := hL.integrable_of_hasCompactSupport hLc
+  have hiC := coreCoulombPotential_mul_integrable u _ hi
+  have hiA : Integrable (fun x => attraction S x*NeutralAtom.coordinateLaplacian φ x) := by
+    apply NeutralAtom.integrable_mul_compact_of_continuousAt _ hL hLc
+    intro x hx
+    have hts : tsupport (NeutralAtom.coordinateLaplacian φ) ⊆ tsupport φ := by
+      apply closure_minimal _ (isClosed_tsupport _)
+      intro x hx
+      by_contra hn
+      exact hx (NeutralAtom.coordinateLaplacian_eq_zero_of_notMem_tsupport hn)
+    have hx' : x∈tsupport φ := hts hx
+    have hs (j) : x≠S.position j := fun h => hnuc j (h ▸ ht hx')
+    change ContinuousAt (fun x => ∑ j : Fin J, S.charge j * ‖x-S.position j‖⁻¹) x
+    apply tendsto_finsetSum
+    intro j hj
+    exact continuousAt_const.mul (((continuous_id.sub continuous_const).norm.continuousAt).inv₀
+      (norm_ne_zero_iff.mpr (sub_ne_zero.mpr (hs j))))
+  simp only [coreScreenedField,sub_mul]
+  rw [integral_sub hiA hiC,attraction_weak_harmonic S hnuc φ hφ hc ht,
+    coreCoulombPotential_weak_harmonic u hu hdis φ hφ hc ht]
+  simp
+
+end Coulomb
+end
+
+end
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/PoissonInterior.lean

@@ -0,0 +1,213 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.Localization.HarmonicInterior
+import OAI.Analysis.CoulombRadii.Localization.HarmonicScale
+
+namespace OAI
+
+noncomputable section
+
+section
+open MeasureTheory Filter Set
+open scoped Topology BigOperators ContDiff
+namespace NeutralAtom
+theorem poisson_interior_estimates (c : Position) {r A M : ℝ}
+    (hr : 0 < r) (hA : 0 ≤ A) (hM : 0 ≤ M) :
+    ∃ C : ℝ, 0 < C ∧ ∀ (F σ : Position → ℝ),
+      ContinuousOn F (Metric.ball c (3*r)) →
+      HasWeakLaplacian F (Metric.ball c (2*r)) (fun x => 4*Real.pi*σ x) →
+      Integrable σ → (∀ x, 0 ≤ σ x) →
+      (∀ x ∈ Metric.closedBall c (3*r), σ x ≤ A) →
+      (∫ x in Metric.closedBall c (2*r), ‖F x‖) ≤ M →
+      (∀ z ∈ Metric.closedBall c r, ‖F z‖ ≤ C) ∧
+      (∀ z ∈ Metric.closedBall c r, ∀ z' ∈ Metric.closedBall c r,
+        ‖F z-F z'‖ ≤ C*‖z-z'‖) := by
+  obtain ⟨HC, hHC, hest⟩ := harmonic_interior_estimates_local hr
+  let W := Metric.closedBall c (3*r)
+  let W' := Metric.closedBall c (2*r)
+  let V := (volume W).toReal
+  let V' := (volume W').toReal
+  let PB := A*(∫ y in Metric.ball (0 : Position) 1, coulombKernel y)+A*V
+  let LB := A*(∫ y in Metric.ball (0 : Position) 1, (coulombKernel y)^2)+A*V
+  have hPB : 0 ≤ PB := add_nonneg (mul_nonneg hA (integral_nonneg coulombKernel_nonneg))
+    (mul_nonneg hA ENNReal.toReal_nonneg)
+  have hLB : 0 ≤ LB := add_nonneg (mul_nonneg hA (integral_nonneg (fun y => sq_nonneg _)))
+    (mul_nonneg hA ENNReal.toReal_nonneg)
+  let H := M+PB*V'
+  have hH : 0 ≤ H := add_nonneg hM (mul_nonneg hPB ENNReal.toReal_nonneg)
+  let C := HC*H+PB+LB+1
+  have hC : 0 < C := by dsimp [C]; positivity
+  refine ⟨C, hC, ?_⟩
+  intro F σ hF hpoisson hσ hσpos hσbd hIF
+  let ρ := W.indicator σ
+  have hρ : Integrable ρ := hσ.indicator measurableSet_closedBall
+  have hρpos : ∀ x, 0 ≤ ρ x := fun x => Set.indicator_nonneg (fun y _ => hσpos y) x
+  have hρbd : ∀ x, ρ x ≤ A := by
+    intro x
+    by_cases hx : x ∈ W
+    · simpa only [ρ, Set.indicator_of_mem hx] using hσbd x hx
+    · simpa only [ρ, Set.indicator_of_notMem hx] using hA
+  have hmass : (∫ x, ρ x) ≤ A*V := by
+    rw [show ρ = W.indicator σ from rfl, integral_indicator measurableSet_closedBall]
+    calc
+      (∫ x in W, σ x) ≤ ∫ _ in W, A := integral_mono_ae hσ.integrableOn
+        (integrableOn_const (isCompact_closedBall c (3*r)).measure_ne_top)
+        ((ae_restrict_mem measurableSet_closedBall).mono (fun x hx => hσbd x hx))
+      _ = A*V := by simp only [integral_const, Measure.restrict_apply_univ, smul_eq_mul, V,
+          measureReal_def, mul_comm]
+  let P := potentialOf ρ
+  have hPcont : Continuous P := potentialOf_continuous hρ hρpos hρbd
+  have hPbd (x : Position) : ‖P x‖ ≤ PB := by
+    have hp : 0 ≤ P x := integral_nonneg (fun y => mul_nonneg (coulombKernel_nonneg _) (hρpos y))
+    rw [Real.norm_eq_abs, abs_of_nonneg hp]
+    exact (bounded_density_convolution measurable_coulombKernel coulombKernel_nonneg
+      (coulombKernel_integrableOn_ball 1) (fun _ => coulombKernel_le_one)
+      hρ hρpos hρbd x).2.trans (by dsimp only [PB]; linarith)
+  have hPlip (x y : Position) : ‖P x-P y‖ ≤ LB*‖x-y‖ :=
+    (potentialOf_lipschitz_bound hρ hρpos hρbd x y).trans
+      (mul_le_mul_of_nonneg_right (by dsimp only [LB]; linarith) (norm_nonneg _))
+  have hW' : W' ⊆ Metric.ball c (3*r) := by
+    intro x hx
+    change dist x c ≤ 2*r at hx
+    change dist x c < 3*r
+    linarith
+  have hball : Metric.ball c (2*r) ⊆ Metric.ball c (3*r) :=
+    Metric.ball_subset_ball (by linarith)
+  let h : Position → ℝ := fun x => F x+P x
+  have hhcont : ContinuousOn h (Metric.ball c (3*r)) := hF.add hPcont.continuousOn
+  have hharm : HasWeakLaplacian h (Metric.ball c (2*r)) (fun _ => 0) :=
+    local_harmonic_part Metric.isOpen_ball (hF.mono hball) hpoisson hρ hρpos hρbd (by
+      intro x hx
+      have hxW : x ∈ W := by
+        change dist x c ≤ 3*r
+        exact (hball hx).le
+      exact (Set.indicator_of_mem hxW σ).symm)
+  have hiF : IntegrableOn (fun x => ‖F x‖) W' :=
+    ((hF.mono hW').norm).integrableOn_compact (isCompact_closedBall c (2*r))
+  have hih : IntegrableOn (fun x => ‖h x‖) W' :=
+    ((hhcont.mono hW').norm).integrableOn_compact (isCompact_closedBall c (2*r))
+  have hiPB : IntegrableOn (fun _ : Position => PB) W' :=
+    integrableOn_const (isCompact_closedBall c (2*r)).measure_ne_top
+  have hIh : (∫ x in W', ‖h x‖) ≤ H := by
+    calc
+      (∫ x in W', ‖h x‖) ≤ ∫ x in W', ‖F x‖+PB := integral_mono_ae hih (hiF.add hiPB)
+        (Filter.Eventually.of_forall (fun x => (norm_add_le (F x) (P x)).trans
+          (add_le_add le_rfl (hPbd x))))
+      _ = (∫ x in W', ‖F x‖)+PB*V' := by
+        rw [integral_add hiF hiPB, integral_const]
+        simp only [Measure.restrict_apply_univ, smul_eq_mul, V', measureReal_def, mul_comm]
+      _ ≤ H := by dsimp only [H]; linarith
+  obtain ⟨hval, hdiff⟩ := hest c h hhcont hharm
+  have hCval : HC*H+PB ≤ C := by dsimp [C]; linarith
+  have hClip : HC*H+LB ≤ C := by dsimp [C]; linarith
+  constructor
+  · intro z hz
+    calc
+      ‖F z‖ = ‖h z-P z‖ := by dsimp [h]; rw [add_sub_cancel_right]
+      _ ≤ ‖h z‖+‖P z‖ := norm_sub_le _ _
+      _ ≤ HC*(∫ x in W', ‖h x‖)+PB := add_le_add (hval z hz) (hPbd z)
+      _ ≤ HC*H+PB := by linarith [mul_le_mul_of_nonneg_left hIh hHC.le]
+      _ ≤ C := hCval
+  · intro z hz z' hz'
+    calc
+      ‖F z-F z'‖ = ‖(h z-h z')-(P z-P z')‖ := by congr 1; dsimp [h]; ring
+      _ ≤ ‖h z-h z'‖+‖P z-P z'‖ := norm_sub_le _ _
+      _ ≤ HC*(∫ x in W', ‖h x‖)*‖z-z'‖+LB*‖z-z'‖ :=
+        add_le_add (hdiff z hz z' hz') (hPlip z z')
+      _ ≤ (HC*H+LB)*‖z-z'‖ := by
+        have hb := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hIh hHC.le)
+          (norm_nonneg (z-z'))
+        nlinarith
+      _ ≤ C*‖z-z'‖ := mul_le_mul_of_nonneg_right hClip (norm_nonneg _)
+
+end NeutralAtom
+
+end
+open MeasureTheory Filter Set
+open scoped Topology BigOperators ContDiff
+namespace NeutralAtom
+
+lemma HasWeakLaplacian.const_mul {F q : Position → ℝ} {U : Set Position}
+    (h : HasWeakLaplacian F U q) (b : ℝ) :
+    HasWeakLaplacian (fun x => b*F x) U (fun x => b*q x) := by
+  intro φ hφ hφc ht
+  simp_rw [mul_assoc, integral_const_mul]
+  rw [h φ hφ hφc ht]
+
+theorem poisson_unit_negative_oscillation {A M : ℝ} (hA : 0≤A) (hM : 0≤M) :
+    ∃ C : ℝ, 0<C ∧ ∀ (F σ : Position → ℝ),
+      ContinuousOn F (Metric.ball 0 3) →
+      HasWeakLaplacian F (Metric.ball 0 2) (fun x => 4*Real.pi*σ x) →
+      Integrable σ → (∀ x, 0≤σ x) →
+      (∀ x ∈ Metric.closedBall 0 3, σ x≤A) →
+      (∀ x ∈ Metric.closedBall 0 2, F x≤M) →
+      volume.real (Metric.closedBall (0:Position) 2)*F 0 ≤
+        (∫ x in Metric.closedBall 0 2, F x) →
+      ∀ z ∈ Metric.closedBall (0:Position) 1,
+        ‖F z-F 0‖ ≤ C*(1+max (-F 0) 0)*‖z‖ := by
+  let V := volume.real (Metric.closedBall (0:Position) 2)
+  have hV : 0≤V := ENNReal.toReal_nonneg
+  obtain ⟨C,hC,H⟩ := poisson_interior_estimates (0:Position)
+    (r:=1) (A:=A) (M:=V*(2*M+1)) (by norm_num) hA (by positivity)
+  refine ⟨C,hC,?_⟩
+  intro F σ hF hLap hσ hp hb hFM hmean z hz
+  let T := 1+max (-F 0) 0
+  have hT : 0<T := by dsimp [T]; positivity
+  have hT1 : 1≤T := by dsimp [T]; linarith [le_max_right (-F 0) 0]
+  have h2sub : Metric.closedBall (0:Position) 2⊆Metric.ball 0 3 := by
+    intro x hx
+    change dist x 0≤2 at hx
+    change dist x 0<3
+    linarith
+  have hiF : IntegrableOn F (Metric.closedBall 0 2) :=
+    (hF.mono h2sub).integrableOn_compact (isCompact_closedBall _ _)
+  have hiabs := hiF.norm
+  have hic : IntegrableOn (fun _ : Position => 2*M) (Metric.closedBall 0 2) :=
+    integrableOn_const (isCompact_closedBall (0:Position) 2).measure_ne_top
+  have hIF : (∫ x in Metric.closedBall 0 2, ‖F x‖) ≤ V*(2*M+max (-F 0) 0) := by
+    calc
+      (∫ x in Metric.closedBall 0 2, ‖F x‖) ≤
+          ∫ x in Metric.closedBall 0 2, 2*M-F x := by
+        apply integral_mono_ae hiabs (hic.sub hiF)
+        filter_upwards [ae_restrict_mem measurableSet_closedBall] with x hx
+        change ‖F x‖ ≤ 2*M-F x
+        rw [Real.norm_eq_abs]
+        exact abs_le.mpr ⟨by linarith [hFM x hx], by linarith [hFM x hx]⟩
+      _ = V*(2*M)-(∫ x in Metric.closedBall 0 2, F x) := by
+        rw [integral_sub hic hiF,integral_const]
+        simp only [measureReal_restrict_apply_univ,smul_eq_mul,V]
+      _ ≤ V*(2*M+max (-F 0) 0) := by
+        change V*F 0 ≤ _ at hmean
+        nlinarith [mul_le_mul_of_nonneg_left (le_max_left (-F 0) 0) hV]
+  have hIscaled : (∫ x in Metric.closedBall 0 2, ‖T⁻¹*F x‖) ≤ V*(2*M+1) := by
+    simp_rw [norm_mul,Real.norm_eq_abs T⁻¹,abs_of_pos (inv_pos.mpr hT),integral_const_mul]
+    have hnum : V*(2*M+max (-F 0) 0) ≤ T*(V*(2*M+1)) := by
+      dsimp [T]
+      nlinarith [mul_nonneg (mul_nonneg hV hM) (le_max_right (-F 0) 0)]
+    calc
+      _ ≤ T⁻¹*(T*(V*(2*M+1))) :=
+        mul_le_mul_of_nonneg_left (hIF.trans hnum) (inv_nonneg.mpr hT.le)
+      _ = _ := by rw [←mul_assoc,inv_mul_cancel₀ hT.ne',one_mul]
+  have hLap' : HasWeakLaplacian (fun x => T⁻¹*F x) (Metric.ball 0 2)
+      (fun x => 4*Real.pi*(T⁻¹*σ x)) := by
+    convert hLap.const_mul T⁻¹ using 1
+    funext point
+    ring
+  obtain ⟨_,hdiff⟩ := H (fun x => T⁻¹*F x) (fun x => T⁻¹*σ x)
+    (by simpa only [mul_one] using hF.const_mul T⁻¹) (by simpa using hLap')
+    (hσ.const_mul _) (fun x => mul_nonneg (inv_nonneg.mpr hT.le) (hp x))
+    (by
+      intro x hx
+      have hh : σ x≤A := hb x (by simpa using hx)
+      have hinv : T⁻¹≤1 := inv_le_one_of_one_le₀ hT1
+      exact (mul_le_mul_of_nonneg_left hh (inv_nonneg.mpr hT.le)).trans
+        (by simpa using mul_le_mul_of_nonneg_right hinv hA)) (by simpa using hIscaled)
+  have hh := hdiff z (by simpa using hz) 0 (by simp)
+  simp only [←mul_sub,norm_mul,Real.norm_eq_abs T⁻¹,abs_of_pos (inv_pos.mpr hT),sub_zero] at hh
+  have hm := mul_le_mul_of_nonneg_left hh hT.le
+  simpa only [←mul_assoc,mul_inv_cancel₀ hT.ne',one_mul,mul_comm T C,T] using hm
+
+end NeutralAtom
+
+end
+
+end OAI

lean/OAI/Analysis/CoulombRadii/FieldAnalysis/PositiveField.lean

@@ -0,0 +1,79 @@
+import Mathlib
+import OAI.Analysis.CoulombRadii.FormDomain.BallTrial
+import OAI.Analysis.CoulombRadii.Packets.ScaledWindow
+import OAI.Analysis.CoulombRadii.FormDomain.FieldOptimization
+
+namespace OAI
+
+section
+section
+open MeasureTheory Set Filter
+open scoped BigOperators ENNReal NNReal Classical SchwartzMap Pointwise
+noncomputable section
+namespace Coulomb
+
+def ballTrialCoefficient : ℝ := ballKineticCoefficient+
+  (1/2:ℝ)*(∑ b : Fin 3, ∫ x : Space, (fderiv ℝ unitWindow x (EuclideanSpace.single b 1))^2)+2
+
+lemma ballTrialCoefficient_pos : 0 < ballTrialCoefficient := by
+  unfold ballTrialCoefficient
+  linarith [ballKineticCoefficient_pos,unitWindow_kinetic_nonneg]
+
+theorem positive_field_ball_trial {J k : ℕ} (S : Nuclei J) (u : H1Vector k)
+    (hu : Antisymmetric u) (hmu : mass u = 1)
+    {a M : ℝ} (ha : 0 < a) (hM : 0 ≤ M)
+    (y : Space) (A : Set Space) (hA : IsClosed A) (hsu : SpatiallySupported u A)
+    (hcore : ∀ z ∈ A, 3*a ≤ ‖z-y‖) (hnuc : ∀ j, 3*a ≤ ‖S.position j-y‖) :
+    unrestrictedFormBottom S ≤ ((form S u-M*coreScreenedField S u y+
+      ballTrialCoefficient*(M^(5/3:ℝ)/a^2+M/a^2+M^2/a) : ℝ) : EReal) := by
+  have H := ballCloud_trial S u hu hmu (scaledWindow unitWindow a ha.ne')
+    (by rw [scaledWindow_mass unitWindow ha,unitWindow_mass])
+    (scaledWindow_compactSupport unitWindow unitWindow_support ha)
+    (scaledWindow_radial unitWindow unitWindow_radial ha)
+    ha hM (scaledWindow_support unitWindow unitWindow_support ha)
+    y A hA hsu hcore hnuc
+  rw [scaledWindow_kinetic unitWindow ha] at H
+  apply H.trans
+  apply EReal.coe_le_coe_iff.mpr
+  have hc : ballKineticCoefficient ≤ ballTrialCoefficient := by
+    unfold ballTrialCoefficient
+    linarith [unitWindow_kinetic_nonneg]
+  have hg : (1/2:ℝ)*(∑ b : Fin 3, ∫ x : Space,
+      (fderiv ℝ unitWindow x (EuclideanSpace.single b 1))^2) ≤ ballTrialCoefficient := by
+    unfold ballTrialCoefficient
+    linarith [ballKineticCoefficient_pos]
+  have he : (5/4:ℝ) ≤ ballTrialCoefficient := by
+    unfold ballTrialCoefficient
+    linarith [ballKineticCoefficient_pos,unitWindow_kinetic_nonneg]
+  have Hc := mul_le_mul_of_nonneg_right hc (show 0 ≤ M^(5/3:ℝ)/a^2 by positivity)
+  have Hg := mul_le_mul_of_nonneg_right hg (show 0 ≤ M/a^2 by positivity)
+  have He := mul_le_mul_of_nonneg_right he (show 0 ≤ M^2/a by positivity)
+  linear_combination Hc+Hg+He
+
+theorem positive_field_core_gain {J k : ℕ} (S : Nuclei J) (u : H1Vector k)
+    (hu : Antisymmetric u) (hmu : mass u = 1)
+    {a m : ℝ} (ha : 0 < a) (hm : 0 ≤ m)
+    (ham : 1 ≤ a*m) (ham' : 1 ≤ a*m^(1/3:ℝ))
+    (y : Space) (A : Set Space) (hA : IsClosed A) (hsu : SpatiallySupported u A)
+    (hcore : ∀ z ∈ A, 3*a ≤ ‖z-y‖) (hnuc : ∀ j, 3*a ≤ ‖S.position j-y‖) :
+    unrestrictedFormBottom S ≤ ((form S u-a*(max (coreScreenedField S u y) 0)^2/
+      (16*ballTrialCoefficient)+4*ballTrialCoefficient*m^2/a : ℝ) : EReal) := by
+  by_cases hb : unrestrictedFormBottom S = ⊥
+  · simp [hb]
+  have ht : unrestrictedFormBottom S ≠ ⊤ := ne_top_of_le_ne_top (EReal.coe_ne_top _)
+    (unrestrictedFormBottom_le_trial S u hu hmu)
+  rw [←EReal.coe_toReal ht hb]
+  apply EReal.coe_le_coe_iff.mpr
+  apply positive_field_trial_optimization ha ballTrialCoefficient_pos hm ham ham'
+  intro M hM
+  apply EReal.coe_le_coe_iff.mp
+  rw [EReal.coe_toReal ht hb]
+  exact positive_field_ball_trial S u hu hmu ha hM y A hA hsu hcore hnuc
+
+end Coulomb
+end
+
+end
+end
+
+end OAI