Add lean source and binary files (part 57)

lean/OAI/Combinatorics/SparsestCut/CubeGeometry.lean

@@ -0,0 +1,165 @@
+import OAI.Combinatorics.SparsestCut.CubePoincare
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.CubeGeometry
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped BigOperators ENNReal
+noncomputable section
+variable {m : ℕ}
+local notation "E" => EuclideanSpace ℝ (Fin m)
+local notation "μ" => CubePoincare.cube (m := m)
+
+lemma pi_uniform : Measure.pi (fun _ : Fin m => GaussianCDF.uniform)=
+    (2:ℝ≥0∞)⁻¹^m • (volume : Measure (Fin m → ℝ)).restrict
+      (univ.pi (fun _ => Ioo (-1:ℝ) 1)) := by
+  apply Measure.pi_eq
+  intro s hs
+  change (2:ℝ≥0∞)⁻¹^m * ((Measure.pi (fun _ : Fin m => (volume : Measure ℝ))).restrict (univ.pi (fun _ => Ioo (-1:ℝ) 1))) (univ.pi s)=_
+  rw [Measure.restrict_pi_pi,Measure.pi_pi]
+  simp only [GaussianCDF.uniform,Measure.smul_apply,smul_eq_mul,Finset.prod_mul_distrib,
+    Finset.prod_const,Finset.card_univ,Fintype.card_fin]
+
+lemma cube_ac : μ ≪ (volume : Measure E) := by
+  have h : Measure.pi (fun _ : Fin m => GaussianCDF.uniform) ≪ (volume : Measure (Fin m → ℝ)) := by
+    rw [pi_uniform]
+    exact (Measure.restrict_le_self.absolutelyContinuous).smul_left _
+  have hh := h.map (show Measurable (WithLp.toLp 2 : (Fin m → ℝ) → E) by fun_prop)
+  rw [(PiLp.volume_preserving_toLp (Fin m)).map_eq] at hh
+  exact hh
+
+lemma uniform_mem : ∀ᵐ t ∂GaussianCDF.uniform, t∈Ioo (-1:ℝ) 1 := by
+  have h : GaussianCDF.uniform ≪ volume.restrict (Ioo (-1:ℝ) 1) :=
+    (Measure.AbsolutelyContinuous.refl _).smul_left _
+  exact h.ae_le (ae_restrict_mem measurableSet_Ioo)
+
+lemma cube_mem : ∀ᵐ x ∂μ, ∀ j, |x j|<1 := by
+  apply (ae_map_iff (by fun_prop) (by measurability)).mpr
+  apply ae_all_iff.mpr
+  intro j
+  have h := (measurePreserving_eval (fun _ : Fin m => GaussianCDF.uniform) j).quasiMeasurePreserving.ae uniform_mem
+  filter_upwards [h] with x hx
+  exact abs_lt.mpr hx
+
+lemma uniform_pow (k : ℕ) : (∫ t, t^k ∂GaussianCDF.uniform)=
+    (1-(-1:ℝ)^(k+1))/(2*(k+1)) := by
+  rw [GaussianCDF.uniform,integral_smul_measure,restrict_Ioo_eq_restrict_Ioc,
+    ← intervalIntegral.integral_of_le (by norm_num : (-1:ℝ)≤1),integral_pow]
+  simp only [ENNReal.toReal_inv,ENNReal.toReal_ofNat,smul_eq_mul,one_pow]
+  field_simp
+
+lemma uniform_pow_integrable (k : ℕ) : Integrable (fun t : ℝ => t^k) GaussianCDF.uniform := by
+  apply (integrable_const (1:ℝ)).mono' (by fun_prop)
+  filter_upwards [uniform_mem] with t ht
+  rw [Real.norm_eq_abs,abs_pow]
+  exact (pow_le_pow_left₀ (abs_nonneg t) (abs_lt.mpr ht).le k).trans_eq (one_pow k)
+
+lemma coordinate_preserving (j : Fin m) : MeasurePreserving (fun x : E => x j) μ GaussianCDF.uniform := by
+  refine ⟨by fun_prop,?_⟩
+  rw [CubePoincare.cube,Measure.map_map (by fun_prop) (by fun_prop)]
+  exact (measurePreserving_eval (fun _ : Fin m => GaussianCDF.uniform) j).map_eq
+
+lemma coordinate_pow (j : Fin m) (k : ℕ) : (∫ x : E, (x j)^k ∂μ)=
+    (1-(-1:ℝ)^(k+1))/(2*(k+1)) := by
+  rw [← uniform_pow k,← (coordinate_preserving j).map_eq]
+  exact (integral_map (by fun_prop) (continuous_id.pow k).aestronglyMeasurable).symm
+
+lemma coordinate_pow_integrable (j : Fin m) (k : ℕ) : Integrable (fun x : E => (x j)^k) μ :=
+  ((coordinate_preserving j).integrable_comp (continuous_id.pow k).aestronglyMeasurable).mpr (uniform_pow_integrable k)
+
+lemma cube_norm : ∀ᵐ x : E ∂μ, ‖x‖≤Real.sqrt m := by
+  filter_upwards [cube_mem] with x hx
+  have h : ‖x‖^2≤(m:ℝ) := by
+    rw [EuclideanSpace.norm_sq_eq]
+    calc
+      _ ≤ ∑ _j : Fin m, (1:ℝ) := by
+        apply Finset.sum_le_sum; intro j _
+        rw [Real.norm_eq_abs,sq_abs]
+        nlinarith [abs_lt.mp (hx j)]
+      _ = _ := by simp
+  nlinarith [Real.sq_sqrt (Nat.cast_nonneg (α := ℝ) m),norm_nonneg x,Real.sqrt_nonneg (m:ℝ)]
+
+lemma bounded_integrable {f : E → ℝ} (hf : AEStronglyMeasurable f μ) {B : ℝ}
+    (hb : ∀ᵐ x ∂μ, |f x|≤B) : Integrable f μ :=
+  (integrable_const B).mono' hf (by simpa only [Real.norm_eq_abs] using hb)
+
+lemma pair_norm_bound : ∀ᵐ z : E × E ∂(μ).prod μ, ‖z.1-z.2‖≤2*Real.sqrt m := by
+  have hp : ∀ᵐ z : E × E ∂(μ).prod μ, ‖z.1‖≤Real.sqrt m ∧ ‖z.2‖≤Real.sqrt m := by
+    apply (Measure.ae_prod_iff_ae_ae (by measurability)).mpr
+    filter_upwards [cube_norm (m := m)] with x hx
+    filter_upwards [cube_norm (m := m)] with y hy
+    exact ⟨hx,hy⟩
+  filter_upwards [hp] with z hz
+  exact (norm_sub_le _ _).trans (by linarith [hz.1,hz.2])
+
+lemma pair_norm_integrable : Integrable (fun z : E × E => ‖z.1-z.2‖) ((μ).prod μ) := by
+  apply (integrable_const (2*Real.sqrt m)).mono' (by fun_prop)
+  simpa only [Real.norm_eq_abs,abs_norm] using pair_norm_bound (m := m)
+
+lemma coordinate_difference_sq (j : Fin m) :
+    (∫ z : E × E, (z.1 j-z.2 j)^2 ∂(μ).prod μ)=2/3 := by
+  have h1 : Integrable (fun x : E => x j) μ := by simpa using coordinate_pow_integrable j 1
+  have h2 := coordinate_pow_integrable j 2
+  have he : (fun z : E × E => (z.1 j-z.2 j)^2) =
+      (fun z => (z.1 j)^2+(z.2 j)^2-2*(z.1 j*z.2 j)) := by funext z; ring
+  rw [he]
+  have hsub := integral_sub ((h2.comp_fst μ).add (h2.comp_snd μ)) ((h1.mul_prod h1).const_mul 2)
+  simp only [Pi.add_apply] at hsub
+  rw [hsub]
+  have hadd := integral_add (h2.comp_fst μ) (h2.comp_snd μ)
+  rw [hadd,integral_const_mul,integral_prod_mul (fun x : E => x j) (fun x : E => x j)]
+  have he0 : (∫ x : E, x j ∂μ)=0 := by simpa using coordinate_pow j 1
+  have he2 : (∫ x : E, (x j)^2 ∂μ)=1/3 := by
+    have hh := coordinate_pow j 2
+    norm_num at hh ⊢
+    exact hh
+  rw [integral_fun_fst (fun x : E => (x j)^2),integral_fun_snd (fun x : E => (x j)^2)]
+  simp [he0,he2]
+  norm_num
+
+lemma coordinate_difference_sq_integrable (j : Fin m) :
+    Integrable (fun z : E × E => (z.1 j-z.2 j)^2) ((μ).prod μ) := by
+  have h1 : Integrable (fun x : E => x j) μ := by simpa using coordinate_pow_integrable j 1
+  have h2 := coordinate_pow_integrable j 2
+  convert ((h2.comp_fst μ).add (h2.comp_snd μ)).sub ((h1.mul_prod h1).const_mul 2) using 1
+  ext z
+  simp only [Pi.add_apply,Pi.sub_apply]
+  ring
+
+lemma pair_norm_sq_integral : (∫ z : E × E, ‖z.1-z.2‖^2 ∂(μ).prod μ)=2*(m:ℝ)/3 := by
+  have hnorm (z : E × E) : ‖z.1-z.2‖^2=∑ j, (z.1 j-z.2 j)^2 := by
+    rw [EuclideanSpace.norm_sq_eq]
+    congr 1
+    funext j
+    simp only [PiLp.sub_apply,Real.norm_eq_abs,sq_abs]
+  simp_rw [hnorm]
+  rw [integral_finsetSum _ (fun j _ => coordinate_difference_sq_integrable j)]
+  simp only [coordinate_difference_sq,Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]
+  ring
+
+lemma pair_norm_average (hm : 0 < m) :
+    Real.sqrt m/3≤∫ z : E × E, ‖z.1-z.2‖ ∂(μ).prod μ := by
+  have hsq : Integrable (fun z : E × E => ‖z.1-z.2‖^2) ((μ).prod μ) := by
+    apply (integrable_const ((2*Real.sqrt m)^2)).mono' (by fun_prop)
+    filter_upwards [pair_norm_bound (m := m)] with z hz
+    rw [Real.norm_eq_abs,abs_of_nonneg (sq_nonneg _)]
+    exact pow_le_pow_left₀ (norm_nonneg _) hz 2
+  have hh := integral_mono_ae hsq (pair_norm_integrable.const_mul (2*Real.sqrt m)) (by
+    filter_upwards [pair_norm_bound (m := m)] with z hz
+    exact (show ‖z.1-z.2‖^2≤2*Real.sqrt m*‖z.1-z.2‖ by nlinarith [norm_nonneg (z.1-z.2)]))
+  rw [pair_norm_sq_integral,integral_const_mul] at hh
+  have hp : 0<Real.sqrt (m:ℝ) := Real.sqrt_pos.mpr (by exact_mod_cast hm)
+  have hs := Real.sq_sqrt (Nat.cast_nonneg (α := ℝ) m)
+  nlinarith
+
+end
+end UniformSparsestCut.CubeGeometry
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/CubePoincare.lean

@@ -0,0 +1,133 @@
+import OAI.Combinatorics.SparsestCut.GaussianCDF
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.CubePoincare
+open MeasureTheory ProbabilityTheory Set
+open scoped Topology ContDiff ENNReal BigOperators
+variable {m : ℕ}
+local notation "E" => EuclideanSpace ℝ (Fin m)
+
+def Ψ (x : E) : E := WithLp.toLp 2 (fun i => GaussianCDF.ψ (x i))
+def cube : Measure E := (Measure.pi (fun _ : Fin m => GaussianCDF.uniform)).map (WithLp.toLp 2)
+
+instance cube_probability : IsProbabilityMeasure (cube (m := m)) := by
+  unfold cube
+  infer_instance
+
+def coordinate (i : Fin m) : E →L[ℝ] ℝ :=
+  (ContinuousLinearMap.proj i).comp (EuclideanSpace.equiv (Fin m) ℝ).toContinuousLinearMap
+
+@[simp] lemma coordinate_apply (i : Fin m) (x : E) : coordinate i x = x i := rfl
+
+def derivative (x : E) : E →L[ℝ] E :=
+  (EuclideanSpace.equiv (Fin m) ℝ).symm.toContinuousLinearMap.comp
+    (ContinuousLinearMap.pi (fun i => (2*GaussianCDF.φ (x i)) • coordinate i))
+
+@[simp] lemma derivative_apply (x v : E) (i : Fin m) : derivative x v i = 2*GaussianCDF.φ (x i)*v i := rfl
+
+lemma Ψ_hasFDeriv (x : E) : HasFDerivAt Ψ (derivative x) x := by
+  have hi (i : Fin m) := (GaussianCDF.ψ_hasDeriv (x i)).comp_hasFDerivAt x (coordinate i).hasFDerivAt
+  have hp := hasFDerivAt_pi.mpr hi
+  have h := (EuclideanSpace.equiv (Fin m) ℝ).symm.toContinuousLinearMap.hasFDerivAt.comp x hp
+  convert h using 1 <;> rfl
+
+lemma Ψ_contDiff : ContDiff ℝ 1 (Ψ (m := m)) := by
+  have h : ContDiff ℝ 1 (fun x : E => fun i => GaussianCDF.ψ (x i)) :=
+    contDiff_pi.mpr (fun i => GaussianCDF.ψ_contDiff.comp (coordinate i).contDiff)
+  exact (EuclideanSpace.equiv (Fin m) ℝ).symm.toContinuousLinearMap.contDiff.comp h
+
+lemma Ψ_norm (x : E) : ‖Ψ x‖ ≤ Real.sqrt m := by
+  have h : ‖Ψ x‖^2 ≤ (m:ℝ) := by
+    rw [EuclideanSpace.norm_sq_eq]
+    calc
+      _ ≤ ∑ _i : Fin m, (1:ℝ) := by
+        apply Finset.sum_le_sum
+        intro i _
+        have hi := GaussianCDF.ψ_mem (x i)
+        change ‖GaussianCDF.ψ (x i)‖^2 ≤ 1
+        rw [Real.norm_eq_abs, sq_abs]
+        nlinarith [hi.1,hi.2]
+      _ = _ := by simp
+  nlinarith [Real.sq_sqrt (Nat.cast_nonneg (α := ℝ) m), Real.sqrt_nonneg (m:ℝ), norm_nonneg (Ψ x)]
+
+lemma derivative_norm (x : E) : ‖derivative x‖ ≤ 1 := by
+  apply (derivative x).opNorm_le_bound (by norm_num)
+  intro v
+  simp only [one_mul]
+  have h : ‖derivative x v‖^2 ≤ ‖v‖^2 := by
+    simp only [EuclideanSpace.norm_sq_eq]
+    apply Finset.sum_le_sum
+    intro i _
+    change ‖2*GaussianCDF.φ (x i)*v i‖^2 ≤ ‖v i‖^2
+    rw [norm_mul, mul_pow]
+    have hi := GaussianCDF.ψ_deriv_bound (x i)
+    have hh : ‖2*GaussianCDF.φ (x i)‖^2 ≤ 1 := by
+      rw [Real.norm_eq_abs]
+      nlinarith [abs_nonneg (2*GaussianCDF.φ (x i))]
+    nlinarith [sq_nonneg ‖v i‖]
+  nlinarith [norm_nonneg (derivative x v), norm_nonneg v]
+
+lemma Ψ_map : (stdGaussian E).map Ψ = cube := by
+  rw [← map_pi_eq_stdGaussian, Measure.map_map Ψ_contDiff.continuous.measurable (by fun_prop)]
+  have he : (Ψ (m := m)) ∘ WithLp.toLp 2 = WithLp.toLp 2 ∘
+      (fun x : Fin m → ℝ => fun i => GaussianCDF.ψ (x i)) := rfl
+  have hmeas : Measurable (fun x : Fin m → ℝ => fun i => GaussianCDF.ψ (x i)) :=
+    Measurable.of_eval (fun i => GaussianCDF.ψ_contDiff.continuous.measurable.comp (measurable_pi_apply i))
+  rw [he, ← Measure.map_map (by fun_prop) hmeas, Measure.pi_map_pi]
+  · simp_rw [GaussianCDF.ψ_map]
+    rfl
+  · intro i
+    exact GaussianCDF.ψ_contDiff.continuous.measurable.aemeasurable
+
+lemma cube_first_moment (h : E → ℝ) (hh : ContDiff ℝ 1 h) :
+    (∫ z : E × E, |h z.1-h z.2| ∂((cube (m := m)).prod cube)) ≤
+      (Real.pi/2)*(∫ x : E, ‖fderiv ℝ h x‖ ∂cube) := by
+  let μ := stdGaussian E
+  let H : E → ℝ := h ∘ Ψ
+  have hH : ContDiff ℝ 1 H := hh.comp Ψ_contDiff
+  have hcompact := isCompact_closedBall (0:E) (Real.sqrt m)
+  obtain ⟨B,hB⟩ := hcompact.exists_bound_of_continuousOn hh.continuous.continuousOn
+  obtain ⟨M,hM⟩ := hcompact.exists_bound_of_continuousOn (hh.continuous_fderiv (by norm_num)).continuousOn
+  have hmem (x : E) : Ψ x ∈ Metric.closedBall 0 (Real.sqrt m) := by simpa using Ψ_norm x
+  have hB' (x : E) : ‖H x‖ ≤ max B 0 := (hB _ (hmem x)).trans (le_max_left _ _)
+  have hcomp (x : E) : fderiv ℝ H x = (fderiv ℝ h (Ψ x)).comp (derivative x) :=
+    ((hh.differentiable (by norm_num) (Ψ x)).hasFDerivAt.comp x (Ψ_hasFDeriv x)).fderiv
+  have hnorm (x : E) : ‖fderiv ℝ H x‖ ≤ ‖fderiv ℝ h (Ψ x)‖ := by
+    rw [hcomp]
+    exact ContinuousLinearMap.opNorm_comp_le _ _ |>.trans
+      ((mul_le_mul_of_nonneg_left (derivative_norm x) (norm_nonneg _)).trans_eq (mul_one _))
+  have hdB (x : E) : ‖fderiv ℝ H x‖ ≤ max M 0 :=
+    (hnorm x).trans ((hM _ (hmem x)).trans (le_max_left _ _))
+  have hint : Integrable (fun x : E => ‖fderiv ℝ h (Ψ x)‖) μ := by
+    apply (integrable_const (max M 0)).mono' ((hh.continuous_fderiv (by norm_num)).comp Ψ_contDiff.continuous |>.norm.aestronglyMeasurable)
+    filter_upwards with x
+    simpa only [norm_norm, Function.comp_apply] using (hM _ (hmem x)).trans (le_max_left _ _)
+  have hintH : Integrable (fun x : E => ‖fderiv ℝ H x‖) μ := by
+    apply hint.mono' (by have hc := hH.continuous_fderiv (by norm_num); fun_prop)
+    filter_upwards with x
+    simpa only [norm_norm] using hnorm x
+  have hp := GaussianPoincare.rotation_first_moment H hH (le_max_right M 0) hdB hB'
+  have hmeasure : MeasurePreserving Ψ μ cube := ⟨Ψ_contDiff.continuous.measurable, Ψ_map⟩
+  have hprod := hmeasure.prod hmeasure
+  have heL : (∫ z : E × E, |H z.1-H z.2| ∂μ.prod μ) =
+      ∫ z : E × E, |h z.1-h z.2| ∂((cube (m := m)).prod cube) := by
+    rw [← hprod.map_eq]
+    exact (integral_map (f := fun z : E × E => |h z.1-h z.2|) hprod.measurable.aemeasurable (by fun_prop)).symm
+  have heR : (∫ x : E, ‖fderiv ℝ h (Ψ x)‖ ∂μ) = ∫ x : E, ‖fderiv ℝ h x‖ ∂cube := by
+    rw [← hmeasure.map_eq]
+    exact (integral_map (f := fun x : E => ‖fderiv ℝ h x‖) hmeasure.measurable.aemeasurable
+      (by have hc := hh.continuous_fderiv (by norm_num); fun_prop)).symm
+  rw [← heL, ← heR]
+  exact hp.trans (mul_le_mul_of_nonneg_left (integral_mono hintH hint hnorm) (by positivity))
+
+end UniformSparsestCut.CubePoincare
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/CubeTransfer.lean

@@ -0,0 +1,145 @@
+import OAI.Combinatorics.SparsestCut.CubeGeometry
+
+namespace OAI
+
+universe u1 u2
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.CubeTransfer
+open MeasureTheory Set Filter
+open scoped BigOperators
+noncomputable section
+variable {m : ℕ} {A : Type u1} [Fintype A]
+local notation "E" => EuclideanSpace ℝ (Fin m)
+local notation "μ" => CubePoincare.cube (m := m)
+lemma continuous_integrable (f : E → ℝ) (hf : Continuous f) : Integrable f μ := by
+  obtain ⟨B,hB⟩ := (isCompact_closedBall (0:E) (Real.sqrt m)).exists_bound_of_continuousOn hf.continuousOn
+  apply CubeGeometry.bounded_integrable hf.aestronglyMeasurable
+  filter_upwards [CubeGeometry.cube_norm (m := m)] with x hx
+  simpa only [Real.norm_eq_abs] using hB x (by simpa using hx)
+lemma pair_continuous_integrable (f : E × E → ℝ) (hf : Continuous f) : Integrable f ((μ).prod μ) := by
+  let K : Set E := Metric.closedBall 0 (Real.sqrt m)
+  have hK : IsCompact K := isCompact_closedBall _ _
+  obtain ⟨B,hB⟩ := (hK.prod hK).exists_bound_of_continuousOn hf.continuousOn
+  have hm : ∀ᵐ x : E ∂μ, x∈K := by simpa only [K,Metric.mem_closedBall,dist_zero_right] using CubeGeometry.cube_norm (m := m)
+  have hp : ∀ᵐ z : E × E ∂(μ).prod μ, z∈K ×ˢ K := by
+    apply (Measure.ae_prod_iff_ae_ae (hK.measurableSet.prod hK.measurableSet)).mpr
+    filter_upwards [hm] with x hx
+    filter_upwards [hm] with y hy
+    exact ⟨hx,hy⟩
+  apply (integrable_const B).mono' hf.aestronglyMeasurable
+  filter_upwards [hp] with z hz
+  exact hB z hz
+
+lemma average_from_gradient (f H : A → E → ℝ) {M B K : ℝ}
+    (hf : ∀ a, Measurable (f a)) (hM : ∀ a x, |f a x|≤M)
+    (hH : ∀ a, ContDiff ℝ 1 (H a))
+    (he : ∀ᵐ x : E ∂μ, ∑ a, |H a x-f a x|≤B)
+    (hg : ∀ᵐ x : E ∂μ, ∑ a, ‖fderiv ℝ (H a) x‖≤K) :
+    (∫ z : E × E, ∑ a, |f a z.1-f a z.2| ∂(μ).prod μ)≤2*B+(Real.pi/2)*K := by
+  classical
+  have hfi (a : A) : Integrable (f a) μ :=
+    CubeGeometry.bounded_integrable (hf a).aestronglyMeasurable (Eventually.of_forall (hM a))
+  have hfdi (a : A) : Integrable (fun z : E × E => |f a z.1-f a z.2|) ((μ).prod μ) :=
+    ((hfi a).comp_fst μ |>.sub ((hfi a).comp_snd μ)).abs
+  have hHd (a : A) : Integrable (fun z : E × E => |H a z.1-H a z.2|) ((μ).prod μ) :=
+    pair_continuous_integrable _ (by have hh := (hH a).continuous; fun_prop)
+  have hDi (a : A) : Integrable (fun x : E => ‖fderiv ℝ (H a) x‖) μ :=
+    continuous_integrable _ (by exact ((hH a).continuous_fderiv (by norm_num)).norm)
+  have hgb : (∫ z : E × E, ∑ a, |H a z.1-H a z.2| ∂(μ).prod μ)≤(Real.pi/2)*K := by
+    rw [integral_finsetSum _ (fun a _ => hHd a)]
+    calc
+      _ ≤ ∑ a, (Real.pi/2)*(∫ x : E, ‖fderiv ℝ (H a) x‖ ∂μ) :=
+        Finset.sum_le_sum (fun a _ => CubePoincare.cube_first_moment (H a) (hH a))
+      _ = (Real.pi/2)*(∫ x : E, ∑ a, ‖fderiv ℝ (H a) x‖ ∂μ) := by
+        rw [integral_finsetSum _ (fun a _ => hDi a),Finset.mul_sum]
+      _ ≤ (Real.pi/2)*K := by
+        apply mul_le_mul_of_nonneg_left _ (by positivity)
+        calc
+          _ ≤ ∫ _x : E, K ∂μ := integral_mono_ae (integrable_finsetSum _ (fun a _ => hDi a)) (integrable_const K) hg
+          _ = _ := by simp
+  have hep : ∀ᵐ z : E × E ∂(μ).prod μ,
+      (∑ a, |H a z.1-f a z.1|≤B) ∧ (∑ a, |H a z.2-f a z.2|≤B) := by
+    have hem : Measurable (fun x : E => ∑ a, |H a x-f a x|) :=
+      Finset.measurable_sum _ (fun a _ => ((hH a).continuous.measurable.sub (hf a)).abs)
+    apply (Measure.ae_prod_iff_ae_ae
+      ((measurableSet_le (hem.comp measurable_fst) measurable_const).inter
+        (measurableSet_le (hem.comp measurable_snd) measurable_const))).mpr
+    filter_upwards [he] with x hx
+    filter_upwards [he] with y hy
+    exact ⟨hx,hy⟩
+  have hpoint : ∀ᵐ z : E × E ∂(μ).prod μ, (∑ a, |f a z.1-f a z.2|)≤2*B+∑ a, |H a z.1-H a z.2| := by
+    filter_upwards [hep] with z hz
+    have hle (a : A) : |f a z.1-f a z.2|≤|H a z.1-f a z.1|+|H a z.1-H a z.2|+|H a z.2-f a z.2| := by
+      calc
+        _ = |-(H a z.1-f a z.1)+(H a z.1-H a z.2)+(H a z.2-f a z.2)| := by congr 1; ring
+        _ ≤ _ := by simpa only [abs_neg] using (abs_add_three (-(H a z.1-f a z.1)) (H a z.1-H a z.2) (H a z.2-f a z.2))
+    have hh := Finset.sum_le_sum (fun a (_ : a∈(Finset.univ : Finset A)) => hle a)
+    simp only [Finset.sum_add_distrib] at hh
+    linarith [hz.1,hz.2]
+  have hfinal := integral_mono_ae (integrable_finsetSum _ (fun a _ => hfdi a))
+    ((integrable_const (2*B)).add (integrable_finsetSum _ (fun a _ => hHd a))) hpoint
+  simp only [Pi.add_apply] at hfinal
+  have hadd := integral_add (show Integrable (fun _ : E × E => 2*B) ((μ).prod μ) from integrable_const _)
+    (integrable_finsetSum Finset.univ (fun a _ => hHd a))
+  rw [hadd] at hfinal
+  simpa using hfinal.trans (add_le_add le_rfl hgb)
+end
+end UniformSparsestCut.CubeTransfer
+
+namespace UniformSparsestCut.ContractionAverage
+open MeasureTheory Set Filter
+open scoped BigOperators RealInnerProductSpace
+noncomputable section
+variable {m N S : ℕ} {A : Type u2} [Fintype A]
+local notation "E" => EuclideanSpace ℝ (Fin (m+1))
+local notation "μ" => CubePoincare.cube (m := m+1)
+open ContractionCore
+
+lemma average (u : Fin S → Fin N → E) (hu : ∀ s i, u s i 0≠0)
+    (hnp : ∀ s i j, i≠j → ∀ t : ℝ, u s i≠t • u s j) (hn : ∀ s i, ‖u s i‖≤2)
+    {τ lam δ R J G : ℝ} (hτ : 0<τ) (hlam : 0<lam) (hlam1 : lam<1)
+    (hδ : 0≤δ) (hJ : 0≤J) (hG : 0≤G)
+    (F : RoundedCharts.Vertex u τ → A → ℝ) {M : ℝ} (hM : 0≤M) (hbound : ∀ v a, |F v a|≤M)
+    (hclose : ∀ s t x (hx : x∈RoundedCharts.cube 2)
+      (hs : RoundedCharts.regular (u s) τ x) (ht : RoundedCharts.regular (u t) τ x),
+      ∑ a, |F (vertex u τ s x hx hs) a-F (vertex u τ t x hx ht) a|≤R)
+    (hmacro : ∀ s x y (hx : x∈RoundedCharts.cube 2) (hy : y∈RoundedCharts.cube 2)
+      (hs : RoundedCharts.regular (u s) τ x) (ht : RoundedCharts.regular (u s) τ y),
+      ∑ a, |F (vertex u τ s x hx hs) a-F (vertex u τ s y hy ht) a|≤G*‖x-y‖+R)
+    (hjump : ∀ (vp vm : RoundedCharts.Vertex u τ) (i : Fin N), vp.val.1=vm.val.1 →
+      vp.val.2 i=vm.val.2 i+1 → (∀ j, j≠i → vp.val.2 j=vm.val.2 j) → ∑ a, |F vp a-F vm a|≤J)
+    (hsmall : ∀ s i, τ/|u s i 0| *KernelGeometry.L lam≤1)
+    (hgood : ∀ D : StrongDual ℝ E, ∃ good : Finset (Fin S), (S:ℝ)/2≤good.card ∧
+      ∀ s∈good, ∀ i, |D (u s i)|≤δ*‖D‖)
+    (s0 : Fin S) :
+    (∫ z : E × E, ∑ a, |ConcreteCells.function u hu τ F s0 a z.1-
+        ConcreteCells.function u hu τ F s0 a z.2| ∂(μ).prod μ)≤
+      2*(G*(lam*Real.sqrt (m+1:ℕ))+R)+Real.pi*(δ*((N:ℝ)*(2*J/τ))+(m+1:ℕ)*R*KernelGeometry.L lam) := by
+  let f : A → E → ℝ := ConcreteCells.function u hu τ F s0
+  let H : A → E → ℝ := fun a => ConvolutionBounds.smooth (KernelGeometry.κ lam) (f a) volume
+  have hc (a : A) : ContDiff ℝ 1 (H a) := by
+    exact (KernelGeometry.compact hlam).contDiff_convolution_left (ContinuousLinearMap.mul ℝ ℝ)
+      ((KernelGeometry.smooth lam).of_le (by simp)) (ConcreteCells.function_integrable u hu τ F hM hbound s0 a)
+  have he : ∀ᵐ x : E ∂μ, (∑ a, |H a x-f a x|)≤G*(lam*Real.sqrt (m+1:ℕ))+R := by
+    have hr := CubeGeometry.cube_ac.ae_le (RoundedCharts.ae_regular (u s0) τ (by
+      intro i h; exact hu s0 i (by rw [h]; rfl)))
+    filter_upwards [CubeGeometry.cube_mem (m := m+1),hr] with x hx hrx
+    exact smoothing_error u hu hτ hlam hlam1 hn hG F hM hbound hmacro s0 x (fun j => (hx j).le) hrx
+  have hg : ∀ᵐ x : E ∂μ, (∑ a, ‖fderiv ℝ (H a) x‖)≤
+      2*(δ*((N:ℝ)*(2*J/τ))+(m+1:ℕ)*R*KernelGeometry.L lam) := by
+    filter_upwards [CubeGeometry.cube_mem (m := m+1)] with x hx
+    exact gradient_bound u hu hnp hn hτ hlam hlam1 hδ hJ F hM hbound hclose hjump hsmall hgood s0 x (fun j => (hx j).le)
+  have h := CubeTransfer.average_from_gradient f H (fun a => ConcreteCells.function_measurable u hu τ F s0 a)
+    (fun a x => ConcreteCells.function_bounded u hu τ F hM hbound s0 a x) hc he hg
+  convert h using 1 ; ring
+end
+end UniformSparsestCut.ContractionAverage
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/CutDuality.lean

@@ -0,0 +1,134 @@
+import OAI.Combinatorics.SparsestCut.Semimetrics
+import OAI.Combinatorics.SparsestCut.FiniteDuality
+
+namespace OAI
+
+universe u1
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut
+
+section CutConeDuality
+variable {n : ℕ}
+
+lemma pairSum_sum {K : Type u1} [Fintype K] (f : K → Fin n → Fin n → ℝ) :
+    pairSum (fun i j => ∑ k, f k i j) = ∑ k, pairSum (f k) := by
+  classical
+  unfold pairSum
+  have hh (i j : Fin n) : (if i < j then ∑ k, f k i j else 0) =
+      ∑ k, if i < j then f k i j else 0 := by
+    split_ifs <;> simp_all
+  simp_rw [hh]
+  conv_lhs => arg 2; intro i; rw [Finset.sum_comm]
+  rw [Finset.sum_comm]
+
+noncomputable def symmetrizeCapacity (c : (Fin n × Fin n) → ℝ)
+    (hc : ∀ e, 0 ≤ c e) : Capacity n where
+  cap i j := if i = j then 0 else c (i,j) + c (j,i)
+  nonneg i j := by split_ifs; exact le_rfl; exact add_nonneg (hc _) (hc _)
+  symm i j := by by_cases h : i = j <;> simp [h, eq_comm, add_comm]
+  diagonal i := by simp
+
+lemma symmetrize_objective (c : (Fin n × Fin n) → ℝ) (hc : ∀ e, 0 ≤ c e)
+    (d : Fin n → Fin n → ℝ) (hs : ∀ i j, d i j = d j i) (hd : ∀ i, d i i = 0) :
+    pairSum (fun i j => (symmetrizeCapacity c hc).cap i j * d i j) =
+      ∑ e, c e * d e.1 e.2 := by
+  have hfun : (fun i j => (symmetrizeCapacity c hc).cap i j * d i j) =
+      (fun i j => c (i,j) * d i j + c (j,i) * d j i) := by
+    funext i j
+    by_cases h : i = j
+    · subst j; simp [hd]
+    · simp [symmetrizeCapacity, h, hs j i, add_mul]
+  rw [hfun, pairSum_add, pairSum_swap _ (fun i => by simp [hd])]
+  exact (Fintype.sum_prod_type (fun e : Fin n × Fin n => c e * d e.1 e.2)).symm
+
+theorem cut_cone_duality (hn : 2 ≤ n) (d : Fin n → Fin n → ℝ)
+    (hd : NegativeType d) {a b : ℝ} (ha : 0 < a) (hb : 0 < b)
+    (havg : (n : ℝ)^2 * a ≤ ∑ i, ∑ j, d i j)
+    (hcon : ∀ (K : Type) [Fintype K] (F : Fin n → K → ℝ),
+      (∀ i j, (∑ k, |F i k - F j k|) ≤ d i j) →
+      (∑ i, ∑ j, ∑ k, |F i k - F j k|) ≤ (n : ℝ)^2 * b) :
+    ∃ C : Capacity n, 1 ≤ OPT C ∧ 0 < glValue C ∧ glValue C ≤ b / a := by
+  classical
+  have hsemi := hd.semimetric
+  let A : (Fin n × Fin n) → Cut n → ℝ := fun e B => cutDist B.1 e.1 e.2
+  let w : Cut n → ℝ := fun B => cutDemand B.1
+  have hcol (B : Cut n) : 0 < ∑ e, A e B := by
+    change 0 < ∑ e : Fin n × Fin n, cutDist B.1 e.1 e.2
+    rw [Fintype.sum_prod_type, orderedSum_eq_two_pairSum _ (cutDist_symm _) (cutDist_self _), pairSum_cut]
+    exact mul_pos (by norm_num) (cutDemand_pos B)
+  have hbound (t : Cut n → ℝ) (ht : ∀ B, 0 ≤ t B)
+      (htd : ∀ e, ∑ B, A e B * t B ≤ d e.1 e.2) :
+      (∑ B, w B * t B) ≤ (n : ℝ)^2 * b / 2 := by
+    let F : Fin n → Cut n → ℝ := fun i B => t B * cutIndicator B.1 i
+    have hFd (i j : Fin n) : (∑ B, |F i B - F j B|) = ∑ B, t B * cutDist B.1 i j := by
+      apply Finset.sum_congr rfl
+      intro B hB
+      simp [F, cutDist, ← mul_sub, abs_mul, abs_of_nonneg (ht B)]
+    have hcontract (i j : Fin n) : (∑ B, |F i B - F j B|) ≤ d i j := by
+      rw [hFd]
+      simpa only [A, mul_comm] using htd (i,j)
+    have htavg := hcon (Cut n) F hcontract
+    simp_rw [hFd] at htavg
+    have hsym (i j : Fin n) : (∑ B, t B * cutDist B.1 i j) =
+        ∑ B, t B * cutDist B.1 j i := by simp_rw [cutDist_symm _ i j]
+    rw [orderedSum_eq_two_pairSum _ hsym (fun i => by simp), pairSum_sum] at htavg
+    simp_rw [pairSum_smul, pairSum_cut] at htavg
+    have he : (∑ B, w B * t B) = ∑ B, t B * cutDemand B.1 := by
+      unfold w; simp_rw [mul_comm]
+    rw [he]
+    linarith
+  let W : ℝ := ∑ B : Cut n, w B
+  have hw0 (B : Cut n) : 0 ≤ w B := (cutDemand_pos B).le
+  obtain ⟨c,hc,hcover,hobj⟩ := FiniteDuality.packing_duality A w
+    (fun e B => cutDist_binary B.1 e.1 e.2) hcol
+    (fun e => d e.1 e.2) (fun e => hsemi.1 _ _)
+    (show 0 ≤ (n : ℝ)^2 * b / 2 by positivity)
+    (show 0 ≤ W from Finset.sum_nonneg (fun B hB => hw0 B))
+    (fun B => Finset.single_le_sum (fun B hB => hw0 B) (Finset.mem_univ B)) hbound
+  let C := symmetrizeCapacity c hc
+  have hC (B : Cut n) : cutDemand B.1 ≤ ∑ i ∈ B.1, ∑ j ∈ B.1ᶜ, C.cap i j := by
+    rw [← cut_capacity_pair, symmetrize_objective c hc _ (cutDist_symm _) (cutDist_self _)]
+    simpa only [A, w, mul_comm] using hcover B
+  refine ⟨C, OPT_ge_one_of_cuts C hn hC, glValue_pos_of_cuts C hn hC, ?_⟩
+  let D := pairSum d
+  have havg' : (n : ℝ)^2 * a ≤ 2 * D := by
+    simpa only [orderedSum_eq_two_pairSum d hsemi.2.1 hsemi.2.2.1] using havg
+  have hn0 : 0 < (n : ℝ) := by exact_mod_cast (show 0 < n by omega)
+  have hD : 0 < D := by nlinarith [mul_pos (sq_pos_of_pos hn0) ha]
+  let d' := fun i j => D⁻¹ * d i j
+  have hd' : Feasible d' := by
+    refine ⟨hd.scale (inv_nonneg.mpr hD.le), ?_⟩
+    change pairSum (fun i j => D��¹ * d i j) = 1
+    rw [pairSum_smul, inv_mul_cancel₀ hD.ne']
+  have hbdd : BddBelow {r | ∃ d : Fin n → Fin n → ℝ, Feasible d ∧
+      r = pairSum (fun i j => C.cap i j * d i j)} := by
+    refine ⟨0, ?_⟩
+    rintro r ⟨d,hd,rfl⟩
+    exact objective_nonneg C hd.1.semimetric
+  have hgl : glValue C ≤ pairSum (fun i j => C.cap i j * d' i j) :=
+    csInf_le hbdd ⟨d',hd',rfl⟩
+  apply hgl.trans
+  have hscale : pairSum (fun i j => C.cap i j * d' i j) =
+      (pairSum (fun i j => C.cap i j * d i j)) / D := by
+    simp only [d', div_eq_mul_inv]
+    rw [mul_comm _ D⁻¹, ← pairSum_smul D⁻¹]
+    congr 1
+    funext i j; ring
+  rw [hscale, symmetrize_objective c hc d hsemi.2.1 hsemi.2.2.1,
+    div_le_div_iff₀ hD ha]
+  have hh1 := mul_le_mul_of_nonneg_right hobj ha.le
+  have hh2 := mul_le_mul_of_nonneg_right havg' hb.le
+  nlinarith
+
+end CutConeDuality
+
+end UniformSparsestCut
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/CutSums.lean

@@ -0,0 +1,165 @@
+import OAI.Combinatorics.SparsestCut.FiniteDuality
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut
+
+section CutSums
+
+variable {n : ℕ}
+
+lemma pairSum_nonneg {f : Fin n → Fin n → ℝ} (hf : ∀ i j, 0 ≤ f i j) :
+    0 ≤ pairSum f := by
+  apply Finset.sum_nonneg
+  intro i hi
+  apply Finset.sum_nonneg
+  intro j hj
+  split_ifs
+  · exact hf _ _
+  · exact le_rfl
+
+lemma pairSum_add (f g : Fin n → Fin n → ℝ) :
+    pairSum (fun i j => f i j + g i j) = pairSum f + pairSum g := by
+  simp only [pairSum, ← Finset.sum_add_distrib]
+  apply Finset.sum_congr rfl
+  intro i hi
+  apply Finset.sum_congr rfl
+  intro j hj
+  split_ifs <;> ring
+
+lemma pairSum_smul (a : ℝ) (f : Fin n → Fin n → ℝ) :
+    pairSum (fun i j => a * f i j) = a * pairSum f := by
+  simp only [pairSum, Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro i hi
+  apply Finset.sum_congr rfl
+  intro j hj
+  split_ifs <;> ring
+
+lemma pairSum_swap (f : Fin n → Fin n → ℝ) (hd : ∀ i, f i i = 0) :
+    pairSum f + pairSum (fun i j => f j i) = ∑ i, ∑ j, f i j := by
+  unfold pairSum
+  conv_lhs => rhs; rw [Finset.sum_comm]
+  rw [← Finset.sum_add_distrib]
+  apply Finset.sum_congr rfl
+  intro i hi
+  rw [← Finset.sum_add_distrib]
+  apply Finset.sum_congr rfl
+  intro j hj
+  rcases lt_trichotomy i j with h | h | h
+  · simp [h, not_lt.mpr h.le]
+  · subst j; simp [hd]
+  · simp [h, not_lt.mpr h.le]
+
+lemma orderedSum_eq_two_pairSum (f : Fin n → Fin n → ℝ)
+    (hs : ∀ i j, f i j = f j i) (hd : ∀ i, f i i = 0) :
+    (∑ i, ∑ j, f i j) = 2 * pairSum f := by
+  have he : (fun i j => f j i) = f := funext (fun i => funext (fun j => hs j i))
+  simpa [he, two_mul] using (pairSum_swap f hd).symm
+
+lemma le_pairSum {f : Fin n → Fin n → ℝ} (hf : ∀ i j, 0 ≤ f i j)
+    {i j : Fin n} (hij : i < j) : f i j ≤ pairSum f := by
+  calc
+    f i j ≤ ∑ k, if i < k then f i k else 0 := by
+      have := Finset.single_le_sum (s := Finset.univ)
+        (f := fun k => if i < k then f i k else 0)
+        (fun k hk => by split_ifs; exact hf _ _; exact le_rfl) (Finset.mem_univ j)
+      simpa [hij] using this
+    _ ≤ pairSum f := by
+      unfold pairSum
+      apply Finset.single_le_sum (f := fun k => ∑ l, if k < l then f k l else 0) (a := i)
+      · intro k hk
+        apply Finset.sum_nonneg
+        intro l hl
+        split_ifs
+        · exact hf _ _
+        · exact le_rfl
+      · exact Finset.mem_univ i
+
+noncomputable def cutIndicator (B : Finset (Fin n)) (i : Fin n) : ℝ := if i ∈ B then 1 else 0
+noncomputable def cutDist (B : Finset (Fin n)) (i j : Fin n) : ℝ :=
+  |cutIndicator B i - cutIndicator B j|
+noncomputable def cutDemand (B : Finset (Fin n)) : ℝ := (B.card : ℝ) * (Bᶜ.card : ℝ)
+
+def Cut (n : ℕ) := {B : Finset (Fin n) // B.Nonempty ∧ B ≠ Finset.univ}
+
+noncomputable instance : Fintype (Cut n) := by unfold Cut; exact Fintype.ofFinite _
+
+lemma cutDist_nonneg (B : Finset (Fin n)) (i j : Fin n) : 0 ≤ cutDist B i j := abs_nonneg _
+lemma cutDist_symm (B : Finset (Fin n)) (i j : Fin n) : cutDist B i j = cutDist B j i :=
+  abs_sub_comm _ _
+@[simp] lemma cutDist_self (B : Finset (Fin n)) (i : Fin n) : cutDist B i i = 0 := by
+  simp [cutDist]
+
+lemma cutDist_binary (B : Finset (Fin n)) (i j : Fin n) :
+    cutDist B i j = 0 ∨ cutDist B i j = 1 := by
+  classical
+  unfold cutDist cutIndicator
+  split_ifs <;> norm_num
+
+lemma cutDist_triangle (B : Finset (Fin n)) (i j k : Fin n) :
+    cutDist B i k ≤ cutDist B i j + cutDist B j k := abs_sub_le _ _ _
+
+lemma cutDemand_eq (B : Finset (Fin n)) :
+    cutDemand B = (B.card : ℝ) * ((n : ℝ) - B.card) := by
+  unfold cutDemand
+  rw [Finset.card_compl, Fintype.card_fin, Nat.cast_sub (show B.card ≤ n by simpa using B.card_le_univ)]
+
+lemma cutDemand_pos (B : Cut n) : 0 < cutDemand B.1 := by
+  unfold cutDemand
+  apply mul_pos
+  · exact_mod_cast Finset.card_pos.mpr B.2.1
+  · exact_mod_cast Finset.card_pos.mpr (by simpa [Finset.nonempty_iff_ne_empty] using B.2.2)
+
+lemma ordered_cut_sum (B : Finset (Fin n)) (f : Fin n → Fin n → ℝ) :
+    (∑ i, ∑ j, f i j * cutDist B i j) =
+      (∑ i ∈ B, ∑ j ∈ Bᶜ, f i j) + (∑ i ∈ Bᶜ, ∑ j ∈ B, f i j) := by
+  classical
+  have hp (i j : Fin n) : f i j * cutDist B i j =
+      (if i ∈ B then if j ∈ Bᶜ then f i j else 0 else 0) +
+      (if i ∈ Bᶜ then if j ∈ B then f i j else 0 else 0) := by
+    unfold cutDist cutIndicator
+    by_cases hi : i ∈ B <;> by_cases hj : j ∈ B <;> simp [hi, hj]
+  simp_rw [hp]
+  simp only [Finset.sum_add_distrib, Finset.sum_ite_irrel,
+    Finset.sum_const_zero, Finset.sum_ite_mem, Finset.univ_inter]
+
+lemma ordered_cut_sum_symm (B : Finset (Fin n)) (f : Fin n → Fin n → ℝ)
+    (hs : ∀ i j, f i j = f j i) :
+    (∑ i, ∑ j, f i j * cutDist B i j) = 2 * (∑ i �� B, ∑ j ∈ Bᶜ, f i j) := by
+  rw [ordered_cut_sum, two_mul]
+  congr 1
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro i hi
+  apply Finset.sum_congr rfl
+  intro j hj
+  exact hs j i
+
+lemma pairSum_cut (B : Finset (Fin n)) : pairSum (cutDist B) = cutDemand B := by
+  have h := ordered_cut_sum_symm B (fun _ _ => 1) (fun _ _ => rfl)
+  simp only [one_mul, Finset.sum_const, nsmul_eq_mul, mul_one] at h
+  rw [orderedSum_eq_two_pairSum _ (cutDist_symm B) (cutDist_self B)] at h
+  unfold cutDemand
+  nlinarith
+
+lemma cut_capacity_pair (C : Capacity n) (B : Finset (Fin n)) :
+    pairSum (fun i j => C.cap i j * cutDist B i j) =
+      ∑ i ∈ B, ∑ j ∈ Bᶜ, C.cap i j := by
+  have h := ordered_cut_sum_symm B C.cap C.symm
+  rw [orderedSum_eq_two_pairSum _ (fun i j => by rw [C.symm i j, cutDist_symm B i j])
+    (fun i => by simp)] at h
+  linarith
+
+end CutSums
+
+end UniformSparsestCut
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/DirectionAsymptotics.lean

@@ -0,0 +1,217 @@
+import OAI.Combinatorics.SparsestCut.DirectionInterpolation
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.DirectionAsymptotics
+open Filter
+open scoped Topology
+
+lemma grid_card_bound (m k : ℕ) (hm : 2 ≤ m) :
+    (((2*m^k+1)^m : ℕ) : ℝ) ≤ Real.exp (((k : ℝ)+2)*(m : ℝ)^2) := by
+  have hm' : (2 : ℝ) ≤ m := by exact_mod_cast hm
+  have hp : (1 : ℝ) ≤ (m : ℝ)^k := one_le_pow₀ (by linarith)
+  have he : (m : ℝ) ≤ Real.exp m := by linarith [Real.add_one_le_exp (m : ℝ)]
+  have h3 : (3 : ℝ) ≤ Real.exp m := by linarith [Real.add_one_le_exp (m : ℝ)]
+  have hb : (2 : ℝ)*(m : ℝ)^k+1 ≤ Real.exp ((k+1 : ℕ)*(m : ℝ)) := by
+    calc
+      _ ≤ 3*(m : ℝ)^k := by linarith
+      _ ≤ Real.exp m * (Real.exp m)^k := by gcongr
+      _ = _ := by rw [← Real.exp_nat_mul]; rw [← Real.exp_add]; congr 1; push_cast; ring
+  push_cast
+  calc
+    _ ≤ (Real.exp ((k+1 : ℕ)*(m : ℝ)))^m := pow_le_pow_left₀ (by positivity) hb _
+    _ = Real.exp (((k : ℝ)+1)*(m : ℝ)^2) := by rw [← Real.exp_nat_mul]; congr 1; push_cast; ring
+    _ ≤ _ := by apply Real.exp_le_exp.mpr; nlinarith [sq_nonneg (m : ℝ)]
+
+lemma polynomial_exp_tendsto_zero (k : ℕ) {c : ℝ} (hc : 0 < c) :
+    Tendsto (fun m : ℕ => (m : ℝ)^k * Real.exp (-c*(m : ℝ))) atTop (𝓝 0) := by
+  have h := (tendsto_rpow_mul_exp_neg_mul_atTop_nhds_zero (k : ℝ) c hc).comp
+    tendsto_natCast_atTop_atTop
+  simpa only [Real.rpow_natCast, Function.comp_def] using h
+
+lemma large_fourier_exponent (x : ℝ) (hx : 1000000 ≤ x) :
+    54*x^2 - x^4/2048 ≤ -x := by
+  have hx0 : 0 ≤ x := by linarith
+  have hx2 : 1000000^2 ≤ x^2 := by nlinarith
+  have hprod := mul_nonneg (show 1000000^2 - (54*2048+2048 : ℝ) ≥ 0 by norm_num) (sq_nonneg x)
+  have hx4 : (1000000 : ℝ)^2*x^2 ≤ x^4 := by nlinarith [mul_le_mul_of_nonneg_right hx2 (sq_nonneg x)]
+  have hxx : x ≤ x^2 := by nlinarith
+  nlinarith
+
+lemma large_chart_exponent (x : ℝ) (hx : 1000000 ≤ x) :
+    6*x^2 - x^3/32 ≤ -x := by
+  have hh : 1000000*x^2 ≤ x^3 := by nlinarith [mul_le_mul_of_nonneg_right hx (sq_nonneg x)]
+  have hxx : x ≤ x^2 := by nlinarith
+  nlinarith
+
+lemma selection_majorant_tendsto :
+    Tendsto (fun m : ℕ => 2*(m : ℝ)^9*Real.exp (-(m : ℝ)/8) +
+      6*(m : ℝ)^3*Real.exp (-(m : ℝ))) atTop (𝓝 0) := by
+  have h1 := (polynomial_exp_tendsto_zero 9 (c := 1/8) (by norm_num)).const_mul 2
+  have h2 := (polynomial_exp_tendsto_zero 3 (c := 1) (by norm_num)).const_mul 6
+  convert h1.add h2 using 1
+  · funext m
+    simp only [show -(1/8 : ℝ)*(m : ℝ) = -(m : ℝ)/8 by ring,
+      show -(1 : ℝ)*(m : ℝ) = -(m : ℝ) by ring]
+    ring
+  · norm_num
+
+lemma eventual_selection_majorant : ∀ᶠ m : ℕ in atTop,
+    2*(m : ℝ)^9*Real.exp (-(m : ℝ)/8) +
+      6*(m : ℝ)^3*Real.exp (-(m : ℝ)) < 1 :=
+  selection_majorant_tendsto.eventually (gt_mem_nhds (by norm_num))
+
+lemma normalized_fourier_exponent {m : ℕ} (hm : 0 < m) :
+    -(m : ℝ)^6*(1/(2*Real.sqrt m))^2/(2*(2*Real.sqrt m)^2) = -(m : ℝ)^4/32 := by
+  have hm0 : (m : ℝ) ≠ 0 := by exact_mod_cast hm.ne'
+  have hs : (2*Real.sqrt m)^2 = 4*(m : ℝ) := by
+    nlinarith [Real.sq_sqrt (Nat.cast_nonneg (α := ℝ) m)]
+  rw [_root_.one_div_pow, hs]
+  field_simp
+  ring
+
+lemma normalized_covariance_exponent (m : ℕ) (hm : 0 < m) :
+    -(m : ℝ)^6*(1/8)^2/(2*(4*(m : ℝ))^2) = -(m : ℝ)^4/2048 := by
+  have hm0 : (m : ℝ) ≠ 0 := by exact_mod_cast hm.ne'
+  field_simp
+  ring
+
+lemma probability_majorization {m : ℕ} (hm : 1000000 ≤ m) {A B : ℝ}
+    (_hA0 : 0 ≤ A) (hB0 : 0 ≤ B)
+    (hA : A ≤ Real.exp (6*(m : ℝ)^2)) (hB : B ≤ Real.exp (48*(m : ℝ)^2)) :
+    (m : ℝ)^3*((m : ℝ)^6*(2*Real.exp (-(m : ℝ)/8)) +
+      A*B*(2*Real.exp (-(m : ℝ)^4/32)) + A*(2*Real.exp (-(m : ℝ)^4/2048))) +
+      A*(2*Real.exp (-(m : ℝ)^3/32)) ≤
+      2*(m : ℝ)^9*Real.exp (-(m : ℝ)/8) + 6*(m : ℝ)^3*Real.exp (-(m : ℝ)) := by
+  have hm' : (1000000 : ℝ) ≤ m := by exact_mod_cast hm
+  have hpow : (1 : ℝ) ≤ (m : ℝ)^3 := one_le_pow₀ (by linarith)
+  have hf : A*B*(2*Real.exp (-(m : ℝ)^4/32)) ≤ 2*Real.exp (-(m : ℝ)) := by
+    calc
+      _ ≤ Real.exp (6*(m : ℝ)^2)*Real.exp (48*(m : ℝ)^2)*
+          (2*Real.exp (-(m : ℝ)^4/32)) := by gcongr
+      _ = 2*Real.exp (54*(m : ℝ)^2-(m : ℝ)^4/32) := by
+        rw [show 54*(m : ℝ)^2-(m : ℝ)^4/32 =
+          (6*(m : ℝ)^2+48*(m : ℝ)^2)+(-(m : ℝ)^4/32) by ring, Real.exp_add, Real.exp_add]
+        ring
+      _ ≤ _ := by
+        apply mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr ?_) (by norm_num)
+        have := large_fourier_exponent (m : ℝ) hm'
+        nlinarith [pow_nonneg (Nat.cast_nonneg (α := ℝ) m) 4]
+  have hc : A*(2*Real.exp (-(m : ℝ)^4/2048)) ≤ 2*Real.exp (-(m : ℝ)) := by
+    calc
+      _ ≤ Real.exp (6*(m : ℝ)^2)*(2*Real.exp (-(m : ℝ)^4/2048)) := by gcongr
+      _ = 2*Real.exp (6*(m : ℝ)^2-(m : ℝ)^4/2048) := by simp only [Real.exp_sub, neg_div, Real.exp_neg]; ring
+      _ ≤ _ := by
+        apply mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr ?_) (by norm_num)
+        have := large_fourier_exponent (m : ℝ) hm'
+        nlinarith [sq_nonneg (m : ℝ)]
+  have hg : A*(2*Real.exp (-(m : ℝ)^3/32)) ≤ 2*Real.exp (-(m : ℝ)) := by
+    calc
+      _ ≤ Real.exp (6*(m : ℝ)^2)*(2*Real.exp (-(m : ℝ)^3/32)) := by gcongr
+      _ = 2*Real.exp (6*(m : ℝ)^2-(m : ℝ)^3/32) := by simp only [Real.exp_sub, neg_div, Real.exp_neg]; ring
+      _ ≤ _ := mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr (large_chart_exponent _ hm')) (by norm_num)
+  have hs := mul_le_mul_of_nonneg_left (add_le_add (add_le_add (le_refl
+    ((m : ℝ)^6*(2*Real.exp (-(m : ℝ)/8)))) hf) hc) (pow_nonneg (Nat.cast_nonneg m) 3)
+  have he := mul_le_mul_of_nonneg_right hpow (Real.exp_pos (-(m : ℝ))).le
+  have hid : (m : ℝ)^3*((m : ℝ)^6*(2*Real.exp (-(m : ℝ)/8))) =
+    2*(m : ℝ)^9*Real.exp (-(m : ℝ)/8) := by ring
+  nlinarith
+
+lemma projection_failure_bound {m : ℕ} (hm : 2 ≤ m) (hlog : 0 ≤ Real.log m) :
+    (m : ℝ)^6*(2*Real.exp (-(10*Real.sqrt (Real.log m))^2/2)) ≤ 1/4 := by
+  have hm' : (2 : ℝ) ≤ m := by exact_mod_cast hm
+  have hm0 : (0 : ℝ) < m := by linarith
+  have hs : -(10*Real.sqrt (Real.log m))^2/2 = -((50 : ℕ) * Real.log m) := by
+    nlinarith [Real.sq_sqrt hlog]
+  rw [hs, Real.exp_neg, Real.exp_nat_mul, Real.exp_log hm0]
+  have hpow : (8 : ℝ) ≤ (m : ℝ)^44 := by
+    have hh : (2 : ℝ)^44 ≤ (m : ℝ)^44 := pow_le_pow_left₀ (by norm_num) hm' _
+    norm_num at hh ⊢ ; linarith
+  have hid : (m : ℝ)^6*(2*((m : ℝ)^50)⁻¹) = 2/(m : ℝ)^44 := by
+    field_simp
+  rw [hid]
+  apply (div_le_iff₀ (pow_pos hm0 _)).mpr
+  linarith
+
+lemma eventual_bias_bound : ∀ᶠ m : ℕ in atTop,
+    0 < m ∧ 16*Real.exp (-(m : ℝ)/12) ≤ 1/(8*(m : ℝ)) := by
+  have ht := (polynomial_exp_tendsto_zero 1 (c := 1/12) (by norm_num)).const_mul 128
+  have hsmall : ∀ᶠ m : ℕ in atTop,
+      128*((m : ℝ)*Real.exp (-(m : ℝ)/12)) < 1 := by
+    simpa only [pow_one, mul_zero, neg_mul, one_div_mul_eq_div, neg_div] using
+      ht.eventually (gt_mem_nhds (by norm_num : (128 : ℝ)*0 < 1))
+  filter_upwards [hsmall, eventually_ge_atTop 1] with m hs hm
+  have hm' : (0 : ℝ) < m := by exact_mod_cast (show 0 < m by omega)
+  refine ⟨by omega, (le_div_iff₀ (by positivity : (0 : ℝ) < 8*(m : ℝ))).mpr ?_⟩
+  nlinarith
+
+lemma scalar_net_error {m : ℕ} (hm : 1000 ≤ m)
+    (hb : 16*Real.exp (-(m : ℝ)/12) ≤ 1/(8*(m : ℝ))) :
+    (1/(2*Real.sqrt m) + 16*Real.exp (-(m : ℝ)/12))/(1-1/(m : ℝ)^3) +
+      (5*(m : ℝ))*(1/(m : ℝ)^3) ≤ 2/Real.sqrt m := by
+  have hx : (1000 : ℝ) ≤ m := by exact_mod_cast hm
+  have hx0 : (0 : ℝ) < m := by linarith
+  have ht : 0 < Real.sqrt m := Real.sqrt_pos.mpr hx0
+  have ht2 := Real.sq_sqrt hx0.le
+  have htm : Real.sqrt m ≤ (m : ℝ) := by nlinarith
+  have hp3 : (8 : ℝ) ≤ (m : ℝ)^3 := by nlinarith [pow_le_pow_left₀ (by norm_num : (0 : ℝ) ≤ 2) (show (2 : ℝ) ≤ m by linarith) 3]
+  have hr : 1/(m : ℝ)^3 ≤ 1/8 := (div_le_div_iff₀ (by positivity) (by norm_num)).mpr (by linarith)
+  have hd : (7/8 : ℝ) ≤ 1-1/(m : ℝ)^3 := by linarith
+  have hsmall : 1/(8*(m : ℝ)) ≤ 1/(8*Real.sqrt m) :=
+    one_div_le_one_div_of_le (by positivity) (by linarith)
+  have hbs : 1/(2*Real.sqrt m) + 16*Real.exp (-(m : ℝ)/12) ≤ (5/8)/Real.sqrt m := by
+    have he : 1/(2*Real.sqrt m) + 1/(8*Real.sqrt m) = (5/8)/Real.sqrt m := by ring
+    linarith
+  have hfirst : (1/(2*Real.sqrt m) + 16*Real.exp (-(m : ℝ)/12))/(1-1/(m : ℝ)^3) ≤
+      (5/7)/Real.sqrt m := by
+    calc
+      _ ≤ ((5/8)/Real.sqrt m)/(7/8) := div_le_div₀ (by positivity) hbs (by norm_num) hd
+      _ = _ := by ring
+  have hlast : (5*(m : ℝ))*(1/(m : ℝ)^3) ≤ 1/Real.sqrt m := by
+    rw [show (5*(m : ℝ))*(1/(m : ℝ)^3) = 5/(m : ℝ)^2 by field_simp ]
+    apply (div_le_div_iff₀ (by positivity) ht).mpr
+    nlinarith
+  have hrest : (5/7)/Real.sqrt m + 1/Real.sqrt m ≤ 2/Real.sqrt m := by
+    rw [← add_div]
+    exact div_le_div_of_nonneg_right (by norm_num) ht.le
+  linarith
+
+lemma covariance_net_error {m : ℕ} (hm : 1000 ≤ m)
+    (hb : 16*Real.exp (-(m : ℝ)/12) ≤ 1/(8*(m : ℝ))) :
+    1/8 + 16*Real.exp (-(m : ℝ)/12) + 8*(m : ℝ)*(1/(m : ℝ)^3) ≤ 1/2 := by
+  have hx : (1000 : ℝ) ≤ m := by exact_mod_cast hm
+  have hx0 : (0 : ℝ) < m := by linarith
+  have hsm : 1/(8*(m : ℝ)) ≤ 1/8 := one_div_le_one_div_of_le (by norm_num) (by linarith)
+  have hh : 8*(m : ℝ)*(1/(m : ℝ)^3) ≤ 1/4 := by
+    rw [show 8*(m : ℝ)*(1/(m : ℝ)^3) = 8/(m : ℝ)^2 by field_simp ]
+    apply (div_le_iff₀ (by positivity)).mpr
+    nlinarith
+  linarith
+
+lemma projection_net_error {m : ℕ} (hm : 1000 ≤ m) (hl : 1 ≤ Real.log m) :
+    10*Real.sqrt (Real.log m) + 2*Real.sqrt m*(1/(m : ℝ)^3) ≤
+      11*Real.sqrt (Real.log m) := by
+  have hx : (1000 : ℝ) ≤ m := by exact_mod_cast hm
+  have hx0 : (0 : ℝ) < m := by linarith
+  have ht := Real.sq_sqrt hx0.le
+  have htm : Real.sqrt m ≤ (m : ℝ) := by nlinarith [Real.sqrt_nonneg (m : ℝ)]
+  have hs : 1 ≤ Real.sqrt (Real.log m) := by
+    nlinarith [Real.sq_sqrt (show 0 ≤ Real.log m by linarith), Real.sqrt_nonneg (Real.log m)]
+  have hg : 2*Real.sqrt m*(1/(m : ℝ)^3) ≤ 1 := by
+    rw [mul_one_div]
+    apply (div_le_iff₀ (by positivity)).mpr
+    have hp : (m : ℝ)^2 ≤ (m : ℝ)^3 := by
+      nlinarith [mul_le_mul_of_nonneg_right (show (1 : ℝ) ≤ m by linarith) (sq_nonneg (m : ℝ))]
+    nlinarith
+  linarith
+
+end UniformSparsestCut.DirectionAsymptotics
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/DirectionFamily.lean

@@ -0,0 +1,201 @@
+import OAI.Combinatorics.SparsestCut.DirectionAsymptotics
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.DirectionFamily
+open Directions DirectionInterpolation DirectionAsymptotics GaussianTools FiniteNets
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped BigOperators Topology
+
+variable {m N S : ℕ}
+local notation "E" => EuclideanSpace ℝ (Fin m)
+
+lemma normBounds_of_not_bad {g : Fin N → E} (hg : g ∉ normBad) (i : Fin N) :
+    (m : ℝ)/4 ≤ ‖g i‖^2 ∧ ‖g i‖^2 ≤ 4*(m : ℝ) := by
+  constructor
+  · by_contra h; exact hg ⟨i, Or.inl (lt_of_not_ge h)⟩
+  · by_contra h; exact hg ⟨i, Or.inr (lt_of_not_ge h)⟩
+
+lemma inner_empiricalSin (g : Fin N → E) (v w : E) :
+    inner ℝ (empiricalSin g w - Real.exp (-‖w‖^2/2) • w) v =
+      (∑ i, inner ℝ (g i) v * Real.sin (inner ℝ (g i) w))/(N : ℝ) -
+      inner ℝ w v * Real.exp (-‖w‖^2/2) := by
+  simp only [empiricalSin, inner_sub_left, inner_smul_left, conj_trivial,
+    sum_inner, div_eq_mul_inv]
+  congr 1
+  · rw [Finset.mul_sum, Finset.sum_mul]
+    apply Finset.sum_congr rfl
+    intro i _
+    ring
+  · ring
+
+lemma net_fourier_scalar (hm : 0 < m) {g : Fin N → E} (hg : g ∉ normBad)
+    {u : ℝ} (v w : E) (hv : ‖v‖ = 1) (hf : g ∉ fourierBad u v w) :
+    |inner ℝ (empiricalSin g w - Real.exp (-‖w‖^2/2) • w) v| ≤
+      u + 16*Real.exp (-(m : ℝ)/12) := by
+  have hsample (i : Fin N) : fourierSummand v w (g i) =
+      inner ℝ (g i) v * Real.sin (inner ℝ (g i) w) := by
+    dsimp only [fourierSummand, covarianceSummand, truncate]
+    exact Set.indicator_of_mem (show g i ∈ {z : E | ‖z‖^2 ≤ 4*(m : ℝ)} from
+      (normBounds_of_not_bad hg i).2) _
+  have hdev : |(∑ i, fourierSummand v w (g i))/(N : ℝ) -
+      ∫ z, fourierSummand v w z ∂stdGaussian E| ≤ u := le_of_not_gt hf
+  simp_rw [hsample] at hdev
+  rw [inner_empiricalSin]
+  have hb := truncation_fourier_bias (show 1 ≤ m by omega) v w hv
+  exact (abs_sub_le _ (∫ z, fourierSummand v w z ∂stdGaussian E) _).trans (add_le_add hdev hb)
+
+lemma net_covariance_scalar {g : Fin N → E} (hg : g ∉ normBad)
+    (v : E) (hv : ‖v‖ = 1) (hf : g ∉ covarianceBad v) :
+    |empiricalCov g v - 1| ≤ 1/8 + 16*Real.exp (-(m : ℝ)/12) := by
+  have hsample (i : Fin N) : covarianceSummand v (g i) = (inner ℝ v (g i))^2 := by
+    dsimp only [fourierSummand, covarianceSummand, truncate]
+    exact Set.indicator_of_mem (show g i ∈ {z : E | ‖z‖^2 ≤ 4*(m : ℝ)} from
+      (normBounds_of_not_bad hg i).2) _
+  have hdev : |(∑ i, covarianceSummand v (g i))/(N : ℝ) -
+      ∫ z, covarianceSummand v z ∂stdGaussian E| ≤ 1/8 := le_of_not_gt hf
+  simp_rw [hsample] at hdev
+  exact (abs_sub_le _ (∫ z, covarianceSummand v z ∂stdGaussian E) _).trans
+    (add_le_add hdev (truncation_covariance_bias v hv))
+
+lemma source_nets (hm : 2 ≤ m) : ∃ V W : Finset E,
+    (∀ v ∈ V, ‖v‖ = 1) ∧
+    (V.card : ℝ) ≤ Real.exp (6*(m : ℝ)^2) ∧
+    (W.card : ℝ) ≤ Real.exp (48*(m : ℝ)^2) ∧
+    (∀ v : E, ‖v‖ = 1 → ∃ v' ∈ V, ‖v-v'‖ ≤ 1/(m : ℝ)^3) ∧
+    (∀ w : E, ‖w‖ ≤ (m : ℝ)^42 → ∃ w' ∈ W, ‖w-w'‖ ≤ 1/(m : ℝ)^3) := by
+  have hm0 : (0 : ℝ) < m := by exact_mod_cast (show 0 < m by omega)
+  have hδ : (0 : ℝ) < 1/(m : ℝ)^4 := by positivity
+  have hid : (m : ℝ) * (1/(m : ℝ)^4) = 1/(m : ℝ)^3 := by field_simp
+  obtain ⟨V,hV,hVc,hVnet⟩ := exists_coordinate_net (K := m^4) hδ {v : E | ‖v‖ = 1} (by
+    intro v hv
+    change ‖v‖ = 1 at hv
+    rw [hv, Nat.cast_pow]
+    simp [hm0.ne'])
+  obtain ⟨W,hW,hWc,hWnet⟩ := exists_coordinate_net (K := m^46) hδ {w : E | ‖w‖ ≤ (m : ℝ)^42} (by
+    intro w hw
+    change ‖w‖ ≤ (m : ℝ)^42 at hw
+    have he : (((m^46 : ℕ) : ℝ))*(1/(m : ℝ)^4) = (m : ℝ)^42 := by push_cast; field_simp
+    rwa [he])
+  refine ⟨V,W,hV,?_,?_,?_,?_⟩
+  · exact (Nat.cast_le.mpr hVc).trans (by simpa only [Nat.cast_pow, Nat.cast_add, Nat.cast_mul, Nat.cast_ofNat, show (4+2 : ℝ) = 6 by norm_num] using grid_card_bound m 4 hm)
+  · exact (Nat.cast_le.mpr hWc).trans (by simpa only [Nat.cast_pow, Nat.cast_add, Nat.cast_mul, Nat.cast_ofNat, show (46+2 : ℝ) = 48 by norm_num] using grid_card_bound m 46 hm)
+  · intro v hv; simpa only [hid] using hVnet v hv
+  · intro w hw; simpa only [hid] using hWnet w hw
+
+lemma select_source_nets (hm : 1000000 ≤ m) (hlog : 1 ≤ Real.log m)
+    (hmajor : 2*(m : ℝ)^9*Real.exp (-(m : ℝ)/8) +
+      6*(m : ℝ)^3*Real.exp (-(m : ℝ)) < 1)
+    (V W : Finset E) (hV : ∀ v ∈ V, ‖v‖ = 1)
+    (hVc : (V.card : ℝ) ≤ Real.exp (6*(m : ℝ)^2))
+    (hWc : (W.card : ℝ) ≤ Real.exp (48*(m : ℝ)^2)) :
+    ∃ g : Fin (m^3) → Fin (m^6) → E,
+      (∀ s a b, a ≠ b → ∀ t : ℝ, g s a ≠ t • g s b) ∧
+      (��� s, g s ∉ normBad) ∧
+      (∀ s, ∀ v ∈ V, ∀ w ∈ W, g s ∉ fourierBad (1/(2*Real.sqrt m)) v w) ∧
+      (∀ s, ∀ v ∈ V, g s ∉ covarianceBad v) ∧
+      (∀ v ∈ V, (badCount (projectionBad (10*Real.sqrt (Real.log m)) v) g : ℝ) ≤
+        ((m^3 : ℕ) : ℝ)/2) := by
+  have hm0 : 0 < m := by omega
+  apply select_on_nets hm0 (pow_pos hm0 _) (pow_pos hm0 _) V W hV
+    (by positivity) (by positivity)
+  · simpa only [Nat.cast_pow] using projection_failure_bound (show 2 ≤ m by omega)
+      (show 0 ≤ Real.log m by linarith)
+  · exact GaussianNonparallel.charts_pairwise_nonparallel (show 2 ≤ m by omega)
+  · simp only [Nat.cast_pow]
+    rw [normalized_fourier_exponent hm0, normalized_covariance_exponent m hm0]
+    exact (probability_majorization hm (Nat.cast_nonneg _) (Nat.cast_nonneg _) hVc hWc).trans_lt hmajor
+
+lemma badCount_le_of_imp {A B : Set (Fin N → E)} (g : Fin S → Fin N → E)
+    (h : ∀ s, g s ∈ A → g s ∈ B) : badCount A g ≤ badCount B g := by
+  classical
+  apply Finset.card_le_card
+  intro s hs
+  simp only [Finset.mem_filter, Finset.mem_univ, true_and] at hs ⊢
+  exact h s hs
+
+lemma good_chart_interpolation {N S : ℕ} (g : Fin S → Fin N → E)
+    (hg : ∀ s, g s ∉ normBad) {v v' : E} {ρ q q' : ℝ}
+    (hd : ‖v-v'‖ ≤ ρ) (hq : q+2*Real.sqrt m*ρ ≤ q') :
+    badCount (projectionBad q' v) g ≤ badCount (projectionBad q v') g := by
+  apply badCount_le_of_imp g
+  intro s hs
+  by_contra hn
+  obtain ⟨i,hi⟩ := hs
+  have hp : |inner ℝ v' (g s i)| ≤ q := by
+    by_contra h; exact hn ⟨i,lt_of_not_ge h⟩
+  have hgn : ‖g s i‖ ≤ 2*Real.sqrt m := by
+    have := (normBounds_of_not_bad (hg s) i).2
+    nlinarith [Real.sq_sqrt (Nat.cast_nonneg (α := ℝ) m), Real.sqrt_nonneg (m : ℝ), norm_nonneg (g s i)]
+  have hh := (projection_interpolate hgn (by positivity) hd hp).trans hq
+  exact not_lt_of_ge hh hi
+
+structure Family (m : ℕ) where
+  g : Fin (m^3) → Fin (m^6) → EuclideanSpace ℝ (Fin m)
+  norms : ∀ s i, Real.sqrt m/2 ≤ ‖g s i‖ ∧ ‖g s i‖ ≤ 2*Real.sqrt m
+  nonparallel : ∀ s a b, a ≠ b → ∀ t : ℝ, g s a ≠ t • g s b
+  covariance : ∀ s v, ‖v‖ = 1 → 1/2 ≤ empiricalCov (g s) v ∧ empiricalCov (g s) v ≤ 2
+  fourier : ∀ s w, ‖w‖ ≤ (m : ℝ)^42 →
+    ‖empiricalSin (g s) w - Real.exp (-‖w‖^2/2) • w‖ ≤ 2/Real.sqrt m
+  good : ∀ v, ‖v‖ = 1 →
+    (badCount (projectionBad (11*Real.sqrt (Real.log m)) v) g : ℝ) ≤ ((m^3 : ℕ) : ℝ)/2
+
+lemma family_at_large (hm : 1000000 ≤ m) (hlog : 1 ≤ Real.log m)
+    (hbias : 16*Real.exp (-(m : ℝ)/12) ≤ 1/(8*(m : ℝ)))
+    (hmajor : 2*(m : ℝ)^9*Real.exp (-(m : ℝ)/8) +
+      6*(m : ℝ)^3*Real.exp (-(m : ℝ)) < 1) : Nonempty (Family m) := by
+  classical
+  obtain ⟨V,W,hV,hVc,hWc,hVnet,hWnet⟩ := source_nets (show 2 ≤ m by omega)
+  obtain ⟨g,hpar,hg,hfour,hcov,hgood⟩ := select_source_nets hm hlog hmajor V W hV hVc hWc
+  have hm0 : 0 < m := by omega
+  have hm0' : (0 : ℝ) < m := by exact_mod_cast hm0
+  have hn : 0 < m^6 := pow_pos hm0 _
+  have hu (s : Fin (m^3)) (i : Fin (m^6)) : ‖g s i‖^2 ≤ 4*(m : ℝ) :=
+    (normBounds_of_not_bad (hg s) i).2
+  refine ⟨{ g := g, norms := ?_, nonparallel := hpar, covariance := ?_, fourier := ?_, good := ?_ }⟩
+  · intro s i
+    have h := normBounds_of_not_bad (hg s) i
+    have hs := Real.sq_sqrt hm0'.le
+    constructor <;> nlinarith [Real.sqrt_nonneg (m : ℝ), norm_nonneg (g s i)]
+  · intro s v hv
+    have hh := covariance_net_bound hn (g s) (hu s) (by positivity) V hV hVnet
+      (fun v hv => net_covariance_scalar (hg s) v (hV v hv) (hcov s v hv)) v hv
+    have herr := covariance_net_error (show 1000 ≤ m by omega) hbias
+    have heq : 2*(4*(m : ℝ))*(1/(m : ℝ)^3) = 8*(m : ℝ)*(1/(m : ℝ)^3) := by ring
+    rw [heq] at hh
+    have hab := abs_le.mp (hh.trans herr)
+    constructor <;> linarith
+  · intro s w hw
+    have hρ : 1/(m : ℝ)^3 < 1 := by
+      apply (div_lt_one (by positivity)).mpr
+      have hx : (2 : ℝ) ≤ m := by exact_mod_cast (show 2 ≤ m by omega)
+      have hh := pow_le_pow_left₀ (by norm_num : (0 : ℝ) ≤ 2) hx 3
+      norm_num at hh; linarith
+    have hh := fourier_net_bound hn (g s) (hu s) (by positivity) (by positivity) hρ V W
+      hVnet hWnet (fun v hv w hw => net_fourier_scalar hm0 (hg s) v w (hV v hv) (hfour s v hv w hw)) w hw
+    have herr := scalar_net_error (show 1000 ≤ m by omega) hbias
+    have heq : 4*(m : ℝ)+(m : ℝ) = 5*(m : ℝ) := by ring
+    rw [heq] at hh
+    exact hh.trans herr
+  · intro v hv
+    obtain ⟨v',hv',hd⟩ := hVnet v hv
+    have hh := good_chart_interpolation g hg hd (projection_net_error (show 1000 ≤ m by omega) hlog)
+    exact (Nat.cast_le.mpr hh).trans (hgood v' hv')
+
+theorem directions_exist : ∀ᶠ m : ℕ in atTop, Nonempty (Family m) := by
+  have hlog : ∀ᶠ m : ℕ in atTop, 1 ≤ Real.log m :=
+    (Real.tendsto_log_atTop.comp tendsto_natCast_atTop_atTop).eventually (eventually_ge_atTop 1)
+  filter_upwards [eventually_ge_atTop 1000000, hlog, eventual_bias_bound,
+    eventual_selection_majorant] with m hm hl hb hp
+  exact family_at_large hm hl hb.2 hp
+
+end UniformSparsestCut.DirectionFamily
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/DirectionInterpolation.lean

@@ -0,0 +1,152 @@
+import OAI.Combinatorics.SparsestCut.GaussianNonparallel
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.DirectionInterpolation
+open GaussianTools FiniteNets MeasureTheory ProbabilityTheory
+open scoped BigOperators Topology
+
+variable {m N : ℕ}
+local notation "E" => EuclideanSpace ℝ (Fin m)
+noncomputable def empiricalSin (g : Fin N → E) (w : E) : E :=
+  (N : ℝ)⁻¹ • ∑ i, Real.sin (inner ℝ (g i) w) • g i
+noncomputable def empiricalCov (g : Fin N → E) (v : E) : ℝ :=
+  (∑ i, (inner ℝ v (g i))^2)/(N : ℝ)
+
+lemma sin_vector_lipschitz (g w w' : E) :
+    ‖Real.sin (inner ℝ g w) • g - Real.sin (inner ℝ g w') • g‖ ≤
+      ‖g‖^2 * ‖w-w'‖ := by
+  rw [← sub_smul, norm_smul, Real.norm_eq_abs]
+  have hs : |Real.sin (inner ℝ g w) - Real.sin (inner ℝ g w')| ≤
+      |inner ℝ g (w-w')| := by
+    simpa only [Real.dist_eq, dist_eq_norm, Real.norm_eq_abs, inner_sub_right, NNReal.coe_one, one_mul] using
+      Real.lipschitzWith_sin.dist_le_mul (inner ℝ g w) (inner ℝ g w')
+  calc
+    _ ≤ |inner ℝ g (w-w')| * ‖g‖ := mul_le_mul_of_nonneg_right hs (norm_nonneg _)
+    _ ≤ (‖g‖*‖w-w'‖)*‖g‖ := mul_le_mul_of_nonneg_right (abs_real_inner_le_norm _ _) (norm_nonneg _)
+    _ = _ := by ring
+
+lemma empiricalSin_lipschitz (hN : 0 < N) (g : Fin N → E) {B : ℝ}
+    (hB : ∀ i, ‖g i‖^2 ≤ B) (w w' : E) :
+    ‖empiricalSin g w - empiricalSin g w'‖ ≤ B*‖w-w'‖ := by
+  have hn : (0 : ℝ) < N := by exact_mod_cast hN
+  rw [empiricalSin, empiricalSin, ← smul_sub, ← Finset.sum_sub_distrib, norm_smul,
+    Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hn)]
+  calc
+    _ ≤ (N : ℝ)⁻¹ * ∑ i, ‖Real.sin (inner ℝ (g i) w) • g i -
+        Real.sin (inner ℝ (g i) w') • g i‖ :=
+      mul_le_mul_of_nonneg_left (norm_sum_le _ _) (inv_nonneg.mpr hn.le)
+    _ ≤ (N : ℝ)⁻¹ * ∑ _ : Fin N, B * ‖w-w'‖ := by
+      gcongr with i
+      exact (sin_vector_lipschitz _ _ _).trans (mul_le_mul_of_nonneg_right (hB i) (norm_nonneg _))
+    _ = _ := by simp [hn.ne']
+
+lemma gaussian_norm_sq_mean : (∫ g : E, ‖g‖^2 ∂stdGaussian E) = m := by
+  have hid (g : E) : ‖g‖^2 = ∑ i : Fin m, (inner ℝ (EuclideanSpace.single i 1) g)^2 := by
+    simp only [EuclideanSpace.norm_sq_eq, EuclideanSpace.inner_single_left, conj_trivial, one_mul,
+      Real.norm_eq_abs, sq_abs]
+  simp_rw [hid]
+  rw [integral_finsetSum _ (fun i _ => inner_sq_integrable _)]
+  simp_rw [gaussian_inner_sq]
+  simp
+
+lemma gaussianTransform_lipschitz (w w' : E) :
+    ‖Real.exp (-‖w‖^2/2) • w - Real.exp (-‖w'‖^2/2) • w'‖ ≤ (m : ℝ)*‖w-w'‖ := by
+  rw [← gaussian_vector_sin w, ← gaussian_vector_sin w',
+    ← integral_sub (gaussian_vector_sin_integrable w) (gaussian_vector_sin_integrable w')]
+  calc
+    _ ≤ ∫ g : E, ‖Real.sin (inner ℝ g w) • g - Real.sin (inner ℝ g w') • g‖ ∂stdGaussian E :=
+      norm_integral_le_integral_norm _
+    _ ≤ ∫ g : E, ‖g‖^2 * ‖w-w'‖ ∂stdGaussian E := by
+      apply integral_mono ((gaussian_vector_sin_integrable w).sub (gaussian_vector_sin_integrable w')).norm
+        (gaussian_norm_sq_integrable.mul_const ‖w-w'‖)
+      exact fun g => sin_vector_lipschitz g w w'
+    _ = _ := by rw [integral_mul_const, gaussian_norm_sq_mean]
+
+lemma covariance_lipschitz (hN : 0 < N) (g : Fin N → E) {B : ℝ}
+    (hg : ∀ i, ‖g i‖^2 ≤ B) {v v' : E} (hv : ‖v‖ = 1) (hv' : ‖v'‖ = 1) :
+    |empiricalCov g v - empiricalCov g v'| ≤ 2*B*‖v-v'‖ := by
+  have hn : (0 : ℝ) < N := by exact_mod_cast hN
+  have hterm (i : Fin N) : |(inner ℝ v (g i))^2 - (inner ℝ v' (g i))^2| ≤
+      2*B*‖v-v'‖ := by
+    rw [sq_sub_sq, abs_mul, mul_comm]
+    have ha : |inner ℝ v (g i)| ≤ ‖g i‖ := by simpa [hv] using abs_real_inner_le_norm v (g i)
+    have hb : |inner ℝ v' (g i)| ≤ ‖g i‖ := by simpa [hv'] using abs_real_inner_le_norm v' (g i)
+    have hd : |inner ℝ v (g i) - inner ℝ v' (g i)| ≤ ‖v-v'‖*‖g i‖ := by
+      simpa only [inner_sub_left] using abs_real_inner_le_norm (v-v') (g i)
+    calc
+      _ ≤ (‖v-v'‖*‖g i‖)*(2*‖g i‖) :=
+        mul_le_mul hd ((abs_add_le _ _).trans (by linarith)) (abs_nonneg _) (by positivity)
+      _ = 2*‖g i‖^2*‖v-v'‖ := by ring
+      _ ≤ 2*B*‖v-v'‖ := by gcongr; exact hg i
+  rw [empiricalCov, empiricalCov, ← sub_div, abs_div, abs_of_pos hn, ← Finset.sum_sub_distrib]
+  apply (div_le_iff₀ hn).mpr
+  calc
+    _ ≤ ∑ i : Fin N, |(inner ℝ v (g i))^2 - (inner ℝ v' (g i))^2| := Finset.abs_sum_le_sum_abs _ _
+    _ ≤ ∑ _ : Fin N, 2*B*‖v-v'‖ := Finset.sum_le_sum (fun i _ => hterm i)
+    _ = _ := by simp [mul_comm]
+
+lemma covariance_net_bound (hN : 0 < N) (g : Fin N → E) {B b ρ : ℝ}
+    (hg : ∀ i, ‖g i‖^2 ≤ B) (hB : 0 ≤ B) (V : Finset E)
+    (hV : ∀ v ∈ V, ‖v‖ = 1)
+    (hnet : ∀ x : E, ‖x‖ = 1 → ∃ v ∈ V, ‖x-v‖ ≤ ρ)
+    (hdev : ∀ v ∈ V, |empiricalCov g v - 1| ≤ b)
+    (x : E) (hx : ‖x‖ = 1) : |empiricalCov g x - 1| ≤ b + 2*B*ρ := by
+  obtain ⟨v,hv,hd⟩ := hnet x hx
+  calc
+    _ ≤ |empiricalCov g x - empiricalCov g v| + |empiricalCov g v - 1| := abs_sub_le _ _ _
+    _ ≤ 2*B*‖x-v‖ + b := add_le_add (covariance_lipschitz hN g hg hx (hV v hv)) (hdev v hv)
+    _ ≤ b + 2*B*ρ := by nlinarith
+
+lemma fourier_net_bound (hN : 0 < N) (g : Fin N → E) {B b ρ δ R : ℝ}
+    (hg : ∀ i, ‖g i‖^2 ≤ B) (hB : 0 ≤ B) (hb : 0 ≤ b) (hρ : ρ < 1)
+    (V W : Finset E)
+    (hV : ∀ x : E, ‖x‖ = 1 → ∃ v ∈ V, ‖x-v‖ ≤ ρ)
+    (hW : ∀ w : E, ‖w‖ ≤ R → ∃ w' ∈ W, ‖w-w'‖ ≤ δ)
+    (hdev : ∀ v ∈ V, ∀ w ∈ W,
+      |inner ℝ (empiricalSin g w - Real.exp (-‖w‖^2/2) • w) v| ≤ b)
+    (w : E) (hw : ‖w‖ ≤ R) :
+    ‖empiricalSin g w - Real.exp (-‖w‖^2/2) • w‖ ≤ b/(1-ρ) + (B+(m : ℝ))*δ := by
+  obtain ⟨w',hw',hd⟩ := hW w hw
+  have hn : ‖empiricalSin g w' - Real.exp (-‖w'‖^2/2) • w'‖ ≤ b/(1-ρ) := by
+    apply (le_div_iff₀ (by linarith : 0 < 1-ρ)).mpr
+    nlinarith [sphere_net_norm_bound hV (fun v hv => hdev v hv w' hw') hb]
+  calc
+    _ ≤ ‖empiricalSin g w - empiricalSin g w'‖ +
+        ‖empiricalSin g w' - Real.exp (-‖w'‖^2/2) • w'‖ +
+        ‖Real.exp (-‖w'‖^2/2) • w' - Real.exp (-‖w‖^2/2) • w‖ :=
+      by
+        have hid : empiricalSin g w - Real.exp (-‖w‖^2/2) • w =
+            (empiricalSin g w - empiricalSin g w') +
+            (empiricalSin g w' - Real.exp (-‖w'‖^2/2) • w') +
+            (Real.exp (-‖w'‖^2/2) • w' - Real.exp (-‖w‖^2/2) • w) := by abel
+        rw [hid]
+        exact (norm_add_le _ _).trans (add_le_add (norm_add_le _ _) (le_refl _))
+    _ ≤ B*‖w-w'‖ + b/(1-ρ) + (m : ℝ)*‖w-w'‖ := by
+      apply add_le_add (add_le_add (empiricalSin_lipschitz hN g hg w w') hn)
+      simpa only [norm_sub_rev] using gaussianTransform_lipschitz w' w
+    _ ≤ b/(1-ρ) + (B+(m : ℝ))*δ := by
+      have hm : (0 : ℝ) ≤ m := Nat.cast_nonneg m
+      nlinarith
+
+lemma projection_interpolate {g v v' : E} {q K ρ : ℝ}
+    (hg : ‖g‖ ≤ K) (_hK : 0 ≤ K) (hd : ‖v-v'‖ ≤ ρ)
+    (hp : |inner ℝ v' g| ≤ q) : |inner ℝ v g| ≤ q + K*ρ := by
+  have hi : inner ℝ v g = inner ℝ v' g + inner ℝ (v-v') g := by rw [inner_sub_left]; ring
+  calc
+    _ ≤ |inner ℝ v' g| + |inner ℝ (v-v') g| := by rw [hi]; exact abs_add_le _ _
+    _ ≤ q + ‖v-v'‖*‖g‖ := add_le_add hp (abs_real_inner_le_norm _ _)
+    _ ≤ q + K*ρ := by
+      have hρ : 0 ≤ ρ := (norm_nonneg _).trans hd
+      nlinarith [mul_le_mul hd hg (norm_nonneg _) hρ]
+
+end UniformSparsestCut.DirectionInterpolation
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/Directions.lean

@@ -0,0 +1,291 @@
+import OAI.Combinatorics.SparsestCut.FiniteNets
+
+namespace OAI
+
+universe u1 u2 u3 u4 u5
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.Directions
+open GaussianTools FiniteNets MeasureTheory ProbabilityTheory Set Filter
+open scoped BigOperators NNReal Topology
+
+section ProductMeasures
+variable {E : Type u1} [MeasurableSpace E] {μ : Measure E} [IsProbabilityMeasure μ]
+
+lemma integral_eval {n : ℕ} {f : E → ℝ} (hf : Measurable f) (i : Fin n) :
+    (∫ x : Fin n → E, f (x i) ∂Measure.pi (fun _ => μ)) = ∫ x, f x ∂μ := by
+  have hp := measurePreserving_eval (fun _ : Fin n => μ) i
+  have hh := integral_map hp.aemeasurable (hf.aestronglyMeasurable :
+    AEStronglyMeasurable f ((Measure.pi (fun _ : Fin n => μ)).map (Function.eval i)))
+  rw [hp.map_eq] at hh
+  exact hh.symm
+
+lemma real_measure_eval {n : ℕ} {A : Set E} (hA : MeasurableSet A) (i : Fin n) :
+    (Measure.pi (fun _ : Fin n => μ)).real {x | x i ∈ A} = μ.real A := by
+  have hp := (measurePreserving_eval (fun _ : Fin n => μ) i).measure_preimage hA.nullMeasurableSet
+  exact congrArg ENNReal.toReal hp
+
+lemma iid_bounded_concentration {n : ℕ} (hn : 0 < n) {f : E → ℝ}
+    (hf : Measurable f) {B : ℝ} (hB : 0 < B) (hfB : ∀ x, |f x| ≤ B)
+    {u : ℝ} (hu : 0 ≤ u) :
+    (Measure.pi (fun _ : Fin n => μ)).real
+      {x | u < |(∑ i, f (x i)) / (n : ℝ) - ∫ z, f z ∂μ|} ≤
+      2 * Real.exp (-(n : ℝ)*u^2/(2*B^2)) := by
+  have h := bounded_concentration hn (fun i (x : Fin n → E) => f (x i))
+    (fun i => (hf.comp (measurable_pi_apply i)).aemeasurable)
+    (iIndepFun_pi (μ := fun _ : Fin n => μ) (fun _ => hf.aemeasurable)) hB
+    (fun i => ae_of_all _ (fun x => hfB (x i))) hu
+  have hn0 : (n : ℝ) ≠ 0 := by exact_mod_cast hn.ne'
+  have heq (x : Fin n → E) :
+      (∑ i, (f (x i) - ∫ z : Fin n → E, f (z i) ∂Measure.pi (fun _ => μ))) / (n : ℝ) =
+        (∑ i, f (x i)) / (n : ℝ) - ∫ z, f z ∂μ := by
+    simp_rw [integral_eval hf]
+    rw [Finset.sum_sub_distrib]
+    simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
+    field_simp
+  simpa only [heq] using h
+
+lemma real_measure_exists_le {n : ℕ} (A : Fin n → Set E) (hA : ∀ i, MeasurableSet (A i))
+    {p : ℝ} (hp : ∀ i, μ.real (A i) ≤ p) :
+    (Measure.pi (fun _ : Fin n => μ)).real {x | ∃ i, x i ∈ A i} ≤ (n : ℝ)*p := by
+  calc
+    _ = (Measure.pi (fun _ : Fin n => μ)).real (⋃ i : Fin n, {x | x i ∈ A i}) := by
+      congr 1; ext x; simp
+    _ ≤ ∑ i : Fin n, (Measure.pi (fun _ : Fin n => μ)).real {x | x i ∈ A i} :=
+      measureReal_iUnion_fintype_le _
+    _ = ∑ i : Fin n, μ.real (A i) := by simp_rw [real_measure_eval (hA _)]
+    _ ≤ ∑ _ : Fin n, p := Finset.sum_le_sum (fun i _ => hp i)
+    _ = _ := by simp
+
+noncomputable def badCount {S : ℕ} (A : Set E) (x : Fin S → E) : ℕ := by
+  classical
+  exact (Finset.univ.filter (fun s => x s ∈ A)).card
+
+lemma bad_chart_fraction {S : ℕ} (hS : 0 < S) {A : Set E} (hA : MeasurableSet A)
+    (hp : μ.real A ≤ 1/4) :
+    (Measure.pi (fun _ : Fin S => μ)).real
+      {x | (S : ℝ)/2 < (badCount A x : ℝ)} ≤
+      2 * Real.exp (-(S : ℝ)/32) := by
+  classical
+  let f : E → ℝ := A.indicator (fun _ => 1)
+  have hf : Measurable f := measurable_const.indicator hA
+  have hbound (x : E) : |f x| ≤ 1 := by
+    by_cases hx : x ∈ A <;> simp [f, hx]
+  have hmean : (∫ x, f x ∂μ) = μ.real A := integral_indicator_one hA
+  have h := iid_bounded_concentration (μ := μ) hS hf (by norm_num : (0 : ℝ) < 1) hbound
+    (u := 1/4) (by norm_num)
+  have hcount (x : Fin S → E) : (∑ s : Fin S, f (x s)) =
+      (badCount A x : ℝ) := by
+    dsimp [badCount]
+    simp only [f, Set.indicator]
+    rw [← Finset.sum_filter]
+    simp
+  have hspos : (0 : ℝ) < S := by exact_mod_cast hS
+  have hsub : {x : Fin S → E | (S : ℝ)/2 < (badCount A x : ℝ)} ⊆
+      {x | (1/4 : ℝ) < |(∑ s, f (x s))/(S : ℝ) - ∫ z, f z ∂μ|} := by
+    intro x hx
+    change (S : ℝ)/2 < (badCount A x : ℝ) at hx
+    change (1/4 : ℝ) < |(∑ s, f (x s))/(S : ℝ) - ∫ z, f z ∂μ|
+    rw [hcount, hmean]
+    apply (lt_abs.mpr (Or.inl ?_))
+    have hh : (1/2 : ℝ) < (badCount A x : ℝ)/(S : ℝ) :=
+      (lt_div_iff₀ hspos).mpr (by linarith)
+    linarith
+  calc
+    _ ≤ _ := measureReal_mono hsub
+    _ ≤ 2 * Real.exp (-(S : ℝ) * (1/4)^2 / (2*1^2)) := h
+    _ = _ := by congr 2; ring
+
+lemma exists_outside_of_real_lt_one {Ω : Type u2} [MeasurableSpace Ω]
+    {ν : Measure Ω} [IsProbabilityMeasure ν] {A : Set Ω} (hA : (ν).real A < 1) :
+    ∃ x, x ∉ A := by
+  by_contra h
+  push Not at h
+  have heq : A = Set.univ := Set.eq_univ_of_forall h
+  simp [heq, measureReal_def] at hA
+
+lemma exists_outside_with_ae {Ω : Type u3} [MeasurableSpace Ω]
+    {ν : Measure Ω} [IsProbabilityMeasure ν] {A : Set Ω} (hA : (ν).real A < 1)
+    {P : Ω → Prop} (hP : ∀ᵐ x ∂ν, P x) : ∃ x, x ∉ A ∧ P x := by
+  have hnull : (ν).real {x | ¬ P x} = 0 := by
+    rw [measureReal_def, ae_iff.mp hP, ENNReal.toReal_zero]
+  have hlt : (ν).real (A ∪ {x | ¬ P x}) < 1 :=
+    ((measureReal_union_le _ _).trans_eq (by rw [hnull, add_zero])).trans_lt hA
+  obtain ⟨x,hx⟩ := exists_outside_of_real_lt_one hlt
+  exact ⟨x, fun ha => hx (Or.inl ha), by_contra (fun hn => hx (Or.inr hn))⟩
+
+end ProductMeasures
+
+lemma finite_union_bound {Ω : Type u4} {I : Type u5} [MeasurableSpace Ω] [Fintype I]
+    {ν : Measure Ω} [IsProbabilityMeasure ν] (A : I → Set Ω) {p : ℝ}
+    (hA : ∀ i, (ν).real (A i) ≤ p) :
+    (ν).real {x | ∃ i, x ∈ A i} ≤ (Fintype.card I : ℝ)*p := by
+  calc
+    _ = (ν).real (⋃ i, A i) := by congr 1; ext; simp
+    _ ≤ ∑ i, (ν).real (A i) := measureReal_iUnion_fintype_le _
+    _ ≤ ∑ _ : I, p := Finset.sum_le_sum (fun i _ => hA i)
+    _ = _ := by simp
+
+section GaussianSelection
+variable {m N S : ℕ}
+local notation "E" => EuclideanSpace ℝ (Fin m)
+local notation "μ" => stdGaussian E
+local notation "ν" => Measure.pi (fun _ : Fin N => μ)
+local notation "π" => Measure.pi (fun _ : Fin S => ν)
+
+noncomputable def fourierSummand (v w : E) : E → ℝ :=
+  truncate m (fun g => inner ℝ g v * Real.sin (inner ℝ g w))
+noncomputable def covarianceSummand (v : E) : E → ℝ :=
+  truncate m (fun g => (inner ℝ v g)^2)
+
+def normBad : Set (Fin N → E) :=
+  {x | ∃ i, ‖x i‖^2 < (m : ℝ)/4 ∨ 4*(m : ℝ) < ‖x i‖^2}
+noncomputable def fourierBad (u : ℝ) (v w : E) : Set (Fin N → E) :=
+  {x | u < |(∑ i, fourierSummand v w (x i))/(N : ℝ) - ∫ g, fourierSummand v w g ∂μ|}
+noncomputable def covarianceBad (v : E) : Set (Fin N → E) :=
+  {x | (1/8 : ℝ) < |(∑ i, covarianceSummand v (x i))/(N : ℝ) - ∫ g, covarianceSummand v g ∂μ|}
+def projectionBad (q : ℝ) (v : E) : Set (Fin N → E) :=
+  {x | ∃ i, q < |inner ℝ v (x i)|}
+
+lemma fourierSummand_measurable (v w : E) : Measurable (fourierSummand v w) :=
+  (by fun_prop : Measurable (fun g : E => inner ℝ g v * Real.sin (inner ℝ g w))).indicator
+    measurable_truncation_set
+lemma covarianceSummand_measurable (v : E) : Measurable (covarianceSummand v) :=
+  (by fun_prop : Measurable (fun g : E => (inner ℝ v g)^2)).indicator measurable_truncation_set
+lemma normBad_measurable : MeasurableSet (normBad (m := m) (N := N)) := by
+  unfold normBad; measurability
+lemma fourierBad_measurable (u : ℝ) (v w : E) : MeasurableSet (fourierBad (N := N) u v w) := by
+  unfold fourierBad
+  have hf (i : Fin N) : Measurable (fun x : Fin N → E => fourierSummand v w (x i)) :=
+    (fourierSummand_measurable v w).comp (measurable_pi_apply i)
+  measurability
+lemma covarianceBad_measurable (v : E) : MeasurableSet (covarianceBad (N := N) v) := by
+  unfold covarianceBad
+  have hf (i : Fin N) : Measurable (fun x : Fin N → E => covarianceSummand v (x i)) :=
+    (covarianceSummand_measurable v).comp (measurable_pi_apply i)
+  measurability
+lemma projectionBad_measurable (q : ℝ) (v : E) : MeasurableSet (projectionBad (N := N) q v) := by
+  unfold projectionBad; measurability
+
+lemma normBad_bound : (ν).real (normBad (m := m) (N := N)) ≤
+    (N : ℝ)* (2*Real.exp (-(m : ℝ)/8)) :=
+  real_measure_exists_le (fun _ => {g : E | ‖g‖^2 < (m : ℝ)/4 ∨ 4*(m : ℝ) < ‖g‖^2})
+    (fun _ => by measurability) (fun _ => by
+      have h := (measureReal_union_le
+        {g : E | ‖g‖^2 < (m : ℝ)/4} {g : E | 4*(m : ℝ) < ‖g‖^2}).trans
+        (add_le_add (gaussian_norm_lower (n := m)) (gaussian_norm_upper (n := m)))
+      have he : Real.exp (-(m : ℝ)/2) ≤ Real.exp (-(m : ℝ)/8) :=
+        Real.exp_le_exp.mpr (by have := Nat.cast_nonneg (α := ℝ) m; linarith)
+      exact h.trans (by linarith))
+
+lemma fourierBad_bound (hm : 0 < m) (hN : 0 < N) {u : ℝ} (hu : 0 ≤ u)
+    (v w : E) (hv : ‖v‖ = 1) :
+    (ν).real (fourierBad (N := N) u v w) ≤
+      2*Real.exp (-(N : ℝ)*u^2/(2*(2*Real.sqrt m)^2)) := by
+  exact iid_bounded_concentration hN (fourierSummand_measurable v w)
+    (by positivity) (truncate_fourier_bound v w hv) hu
+lemma covarianceBad_bound (hm : 0 < m) (hN : 0 < N) (v : E) (hv : ‖v‖ = 1) :
+    (ν).real (covarianceBad (N := N) v) ≤
+      2*Real.exp (-(N : ℝ)*(1/8)^2/(2*(4*(m : ℝ))^2)) := by
+  exact iid_bounded_concentration hN (covarianceSummand_measurable v)
+    (by positivity) (truncate_covariance_bound v hv) (by norm_num)
+lemma projectionBad_bound {q : ℝ} (hq : 0 ≤ q) (v : E) (hv : ‖v‖ = 1) :
+    (ν).real (projectionBad (N := N) q v) ≤ (N : ℝ)*(2*Real.exp (-q^2/2)) :=
+  real_measure_exists_le (fun _ => {g : E | q < |inner ℝ v g|})
+    (fun _ => by measurability) (fun _ => gaussian_inner_tail v hv hq)
+
+noncomputable def chartBad (V W : Finset E) (u : ℝ) : Set (Fin N → E) :=
+  normBad ∪ {x | ∃ z : V × W, x ∈ fourierBad u z.1 z.2} ∪
+    {x | ∃ v : V, x ∈ covarianceBad v}
+
+lemma chartBad_measurable (V W : Finset E) (u : ℝ) :
+    MeasurableSet (chartBad (N := N) V W u) := by
+  classical
+  have hFm : MeasurableSet {x : Fin N → E | ∃ z : V × W, x ∈ fourierBad u z.1 z.2} := by
+    rw [show {x : Fin N → E | ∃ z : V × W, x ∈ fourierBad u z.1 z.2} =
+      ⋃ z : V × W, fourierBad (N := N) u z.1 z.2 by ext x; simp]
+    exact MeasurableSet.iUnion (fun z : V × W => fourierBad_measurable (m := m) (N := N) u z.1 z.2)
+  have hCm : MeasurableSet {x : Fin N → E | ∃ v : V, x ∈ covarianceBad v} := by
+    rw [show {x : Fin N → E | ∃ v : V, x ∈ covarianceBad v} =
+      ⋃ v : V, covarianceBad (N := N) v by ext x; simp]
+    exact MeasurableSet.iUnion (fun v : V => covarianceBad_measurable (m := m) (N := N) v)
+  exact (normBad_measurable.union hFm).union hCm
+
+lemma chartBad_bound (hm : 0 < m) (hN : 0 < N) (V W : Finset E)
+    (hV : ∀ v ∈ V, ‖v‖ = 1) {u : ℝ} (hu : 0 ≤ u) :
+    (ν).real (chartBad (N := N) V W u) ≤ (N : ℝ)*(2*Real.exp (-(m : ℝ)/8)) +
+        (V.card : ℝ)*(W.card : ℝ)*(2*Real.exp (-(N : ℝ)*u^2/(2*(2*Real.sqrt m)^2))) +
+        (V.card : ℝ)*(2*Real.exp (-(N : ℝ)*(1/8)^2/(2*(4*(m : ℝ))^2))) := by
+  classical
+  have h1 := finite_union_bound («ν» := ν) (fun z : V × W => fourierBad u z.1 z.2)
+    (fun z => fourierBad_bound hm hN hu z.1 z.2 (hV z.1 z.1.property))
+  have h2 := finite_union_bound («ν» := ν) (fun v : V => covarianceBad v)
+    (fun v => covarianceBad_bound hm hN v (hV v v.property))
+  simp only [Fintype.card_prod, Fintype.card_coe, Nat.cast_mul] at h1 h2
+  exact (measureReal_union_le _ _).trans
+    (add_le_add ((measureReal_union_le _ _).trans (add_le_add normBad_bound h1)) h2)
+
+lemma projection_chart_fraction (hS : 0 < S) (v : E) (hv : ‖v‖ = 1)
+    {q : ℝ} (hq : 0 ≤ q) (hqprob : (N : ℝ)*(2*Real.exp (-q^2/2)) ≤ 1/4) :
+    (π).real {g | (S : ℝ)/2 < (badCount (projectionBad q v) g : ℝ)} ≤
+      2*Real.exp (-(S : ℝ)/32) := by
+  have hmeas : MeasurableSet (projectionBad (N := N) q v) := projectionBad_measurable q v
+  have hbound : (ν).real (projectionBad (N := N) q v) ≤ 1/4 :=
+    (projectionBad_bound hq v hv).trans hqprob
+  exact bad_chart_fraction hS hmeas hbound
+
+lemma goodBad_bound (hS : 0 < S) (V : Finset E) (hV : ∀ v ∈ V, ‖v‖ = 1)
+    {q : ℝ} (hq : 0 ≤ q) (hqprob : (N : ℝ)*(2*Real.exp (-q^2/2)) ≤ 1/4) :
+    (π).real {g | ∃ v : V, (S : ℝ)/2 < (badCount (projectionBad q v) g : ℝ)} ≤
+      (V.card : ℝ)*(2*Real.exp (-(S : ℝ)/32)) := by
+  classical
+  have h := finite_union_bound («ν» := π)
+    (fun v : V => {g | (S : ℝ)/2 < (badCount (projectionBad q v) g : ℝ)})
+    (fun v => projection_chart_fraction hS (v : E) (hV v v.property) hq hqprob)
+  simpa only [Fintype.card_coe, Set.mem_ofPred_eq] using h
+
+theorem select_on_nets (hm : 0 < m) (hN : 0 < N) (hS : 0 < S)
+    (V W : Finset E) (hV : ∀ v ∈ V, ‖v‖ = 1)
+    {u q : ℝ} (hu : 0 ≤ u) (hq : 0 ≤ q)
+    (hqprob : (N : ℝ)*(2*Real.exp (-q^2/2)) ≤ 1/4)
+    {P : (Fin S → Fin N → E) → Prop} (hP : ∀ᵐ g ∂π, P g)
+    (hprob : (S : ℝ) * ((N : ℝ)*(2*Real.exp (-(m : ℝ)/8)) +
+        (V.card : ℝ)*(W.card : ℝ)*(2*Real.exp (-(N : ℝ)*u^2/(2*(2*Real.sqrt m)^2))) +
+        (V.card : ℝ)*(2*Real.exp (-(N : ℝ)*(1/8)^2/(2*(4*(m : ℝ))^2)))) +
+        (V.card : ℝ)*(2*Real.exp (-(S : ℝ)/32)) < 1) :
+    ∃ g : Fin S → Fin N → E, P g ∧
+      (∀ s, g s ∉ normBad) ∧
+      (∀ s, ∀ v ∈ V, ∀ w ∈ W, g s ∉ fourierBad u v w) ∧
+      (∀ s, ∀ v ∈ V, g s ∉ covarianceBad v) ∧
+      (∀ v ∈ V, (badCount (projectionBad q v) g : ℝ) ≤ (S : ℝ)/2) := by
+  classical
+  let A := chartBad (N := N) V W u
+  let B : Set (Fin S → Fin N → E) := {g | ∃ s, g s ∈ A}
+  let C : Set (Fin S → Fin N → E) :=
+    {g | ∃ v : V, (S : ℝ)/2 < (badCount (projectionBad q v) g : ℝ)}
+  have hBbound := real_measure_exists_le (fun _ : Fin S => A)
+    (fun _ => chartBad_measurable V W u) (fun _ => chartBad_bound hm hN V W hV hu)
+  have hCbound := goodBad_bound hS V hV hq hqprob
+  have hBC : (π).real (B ∪ C) < 1 :=
+    ((measureReal_union_le B C).trans (add_le_add hBbound hCbound)).trans_lt hprob
+  obtain ⟨g, hg, hgP⟩ := exists_outside_with_ae hBC hP
+  have hgB : ∀ s, g s ∉ A := by
+    intro s hs; exact hg (Or.inl ⟨s, hs⟩)
+  refine ⟨g, hgP, ?_, ?_, ?_, ?_⟩
+  · intro s hs; exact hgB s (Or.inl (Or.inl hs))
+  · intro s v hv w hw hs; exact hgB s (Or.inl (Or.inr ⟨(⟨v,hv⟩,⟨w,hw⟩), hs⟩))
+  · intro s v hv hs; exact hgB s (Or.inr ⟨⟨v,hv⟩, hs⟩)
+  · intro v hv; by_contra h
+    exact hg (Or.inr ⟨⟨v,hv⟩, lt_of_not_ge h⟩)
+
+end GaussianSelection
+
+end UniformSparsestCut.Directions
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/EuclideanCells.lean

@@ -0,0 +1,164 @@
+import OAI.Combinatorics.SparsestCut.CoordinateSplit
+
+namespace OAI
+
+universe u1 u2
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.EuclideanCells
+open MeasureTheory Set ProductSlice CellInterface CoordinateSplit
+open scoped BigOperators RealInnerProductSpace
+noncomputable section
+variable {m : ℕ} {I : Type u1} {A : Type u2} [Fintype I] [Fintype A] [DecidableEq I]
+local notation "E" => EuclideanSpace ℝ (Fin (m+1))
+local notation "Z" => EuclideanSpace ℝ (Fin m)
+
+def B (u : I → E) : I → Z →L[ℝ] ℝ := fun i => slope (u i)
+def pivot (u : I → E) (i : I) : ℝ := u i 0
+
+def values (u : I → E) (τ : ℝ) (s : Finset ℤ) (U : Set (ℝ × Z))
+    (F : LabelVertex (ell (B u) (pivot u)) τ U → A → ℝ) : Finset (I × s) → A → ℝ :=
+  extension (ell (B u) (pivot u)) (pivot u) τ s U F
+
+def chartFunction (u : I → E) (τ : ℝ) (s : Finset ℤ) (U : Set (ℝ × Z))
+    (F : LabelVertex (ell (B u) (pivot u)) τ U → A → ℝ) (a : A) : E → ℝ :=
+  (cell (B u) (fun i (k : s) => -((k:ℤ)*τ/pivot u i)) (fun P => values u τ s U F P a)) ∘ split
+
+lemma form_comp (u : E) (hu : u 0≠0) :
+    (form (slope u)).comp split.toContinuousLinearMap=(u 0)⁻¹ • InnerProductSpace.toDual ℝ E u := by
+  ext x
+  have hh := normalized_form u hu x
+  change (split x).1-slope u (split x).2=(u 0)⁻¹*inner ℝ u x
+  rw [← hh,div_eq_mul_inv,mul_comm]
+
+lemma kernel_split (φ : ℝ → ℝ) :
+    (ProductMollifier.kernel (m := m+1) φ) ∘ split.symm =
+      (fun p : ℝ × Z => φ p.1*ProductMollifier.kernel φ p.2) := by
+  funext p
+  simp [ProductMollifier.kernel,Fin.prod_univ_succ]
+
+omit [Fintype A] [DecidableEq I] in
+lemma chartFunction_eq (u : I → E) (hu : ∀ i, u i 0≠0)
+    {τ : ℝ} (hτ : 0<τ) (s : Finset ℤ) (U : Set (ℝ × Z))
+    (hb : ∀ x∈U, regular (ell (B u) (pivot u)) τ x → ∀ i, label (ell (B u) (pivot u)) τ x i∈s)
+    (F : LabelVertex (ell (B u) (pivot u)) τ U → A → ℝ)
+    (x : E) (hx : split x∈U) (hr : regular (ell (B u) (pivot u)) τ (split x)) (a : A) :
+    chartFunction u τ s U F a x=F (vertex (ell (B u) (pivot u)) τ (split x) hx hr) a := by
+  change cell (B u) (fun i (k : s) => -((k:ℤ)*τ/pivot u i)) (fun P => extension (ell (B u) (pivot u)) (pivot u) τ s U F P a) (split x)=_
+  rw [cell_eq_extension (B u) (pivot u) hu (F := F)]
+  exact congrFun (extension_eq (ell (B u) (pivot u)) (pivot u) hu hτ s U hb F _ hx hr) a
+
+omit [Fintype A] in
+lemma chartFunction_measurable (u : I → E) (τ : ℝ) (s : Finset ℤ) (U : Set (ℝ × Z))
+    (F : LabelVertex (ell (B u) (pivot u)) τ U → A → ℝ) (a : A) :
+    Measurable (chartFunction u τ s U F a) :=
+  (cell_measurable _ _ _).comp split.continuous.measurable
+
+omit [Fintype A] in
+lemma chartFunction_integrable (u : I → E) (τ : ℝ) (s : Finset ℤ) (U : Set (ℝ × Z))
+    (F : LabelVertex (ell (B u) (pivot u)) τ U → A → ℝ) {M : ℝ} (hM : 0≤M)
+    (hF : ∀ v a, |F v a|≤M) (a : A) : LocallyIntegrable (chartFunction u τ s U F a) := by
+  apply (locallyIntegrable_const M).mono (chartFunction_measurable _ _ _ _ _ _).aestronglyMeasurable
+  filter_upwards with x
+  simpa only [chartFunction,Function.comp_apply,cell,values,Real.norm_eq_abs,abs_of_nonneg hM] using extension_bounded _ _ _ _ _ F hM hF _ a
+
+lemma coefficients (u : I → E) (hu : ∀ i, u i 0≠0)
+    (hnp : ∀ i j, i≠j → ∀ t : ℝ, u i≠t • u j)
+    {τ lam : ℝ} (hτ : 0<τ) (hlam : 0<lam) (s : Finset ℤ)
+    {U : Set (ℝ × Z)} (hU : IsOpen U)
+    (hb : ∀ x∈U, regular (ell (B u) (pivot u)) τ x → ∀ i, label (ell (B u) (pivot u)) τ x i∈s)
+    (F : LabelVertex (ell (B u) (pivot u)) τ U → A → ℝ) {M J : ℝ}
+    (hM : 0≤M) (hJ : 0≤J) (hbound : ∀ v a, |F v a|≤M)
+    (hF : ∀ (vp vm : LabelVertex (ell (B u) (pivot u)) τ U) (i : I), vp.val i=vm.val i+1 →
+      (∀ j, j≠i → vp.val j=vm.val j) → ∑ a, |F vp a-F vm a|≤J)
+    (θ : E)
+    (hsupp : ∀ᵐ z ∂law (ProductMollifier.kernel (m := m) (ProductMollifier.density lam)) volume,
+      ∀ t : ℝ, |t|<lam → split θ-(t,z)∈U)
+    (hsmall : ∀ i, τ/|pivot u i| *(lam⁻¹*(∫ t, |deriv ProductMollifier.rho t|))≤1) :
+    ∃ β : I → A → ℝ,
+      (∀ a, HasFDerivAt (convolution (ProductMollifier.kernel (m := m+1) (ProductMollifier.density lam))
+          (chartFunction u τ s U F a) (ContinuousLinearMap.mul ℝ ℝ) volume)
+        (∑ i, β i a • InnerProductSpace.toDual ℝ E (u i)) θ) ∧
+      (∀ i, ∑ a, |β i a|≤2*J/τ) := by
+  let φ := ProductMollifier.density lam
+  let ψ : Z → ℝ := ProductMollifier.kernel φ
+  let Ξ := values u τ s U F
+  let q (i : I) (k : s) := -((k:ℤ)*τ/pivot u i)
+  have hBij := slope_injective u hu hnp
+  have hq (i : I) : Function.Injective (q i) := by
+    intro k l he
+    apply Subtype.ext
+    have he' : (k.val:ℝ)=(l.val:ℝ) := by
+      dsimp only [q] at he
+      exact (mul_left_inj' hτ.ne').mp ((div_left_inj' (show pivot u i≠0 from hu i)).mp (neg_injective he))
+    exact_mod_cast he'
+  have hcφ := (ProductMollifier.density_smooth lam).continuous
+  have hiφ := ProductMollifier.density_integrable hlam
+  have hcompφ := ProductMollifier.density_compact hlam
+  have hdφ (t : ℝ) : HasDerivAt φ (deriv φ t) t :=
+    ((ProductMollifier.density_smooth lam).differentiable (by simp) t).hasDerivAt
+  have hiφ' : Integrable (deriv φ) :=
+    ((ProductMollifier.density_smooth lam).continuous_deriv (by simp)).integrable_of_hasCompactSupport hcompφ.deriv
+  have hnφ := ProductMollifier.density_nonneg hlam.le
+  have hcψ := ProductMollifier.kernel_smooth (m := m) φ (ProductMollifier.density_smooth lam)
+  have hcompψ := ProductMollifier.kernel_compact (m := m) hlam.le (fun t ht => (ProductMollifier.density_support hlam ht).le)
+  have hiψ : Integrable ψ := hcψ.continuous.integrable_of_hasCompactSupport hcompψ
+  have hnψ := ProductMollifier.kernel_nonneg (m := m) hnφ
+  have hψ1 : ∫ z, ψ z=1 := by rw [ProductMollifier.kernel_integral,ProductMollifier.density_integral hlam,one_pow]
+  obtain ⟨C,hC⟩ := hcφ.bounded_above_of_compact_support hcompφ
+  have hC0 : 0≤C := (norm_nonneg (φ 0)).trans (hC 0)
+  have hΞ : ∀ P a, |Ξ P a|≤M := extension_bounded _ _ _ _ _ F hM hbound
+  let d (i : I) (a : A) : ℝ := ∑ k : s, ∫ z,
+      -(φ (form (B u i) (split θ)+B u i z-(k:ℤ)*τ/pivot u i)*
+        jump (B u) q Ξ (split θ) i k z a) ∂law ψ volume
+  refine ⟨fun i a => (pivot u i)⁻¹*d i a,?_,?_⟩
+  · intro a
+    have hd := convolution_derivative (B u) hBij q hq (fun P => Ξ P a) hM hC0 (fun P => hΞ P a)
+      hiφ hcφ hC hcψ.continuous.measurable hnψ hiψ hψ1 (split θ)
+    have he : convolution (ProductMollifier.kernel (m := m+1) φ) (chartFunction u τ s U F a)
+        (ContinuousLinearMap.mul ℝ ℝ) volume =
+        (convolution (fun p : ℝ × Z => φ p.1*ψ p.2) (cell (B u) q (fun P => Ξ P a))
+          (ContinuousLinearMap.mul ℝ ℝ) volume) ∘ split := by
+      funext x
+      rw [chartFunction,convolution_split,kernel_split]
+      rfl
+    rw [he]
+    have hd' : HasFDerivAt
+        (convolution (fun p : ℝ × Z => φ p.1*ψ p.2) (cell (B u) q (fun P => Ξ P a))
+          (ContinuousLinearMap.mul ℝ ℝ) volume)
+        (∑ i, d i a • form (B u i)) (split θ) := by
+      simpa only [d,jump,q,sub_eq_add_neg] using hd
+    have ht := derivative_transport _ _ θ hd'
+    have hL : (∑ i, d i a • form (B u i)).comp split.toContinuousLinearMap =
+        ∑ i, ((pivot u i)⁻¹*d i a) • InnerProductSpace.toDual ℝ E (u i) := by
+      ext x
+      simp only [ContinuousLinearMap.comp_apply,_root_.sum_apply,_root_.smul_apply,smul_eq_mul]
+      apply Finset.sum_congr rfl
+      intro i _
+      have hi := congrArg (fun L : E →L[ℝ] ℝ => L x) (form_comp (u i) (hu i))
+      change form (B u i) (split x)=(pivot u i)⁻¹*inner ℝ (u i) x at hi
+      change d i a * form (B u i) (split x)=((pivot u i)⁻¹*d i a)*inner ℝ (u i) x
+      rw [hi]
+      ring
+    rw [hL] at ht
+    exact ht
+  · intro i
+    have hj := actual_jump_budget (B u) hBij (pivot u) hu hτ s hU hb F hF φ ψ (split θ) i (by
+      filter_upwards [hsupp] with z hz k hk
+      exact hz _ (ProductMollifier.density_support hlam hk))
+    have hh := common_coefficient_budget (B u) s (pivot u) hu hτ Ξ hM hC0 hJ hΞ
+      hdφ hnφ hiφ hiφ' (ProductMollifier.density_integral hlam) hC
+      hcψ.continuous.measurable hnψ hiψ hψ1 (split θ) i hj (by
+        rw [ProductMollifier.density_deriv_integral hlam]
+        exact hsmall i)
+    exact hh
+end
+end UniformSparsestCut.EuclideanCells
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/FiniteDuality.lean

@@ -0,0 +1,214 @@
+import OAI.Combinatorics.SparsestCut.Model
+
+namespace OAI
+
+universe u1 u2
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut
+
+namespace FiniteDuality
+
+variable {E : Type u1} {K : Type u2} [Fintype E] [Fintype K]
+
+def packingCone (A : E → K → ℝ) (w : K → ℝ) : Set ((E → ℝ) × ℝ) :=
+  {y | ∃ t : K → ℝ, (∀ k, 0 ≤ t k) ∧
+      (∀ e, ∑ k, A e k * t k ≤ y.1 e) ∧ y.2 ≤ ∑ k, w k * t k}
+
+lemma packingCone_closed (A : E → K → ℝ) (w : K → ℝ)
+    (hA : ∀ e k, 0 ≤ A e k) (hcol : ∀ k, 0 < ∑ e, A e k) :
+    IsClosed (packingCone A w) := by
+  classical
+  apply isSeqClosed_iff_isClosed.mp
+  intro y b hy hyb
+  choose t ht0 htA htw using hy
+  have hsum : Tendsto (fun n => ∑ e, (y n).1 e) atTop (𝓝 (∑ e, b.1 e)) :=
+    tendsto_finsetSum _ (fun e he => (tendsto_pi_nhds.mp hyb.fst_nhds) e)
+  obtain ⟨B, hB⟩ := hsum.bddAbove_range
+  have hbound (n : ℕ) (k : K) : t n k ≤ B / (∑ e, A e k) := by
+    apply (le_div_iff₀ (hcol k)).mpr
+    calc
+      t n k * ∑ e, A e k = ∑ e, A e k * t n k := by
+        rw [Finset.mul_sum]; apply Finset.sum_congr rfl; intros; ring
+      _ ≤ ∑ e, ∑ j, A e j * t n j := by
+        apply Finset.sum_le_sum
+        intro e he
+        exact Finset.single_le_sum (fun j hj => mul_nonneg (hA e j) (ht0 n j))
+          (Finset.mem_univ k)
+      _ ≤ ∑ e, (y n).1 e := Finset.sum_le_sum (fun e he => htA n e)
+      _ ≤ B := hB (Set.mem_range_self n)
+  obtain ⟨u, hu, φ, hφ, htend⟩ :=
+    (isCompact_Icc : IsCompact (Icc (0 : K → ℝ) (fun k => B / (∑ e, A e k)))).tendsto_subseq
+      (fun n => ⟨ht0 n, hbound n⟩)
+  refine ⟨u, hu.1, ?_, ?_⟩
+  · intro e
+    apply le_of_tendsto_of_tendsto
+      (tendsto_finsetSum _ (fun k hk =>
+        tendsto_const_nhds.mul ((tendsto_pi_nhds.mp htend) k)))
+      (((tendsto_pi_nhds.mp hyb.fst_nhds) e).comp hφ.tendsto_atTop)
+    exact Eventually.of_forall (fun n => htA (φ n) e)
+  · apply le_of_tendsto_of_tendsto (hyb.snd_nhds.comp hφ.tendsto_atTop)
+      (tendsto_finsetSum _ (fun k hk =>
+        tendsto_const_nhds.mul ((tendsto_pi_nhds.mp htend) k)))
+    exact Eventually.of_forall (fun n => htw (φ n))
+
+noncomputable def packingProperCone (A : E → K → ℝ) (w : K → ℝ)
+    (hA : ∀ e k, 0 ≤ A e k) (hcol : ∀ k, 0 < ∑ e, A e k) :
+    ProperCone ℝ ((E → ℝ) × ℝ) where
+  carrier := packingCone A w
+  zero_mem' := by
+    refine ⟨0, by simp, ?_, ?_⟩ <;> simp
+  add_mem' := by
+    rintro x y ⟨s, hs0, hsA, hsw⟩ ⟨t, ht0, htA, htw⟩
+    refine ⟨s+t, fun k => add_nonneg (hs0 k) (ht0 k), ?_, ?_⟩
+    · intro e
+      simpa [mul_add, Finset.sum_add_distrib] using add_le_add (hsA e) (htA e)
+    · simpa [mul_add, Finset.sum_add_distrib] using add_le_add hsw htw
+  smul_mem' := by
+    rintro ⟨a, ha⟩ x ⟨t, ht0, htA, htw⟩
+    refine ⟨a • t, fun k => mul_nonneg ha (ht0 k), ?_, ?_⟩
+    · intro e
+      change (∑ k, A e k * (a * t k)) ≤ a * x.1 e
+      simpa [← Finset.mul_sum, mul_left_comm] using
+        mul_le_mul_of_nonneg_left (htA e) ha
+    · change a * x.2 ≤ ∑ k, w k * (a * t k)
+      simpa [← Finset.mul_sum, mul_left_comm] using
+        mul_le_mul_of_nonneg_left htw ha
+  isClosed' := packingCone_closed A w hA hcol
+
+lemma dual_functional (f : ((E → ℝ) × ℝ) →L[ℝ] ℝ) :
+    ∃ c : E → ℝ, ∃ q : ℝ, ∀ x : (E → ℝ) × ℝ,
+      f x = (∑ e, c e * x.1 e) + q * x.2 := by
+  classical
+  refine ⟨fun e => f (Pi.single e 1, 0), f (0, 1), ?_⟩
+  rintro ⟨x,y⟩
+  have heq : (x,y) = (∑ e, x e • (Pi.single e 1, (0 : ℝ))) + y • (0, (1 : ℝ)) := by
+    ext e <;> simp [Prod.fst_sum, Prod.snd_sum, ← Pi.single_smul,
+      Finset.univ_sum_single]
+  calc
+    f (x,y) = f ((∑ e, x e • (Pi.single e 1, (0 : ℝ))) + y • (0, (1 : ℝ))) :=
+      congrArg f heq
+    _ = (∑ e, f (Pi.single e 1, 0) * x e) + f (0, 1) * y := by
+      simp only [map_add, map_sum, map_smul, smul_eq_mul, mul_comm]
+
+theorem packing_duality_strict (A : E → K → ℝ) (w : K → ℝ)
+    (hA : ∀ e k, 0 ≤ A e k) (hcol : ∀ k, 0 < ∑ e, A e k)
+    (d : E → ℝ) (hd : ∀ e, 0 ≤ d e) {β : ℝ} (hβ : 0 < β)
+    (hbound : ∀ t : K → ℝ, (∀ k, 0 ≤ t k) →
+      (∀ e, ∑ k, A e k * t k ≤ d e) → (∑ k, w k * t k) < β) :
+    ∃ c : E → ℝ, (∀ e, 0 ≤ c e) ∧
+      (∀ k, w k ≤ ∑ e, A e k * c e) ∧ (∑ e, c e * d e) < β := by
+  classical
+  let C := packingProperCone A w hA hcol
+  have hnot : (d,β) ∉ C := by
+    rintro ⟨t, ht0, htA, htw⟩
+    exact (hbound t ht0 htA).not_ge htw
+  obtain ⟨f, hf, hfb⟩ := C.hyperplane_separation_point hnot
+  obtain ⟨c,q,hform⟩ := dual_functional f
+  have hc (e : E) : 0 ≤ c e := by
+    have hx : (Pi.single e 1, (0 : ℝ)) ∈ C := by
+      refine ⟨0, by simp, ?_, ?_⟩
+      · intro j; simp only [Pi.zero_apply, mul_zero, Finset.sum_const_zero]
+        simp [Pi.single_apply]; split_ifs <;> norm_num
+      · simp
+    simpa [hform, Pi.single_apply, mul_ite] using hf _ hx
+  have hq : q < 0 := by
+    rw [hform] at hfb
+    have hcd : 0 ≤ ∑ e, c e * d e :=
+      Finset.sum_nonneg (fun e he => mul_nonneg (hc e) (hd e))
+    nlinarith
+  have hcoldual (k : K) : 0 ≤ (∑ e, c e * A e k) + q * w k := by
+    have hx : ((fun e => A e k), w k) ∈ C := by
+      refine ⟨Pi.single k 1, ?_, ?_, ?_⟩
+      · intro j; simp [Pi.single_apply]; split_ifs <;> norm_num
+      · intro e; simp [Pi.single_apply, mul_ite]
+      · simp [Pi.single_apply, mul_ite]
+    simpa [hform, Pi.single_apply, mul_ite] using hf _ hx
+  refine ⟨fun e => c e / (-q), fun e => div_nonneg (hc e) (neg_pos.mpr hq).le, ?_, ?_⟩
+  · intro k
+    simp only [← mul_div_assoc, ← Finset.sum_div]
+    apply (le_div_iff₀ (neg_pos.mpr hq)).mpr
+    have := hcoldual k
+    have hsum : (∑ e, A e k * c e) = ∑ e, c e * A e k := by
+      apply Finset.sum_congr rfl; intros; ring
+    rw [hsum]
+    nlinarith
+  · simp only [div_mul_eq_mul_div, ← Finset.sum_div]
+    apply (div_lt_iff₀ (neg_pos.mpr hq)).mpr
+    rw [hform] at hfb
+    nlinarith
+
+omit [Fintype K] in
+
+lemma cap_covering (A : E → K → ℝ) (w : K → ℝ)
+    (hA : ∀ e k, A e k = 0 ∨ A e k = 1) {W : ℝ} (hW : 0 ≤ W)
+    (hw : ∀ k, w k ≤ W) (c : E → ℝ) (hc : ∀ e, 0 ≤ c e)
+    (hcover : ∀ k, w k ≤ ∑ e, A e k * c e) :
+    ∀ k, w k ≤ ∑ e, A e k * min (c e) W := by
+  classical
+  intro k
+  by_cases hb : ∃ e, A e k = 1 ∧ W < c e
+  · obtain ⟨e, he, hce⟩ := hb
+    calc
+      w k ≤ W := hw k
+      _ = A e k * min (c e) W := by rw [he, min_eq_right hce.le]; ring
+      _ ≤ ∑ j, A j k * min (c j) W :=
+        Finset.single_le_sum (fun j hj => mul_nonneg
+          (show 0 ≤ A j k from by rcases hA j k with h | h <;> rw [h] ; norm_num)
+          (le_min (hc j) hW)) (Finset.mem_univ e)
+  · convert hcover k using 1
+    apply Finset.sum_congr rfl
+    intro e he
+    rcases hA e k with hz | ho
+    · simp [hz]
+    · have hcW : c e ≤ W := le_of_not_gt (fun h => hb ⟨e, ho, h⟩)
+      rw [min_eq_left hcW]
+
+theorem packing_duality (A : E → K → ℝ) (w : K → ℝ)
+    (hA : ∀ e k, A e k = 0 ∨ A e k = 1) (hcol : ∀ k, 0 < ∑ e, A e k)
+    (d : E → ℝ) (hd : ∀ e, 0 ≤ d e) {β W : ℝ} (hβ : 0 ≤ β) (hW : 0 ≤ W)
+    (hw : ∀ k, w k ≤ W)
+    (hbound : ∀ t : K → ℝ, (∀ k, 0 ≤ t k) →
+      (∀ e, ∑ k, A e k * t k ≤ d e) → (∑ k, w k * t k) ≤ β) :
+    ∃ c : E → ℝ, (∀ e, 0 ≤ c e) ∧
+      (∀ k, w k ≤ ∑ e, A e k * c e) ∧ (∑ e, c e * d e) ≤ β := by
+  classical
+  have hA0 : ∀ e k, 0 ≤ A e k := by
+    intro e k; rcases hA e k with h | h <;> rw [h] ; norm_num
+  let T : Set (E → ℝ) := Icc 0 (fun _ => W) ∩ {c | ∀ k, w k ≤ ∑ e, A e k * c e}
+  have hTc : IsCompact T := by
+    refine isCompact_Icc.inter_right ?_
+    simp only [ofPred_forall]
+    apply isClosed_iInter
+    intro k
+    apply isClosed_le continuous_const
+    exact continuous_finsetSum _ (fun e he => continuous_const.mul (continuous_apply e))
+  have hcapped : ∀ γ, β < γ → ∃ c ∈ T, (∑ e, c e * d e) < γ := by
+    intro γ hγ
+    obtain ⟨c, hc0, hcA, hcd⟩ := packing_duality_strict A w hA0 hcol d hd
+      (hβ.trans_lt hγ) (fun t ht htA => (hbound t ht htA).trans_lt hγ)
+    refine ⟨fun e => min (c e) W, ⟨⟨?_, ?_⟩, cap_covering A w hA hW hw c hc0 hcA⟩, ?_⟩
+    · exact fun e => le_min (hc0 e) hW
+    · exact fun e => min_le_right _ _
+    · exact lt_of_le_of_lt (Finset.sum_le_sum (fun e he =>
+        mul_le_mul_of_nonneg_right (min_le_left _ _) (hd e))) hcd
+  obtain ⟨c0, hc0, _⟩ := hcapped (β+1) (by linarith)
+  have hobj : Continuous (fun c : E → ℝ => ∑ e, c e * d e) :=
+    continuous_finsetSum _ (fun e he => (continuous_apply e).mul continuous_const)
+  obtain ⟨c, hc, hmin⟩ := hTc.exists_isMinOn ⟨c0,hc0⟩ hobj.continuousOn
+  refine ⟨c, hc.1.1, hc.2, ?_⟩
+  by_contra! hstrict
+  obtain ⟨c', hc', hlt⟩ := hcapped (∑ e, c e * d e) hstrict
+  exact hlt.not_ge (hmin hc')
+
+end FiniteDuality
+
+end UniformSparsestCut
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/FiniteGraph.lean

@@ -0,0 +1,128 @@
+import Mathlib.Algebra.Order.BigOperators.Group.Finset
+import Mathlib.Algebra.Order.Field.Rat
+import Mathlib.Data.Finset.Max
+import Mathlib.Data.Fintype.Powerset
+import Mathlib.Tactic.Positivity
+
+namespace OAI
+
+/-!
+# Finite uniform sparsest cut
+
+The rational-capacity objective and its unit-demand denominator follow the introduction of
+*Constant-factor hardness of uniform sparsest cut* by OpenAI.
+-/
+
+open scoped BigOperators
+
+namespace UniformSparsestCut
+
+
+/-- An undirected rational-capacity graph.  Zero capacities encode absent edges.
+There are no input demand weights: all distinct pairs have demand one. -/
+structure Graph where
+  n : ℕ
+  two_le : 2 ≤ n
+  capacity : Fin n → Fin n → ℚ
+  nonnegative : ∀ i j, 0 ≤ capacity i j
+  symmetric : ∀ i j, capacity i j = capacity j i
+  diagonal : ∀ i, capacity i i = 0
+
+/-- Demand is fixed, not chosen by the reduction. -/
+def Graph.demand (G : Graph) (i j : Fin G.n) : ℕ := if i = j then 0 else 1
+
+@[simp] theorem Graph.demand_self (G : Graph) (i : Fin G.n) : G.demand i i = 0 := by
+  simp [Graph.demand]
+
+theorem Graph.demand_of_ne (G : Graph) {i j : Fin G.n} (h : i ≠ j) :
+    G.demand i j = 1 := by
+  simp [Graph.demand, h]
+
+/-- A nonempty proper subset of the vertices. -/
+def IsCut {n : ℕ} (S : Finset (Fin n)) : Prop := 0 < S.card ∧ S.card < n
+
+instance {n : ℕ} (S : Finset (Fin n)) : Decidable (IsCut S) :=
+  inferInstanceAs (Decidable (0 < S.card ∧ S.card < n))
+
+def cuts (n : ℕ) : Finset (Finset (Fin n)) := Finset.univ.filter IsCut
+
+@[simp] theorem mem_cuts {n : ℕ} {S : Finset (Fin n)} : S ∈ cuts n ↔ IsCut S := by
+  simp [cuts]
+
+theorem cuts_nonempty (G : Graph) : (cuts G.n).Nonempty := by
+  have hn : 0 < G.n := lt_of_lt_of_le (by decide : 0 < 2) G.two_le
+  refine ⟨{⟨0, hn⟩}, mem_cuts.mpr ?_⟩
+  simpa [IsCut] using (show 0 < 1 ∧ 1 < G.n from ⟨by decide, by have := G.two_le; omega⟩)
+
+/-- Each unordered separated pair occurs once, with its endpoint in `S` first. -/
+def Graph.cutCapacity (G : Graph) (S : Finset (Fin G.n)) : ℚ :=
+  ∑ i ∈ S, ∑ j ∈ Finset.univ \ S, G.capacity i j
+
+def Graph.cutRatio (G : Graph) (S : Finset (Fin G.n)) : ℚ :=
+  G.cutCapacity S / ((S.card : ℚ) * (G.n - S.card : ℕ))
+
+/-- The actual minimum over all nonempty proper cuts, not a relaxation. -/
+def Graph.phi (G : Graph) : ℚ :=
+  ((cuts G.n).image G.cutRatio).min' ((cuts_nonempty G).image _)
+
+theorem cut_card_le (G : Graph) (S : Finset (Fin G.n)) : S.card ≤ G.n := by
+  simpa using Finset.card_le_card (Finset.subset_univ S)
+
+theorem cut_denominator_pos (G : Graph) {S : Finset (Fin G.n)} (hS : IsCut S) :
+    (0 : ℚ) < (S.card : ℚ) * (G.n - S.card : ℕ) := by
+  exact mul_pos (Nat.cast_pos.mpr hS.1) (Nat.cast_pos.mpr (Nat.sub_pos_of_lt hS.2))
+
+theorem Graph.cutCapacity_nonneg (G : Graph) (S : Finset (Fin G.n)) :
+    0 ≤ G.cutCapacity S := by
+  exact Finset.sum_nonneg (fun i _ => Finset.sum_nonneg (fun j _ => G.nonnegative i j))
+
+theorem Graph.cutRatio_nonneg (G : Graph) (S : Finset (Fin G.n)) :
+    0 ≤ G.cutRatio S := by
+  exact div_nonneg (G.cutCapacity_nonneg S) (by positivity)
+
+theorem Graph.phi_le_cutRatio (G : Graph) {S : Finset (Fin G.n)} (hS : IsCut S) :
+    G.phi ≤ G.cutRatio S := by
+  exact Finset.min'_le _ _ (Finset.mem_image.mpr ⟨S, mem_cuts.mpr hS, rfl⟩)
+
+theorem Graph.exists_minimizing_cut (G : Graph) :
+    ∃ S : Finset (Fin G.n), IsCut S ∧ G.cutRatio S = G.phi := by
+  obtain ⟨S, hS, hv⟩ := Finset.mem_image.mp
+    (Finset.min'_mem ((cuts G.n).image G.cutRatio) ((cuts_nonempty G).image _))
+  exact ⟨S, mem_cuts.mp hS, hv⟩
+
+theorem Graph.phi_nonneg (G : Graph) : 0 ≤ G.phi := by
+  obtain ⟨S, _, hS⟩ := G.exists_minimizing_cut
+  rw [← hS]
+  exact G.cutRatio_nonneg S
+
+/-- In particular, strict soundness for every cut implies strict soundness for the minimum. -/
+theorem Graph.lt_phi_iff (G : Graph) (r : ℚ) :
+    r < G.phi ↔ ∀ S : Finset (Fin G.n), IsCut S → r < G.cutRatio S := by
+  constructor
+  · intro hr S hS
+    exact hr.trans_le (G.phi_le_cutRatio hS)
+  · intro h
+    obtain ⟨S, hS, heq⟩ := G.exists_minimizing_cut
+    simpa [heq] using h S hS
+
+/-- Summing the exactly-unit demands gives precisely the denominator in the source. -/
+theorem Graph.separated_demand (G : Graph) (S : Finset (Fin G.n)) :
+    (∑ i ∈ S, ∑ j ∈ Finset.univ \ S, G.demand i j) = S.card * (G.n - S.card) := by
+  have hne (i : Fin G.n) (hi : i ∈ S) (j : Fin G.n) (hj : j ∈ Finset.univ \ S) :
+      i ≠ j := by
+    intro hij
+    exact (Finset.mem_sdiff.mp hj).2 (hij ▸ hi)
+  have hc : (Finset.univ \ S).card = G.n - S.card := by
+    simp [Finset.card_sdiff]
+  calc
+    _ = ∑ _i ∈ S, ∑ _j ∈ Finset.univ \ S, (1 : ℕ) := by
+      apply Finset.sum_congr rfl
+      intro i hi
+      apply Finset.sum_congr rfl
+      intro j hj
+      exact G.demand_of_ne (hne i hi j hj)
+    _ = _ := by simp [hc]
+
+end UniformSparsestCut
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/FiniteNets.lean

@@ -0,0 +1,122 @@
+import OAI.Combinatorics.SparsestCut.GaussianTools
+
+namespace OAI
+
+universe u1
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.FiniteNets
+
+lemma euclidean_norm_le_sum_abs {n : ℕ} (x : EuclideanSpace ℝ (Fin n)) :
+    ‖x‖ ≤ ∑ i, |x i| := by
+  classical
+  have heq : x = ∑ i : Fin n, (PiLp.single 2 i (x i) : EuclideanSpace ℝ (Fin n)) := by
+    ext j
+    simp
+  calc
+    _ = ‖∑ i : Fin n, (PiLp.single 2 i (x i) : EuclideanSpace ℝ (Fin n))‖ := congrArg norm heq
+    _ ≤ ∑ i : Fin n, ‖(PiLp.single 2 i (x i) : EuclideanSpace ℝ (Fin n))‖ := norm_sum_le _ _
+    _ = _ := by simp [PiLp.norm_single, Real.norm_eq_abs]
+
+lemma floor_coordinate_bound {n K : ℕ} {δ : ℝ} (hδ : 0 < δ)
+    {x : EuclideanSpace ℝ (Fin n)} (hx : ‖x‖ ≤ (K : ℝ) * δ) (i : Fin n) :
+    ⌊x i / δ⌋ ∈ Finset.Icc (-(K : ℤ)) (K : ℤ) := by
+  have hcoord : |x i| ≤ ‖x‖ := by simpa using PiLp.norm_apply_le x i
+  have hi : |x i| ≤ (K : ℝ) * δ := hcoord.trans hx
+  rw [Finset.mem_Icc]
+  constructor
+  · apply Int.le_floor.mpr
+    push_cast
+    apply (le_div_iff₀ hδ).mpr
+    linarith [neg_abs_le (x i)]
+  · have hh : x i / δ ≤ (K : ℝ) := (div_le_iff₀ hδ).mpr ((le_abs_self _).trans hi)
+    have h := Int.floor_mono hh
+    simpa using h
+
+lemma same_floor_distance {n : ℕ} {δ : ℝ} (hδ : 0 < δ)
+    {x y : EuclideanSpace ℝ (Fin n)} (hxy : ∀ i, ⌊x i / δ⌋ = ⌊y i / δ⌋) :
+    ‖x - y‖ ≤ (n : ℝ) * δ := by
+  have hc (i : Fin n) : |x i - y i| ≤ δ := by
+    have hx1 := Int.floor_le (x i / δ)
+    have hx2 := Int.lt_floor_add_one (x i / δ)
+    have hy1 := Int.floor_le (y i / δ)
+    have hy2 := Int.lt_floor_add_one (y i / δ)
+    rw [hxy i] at hx1 hx2
+    apply abs_le.mpr
+    constructor
+    · have hh : -1 ≤ (x i - y i) / δ := by rw [sub_div]; linarith
+      have := (le_div_iff₀ hδ).mp hh
+      linarith
+    · have hh : (x i - y i) / δ ≤ 1 := by rw [sub_div]; linarith
+      have := (div_le_iff₀ hδ).mp hh
+      linarith
+  calc
+    ‖x-y‖ ≤ ∑ i, |(x-y) i| := euclidean_norm_le_sum_abs _
+    _ ≤ ∑ _ : Fin n, δ := Finset.sum_le_sum (fun i _ => hc i)
+    _ = _ := by simp
+
+theorem exists_coordinate_net {n K : ℕ} {δ : ℝ} (hδ : 0 < δ)
+    (A : Set (EuclideanSpace ℝ (Fin n)))
+    (hA : ∀ x ∈ A, ‖x‖ ≤ (K : ℝ) * δ) :
+    ∃ V : Finset (EuclideanSpace ℝ (Fin n)),
+      (∀ v ∈ V, v ∈ A) ∧ V.card ≤ (2*K+1)^n ∧
+      ∀ x ∈ A, ∃ v ∈ V, ‖x-v‖ ≤ (n : ℝ)*δ := by
+  classical
+  let G := Fin n → ↥(Finset.Icc (-(K : ℤ)) (K : ℤ))
+  let represented : G → Prop := fun g => ∃ x ∈ A, ∀ i, ⌊x i / δ⌋ = (g i).val
+  let point : G → EuclideanSpace ℝ (Fin n) := fun g =>
+    if h : represented g then h.choose else 0
+  have hpoint (g : G) (hg : represented g) :
+      point g ∈ A ∧ ∀ i, ⌊point g i / δ⌋ = (g i).val := by
+    simpa [point, hg] using hg.choose_spec
+  let V := (Finset.univ.filter represented).image point
+  refine ⟨V, ?_, ?_, ?_⟩
+  · intro v hv
+    obtain ⟨g, hg, rfl⟩ := Finset.mem_image.mp hv
+    exact (hpoint g (Finset.mem_filter.mp hg).2).1
+  · calc
+      V.card ≤ (Finset.univ.filter represented).card := Finset.card_image_le
+      _ ≤ Fintype.card G := (Finset.card_filter_le _ _).trans_eq (Finset.card_univ)
+      _ = (2*K+1)^n := by
+        simp only [G, Fintype.card_fun, Fintype.card_coe, Int.card_Icc, Fintype.card_fin]
+        congr 1
+        omega
+  · intro x hx
+    let g : G := fun i => ⟨⌊x i / δ⌋, floor_coordinate_bound hδ (hA x hx) i⟩
+    have hg : represented g := ⟨x, hx, fun _ => rfl⟩
+    refine ⟨point g, Finset.mem_image.mpr ⟨g, Finset.mem_filter.mpr ⟨Finset.mem_univ _, hg⟩, rfl⟩, ?_⟩
+    exact same_floor_distance hδ (fun i => ((hpoint g hg).2 i).symm)
+
+lemma sphere_net_norm_bound {E : Type u1} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+    {V : Finset E} {ρ B : ℝ}
+    (hnet : ∀ x : E, ‖x‖ = 1 → ∃ v ∈ V, ‖x-v‖ ≤ ρ)
+    {z : E} (hz : ∀ v ∈ V, |inner ℝ z v| ≤ B) (hB : 0 ≤ B) :
+    (1-ρ)*‖z‖ ≤ B := by
+  by_cases hzero : z = 0
+  · simpa [hzero] using hB
+  have hn : 0 < ‖z‖ := norm_pos_iff.mpr hzero
+  let x := ‖z‖⁻¹ • z
+  have hx : ‖x‖ = 1 := by simp [x, norm_smul, hn.ne']
+  obtain ⟨v, hv, hdist⟩ := hnet x hx
+  have hinner : inner ℝ z x = ‖z‖ := by
+    simp [x, inner_smul_right, sq, hn.ne']
+  have heq : inner ℝ z x = inner ℝ z v + inner ℝ z (x-v) := by
+    rw [inner_sub_right]
+    ring
+  have hbound : ‖z‖ ≤ B + ‖z‖ * ρ := by
+    calc
+      ‖z‖ = |inner ℝ z x| := by rw [hinner, abs_of_nonneg (norm_nonneg _)]
+      _ ≤ |inner ℝ z v| + |inner ℝ z (x-v)| := by rw [heq]; exact abs_add_le _ _
+      _ ≤ B + ‖z‖ * ρ := add_le_add (hz v hv)
+        ((abs_real_inner_le_norm _ _).trans (mul_le_mul_of_nonneg_left hdist (norm_nonneg _)))
+  nlinarith
+
+end UniformSparsestCut.FiniteNets
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/FiniteWeights.lean

@@ -0,0 +1,168 @@
+/-
+Copyright (c) 2026 OpenAI. All rights reserved.
+Authors: OpenAI
+-/
+import Mathlib.Algebra.Order.BigOperators.Ring.Finset
+import Mathlib.Basic.Real.Basic
+import Mathlib.Tactic.Linarith
+
+namespace OAI
+
+/-!
+# Finite Boolean weights and variances
+
+Finite weighted laws support Boolean event masses, complementary masses, and the disagreement
+of independent draws. The variance estimates give scalar ingredients for the finite graph
+construction in Section 7 of *Constant-factor hardness of uniform sparsest cut*.
+-/
+
+open scoped BigOperators
+
+namespace UniformSparsestCut.FiniteWeights
+
+variable {ι : Type*} [Fintype ι]
+
+def indicator (b : Bool) : ℝ := if b then 1 else 0
+
+def disagree (b c : Bool) : ℝ := if b = c then 0 else 1
+
+def total (w : ι → ℝ) : ℝ := ∑ i, w i
+
+def mass (w : ι → ℝ) (h : ι → Bool) : ℝ := ∑ i, w i * indicator (h i)
+
+def variance (w : ι → ℝ) (h : ι → Bool) : ℝ := mass w h * (1 - mass w h)
+
+/-- The weight of a disagreement for two independent draws (not necessarily normalized). -/
+def disagreement (w u : ι → ℝ) (h : ι → Bool) : ℝ :=
+  ∑ i, w i * ∑ j, u j * disagree (h i) (h j)
+
+theorem indicator_nonneg (b : Bool) : 0 ≤ indicator b := by
+  cases b <;> simp [indicator]
+
+theorem indicator_le_one (b : Bool) : indicator b ≤ 1 := by
+  cases b <;> simp [indicator]
+
+theorem indicator_not (b : Bool) : indicator (!b) = 1 - indicator b := by
+  cases b <;> simp [indicator]
+
+theorem disagree_nonneg (b c : Bool) : 0 ≤ disagree b c := by
+  cases b <;> cases c <;> simp [disagree]
+
+theorem disagree_eq (b c : Bool) :
+    disagree b c = indicator b * (1 - indicator c) + (1 - indicator b) * indicator c := by
+  cases b <;> cases c <;> simp [disagree, indicator]
+
+theorem total_nonneg {w : ι → ℝ} (hw : ∀ i, 0 ≤ w i) : 0 ≤ total w :=
+  Finset.sum_nonneg (fun i _ => hw i)
+
+theorem total_mono {w u : ι → ℝ} (hwu : ∀ i, w i ≤ u i) : total w ≤ total u :=
+  Finset.sum_le_sum (fun i _ => hwu i)
+
+theorem total_add (w u : ι → ℝ) : total (fun i => w i + u i) = total w + total u := by
+  simp [total, Finset.sum_add_distrib]
+
+theorem total_smul (a : ℝ) (w : ι → ℝ) : total (fun i => a * w i) = a * total w := by
+  simp [total, Finset.mul_sum]
+
+theorem mass_nonneg {w : ι → ℝ} (hw : ∀ i, 0 ≤ w i) (h : ι → Bool) : 0 ≤ mass w h :=
+  Finset.sum_nonneg (fun i _ => mul_nonneg (hw i) (indicator_nonneg (h i)))
+
+theorem mass_le_total {w : ι → ℝ} (hw : ∀ i, 0 ≤ w i) (h : ι → Bool) :
+    mass w h ≤ total w := by
+  apply Finset.sum_le_sum
+  intro i _
+  simpa using mul_le_mul_of_nonneg_left (indicator_le_one (h i)) (hw i)
+
+theorem mass_mono {w u : ι → ℝ} (hwu : ∀ i, w i ≤ u i) (h : ι → Bool) :
+    mass w h ≤ mass u h := by
+  exact Finset.sum_le_sum (fun i _ =>
+    mul_le_mul_of_nonneg_right (hwu i) (indicator_nonneg (h i)))
+
+theorem mass_add (w u : ι → ℝ) (h : ι → Bool) :
+    mass (fun i => w i + u i) h = mass w h + mass u h := by
+  simp [mass, add_mul, Finset.sum_add_distrib]
+
+theorem mass_smul (a : ℝ) (w : ι → ℝ) (h : ι → Bool) :
+    mass (fun i => a * w i) h = a * mass w h := by
+  simp [mass, mul_assoc, Finset.mul_sum]
+
+theorem mass_compl (w : ι → ℝ) (h : ι → Bool) :
+    mass w (fun i => !(h i)) = total w - mass w h := by
+  simp [mass, indicator_not, mul_sub, Finset.sum_sub_distrib, total]
+
+theorem variance_nonneg {w : ι → ℝ} (hw : ∀ i, 0 ≤ w i) (hw₁ : total w = 1)
+    (h : ι → Bool) : 0 ≤ variance w h := by
+  exact mul_nonneg (mass_nonneg hw h) (sub_nonneg.mpr (hw₁ ▸ mass_le_total hw h))
+
+theorem inner_disagreement (u : ι → ℝ) (h : ι → Bool) (b : Bool) :
+    (∑ j, u j * disagree b (h j)) =
+      indicator b * (total u - mass u h) + (1 - indicator b) * mass u h := by
+  calc
+    _ = ∑ j, (indicator b * (u j - u j * indicator (h j)) +
+        (1 - indicator b) * (u j * indicator (h j))) := by
+      apply Finset.sum_congr rfl
+      intro j _
+      rw [disagree_eq]
+      ring
+    _ = _ := by
+      simp only [Finset.sum_add_distrib, ← Finset.mul_sum, Finset.sum_sub_distrib,
+        total, mass]
+
+theorem disagreement_eq (w u : ι → ℝ) (h : ι → Bool) :
+    disagreement w u h = mass w h * (total u - mass u h) +
+      (total w - mass w h) * mass u h := by
+  unfold disagreement
+  simp_rw [inner_disagreement]
+  calc
+    _ = ∑ i, ((w i * indicator (h i)) * (total u - mass u h) +
+        (w i - w i * indicator (h i)) * mass u h) := by
+      apply Finset.sum_congr rfl
+      intro i _
+      ring
+    _ = _ := by
+      simp only [Finset.sum_add_distrib, ← Finset.sum_mul, Finset.sum_sub_distrib,
+        total, mass]
+
+theorem disagreement_self (w : ι → ℝ) (hw : total w = 1) (h : ι → Bool) :
+    disagreement w w h = 2 * variance w h := by
+  rw [disagreement_eq, hw]
+  unfold variance
+  ring
+
+theorem disagreement_nonneg {w u : ι → ℝ} (hw : ∀ i, 0 ≤ w i)
+    (hu : ∀ i, 0 ≤ u i) (h : ι → Bool) : 0 ≤ disagreement w u h := by
+  unfold disagreement
+  exact Finset.sum_nonneg (fun i _ => mul_nonneg (hw i)
+    (Finset.sum_nonneg (fun j _ => mul_nonneg (hu j) (disagree_nonneg _ _))))
+
+/-- Product domination: the constant is squared, since the two draws are independent. -/
+theorem variance_domination {w u : ι → ℝ} {A : ℝ}
+    (hw : ∀ i, 0 ≤ w i) (hu : ∀ i, 0 ≤ u i)
+    (hw₁ : total w = 1) (hu₁ : total u = 1) (hA : 0 ≤ A)
+    (hdom : ∀ i, w i ≤ A * u i) (h : ι → Bool) :
+    variance w h ≤ A ^ 2 * variance u h := by
+  have hm : mass w h ≤ A * mass u h := by
+    simpa [mass_smul] using mass_mono hdom h
+  have hc : 1 - mass w h ≤ A * (1 - mass u h) := by
+    simpa [mass_smul, mass_compl, total_smul, hw₁, hu₁, mul_sub] using
+      mass_mono hdom (fun i => !(h i))
+  have hc₀ : 0 ≤ 1 - mass w h := sub_nonneg.mpr (hw₁ ▸ mass_le_total hw h)
+  have hm₀ : 0 ≤ A * mass u h := mul_nonneg hA (mass_nonneg hu h)
+  have hh := mul_le_mul hm hc hc₀ hm₀
+  unfold variance
+  nlinarith only [hh]
+
+/-- A change of color with probability at most `L` changes Boolean variance by at most `L`.
+This scalar estimate also follows by coupling two independent draws and a union bound. -/
+theorem variance_change {z r L : ℝ} (hz₀ : 0 ≤ z) (hz₁ : z ≤ 1)
+    (hr₀ : 0 ≤ r) (hr₁ : r ≤ 1) (h₁ : z - r ≤ L) (h₂ : r - z ≤ L) :
+    z * (1 - z) ≤ r * (1 - r) + L := by
+  rcases le_total z r with hzr | hrz
+  · have hh := mul_nonneg (sub_nonneg.mpr hzr) (show 0 ≤ 2 - z - r by linarith)
+    nlinarith only [hh, h₂]
+  · have hh := mul_nonneg (sub_nonneg.mpr hrz) (add_nonneg hz₀ hr₀)
+    nlinarith only [hh, h₁]
+
+end UniformSparsestCut.FiniteWeights
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/GapEstimates.lean

@@ -0,0 +1,57 @@
+import Mathlib.Basic.Real.Basic
+import Mathlib.Tactic.Linarith
+
+namespace OAI
+
+/-!
+# Numerical estimates for the finite sparsest-cut graph
+
+These are the final completeness and soundness inequalities in Section 7 of
+*Constant-factor hardness of uniform sparsest cut* by OpenAI.
+-/
+
+namespace UniformSparsestCut
+
+/-- A cut of capacity at most `22` whose two sides have counting mass at least
+`1 / 40000` lies below the completeness threshold. -/
+theorem completeness_ratio {N z T : ℝ} (hN : 0 < N)
+    (hz : (1 : ℝ) / 40000 ≤ z) (hz' : (1 : ℝ) / 40000 ≤ 1 - z)
+    (hT : T ≤ 22) : T / (N ^ 2 * (z * (1 - z))) < 10 ^ 12 / N ^ 2 := by
+  have hz₀ : 0 < z := by linarith
+  have hz₁ : 0 < 1 - z := by linarith
+  have hvar : (1 / 40000 : ℝ) ^ 2 ≤ z * (1 - z) := by
+    simpa only [pow_two] using
+      mul_le_mul hz hz' (by norm_num : (0 : ℝ) ≤ 1 / 40000) hz₀.le
+  have hgap : T < (10 : ℝ) ^ 12 * (z * (1 - z)) := by nlinarith
+  have hvpos := mul_pos hz₀ hz₁
+  have hdiv : T / (z * (1 - z)) < (10 : ℝ) ^ 12 := (div_lt_iff₀ hvpos).mpr hgap
+  have hN₂ : 0 < N ^ 2 := sq_pos_of_pos hN
+  calc
+    _ = (T / (z * (1 - z))) / N ^ 2 := by rw [div_div, mul_comm]
+    _ < _ := (div_lt_div_iff_of_pos_right hN₂).mpr hdiv
+
+/-- Variance transfer and the tether bound contradict the comparison gap for a
+nontrivial monochromatic-cluster cut. -/
+theorem soundness_contradiction {κ z ν T L D : ℝ}
+    (hκ : 0 < κ) (hz₀ : 0 < z) (hz₁ : z < 1) (hν : 0 ≤ ν) (hL : 0 ≤ L)
+    (hsmall : T ≤ κ * (z * (1 - z)))
+    (htether : 2 * κ * L ≤ T) (htransfer : z * (1 - z) ≤ 36 * ν + L)
+    (hraw : D ≤ T) (hgap : 0 < ν → 100 * κ * ν < D) : False := by
+  have ht : T ≤ κ * (36 * ν + L) :=
+    hsmall.trans (mul_le_mul_of_nonneg_left htransfer hκ.le)
+  have ht72 : T ≤ 72 * κ * ν := by nlinarith only [ht, htether]
+  have hνpos : 0 < ν := by
+    by_contra hn
+    have hνzero : ν = 0 := le_antisymm (le_of_not_gt hn) hν
+    rw [hνzero] at ht72 htransfer
+    have hT : T ≤ 0 := by simpa using ht72
+    have hLzero : L = 0 := by nlinarith [mul_pos hκ (show (0 : ℝ) < 2 by norm_num)]
+    have hvarpos : 0 < z * (1 - z) := mul_pos hz₀ (sub_pos.mpr hz₁)
+    nlinarith only [htransfer, hLzero, hvarpos]
+  have hpositive := mul_pos hκ hνpos
+  have hno := hgap hνpos
+  nlinarith only [ht72, hraw, hno, hpositive]
+
+end UniformSparsestCut
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/GapReduction.lean

@@ -0,0 +1,192 @@
+import OAI.Combinatorics.SparsestCut.FiniteGraph
+import Mathlib.Computability.TuringMachine.Computable
+import Mathlib.Data.List.OfFn
+import Mathlib.Basic.Real.Basic
+import Mathlib.Tactic.Linarith
+
+namespace OAI
+
+/-!
+# Encodings and reductions for uniform sparsest cut
+
+These definitions express the polynomial-time reduction and approximation search problem in
+*Constant-factor hardness of uniform sparsest cut* by OpenAI. The last semantic implication
+uses rational threshold comparison.
+-/
+
+namespace UniformSparsestCut
+
+abbrev BitString := List Bool
+
+/-- A self-delimiting binary block: unary length, terminator, then the bits. -/
+def block (s : BitString) : BitString := List.replicate s.length true ++ false :: s
+
+/-- Binary, not unary, representation of a natural number, with a length prefix. -/
+def encodeNat (n : ℕ) : BitString := block (Computability.encodeNat n)
+
+/-- Signed numerator and positive denominator, both in binary. -/
+def encodeRat (q : ℚ) : BitString :=
+  decide (q.num < 0) :: (encodeNat q.num.natAbs ++ encodeNat q.den)
+
+def encodePair (p : BitString × BitString) : BitString := block p.1 ++ p.2
+
+def encodeBool (b : Bool) : BitString := [b]
+
+/-- A finite-stack, finite-alphabet Turing machine with a polynomial step bound.
+
+Mathlib's `FinTM2` only supplies alphabet finiteness for the input stack.  The
+extra condition here requires *every* stack alphabet to be finite.  Thus one
+cannot store an arbitrary natural number or a function in a single stack symbol.
+-/
+def Polytime {α β : Type} (ea : α → BitString) (eb : β → BitString)
+    (f : α → β) : Prop :=
+  ∃ M : Turing.TM2ComputableInPolyTime ea eb f, ∀ k, Finite (M.tm.Γ k)
+
+/-! ## 3CNF formulas -/
+
+structure Literal where
+  index : ℕ
+  positive : Bool
+  deriving DecidableEq
+
+structure Clause where
+  first : Literal
+  second : Literal
+  third : Literal
+  deriving DecidableEq
+
+/-- Exactly three literals per clause; repetitions are permitted. -/
+abbrev Formula := List Clause
+
+def Literal.eval (v : ℕ → Bool) (l : Literal) : Bool :=
+  if l.positive then v l.index else !(v l.index)
+
+def Clause.eval (v : ℕ → Bool) (c : Clause) : Bool :=
+  c.first.eval v || c.second.eval v || c.third.eval v
+
+def Satisfiable (F : Formula) : Prop :=
+  ∃ v : ℕ → Bool, ∀ c ∈ F, c.eval v = true
+
+def Literal.encode (l : Literal) : BitString := l.positive :: encodeNat l.index
+
+def Clause.encode (c : Clause) : BitString :=
+  c.first.encode ++ c.second.encode ++ c.third.encode
+
+def encodeFormula (F : Formula) : BitString :=
+  encodeNat F.length ++ F.flatMap Clause.encode
+
+def formulaSize (F : Formula) : ℕ := (encodeFormula F).length
+
+def encodeGraph (G : Graph) : BitString :=
+  encodeNat G.n ++ (List.finRange G.n).flatMap (fun i =>
+    (List.finRange G.n).flatMap (fun j => encodeRat (G.capacity i j)))
+
+/-- The rational threshold is additional to the graph. -/
+structure Instance where
+  graph : Graph
+  threshold : ℚ
+  threshold_pos : 0 < threshold
+
+def encodeInstance (I : Instance) : BitString :=
+  block (encodeGraph I.graph) ++ encodeRat I.threshold
+
+/-- This records graph size, every numeric bit length, and total output length.
+The polynomial is quantified *inside* the choice of the fixed factor. -/
+def OutputBound (R : Formula → Instance) (p : Polynomial ℕ) : Prop :=
+  ∀ F, let I := R F
+    I.graph.n + I.graph.n ^ 2 ≤ p.eval (formulaSize F) ∧
+    (∀ i j, (encodeRat (I.graph.capacity i j)).length ≤ p.eval (formulaSize F)) ∧
+    (encodeRat I.threshold).length ≤ p.eval (formulaSize F) ∧
+    (encodeInstance I).length ≤ p.eval (formulaSize F)
+
+/-- Polynomial-time gap reduction for the specific objective above. -/
+def HasGapReduction (C : ℝ) : Prop :=
+  ∃ R : Formula → Instance,
+    Polytime encodeFormula encodeInstance R ∧
+    (∃ p : Polynomial ℕ, OutputBound R p) ∧
+    (∀ F, Satisfiable F → (R F).graph.phi ≤ (R F).threshold) ∧
+    (∀ F, ¬ Satisfiable F → C * ((R F).threshold : ℝ) < ((R F).graph.phi : ℝ))
+
+/-! ## The approximation search problem and NP-hardness -/
+
+/-- A cut is returned as one bit per vertex, in vertex order. -/
+def cutOfBits (G : Graph) (s : BitString) : Finset (Fin G.n) :=
+  Finset.univ.filter (fun i => s[i.val]?.getD false = true)
+
+/-- The approximation algorithm must return a feasible cut, not just an estimated value. -/
+def ApproxAnswer (C : ℝ) (G : Graph) (s : BitString) : Prop :=
+  s.length = G.n ∧ IsCut (cutOfBits G s) ∧
+    (G.cutRatio (cutOfBits G s) : ℝ) ≤ C * (G.phi : ℝ)
+
+abbrev Language := BitString → Prop
+
+/-- NP via a deterministic polynomial-time verifier and a polynomial-length certificate. -/
+def InNP (L : Language) : Prop :=
+  ∃ (V : BitString × BitString → Bool) (p : Polynomial ℕ),
+    Polytime encodePair encodeBool V ∧
+    ∀ x, L x ↔ ∃ w, w.length ≤ p.eval x.length ∧ V (x, w) = true
+
+/-- NP-hardness of the factor-`C` search problem, under one-call polynomial-time
+oracle reductions.  The postprocessor must work for *every* valid approximate
+answer, not just for a helpful choice of answer. -/
+def ApproximationNPHard (C : ℝ) : Prop :=
+  ∀ L : Language, InNP L →
+    ∃ (query : BitString → Graph) (decideAnswer : BitString × BitString → Bool),
+      Polytime id encodeGraph query ∧
+      Polytime encodePair encodeBool decideAnswer ∧
+      ∀ x s, ApproxAnswer C (query x) s → (decideAnswer (x, s) = true ↔ L x)
+
+def bitsOfCut (G : Graph) (S : Finset (Fin G.n)) : BitString :=
+  List.ofFn (fun i : Fin G.n => decide (i ∈ S))
+
+@[simp] theorem bitsOfCut_length (G : Graph) (S : Finset (Fin G.n)) :
+    (bitsOfCut G S).length = G.n := by simp [bitsOfCut]
+
+@[simp] theorem cutOfBits_bitsOfCut (G : Graph) (S : Finset (Fin G.n)) :
+    cutOfBits G (bitsOfCut G S) = S := by
+  ext i
+  simp [cutOfBits, bitsOfCut]
+
+/-- Every graph has a factor-`C` approximation when `C ≥ 1`. -/
+theorem exists_approximation_answer (G : Graph) {C : ℝ} (hC : 1 ≤ C) :
+    ∃ s, ApproxAnswer C G s := by
+  obtain ⟨S, hS, hmin⟩ := G.exists_minimizing_cut
+  refine ⟨bitsOfCut G S, bitsOfCut_length G S, ?_, ?_⟩
+  · simpa using hS
+  · rw [cutOfBits_bitsOfCut, hmin]
+    have hp : (0 : ℝ) ≤ G.phi := by exact_mod_cast G.phi_nonneg
+    simpa using mul_le_mul_of_nonneg_right hC hp
+
+/-- Rational comparison of the returned cut with a fixed rational factor `B`.
+No real-number oracle is used by this predicate. -/
+def decideGap (B : ℚ) (I : Instance) (s : BitString) : Bool :=
+  decide (I.graph.cutRatio (cutOfBits I.graph s) ≤ B * I.threshold)
+
+/-- A gap for a larger rational factor decides satisfiability from every valid
+approximation at the target real factor. -/
+theorem gap_decision_correct {F : Formula} {I : Instance} {C : ℝ} {B : ℚ}
+    (hC : 0 ≤ C) (hCB : C ≤ (B : ℝ))
+    (hyes : Satisfiable F → I.graph.phi ≤ I.threshold)
+    (hno : ¬ Satisfiable F → (B : ℝ) * I.threshold < I.graph.phi)
+    {s : BitString} (hs : ApproxAnswer C I.graph s) :
+    decideGap B I s = true ↔ Satisfiable F := by
+  simp only [decideGap, decide_eq_true_eq]
+  constructor
+  · intro hratio
+    by_contra hunsat
+    have hno' := hno hunsat
+    have hp : (I.graph.phi : ℝ) ≤ I.graph.cutRatio (cutOfBits I.graph s) := by
+      exact_mod_cast I.graph.phi_le_cutRatio hs.2.1
+    have hr : (I.graph.cutRatio (cutOfBits I.graph s) : ℝ) ≤ (B : ℝ) * I.threshold := by
+      exact_mod_cast hratio
+    linarith only [hno', hp, hr]
+  · intro hsat
+    have hp : (I.graph.phi : ℝ) ≤ I.threshold := by exact_mod_cast hyes hsat
+    have ha : (0 : ℝ) ≤ I.threshold := by exact_mod_cast I.threshold_pos.le
+    have hbound := hs.2.2.trans (mul_le_mul_of_nonneg_left hp hC)
+    have hbound' := hbound.trans (mul_le_mul_of_nonneg_right hCB ha)
+    exact_mod_cast hbound'
+
+end UniformSparsestCut
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/GaussianCDF.lean

@@ -0,0 +1,144 @@
+import OAI.Combinatorics.SparsestCut.GaussianPoincare
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.GaussianCDF
+local notation "μ" => gaussianReal 0 1
+def Φ (x : ℝ) : ℝ := cdf μ x
+def φ (x : ℝ) : ℝ := gaussianPDFReal 0 1 x
+
+lemma φ_pos (x : ℝ) : 0 < φ x := gaussianPDFReal_pos _ _ _ (by norm_num)
+lemma φ_contDiff : ContDiff ℝ ∞ φ := by unfold φ gaussianPDFReal; fun_prop
+lemma φ_integrable : Integrable φ := integrable_gaussianPDFReal _ _
+lemma Φ_integral (x : ℝ) : Φ x = ∫ t in Iic x, φ t := by
+  rw [Φ, cdf_eq_real, measureReal_def, gaussianReal_apply_eq_integral _ (by norm_num)]
+  exact ENNReal.toReal_ofReal (integral_nonneg (fun t => gaussianPDFReal_nonneg (0:ℝ) 1 t))
+
+lemma Φ_primitive (x : ℝ) : Φ x = Φ 0 + ∫ t in (0:ℝ)..x, φ t := by
+  rw [Φ_integral, Φ_integral]
+  have h := intervalIntegral.integral_Iic_sub_Iic
+    (φ_integrable.integrableOn (s := Iic 0)) (φ_integrable.integrableOn (s := Iic x))
+  linarith
+
+lemma Φ_hasDeriv (x : ℝ) : HasDerivAt Φ (φ x) x := by
+  have h := intervalIntegral.integral_hasDerivAt_right
+    (φ_contDiff.continuous.intervalIntegrable (0:ℝ) x)
+    φ_contDiff.continuous.stronglyMeasurable.stronglyMeasurableAtFilter
+    φ_contDiff.continuous.continuousAt
+  have h' := h.const_add (Φ 0)
+  convert h' using 1
+  first | rfl | exact funext Φ_primitive
+
+lemma Φ_continuous : Continuous Φ := continuous_iff_continuousAt.mpr (fun x => (Φ_hasDeriv x).continuousAt)
+lemma Φ_strictMono : StrictMono Φ := strictMono_of_deriv_pos (fun x => by rw [(Φ_hasDeriv x).deriv]; exact φ_pos x)
+lemma Φ_mem (x : ℝ) : Φ x ∈ Ioo (0:ℝ) 1 := by
+  constructor
+  · exact (cdf_nonneg μ (x-1)).trans_lt (Φ_strictMono (by linarith))
+  · exact (Φ_strictMono (show x < x+1 by linarith)).trans_le (cdf_le_one μ (x+1))
+
+lemma Φ_surj {y : ℝ} (hy : y ∈ Ioo (0:ℝ) 1) : ∃ x, Φ x = y := by
+  apply intermediate_value_univ₂_eventually₂ (l₁ := atBot) (l₂ := atTop) Φ_continuous continuous_const
+  · exact (tendsto_cdf_atBot μ).eventually (eventually_le_nhds hy.1)
+  · exact (tendsto_cdf_atTop μ).eventually (eventually_ge_nhds hy.2)
+
+lemma Φ_map : (μ).map Φ = volume.restrict (Ioo (0:ℝ) 1) := by
+  apply Measure.ext_of_Iic
+  intro y
+  rw [Measure.map_apply Φ_continuous.measurable measurableSet_Iic,
+    Measure.restrict_apply measurableSet_Iic]
+  by_cases h0 : y ≤ 0
+  · have he : Φ ⁻¹' Iic y = ∅ := by
+      ext x; simp only [mem_preimage, mem_Iic, mem_empty_iff_false, iff_false]
+      exact not_le.mpr (h0.trans_lt (Φ_mem x).1)
+    have he' : Iic y ∩ Ioo (0:ℝ) 1 = ∅ := by ext x; simp only [mem_inter_iff, mem_Iic, mem_Ioo, mem_empty_iff_false, iff_false]; grind
+    rw [he, he', measure_empty, measure_empty]
+  by_cases h1 : 1 ≤ y
+  · have he : Φ ⁻¹' Iic y = univ := by ext x; simp only [mem_preimage, mem_Iic, mem_univ, iff_true]; exact (Φ_mem x).2.le.trans h1
+    have he' : Iic y ∩ Ioo (0:ℝ) 1 = Ioo (0:ℝ) 1 := by ext x; simp only [mem_inter_iff, mem_Iic, mem_Ioo]; constructor <;> grind
+    rw [he, he', measure_univ, Real.volume_Ioo]; norm_num
+  obtain ⟨x,hx⟩ := Φ_surj ⟨lt_of_not_ge h0, lt_of_not_ge h1⟩
+  have he : Φ ⁻¹' Iic y = Iic x := by ext z; simpa only [mem_preimage, mem_Iic, ← hx] using Φ_strictMono.le_iff_le
+  have he' : Iic y ∩ Ioo (0:ℝ) 1 = Ioc (0:ℝ) y := by
+    ext z; simp only [mem_inter_iff, mem_Iic, mem_Ioo, mem_Ioc]; grind
+  rw [he, he', ← ofReal_cdf μ x, Real.volume_Ioc, sub_zero, ← hx]
+  rfl
+
+def ψ (x : ℝ) : ℝ := 2*Φ x-1
+lemma ψ_hasDeriv (x : ℝ) : HasDerivAt ψ (2*φ x) x := (Φ_hasDeriv x).const_mul 2 |>.sub_const 1
+lemma ψ_mem (x : ℝ) : ψ x ∈ Ioo (-1:ℝ) 1 := by
+  have h := Φ_mem x
+  dsimp [ψ]; constructor <;> linarith [h.1,h.2]
+
+lemma ψ_contDiff : ContDiff ℝ 1 ψ := by
+  apply contDiff_one_iff_deriv.mpr
+  constructor
+  · exact fun x => (ψ_hasDeriv x).differentiableAt
+  · have he : deriv ψ = fun x => 2*φ x := funext (fun x => (ψ_hasDeriv x).deriv)
+    rw [he]
+    exact continuous_const.mul φ_contDiff.continuous
+
+lemma ψ_deriv_bound (x : ℝ) : |2*φ x| ≤ 1 := by
+  have hs : 0 < Real.sqrt (2*Real.pi) := Real.sqrt_pos.mpr (by positivity)
+  have hs2 := Real.sq_sqrt (show 0 ≤ 2*Real.pi by positivity)
+  have hge : 2 ≤ Real.sqrt (2*Real.pi) := by nlinarith [Real.pi_gt_three]
+  have he : Real.exp (-x^2/2) ≤ 1 := Real.exp_le_one_iff.mpr (by nlinarith [sq_nonneg x])
+  have he0 : 0 ≤ Real.exp (-x^2/2) := (Real.exp_pos _).le
+  rw [abs_of_pos (mul_pos (by norm_num : (0:ℝ)<2) (φ_pos x))]
+  change 2*((Real.sqrt (2*Real.pi*1))⁻¹*Real.exp (-(x-0)^2/(2*1))) ≤ 1
+  simp only [mul_one, sub_zero]
+  calc
+    _ = (Real.sqrt (2*Real.pi))⁻¹*(2*Real.exp (-x^2/2)) := by ring
+    _ ≤ 1 := (inv_mul_le_iff₀ hs).mpr (by nlinarith)
+
+def uniform : Measure ℝ := (2:ℝ��0∞)⁻¹ • volume.restrict (Ioo (-1:ℝ) 1)
+
+lemma ψ_map : (μ).map ψ = uniform := by
+  apply Measure.ext_of_Iic
+  intro y
+  rw [Measure.map_apply ψ_contDiff.continuous.measurable measurableSet_Iic]
+  change μ (ψ ⁻¹' Iic y) = (2:ℝ≥0∞)⁻¹ * (volume.restrict (Ioo (-1:ℝ) 1)) (Iic y)
+  rw [Measure.restrict_apply measurableSet_Iic]
+  by_cases h0 : y ≤ -1
+  · have he : ψ ⁻¹' Iic y = ∅ := by
+      ext x; simp only [mem_preimage, mem_Iic, mem_empty_iff_false, iff_false]
+      exact not_le.mpr (h0.trans_lt (ψ_mem x).1)
+    have he' : Iic y ∩ Ioo (-1:ℝ) 1 = ∅ := by
+      ext x; simp only [mem_inter_iff, mem_Iic, mem_Ioo, mem_empty_iff_false, iff_false]; grind
+    simp [he,he']
+  by_cases h1 : 1 ≤ y
+  · have he : ψ ⁻¹' Iic y = univ := by
+      ext x; simp only [mem_preimage, mem_Iic, mem_univ, iff_true]
+      exact (ψ_mem x).2.le.trans h1
+    have he' : Iic y ∩ Ioo (-1:ℝ) 1 = Ioo (-1:ℝ) 1 := by
+      ext x; simp only [mem_inter_iff, mem_Iic, mem_Ioo]; constructor <;> grind
+    rw [he,he',measure_univ,Real.volume_Ioo]; norm_num;
+    exact (ENNReal.inv_mul_cancel (by norm_num) (by norm_num)).symm
+  have hy : (y+1)/2 ∈ Ioo (0:ℝ) 1 := by constructor <;> linarith
+  obtain ⟨x,hx⟩ := Φ_surj hy
+  have he : ψ ⁻¹' Iic y = Iic x := by
+    ext z
+    simp only [mem_preimage, mem_Iic, ψ]
+    rw [show y = 2*Φ x-1 by linarith]
+    rw [show 2*Φ z-1 ≤ 2*Φ x-1 ↔ Φ z ≤ Φ x by constructor <;> intro hn <;> linarith]
+    exact Φ_strictMono.le_iff_le
+  have he' : Iic y ∩ Ioo (-1:ℝ) 1 = Ioc (-1:ℝ) y := by
+    ext z; simp only [mem_inter_iff, mem_Iic, mem_Ioo, mem_Ioc]; grind
+  rw [he,he',← ofReal_cdf μ x,Real.volume_Ioc]
+  change ENNReal.ofReal (Φ x) = (2:ℝ≥0∞)⁻¹ * ENNReal.ofReal (y- -1)
+  rw [hx,show y- -1 = y+1 by ring,ENNReal.ofReal_div_of_pos (by norm_num : (0:ℝ)<2)]
+  simp [div_eq_mul_inv,mul_comm]
+
+instance uniform_probability : IsProbabilityMeasure uniform := by
+  rw [← ψ_map]
+  infer_instance
+
+end UniformSparsestCut.GaussianCDF
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/GaussianNonparallel.lean

@@ -0,0 +1,116 @@
+import OAI.Combinatorics.SparsestCut.Directions
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.GaussianNonparallel
+
+variable {m : ℕ}
+local notation "E" => EuclideanSpace ℝ (Fin m)
+local notation "μ" => stdGaussian E
+
+lemma gaussian_inner_zero_measure (v : E) (hv : v ≠ 0) :
+    (stdGaussian E) {x | inner ℝ v x = 0} = 0 := by
+  let c : ℝ≥0 := ⟨‖v‖^2, sq_nonneg _⟩
+  have hc : c ≠ 0 := by
+    intro h
+    have := congrArg (fun x : ℝ≥0 => (x : ℝ)) h
+    change ‖v‖^2 = 0 at this
+    exact hv (norm_eq_zero.mp (sq_eq_zero_iff.mp this))
+  let := nullSingletonClass_gaussianReal («μ» := 0) hc
+  have hmap : (stdGaussian E).map (fun x => inner ℝ v x) = gaussianReal 0 c := by
+    have h := IsGaussian.map_eq_gaussianReal («μ» := stdGaussian E) (innerSL ℝ v)
+    simp only [integral_strongDual_stdGaussian, variance_dual_stdGaussian,
+      innerSL_apply_norm] at h
+    convert h using 2
+    · rfl
+    · apply NNReal.eq
+      change ‖v‖^2 = ((‖v‖^2).toNNReal : ℝ)
+      simp
+  have h := congrArg (fun ν : Measure ℝ => ν {0}) hmap
+  rw [Measure.map_apply (by fun_prop) (measurableSet_singleton _), measure_singleton] at h
+  exact h
+
+lemma gaussian_coordinate_ne (i : Fin m) : ∀ᵐ x : E ∂μ, x i ≠ 0 := by
+  have hv : (EuclideanSpace.single i 1 : E) ≠ 0 := by
+    intro h
+    have hh := congrArg (fun x : E => x i) h
+    simp at hh
+  have h := gaussian_inner_zero_measure (EuclideanSpace.single i 1) hv
+  apply ae_iff.mpr
+  simpa [EuclideanSpace.inner_single_left] using h
+
+def cross (i j : Fin m) (x y : E) : ℝ := x i * y j - x j * y i
+
+lemma gaussian_cross_zero_measure (i j : Fin m) (hij : i ≠ j) :
+    ((μ).prod μ) {z : E × E | cross i j z.1 z.2 = 0} = 0 := by
+  rw [Measure.prod_apply (by unfold cross; measurability)]
+  apply lintegral_eq_zero_of_ae_eq_zero
+  filter_upwards [gaussian_coordinate_ne i] with x hx
+  let v : E := EuclideanSpace.single j (x i) - EuclideanSpace.single i (x j)
+  have hv : v ≠ 0 := by
+    intro h
+    have hh := congrArg (fun x : E => x j) h
+    have hh' : x i = 0 := by simpa [v, PiLp.single_apply, hij, Ne.symm hij] using hh
+    exact hx hh'
+  have hid (y : E) : inner ℝ v y = cross i j x y := by
+    simp [v, cross, inner_sub_left, EuclideanSpace.inner_single_left]
+  simpa only [preimage_ofPred_eq, hid, Pi.zero_apply] using gaussian_inner_zero_measure v hv
+
+lemma ae_cross_ne (i j : Fin m) (hij : i ≠ j) :
+    ∀ᵐ z : E × E ∂(μ).prod μ, cross i j z.1 z.2 ≠ 0 := by
+  apply ae_iff.mpr
+  simpa only [not_not] using gaussian_cross_zero_measure i j hij
+
+lemma iid_cross_ne {N : ℕ} (i j : Fin m) (hij : i ≠ j) (a b : Fin N) (hab : a ≠ b) :
+    ∀ᵐ g : Fin N → E ∂Measure.pi (fun _ => μ), cross i j (g a) (g b) ≠ 0 := by
+  let ν := Measure.pi (fun _ : Fin N => μ)
+  have hind : iIndepFun (fun k (g : Fin N → E) => g k) ν :=
+    iIndepFun_pi («μ» := fun _ : Fin N => μ) (fun _ => aemeasurable_id)
+  have hmap := (hind.indepFun hab).map_prod_eq_prod_map_map
+    (measurable_pi_apply a).aemeasurable (measurable_pi_apply b).aemeasurable
+  rw [(measurePreserving_eval (fun _ : Fin N => μ) a).map_eq,
+    (measurePreserving_eval (fun _ : Fin N => μ) b).map_eq] at hmap
+  have hh := congrArg (fun ν : Measure (E × E) => ν {z | cross i j z.1 z.2 = 0}) hmap
+  rw [Measure.map_apply (by fun_prop) (by unfold cross; measurability),
+    gaussian_cross_zero_measure i j hij] at hh
+  apply ae_iff.mpr
+  simpa only [ν, preimage_ofPred_eq, not_not] using hh
+
+lemma iid_pairwise_nonparallel {N : ℕ} (hm : 2 ≤ m) :
+    ∀ᵐ g : Fin N → E ∂Measure.pi (fun _ => μ),
+      ∀ a b, a ≠ b → ∀ t : ℝ, g a ≠ t • g b := by
+  let i : Fin m := ⟨0, by omega⟩
+  let j : Fin m := ⟨1, by omega⟩
+  have hij : i ≠ j := by intro h; have := congrArg Fin.val h; simp [i,j] at this
+  have hh : ∀ a b : Fin N, ∀ᵐ g : Fin N → E ∂Measure.pi (fun _ => μ),
+      a ≠ b → cross i j (g a) (g b) ≠ 0 := by
+    intro a b
+    by_cases hab : a = b
+    · exact ae_of_all _ (fun _ hn => (hn hab).elim)
+    · filter_upwards [iid_cross_ne i j hij a b hab] with g hg using fun _ => hg
+  have hall := (ae_all_iff.mpr (fun a => ae_all_iff.mpr (hh a)))
+  filter_upwards [hall] with g hg
+  intro a b hab t h
+  apply hg a b hab
+  rw [h]
+  simp [cross]
+  ring
+
+lemma charts_pairwise_nonparallel {N S : ℕ} (hm : 2 ≤ m) :
+    ∀ᵐ g : Fin S → Fin N → E ∂Measure.pi (fun _ => Measure.pi (fun _ => μ)),
+      ∀ s a b, a ≠ b → ∀ t : ℝ, g s a ≠ t • g s b := by
+  apply ae_all_iff.mpr
+  intro s
+  exact (measurePreserving_eval (fun _ : Fin S => Measure.pi (fun _ : Fin N => μ)) s).quasiMeasurePreserving.ae
+    (iid_pairwise_nonparallel hm)
+
+end UniformSparsestCut.GaussianNonparallel
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/GaussianPoincare.lean

@@ -0,0 +1,155 @@
+import OAI.Combinatorics.SparsestCut.ContractionCore
+
+namespace OAI
+
+universe u1
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.GaussianPoincare
+variable {E : Type u1} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
+local notation "μ" => stdGaussian E
+
+lemma gaussian_dual_sq (L : StrongDual ℝ E) : ∫ x, (L x)^2 ∂μ = ‖L‖^2 := by
+  have h := variance_dual_stdGaussian L
+  rw [variance_eq_integral (by fun_prop), integral_strongDual_stdGaussian] at h
+  simpa only [sub_zero] using h
+
+lemma gaussian_dual_abs (L : StrongDual ℝ E) : ∫ x, |L x| ∂μ ≤ ‖L‖ := by
+  by_cases hz : L = 0
+  · simp [hz]
+  have h0 : 0 < ‖L‖ := norm_pos_iff.mpr hz
+  have hL : MemLp (fun x => L x) 2 μ := IsGaussian.memLp_dual _ _ _ (by norm_num)
+  have hi : Integrable (fun x => (|L x|-‖L‖)^2) μ := by
+    simpa using (hL.norm.sub (memLp_const ‖L‖)).integrable_sq
+  have hn : 0 ≤ ∫ x, (|L x|-‖L‖)^2 ∂μ := integral_nonneg (fun _ => sq_nonneg _)
+  have he : (∫ x, (|L x|-‖L‖)^2 ∂μ) = 2*‖L‖^2-2*‖L‖*(∫ x, |L x| ∂μ) := by
+    simp_rw [sub_sq, sq_abs]
+    have hc := ((hL.integrable (by norm_num)).abs.const_mul 2).mul_const ‖L‖
+    rw [integral_add (f := fun x => L x^2-2*|L x| *‖L‖)
+      (g := fun _ => ‖L‖^2) (hL.integrable_sq.sub hc) (integrable_const _),
+      integral_sub (f := fun x => L x^2) (g := fun x => 2*|L x| *‖L‖) hL.integrable_sq hc]
+    rw [gaussian_dual_sq]
+    simp only [integral_const, measureReal_def, measure_univ, ENNReal.toReal_one, smul_eq_mul, one_mul]
+    rw [integral_mul_const, integral_const_mul]
+    ring
+  rw [he] at hn
+  nlinarith
+
+noncomputable def path (t : ℝ) (z : E × E) : E := Real.cos t • z.1 + Real.sin t • z.2
+noncomputable def tangent (t : ℝ) (z : E × E) : E := -Real.sin t • z.1 + Real.cos t • z.2
+
+omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in
+lemma path_hasDeriv (t : ℝ) (z : E × E) : HasDerivAt (fun u => path u z) (tangent t z) t := by
+  exact ((Real.hasDerivAt_cos t).smul_const z.1).add ((Real.hasDerivAt_sin t).smul_const z.2)
+
+omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in
+lemma tangent_norm_le (t : ℝ) (z : E × E) : ‖tangent t z‖ ≤ ‖z.1‖ + ‖z.2‖ := by
+  calc
+    _ ≤ ‖-Real.sin t • z.1‖ + ‖Real.cos t • z.2‖ := norm_add_le _ _
+    _ = |Real.sin t| *‖z.1‖ + |Real.cos t| *‖z.2‖ := by simp [norm_smul, Real.norm_eq_abs]
+    _ ≤ 1*‖z.1‖ + 1*‖z.2‖ := add_le_add (mul_le_mul_of_nonneg_right (Real.abs_sin_le_one _) (norm_nonneg _))
+      (mul_le_mul_of_nonneg_right (Real.abs_cos_le_one _) (norm_nonneg _))
+    _ = _ := by ring
+
+lemma integral_rotation (f : E × E → ℝ) (hf : AEStronglyMeasurable f ((μ).prod μ)) (t : ℝ) :
+    ∫ z, f (path t z, tangent t z) ∂((μ).prod μ) = ∫ z, f z ∂((μ).prod μ) := by
+  have hr := IsGaussian.map_rotation_eq_self (integral_id_stdGaussian (E := E)) t
+  have hm : AEMeasurable (ContinuousLinearMap.rotation (E := E) t) ((μ).prod μ) := by fun_prop
+  have h := integral_map hm (hr ▸ hf)
+  exact h.symm.trans (congrArg (fun ν => ∫ z, f z ∂ν) hr)
+
+lemma derivative_integrable (h : E → ℝ) (hh : ContDiff ℝ 1 h) {M : ℝ} (_hM : 0 ≤ M)
+    (hb : ∀ x, ‖fderiv ℝ h x‖ ≤ M) :
+    Integrable (fun z : E × E => |fderiv ℝ h z.1 z.2|) ((μ).prod μ) := by
+  have hi : Integrable (fun z : E × E => M*‖z.2‖) ((μ).prod μ) :=
+    ((IsGaussian.integrable_id («μ» := μ)).norm.comp_snd μ).const_mul M
+  apply hi.mono' (by have hc := hh.continuous_fderiv (by norm_num); fun_prop)
+  filter_upwards with z
+  simp only [Real.norm_eq_abs, abs_abs]
+  exact (ContinuousLinearMap.le_opNorm _ _).trans (mul_le_mul_of_nonneg_right (hb _) (norm_nonneg _))
+
+lemma derivative_average_bound (h : E → ℝ) (hh : ContDiff ℝ 1 h) {M : ℝ} (hM : 0 ≤ M)
+    (hb : ∀ x, ‖fderiv ℝ h x‖ ≤ M) :
+    (∫ z : E × E, |fderiv ℝ h z.1 z.2| ∂((μ).prod μ)) ≤ ∫ x, ‖fderiv ℝ h x‖ ∂μ := by
+  rw [integral_prod _ (derivative_integrable h hh hM hb)]
+  refine integral_mono_ae (derivative_integrable h hh hM hb).integral_prod_left ?_ ?_
+  · exact (integrable_const M).mono' (by have hc := hh.continuous_fderiv (by norm_num); fun_prop)
+      (ae_of_all _ fun x => by simpa using hb x)
+  · filter_upwards with x using gaussian_dual_abs (fderiv ℝ h x)
+
+omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in
+lemma endpoint_bound (h : E → ℝ) (hh : ContDiff ℝ 1 h) (z : E × E) :
+    |h z.1-h z.2| ≤ ∫ t in (0 : ℝ)..(Real.pi/2),
+      |fderiv ℝ h (path t z) (tangent t z)| := by
+  have hd (t : ℝ) : HasDerivAt (fun t => h (path t z))
+      (fderiv ℝ h (path t z) (tangent t z)) t :=
+    ((hh.differentiable (by norm_num) _).hasFDerivAt).comp_hasDerivAt t (path_hasDeriv t z)
+  have hc : Continuous (fun t => fderiv ℝ h (path t z) (tangent t z)) := by
+    have hD := hh.continuous_fderiv (by norm_num)
+    unfold path tangent
+    fun_prop
+  have he := intervalIntegral.integral_eq_sub_of_hasDerivAt (fun t _ => hd t)
+    (hc.intervalIntegrable 0 (Real.pi/2))
+  have hn := intervalIntegral.abs_integral_le_integral_abs («μ» := volume)
+    (f := fun t => fderiv ℝ h (path t z) (tangent t z))
+    (by positivity : (0 : ℝ) ≤ Real.pi/2)
+  rw [he] at hn
+  simpa [path, abs_sub_comm] using hn
+
+lemma rotation_first_moment (h : E → ℝ) (hh : ContDiff ℝ 1 h)
+    {M B : ℝ} (hM : 0 ≤ M) (hb : ∀ x, ‖fderiv ℝ h x‖ ≤ M)
+    (hB : ∀ x, ‖h x‖ ≤ B) :
+    (∫ z : E × E, |h z.1-h z.2| ∂((μ).prod μ)) ≤
+      (Real.pi/2) * ∫ x, ‖fderiv ℝ h x‖ ∂μ := by
+  let b : ℝ := Real.pi/2
+  have hb0 : 0 ≤ b := by dsimp [b]; positivity
+  let ν := volume.restrict (Ioc (0 : ℝ) b)
+  have : IsFiniteMeasure ν := by dsimp [ν]; infer_instance
+  let g (t : ℝ) (z : E × E) := |fderiv ℝ h (path t z) (tangent t z)|
+  have hc : Continuous (Function.uncurry g) := by
+    have hD := hh.continuous_fderiv (by norm_num)
+    dsimp [g, Function.uncurry, path, tangent]
+    fun_prop
+  have hnorm : Integrable (fun z : E × E => ‖z.1‖+‖z.2‖) ((μ).prod μ) :=
+    ((IsGaussian.integrable_id («μ» := stdGaussian E)).norm.comp_fst _).add
+      ((IsGaussian.integrable_id («μ» := stdGaussian E)).norm.comp_snd _)
+  have hI : Integrable (Function.uncurry g) (ν.prod ((μ).prod μ)) := by
+    apply ((hnorm.const_mul M).comp_snd ν).mono' hc.aestronglyMeasurable
+    filter_upwards with x
+    dsimp [g, Function.uncurry]
+    simp only [ abs_abs]
+    exact (ContinuousLinearMap.le_opNorm _ _).trans
+      ((mul_le_mul_of_nonneg_right (hb _) (norm_nonneg _)).trans
+        (mul_le_mul_of_nonneg_left (tangent_norm_le _ _) hM))
+  have hInt : Integrable (fun z => ∫ t in (0 : ℝ)..b, g t z) ((μ).prod μ) := by
+    simpa only [intervalIntegral.integral_of_le hb0, ν, Function.uncurry_apply_pair] using hI.integral_prod_right
+  have hLeft : Integrable (fun z : E × E => |h z.1-h z.2|) ((μ).prod μ) := by
+    apply (integrable_const (2*B)).mono' (by fun_prop)
+    filter_upwards with z
+    simpa only [Real.norm_eq_abs, abs_abs] using
+      (norm_sub_le (h z.1) (h z.2)).trans (by linarith [hB z.1,hB z.2])
+  have hrotate (t : ℝ) : (∫ z, g t z ∂((μ).prod μ)) =
+      ∫ z : E × E, |fderiv ℝ h z.1 z.2| ∂((μ).prod μ) := by
+    exact integral_rotation _ (derivative_integrable h hh hM hb).aestronglyMeasurable t
+  calc
+    _ ≤ ∫ z : E × E, (∫ t in (0 : ℝ)..b, g t z) ∂((μ).prod μ) :=
+      integral_mono hLeft hInt (endpoint_bound h hh)
+    _ = ∫ t in (0 : ℝ)..b, ∫ z, g t z ∂((μ).prod μ) := by
+      symm
+      apply intervalIntegral_integral_swap
+      simpa only [uIoc_of_le hb0] using hI
+    _ = b * ∫ z : E × E, |fderiv ℝ h z.1 z.2| ∂((μ).prod μ) := by
+      simp_rw [hrotate]
+      simp [intervalIntegral.integral_const, smul_eq_mul]
+    _ ≤ _ := mul_le_mul_of_nonneg_left (derivative_average_bound h hh hM hb) hb0
+
+end UniformSparsestCut.GaussianPoincare
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/GaussianTools.lean

@@ -0,0 +1,514 @@
+import OAI.Combinatorics.SparsestCut.Model
+
+namespace OAI
+
+universe u1 u2
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.GaussianTools
+
+section Concentration
+variable {Ω : Type u1} [MeasurableSpace Ω] {μ : Measure Ω} [IsProbabilityMeasure μ]
+
+lemma subgaussian_abs_tail {X : Ω → ℝ} {c : ℝ≥0}
+    (hX : HasSubgaussianMGF X c μ) {u : ℝ} (hu : 0 ≤ u) :
+    μ.real {sample | u < |X sample|} ≤ 2 * Real.exp (-u^2 / (2 * c)) := by
+  have hsub : {sample | u < |X sample|} ⊆ {sample | u ≤ X sample} ∪ {sample | u ≤ -X sample} := by
+    intro sample hω
+    change u < |X sample| at hω
+    rcases lt_abs.mp hω with h | h
+    · exact Or.inl h.le
+    · exact Or.inr h.le
+  calc
+    _ ≤ μ.real ({sample | u ≤ X sample} ∪ {sample | u ≤ -X sample}) := measureReal_mono hsub
+    _ ≤ μ.real {sample | u ≤ X sample} + μ.real {sample | u ≤ -X sample} := measureReal_union_le _ _
+    _ ≤ Real.exp (-u^2 / (2 * c)) + Real.exp (-u^2 / (2 * c)) :=
+      add_le_add (hX.measure_ge_le hu) (hX.neg.measure_ge_le hu)
+    _ = _ := by ring
+
+theorem bounded_concentration {n : ℕ} (hn : 0 < n) (X : Fin n → Ω → ℝ)
+    (hmeas : ∀ i, AEMeasurable (X i) μ) (hind : iIndepFun X μ)
+    {B : ℝ} (hB : 0 < B) (hbound : ∀ i, ∀ᵐ sample ∂μ, |X i sample| ≤ B)
+    {u : ℝ} (hu : 0 ≤ u) :
+    μ.real {sample | u < |(∑ i, (X i sample - ∫ z, X i z ∂μ)) / (n : ℝ)|} ≤
+      2 * Real.exp (-(n : ℝ) * u^2 / (2 * B^2)) := by
+  classical
+  let Y : Fin n → Ω → ℝ := fun i sample => X i sample - ∫ z, X i z ∂μ
+  have hY (i : Fin n) : HasSubgaussianMGF (Y i) ⟨B^2, sq_nonneg B⟩ μ := by
+    have hh := hasSubgaussianMGF_of_mem_Icc (hmeas i)
+      (show ∀ᵐ sample ∂μ, X i sample ∈ Icc (-B) B by
+        filter_upwards [hbound i] with sample hω using abs_le.mp hω)
+    have hc : ((‖B - -B‖₊ / 2) ^ 2) = (⟨B^2, sq_nonneg B⟩ : ℝ≥0) := by
+      ext
+      change (‖B - -B‖ / 2) ^ 2 = B ^ 2
+      rw [Real.norm_eq_abs]
+      rw [abs_of_nonneg (by linarith : 0 ≤ B - -B)]
+      ring
+    exact (congrArg (fun variance : ℝ≥0 => HasSubgaussianMGF (Y i) variance μ) hc).mp hh
+  have hYi : iIndepFun Y μ := hind.comp (fun i z => z - ∫ z, X i z ∂μ) (fun i => by fun_prop)
+  have hsum := HasSubgaussianMGF.sum_of_iIndepFun hYi
+    (s := Finset.univ) (fun i hi => hY i)
+  have havg := hsum.const_mul ((n : ℝ)⁻¹)
+  have htail := subgaussian_abs_tail havg hu
+  have hn0 : (n : ℝ) ≠ 0 := by exact_mod_cast hn.ne'
+  convert htail using 1
+  · congr 1; ext sample
+    simp only [Y, div_eq_mul_inv, mul_comm]
+  · congr 2
+    have hc : ((⟨(n : ℝ)⁻¹ ^ 2, sq_nonneg _⟩ : ℝ≥0) *
+        ∑ _ : Fin n, (⟨B^2, sq_nonneg _⟩ : ℝ≥0) : ℝ≥0) =
+        (⟨B^2 / n, div_nonneg (sq_nonneg _) (by positivity)⟩ : ℝ≥0) := by
+      apply NNReal.eq
+      change (n : ℝ)⁻¹ ^ 2 * ↑(∑ _ : Fin n, (⟨B^2, sq_nonneg _⟩ : ℝ≥0)) = B^2 / n
+      simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin]
+      change (n : ℝ)⁻¹ ^ 2 * ↑(n • (⟨B^2, sq_nonneg _⟩ : ℝ≥0)) = B^2 / n
+      simp only [nsmul_eq_mul]
+      change (n : ℝ)⁻¹ ^ 2 * ((n : ℝ) * B^2) = B^2 / n
+      field_simp
+
+    change -(n : ℝ) * u^2 / (2 * B^2) =
+      -u^2 / (2 * (((⟨(n : ℝ)⁻¹ ^ 2, sq_nonneg _⟩ : ℝ≥0) *
+        ∑ _ : Fin n, (⟨B^2, sq_nonneg _⟩ : ℝ≥0) : ℝ≥0) : ℝ))
+    rw [hc]
+    change -(n : ℝ) * u^2 / (2 * B^2) = -u^2 / (2 * (B^2 / n))
+    field_simp
+
+end Concentration
+
+section Fourier
+variable {E : Type u2} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
+
+lemma gaussian_cos_integrable (w : E) :
+    Integrable (fun g : E => Real.cos (inner ℝ g w)) (stdGaussian E) := by
+  apply Integrable.mono' (integrable_const (1 : ℝ))
+  · exact (by fun_prop : Continuous (fun g : E => Real.cos (inner ℝ g w))).aestronglyMeasurable
+  · exact ae_of_all _ (fun g => by simpa only [Real.norm_eq_abs] using Real.abs_cos_le_one _)
+
+lemma gaussian_cos (w : E) :
+    (∫ g : E, Real.cos (inner ℝ g w) ∂stdGaussian E) =
+      Real.exp (-‖w‖^2 / 2) := by
+  have hh := congrArg Complex.re (charFun_stdGaussian w)
+  rw [charFun_apply] at hh
+  have hf : Integrable (fun g : E => Complex.exp ((inner ℝ g w : ℂ) * Complex.I))
+      (stdGaussian E) := by
+    apply Integrable.mono' (integrable_const (1 : ℝ))
+    · exact (by fun_prop : Continuous (fun g : E => Complex.exp ((inner ℝ g w : ℂ) * Complex.I))).aestronglyMeasurable
+    · exact ae_of_all _ (fun g => by simp)
+  have hi := Complex.reCLM.integral_comp_comm hf
+  change (∫ g : E, (Complex.exp ((inner ℝ g w : ℂ) * Complex.I)).re ∂stdGaussian E) =
+    (∫ g : E, Complex.exp ((inner ℝ g w : ℂ) * Complex.I) ∂stdGaussian E).re at hi
+  rw [← hi] at hh
+  simpa [Complex.exp_re, pow_two, Complex.mul_re, Complex.mul_im] using hh
+
+lemma gaussian_linear_sin_integrable (w v : E) :
+    Integrable (fun g : E => inner ℝ g v * Real.sin (inner ℝ g w)) (stdGaussian E) := by
+  apply Integrable.mono' ((IsGaussian.integrable_id (μ := stdGaussian E)).norm.mul_const ‖v‖)
+  · exact (by fun_prop : Continuous (fun g : E => inner ℝ g v * Real.sin (inner ℝ g w))).aestronglyMeasurable
+  · filter_upwards [] with g
+    simp only [Real.norm_eq_abs, abs_mul]
+    calc
+      _ ≤ |inner ℝ g v| * 1 := mul_le_mul_of_nonneg_left (Real.abs_sin_le_one _) (abs_nonneg _)
+      _ ≤ ‖g‖ * ‖v‖ := by simpa using abs_real_inner_le_norm g v
+
+lemma gaussian_linear_sin (w v : E) :
+    (∫ g : E, inner ℝ g v * Real.sin (inner ℝ g w) ∂stdGaussian E) =
+      inner ℝ w v * Real.exp (-‖w‖^2 / 2) := by
+  let F : ℝ → E → ℝ := fun t g => Real.cos (inner ℝ g (w + t • v))
+  let F' : ℝ → E → ℝ := fun t g => -Real.sin (inner ℝ g (w + t • v)) * inner ℝ g v
+  have hd (g : E) (t : ℝ) : HasDerivAt (fun t => F t g) (F' t g) t := by
+    have h := ((hasDerivAt_const t w).add ((hasDerivAt_id t).smul_const v))
+    have hh := ((hasDerivAt_const t g).inner ℝ h).cos
+    simpa [F, F'] using hh
+  have hbound (g : E) (t : ℝ) : ‖F' t g‖ ≤ ‖g‖ * ‖v‖ := by
+    simp only [F', Real.norm_eq_abs, abs_mul, abs_neg]
+    calc
+      _ ≤ 1 * |inner ℝ g v| := mul_le_mul_of_nonneg_right (Real.abs_sin_le_one _) (abs_nonneg _)
+      _ ≤ ‖g‖ * ‖v‖ := by simpa using abs_real_inner_le_norm g v
+  have hi := hasDerivAt_integral_of_dominated_loc_of_deriv_le
+    (μ := stdGaussian E) (F := F) (F' := F') (bound := fun g => ‖g‖ * ‖v‖)
+    (s := Set.univ) (x₀ := (0 : ℝ)) (Filter.univ_mem)
+    (Filter.Eventually.of_forall (fun t =>
+      (show Continuous (F t) by dsimp [F]; fun_prop).aestronglyMeasurable))
+    (by simpa [F] using gaussian_cos_integrable w)
+    (show AEStronglyMeasurable (F' 0) (stdGaussian E) from
+      (show Continuous (F' 0) by dsimp [F']; fun_prop).aestronglyMeasurable)
+    (ae_of_all _ (fun g t _ => hbound g t))
+    ((IsGaussian.integrable_id (μ := stdGaussian E)).norm.mul_const ‖v‖)
+    (ae_of_all _ (fun g t _ => hd g t))
+  have ht := (((hasDerivAt_const (0 : ℝ) w).add
+    ((hasDerivAt_id (0 : ℝ)).smul_const v)).norm_sq.neg.div_const 2).exp
+  have heq : (fun t => ∫ g : E, F t g ∂stdGaussian E) =
+      (fun t : ℝ => Real.exp (-‖w + t • v‖^2 / 2)) := by
+    funext t
+    exact gaussian_cos _
+  rw [heq] at hi
+  have huniq := hi.2.unique ht
+  simp only [F', zero_smul, add_zero, one_smul, zero_add] at huniq
+  have hneg : (∫ g : E, -Real.sin (inner ℝ g w) * inner ℝ g v ∂stdGaussian E) =
+      -(∫ g : E, inner ℝ g v * Real.sin (inner ℝ g w) ∂stdGaussian E) := by
+    rw [← integral_neg]
+    congr 1
+    funext g
+    ring
+  rw [hneg] at huniq
+  dsimp at huniq
+  simp only [zero_smul, add_zero] at huniq
+  nlinarith
+
+lemma gaussian_vector_sin_integrable (w : E) :
+    Integrable (fun g : E => Real.sin (inner ℝ g w) • g) (stdGaussian E) := by
+  exact (IsGaussian.integrable_id (μ := stdGaussian E)).bdd_smul 1
+    (by fun_prop) (ae_of_all _ (fun g => by simpa using Real.abs_sin_le_one (inner ℝ g w)))
+
+lemma gaussian_vector_sin (w : E) :
+    (∫ g : E, Real.sin (inner ℝ g w) • g ∂stdGaussian E) =
+      Real.exp (-‖w‖^2 / 2) • w := by
+  apply ext_inner_left ℝ
+  intro v
+  rw [← integral_inner (gaussian_vector_sin_integrable w), inner_smul_right]
+  simp only [inner_smul_right]
+  simpa only [real_inner_comm, mul_comm] using gaussian_linear_sin w v
+
+lemma gaussian_inner_law (v : E) :
+    (stdGaussian E).map (fun g => inner ℝ v g) =
+      gaussianReal 0 (⟨‖v‖^2, sq_nonneg _⟩ : ℝ≥0) := by
+  have h := IsGaussian.map_eq_gaussianReal (μ := stdGaussian E) (innerSL ℝ v)
+  simp only [integral_strongDual_stdGaussian, variance_dual_stdGaussian,
+    innerSL_apply_norm] at h
+  have hvariance : (‖v‖^2).toNNReal = (⟨‖v‖^2, sq_nonneg _⟩ : ℝ≥0) :=
+    Real.toNNReal_of_nonneg (sq_nonneg _)
+  exact h.trans (congrArg (gaussianReal 0) hvariance)
+
+lemma gaussian_inner_sq (v : E) :
+    (∫ g : E, (inner ℝ v g)^2 ∂stdGaussian E) = ‖v‖^2 := by
+  have h := variance_dual_stdGaussian (innerSL ℝ v)
+  rw [variance_eq_integral (by fun_prop), integral_strongDual_stdGaussian] at h
+  simpa only [sub_zero, innerSL_apply_norm, innerSL_apply_apply] using h
+
+lemma gaussian_inner_subgaussian (v : E) :
+    HasSubgaussianMGF (fun g => inner ℝ v g) (⟨‖v‖^2, sq_nonneg _⟩ : ℝ≥0) (stdGaussian E) where
+  integrable_exp_mul t := by
+    have h := integrable_exp_mul_gaussianReal (μ := 0)
+      (v := (⟨‖v‖^2, sq_nonneg _⟩ : ℝ≥0)) t
+    rw [← gaussian_inner_law v] at h
+    exact (integrable_map_measure h.aestronglyMeasurable (by fun_prop)).mp h
+  mgf_le t := by
+    rw [mgf_gaussianReal ⟨by fun_prop, gaussian_inner_law v⟩]
+    simp
+
+lemma gaussian_inner_tail (v : E) (hv : ‖v‖ = 1) {u : ℝ} (hu : 0 ≤ u) :
+    (stdGaussian E).real {g | u < |inner ℝ v g|} ≤ 2 * Real.exp (-u^2 / 2) := by
+  have h := subgaussian_abs_tail (gaussian_inner_subgaussian v) hu
+  change _ ≤ 2 * Real.exp (-u^2 / (2 * ‖v‖^2)) at h
+  simpa [hv] using h
+
+end Fourier
+section NormTails
+
+lemma gaussian_real_exp_sq (t : ℝ) (ht : t < 1/2) :
+    (∫ x : ℝ, Real.exp (t * x^2) ∂gaussianReal 0 1) =
+      Real.exp (-(1/2 : ℝ) * Real.log (1 - 2*t)) := by
+  rw [integral_gaussianReal_eq_integral_smul (by norm_num : (1 : ℝ≥0) ≠ 0)]
+  have heq (x : ℝ) : gaussianPDFReal 0 1 x * Real.exp (t * x^2) =
+      (Real.sqrt (2 * Real.pi))⁻¹ * Real.exp (-(1/2-t) * x^2) := by
+    simp only [gaussianPDFReal, NNReal.coe_one, mul_one, sub_zero]
+    rw [mul_assoc, ← Real.exp_add]
+    congr 2
+    ring
+  simp_rw [smul_eq_mul, heq]
+  rw [integral_const_mul, integral_gaussian]
+  have hpos : 0 < 1 - 2*t := by linarith
+  have hhalf : 0 < 1/2-t := by linarith
+  have hpi := Real.pi_pos
+  have heq2 : (Real.sqrt (2 * Real.pi))⁻¹ * Real.sqrt (Real.pi / (1/2-t)) =
+      Real.sqrt ((1 - 2*t)⁻¹) := by
+    rw [← Real.sqrt_inv, ← Real.sqrt_mul (inv_nonneg.mpr (by positivity))]
+    congr 1
+    field_simp
+
+  rw [heq2, Real.sqrt_eq_rpow, Real.rpow_def_of_pos (inv_pos.mpr hpos), Real.log_inv]
+  congr 1
+  ring
+
+lemma gaussian_real_exp_sq_integrable (t : ℝ) (ht : t < 1/2) :
+    Integrable (fun x : ℝ => Real.exp (t * x^2)) (gaussianReal 0 1) := by
+  by_contra h
+  have hh := gaussian_real_exp_sq t ht
+  rw [integral_undef h] at hh
+  exact (Real.exp_ne_zero _).symm hh
+
+lemma gaussian_exp_norm_sq {n : ℕ} (t : ℝ) (ht : t < 1/2) :
+    (∫ g : EuclideanSpace ℝ (Fin n), Real.exp (t * ‖g‖^2)
+      ∂stdGaussian (EuclideanSpace ℝ (Fin n))) =
+      Real.exp (-(n : ℝ)/2 * Real.log (1-2*t)) := by
+  rw [← map_pi_eq_stdGaussian]
+  rw [integral_map (by fun_prop) (by fun_prop)]
+  have heq (g : Fin n → ℝ) : Real.exp (t * ‖WithLp.toLp 2 g‖^2) =
+      ∏ i, Real.exp (t * (g i)^2) := by
+    rw [EuclideanSpace.real_norm_sq_eq, Finset.mul_sum, Real.exp_sum]
+  simp_rw [heq]
+  have hp := integral_fintype_prod_eq_pow (ι := Fin n) (μ := gaussianReal 0 1)
+    (fun x : ℝ => Real.exp (t * x^2))
+  rw [Fintype.card_fin] at hp
+  change (∫ x : Fin n → ℝ, ∏ i, Real.exp (t * x i ^ 2) ∂Measure.pi (fun _ => gaussianReal 0 1)) =
+    (∫ x : ℝ, Real.exp (t * x^2) ∂gaussianReal 0 1) ^ n at hp
+  rw [hp, gaussian_real_exp_sq t ht, ← Real.exp_nat_mul]
+  congr 1
+  ring
+
+lemma gaussian_exp_norm_sq_integrable {n : ℕ} (t : ℝ) (ht : t < 1/2) :
+    Integrable (fun g : EuclideanSpace ℝ (Fin n) => Real.exp (t * ‖g‖^2))
+       (stdGaussian (EuclideanSpace ℝ (Fin n))) := by
+  by_contra h
+  have hh := gaussian_exp_norm_sq (n := n) t ht
+  rw [integral_undef h] at hh
+  exact (Real.exp_ne_zero _).symm hh
+
+lemma gaussian_norm_upper {n : ℕ} :
+    (stdGaussian (EuclideanSpace ℝ (Fin n))).real
+      {g | 4 * (n : ℝ) < ‖g‖^2} ≤ Real.exp (-(n : ℝ)/2) := by
+  let μ := stdGaussian (EuclideanSpace ℝ (Fin n))
+  have hmark := mul_meas_ge_le_integral_of_nonneg (μ := μ)
+    (f := fun g => Real.exp ((1/4 : ℝ) * ‖g‖^2))
+    (ae_of_all _ (fun _ => (Real.exp_pos _).le))
+    (gaussian_exp_norm_sq_integrable (1/4) (by norm_num)) (Real.exp n)
+  rw [gaussian_exp_norm_sq (1/4) (by norm_num)] at hmark
+  have hs : {g : EuclideanSpace ℝ (Fin n) | 4 * (n : ℝ) < ‖g‖^2} ⊆
+      {g | Real.exp n ≤ Real.exp ((1/4 : ℝ) * ‖g‖^2)} := by
+    intro g hg
+    apply Real.exp_le_exp.mpr
+    change 4 * (n : ℝ) < ‖g‖^2 at hg
+    linarith
+  have hn : (0 : ℝ) ≤ n := Nat.cast_nonneg _
+  calc
+    _ ≤ μ.real {g | Real.exp n ≤ Real.exp ((1/4 : ℝ) * ‖g‖^2)} := measureReal_mono hs
+    _ ≤ Real.exp (-(n : ℝ)/2 * Real.log (1-2*(1/4 : ℝ))) / Real.exp n :=
+      (le_div_iff₀ (Real.exp_pos _)).mpr (by simpa [mul_comm] using hmark)
+    _ ≤ Real.exp (-(n : ℝ)/2) := by
+      rw [← Real.exp_sub]
+      apply Real.exp_le_exp.mpr
+      have hh := Real.log_le_sub_one_of_pos (by norm_num : (0 : ℝ) < 2)
+      have hl : Real.log (1-2*(1/4 : ℝ)) = -Real.log 2 := by
+        norm_num
+        rw [show (1/2 : ℝ) = (2 : ℝ)⁻¹ by norm_num, Real.log_inv]
+      rw [hl]
+      nlinarith
+
+lemma gaussian_norm_lower {n : ℕ} :
+    (stdGaussian (EuclideanSpace ℝ (Fin n))).real
+      {g | ‖g‖^2 < (n : ℝ)/4} ≤ Real.exp (-(n : ℝ)/8) := by
+  let μ := stdGaussian (EuclideanSpace ℝ (Fin n))
+  have hmark := mul_meas_ge_le_integral_of_nonneg (μ := μ)
+    (f := fun g => Real.exp ((-1/2 : ℝ) * ‖g‖^2))
+    (ae_of_all _ (fun _ => (Real.exp_pos _).le))
+    (gaussian_exp_norm_sq_integrable (-1/2) (by norm_num)) (Real.exp (-(n : ℝ)/8))
+  rw [gaussian_exp_norm_sq (-1/2) (by norm_num)] at hmark
+  have hs : {g : EuclideanSpace ℝ (Fin n) | ‖g‖^2 < (n : ℝ)/4} ⊆
+      {g | Real.exp (-(n : ℝ)/8) ≤ Real.exp ((-1/2 : ℝ) * ‖g‖^2)} := by
+    intro g hg
+    apply Real.exp_le_exp.mpr
+    change ‖g‖^2 < (n : ℝ)/4 at hg
+    linarith
+  have hn : (0 : ℝ) ≤ n := Nat.cast_nonneg _
+  calc
+    _ ≤ μ.real {g | Real.exp (-(n : ℝ)/8) ≤ Real.exp ((-1/2 : ℝ) * ‖g‖^2)} := measureReal_mono hs
+    _ ≤ Real.exp (-(n : ℝ)/2 * Real.log (1-2*(-1/2 : ℝ))) / Real.exp (-(n : ℝ)/8) :=
+      (le_div_iff₀ (Real.exp_pos _)).mpr (by simpa [mul_comm] using hmark)
+    _ ≤ Real.exp (-(n : ℝ)/8) := by
+      rw [← Real.exp_sub]
+      apply Real.exp_le_exp.mpr
+      norm_num only at *
+      have hh := Real.one_sub_inv_le_log_of_pos (by norm_num : (0 : ℝ) < 2)
+      norm_num at hh ⊢
+      nlinarith
+
+lemma gaussian_norm_tail {n : ℕ} :
+    (stdGaussian (EuclideanSpace ℝ (Fin n))).real
+      {g | ‖g‖ ∉ Icc (Real.sqrt n / 2) (2 * Real.sqrt n)} ≤
+      2 * Real.exp (-(n : ℝ)/8) := by
+  have hs : {g : EuclideanSpace ℝ (Fin n) | ‖g‖ ∉ Icc (Real.sqrt n / 2) (2 * Real.sqrt n)} ⊆
+      {g | ‖g‖^2 < (n : ℝ)/4} ∪ {g | 4 * (n : ℝ) < ‖g‖^2} := by
+    intro g hg
+    change ¬(Real.sqrt n / 2 ≤ ‖g‖ ∧ ‖g‖ ≤ 2 * Real.sqrt n) at hg
+    have hsq := Real.sq_sqrt (Nat.cast_nonneg n)
+    have hsqrt := Real.sqrt_nonneg (n : ℝ)
+    have hnorm := norm_nonneg g
+    rcases not_and_or.mp hg with h | h
+    · exact Or.inl (by simp only [mem_ofPred_eq]; nlinarith [lt_of_not_ge h])
+    · exact Or.inr (by simp only [mem_ofPred_eq]; nlinarith [lt_of_not_ge h])
+  calc
+    _ ≤ _ := measureReal_mono hs
+    _ ≤ _ := measureReal_union_le _ _
+    _ ≤ Real.exp (-(n : ℝ)/8) + Real.exp (-(n : ℝ)/2) :=
+      add_le_add gaussian_norm_lower gaussian_norm_upper
+    _ ≤ 2 * Real.exp (-(n : ℝ)/8) := by
+      have hh : Real.exp (-(n : ℝ)/2) ≤ Real.exp (-(n : ℝ)/8) :=
+        Real.exp_le_exp.mpr (by have := Nat.cast_nonneg (α := ℝ) n; linarith)
+      linarith
+
+lemma gaussian_truncated_sq_bound {n : ℕ} :
+    (∫ g : EuclideanSpace ℝ (Fin n),
+      ({g | 4*(n : ℝ) < ‖g‖^2} : Set (EuclideanSpace ℝ (Fin n))).indicator
+        (fun g => ‖g‖^2) g ∂stdGaussian (EuclideanSpace ℝ (Fin n))) ≤
+      16 * Real.exp (-(n : ℝ)/12) := by
+  let μ := stdGaussian (EuclideanSpace ℝ (Fin n))
+  have hm (g : EuclideanSpace ℝ (Fin n)) :
+      ({g | 4*(n : ℝ) < ‖g‖^2} : Set (EuclideanSpace ℝ (Fin n))).indicator
+        (fun g => ‖g‖^2) g ≤
+      (16 * Real.exp (-(n : ℝ)/4)) * Real.exp ((1/8 : ℝ) * ‖g‖^2) := by
+    by_cases hg : 4*(n : ℝ) < ‖g‖^2
+    · simp only [Set.indicator, Set.mem_ofPred_eq, hg, ↓reduceIte]
+      have he := Real.add_one_le_exp (‖g‖^2/16)
+      have hh : Real.exp (‖g‖^2/16) ≤
+          Real.exp (-(n : ℝ)/4) * Real.exp ((1/8 : ℝ) * ‖g‖^2) := by
+        rw [← Real.exp_add]
+        apply Real.exp_le_exp.mpr
+        linarith
+      nlinarith
+    · simp only [Set.indicator, Set.mem_ofPred_eq, hg, ↓reduceIte]
+      positivity
+  have hi := (gaussian_exp_norm_sq_integrable (n := n) (1/8) (by norm_num)).const_mul
+    (16 * Real.exp (-(n : ℝ)/4))
+  calc
+    _ ≤ ∫ g : EuclideanSpace ℝ (Fin n),
+        (16 * Real.exp (-(n : ℝ)/4)) * Real.exp ((1/8 : ℝ) * ‖g‖^2) ∂μ := by
+      apply integral_mono_of_nonneg
+      · exact ae_of_all _ (fun g => Set.indicator_nonneg (fun g _ => sq_nonneg ‖g‖) g)
+      · exact hi
+      · exact ae_of_all _ hm
+    _ = 16 * Real.exp (-(n : ℝ)/4 - (n : ℝ)/2 * Real.log (1-2*(1/8 : ℝ))) := by
+      rw [integral_const_mul, gaussian_exp_norm_sq (1/8) (by norm_num), mul_assoc, ← Real.exp_add]
+      congr 2
+      ring
+    _ ≤ 16 * Real.exp (-(n : ℝ)/12) := by
+      gcongr
+      have hl : Real.log (1-2*(1/8 : ℝ)) = -Real.log (4/3) := by
+        norm_num
+        rw [show (3/4 : ℝ) = (4/3 : ℝ)⁻¹ by norm_num, Real.log_inv]
+      rw [hl]
+      have hh := Real.log_le_sub_one_of_pos (by norm_num : (0 : ℝ) < 4/3)
+      have hn := Nat.cast_nonneg (α := ℝ) n
+      nlinarith
+
+lemma gaussian_norm_sq_integrable {n : ℕ} :
+    Integrable (fun g : EuclideanSpace ℝ (Fin n) => ‖g‖^2)
+      (stdGaussian (EuclideanSpace ℝ (Fin n))) := by
+  apply Integrable.mono' ((gaussian_exp_norm_sq_integrable (n := n) (1/4) (by norm_num)).const_mul 4)
+  · fun_prop
+  · filter_upwards [] with g
+    rw [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg _)]
+    have := Real.add_one_le_exp ((1/4 : ℝ) * ‖g‖^2)
+    linarith
+
+end NormTails
+
+section Truncation
+variable {n : ℕ}
+local notation "E" => EuclideanSpace ℝ (Fin n)
+local notation "μ" => stdGaussian E
+
+noncomputable def truncate (n : ℕ) (f : EuclideanSpace ℝ (Fin n) → ℝ) :
+    EuclideanSpace ℝ (Fin n) → ℝ :=
+  {g | ‖g‖^2 ≤ 4*(n : ℝ)}.indicator f
+
+lemma measurable_truncation_set : MeasurableSet {g : E | ‖g‖^2 ≤ 4*(n : ℝ)} := by
+  measurability
+
+lemma measurable_tail_set : MeasurableSet {g : E | 4*(n : ℝ) < ‖g‖^2} := by
+  measurability
+
+lemma integrable_truncate {f : E → ℝ} (hf : Integrable f μ) :
+    Integrable (truncate n f) μ := hf.indicator measurable_truncation_set
+
+lemma truncation_bias {f : E → ℝ} (hf : Integrable f μ)
+    (hb : ∀ g, 4*(n : ℝ) < ‖g‖^2 → |f g| ≤ ‖g‖^2) :
+    |(∫ g, truncate n f g ∂μ) - ∫ g, f g ∂μ| ≤
+      16 * Real.exp (-(n : ℝ)/12) := by
+  let T : Set E := {g | 4*(n : ℝ) < ‖g‖^2}
+  have hT : MeasurableSet T := measurable_tail_set
+  have hid (g : E) : truncate n f g - f g = -T.indicator f g := by
+    by_cases h : ‖g‖^2 ≤ 4*(n : ℝ)
+    · simp [truncate, T, h, not_lt.mpr h]
+    · simp [truncate, T, h, lt_of_not_ge h]
+  rw [← integral_sub (integrable_truncate hf) hf]
+  simp_rw [hid]
+  rw [integral_neg, abs_neg]
+  calc
+    |∫ g, T.indicator f g ∂μ| ≤ ∫ g, |T.indicator f g| ∂μ := abs_integral_le_integral_abs
+    _ ≤ ∫ g, T.indicator (fun g => ‖g‖^2) g ∂μ := by
+      apply integral_mono ((hf.indicator hT).abs) (gaussian_norm_sq_integrable.indicator hT)
+      intro g
+      by_cases hg : g ∈ T
+      · simpa [Set.indicator_of_mem hg] using hb g hg
+      · simp [Set.indicator_of_notMem hg]
+    _ ≤ _ := gaussian_truncated_sq_bound
+
+lemma inner_sq_integrable (v : E) : Integrable (fun g => (inner ℝ v g)^2) μ := by
+  apply Integrable.mono' (gaussian_norm_sq_integrable.const_mul (‖v‖^2))
+  · fun_prop
+  · filter_upwards [] with g
+    simp only [Real.norm_eq_abs, abs_sq]
+    have h := abs_real_inner_le_norm v g
+    simpa only [sq_abs, mul_pow] using pow_le_pow_left₀ (abs_nonneg _) h 2
+
+lemma truncation_covariance_bias (v : E) (hv : ‖v‖ = 1) :
+    |(∫ g, truncate n (fun g => (inner ℝ v g)^2) g ∂μ) - 1| ≤
+      16 * Real.exp (-(n : ℝ)/12) := by
+  have h := truncation_bias (inner_sq_integrable v) (fun g hg => by
+    have hh := abs_real_inner_le_norm v g
+    rw [hv, one_mul] at hh
+    simpa only [abs_sq, sq_abs] using pow_le_pow_left₀ (abs_nonneg _) hh 2)
+  simpa [gaussian_inner_sq, hv] using h
+
+lemma truncation_fourier_bias (hn : 1 ≤ n) (v w : E) (hv : ‖v‖ = 1) :
+    |(∫ g, truncate n (fun g => inner ℝ g v * Real.sin (inner ℝ g w)) g ∂μ) -
+      inner ℝ w v * Real.exp (-‖w‖^2/2)| ≤
+      16 * Real.exp (-(n : ℝ)/12) := by
+  have h := truncation_bias (gaussian_linear_sin_integrable w v) (fun g hg => by
+    have hn' : (1 : ℝ) ≤ n := by exact_mod_cast hn
+    have hh := abs_real_inner_le_norm g v
+    rw [hv, mul_one] at hh
+    have hn1 : 1 ≤ ‖g‖ := by nlinarith [norm_nonneg g]
+    calc
+      |inner ℝ g v * Real.sin (inner ℝ g w)| ≤ |inner ℝ g v| * 1 := by
+        rw [abs_mul]; exact mul_le_mul_of_nonneg_left (Real.abs_sin_le_one _) (abs_nonneg _)
+      _ ≤ ‖g‖^2 := by nlinarith)
+  simpa only [gaussian_linear_sin] using h
+
+lemma truncate_fourier_bound (v w : E) (hv : ‖v‖ = 1) (g : E) :
+    |truncate n (fun g => inner ℝ g v * Real.sin (inner ℝ g w)) g| ≤ 2*Real.sqrt n := by
+  by_cases hg : ‖g‖^2 ≤ 4*(n : ℝ)
+  · have hh := abs_real_inner_le_norm g v
+    rw [hv, mul_one] at hh
+    have hs := Real.sq_sqrt (Nat.cast_nonneg (α := ℝ) n)
+    have hb : ‖g‖ ≤ 2*Real.sqrt n := by nlinarith [Real.sqrt_nonneg (n : ℝ), norm_nonneg g]
+    simp only [truncate, Set.indicator, Set.mem_ofPred_eq, hg, ↓reduceIte, abs_mul]
+    calc
+      _ ≤ |inner ℝ g v| * 1 := mul_le_mul_of_nonneg_left (Real.abs_sin_le_one _) (abs_nonneg _)
+      _ ≤ _ := by linarith
+  · simp only [truncate, Set.indicator, Set.mem_ofPred_eq, hg, ↓reduceIte, abs_zero]
+    positivity
+
+lemma truncate_covariance_bound (v : E) (hv : ‖v‖ = 1) (g : E) :
+    |truncate n (fun g => (inner ℝ v g)^2) g| ≤ 4*(n : ℝ) := by
+  by_cases hg : ‖g‖^2 ≤ 4*(n : ℝ)
+  · have hh := abs_real_inner_le_norm v g
+    rw [hv, one_mul] at hh
+    have hb := pow_le_pow_left₀ (abs_nonneg _) hh 2
+    rw [sq_abs] at hb
+    simp only [truncate, Set.indicator, Set.mem_ofPred_eq, hg, ↓reduceIte, abs_sq]
+    nlinarith
+  · simp only [truncate, Set.indicator, Set.mem_ofPred_eq, hg, ↓reduceIte, abs_zero]
+    positivity
+end Truncation
+
+end UniformSparsestCut.GaussianTools
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/GradientBudget.lean

@@ -0,0 +1,267 @@
+import OAI.Combinatorics.SparsestCut.ConcreteCells
+
+namespace OAI
+
+universe u1 u2 u3 u4 u5 u6 u7 u8 u9
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.GradientBudget
+variable {E : Type u1} {S : Type u2} {I : Type u3} {A : Type u4} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [Fintype S] [Fintype I] [Fintype A] [DecidableEq S]
+
+lemma directional_control (u : I → E) (β : I → ℝ) (a e : E) {δ : ℝ}
+    (hδ : 0 ≤ δ) (ha : a+e=∑ i, β i • u i)
+    (hu : ∀ i, |inner ℝ (u i) a| ≤ δ*‖a‖) :
+    ‖a‖ ≤ δ*∑ i, |β i|+‖e‖ := by
+  by_cases hz : a=0
+  · simp only [hz,norm_zero]; positivity
+  have hn : 0 < ‖a‖ := norm_pos_iff.mpr hz
+  have hs : |inner ℝ (∑ i, β i • u i) a| ≤ δ*‖a‖*∑ i, |β i| := by
+    rw [sum_inner]
+    calc
+      _ ≤ ∑ i, |inner ℝ (β i • u i) a| := Finset.abs_sum_le_sum_abs _ _
+      _ ≤ ∑ i, |β i| * (δ*‖a‖) := by
+        apply Finset.sum_le_sum; intro i _
+        rw [real_inner_smul_left,abs_mul]
+        exact mul_le_mul_of_nonneg_left (hu i) (abs_nonneg _)
+      _ = _ := by rw [← Finset.sum_mul]; ring
+  have hip : ‖a‖^2 ≤ |inner ℝ (∑ i, β i • u i) a|+‖e‖*‖a‖ := by
+    rw [← ha,inner_add_left]
+    have h := abs_real_inner_le_norm e a
+    rw [real_inner_self_eq_norm_sq]
+    have hab := le_abs_self (‖a‖^2+inner ℝ e a)
+    have hab' := neg_le_abs (inner ℝ e a)
+    nlinarith
+  have hmul : ‖a‖*‖a‖ ≤ (δ*∑ i, |β i|+‖e‖)*‖a‖ := by nlinarith
+  nlinarith
+
+omit [DecidableEq S] in
+lemma good_chart_average (u : S → I → E) (β : S → I → ℝ) (a : E) (e : S → E)
+    {δ : ℝ} (hδ : 0 ≤ δ)
+    (ha : ∀ s, a+e s=∑ i, β s i • u s i)
+    (good : Finset S) (hgood : (Fintype.card S : ℝ)/2 ≤ good.card)
+    (hu : ∀ s ∈ good, ∀ i, |inner ℝ (u s i) a| ≤ δ*‖a‖) :
+    (Fintype.card S : ℝ)*‖a‖ ≤ 2*∑ s, (δ*∑ i, |β s i|+‖e s‖) := by
+  have hg : (good.card:ℝ)*‖a‖ ≤ ∑ s ∈ good, (δ*∑ i, |β s i|+‖e s‖) := by
+    calc
+      _ = ∑ _s ∈ good, ‖a‖ := by simp
+      _ ≤ _ := Finset.sum_le_sum (fun s hs => directional_control (u s) (β s) a (e s) hδ (ha s) (hu s hs))
+  have hsub : (∑ s ∈ good, (δ*∑ i, |β s i|+‖e s‖)) ≤ ∑ s, (δ*∑ i, |β s i|+‖e s‖) := by
+    apply Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _)
+    intro s _ _; positivity
+  have hmult := mul_le_mul_of_nonneg_right hgood (norm_nonneg a)
+  linarith
+
+omit [DecidableEq S] in
+lemma total_gradient (u : S → I → E) (β : S → I → A → ℝ) (a : A → E) (e : S → A → E)
+    {δ B R : ℝ} (hδ : 0 ≤ δ)
+    (ha : ∀ s α, a α+e s α=∑ i, β s i α • u s i)
+    (hg : ∀ α, ∃ good : Finset S, (Fintype.card S : ℝ)/2 ≤ good.card ∧
+      ∀ s ∈ good, ∀ i, |inner ℝ (u s i) (a α)| ≤ δ*‖a α‖)
+    (hβ : ∀ s, ∑ i, ∑ α, |β s i α| ≤ B)
+    (he : ∀ s, ∑ α, ‖e s α‖ ≤ R) (hS : 0 < Fintype.card S) :
+    ∑ α, ‖a α‖ ≤ 2*(δ*B+R) := by
+  have hcomp (α : A) : (Fintype.card S : ℝ)*‖a α‖ ≤
+      2*∑ s, (δ*∑ i, |β s i α|+‖e s α‖) := by
+    obtain ⟨good,hgood,hu⟩ := hg α
+    exact good_chart_average u (fun s i => β s i α) (a α) (fun s => e s α) hδ
+      (fun s => ha s α) good hgood hu
+  have hs := Finset.sum_le_sum (s := Finset.univ) (fun α _ => hcomp α)
+  rw [← Finset.mul_sum, ← Finset.mul_sum, Finset.sum_comm] at hs
+  have hb (s : S) : (∑ α, (δ*∑ i, |β s i α|+‖e s α‖)) ≤ δ*B+R := by
+    rw [Finset.sum_add_distrib,← Finset.mul_sum,Finset.sum_comm]
+    exact add_le_add (mul_le_mul_of_nonneg_left (hβ s) hδ) (he s)
+  have hsum := Finset.sum_le_sum (s := Finset.univ) (fun s _ => hb s)
+  simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul] at hsum
+  have hcard : (0:ℝ) < Fintype.card S := by exact_mod_cast hS
+  nlinarith
+
+end UniformSparsestCut.GradientBudget
+
+namespace UniformSparsestCut.ConvolutionBounds
+open MeasureTheory Set
+open scoped BigOperators
+variable {G : Type u5} {A : Type u6} [NormedAddCommGroup G] [NormedSpace ℝ G]
+  [MeasurableSpace G] [BorelSpace G] [Fintype A]
+  {μ : Measure G} [SFinite μ] [μ.IsAddLeftInvariant] [μ.IsNegInvariant]
+
+def smooth (κ f : G → ℝ) (μ : Measure G) : G → ℝ :=
+  convolution κ f (ContinuousLinearMap.mul ℝ ℝ) μ
+
+omit [NormedSpace ℝ G] [BorelSpace G] [SFinite μ] [μ.IsAddLeftInvariant] [μ.IsNegInvariant] in
+lemma smooth_eq (κ f : G → ℝ) (x : G) :
+    smooth κ f μ x = ∫ z, κ z*f (x-z) ∂μ := rfl
+
+lemma smooth_deriv {κ f : G → ℝ} (hk : HasCompactSupport κ)
+    (hc : ContDiff ℝ 1 κ) (hf : LocallyIntegrable f μ) (x h : G) :
+    fderiv ℝ (smooth κ f μ) x h = ∫ z, (fderiv ℝ κ z h)*f (x-z) ∂μ := by
+  unfold smooth
+  rw [(hk.hasFDerivAt_convolution_left (ContinuousLinearMap.mul ℝ ℝ) hc hf x).fderiv]
+  have hi := (hk.fderiv ℝ).convolutionExists_left
+    ((ContinuousLinearMap.mul ℝ ℝ).precompL G) (hc.continuous_fderiv (by norm_num)) hf x
+  exact ContinuousLinearMap.integral_apply hi h
+
+omit [SFinite μ] in
+lemma smooth_deriv_integrable {κ f : G → ℝ} (hk : HasCompactSupport κ)
+    (hc : ContDiff ℝ 1 κ) (hf : LocallyIntegrable f μ) (x h : G) :
+    Integrable (fun z => (fderiv ℝ κ z h)*f (x-z)) μ := by
+  have hi := (hk.fderiv ℝ).convolutionExists_left
+    ((ContinuousLinearMap.mul ℝ ℝ).precompL G) (hc.continuous_fderiv (by norm_num)) hf x
+  exact hi.apply_continuousLinearMap h
+
+omit [NormedAddCommGroup G] [NormedSpace ℝ G] [BorelSpace G] [SFinite μ] [μ.IsAddLeftInvariant] [μ.IsNegInvariant] in
+
+lemma integral_l1_bound (f : A → G → ℝ) (hf : ∀ a, Integrable (f a) μ)
+    {B : G → ℝ} (hB : Integrable B μ) (hb : ∀ᵐ z ∂μ, ∑ a, |f a z| ≤ B z) :
+    (∑ a, |∫ z, f a z ∂μ|) ≤ ∫ z, B z ∂μ := by
+  calc
+    _ ≤ ∑ a, ∫ z, |f a z| ∂μ := Finset.sum_le_sum (fun a _ => by
+      simpa only [Real.norm_eq_abs] using norm_integral_le_integral_norm (f a))
+    _ = ∫ z, ∑ a, |f a z| ∂μ := (integral_finsetSum _ (fun a _ => (hf a).abs)).symm
+    _ ≤ _ := integral_mono_ae (integrable_finsetSum _ (fun a _ => (hf a).abs)) hB hb
+
+lemma mismatch {κ : G → ℝ} (hk : HasCompactSupport κ) (hc : ContDiff ℝ 1 κ)
+    (f g : A → G → ℝ) (hf : ∀ a, LocallyIntegrable (f a) μ)
+    (hg : ∀ a, LocallyIntegrable (g a) μ) (x h : G) {B : ℝ}
+    (hki : Integrable (fun z => |fderiv ℝ κ z h|) μ)
+    (hb : ∀ᵐ z ∂μ, fderiv ℝ κ z h ≠ 0 → ∑ a, |f a (x-z)-g a (x-z)| ≤ B) :
+    (∑ a, |fderiv ℝ (smooth κ (f a) μ) x h-fderiv ℝ (smooth κ (g a) μ) x h|) ≤
+      B*(∫ z, |fderiv ℝ κ z h| ∂μ) := by
+  simp_rw [smooth_deriv hk hc (hf _),smooth_deriv hk hc (hg _)]
+  have hi (a : A) : Integrable (fun z => fderiv ℝ κ z h*(f a (x-z)-g a (x-z))) μ := by
+    convert! (smooth_deriv_integrable hk hc (hf a) x h).sub
+      (smooth_deriv_integrable hk hc (hg a) x h) using 1
+    ext z
+    simp only [Pi.sub_apply,mul_sub]
+  have he (a : A) : (∫ z, fderiv ℝ κ z h*f a (x-z) ∂μ)-
+      (∫ z, fderiv ℝ κ z h*g a (x-z) ∂μ) =
+      ∫ z, fderiv ℝ κ z h*(f a (x-z)-g a (x-z)) ∂μ := by
+    simp only [mul_sub]
+    exact (integral_sub (smooth_deriv_integrable hk hc (hf a) x h)
+      (smooth_deriv_integrable hk hc (hg a) x h)).symm
+  simp_rw [he]
+  rw [← integral_const_mul]
+  apply integral_l1_bound _ hi (hki.const_mul B)
+  filter_upwards [hb] with z hz
+  by_cases hn : fderiv ℝ κ z h=0
+  · simp [hn]
+  · simp_rw [abs_mul,← Finset.mul_sum]
+    simpa only [mul_comm] using mul_le_mul_of_nonneg_left (hz hn) (abs_nonneg (fderiv ℝ κ z h))
+
+omit [NormedSpace ℝ G] [SFinite μ] in
+
+lemma error {κ : G → ℝ} (hk : HasCompactSupport κ) (hc : Continuous κ)
+    (hki : Integrable κ μ) (hkn : ∀ z, 0 ≤ κ z) (hk1 : ∫ z, κ z ∂μ=1)
+    (f : A → G → ℝ) (hf : ∀ a, LocallyIntegrable (f a) μ) (x : G) {B : ℝ}
+    (hb : ∀ᵐ z ∂μ, κ z ≠ 0 → ∑ a, |f a (x-z)-f a x| ≤ B) :
+    (∑ a, |smooth κ (f a) μ x-f a x|) ≤ B := by
+  have hi0 (a : A) : Integrable (fun z => κ z*f a (x-z)) μ :=
+    hk.convolutionExists_left (ContinuousLinearMap.mul ℝ ℝ) hc (hf a) x
+  have hi (a : A) : Integrable (fun z => κ z*(f a (x-z)-f a x)) μ := by
+    convert! (hi0 a).sub (hki.mul_const (f a x)) using 1
+    ext z
+    simp only [Pi.sub_apply,mul_sub]
+  have he (a : A) : smooth κ (f a) μ x-f a x = ∫ z, κ z*(f a (x-z)-f a x) ∂μ := by
+    rw [smooth_eq]
+    simp only [mul_sub]
+    rw [integral_sub (hi0 a)
+      (hki.mul_const (f a x)),integral_mul_const,hk1,one_mul]
+  simp_rw [he]
+  have hres := integral_l1_bound (μ := μ) _ hi (hki.const_mul B) (by
+    filter_upwards [hb] with z hz
+    by_cases hn : κ z=0
+    · simp [hn]
+    · simp_rw [abs_mul,abs_of_nonneg (hkn z),← Finset.mul_sum]
+      simpa only [mul_comm] using mul_le_mul_of_nonneg_left (hz hn) (hkn z))
+  simpa only [integral_const_mul,hk1,mul_one] using hres
+
+end UniformSparsestCut.ConvolutionBounds
+
+namespace UniformSparsestCut.GradientCalculus
+open MeasureTheory Set
+open scoped BigOperators RealInnerProductSpace
+noncomputable section
+variable {m : ℕ} {A : Type u7} {S : Type u8} {I : Type u9} [Fintype A] [Fintype S] [Fintype I] [DecidableEq S]
+local notation "E" => EuclideanSpace ℝ (Fin m)
+
+def vector (D : StrongDual ℝ E) : E := (InnerProductSpace.toDual ℝ E).symm D
+@[simp] lemma vector_norm (D : StrongDual ℝ E) : ‖vector D‖=‖D‖ :=
+  (InnerProductSpace.toDual ℝ E).symm.norm_map D
+@[simp] lemma vector_inner (D : StrongDual ℝ E) (x : E) : inner ℝ (vector D) x=D x :=
+  InnerProductSpace.toDual_symm_apply
+lemma vector_coordinate (D : StrongDual ℝ E) (j : Fin m) :
+    vector D j=D (EuclideanSpace.single j 1) := by
+  have h := vector_inner D (EuclideanSpace.single j 1)
+  simpa [PiLp.inner_apply,PiLp.single_apply] using h
+lemma norm_le_partials (D : StrongDual ℝ E) : ‖D‖≤∑ j, |D (EuclideanSpace.single j 1)| := by
+  rw [← vector_norm]
+  have he : vector D=∑ j, EuclideanSpace.single j (vector D j) := by
+    ext i
+    simp
+  calc
+    _ = ‖∑ j, EuclideanSpace.single j (vector D j)‖ := congrArg norm he
+    _ ≤ ∑ j, ‖EuclideanSpace.single j (vector D j)‖ := norm_sum_le _ _
+    _ = _ := by simp only [PiLp.norm_single,Real.norm_eq_abs,vector_coordinate]
+lemma vector_representation (D : StrongDual ℝ E) (u : I → E) (β : I → ℝ)
+    (hd : D=∑ i, β i • InnerProductSpace.toDual ℝ E (u i)) :
+    vector D=∑ i, β i • u i := by
+  apply (InnerProductSpace.toDual ℝ E).injective
+  simp only [vector,LinearIsometryEquiv.apply_symm_apply,map_sum,map_smul,hd]
+
+lemma gradient_mismatch {κ : E → ℝ} (hk : HasCompactSupport κ) (hc : ContDiff ℝ 1 κ)
+    (f g : A → E → ℝ) (hf : ∀ a, LocallyIntegrable (f a))
+    (hg : ∀ a, LocallyIntegrable (g a)) (x : E) {B L : ℝ}
+    (hki : ∀ j : Fin m, Integrable (fun z => |fderiv ℝ κ z (EuclideanSpace.single j 1)|))
+    (hL : ∀ j : Fin m, ∫ z, |fderiv ℝ κ z (EuclideanSpace.single j 1)| = L)
+    (hb : ∀ᵐ z, (∃ j : Fin m, fderiv ℝ κ z (EuclideanSpace.single j 1)≠0) →
+      ∑ a, |f a (x-z)-g a (x-z)|≤B) :
+    (∑ a, ‖fderiv ℝ (ConvolutionBounds.smooth κ (f a) volume) x-
+      fderiv ℝ (ConvolutionBounds.smooth κ (g a) volume) x‖)≤(m:ℝ)*B*L := by
+  calc
+    _ ≤ ∑ a, ∑ j : Fin m, |fderiv ℝ (ConvolutionBounds.smooth κ (f a) volume) x (EuclideanSpace.single j 1)-
+        fderiv ℝ (ConvolutionBounds.smooth κ (g a) volume) x (EuclideanSpace.single j 1)| := by
+      apply Finset.sum_le_sum; intro a _
+      exact norm_le_partials _
+    _ = ∑ j : Fin m, ∑ a, |fderiv ℝ (ConvolutionBounds.smooth κ (f a) volume) x (EuclideanSpace.single j 1)-
+        fderiv ℝ (ConvolutionBounds.smooth κ (g a) volume) x (EuclideanSpace.single j 1)| := Finset.sum_comm
+    _ ≤ ∑ _j : Fin m, B*L := by
+      apply Finset.sum_le_sum; intro j _
+      rw [← hL j]
+      apply ConvolutionBounds.mismatch hk hc f g hf hg x _ (hki j)
+      filter_upwards [hb] with z hz hj using hz ⟨j,hj⟩
+    _ = _ := by simp; ring
+
+omit [DecidableEq S] in
+lemma gradient_budget (u : S → I → E) (β : S → I → A → ℝ)
+    (D : S → A → StrongDual ℝ E) (base : A → StrongDual ℝ E)
+    {δ B R : ℝ} (hδ : 0≤δ)
+    (hd : ∀ s a, D s a=∑ i, β s i a • InnerProductSpace.toDual ℝ E (u s i))
+    (hgood : ∀ a, ∃ good : Finset S, (Fintype.card S:ℝ)/2≤good.card ∧
+      ∀ s∈good, ∀ i, |base a (u s i)|≤δ*‖base a‖)
+    (hβ : ∀ s, ∑ i, ∑ a, |β s i a|≤B)
+    (he : ∀ s, ∑ a, ‖D s a-base a‖≤R) (hS : 0<Fintype.card S) :
+    ∑ a, ‖base a‖≤2*(δ*B+R) := by
+  have hvec (s : S) (a : A) : vector (base a)+vector (D s a-base a)=∑ i, β s i a • u s i := by
+    change (InnerProductSpace.toDual ℝ E).symm (base a)+(InnerProductSpace.toDual ℝ E).symm (D s a-base a)=_
+    rw [← map_add,add_sub_cancel]
+    exact vector_representation _ _ _ (hd s a)
+  have hg (a : A) : ∃ good : Finset S, (Fintype.card S:ℝ)/2≤good.card ∧
+      ∀ s∈good, ∀ i, |inner ℝ (u s i) (vector (base a))|≤δ*‖vector (base a)‖ := by
+    obtain ⟨good,hc,hg⟩ := hgood a
+    refine ⟨good,hc,?_⟩
+    intro s hs i
+    rw [real_inner_comm,vector_inner,vector_norm]
+    exact hg s hs i
+  simpa only [vector_norm] using GradientBudget.total_gradient u β (fun a => vector (base a))
+    (fun s a => vector (D s a-base a)) hδ hvec hg hβ
+    (by intro s; simpa only [vector_norm] using he s) hS
+end
+end UniformSparsestCut.GradientCalculus
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/InterfaceStep.lean

@@ -0,0 +1,582 @@
+import OAI.Combinatorics.SparsestCut.ContractionBounds
+
+namespace OAI
+
+universe u1 u2 u3 u4 u5 u6 u7 u8 u9 u10
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.InterfaceStep
+variable {ι : Type u1} {V : Type u2} [DecidableEq ι] [AddCommGroup V]
+
+lemma telescoping_events (s : Finset ι) (t : ι → ℝ) (ht : Set.InjOn t s)
+    (F : Finset ι → V) :
+    (∑ i ∈ s, (F (s.filter (fun j => t j ≤ t i))-F (s.filter (fun j => t j < t i)))) =
+      F s-F ∅ := by
+  revert ht
+  induction s using Finset.strongInductionOn with
+  | _ s ih =>
+    intro ht
+    by_cases hs : s.Nonempty
+    · obtain ⟨a,ha,hmax⟩ := s.exists_max_image t hs
+      let r := s.erase a
+      have hr : r ⊂ s := Finset.erase_ssubset ha
+      have htr : Set.InjOn t (↑r : Set ι) := ht.mono (by intro i hi; exact Finset.mem_of_mem_erase hi)
+      have hind := ih r hr htr
+      have hle : s.filter (fun j => t j ≤ t a) = s := by
+        apply Finset.filter_eq_self.mpr; intro j hj; exact hmax j hj
+      have hlt : s.filter (fun j => t j < t a) = r := by
+        ext j
+        simp only [Finset.mem_filter, r, Finset.mem_erase]
+        constructor
+        · rintro ⟨hj,h⟩; exact ⟨fun he => by simp [he] at h,hj⟩
+        · rintro ⟨hne,hj⟩
+          exact ⟨hj,lt_of_le_of_ne (hmax j hj) (fun he => hne (ht hj ha he))⟩
+      have hfilters (i : ι) (hi : i ∈ r) :
+          s.filter (fun j => t j ≤ t i) = r.filter (fun j => t j ≤ t i) ∧
+          s.filter (fun j => t j < t i) = r.filter (fun j => t j < t i) := by
+        have hia : t i < t a := (Finset.mem_filter.mp (show i ∈ s.filter (fun j => t j < t a) by rw [hlt]; exact hi)).2
+        constructor <;> (ext j; simp only [Finset.mem_filter, r, Finset.mem_erase]; constructor)
+        · rintro ⟨hj,hji⟩
+          exact ⟨⟨fun he => by subst j; linarith,hj⟩,hji⟩
+        · rintro ⟨⟨_,hj⟩,hji⟩; exact ⟨hj,hji⟩
+        · rintro ⟨hj,hji⟩
+          exact ⟨⟨fun he => by subst j; linarith,hj⟩,hji⟩
+        · rintro ⟨⟨_,hj⟩,hji⟩; exact ⟨hj,hji⟩
+      rw [← Finset.sum_erase_add _ _ ha, hle,hlt]
+      change (∑ i ∈ r, _) + (F s-F r) = _
+      have he : (∑ i ∈ r, (F (s.filter (fun j => t j ≤ t i))-F (s.filter (fun j => t j < t i)))) =
+          ∑ i ∈ r, (F (r.filter (fun j => t j ≤ t i))-F (r.filter (fun j => t j < t i))) := by
+        apply Finset.sum_congr rfl; intro i hi; rw [(hfilters i hi).1,(hfilters i hi).2]
+      rw [he,hind]
+      abel
+    · simp [Finset.not_nonempty_iff_eq_empty.mp hs]
+
+lemma threshold_decomposition (s : Finset ι) (t : ι → ℝ) (ht : Set.InjOn t s)
+    (F : Finset ι → V) (x : ℝ) :
+    F (s.filter (fun i => t i < x)) = F ∅+
+      ∑ i ∈ s, if t i < x then
+        F (s.filter (fun j => t j ≤ t i))-F (s.filter (fun j => t j < t i)) else 0 := by
+  let r := s.filter (fun i => t i < x)
+  have htr : Set.InjOn t (↑r : Set ι) := ht.mono (by intro i hi; exact (Finset.mem_filter.mp hi).1)
+  have h := telescoping_events r t htr F
+  have hfilters (i : ι) (hi : i ∈ r) :
+      r.filter (fun j => t j ≤ t i) = s.filter (fun j => t j ≤ t i) ∧
+      r.filter (fun j => t j < t i) = s.filter (fun j => t j < t i) := by
+    have hix : t i < x := (Finset.mem_filter.mp hi).2
+    constructor <;> (ext j; simp only [r,Finset.mem_filter]; constructor)
+    · rintro ⟨⟨hj,_⟩,hji⟩; exact ⟨hj,hji⟩
+    · rintro ⟨hj,hji⟩; exact ⟨⟨hj,lt_of_le_of_lt hji hix⟩,hji⟩
+    · rintro ⟨⟨hj,_⟩,hji⟩; exact ⟨hj,hji⟩
+    · rintro ⟨hj,hji⟩; exact ⟨⟨hj,hji.trans hix⟩,hji⟩
+  have he : (∑ i ∈ r, (F (r.filter (fun j => t j ≤ t i))-F (r.filter (fun j => t j < t i)))) =
+      ∑ i ∈ r, (F (s.filter (fun j => t j ≤ t i))-F (s.filter (fun j => t j < t i))) := by
+    apply Finset.sum_congr rfl; intro i hi; rw [(hfilters i hi).1,(hfilters i hi).2]
+  rw [he] at h
+  rw [← Finset.sum_filter]
+  change F r = F ∅+_
+  rw [h]
+  abel
+
+section Integral
+variable {W : Type u3} [NormedAddCommGroup W] [NormedSpace ℝ W] [CompleteSpace W]
+
+lemma integral_deriv_eq_zero {φ : ℝ → ℝ} (hφ : ContDiff ℝ 1 φ)
+    (hc : HasCompactSupport φ) : ∫ x, deriv φ x = 0 := by
+  apply integral_eq_zero_of_hasDerivAt_of_integrable
+    (fun x => (hφ.differentiable one_ne_zero x).hasDerivAt)
+  · exact (hφ.continuous_deriv le_rfl).integrable_of_hasCompactSupport hc.deriv
+  · exact hφ.continuous.integrable_of_hasCompactSupport hc
+
+lemma threshold_integral_deriv (s : Finset ι) (t : ι → ℝ) (ht : Set.InjOn t s)
+    (F : Finset ι → W) {φ : ℝ → ℝ} (hφ : ContDiff ℝ 1 φ)
+    (hc : HasCompactSupport φ) :
+    (∫ x, deriv φ x • F (s.filter (fun i => t i < x))) =
+      -∑ i ∈ s, φ (t i) •
+        (F (s.filter (fun j => t j ≤ t i))-F (s.filter (fun j => t j < t i))) := by
+  let Δ := fun i => F (s.filter (fun j => t j ≤ t i))-F (s.filter (fun j => t j < t i))
+  have hd : Integrable (deriv φ) :=
+    (hφ.continuous_deriv le_rfl).integrable_of_hasCompactSupport hc.deriv
+  have hi (i : ι) : Integrable (fun x => deriv φ x • (if t i < x then Δ i else 0)) := by
+    have he : (fun x => deriv φ x • (if t i < x then Δ i else 0)) =
+        (Ioi (t i)).indicator (fun x => deriv φ x • Δ i) := by
+      funext x; by_cases hx : t i < x <;> simp [hx]
+    rw [he]
+    exact (hd.smul_const _).indicator measurableSet_Ioi
+  have he (x : ℝ) : deriv φ x • F (s.filter (fun i => t i < x)) =
+      deriv φ x • F ∅ + ∑ i ∈ s, deriv φ x • (if t i < x then Δ i else 0) := by
+    rw [threshold_decomposition s t ht F x, smul_add, Finset.smul_sum]
+  simp_rw [he]
+  rw [integral_add (hd.smul_const _) (integrable_finsetSum _ (fun i _ => hi i)),
+    integral_smul_const, integral_deriv_eq_zero hφ hc, zero_smul, zero_add,
+    integral_finsetSum _ (fun i _ => hi i), ← Finset.sum_neg_distrib]
+  apply Finset.sum_congr rfl
+  intro i hi'
+  have he : (fun x => deriv φ x • (if t i < x then Δ i else 0)) =
+      (Ioi (t i)).indicator (fun x => deriv φ x • Δ i) := by
+    funext x; by_cases hx : t i < x <;> simp [hx]
+  rw [he, integral_indicator measurableSet_Ioi, integral_smul_const,
+    hc.integral_Ioi_deriv_eq hφ, neg_smul]
+end Integral
+
+section MovingEvents
+variable {X : Type u4} [MeasurableSpace X]
+
+lemma measurable_filter_apply (s : Finset ι) (P : ι → X → Prop)
+    [∀ i, DecidablePred (P i)] (hP : ∀ i, MeasurableSet {x | P i x})
+    (F : Finset ι → ℝ) : Measurable (fun x => F (s.filter (fun i => P i x))) := by
+  classical
+  induction s using Finset.induction_on generalizing F with
+  | empty => simp
+  | @insert i s hi ih =>
+    have h₁ := ih (fun a => F (insert i a))
+    have h₂ := ih F
+    have h : Measurable (fun x => if P i x then F (insert i (s.filter (fun j => P j x))) else F (s.filter (fun j => P j x))) := Measurable.ite (hP i) h₁ h₂
+    convert h using 1
+    funext x
+    by_cases hx : P i x <;> simp [Finset.filter_insert, hx]
+
+end MovingEvents
+
+section ContinuousEvents
+variable [Fintype ι] {X : Type u5} [TopologicalSpace X] [FirstCountableTopology X]
+
+omit [DecidableEq ι] [Fintype ι] [FirstCountableTopology X] in
+lemma eventually_threshold_eq (s : Finset ι) (t : ι → X → ℝ) {y : X} {x : ℝ}
+    (ht : ∀ i ∈ s, ContinuousAt (t i) y) (hx : ∀ i ∈ s, x ≠ t i y) :
+    ∀ᶠ z in 𝓝 y, s.filter (fun i => t i z < x) = s.filter (fun i => t i y < x) := by
+  have hi (i : ι) (hi : i ∈ s) : ∀ᶠ z in 𝓝 y, (t i z < x ↔ t i y < x) := by
+    rcases lt_or_gt_of_ne (hx i hi) with h | h
+    · filter_upwards [(ht i hi).eventually (lt_mem_nhds h)] with z hz
+      exact iff_of_false (not_lt.mpr hz.le) (not_lt.mpr h.le)
+    · filter_upwards [(ht i hi).eventually (gt_mem_nhds h)] with z hz
+      exact iff_of_true hz h
+  filter_upwards [s.eventually_all.mpr hi] with z hz
+  ext i
+  simp only [Finset.mem_filter]
+  exact and_congr_right (fun hi => hz i hi)
+
+lemma continuousAt_threshold_integral (s : Finset ι) (t : ι → X → ℝ) (F : Finset ι → ℝ)
+    {y : X} (ht : ∀ i ∈ s, ContinuousAt (t i) y) {φ : ℝ → ℝ} (hφ : Integrable φ) :
+    ContinuousAt (fun z => ∫ x, φ x * F (s.filter (fun i => t i z < x))) y := by
+  let M : ℝ := ∑ a : Finset ι, |F a|
+  have hM (a : Finset ι) : |F a| ≤ M := by
+    exact Finset.single_le_sum (f := fun a : Finset ι => |F a|) (fun _ _ => abs_nonneg _) (Finset.mem_univ a)
+  apply continuousAt_of_dominated (bound := fun x => |φ x| * M)
+  · apply Filter.Eventually.of_forall
+    intro z
+    exact hφ.aestronglyMeasurable.mul ((measurable_filter_apply s
+      (fun i x => t i z < x) (fun _ => measurableSet_Ioi) F).aestronglyMeasurable)
+  · exact Filter.Eventually.of_forall (fun z => ae_of_all _ (fun x => by
+      simp only [Real.norm_eq_abs, abs_mul]
+      exact mul_le_mul_of_nonneg_left (hM _) (abs_nonneg _)))
+  · exact hφ.abs.mul_const M
+  · have hn : ∀ᵐ x : ℝ, ∀ i : ι, x ≠ t i y := ae_all_iff.mpr (fun i => volume.ae_ne (t i y))
+    filter_upwards [hn] with x hx
+    have he := eventually_threshold_eq s t ht (fun i _ => hx i)
+    apply ContinuousAt.congr_of_eventuallyEq (by fun_prop : ContinuousAt (fun _ : X => φ x * F (s.filter (fun i => t i y < x))) y)
+    filter_upwards [he] with z hz
+    rw [hz]
+
+omit [Fintype ι] in
+lemma threshold_integral (s : Finset ι) (t : ι → ℝ) (ht : Set.InjOn t s)
+    (F : Finset ι → ℝ) {φ : ℝ → ℝ} (hφ : Integrable φ) :
+    (∫ x, φ x * F (s.filter (fun i => t i < x))) =
+      (∫ x, φ x)*F ∅ + ∑ i ∈ s, (∫ x in Ioi (t i), φ x) *
+        (F (s.filter (fun j => t j ≤ t i))-F (s.filter (fun j => t j < t i))) := by
+  let Δ := fun i => F (s.filter (fun j => t j ≤ t i))-F (s.filter (fun j => t j < t i))
+  have hi (i : ι) : Integrable (fun x => φ x * (if t i < x then Δ i else 0)) := by
+    have he : (fun x => φ x * (if t i < x then Δ i else 0)) =
+        (Ioi (t i)).indicator (fun x => φ x * Δ i) := by
+      funext x; by_cases hx : t i < x <;> simp [hx]
+    rw [he]
+    exact (hφ.mul_const _).indicator measurableSet_Ioi
+  have he (x : ℝ) : φ x * F (s.filter (fun i => t i < x)) =
+      φ x * F ∅ + ∑ i ∈ s, φ x * (if t i < x then Δ i else 0) := by
+    rw [threshold_decomposition s t ht F x, mul_add, Finset.mul_sum]
+  simp_rw [he]
+  rw [integral_add (hφ.mul_const _) (integrable_finsetSum _ (fun i _ => hi i)),
+    integral_mul_const, integral_finsetSum _ (fun i _ => hi i)]
+  congr 1
+  apply Finset.sum_congr rfl
+  intro i hi'
+  have he : (fun x => φ x * (if t i < x then Δ i else 0)) =
+      (Ioi (t i)).indicator (fun x => φ x * Δ i) := by
+    funext x; by_cases hx : t i < x <;> simp [hx]
+  rw [he, integral_indicator measurableSet_Ioi, integral_mul_const]
+
+lemma tail_integral_hasDerivAt {φ : ℝ → ℝ} (hφ : Integrable φ) (hc : Continuous φ) (x : ℝ) :
+    HasDerivAt (fun t => ∫ z in Ioi t, φ z) (-φ x) x := by
+  have he (t : ℝ) : (∫ z in Ioi t, φ z) = (∫ z in Ioi (0:ℝ), φ z)-(∫ z in (0:ℝ)..t, φ z) := by
+    rw [← intervalIntegral.integral_Ioi_sub_Ioi' hφ.integrableOn hφ.integrableOn]
+    ring
+  rw [show (fun t => ∫ z in Ioi t, φ z) = (fun t => (∫ z in Ioi (0:ℝ), φ z)-(∫ z in (0:ℝ)..t, φ z)) from funext he]
+  exact (intervalIntegral.integral_hasDerivAt_right (hφ.intervalIntegrable) hc.stronglyMeasurable.stronglyMeasurableAtFilter hc.continuousAt).const_sub _
+end ContinuousEvents
+
+section Slope
+variable [Fintype ι]
+
+omit [Fintype ι] in
+lemma eventually_order_eq {X : Type u6} [TopologicalSpace X] (s : Finset ι) (t : ι → X → ℝ) {y : X}
+    (ht : ∀ i ∈ s, ContinuousAt (t i) y) (hi : Set.InjOn (fun i => t i y) s) :
+    ∀ᶠ z in 𝓝 y, Set.InjOn (fun i => t i z) s ∧
+      ∀ i ∈ s, s.filter (fun j => t j z ≤ t i z) = s.filter (fun j => t j y ≤ t i y) ∧
+        s.filter (fun j => t j z < t i z) = s.filter (fun j => t j y < t i y) := by
+  have hp (i : ι) (his : i ∈ s) (j : ι) (hjs : j ∈ s) :
+      ∀ᶠ z in 𝓝 y, (t i z < t j z ↔ t i y < t j y) := by
+    by_cases hij : i = j
+    · subst j; simp
+    have hne : t i y ≠ t j y := fun he => hij (hi his hjs he)
+    rcases hne.lt_or_gt with h | h
+    · filter_upwards [(ht i his).eventually_lt (ht j hjs) h] with z hz
+      exact iff_of_true hz h
+    · filter_upwards [(ht j hjs).eventually_lt (ht i his) h] with z hz
+      exact iff_of_false (not_lt.mpr hz.le) (not_lt.mpr h.le)
+  have hall : ∀ᶠ z in 𝓝 y, ∀ i ∈ s, ∀ j ∈ s, (t i z < t j z ↔ t i y < t j y) :=
+    s.eventually_all.mpr (fun i his => s.eventually_all.mpr (fun j hjs => hp i his j hjs))
+  filter_upwards [hall] with z hz
+  refine ⟨?_,?_⟩
+  · intro i his j hjs he
+    change t i z=t j z at he
+    apply hi his hjs
+    apply le_antisymm
+    · apply not_lt.mp
+      intro h
+      have := (hz j hjs i his).mpr h
+      rw [he] at this
+      exact (lt_irrefl _ this)
+    · apply not_lt.mp
+      intro h
+      have := (hz i his j hjs).mpr h
+      rw [he] at this
+      exact (lt_irrefl _ this)
+  · intro i his
+    constructor <;> ext j <;> simp only [Finset.mem_filter]
+    · apply and_congr_right
+      intro hjs
+      simp only [← not_lt, hz i his j hjs]
+    · exact and_congr_right (fun hjs => hz j hjs i his)
+
+omit [Fintype ι] in
+lemma moving_threshold_integral_hasDerivAt (s : Finset ι) (t : ι → ℝ → ℝ)
+    (F : Finset ι → ℝ) {y : ℝ} (t' : ι → ℝ)
+    (ht : ∀ i ∈ s, HasDerivAt (t i) (t' i) y) (hi : Set.InjOn (fun i => t i y) s)
+    {φ : ℝ → ℝ} (hφ : Integrable φ) (hc : Continuous φ) :
+    HasDerivAt (fun z => ∫ x, φ x * F (s.filter (fun i => t i z < x)))
+      (-∑ i ∈ s, t' i * φ (t i y) *
+        (F (s.filter (fun j => t j y ≤ t i y))-F (s.filter (fun j => t j y < t i y)))) y := by
+  let Δ := fun i => F (s.filter (fun j => t j y ≤ t i y))-F (s.filter (fun j => t j y < t i y))
+  have he : (fun z => ∫ x, φ x * F (s.filter (fun i => t i z < x))) =ᶠ[𝓝 y]
+      (fun z => (∫ x, φ x)*F ∅ + ∑ i ∈ s, (∫ x in Ioi (t i z), φ x)*Δ i) := by
+    filter_upwards [eventually_order_eq s t (fun i his => (ht i his).continuousAt) hi] with z hz
+    rw [threshold_integral s (fun i => t i z) hz.1 F hφ]
+    congr 1
+    apply Finset.sum_congr rfl
+    intro i his
+    rw [(hz.2 i his).1,(hz.2 i his).2]
+  have hd (i : ι) (his : i ∈ s) : HasDerivAt (fun z => (∫ x in Ioi (t i z), φ x)*Δ i)
+      (-(t' i * φ (t i y)*Δ i)) y := by
+    convert ((tail_integral_hasDerivAt hφ hc (t i y)).comp y (ht i his)).mul_const (Δ i) using 1 <;> try rfl
+    ring
+  have hs := (HasDerivAt.sum (fun i his => hd i his)).const_add ((∫ x, φ x)*F ∅)
+  simp only [Finset.sum_neg_distrib, Finset.sum_apply] at hs
+  exact hs.congr_of_eventuallyEq he
+
+end Slope
+
+section Weak
+variable [Fintype ι]
+
+lemma integral_deriv_zero_off_countable {f f' : ℝ → ℝ}
+    (hf : Continuous f) (hs : HasCompactSupport f) (hs' : HasCompactSupport f')
+    (hi : Integrable f') {bad : Set ℝ} (hb : bad.Countable)
+    (hd : ∀ x ∉ bad, HasDerivAt f (f' x) x) : ∫ x, f' x = 0 := by
+  obtain ⟨R,hR,hbound⟩ := (hs.isCompact.union hs'.isCompact).isBounded.exists_pos_norm_lt
+  have hf0 {x : ℝ} (hx : R ≤ |x|) : f x=0 := by
+    apply image_eq_zero_of_notMem_tsupport
+    intro hm
+    have := hbound x (Or.inl hm)
+    simpa only [Real.norm_eq_abs] using not_lt.mpr hx this
+  have hf'0 {x : ℝ} (hx : R ≤ |x|) : f' x=0 := by
+    apply image_eq_zero_of_notMem_tsupport
+    intro hm
+    have := hbound x (Or.inr hm)
+    simpa only [Real.norm_eq_abs] using not_lt.mpr hx this
+  have hI := integral_eq_of_hasDerivAt_off_countable_of_le f f' (by linarith : -R ≤ R)
+    hb hf.continuousOn (fun x hx => hd x hx.2) hi.intervalIntegrable
+  rw [hf0 (by rw [abs_of_pos hR]), hf0 (by rw [abs_neg,abs_of_pos hR]),sub_self,
+    intervalIntegral.integral_of_le (by linarith)] at hI
+  rw [setIntegral_eq_integral_of_forall_compl_eq_zero (fun x hx => hf'0 (by
+    simp only [mem_Ioc,not_and_or,not_lt,not_le] at hx
+    rcases hx with hx | hx
+    · exact (neg_le_abs x).trans' (by linarith)
+    · exact (le_abs_self x).trans' hx.le))] at hI
+  exact hI
+
+omit [DecidableEq ι] in
+lemma affine_collisions_countable (s : Finset ι) (a b : ι → ℝ)
+    (hab : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → a i ≠ a j ∨ b i ≠ b j) :
+    {y : ℝ | ¬ Set.InjOn (fun i => a i*y+b i) s}.Countable := by
+  classical
+  have hp (i j : ι) : {y : ℝ | i ∈ s ∧ j ∈ s ∧ i ≠ j ∧ a i*y+b i=a j*y+b j}.Subsingleton := by
+    intro x hx y hy
+    have h := hab i hx.1 j hx.2.1 hx.2.2.1
+    rcases h with h | h
+    · have he : (a i-a j)*(x-y)=0 := by nlinarith [hx.2.2.2,hy.2.2.2]
+      exact sub_eq_zero.mp ((mul_eq_zero.mp he).resolve_left (sub_ne_zero.mpr h))
+    · by_cases ha : a i=a j
+      · exfalso; apply h; have he := hx.2.2.2; rw [ha] at he; linarith
+      · have he : (a i-a j)*(x-y)=0 := by nlinarith [hx.2.2.2,hy.2.2.2]
+        exact sub_eq_zero.mp ((mul_eq_zero.mp he).resolve_left (sub_ne_zero.mpr ha))
+  apply (countable_iUnion (fun i => countable_iUnion (fun j => (hp i j).countable))).mono
+  intro y hy
+  simp only [mem_ofPred_eq,Set.InjOn,not_forall] at hy
+  obtain ⟨i,hi,j,hj,he,hne⟩ := hy
+  exact mem_iUnion.mpr ⟨i,mem_iUnion.mpr ⟨j,hi,hj,hne,he⟩⟩
+
+lemma moving_threshold_weak (s : Finset ι) (a b : ι → ℝ)
+    (hab : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → a i ≠ a j ∨ b i ≠ b j)
+    (F : Finset ι → ℝ) {φ χ χ' : ℝ → ℝ}
+    (hφ : Integrable φ) (hcφ : Continuous φ) (hcχ : Continuous χ)
+    (hsχ : HasCompactSupport χ) (hsχ' : HasCompactSupport χ')
+    (hdχ : ∀ y, HasDerivAt χ (χ' y) y)
+    (hi₁ : Integrable (fun y => χ' y * ∫ x, φ x * F (s.filter (fun i => a i*y+b i < x))))
+    (hi₂ : Integrable (fun y => χ y * ∑ i ∈ s, a i * φ (a i*y+b i) *
+      (F (s.filter (fun j => a j*y+b j ≤ a i*y+b i))-F (s.filter (fun j => a j*y+b j < a i*y+b i))))) :
+    (∫ y, χ' y * ∫ x, φ x * F (s.filter (fun i => a i*y+b i < x))) =
+      ∫ y, χ y * ∑ i ∈ s, a i * φ (a i*y+b i) *
+      (F (s.filter (fun j => a j*y+b j ≤ a i*y+b i))-F (s.filter (fun j => a j*y+b j < a i*y+b i))) := by
+  let H := fun y => ∫ x, φ x * F (s.filter (fun i => a i*y+b i < x))
+  let D := fun y => ∑ i ∈ s, a i * φ (a i*y+b i) *
+      (F (s.filter (fun j => a j*y+b j ≤ a i*y+b i))-F (s.filter (fun j => a j*y+b j < a i*y+b i)))
+  have hH : Continuous H := continuous_iff_continuousAt.mpr (fun y =>
+    continuousAt_threshold_integral s (fun i y => a i*y+b i) F (fun _ _ => by fun_prop) hφ)
+  have hprod : HasCompactSupport (fun y => χ y * H y) := hsχ.mul_right
+  have hder : HasCompactSupport (fun y => χ' y * H y-χ y * D y) :=
+    hsχ'.mul_right.sub hsχ.mul_right
+  have hzero := integral_deriv_zero_off_countable (hcχ.mul hH) hprod hder (hi₁.sub hi₂)
+    (affine_collisions_countable s a b hab) (fun y hy => by
+      have hdy := moving_threshold_integral_hasDerivAt s (fun i y => a i*y+b i) F a
+        (fun i _ => by simpa using ((hasDerivAt_id y).const_mul (a i)).add_const (b i))
+        (not_not.mp hy) hφ hcφ
+      convert (hdχ y).mul hdy using 1
+      dsimp [D]
+      ring)
+  rw [integral_sub hi₁ hi₂,sub_eq_zero] at hzero
+  exact hzero
+
+end Weak
+
+section Lipschitz
+variable [Fintype ι]
+
+lemma threshold_integrable (s : Finset ι) (t : ι → ℝ) (F : Finset ι → ℝ)
+    {φ : ℝ → ℝ} (hφ : Integrable φ) :
+    Integrable (fun x => φ x * F (s.filter (fun i => t i < x))) := by
+  classical
+  let M := ∑ a : Finset ι, |F a|
+  apply hφ.mul_bdd (measurable_filter_apply s (fun i x => t i < x)
+      (fun _ => measurableSet_Ioi) F).aestronglyMeasurable
+  apply ae_of_all
+  intro x
+  exact Finset.single_le_sum (f := fun a : Finset ι => |F a|) (fun _ _ => abs_nonneg _) (Finset.mem_univ _)
+
+lemma threshold_pointwise_bound (s : Finset ι) (t u : ι → ℝ) (F : Finset ι → ℝ)
+    {M : ℝ} (hM0 : 0 ≤ M) (hM : ∀ a, |F a| ≤ M) (x : ℝ) :
+    |F (s.filter (fun i => t i < x))-F (s.filter (fun i => u i < x))| ≤
+      2*M*∑ i ∈ s, (uIoc (t i) (u i)).indicator (fun _ => (1:ℝ)) x := by
+  classical
+  have hn (i : ι) : 0 ≤ (uIoc (t i) (u i)).indicator (fun _ => (1:ℝ)) x := by
+    by_cases hx : x ∈ uIoc (t i) (u i) <;> simp [hx]
+  by_cases he : ∀ i ∈ s, t i < x ↔ u i < x
+  · have he' : s.filter (fun i => t i < x) = s.filter (fun i => u i < x) := by
+      ext i; simp only [Finset.mem_filter]; exact and_congr_right (he i)
+    rw [he',sub_self,abs_zero]
+    exact mul_nonneg (by positivity) (Finset.sum_nonneg (fun i _ => hn i))
+  · simp only [not_forall] at he
+    obtain ⟨i,his,hi⟩ := he
+    have hx : x ∈ uIoc (t i) (u i) := by
+      change min (t i) (u i) < x ∧ x ≤ max (t i) (u i)
+      rcases lt_or_ge (t i) x with ht | ht <;> rcases lt_or_ge (u i) x with hu | hu
+      · exact False.elim (hi (iff_of_true ht hu))
+      · exact ⟨(min_le_left _ _).trans_lt ht,hu.trans (le_max_right _ _)⟩
+      · exact ⟨(min_le_right _ _).trans_lt hu,ht.trans (le_max_left _ _)⟩
+      · exact False.elim (hi (iff_of_false (not_lt.mpr ht) (not_lt.mpr hu)))
+    have hs : 1 ≤ ∑ i ∈ s, (uIoc (t i) (u i)).indicator (fun _ => (1:ℝ)) x := by
+      have hh := Finset.single_le_sum (fun j _ => hn j) his
+      simpa [hx] using hh
+    calc
+      _ ≤ |F (s.filter (fun i => t i < x))|+|F (s.filter (fun i => u i < x))| := abs_sub _ _
+      _ ≤ 2*M := by linarith [hM (s.filter (fun i => t i < x)),hM (s.filter (fun i => u i < x))]
+      _ ≤ _ := le_mul_of_one_le_right (by positivity) hs
+
+lemma threshold_integral_diff_bound (s : Finset ι) (t u : ι → ℝ) (F : Finset ι → ℝ)
+    {φ : ℝ → ℝ} (hφ : Integrable φ) {M C : ℝ} (hM0 : 0 ≤ M) (hC : 0 ≤ C)
+    (hM : ∀ a, |F a| ≤ M) (hφC : ∀ x, |φ x| ≤ C) :
+    |(∫ x, φ x * F (s.filter (fun i => t i < x)))-
+      (∫ x, φ x * F (s.filter (fun i => u i < x)))| ≤
+      2*M*C*∑ i ∈ s, |u i-t i| := by
+  classical
+  let I := fun i x => (uIoc (t i) (u i)).indicator (fun _ => (1:ℝ)) x
+  have hi (i : ι) : Integrable (I i) := by
+    exact (integrable_indicator_iff measurableSet_uIoc).mpr (integrableOn_const (μ := volume) (s := uIoc (t i) (u i)) (C := (1:ℝ)) (by rw [Real.volume_uIoc]; exact ENNReal.ofReal_ne_top))
+  have hiS : Integrable (fun x => 2*M*C*∑ i ∈ s, I i x) :=
+    (integrable_finsetSum s (fun i _ => hi i)).const_mul _
+  have hbound (x : ℝ) : ‖φ x*(F (s.filter (fun i => t i < x))-F (s.filter (fun i => u i < x)))‖ ≤
+      2*M*C*∑ i ∈ s, I i x := by
+    rw [Real.norm_eq_abs,abs_mul]
+    have hp := mul_le_mul (hφC x) (threshold_pointwise_bound s t u F hM0 hM x) (abs_nonneg _) hC
+    dsimp [I]
+    convert hp using 1
+    first | rfl | ring
+  rw [← integral_sub (threshold_integrable s t F hφ) (threshold_integrable s u F hφ)]
+  simp_rw [← mul_sub]
+  calc
+    _ ≤ ∫ x, 2*M*C*∑ i ∈ s, I i x := by
+      simpa only [Real.norm_eq_abs] using norm_integral_le_of_norm_le hiS (ae_of_all _ hbound)
+    _ = 2*M*C*∑ i ∈ s, |u i-t i| := by
+      rw [integral_const_mul,integral_finsetSum s (fun i _ => hi i)]
+      congr 1
+      apply Finset.sum_congr rfl
+      intro i _
+      dsimp [I]
+      change (∫ x, (uIoc (t i) (u i)).indicator (1 : ℝ → ℝ) x) = _
+      rw [integral_indicator_one measurableSet_uIoc,measureReal_def,Real.volume_uIoc,ENNReal.toReal_ofReal (abs_nonneg _)]
+
+end Lipschitz
+
+section FDeriv
+variable [Fintype ι]
+variable {X : Type u7} [NormedAddCommGroup X] [NormedSpace ℝ X]
+
+omit [Fintype ι] in
+lemma moving_threshold_integral_hasFDerivAt (s : Finset ι) (t : ι → X → ℝ)
+    (F : Finset ι → ℝ) {y : X} (t' : ι → X →L[ℝ] ℝ)
+    (ht : ∀ i ∈ s, HasFDerivAt (t i) (t' i) y) (hi : Set.InjOn (fun i => t i y) s)
+    {φ : ℝ → ℝ} (hφ : Integrable φ) (hc : Continuous φ) :
+    HasFDerivAt (fun z => ∫ x, φ x * F (s.filter (fun i => t i z < x)))
+      (∑ i ∈ s, (-(φ (t i y) *
+        (F (s.filter (fun j => t j y ≤ t i y))-F (s.filter (fun j => t j y < t i y))))) • t' i) y := by
+  let Δ := fun i => F (s.filter (fun j => t j y ≤ t i y))-F (s.filter (fun j => t j y < t i y))
+  have he : (fun z => ∫ x, φ x * F (s.filter (fun i => t i z < x))) =ᶠ[𝓝 y]
+      (fun z => (∫ x, φ x)*F ∅ + ∑ i ∈ s, (∫ x in Ioi (t i z), φ x)*Δ i) := by
+    filter_upwards [eventually_order_eq s t (fun i his => (ht i his).continuousAt) hi] with z hz
+    rw [threshold_integral s (fun i => t i z) hz.1 F hφ]
+    congr 1
+    apply Finset.sum_congr rfl
+    intro i his
+    rw [(hz.2 i his).1,(hz.2 i his).2]
+  have hd (i : ι) (his : i ∈ s) : HasFDerivAt (fun z => (∫ x in Ioi (t i z), φ x)*Δ i)
+      (-(φ (t i y)*Δ i) • t' i) y := by
+    convert ((tail_integral_hasDerivAt hφ hc (t i y)).comp_hasFDerivAt y (ht i his)).mul_const (Δ i) using 1 <;> try rfl
+    simp only [smul_smul]
+    congr 1; ring
+  have hs := (HasFDerivAt.sum (fun i his => hd i his)).const_add ((∫ x, φ x)*F ∅)
+  simp only [Finset.sum_apply] at hs
+  exact hs.congr_of_eventuallyEq he
+
+lemma affine_threshold_lipschitz (s : Finset ι) (L : ι → X →L[ℝ] ℝ) (b : ι → ℝ)
+    (F : Finset ι → ℝ) {φ : ℝ → ℝ} (hφ : Integrable φ)
+    {M C : ℝ} (hM0 : 0 ≤ M) (hC : 0 ≤ C) (hM : ∀ a, |F a| ≤ M) (hφC : ∀ x, |φ x| ≤ C) :
+    LipschitzWith (Real.nnabs (2*M*C*∑ i ∈ s, ‖L i‖))
+      (fun y => ∫ x, φ x * F (s.filter (fun i => L i y+b i < x))) := by
+  apply LipschitzWith.of_dist_le_mul
+  intro y z
+  simp only [dist_eq_norm]
+  have hb := threshold_integral_diff_bound s (fun i => L i y+b i) (fun i => L i z+b i) F hφ hM0 hC hM hφC
+  simp only [Real.norm_eq_abs] at ⊢
+  refine hb.trans ?_
+  have hs : (∑ i ∈ s, |L i z+b i-(L i y+b i)|) ≤ (∑ i ∈ s, ‖L i‖)*‖y-z‖ := by
+    rw [Finset.sum_mul]
+    apply Finset.sum_le_sum
+    intro i _
+    have ht := (L i).le_opNorm (z-y)
+    simpa only [map_sub, Real.norm_eq_abs, add_sub_add_right_eq_sub, norm_sub_rev z y] using ht
+  exact mul_le_mul_of_nonneg_left hs (by positivity) |>.trans_eq (by simp only [Real.coe_nnabs, abs_of_nonneg (show 0 ≤ 2*M*C*∑ i ∈ s, ‖L i‖ by positivity)]; ring)
+
+end FDeriv
+
+end UniformSparsestCut.InterfaceStep
+
+namespace UniformSparsestCut.InterfaceStep
+open MeasureTheory Set
+open scoped BigOperators Topology
+variable {ι : Type u8} {X : Type u9} {Z : Type u10} [DecidableEq ι] [Fintype ι]
+  [NormedAddCommGroup X] [NormedSpace ℝ X] [MeasurableSpace Z]
+
+lemma averaged_threshold_derivative (s : Finset ι) (L : ι → X →L[ℝ] ℝ)
+    (b : ι → Z → ℝ) (hb : ∀ i, Measurable (b i)) (F : Finset ι → ℝ)
+    {φ : ℝ → ℝ} (hφ : Integrable φ) (hc : Continuous φ)
+    {M C : ℝ} (hM0 : 0 ≤ M) (hC : 0 ≤ C) (hM : ∀ a, |F a| ≤ M) (hφC : ∀ x, |φ x| ≤ C)
+    (μ : Measure Z) [IsFiniteMeasure μ] (y : X)
+    (hi : ∀ᵐ z ∂μ, Set.InjOn (fun i => L i y+b i z) s) :
+    HasFDerivAt (fun y => ∫ z, (∫ x, φ x * F (s.filter (fun i => L i y+b i z < x))) ∂μ)
+      (∑ i ∈ s, (∫ z, -(φ (L i y+b i z) *
+        (F (s.filter (fun j => L j y+b j z ≤ L i y+b i z))-
+          F (s.filter (fun j => L j y+b j z < L i y+b i z)))) ∂μ) • L i) y := by
+  let H : X → Z → ℝ := fun y z => ∫ x, φ x * F (s.filter (fun i => L i y+b i z < x))
+  let c : ι → Z → ℝ := fun i z => -(φ (L i y+b i z) *
+    (F (s.filter (fun j => L j y+b j z ≤ L i y+b i z))-
+      F (s.filter (fun j => L j y+b j z < L i y+b i z))))
+  have hmH (y : X) : StronglyMeasurable (H y) := by
+    apply StronglyMeasurable.integral_prod_right
+    apply Measurable.stronglyMeasurable
+    exact (hc.measurable.comp measurable_snd).mul (measurable_filter_apply s
+      (fun i (p : Z × ℝ) => L i y+b i p.1 < p.2)
+      (fun i => measurableSet_lt ((measurable_const.add ((hb i).comp measurable_fst))) measurable_snd) F)
+  have hmC (i : ι) : Measurable (c i) := by
+    apply Measurable.neg
+    apply Measurable.mul (hc.measurable.comp (measurable_const.add (hb i)))
+    exact (measurable_filter_apply s (fun j z => L j y+b j z ≤ L i y+b i z)
+      (fun j => measurableSet_le (measurable_const.add (hb j)) (measurable_const.add (hb i))) F).sub
+      (measurable_filter_apply s (fun j z => L j y+b j z < L i y+b i z)
+      (fun j => measurableSet_lt (measurable_const.add (hb j)) (measurable_const.add (hb i))) F)
+  have hcB (i : ι) (z : Z) : ‖c i z‖ ≤ C*(2*M) := by
+    dsimp [c]
+    simp only [abs_neg,abs_mul]
+    have hd := abs_sub_le (F (s.filter (fun j => L j y+b j z ≤ L i y+b i z))) 0
+      (F (s.filter (fun j => L j y+b j z < L i y+b i z)))
+    simp only [sub_zero,zero_sub,abs_neg] at hd
+    apply mul_le_mul (hφC _) _ (abs_nonneg _) hC
+    linarith [hM (s.filter (fun j => L j y+b j z ≤ L i y+b i z)),
+      hM (s.filter (fun j => L j y+b j z < L i y+b i z))]
+  have hiC (i : ι) : Integrable (c i) μ :=
+    (integrable_const (C*(2*M))).mono' (hmC i).aestronglyMeasurable (ae_of_all _ (hcB i))
+  have hiH : Integrable (H y) μ := by
+    apply (integrable_const (∫ x, |φ x| * M)).mono' (hmH y).aestronglyMeasurable
+    filter_upwards with z
+    apply norm_integral_le_of_norm_le (hφ.abs.mul_const M)
+    filter_upwards with x
+    rw [Real.norm_eq_abs,abs_mul]
+    exact mul_le_mul_of_nonneg_left (hM _) (abs_nonneg _)
+  let K : NNReal := Real.nnabs (2*M*C*∑ i ∈ s, ‖L i‖)
+  have hLip (z : Z) : LipschitzWith K (fun y => H y z) :=
+    affine_threshold_lipschitz s L (fun i => b i z) F hφ hM0 hC hM hφC
+  have hD : ∀ᵐ z ∂μ, HasFDerivAt (fun y => H y z) (∑ i ∈ s, c i z • L i) y := by
+    filter_upwards [hi] with z hz
+    exact moving_threshold_integral_hasFDerivAt s (fun i y => L i y+b i z) F L
+      (fun i _ => (L i).hasFDerivAt.add_const _) hz hφ hc
+  have hres := hasFDerivAt_integral_of_dominated_loc_of_lip (μ := μ) (F := H)
+    (s := Set.univ) (bound := fun _ => (K : ℝ)) (F' := fun z => ∑ i ∈ s, c i z • L i)
+    (Filter.univ_mem) (Filter.Eventually.of_forall (fun x => (hmH x).aestronglyMeasurable)) hiH
+    (by
+      have hm := (Finset.stronglyMeasurable_sum s (fun i _ => (hmC i).stronglyMeasurable.smul_const (L i))).aestronglyMeasurable (μ := μ)
+      have he : (∑ i ∈ s, (fun z => c i z • L i)) = (fun z => ∑ i ∈ s, c i z • L i) := by
+        funext z; exact Finset.sum_apply z s _
+      rw [he] at hm
+      exact hm)
+    (ae_of_all _ (fun z => by simpa using (hLip z).lipschitzOnWith (s := Set.univ)))
+    (integrable_const _) hD
+  rw [integral_finsetSum s (fun i _ => (hiC i).smul_const (L i))] at hres
+  simp only [integral_smul_const] at hres
+  exact hres.2
+
+end UniformSparsestCut.InterfaceStep
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/KernelApprox.lean

@@ -0,0 +1,184 @@
+import OAI.Combinatorics.SparsestCut.PositiveKernels
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.KernelApprox
+
+def profile (t : ℝ) : ℝ := 1 - Real.exp (-1/(2*t^2))
+
+lemma profile_nonneg (t : ℝ) : 0 ≤ profile t := by
+  unfold profile
+  have h : -1/(2*t^2) ≤ 0 := div_nonpos_of_nonpos_of_nonneg (by norm_num) (by positivity)
+  linarith [Real.exp_le_one_iff.mpr h]
+
+lemma profile_le_one (t : ℝ) : profile t ≤ 1 := by
+  unfold profile
+  linarith [Real.exp_pos (-1/(2*t^2))]
+
+lemma profile_le_inv_sq (t : ℝ) : profile t ≤ 1/(2*t^2) := by
+  have h := Real.add_one_le_exp (-1/(2*t^2))
+  unfold profile
+  rw [neg_div] at h ⊢
+  linarith
+
+lemma profile_pos {t : ℝ} (ht : t ≠ 0) : 0 < profile t := by
+  unfold profile
+  have h : -1/(2*t^2) < 0 := div_neg_of_neg_of_pos (by norm_num) (by positivity)
+  linarith [Real.exp_lt_one_iff.mpr h]
+
+lemma profile_measurable : Measurable profile := by unfold profile; fun_prop
+
+lemma profile_integrable_lower : IntegrableOn profile (Ioc 0 1) := by
+  apply (integrableOn_const (C := (1 : ℝ)) (s := Ioc (0 : ℝ) 1) (by simp)).mono'
+    profile_measurable.aestronglyMeasurable
+  filter_upwards with t
+  simpa only [Real.norm_eq_abs, abs_of_nonneg (profile_nonneg t)] using profile_le_one t
+
+lemma profile_integrable_upper : IntegrableOn profile (Ioi 1) := by
+  have hi := (integrableOn_Ioi_rpow_of_lt (by norm_num : (-2 : ℝ) < -1)
+    (by norm_num : (0 : ℝ) < 1)).const_mul (1/2 : ℝ)
+  apply hi.mono' profile_measurable.aestronglyMeasurable
+  filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht
+  change 1 < t at ht
+  have he : (1/2 : ℝ)*t^(-2 : ℝ) = 1/(2*t^2) := by
+    rw [Real.rpow_neg (by linarith : 0 ≤ t), Real.rpow_two]
+    ring
+  simpa only [Real.norm_eq_abs, abs_of_nonneg (profile_nonneg t), he] using profile_le_inv_sq t
+
+lemma profile_integrable : IntegrableOn profile (Ioi 0) := by
+  have h := profile_integrable_lower.union profile_integrable_upper
+  simpa only [Ioc_union_Ioi_eq_Ioi (by norm_num : (0 : ℝ) ≤ 1)] using h
+
+noncomputable def cstar : ℝ := 2 * ∫ t in Ioi (0 : ℝ), profile t
+
+lemma cstar_pos : 0 < cstar := by
+  have hp : 0 < ∫ t in Ioi (0 : ℝ), profile t := by
+    apply (integral_pos_iff_support_of_nonneg_ae _ profile_integrable).mpr
+    · have hs : Ioi (0 : ℝ) ⊆ Function.support profile := by
+        intro t ht
+        exact ne_of_gt (profile_pos (ne_of_gt ht))
+      have hc : (volume.restrict (Ioi (0 : ℝ))) (Ioi (0 : ℝ)) ≠ 0 := by simp
+      exact bot_lt_iff_ne_bot.mpr (ne_bot_of_le_ne_bot hc (measure_mono hs))
+    · filter_upwards with t using profile_nonneg t
+  exact mul_pos (by norm_num) hp
+
+def scaled (r t : ℝ) : ℝ := 1-Real.exp (-r^2/(2*t^2))
+
+lemma scaled_eq_profile (r t : ℝ) : scaled r t = profile (t/r) := by
+  by_cases hr : r = 0
+  · simp [hr, scaled, profile]
+  by_cases ht : t = 0
+  · simp [ht, scaled, profile]
+  unfold scaled profile
+  congr 2
+  field_simp
+
+lemma scaled_nonneg (r t : ℝ) : 0 ≤ scaled r t := by
+  rw [scaled_eq_profile]; exact profile_nonneg _
+
+lemma scaled_le_one (r t : ℝ) : scaled r t ≤ 1 := by
+  rw [scaled_eq_profile]; exact profile_le_one _
+
+lemma scaled_le_tail (r t : ℝ) : scaled r t ≤ r^2/(2*t^2) := by
+  have h := Real.add_one_le_exp (-r^2/(2*t^2))
+  unfold scaled
+  rw [neg_div] at h ⊢
+  linarith
+
+lemma scaled_measurable (r : ℝ) : Measurable (scaled r) := by unfold scaled; fun_prop
+
+lemma scaled_integrable_lower (r : ℝ) {a : ℝ} (_ha : 0 ≤ a) :
+    IntegrableOn (scaled r) (Ioc 0 a) := by
+  apply (integrableOn_const (C := (1 : ℝ)) (s := Ioc (0 : ℝ) a) (by simp)).mono'
+    (scaled_measurable r).aestronglyMeasurable
+  filter_upwards with t
+  simpa only [Real.norm_eq_abs, abs_of_nonneg (scaled_nonneg r t)] using scaled_le_one r t
+
+lemma scaled_integrable_upper (r : ℝ) {a : ℝ} (ha : 0 < a) :
+    IntegrableOn (scaled r) (Ioi a) := by
+  have hi := (integrableOn_Ioi_rpow_of_lt (by norm_num : (-2 : ℝ) < -1) ha).const_mul (r^2/2)
+  apply hi.mono' (scaled_measurable r).aestronglyMeasurable
+  filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht
+  change a < t at ht
+  have he : (r^2/2)*t^(-2 : ℝ) = r^2/(2*t^2) := by
+    rw [Real.rpow_neg (by linarith : 0 ≤ t), Real.rpow_two]
+    ring
+  simpa only [Real.norm_eq_abs, abs_of_nonneg (scaled_nonneg r t), he] using scaled_le_tail r t
+
+lemma scaled_integrable (r : ℝ) : IntegrableOn (scaled r) (Ioi 0) := by
+  have h := (scaled_integrable_lower r (by norm_num : (0 : ℝ) ≤ 1)).union
+    (scaled_integrable_upper r (by norm_num : (0 : ℝ) < 1))
+  simpa only [Ioc_union_Ioi_eq_Ioi (by norm_num : (0 : ℝ) ≤ 1)] using h
+
+lemma full_integral {r : ℝ} (hr : 0 ≤ r) :
+    2 * (∫ t in Ioi (0 : ℝ), scaled r t) = cstar*r := by
+  rcases eq_or_lt_of_le hr with hz | hr
+  · simp [← hz, scaled]
+  simp_rw [scaled_eq_profile, div_eq_inv_mul]
+  rw [integral_comp_mul_left_Ioi profile 0 (inv_pos.mpr hr)]
+  simp only [mul_zero, inv_inv, smul_eq_mul, cstar]
+  ring
+
+lemma lower_tail_bound (r : ℝ) {a : ℝ} (ha : 0 ≤ a) :
+    (∫ t in Ioc (0 : ℝ) a, scaled r t) ≤ a := by
+  have h := integral_mono (scaled_integrable_lower r ha)
+    (integrableOn_const (C := (1 : ℝ)) (s := Ioc (0 : ℝ) a) (by simp))
+    (fun t => scaled_le_one r t)
+  simpa [integral_const, Real.volume_real_Ioc, ha] using h
+
+lemma upper_tail_bound (r : ℝ) {b : ℝ} (hb : 0 < b) :
+    (∫ t in Ioi b, scaled r t) ≤ r^2/(2*b) := by
+  have hi := (integrableOn_Ioi_rpow_of_lt (by norm_num : (-2 : ℝ) < -1) hb).const_mul (r^2/2)
+  calc
+    _ ≤ ∫ t in Ioi b, (r^2/2)*t^(-2 : ℝ) := by
+      apply integral_mono_ae (scaled_integrable_upper r hb) hi
+      filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht
+      change b < t at ht
+      rw [Real.rpow_neg (by linarith : 0 ≤ t), Real.rpow_two]
+      exact (scaled_le_tail r t).trans_eq (by ring)
+    _ = _ := by
+      rw [integral_const_mul, integral_Ioi_rpow_of_lt (by norm_num : (-2 : ℝ) < -1) hb]
+      norm_num
+      rw [Real.rpow_neg_one]
+      ring
+
+lemma truncated_error {r a b : ℝ} (hr : 0 ≤ r) (ha : 0 < a) (hab : a ≤ b) :
+    |2 * (∫ t in Ioc a b, scaled r t) - cstar*r| ≤ 2*a + r^2/b := by
+  have hb : 0 < b := ha.trans_le hab
+  have hi1 := scaled_integrable_lower r ha.le
+  have hi2 : IntegrableOn (scaled r) (Ioc a b) :=
+    (scaled_integrable r).mono_set (fun t ht => ha.trans ht.1)
+  have hi3 := scaled_integrable_upper r hb
+  have he : (∫ t in Ioi (0 : ℝ), scaled r t) =
+      (∫ t in Ioc (0 : ℝ) a, scaled r t) + (∫ t in Ioc a b, scaled r t) +
+      ∫ t in Ioi b, scaled r t := by
+    rw [← Ioc_union_Ioi_eq_Ioi hb.le, setIntegral_union]
+    · rw [← Ioc_union_Ioc_eq_Ioc ha.le hab, setIntegral_union]
+      · exact Ioc_disjoint_Ioc_of_le le_rfl
+      · exact measurableSet_Ioc
+      · exact hi1
+      · exact hi2
+    · exact Ioc_disjoint_Ioi_same
+    · exact measurableSet_Ioi
+    · exact scaled_integrable_lower r hb.le
+    · exact hi3
+  have hx := full_integral hr
+  rw [he] at hx
+  have hn1 : 0 ≤ ∫ t in Ioc (0 : ℝ) a, scaled r t := integral_nonneg (fun _ => scaled_nonneg _ _)
+  have hn3 : 0 ≤ ∫ t in Ioi b, scaled r t := integral_nonneg (fun _ => scaled_nonneg _ _)
+  have hu1 := lower_tail_bound r ha.le
+  have hu3 := upper_tail_bound r hb
+  have he' : r^2/b = 2*(r^2/(2*b)) := by ring
+  rw [abs_of_nonpos (by linarith), he']
+  linarith
+
+end UniformSparsestCut.KernelApprox
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/LabelCount.lean

@@ -0,0 +1,129 @@
+import OAI.Combinatorics.SparsestCut.WeightedMetric
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.LabelCount
+open scoped BigOperators RealInnerProductSpace
+open UniformSparsestCut
+variable {m N : ℕ}
+local notation "E" => EuclideanSpace ℝ (Fin m)
+
+def signature (B : ℤ) (l : Fin N → ℤ) : Finset (Fin N × ↥(Finset.Icc (-B) B)) :=
+  Finset.univ.filter (fun p => p.2.val ≤ l p.1)
+
+lemma signature_injective (B : ℤ) (A : Finset (Fin N → ℤ))
+    (hA : ∀ l ∈ A, ∀ i, l i ∈ Finset.Icc (-B) B) :
+    Set.InjOn (signature B) (↑A : Set (Fin N → ℤ)) := by
+  intro l hl k hk he
+  funext i
+  apply le_antisymm
+  · have hm : (i,⟨l i,hA l hl i⟩) ∈ signature B l := by simp [signature]
+    rw [he] at hm
+    simpa [signature] using hm
+  · have hm : (i,⟨k i,hA k hk i⟩) ∈ signature B k := by simp [signature]
+    rw [← he] at hm
+    simpa [signature] using hm
+
+lemma regular_floor_iff (u : Fin N → E) {τ : ℝ} (hτ : 0 < τ)
+    {θ : E} (hθ : RoundedCharts.regular u τ θ) (i : Fin N) (k : ℤ) :
+    k ≤ RoundedCharts.integerLabel u τ θ i ↔ (k:ℝ)*τ < inner ℝ (u i) θ := by
+  rw [RoundedCharts.integerLabel, Int.le_floor]
+  rw [le_div_iff₀ hτ]
+  exact ⟨fun h => lt_of_le_of_ne h (Ne.symm (hθ i k)), le_of_lt⟩
+
+def affineForm (u : Fin N → E) (τ : ℝ) (B : ℤ)
+    (p : Fin N × ↥(Finset.Icc (-B) B)) : E × ℝ →ₗ[ℝ] ℝ :=
+  (innerSL ℝ (u p.1)).toLinearMap.comp (LinearMap.fst ℝ E ℝ) -
+    ((p.2.val:ℝ)*τ) • LinearMap.snd ℝ E ℝ
+
+lemma label_count (u : Fin N → E) {τ : ℝ} (hτ : 0 < τ) (B : ℤ)
+    (A : Finset (Fin N → ℤ))
+    (hb : ∀ l ∈ A, ∀ i, l i ∈ Finset.Icc (-B) B)
+    (hA : ∀ l ∈ A, ∃ θ : E, RoundedCharts.regular u τ θ ∧ RoundedCharts.integerLabel u τ θ = l) :
+    A.card ≤ ∑ j ∈ Finset.Iic (m+1), (N*(Finset.Icc (-B) B).card).choose j := by
+  let P := A.image (signature B)
+  have hP : ∀ p ∈ P, ∃ θ : E × ℝ, ∀ i,
+      affineForm u τ B i θ ≠ 0 ∧ (0 < affineForm u τ B i θ ↔ i ∈ p) := by
+    intro p hp
+    obtain ⟨l,hl,rfl⟩ := Finset.mem_image.mp hp
+    obtain ⟨θ,hr,hθ⟩ := hA l hl
+    refine ⟨(θ,1),?_⟩
+    intro i
+    have he : affineForm u τ B i (θ,1) = inner ℝ (u i.1) θ-(i.2.val:ℝ)*τ := by
+      simp [affineForm]
+    rw [he]
+    refine ⟨sub_ne_zero.mpr (hr _ _),?_⟩
+    rw [sub_pos, ← regular_floor_iff u hτ hr,hθ]
+    simp [signature]
+  have hc := HyperplaneCount.sign_patterns_bound (affineForm u τ B) P hP
+  have hdim : Module.finrank ℝ (E × ℝ) = m+1 := by simp [Module.finrank_prod]
+  have hcard : Fintype.card (Fin N × ↥(Finset.Icc (-B) B)) = N*(Finset.Icc (-B) B).card := by simp
+  rw [hdim,hcard] at hc
+  rwa [Finset.card_image_of_injOn (signature_injective B A hb)] at hc
+
+end UniformSparsestCut.LabelCount
+
+namespace UniformSparsestCut.LabelCount
+open scoped BigOperators
+noncomputable section
+lemma power_sum_le (H d : ℕ) : (∑ j∈Finset.range (d+1), H^j)≤(H+1)^d := by
+  induction d with
+  | zero => simp
+  | succ d ih =>
+    rw [Finset.sum_range_succ]
+    calc
+      _ ≤ (H+1)^d+H^(d+1) := Nat.add_le_add_right ih _
+      _ ≤ (H+1)^d+(H+1)^d*H := by
+        rw [pow_succ]
+        gcongr
+        omega
+      _ = (H+1)^(d+1) := by ring
+lemma binomial_sum_le (H d : ℕ) : (∑ j∈Finset.Iic d, H.choose j)≤(H+1)^d := by
+  have he : Finset.Iic d=Finset.range (d+1) := by ext j; simp
+  rw [he]
+  exact (Finset.sum_le_sum (fun j _ => Nat.choose_le_pow H j)).trans (power_sum_le H d)
+variable {m N S : ℕ}
+local notation "E" => EuclideanSpace ℝ (Fin m)
+lemma vertex_count (u : Fin S → Fin N → E) {τ : ℝ} (hτ : 0<τ)
+    [Fintype (RoundedCharts.Vertex u τ)] (B : ℤ)
+    (hb : ∀ v : RoundedCharts.Vertex u τ, ∀ i, v.val.2 i∈Finset.Icc (-B) B) :
+    Fintype.card (RoundedCharts.Vertex u τ)≤S*(N*(Finset.Icc (-B) B).card+1)^(m+1) := by
+  classical
+  let T (s : Fin S) := Finset.univ.filter (fun v : RoundedCharts.Vertex u τ => v.val.1=s)
+  let A (s : Fin S) := (T s).image (fun v => v.val.2)
+  have hcard (s : Fin S) : (T s).card=(A s).card := by
+    apply (Finset.card_image_of_injOn _).symm
+    intro v hv w hw h
+    apply Subtype.ext
+    apply Prod.ext
+    · exact (Finset.mem_filter.mp hv).2.trans (Finset.mem_filter.mp hw).2.symm
+    · exact h
+  have hs (s : Fin S) : (T s).card≤(N*(Finset.Icc (-B) B).card+1)^(m+1) := by
+    rw [hcard]
+    apply (label_count (u s) hτ B (A s) ?_ ?_).trans (binomial_sum_le _ _)
+    · intro l hl i
+      obtain ⟨v,hv,rfl⟩ := Finset.mem_image.mp hl
+      exact hb v i
+    · intro l hl
+      obtain ⟨v,hv,rfl⟩ := Finset.mem_image.mp hl
+      obtain ⟨θ,hθ,hr,hl⟩ := v.property
+      have he : v.val.1=s := (Finset.mem_filter.mp hv).2
+      exact ⟨θ,by simpa only [← he] using hr,by simpa only [�� he] using hl⟩
+  calc
+    _ = ∑ s, (T s).card := by
+      simpa only [Finset.card_univ] using (Finset.card_eq_sum_card_fiberwise
+        (f := fun v : RoundedCharts.Vertex u τ => v.val.1)
+        (s := Finset.univ) (t := Finset.univ) (fun _ _ => Finset.mem_univ _))
+    _ ≤ ∑ _s : Fin S, (N*(Finset.Icc (-B) B).card+1)^(m+1) := Finset.sum_le_sum (fun s _ => hs s)
+    _ = _ := by simp
+end
+end UniformSparsestCut.LabelCount
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/LatticeDensity.lean

@@ -0,0 +1,125 @@
+import OAI.Combinatorics.SparsestCut.ProductSlice
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.LatticeDensity
+
+lemma cell_bound {h h' : ℝ → ℝ} {a b : ℝ} (hab : a ≤ b)
+    (hd : ∀ t, HasDerivAt h (h' t) t) (hi : IntervalIntegrable h' volume a b) :
+    (b-a)*h a ≤ (∫ t in a..b, h t)+(b-a)*(∫ t in a..b, |h' t|) := by
+  have hc : Continuous h := continuous_iff_continuousAt.mpr (fun t => (hd t).continuousAt)
+  have hh : ∀ t ∈ Icc a b, h a ≤ h t+∫ x in a..b, |h' x| := by
+    intro t ht
+    have hid : IntervalIntegrable h' volume a t := hi.mono_set (by
+      rw [uIcc_of_le ht.1, uIcc_of_le hab]
+      exact Icc_subset_Icc le_rfl ht.2)
+    have he := intervalIntegral.integral_eq_sub_of_hasDerivAt (fun x _ => hd x) hid
+    have hm : (∫ x in a..t, |h' x|) ≤ ∫ x in a..b, |h' x| := by
+      apply intervalIntegral.integral_mono_interval le_rfl ht.1 ht.2
+      · filter_upwards with x using abs_nonneg (h' x)
+      · exact hi.abs
+    have hn := intervalIntegral.abs_integral_le_integral_abs (f := h') (μ := volume) ht.1
+    rw [he] at hn
+    have habs : h a-h t ≤ |h t-h a| := by rw [abs_sub_comm]; exact le_abs_self _
+    linarith
+  have h := intervalIntegral.integral_mono_on (μ := volume) hab intervalIntegrable_const
+    ((hc.intervalIntegrable a b).add intervalIntegrable_const) hh
+  rw [intervalIntegral.integral_const, intervalIntegral.integral_add (hc.intervalIntegrable a b) intervalIntegrable_const,
+    intervalIntegral.integral_const] at h
+  simpa only [smul_eq_mul] using h
+
+lemma lattice_intervals_disjoint {τ : ℝ} (hτ : 0 < τ) :
+    ∀ k l : ℤ, k ≠ l → Disjoint (Ioc ((k:ℝ)*τ) (((k:ℝ)+1)*τ))
+      (Ioc ((l:ℝ)*τ) (((l:ℝ)+1)*τ)) := by
+  intro k l hkl
+  rcases lt_or_gt_of_ne hkl with h | h
+  · apply Set.disjoint_left.mpr
+    intro x hx hy
+    have hkl' : (k:ℝ)+1 ≤ l := by exact_mod_cast (Int.add_one_le_iff.mpr h)
+    have hz := mul_le_mul_of_nonneg_right hkl' hτ.le
+    linarith [hx.2, hy.1]
+  · apply Set.disjoint_left.mpr
+    intro x hx hy
+    have hkl' : (l:ℝ)+1 ≤ k := by exact_mod_cast (Int.add_one_le_iff.mpr h)
+    have hz := mul_le_mul_of_nonneg_right hkl' hτ.le
+    linarith [hy.2, hx.1]
+
+lemma lattice_bound {h h' : ℝ → ℝ} {τ : ℝ} (hτ : 0 < τ)
+    (hd : ∀ t, HasDerivAt h (h' t) t) (hh : ∀ t, 0 ≤ h t)
+    (hi : Integrable h) (hi' : Integrable h') (s : Finset ℤ) :
+    τ*(∑ k ∈ s, h ((k:ℝ)*τ)) ≤ (∫ t, h t)+τ*(∫ t, |h' t|) := by
+  let U := ⋃ k ∈ s, Ioc ((k:ℝ)*τ) (((k:ℝ)+1)*τ)
+  have hle (k : ℤ) : (k:ℝ)*τ ≤ ((k:ℝ)+1)*τ := by linarith
+  have hs (f : ℝ → ℝ) (hf : Integrable f) :
+      (∑ k ∈ s, ∫ t in ((k:ℝ)*τ)..(((k:ℝ)+1)*τ), f t) = ∫ t in U, f t := by
+    simp_rw [intervalIntegral.integral_of_le (hle _)]
+    exact (integral_biUnion_finset s (fun _ _ => measurableSet_Ioc)
+      (fun k _ l _ hkl => lattice_intervals_disjoint hτ k l hkl)
+      (fun _ _ => hf.integrableOn)).symm
+  have he (k : ℤ) : (((k:ℝ)+1)*τ-(k:ℝ)*τ) = τ := by ring
+  have hb (k : ℤ) : τ*h ((k:ℝ)*τ) ≤
+      (∫ t in ((k:ℝ)*τ)..(((k:ℝ)+1)*τ), h t)+
+        τ*(∫ t in ((k:ℝ)*τ)..(((k:ℝ)+1)*τ), |h' t|) := by
+    simpa only [he] using cell_bound (a := (k:ℝ)*τ) (b := ((k:ℝ)+1)*τ)
+      (by linarith) hd hi'.intervalIntegrable
+  calc
+    _ = ∑ k ∈ s, τ*h ((k:ℝ)*τ) := Finset.mul_sum ..
+    _ ≤ ∑ k ∈ s, ((∫ t in ((k:ℝ)*τ)..(((k:ℝ)+1)*τ), h t)+
+        τ*(∫ t in ((k:ℝ)*τ)..(((k:ℝ)+1)*τ), |h' t|)) := Finset.sum_le_sum (fun k _ => hb k)
+    _ = (∫ t in U, h t)+τ*(∫ t in U, |h' t|) := by
+      rw [Finset.sum_add_distrib, ← Finset.mul_sum, hs h hi, hs (fun t => |h' t|) hi'.abs]
+    _ ≤ _ := add_le_add
+      (integral_mono_measure Measure.restrict_le_self (by filter_upwards with t using hh t) hi)
+      (mul_le_mul_of_nonneg_left
+        (integral_mono_measure Measure.restrict_le_self (by filter_upwards with t using abs_nonneg (h' t)) hi'.abs) hτ.le)
+
+end UniformSparsestCut.LatticeDensity
+
+namespace UniformSparsestCut.LatticeDensity
+open MeasureTheory Set
+open scoped BigOperators
+
+lemma affine_integral (f : ℝ → ℝ) (c a : ℝ) :
+    (∫ t, f (c-t/a)) = |a| *(∫ t, f t) := by
+  rw [Measure.integral_comp_div (fun x => f (c-x)),smul_eq_mul,integral_sub_left_eq_self]
+
+lemma affine_integrable {f : ℝ → ℝ} (hf : Integrable f) (c : ℝ) {a : ℝ} (ha : a ≠ 0) :
+    Integrable (fun t => f (c-t/a)) :=
+  ((integrable_comp_sub_left f c).mpr hf).comp_div ha
+
+lemma affine_lattice_bound {φ φ' : ℝ → ℝ} (hd : ∀ t, HasDerivAt φ (φ' t) t)
+    (hn : ∀ t, 0 ≤ φ t) (hi : Integrable φ) (hi' : Integrable φ')
+    (h1 : ∫ t, φ t=1) {τ a : ℝ} (hτ : 0 < τ) (ha : a ≠ 0) (c : ℝ) (s : Finset ℤ) :
+    τ/|a| *(∑ k ∈ s, φ (c-(k:ℝ)*τ/a)) ≤ 1+τ/|a| *(�� t, |φ' t|) := by
+  let h : ℝ → ℝ := fun t => φ (c-t/a)/|a|
+  let h' : ℝ → ℝ := fun t => -(φ' (c-t/a)/a)/|a|
+  have ha' : 0 < |a| := abs_pos.mpr ha
+  have hD (t : ℝ) : HasDerivAt h (h' t) t := by
+    convert! ((hd (c-t/a)).comp t (((hasDerivAt_id t).div_const a).const_sub c)).div_const |a| using 1
+    dsimp [h']
+    ring
+  have hint : (∫ t, h t)=1 := by
+    dsimp [h]
+    rw [integral_div,affine_integral,h1,mul_one,div_self ha'.ne']
+  have h'int : (∫ t, |h' t|)=(∫ t, |φ' t|)/|a| := by
+    dsimp [h']
+    simp only [abs_div,abs_neg,abs_abs]
+    rw [integral_div,integral_div,affine_integral (fun t => |φ' t|)]
+    field_simp
+  have hb := lattice_bound hτ hD (fun t => div_nonneg (hn _) (abs_nonneg _))
+    ((affine_integrable hi c ha).div_const _) (((affine_integrable hi' c ha).div_const a).neg.div_const _) s
+  rw [hint,h'int] at hb
+  dsimp [h] at hb
+  rw [← Finset.sum_div] at hb
+  convert hb using 1 <;> ring
+
+end UniformSparsestCut.LatticeDensity
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/Logarithms.lean

@@ -0,0 +1,84 @@
+import OAI.Combinatorics.SparsestCut.UniformMetric
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.RateComparison
+open Filter
+noncomputable section
+def weight (x : ℝ) : ℝ := Real.sqrt x*(Real.log x)^2*Real.sqrt (Real.log x)
+lemma weight_pos {d : ℕ} (hd : 0<d) (hl : 1≤Real.log d) : 0<weight d := by
+  have hd' : (0:ℝ)<d := by exact_mod_cast hd
+  have hl' : 0<Real.log d := by linarith
+  unfold weight
+  positivity
+lemma logarithms {d n : ℕ} (hd : 0<d) (hl : 1≤Real.log d)
+    (hnlo : d^d≤n) (hnhi : n≤d^(4030*d)) :
+    0<Real.log n ∧ Real.log d≤Real.log (Real.log n) ∧
+      Real.log n≤4030*(d:ℝ)*Real.log d := by
+  have hx : (0:ℝ)<d := by exact_mod_cast hd
+  have hlo : (d:ℝ)*Real.log d≤Real.log n := by
+    calc
+      _ = Real.log ((d:ℝ)^d) := (Real.log_pow _ _).symm
+      _ ≤ _ := Real.log_le_log (by positivity) (by exact_mod_cast hnlo)
+  have hdn : (d:ℝ)≤Real.log n := (le_mul_of_one_le_right hx.le hl).trans hlo
+  have hn0 : 0<n := (pow_pos hd _).trans_le hnlo
+  have hn0' : (0:ℝ)<n := by exact_mod_cast hn0
+  refine ⟨hx.trans_le hdn,Real.log_le_log hx hdn,?_⟩
+  calc
+    _ ≤ Real.log ((d:ℝ)^(4030*d)) := Real.log_le_log hn0' (by exact_mod_cast hnhi)
+    _ = _ := by rw [Real.log_pow]; push_cast; ring
+lemma bound {d n : ℕ} (hd : 0<d) (hl : 1≤Real.log d)
+    (hnlo : d^d≤n) (hnhi : n≤d^(4030*d)) :
+    Real.sqrt (Real.log n)/(Real.log (Real.log n))^3≤Real.sqrt 4030*(d:ℝ)/weight d := by
+  have hx : (0:ℝ)<d := by exact_mod_cast hd
+  have hℓ : 0<Real.log d := by linarith
+  obtain ⟨hn0,hll,hln⟩ := logarithms hd hl hnlo hnhi
+  have hll0 : 0<Real.log (Real.log n) := hℓ.trans_le hll
+  have hs : Real.sqrt (Real.log n)≤Real.sqrt 4030*Real.sqrt d*Real.sqrt (Real.log d) := by
+    calc
+      _ ≤ Real.sqrt (4030*(d:ℝ)*Real.log d) := Real.sqrt_le_sqrt hln
+      _ = _ := by rw [Real.sqrt_mul (by positivity),Real.sqrt_mul (by norm_num)]
+  apply (div_le_div_iff₀ (pow_pos hll0 _) (weight_pos hd hl)).mpr
+  have hlim := mul_le_mul_of_nonneg_left (pow_le_pow_left₀ hℓ.le hll 3)
+    (mul_nonneg (Real.sqrt_nonneg 4030) hx.le)
+  calc
+    _ ≤ (Real.sqrt 4030*Real.sqrt d*Real.sqrt (Real.log d))*weight d :=
+      mul_le_mul_of_nonneg_right hs (weight_pos hd hl).le
+    _ = Real.sqrt 4030*(d:ℝ)*(Real.log d)^3 := by
+      unfold weight
+      calc
+        _ = Real.sqrt 4030*(Real.sqrt d)^2*(Real.sqrt (Real.log d))^2*(Real.log d)^2 := by ring
+        _ = _ := by rw [Real.sq_sqrt hx.le,Real.sq_sqrt hℓ.le]; ring
+    _ ≤ _ := hlim
+lemma gap_of_gl {d n : ℕ} (hd : 0<d) (hl : 1≤Real.log d)
+    (hnlo : d^d≤n) (hnhi : n≤d^(4030*d))
+    {α β opt gl : ℝ} (hα : 0<α) (hβ : 0<β) (hopt : 1≤opt) (hgl : 0<gl)
+    (hbound : gl≤β*weight d/(α*(d:ℝ))) :
+    (α/(β*Real.sqrt 4030))*Real.sqrt (Real.log n)/(Real.log (Real.log n))^3≤opt/gl := by
+  have hx : (0:ℝ)<d := by exact_mod_cast hd
+  have hw := weight_pos hd hl
+  have hs : (0:ℝ)<Real.sqrt 4030 := by positivity
+  have hr := bound hd hl hnlo hnhi
+  have hconst : 0<α/(β*Real.sqrt 4030) := by positivity
+  have hratio : α*(d:ℝ)/(β*weight d)≤opt/gl := by
+    apply (div_le_div_iff₀ (mul_pos hβ hw) hgl).mpr
+    have h := (le_div_iff₀ (mul_pos hα hx)).mp hbound
+    have h' := mul_le_mul_of_nonneg_right hopt (mul_pos hβ hw).le
+    nlinarith only [h,h']
+  calc
+    _ = (α/(β*Real.sqrt 4030))*(Real.sqrt (Real.log n)/(Real.log (Real.log n))^3) := by ring
+    _ ≤ (α/(β*Real.sqrt 4030))*(Real.sqrt 4030*(d:ℝ)/weight d) :=
+      mul_le_mul_of_nonneg_left hr hconst.le
+    _ = α*(d:ℝ)/(β*weight d) := by field_simp
+    _ ≤ _ := hratio
+end
+end UniformSparsestCut.RateComparison
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/Main.lean

@@ -0,0 +1,60 @@
+import OAI.Combinatorics.SparsestCut.Logarithms
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut
+open Filter
+noncomputable section
+
+theorem mainGap :
+    ∃ c : ℝ, 0 < c ∧
+      ∃ n : ℕ → ℕ, ∃ C : (j : ℕ) → Capacity (n j),
+        (∀ j, 2 ≤ n j) ∧
+        Tendsto n atTop atTop ∧
+        (∀ j, 0 < glValue (C j)) ∧
+        ∀ᶠ j in atTop,
+          c * Real.sqrt (Real.log (n j : ℝ)) / (Real.log (Real.log (n j : ℝ))) ^ 3 ≤
+            OPT (C j) / glValue (C j) := by
+  classical
+  let α : ℝ := KernelApprox.cstar/6
+  let β : ℝ := SourceContraction.C+1
+  have hα : 0<α := div_pos KernelApprox.cstar_pos (by norm_num)
+  have hβ : 0<β := by have hc := SourceContraction.C_pos; dsimp [β]; linarith
+  have hcast : Tendsto (fun d : ℕ => (d:ℝ)) atTop atTop := tendsto_natCast_atTop_atTop
+  have hevent : ∀ᶠ d : ℕ in atTop, Nonempty (PivotFamily.PFamily d) ∧
+      3000≤d ∧ 1≤Real.log d ∧ SourceContraction.H≤(d:ℝ) ∧
+      4*SourceWeighted.D≤(d:ℝ) ∧ SourceMetric.C₀+1≤α*(d:ℝ) := by
+    filter_upwards [PivotFamily.pivot_directions_exist,eventually_ge_atTop 3000,
+      (Real.tendsto_log_atTop.comp hcast).eventually (eventually_ge_atTop 1),
+      hcast.eventually (eventually_ge_atTop SourceContraction.H),
+      hcast.eventually (eventually_ge_atTop (4*SourceWeighted.D)),
+      hcast.eventually (eventually_ge_atTop ((SourceMetric.C₀+1)/α))] with d hf hd hl hH hD ha
+    exact ⟨hf,hd,hl,hH,hD,by simpa only [mul_comm] using (div_le_iff₀ hα).mp ha⟩
+  obtain ⟨N,hN⟩ := eventually_atTop.mp hevent
+  have hex : ∀ j : ℕ, ∃ (n : ℕ) (C : Capacity n),
+      (j+N+1)^(j+N+1)≤n ∧ n≤(j+N+1)^(4030*(j+N+1)) ∧
+      2≤n ∧ 1≤OPT C ∧ 0<glValue C ∧ glValue C≤β*RateComparison.weight (j+N+1:ℕ)/(α*(j+N+1:ℕ)) := by
+    intro j
+    obtain ⟨⟨f⟩,hd,hl,hH,hD,ha⟩ := hN (j+N+1) (by omega)
+    exact SourceUniform.instance_exists f hd hl hH hD ha
+  choose n C hlo hhi hn hopt hgl hbound using hex
+  refine ⟨α/(β*Real.sqrt 4030),by positivity,n,C,hn,?_,hgl,?_⟩
+  · apply tendsto_atTop_mono (fun j => ?_) tendsto_id
+    have hd1 : 1≤j+N+1 := by omega
+    have hp : j+N+1≤(j+N+1)^(j+N+1) := by
+      simpa using (Nat.pow_le_pow_right hd1 hd1 : (j+N+1)^1≤(j+N+1)^(j+N+1))
+    exact (show j≤j+N+1 by omega).trans (hp.trans (hlo j))
+  · exact Filter.Eventually.of_forall (fun j => RateComparison.gap_of_gl
+      (by omega : 0<j+N+1) (hN (j+N+1) (by omega)).2.2.1
+      (hlo j) (hhi j) hα hβ (hopt j) (hgl j) (hbound j))
+end
+end UniformSparsestCut
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/Metric.lean

@@ -0,0 +1,155 @@
+import OAI.Combinatorics.SparsestCut.Parameters
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.SourceMetric
+open scoped BigOperators RealInnerProductSpace
+open SourceParameters SourceCharts
+noncomputable section
+variable {m : ℕ} (f : PivotFamily.PFamily m)
+local notation "E" => EuclideanSpace ℝ (Fin m)
+abbrev V := RoundedCharts.Vertex (u f) (p m 2000)
+noncomputable instance vertexFintype [NeZero m] : Fintype (V f) := by
+  letI := RoundedCharts.vertex_finite (u f) (τ := p m 2000) (p_pos (by exact_mod_cast NeZero.pos m) _) (fun s i => (u_norm f (NeZero.pos m) s i).2)
+  exact Fintype.ofFinite _
+def L : ℝ := GramMetric.localCost (m^6) (m^3) (Real.sqrt m) (p m 5) (p m 200)
+  (p m 40) ((m:ℝ)^40) (p m 1997) (2/Real.sqrt m)
+def err : ℝ := GramMetric.macroCost (m^6) (m^3) (Real.sqrt m) (p m 5) (p m 200)
+  (p m 40) ((m:ℝ)^40) (p m 1997) (3*Real.sqrt m) 0
+lemma realization [NeZero m] (hm : 3000 ≤ m) (hl : 1≤Real.log m) :
+    ∃ Z : V f → EuclideanSpace ℝ (V f),
+      (∀ v w z, ‖Z v-Z z‖^2≤‖Z v-Z w‖^2+‖Z w-Z z‖^2) ∧
+      (∀ v w, |‖Z v-Z w‖^2-KernelApprox.cstar*Real.sqrt m*
+         ‖B f (NeZero.pos m) v.val.1 (RoundedCharts.coordinate (u f) (p m 2000) v)-
+           B f (NeZero.pos m) w.val.1 (RoundedCharts.coordinate (u f) (p m 2000) w)‖|≤err (m:=m)+8*p m 8) ∧
+      (∀ v w, v.val.1=w.val.1 → (∑ i, |RoundedCharts.coordinate (u f) (p m 2000) v i-
+        RoundedCharts.coordinate (u f) (p m 2000) w i|)=p m 2000 →
+        ‖Z v-Z w‖^2≤50000000*p m 2000*p m 5*(Real.log m)^2) := by
+  have hm0 := NeZero.pos m
+  have hm1 : 1 ≤ m := by omega
+  have hm2 : 2 ≤ m := by omega
+  have hx : (1:ℝ) ≤ m := by exact_mod_cast hm1
+  have hx0 : (0:ℝ) < m := by exact_mod_cast hm0
+  have hτ := p_pos hx0 2000
+  let c : V f → Fin (m^3) := fun v => v.val.1
+  let x := RoundedCharts.coordinate (u f) (p m 2000)
+  let θ : V f → E := fun v => B f hm0 (c v) (x v)
+  have hhab : p m 40≤(m:ℝ)^40 := (p_one_le hx _).trans (one_le_pow₀ hx)
+  have hb (s : Fin (m^3)) (i : Fin (m^6)) : ‖B f hm0 s (EuclideanSpace.single i 1)‖≤4*p m 5 := by
+    have h := B_column f hm0 s i
+    convert h using 1
+    unfold p; field_simp
+  have hFourier (s : Fin (m^3)) (w : E) (hw : ‖w‖≤2*(3*Real.sqrt m)/p m 40) :
+      ‖Real.exp (-‖w‖^2/2) • w-((m^6:ℕ):ℝ)⁻¹ • ∑ i, Real.sin (inner ℝ (f.g s i) w) • f.g s i‖≤2/Real.sqrt m := by
+    rw [norm_sub_rev]
+    exact f.fourier s w (hw.trans (fourier_radius (show 6 ≤ m by omega)))
+  have hB (v : V f) : ‖B f hm0 (c v) (x v)‖≤3*Real.sqrt m := by
+    have h := vertex_B_bound f hm0 hm2 hτ v
+    rw [rounded_radius hm0] at h
+    exact h.trans (by linarith [radius_le_sqrt hm1])
+  have hres (v : V f) :
+      ‖ChartKernel.residual (FrameCharts.chart (fun i => (Real.sqrt m)⁻¹ • f.g (c v) i)) (B f hm0 (c v)) (x v)‖≤p m 1997 := by
+    have h := vertex_residual_bound f hm0 hτ v
+    rw [rounded_radius hm0] at h
+    exact h
+  have he := (macro_bounds hm1).1
+  have her : 3*err (m:=m)/2≤p m 8 := by
+    have hsmall := macro_small hm
+    change err (m:=m)≤p m 8/2 at hsmall
+    nlinarith [p_nonneg hx0.le 8]
+  obtain ⟨Z,htri,hmac,hloc,hzero⟩ := GramMetric.realization f.g (B f hm0) c x θ
+    (q:=Real.sqrt m) (k:=p m 5) (ε:=p m 200) (a:=p m 40) (b:=(m:ℝ)^40)
+    (R:=p m 1997) (T:=3*Real.sqrt m) (Rpos:=0) (γ:=2/Real.sqrt m) (r:=p m 8)
+    (Real.sqrt_pos.mpr hx0) (p_nonneg hx0.le 5) (p_one_le hx 5) (p_pos hx0 200) (p_pos hx0 40) hhab
+    (p_nonneg hx0.le 1997) (by positivity) (by positivity)
+    (by simpa only [Nat.cast_pow] using k_eq hx0)
+    (fun s i => (f.norms s i).2) hb hFourier hB hres
+    (fun v => by simp [θ]) he (p_pos hx0 8) her
+  refine ⟨Z,htri,hmac,?_⟩
+  intro v w hc hsum
+  have hh := local_tau hm hl
+  have h := hloc v w hc (by rw [hsum]; exact hh.1) (by rw [hsum]; exact hh.2.1)
+  rw [hsum] at h
+  exact h.trans hh.2.2
+end
+end UniformSparsestCut.SourceMetric
+
+namespace UniformSparsestCut.SourceMetric
+open scoped BigOperators RealInnerProductSpace
+open SourceParameters SourceCharts
+noncomputable section
+variable {m : ℕ} (f : PivotFamily.PFamily m) [NeZero m]
+local notation "E" => EuclideanSpace ℝ (Fin m)
+def C₀ : ℝ := 9+2*KernelApprox.cstar
+lemma C₀_pos : 0<C₀ := by unfold C₀; linarith [KernelApprox.cstar_pos]
+def vertex (s : Fin (m^3)) (θ : E) (hθ : θ∈RoundedCharts.cube 2)
+    (hs : RoundedCharts.regular (u f s) (p m 2000) θ) : V f :=
+  ⟨(s,RoundedCharts.integerLabel (u f s) (p m 2000) θ),θ,hθ,hs,rfl⟩
+omit [NeZero m] in
+lemma near_norm (hm : 3000 ≤ m) : Real.sqrt m*p m 1997≤p m 8 := by
+  have hx : (1:ℝ) ≤ m := by exact_mod_cast (show 1 ≤ m by omega)
+  calc
+    _ ≤ (m:ℝ)*p m 1997 := mul_le_mul_of_nonneg_right (sqrt_le hx) (p_nonneg (by positivity) _)
+    _ = p m 1996 := p_succ (by positivity : (m:ℝ)≠0) 1996
+    _ ≤ _ := p_le hx (by norm_num)
+lemma macro_bound (hm : 3000 ≤ m) (Z : V f → EuclideanSpace ℝ (V f))
+    (hmac : ∀ v w, |‖Z v-Z w‖^2-KernelApprox.cstar*Real.sqrt m*
+         ‖B f (NeZero.pos m) v.val.1 (RoundedCharts.coordinate (u f) (p m 2000) v)-
+           B f (NeZero.pos m) w.val.1 (RoundedCharts.coordinate (u f) (p m 2000) w)‖|≤err (m:=m)+8*p m 8)
+    (s t : Fin (m^3)) (θ η : E) (hθ : θ∈RoundedCharts.cube 2) (hη : η∈RoundedCharts.cube 2)
+    (hs : RoundedCharts.regular (u f s) (p m 2000) θ)
+    (ht : RoundedCharts.regular (u f t) (p m 2000) η) :
+    |‖Z (vertex f s θ hθ hs)-Z (vertex f t η hη ht)‖^2-KernelApprox.cstar*Real.sqrt m*‖θ-η‖|≤C₀*p m 8 := by
+  let v := vertex f s θ hθ hs
+  let w := vertex f t η hη ht
+  let X := B f (NeZero.pos m) s (RoundedCharts.rounded (u f s) (p m 2000) θ)
+  let Y := B f (NeZero.pos m) t (RoundedCharts.rounded (u f t) (p m 2000) η)
+  have hτ : 0<p m 2000 := p_pos (by exact_mod_cast NeZero.pos m) _
+  have hx : ‖X-θ‖≤p m 1997 := by
+    simpa only [rounded_radius (NeZero.pos m)] using rounded_B_error f (NeZero.pos m) (show 2 ≤ m by omega) hτ s θ
+  have hy : ‖Y-η‖≤p m 1997 := by
+    simpa only [rounded_radius (NeZero.pos m)] using rounded_B_error f (NeZero.pos m) (show 2 ≤ m by omega) hτ t η
+  have hnorm : |‖X-Y‖-‖θ-η‖|≤2*p m 1997 := by
+    calc
+      _ ≤ ‖(X-Y)-(θ-η)‖ := abs_norm_sub_norm_le _ _
+      _ = ‖(X-θ)-(Y-η)‖ := by congr 1; abel
+      _ ≤ ‖X-θ‖+‖Y-η‖ := norm_sub_le _ _
+      _ ≤ _ := by linarith
+  have hM := hmac v w
+  change |‖Z v-Z w‖^2-KernelApprox.cstar*Real.sqrt m*‖X-Y‖|≤err (m:=m)+8*p m 8 at hM
+  have hq : 0≤KernelApprox.cstar*Real.sqrt m := mul_nonneg KernelApprox.cstar_pos.le (Real.sqrt_nonneg _)
+  have hh := mul_le_mul_of_nonneg_left (near_norm (m:=m) hm) (mul_nonneg (by norm_num : (0:ℝ)≤2) KernelApprox.cstar_pos.le)
+  have he := macro_small hm
+  change err (m:=m)≤p m 8/2 at he
+  have hM' := abs_le.mp hM
+  have hn' := abs_le.mp hnorm
+  have hn1 := mul_le_mul_of_nonneg_left hn'.1 hq
+  have hn2 := mul_le_mul_of_nonneg_left hn'.2 hq
+  change |‖Z v-Z w‖^2-KernelApprox.cstar*Real.sqrt m*‖θ-η‖|≤_
+  rw [abs_le]; unfold C₀
+  constructor <;> nlinarith [p_nonneg (by positivity : (0:ℝ) ≤ m) 8]
+lemma one_step (vp vm : V f) (i : Fin (m^6))
+    (hi : vp.val.2 i=vm.val.2 i+1) (hj : ∀ j, j≠i → vp.val.2 j=vm.val.2 j) :
+    (∑ j, |RoundedCharts.coordinate (u f) (p m 2000) vp j-
+        RoundedCharts.coordinate (u f) (p m 2000) vm j|)=p m 2000 := by
+  classical
+  rw [Finset.sum_eq_single i]
+  · change |p m 2000*(vp.val.2 i:ℝ)-p m 2000*(vm.val.2 i:ℝ)|=_
+    rw [hi,Int.cast_add,Int.cast_one]
+    have h : p m 2000*((vm.val.2 i:ℝ)+1)-p m 2000*(vm.val.2 i:ℝ)=p m 2000 := by ring
+    rw [h,abs_of_pos (p_pos (by exact_mod_cast NeZero.pos m) _)]
+  · intro j hmem hji
+    change |p m 2000*(vp.val.2 j:ℝ)-p m 2000*(vm.val.2 j:ℝ)|=0
+    rw [hj j hji,sub_self,abs_zero]
+  · simp
+end
+end UniformSparsestCut.SourceMetric
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/MetricKernel.lean

@@ -0,0 +1,218 @@
+import OAI.Combinatorics.SparsestCut.Profiles
+
+namespace OAI
+
+universe u1 u2 u3 u4 u5 u6
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.MetricKernel
+open MeasureTheory Set
+open scoped RealInnerProductSpace BigOperators
+variable {E : Type u1} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+variable {ι : Type u2} {κ : Type u3} [Fintype ι] [Fintype κ]
+
+omit [Fintype ι] in
+lemma gram_eq_kernel (g : κ → E) (θ : ι → E) (α : ι → κ → ℝ)
+    (q ε : ℝ) {a b : ℝ} (ha : 0 < a) (hab : a ≤ b) (v w : ι) :
+    CommonKernel.gram g θ α q ε a b v w =
+      Profile.kernel g q ε a b (θ v) (θ w) (α v) (α w) := by
+  have hf (k : κ) := CommonKernel.circle_integrable g θ α ha hab v w k
+  have hi := CommonKernel.gaussian_integrable θ ha hab v w
+  have hiS : IntervalIntegrable (fun σ => ∑ i, inner ℝ
+      (CommonKernel.circle (inner ℝ (g i) (θ v)/σ) (α v i))
+      (CommonKernel.circle (inner ℝ (g i) (θ w)/σ) (α w i))/σ) volume a b := by
+    convert IntervalIntegrable.sum Finset.univ (fun i _ => hf i) using 1
+    funext σ
+    simp only [Finset.sum_apply]
+  unfold CommonKernel.gram Profile.kernel Profile.pairing
+  rw [← intervalIntegral.integral_const_mul, ← intervalIntegral.integral_finsetSum (fun k _ => hf k),
+    ← intervalIntegral.integral_const_mul, ← intervalIntegral.integral_add (hi.const_mul q)
+      (hiS.const_mul ε)]
+  apply intervalIntegral.integral_congr
+  intro σ hσ
+  rw [norm_sub_rev (θ w) (θ v)]
+
+  simp only [CommonKernel.circle_inner, inner_sub_right, sub_div, ← Finset.sum_div]
+  ring
+
+lemma kernel_psd (g : κ → E) (θ : ι → E) (α : ι → κ → ℝ)
+    {q ε a b : ℝ} (hq : 0 ≤ q) (hε : 0 ≤ ε) (ha : 0 < a) (hab : a ≤ b) :
+    Matrix.PosSemidef (fun v w => Profile.kernel g q ε a b (θ v) (θ w) (α v) (α w)) := by
+  have he : (fun v w => Profile.kernel g q ε a b (θ v) (θ w) (α v) (α w)) =
+      CommonKernel.gram g θ α q ε a b := by
+    funext v w; exact (gram_eq_kernel g θ α q ε ha hab v w).symm
+  rw [he]
+  exact CommonKernel.gram_posSemidef g θ α hq hε ha hab
+
+lemma base_pairing (g : κ → E) (q ε σ : ℝ) (θ η : E) :
+    Profile.pairing g q ε σ θ θ 0 0 + Profile.pairing g q ε σ η η 0 0 -
+      2*Profile.pairing g q ε σ θ η 0 0 =
+      2*q*KernelApprox.scaled ‖η-θ‖ σ +
+        2*ε/σ*∑ i, (1-Real.cos (inner ℝ (g i) (η-θ)/σ)) := by
+  simp only [Profile.pairing, Pi.zero_apply, mul_zero, zero_mul, add_zero,
+     sub_self, norm_zero, zero_pow (by decide : (2:ℕ) ≠ 0), neg_zero,
+    zero_div, Real.exp_zero, inner_zero_right, Real.cos_zero, Real.sin_zero, one_mul,
+    Finset.sum_const, nsmul_eq_mul, mul_one, Finset.sum_sub_distrib, KernelApprox.scaled]
+  ring
+
+omit [InnerProductSpace ℝ E] in
+lemma gaussian_scaled_integrable (θ η : E) {a b : ℝ} (ha : 0 < a) (hab : a ≤ b) :
+    IntervalIntegrable (KernelApprox.scaled ‖η-θ‖) volume a b := by
+  apply ContinuousOn.intervalIntegrable
+  rw [uIcc_of_le hab]
+  unfold KernelApprox.scaled
+  apply continuousOn_const.sub
+  apply Real.continuous_exp.comp_continuousOn
+  exact continuousOn_const.div (by fun_prop) (fun σ hσ => by have := ha.trans_le hσ.1; positivity)
+
+omit [Fintype κ] in
+lemma cos_integrable (g : κ → E) (θ η : E) {a b : ℝ} (ha : 0 < a) (hab : a ≤ b) (i : κ) :
+    IntervalIntegrable (fun σ => (1-Real.cos (inner ℝ (g i) (η-θ)/σ))/σ) volume a b := by
+  apply ContinuousOn.intervalIntegrable
+  rw [uIcc_of_le hab]
+  have hn : ∀ σ ∈ Icc a b, σ ≠ 0 := fun σ hσ => (ha.trans_le hσ.1).ne'
+  exact (continuousOn_const.sub (Real.continuous_cos.comp_continuousOn
+    (continuousOn_const.div continuousOn_id hn))).div continuousOn_id hn
+
+omit [Fintype κ] in
+lemma cos_integral_bound (g : κ → E) (θ η : E) {a b : ℝ} (ha : 0 < a) (hab : a ≤ b) (i : κ) :
+    |∫ σ in a..b, (1-Real.cos (inner ℝ (g i) (η-θ)/σ))/σ| ≤ 2*Real.log (b/a) := by
+  have hi := cos_integrable g θ η ha hab i
+  have hii : IntervalIntegrable (fun σ : ℝ => σ⁻¹) volume a b := by
+    apply ContinuousOn.intervalIntegrable
+    rw [uIcc_of_le hab]
+    exact continuousOn_id.inv₀ (fun σ hσ => (ha.trans_le hσ.1).ne')
+  have hn : 0 ≤ ∫ σ in a..b, (1-Real.cos (inner ℝ (g i) (η-θ)/σ))/σ := by
+    apply intervalIntegral.integral_nonneg hab
+    intro σ hσ
+    exact div_nonneg (sub_nonneg.mpr (Real.cos_le_one _)) (ha.trans_le hσ.1).le
+  rw [abs_of_nonneg hn]
+  calc
+    _ ≤ ∫ σ in a..b, 2*σ⁻¹ := by
+      apply intervalIntegral.integral_mono_on hab hi (hii.const_mul 2)
+      intro σ hσ
+      rw [← div_eq_mul_inv]
+      apply div_le_div_of_nonneg_right _ (ha.trans_le hσ.1).le
+      linarith [Real.neg_one_le_cos (inner ℝ (g i) (η-θ)/σ)]
+    _ = _ := by rw [intervalIntegral.integral_const_mul, integral_inv_of_pos ha (ha.trans_le hab)]
+
+lemma base_distance_error (g : κ → E) {q ε a b : ℝ} (hq : 0 ≤ q) (hε : 0 ≤ ε)
+    (ha : 0 < a) (hab : a ≤ b) (θ η : E) :
+    |Profile.kernel g q ε a b θ θ 0 0 + Profile.kernel g q ε a b η η 0 0 -
+      2*Profile.kernel g q ε a b θ η 0 0 - KernelApprox.cstar*q*‖η-θ‖| ≤
+      q*(2*a+‖η-θ‖^2/b)+4*ε*(Fintype.card κ : ℝ)*Real.log (b/a) := by
+  have hi1 := Profile.pairing_integrable g q ε θ θ 0 0 ha hab
+  have hi2 := Profile.pairing_integrable g q ε η η 0 0 ha hab
+  have hi3 := Profile.pairing_integrable g q ε θ η 0 0 ha hab
+  have hic (i : κ) := cos_integrable g θ η ha hab i
+  have hig := gaussian_scaled_integrable θ η ha hab
+  have hiS : IntervalIntegrable (fun σ => ∑ i, (1-Real.cos (inner ℝ (g i) (η-θ)/σ))/σ) volume a b := by
+    convert IntervalIntegrable.sum Finset.univ (fun i _ => hic i) using 1
+    funext σ
+    simp only [Finset.sum_apply]
+  have he : Profile.kernel g q ε a b θ θ 0 0 + Profile.kernel g q ε a b η η 0 0 -
+      2*Profile.kernel g q ε a b θ η 0 0 =
+      2*q*(∫ σ in a..b, KernelApprox.scaled ‖η-θ‖ σ) +
+      2*ε*(∑ i, ∫ σ in a..b, (1-Real.cos (inner ℝ (g i) (η-θ)/σ))/σ) := by
+    unfold Profile.kernel
+    rw [← intervalIntegral.integral_add hi1 hi2, ← intervalIntegral.integral_const_mul,
+      ← intervalIntegral.integral_sub (hi1.add hi2) (hi3.const_mul 2)]
+    have hi : (fun σ => Profile.pairing g q ε σ θ θ 0 0 + Profile.pairing g q ε σ η η 0 0 -
+        2*Profile.pairing g q ε σ θ η 0 0) =
+        (fun σ => 2*q*KernelApprox.scaled ‖η-θ‖ σ +
+          2*ε*∑ i, (1-Real.cos (inner ℝ (g i) (η-θ)/σ))/σ) := by
+      funext σ; rw [base_pairing]; simp only [← Finset.sum_div]; ring
+    rw [hi, intervalIntegral.integral_add (hig.const_mul _) (hiS.const_mul _),
+      intervalIntegral.integral_const_mul, intervalIntegral.integral_const_mul,
+      intervalIntegral.integral_finsetSum (fun i _ => hic i)]
+  rw [he]
+  have ht := KernelApprox.truncated_error (norm_nonneg (η-θ)) ha hab
+  rw [← intervalIntegral.integral_of_le hab] at ht
+  have hs : |∑ i, ∫ σ in a..b, (1-Real.cos (inner ℝ (g i) (η-θ)/σ))/σ| ≤
+      (Fintype.card κ : ℝ)*(2*Real.log (b/a)) := by
+    calc
+      _ ≤ ∑ i, |∫ σ in a..b, (1-Real.cos (inner ℝ (g i) (η-θ)/σ))/σ| := Finset.abs_sum_le_sum_abs _ _
+      _ ≤ ∑ _i : κ, 2*Real.log (b/a) := Finset.sum_le_sum (fun i _ => cos_integral_bound g θ η ha hab i)
+      _ = _ := by simp
+  have hsplit : 2*q*(∫ σ in a..b, KernelApprox.scaled ‖η-θ‖ σ) +
+      2*ε*(∑ i, ∫ σ in a..b, (1-Real.cos (inner ℝ (g i) (η-θ)/σ))/σ) -
+      KernelApprox.cstar*q*‖η-θ‖ =
+      q*(2*(∫ σ in a..b, KernelApprox.scaled ‖η-θ‖ σ)-KernelApprox.cstar*‖η-θ‖)+
+      2*ε*(∑ i, ∫ σ in a..b, (1-Real.cos (inner ℝ (g i) (η-θ)/σ))/σ) := by ring
+  rw [hsplit]
+  calc
+    _ ≤ |q*(2*(∫ σ in a..b, KernelApprox.scaled ‖η-θ‖ σ)-KernelApprox.cstar*‖η-θ‖)|+
+        |2*ε*(∑ i, ∫ σ in a..b, (1-Real.cos (inner ℝ (g i) (η-θ)/σ))/σ)| := abs_add_le ..
+    _ ≤ q*(2*a+‖η-θ‖^2/b)+2*ε*((Fintype.card κ : ℝ)*(2*Real.log (b/a))) := by
+      simp only [abs_mul, abs_of_nonneg hq, abs_of_nonneg (mul_nonneg (by norm_num : (0:ℝ) ≤ 2) hε)]
+      exact add_le_add (mul_le_mul_of_nonneg_left ht hq) (mul_le_mul_of_nonneg_left hs (by positivity))
+    _ = _ := by ring
+
+end UniformSparsestCut.MetricKernel
+
+namespace UniformSparsestCut.MetricKernel
+open MeasureTheory Set
+open scoped BigOperators RealInnerProductSpace
+variable {E : Type u4} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+variable {S : Type u5} {N : Type u6} [Fintype S] [Fintype N] [DecidableEq S]
+
+lemma full_differential_bound (g : S → N → E) (s : S)
+    {q ε σ k γ G A V H D₀ : ℝ} (θ η v : E) (h : N → ℝ) (α β : S × N → ℝ)
+    (hq : 0 < q) (hε : 0 < ε) (hσ : 0 < σ) (hk : k = q^2/(Fintype.card N : ℝ))
+    (hG : 0 ≤ G) (hA : 0 ≤ A) (hV : 0 ≤ V) (hH : 0 ≤ H) (hD : 0 ≤ D₀) (hγ : 0 ≤ γ)
+    (hg : ∀ s i, ‖g s i‖ ≤ G) (hv : ‖v‖ ≤ V*H) (hh : ∑ i, |h i| ≤ H)
+    (hα : ∀ i, |α i| ≤ A) (hβ : ∀ i, |β i| ≤ A)
+    (hδ : ∀ i : S × N, |(if i.1 = s then k/ε*(h i.2-inner ℝ (g i.1 i.2) v/q) else 0)| ≤ D₀*H)
+    (hf : ‖Real.exp (-‖(σ⁻¹:ℝ) • (η-θ)‖^2/2) • ((σ⁻¹:ℝ) • (η-θ)) -
+       ((Fintype.card N : ℝ)⁻¹) • ∑ i, Real.sin (inner ℝ (g s i) (η-θ)/σ) • g s i‖ ≤ γ) :
+    |Profile.differential (fun j : S × N => g j.1 j.2) q ε σ θ η v α β
+      (fun j => if j.1 = s then k/ε*(h j.2-inner ℝ (g j.1 j.2) v/q) else 0)| ≤
+      ((k+q*γ*V+ε*((Fintype.card S : ℝ)*(Fintype.card N : ℝ))*D₀*A)*H)/σ +
+      (ε*((Fintype.card S : ℝ)*(Fintype.card N : ℝ))*G*V*(1+A^2+2*A)*H)/σ^2 := by
+  let δ : S × N → ℝ := fun j => if j.1 = s then k/ε*(h j.2-inner ℝ (g j.1 j.2) v/q) else 0
+  let c : ℝ := (Fintype.card S : ℝ)*(Fintype.card N : ℝ)
+  have hc : 0 ≤ c := by dsimp [c]; positivity
+  have hk0 : 0 ≤ k := by rw [hk]; positivity
+  have hg0 := Profile.active_bound g s θ η v h hq hε hσ hk hg hf
+  have hcorr := Profile.differential_correction (q := q) (fun j : S × N => g j.1 j.2) hε.le hσ θ η v α β δ
+  have hc' : (∑ i : S × N, (|δ i| *|β i|+|inner ℝ (g i.1 i.2) v|/σ*
+      (|α i| *|β i|+|α i|+|β i|))) ≤ c*(D₀*H*A+G*(V*H)/σ*(A^2+2*A)) := by
+    calc
+      _ ≤ ∑ _i : S × N, (D₀*H*A+G*(V*H)/σ*(A^2+2*A)) := by
+        apply Finset.sum_le_sum; intro i _
+        apply add_le_add
+        · exact mul_le_mul (hδ i) (hβ i) (abs_nonneg _) (mul_nonneg hD hH)
+        · apply mul_le_mul
+          · apply div_le_div_of_nonneg_right _ hσ.le
+            exact (abs_real_inner_le_norm _ v).trans (mul_le_mul (hg i.1 i.2) hv (norm_nonneg v) hG)
+          · have hp := mul_le_mul (hα i) (hβ i) (abs_nonneg _) hA
+            nlinarith [hα i,hβ i]
+          · positivity
+          · positivity
+      _ = _ := by simp [c,Fintype.card_prod]; ring
+  have hb0 : k/σ*(∑ i, |h i|) + q*γ/σ*‖v‖ + ε/σ^2*(c*G)*‖v‖ ≤
+      k/σ*H+q*γ/σ*(V*H)+ε/σ^2*(c*G)*(V*H) := by
+    exact add_le_add (add_le_add (mul_le_mul_of_nonneg_left hh (by positivity))
+      (mul_le_mul_of_nonneg_left hv (by positivity))) (mul_le_mul_of_nonneg_left hv (by positivity))
+  calc
+    _ ≤ |Profile.differential (fun j : S × N => g j.1 j.2) q ε σ θ η v 0 0 δ|+
+      |Profile.differential (fun j : S × N => g j.1 j.2) q ε σ θ η v α β δ -
+        Profile.differential (fun j : S × N => g j.1 j.2) q ε σ θ η v 0 0 δ| := by
+      simpa only [add_sub_cancel] using abs_add_le
+        (Profile.differential (fun j : S × N => g j.1 j.2) q ε σ θ η v 0 0 δ)
+        (Profile.differential (fun j : S × N => g j.1 j.2) q ε σ θ η v α β δ-
+          Profile.differential (fun j : S × N => g j.1 j.2) q ε σ θ η v 0 0 δ)
+    _ ≤ (k/σ*H+q*γ/σ*(V*H)+ε/σ^2*(c*G)*(V*H))+
+        ε/σ*(c*(D₀*H*A+G*(V*H)/σ*(A^2+2*A))) :=
+      add_le_add (hg0.trans hb0) (hcorr.trans (mul_le_mul_of_nonneg_left hc' (by positivity)))
+    _ = _ := by dsimp [c]; field_simp; ring
+
+end UniformSparsestCut.MetricKernel
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/Model.lean

@@ -0,0 +1,38 @@
+import Mathlib
+
+namespace OAI
+
+open scoped BigOperators
+
+namespace UniformSparsestCut
+
+structure Capacity (n : ℕ) where
+  cap : Fin n → Fin n → ℝ
+  nonneg : ∀ i j, 0 ≤ cap i j
+  symm : ∀ i j, cap i j = cap j i
+  diagonal : ∀ i, cap i i = 0
+
+def pairSum {n : ℕ} (f : Fin n → Fin n → ℝ) : ℝ :=
+  ∑ i, ∑ j, if i < j then f i j else 0
+
+noncomputable def cutRatio {n : ℕ} (C : Capacity n) (B : Finset (Fin n)) : ℝ :=
+  (∑ i ∈ B, ∑ j ∈ Bᶜ, C.cap i j) /
+    ((B.card : ℝ) * ((n : ℝ) - (B.card : ℝ)))
+
+noncomputable def OPT {n : ℕ} (C : Capacity n) : ℝ :=
+  sInf {r | ∃ B : Finset (Fin n), B.Nonempty ∧ B ≠ Finset.univ ∧ r = cutRatio C B}
+
+def NegativeType {n : ℕ} (d : Fin n → Fin n → ℝ) : Prop :=
+  (∃ x : Fin n → EuclideanSpace ℝ (Fin n), ∀ i j, d i j = ‖x i - x j‖ ^ 2) ∧
+  ∀ i j k, d i k ≤ d i j + d j k
+
+def Feasible {n : ℕ} (d : Fin n → Fin n → ℝ) : Prop :=
+  NegativeType d ∧ pairSum d = 1
+
+noncomputable def glValue {n : ℕ} (C : Capacity n) : ℝ :=
+  sInf {r | ∃ d : Fin n → Fin n → ℝ, Feasible d ∧
+    r = pairSum (fun i j => C.cap i j * d i j)}
+
+end UniformSparsestCut
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/Mollifier.lean

@@ -0,0 +1,156 @@
+import OAI.Combinatorics.SparsestCut.Metric
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.ProductMollifier
+
+def bump : ContDiffBump (0:ℝ) := ⟨1/2,1,by norm_num,by norm_num⟩
+def rho : ℝ → ℝ := bump.normed volume
+lemma rho_nonneg (x : ℝ) : 0 ≤ rho x := bump.nonneg_normed x
+lemma rho_integral : ∫ x, rho x = 1 := bump.integral_normed
+lemma rho_integrable : Integrable rho := bump.integrable_normed
+lemma rho_smooth : ContDiff ℝ (⊤:ℕ∞) rho := bump.contDiff_normed
+lemma rho_compact : HasCompactSupport rho := bump.hasCompactSupport_normed
+lemma rho_even (x : ℝ) : rho (-x) = rho x := bump.normed_neg x
+lemma rho_support {x : ℝ} (hx : rho x ≠ 0) : |x| < 1 := by
+  have h : x ∈ Function.support rho := hx
+  rw [rho,bump.support_normed_eq] at h
+  simpa [bump,Metric.mem_ball,dist_eq_norm] using h
+lemma rho_deriv_integrable : Integrable (deriv rho) :=
+  (rho_smooth.continuous_deriv (by simp)).integrable_of_hasCompactSupport rho_compact.deriv
+
+def density (ell : ℝ) (x : ℝ) : ℝ := ell⁻¹*rho (x/ell)
+lemma density_nonneg {ell : ℝ} (hell : 0 ≤ ell) (x : ℝ) : 0 ≤ density ell x := by
+  exact mul_nonneg (inv_nonneg.mpr hell) (rho_nonneg _)
+lemma density_smooth (ell : ℝ) : ContDiff ℝ (⊤:ℕ∞) (density ell) := by
+  unfold density
+  exact contDiff_const.mul (rho_smooth.comp (contDiff_id.div_const ell))
+lemma density_integral {ell : ℝ} (hell : 0 < ell) : ∫ x, density ell x = 1 := by
+  unfold density
+  rw [integral_const_mul,Measure.integral_comp_div,rho_integral,smul_eq_mul,abs_of_pos hell]
+  simp [hell.ne']
+lemma density_support {ell x : ℝ} (hell : 0 < ell) (hx : density ell x ≠ 0) : |x| < ell := by
+  have hρ : rho (x/ell) ≠ 0 := by intro he; exact hx (by simp [density,he])
+  have h := rho_support hρ
+  rwa [abs_div,abs_of_pos hell,div_lt_one hell] at h
+lemma density_compact {ell : ℝ} (hell : 0 < ell) : HasCompactSupport (density ell) := by
+  apply HasCompactSupport.intro (isCompact_Icc (a := -ell) (b := ell))
+  intro x hx
+  by_contra hn
+  exact hx (abs_le.mp (density_support hell hn).le)
+lemma density_integrable {ell : ℝ} (hell : 0 < ell) : Integrable (density ell) :=
+  (density_smooth ell).continuous.integrable_of_hasCompactSupport (density_compact hell)
+lemma density_hasDeriv {ell : ℝ} (x : ℝ) : HasDerivAt (density ell)
+    (ell⁻¹/ell*deriv rho (x/ell)) x := by
+  have hd := ((rho_smooth.differentiable (by simp) (x/ell)).hasDerivAt.comp x
+    ((hasDerivAt_id x).div_const ell)).const_mul (ell⁻¹)
+  convert hd using 1 <;> try rfl
+  ring
+lemma density_deriv_integral {ell : ℝ} (hell : 0 < ell) :
+    (∫ x, |deriv (density ell) x|) = ell⁻¹*(∫ x, |deriv rho x|) := by
+  simp_rw [(density_hasDeriv (ell := ell) _).deriv,abs_mul,abs_of_pos (div_pos (inv_pos.mpr hell) hell)]
+  rw [integral_const_mul]
+  rw [Measure.integral_comp_div (fun t => |deriv rho t|),smul_eq_mul,abs_of_pos hell]
+  field_simp
+
+variable {m : ℕ}
+local notation "E" => EuclideanSpace ℝ (Fin m)
+def coordinate (i : Fin m) : E →L[ℝ] ℝ :=
+  (ContinuousLinearMap.proj i).comp (EuclideanSpace.equiv (Fin m) ℝ).toContinuousLinearMap
+@[simp] lemma coordinate_apply (i : Fin m) (x : E) : coordinate i x = x i := rfl
+
+def kernel (φ : ℝ → ℝ) (x : E) : ℝ := ∏ i, φ (x i)
+lemma kernel_smooth (φ : ℝ → ℝ) {n : ℕ∞} (hc : ContDiff ℝ n φ) : ContDiff ℝ n (kernel (m := m) φ) := by
+  unfold kernel
+  apply contDiff_prod
+  intro i _
+  exact hc.comp (coordinate i).contDiff
+lemma kernel_nonneg {φ : ℝ → ℝ} (hn : ∀ t, 0 ≤ φ t) (x : E) : 0 ≤ kernel φ x :=
+  Finset.prod_nonneg (fun _i _ => hn _)
+lemma kernel_integral (φ : ℝ → ℝ) : (∫ x : E, kernel φ x) = (∫ t, φ t)^m := by
+  rw [← (PiLp.volume_preserving_toLp (Fin m)).integral_comp (MeasurableEquiv.measurableEmbedding (MeasurableEquiv.toLp 2 _))]
+  simpa only [kernel,Fintype.card_fin] using integral_fintype_prod_volume_eq_pow (ι := Fin m) φ
+lemma kernel_integrable {φ : ℝ → ℝ} (hi : Integrable φ) : Integrable (kernel (m := m) φ) := by
+  rw [← (PiLp.volume_preserving_toLp (Fin m)).integrable_comp_emb (MeasurableEquiv.measurableEmbedding (MeasurableEquiv.toLp 2 _))]
+  exact Integrable.fintype_prod (fun _ : Fin m => hi)
+
+lemma coordinate_norm_bound {R : ℝ} (hR : 0 ≤ R) (x : E) (hx : ∀ j, |x j| ≤ R) :
+    ‖x‖ ≤ R*Real.sqrt m := by
+  have hs : ‖x‖^2 ≤ (m:ℝ)*R^2 := by
+    rw [EuclideanSpace.norm_sq_eq]
+    calc
+      _ ≤ ∑ _j : Fin m, R^2 := by
+        apply Finset.sum_le_sum; intro j _
+        rw [Real.norm_eq_abs]
+        exact pow_le_pow_left₀ (abs_nonneg _) (hx j) _
+      _ = _ := by simp
+  have hroot := Real.sq_sqrt (Nat.cast_nonneg m)
+  have hp : 0 ≤ R*Real.sqrt m := mul_nonneg hR (Real.sqrt_nonneg _)
+  have he : (R*Real.sqrt m)^2 = (m:ℝ)*R^2 := by rw [mul_pow,hroot]; ring
+  nlinarith [norm_nonneg x]
+
+lemma kernel_support_bound {φ : ℝ → ℝ} {R : ℝ} (hR : 0 ≤ R)
+    (hφ : ∀ t, φ t ≠ 0 → |t| ≤ R) {x : E} (hx : kernel φ x ≠ 0) : ‖x‖ ≤ R*Real.sqrt m := by
+  apply coordinate_norm_bound hR x
+  intro j
+  apply hφ _
+  intro hj
+  exact hx (Finset.prod_eq_zero (Finset.mem_univ j) hj)
+
+lemma kernel_compact {φ : ℝ → ℝ} {R : ℝ} (hR : 0 ≤ R)
+    (hφ : ∀ t, φ t ≠ 0 → |t| ≤ R) : HasCompactSupport (kernel (m := m) φ) := by
+  apply HasCompactSupport.intro (isCompact_closedBall (0:E) (R*Real.sqrt m))
+  intro x hx
+  by_contra hn
+  exact hx (by simpa using kernel_support_bound hR hφ hn)
+
+lemma kernel_hasFDeriv {φ φ' : ℝ → ℝ} (hd : ∀ t, HasDerivAt φ (φ' t) t) (x : E) :
+    HasFDerivAt (kernel φ)
+      (∑ i, ((∏ j ∈ Finset.univ.erase i, φ (x j))*φ' (x i)) • coordinate i) x := by
+  have h (i : Fin m) : HasFDerivAt (fun x : E => φ (x i)) (φ' (x i) • coordinate i) x :=
+    (hd (x i)).comp_hasFDerivAt x (coordinate i).hasFDerivAt
+  convert! HasFDerivAt.finsetProd (u := Finset.univ) (fun i _ => h i) using 1
+  simp only [smul_smul]
+
+lemma kernel_partial {φ φ' : ℝ → ℝ} (hd : ∀ t, HasDerivAt φ (φ' t) t) (x : E) (i : Fin m) :
+    fderiv ℝ (kernel φ) x (EuclideanSpace.single i 1) =
+      φ' (x i)*(∏ j ∈ Finset.univ.erase i, φ (x j)) := by
+  rw [(kernel_hasFDeriv hd x).fderiv]
+  simp [coordinate,mul_comm]
+
+lemma kernel_partial_integral {φ φ' : ℝ → ℝ} (hd : ∀ t, HasDerivAt φ (φ' t) t)
+    (hn : ∀ t, 0 ≤ φ t) (h1 : ∫ t, φ t = 1) (i : Fin m) :
+    (∫ x : E, |fderiv ℝ (kernel φ) x (EuclideanSpace.single i 1)|) = ∫ t, |φ' t| := by
+  classical
+  simp_rw [kernel_partial hd,abs_mul,abs_of_nonneg (Finset.prod_nonneg (fun j _ => hn _))]
+  let f : Fin m → ℝ → ℝ := fun j t => if j=i then |φ' t| else φ t
+  have he (x : E) : |φ' (x i)| *(∏ j ∈ Finset.univ.erase i, φ (x j)) = ∏ j, f j (x j) := by
+    rw [← Finset.mul_prod_erase (s := Finset.univ) (fun j => f j (x j)) (Finset.mem_univ i)]
+    simp only [f,ite_eq_left rfl]
+    congr 1
+    apply Finset.prod_congr rfl
+    intro j hj
+    simp only [Finset.mem_erase,Finset.mem_univ,and_true] at hj
+    simp [hj]
+  simp_rw [he]
+  rw [← (PiLp.volume_preserving_toLp (Fin m)).integral_comp (MeasurableEquiv.measurableEmbedding (MeasurableEquiv.toLp 2 _))]
+  rw [integral_fintype_prod_volume_eq_prod]
+  rw [← Finset.mul_prod_erase (s := Finset.univ) (fun j => ∫ t, f j t) (Finset.mem_univ i)]
+  simp only [f,ite_eq_left rfl]
+  have ho : (∏ j ∈ Finset.univ.erase i, ∫ t, if j=i then |φ' t| else φ t) = 1 := by
+    apply Finset.prod_eq_one
+    intro j hj
+    simp only [Finset.mem_erase,Finset.mem_univ,and_true] at hj
+    simpa [hj] using h1
+  rw [ho,mul_one]
+
+end UniformSparsestCut.ProductMollifier
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/Parameters.lean

@@ -0,0 +1,211 @@
+import OAI.Combinatorics.SparsestCut.ChartMetric
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.SourceParameters
+open Filter
+noncomputable section
+
+def p (x : ℝ) (n : ℕ) : ℝ := 1/x^n
+lemma p_nonneg {x : ℝ} (hx : 0≤x) (n : ℕ) : 0≤p x n := by unfold p; positivity
+lemma p_pos {x : ℝ} (hx : 0<x) (n : ℕ) : 0<p x n := by unfold p; positivity
+lemma p_mul {x : ℝ} (hx : x≠0) (a b : ℕ) : p x a*p x b=p x (a+b) := by
+  simp only [p,pow_add]; field_simp
+lemma p_le {x : ℝ} (hx : 1≤x) {a b : ℕ} (hab : a≤b) : p x b≤p x a := by
+  unfold p
+  exact one_div_le_one_div_of_le (by positivity) (pow_le_pow_right₀ hx hab)
+lemma p_one_le {x : ℝ} (hx : 1≤x) (a : ℕ) : p x a≤1 := by
+  simpa [p] using p_le hx (Nat.zero_le a)
+lemma p_succ {x : ℝ} (hx : x≠0) (a : ℕ) : x*p x (a+1)=p x a := by
+  unfold p; rw [pow_succ]; field_simp
+lemma log_ratio {x : ℝ} (hx : 0<x) : Real.log (x^40/(p x 40))=80*Real.log x := by
+  rw [Real.log_div (pow_ne_zero _ hx.ne') (ne_of_gt (p_pos hx 40))]
+  simp [p,Real.log_pow]; ring
+lemma k_eq {x : ℝ} (hx : 0<x) : p x 5=(Real.sqrt x)^2/x^6 := by
+  rw [Real.sq_sqrt hx.le]; unfold p; field_simp
+lemma local_formula {m : ℕ} (hm : 0 < m) :
+    GramMetric.localCost (m^6) (m^3) (Real.sqrt m) (p m 5) (p m 200)
+      (p m 40) ((m:ℝ)^40) (p m 1997) (2/Real.sqrt m)=
+      1440*p m 5*Real.log m+1440*p m 1798*Real.log m+
+        16*Real.sqrt m*p m 156*(1+p m 1802)^2 := by
+  have hm0 : (0:ℝ) < m := by exact_mod_cast hm
+  have hq := ne_of_gt (Real.sqrt_pos.mpr hm0)
+  unfold GramMetric.localCost
+  rw [log_ratio hm0]
+  simp only [p,Nat.cast_pow]
+  field_simp
+  ring
+lemma macro_formula {m : ℕ} (hm : 0 < m) :
+    GramMetric.macroCost (m^6) (m^3) (Real.sqrt m) (p m 5) (p m 200)
+      (p m 40) ((m:ℝ)^40) (p m 1997) (3*Real.sqrt m) 0=
+      2*Real.sqrt m*p m 40+36*Real.sqrt m*p m 39+
+        320*p m 191*Real.log m*(1+p m 1802)^2 := by
+  have hm0 : (0:ℝ) < m := by exact_mod_cast hm
+  unfold GramMetric.macroCost
+  rw [log_ratio hm0]
+  simp only [p,Nat.cast_pow,mul_zero,add_zero]
+  simp only [mul_pow,Real.sq_sqrt hm0.le]
+  field_simp
+  ring
+end
+end UniformSparsestCut.SourceParameters
+
+namespace UniformSparsestCut.SourceParameters
+open Filter
+noncomputable section
+lemma sqrt_le {x : ℝ} (hx : 1≤x) : Real.sqrt x≤x := by
+  have h := Real.sq_sqrt (by linarith : 0≤x)
+  have hx0 : 0≤x := by linarith
+  nlinarith [Real.sqrt_nonneg x]
+lemma correction_le {x : ℝ} (hx : 1≤x) : (1+p x 1802)^2≤4 := by
+  have h0 := p_nonneg (by linarith : 0≤x) 1802
+  have h1 := p_one_le hx 1802
+  nlinarith
+lemma local_bounds {m : ℕ} (hm1 : 1 ≤ m) (hl : 1≤Real.log m) :
+    p m 5≤GramMetric.localCost (m^6) (m^3) (Real.sqrt m) (p m 5) (p m 200)
+      (p m 40) ((m:ℝ)^40) (p m 1997) (2/Real.sqrt m) ∧
+    GramMetric.localCost (m^6) (m^3) (Real.sqrt m) (p m 5) (p m 200)
+      (p m 40) ((m:ℝ)^40) (p m 1997) (2/Real.sqrt m)≤3000*p m 5*Real.log m := by
+  have hm0 : 0 < m := by omega
+  have hx : (1:ℝ) ≤ m := by exact_mod_cast hm1
+  have hn : (0:ℝ) ≤ m := by positivity
+  rw [local_formula hm0]
+  have hp5 := p_nonneg hn 5
+  have hl0 : 0≤Real.log m := by linarith
+  have hextra1 : 1440*p m 1798*Real.log m≤1440*p m 5*Real.log m := by
+    gcongr
+    exact p_le hx (by norm_num)
+  have hextra2 : 16*Real.sqrt m*p m 156*(1+p m 1802)^2≤64*p m 5*Real.log m := by
+    calc
+      _ ≤ 16*(m:ℝ)*p m 156*4 := by
+        gcongr <;> first | exact sqrt_le hx | exact correction_le hx | (unfold p; positivity)
+      _ = 64*p m 155 := by
+        have hh := p_succ (by positivity : (m:ℝ)≠0) 155
+        nlinarith
+      _ ≤ 64*p m 5*Real.log m := by
+        have hh := p_le hx (show 5≤155 by norm_num)
+        nlinarith
+  constructor
+  · have hmain : p m 5≤1440*p m 5*Real.log m := by nlinarith
+    linarith [show 0≤1440*p m 1798*Real.log m by unfold p; positivity,
+      show 0≤16*Real.sqrt m*p m 156*(1+p m 1802)^2 by unfold p; positivity]
+  · nlinarith [mul_nonneg hp5 hl0]
+lemma macro_bounds {m : ℕ} (hm1 : 1 ≤ m) :
+    0≤GramMetric.macroCost (m^6) (m^3) (Real.sqrt m) (p m 5) (p m 200)
+      (p m 40) ((m:ℝ)^40) (p m 1997) (3*Real.sqrt m) 0 ∧
+    GramMetric.macroCost (m^6) (m^3) (Real.sqrt m) (p m 5) (p m 200)
+      (p m 40) ((m:ℝ)^40) (p m 1997) (3*Real.sqrt m) 0≤1318*p m 38 := by
+  have hm0 : 0 < m := by omega
+  have hx : (1:ℝ) ≤ m := by exact_mod_cast hm1
+  have hn : (0:ℝ) ≤ m := by positivity
+  have hl0 := Real.log_nonneg hx
+  have hl1 : Real.log m≤(m:ℝ) := (Real.log_le_sub_one_of_pos (by positivity)).trans (by linarith)
+  rw [macro_formula hm0]
+  constructor
+  · unfold p; positivity
+  · have h1 : 2*Real.sqrt m*p m 40≤2*p m 38 := by
+      calc
+        _ ≤ 2*(m:ℝ)*p m 40 := by gcongr <;> first | exact sqrt_le hx | (unfold p; positivity)
+        _ = 2*p m 39 := by nlinarith [p_succ (by positivity : (m:ℝ)≠0) 39]
+        _ ≤ _ := by gcongr; exact p_le hx (by norm_num)
+    have h2 : 36*Real.sqrt m*p m 39≤36*p m 38 := by
+      calc
+        _ ≤ 36*(m:ℝ)*p m 39 := by gcongr <;> first | exact sqrt_le hx | (unfold p; positivity)
+        _ = _ := by nlinarith [p_succ (by positivity : (m:ℝ)≠0) 38]
+    have h3 : 320*p m 191*Real.log m*(1+p m 1802)^2≤1280*p m 38 := by
+      calc
+        _ ≤ 320*p m 191*(m:ℝ)*4 := by gcongr <;> first | exact correction_le hx | exact hl1 | (unfold p; positivity)
+        _ = 1280*p m 190 := by nlinarith [p_succ (by positivity : (m:ℝ)≠0) 190]
+        _ ≤ _ := by gcongr; exact p_le hx (by norm_num)
+    linarith
+lemma macro_small {m : ℕ} (hm : 3000 ≤ m) :
+    GramMetric.macroCost (m^6) (m^3) (Real.sqrt m) (p m 5) (p m 200)
+      (p m 40) ((m:ℝ)^40) (p m 1997) (3*Real.sqrt m) 0≤p m 8/2 := by
+  have hx : (1:ℝ) ≤ m := by exact_mod_cast (show 1 ≤ m by omega)
+  have hp : (2636:ℝ)≤(m:ℝ)^30 := by
+    have hh := pow_le_pow_right₀ hx (show 1≤30 by norm_num)
+    simp only [pow_one] at hh
+    have hm' : (3000:ℝ) ≤ m := by exact_mod_cast hm
+    linarith
+  calc
+    _ ≤ 1318*p m 38 := (macro_bounds (show 1 ≤ m by omega)).2
+    _ ≤ p m 8/2 := by
+      have hm0 : (0:ℝ) < m := by positivity
+      unfold p
+      rw [show (m:ℝ)^38=(m:ℝ)^8*(m:ℝ)^30 by ring]
+      apply (le_div_iff₀ (by norm_num : (0:ℝ)<2)).mpr
+      field_simp
+      nlinarith
+end
+end UniformSparsestCut.SourceParameters
+
+namespace UniformSparsestCut.SourceParameters
+open scoped BigOperators
+noncomputable section
+lemma sqrt_m6 (m : ℕ) : Real.sqrt (m^6:ℕ)=(m:ℝ)^3 := by
+  rw [Nat.cast_pow,show (m:ℝ)^6=((m:ℝ)^3)^2 by ring,Real.sqrt_sq (by positivity)]
+lemma rounded_radius {m : ℕ} (hm : 0 < m) : Real.sqrt (m^6:ℕ)*p m 2000=p m 1997 := by
+  rw [sqrt_m6]; unfold p; field_simp
+lemma radius_le_sqrt {m : ℕ} (hm : 1 ≤ m) : p m 1997≤Real.sqrt m := by
+  have hx : (1:ℝ) ≤ m := by exact_mod_cast hm
+  exact (p_one_le hx _).trans (Real.one_le_sqrt.mpr hx)
+lemma fourier_radius {m : ℕ} (hm : 6 ≤ m) : 2*(3*Real.sqrt m)/p m 40≤(m:ℝ)^42 := by
+  have hx : (6:ℝ) ≤ m := by exact_mod_cast hm
+  have hx1 : (1:ℝ) ≤ m := by linarith
+  calc
+    _ = 6*Real.sqrt m*(m:ℝ)^40 := by unfold p; field_simp ; ring
+    _ ≤ (m:ℝ)*(m:ℝ)*(m:ℝ)^40 := by gcongr; exact sqrt_le hx1
+    _ = _ := by ring
+lemma local_tau {m : ℕ} (hm : 3000 ≤ m) (hl : 1≤Real.log m) :
+    let L := GramMetric.localCost (m^6) (m^3) (Real.sqrt m) (p m 5) (p m 200)
+      (p m 40) ((m:ℝ)^40) (p m 1997) (2/Real.sqrt m)
+    0<L*p m 2000 ∧ L*p m 2000≤p m 8 ∧
+    L*p m 2000*(9+8*Real.log (p m 8/(L*p m 2000)))≤
+      50000000*p m 2000*p m 5*(Real.log m)^2 := by
+  dsimp only
+  let L := GramMetric.localCost (m^6) (m^3) (Real.sqrt m) (p m 5) (p m 200)
+      (p m 40) ((m:ℝ)^40) (p m 1997) (2/Real.sqrt m)
+  change 0<L*p m 2000 ∧ L*p m 2000≤p m 8 ∧ _
+  have hx : (3000:ℝ) ≤ m := by exact_mod_cast hm
+  have hx1 : (1:ℝ) ≤ m := by linarith
+  have hx0 : (0:ℝ) < m := by linarith
+  have hτ := p_pos hx0 2000
+  have hp5 := p_pos hx0 5
+  have hp8 := p_pos hx0 8
+  have hL := local_bounds (show 1 ≤ m by omega) hl
+  change p m 5≤L ∧ L≤3000*p m 5*Real.log m at hL
+  have hδ : 0<L*p m 2000 := mul_pos (hp5.trans_le hL.1) hτ
+  have hδ0 : p m 5*p m 2000≤L*p m 2000 := mul_le_mul_of_nonneg_right hL.1 hτ.le
+  have hδ1 : L*p m 2000≤3000*p m 2000*p m 5*Real.log m := by nlinarith [mul_le_mul_of_nonneg_right hL.2 hτ.le]
+  have hlx : Real.log m≤(m:ℝ) := (Real.log_le_sub_one_of_pos hx0).trans (by linarith)
+  have hs : L*p m 2000≤p m 8 := by
+    calc
+      _ ≤ 3000*p m 2000*p m 5*(m:ℝ) := hδ1.trans (mul_le_mul_of_nonneg_left hlx (by unfold p; positivity))
+      _ = 3000*p m 2004 := by rw [mul_assoc (3000:ℝ),p_mul hx0.ne']; norm_num; nlinarith [p_succ hx0.ne' 2004]
+      _ ≤ 3000*p m 9 := mul_le_mul_of_nonneg_left (p_le hx1 (by norm_num)) (by norm_num)
+      _ ≤ (m:ℝ)*p m 9 := mul_le_mul_of_nonneg_right hx (p_nonneg hx0.le _)
+      _ = p m 8 := p_succ hx0.ne' 8
+  have he : p m 8/(p m 5*p m 2000)=(m:ℝ)^1997 := by unfold p; field_simp
+  have hlog : Real.log (p m 8/(L*p m 2000))≤1997*Real.log m := by
+    calc
+      _ ≤ Real.log (p m 8/(p m 5*p m 2000)) :=
+        Real.log_le_log (div_pos hp8 hδ) (div_le_div_of_nonneg_left hp8.le (mul_pos hp5 hτ) hδ0)
+      _ = _ := by rw [he,Real.log_pow]; norm_num
+  have hlog0 : 0≤Real.log (p m 8/(L*p m 2000)) := Real.log_nonneg ((one_le_div hδ).mpr hs)
+  refine ⟨hδ,hs,?_⟩
+  change L*p m 2000*(9+8*Real.log (p m 8/(L*p m 2000)))≤_
+  calc
+    _ ≤ (3000*p m 2000*p m 5*Real.log m)*(15985*Real.log m) := by
+      apply mul_le_mul hδ1 (by linarith) (by positivity) (by unfold p; positivity)
+    _ ≤ _ := by nlinarith [show 0≤p m 2000*p m 5*(Real.log m)^2 by unfold p; positivity]
+end
+end UniformSparsestCut.SourceParameters
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/PivotFamily.lean

@@ -0,0 +1,211 @@
+import OAI.Combinatorics.SparsestCut.DirectionFamily
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.PivotFamily
+open UniformSparsestCut.GaussianTools UniformSparsestCut.Directions
+open UniformSparsestCut.DirectionFamily UniformSparsestCut.DirectionAsymptotics
+open UniformSparsestCut.DirectionInterpolation
+open scoped NNReal
+
+lemma standard_density_le_one (x : ℝ) : gaussianPDFReal 0 1 x ≤ 1 := by
+  rw [gaussianPDFReal]
+  simp only [NNReal.coe_one,mul_one,sub_zero]
+  have hs : 1 ≤ Real.sqrt (2*Real.pi) := (Real.le_sqrt (by norm_num) (by positivity)).mpr (by nlinarith [Real.pi_gt_three])
+  have hex : Real.exp (-x^2/2) ≤ 1 := Real.exp_le_one_iff.mpr (by nlinarith [sq_nonneg x])
+  have hi : (√(2*Real.pi))⁻¹ ≤ 1 := inv_le_one_of_one_le₀ hs
+  simpa using mul_le_mul hi hex (Real.exp_nonneg _) (by norm_num : (0:ℝ) ≤ 1)
+
+lemma standard_small_ball {a : ℝ} (ha : 0 ≤ a) :
+    (gaussianReal 0 1).real {x | |x| ≤ a} ≤ 2*a := by
+  have hs : {x : ℝ | |x| ≤ a} = Icc (-a) a := by ext (x : ℝ); exact (abs_le : |x| ≤ a ↔ -a ≤ x ∧ x ≤ a)
+  rw [hs,measureReal_def,gaussianReal_apply_eq_integral 0 (by norm_num)]
+  rw [ENNReal.toReal_ofReal (integral_nonneg (fun x => gaussianPDFReal_nonneg 0 1 x))]
+  calc
+    _ ≤ ∫ x in Icc (-a) a, (1:ℝ) := by
+      apply integral_mono (integrable_gaussianPDFReal 0 1).integrableOn (integrableOn_const (by rw [Real.volume_Icc]; exact ENNReal.ofReal_ne_top))
+      exact standard_density_le_one
+    _ = 2*a := by
+      rw [integral_const,measureReal_def,Measure.restrict_apply MeasurableSet.univ,Set.univ_inter,Real.volume_Icc,ENNReal.toReal_ofReal (by linarith : 0 ≤ a-(-a))]
+      simp only [smul_eq_mul,mul_one]; ring
+
+lemma coordinate_small_ball {m : ℕ} (j : Fin m) {a : ℝ} (ha : 0 ≤ a) :
+    (stdGaussian (EuclideanSpace ℝ (Fin m))).real {x | |x j| ≤ a} ≤ 2*a := by
+  have hmap : (stdGaussian (EuclideanSpace ℝ (Fin m))).map (fun x => x j) = gaussianReal 0 1 := by
+    have h := gaussian_inner_law (EuclideanSpace.single j 1 : EuclideanSpace ℝ (Fin m))
+    have he : (⟨‖(EuclideanSpace.single j 1 : EuclideanSpace ℝ (Fin m))‖^2, sq_nonneg _⟩ : NNReal) = 1 := by
+      apply Subtype.ext
+      simp
+    rw [he] at h
+    simp only [EuclideanSpace.inner_single_left, map_one, one_mul] at h
+    exact h
+  have h := congrArg (fun μ : Measure ℝ => μ.real {x | |x| ≤ a}) hmap
+  simp only [measureReal_def] at h
+  rw [Measure.map_apply_of_aemeasurable (by fun_prop) (by measurability)] at h
+  exact h.le.trans (standard_small_ball ha)
+
+lemma all_coordinate_small_ball {m N S : ℕ} {a : ℝ} (ha : 0 ≤ a) :
+    (Measure.pi (fun _ : Fin S => Measure.pi (fun _ : Fin N => stdGaussian (EuclideanSpace ℝ (Fin m))))).real
+      {g | ∃ s i j, |g s i j| ≤ a} ≤ (S:ℝ)*((N:ℝ)*((m:ℝ)*(2*a))) := by
+  have hcol : (stdGaussian (EuclideanSpace ℝ (Fin m))).real {x | ∃ j, |x j| ≤ a} ≤ (m:ℝ)*(2*a) := by
+    simpa only [Fintype.card_fin,Set.mem_ofPred_eq] using finite_union_bound (fun j : Fin m => {x : EuclideanSpace ℝ (Fin m) | |x j| ≤ a}) (fun j => coordinate_small_ball j ha)
+  have hchart := real_measure_exists_le (μ := stdGaussian (EuclideanSpace ℝ (Fin m)))
+    (fun _ : Fin N => {x : EuclideanSpace ℝ (Fin m) | ∃ j, |x j| ≤ a}) (fun _ => by measurability) (fun _ => hcol)
+  exact real_measure_exists_le
+    (fun _ : Fin S => {g : Fin N → EuclideanSpace ℝ (Fin m) | ∃ i j, |g i j| ≤ a})
+    (fun _ => by measurability) (fun _ => hchart)
+
+section ExtraSelection
+variable {m N S : ℕ}
+local notation "E" => EuclideanSpace ℝ (Fin m)
+local notation "μ" => stdGaussian E
+local notation "ν" => Measure.pi (fun _ : Fin N => μ)
+local notation "π" => Measure.pi (fun _ : Fin S => ν)
+theorem select_on_nets_extra (hm : 0 < m) (hN : 0 < N) (hS : 0 < S)
+    (V W : Finset E) (hV : ∀ v ∈ V, ‖v‖ = 1)
+    {u q : ℝ} (hu : 0 ≤ u) (hq : 0 ≤ q)
+    (hqprob : (N : ℝ)*(2*Real.exp (-q^2/2)) ≤ 1/4)
+    {P : (Fin S → Fin N → E) → Prop} (hP : ∀ᵐ g ∂π, P g)
+    (Q : Set (Fin S → Fin N → E)) {p : ℝ} (hQ : (π).real Q ≤ p)
+    (hprob : (S : ℝ) * ((N : ℝ)*(2*Real.exp (-(m : ℝ)/8)) +
+        (V.card : ℝ)*(W.card : ℝ)*(2*Real.exp (-(N : ℝ)*u^2/(2*(2*Real.sqrt m)^2))) +
+        (V.card : ℝ)*(2*Real.exp (-(N : ℝ)*(1/8)^2/(2*(4*(m : ℝ))^2)))) +
+        (V.card : ℝ)*(2*Real.exp (-(S : ℝ)/32)) + p < 1) :
+    ∃ g : Fin S → Fin N → E, P g ∧ g ∉ Q ∧
+      (∀ s, g s ∉ normBad) ∧
+      (∀ s, ∀ v ∈ V, ∀ w ∈ W, g s ∉ fourierBad u v w) ∧
+      (∀ s, ∀ v ∈ V, g s ∉ covarianceBad v) ∧
+      (∀ v ∈ V, (badCount (projectionBad q v) g : ℝ) ≤ (S : ℝ)/2) := by
+  classical
+  let A := chartBad (N := N) V W u
+  let B : Set (Fin S → Fin N → E) := {g | ∃ s, g s ∈ A}
+  let C : Set (Fin S → Fin N → E) :=
+    {g | ∃ v : V, (S : ℝ)/2 < (badCount (projectionBad q v) g : ℝ)}
+  have hBbound := real_measure_exists_le (fun _ : Fin S => A)
+    (fun _ => chartBad_measurable V W u) (fun _ => chartBad_bound hm hN V W hV hu)
+  have hCbound := goodBad_bound hS V hV hq hqprob
+  have hBC : (π).real ((B ∪ C) ∪ Q) < 1 :=
+    ((measureReal_union_le (B ∪ C) Q).trans
+      (add_le_add ((measureReal_union_le B C).trans (add_le_add hBbound hCbound)) hQ)).trans_lt hprob
+  obtain ⟨g, hg0, hgP⟩ := exists_outside_with_ae hBC hP
+  have hg : g ∉ B ∪ C := fun h => hg0 (Or.inl h)
+  have hgQ : g ∉ Q := fun h => hg0 (Or.inr h)
+  have hgB : ∀ s, g s ∉ A := by
+    intro s hs; exact hg (Or.inl ⟨s, hs⟩)
+  refine ⟨g, hgP, hgQ, ?_, ?_, ?_, ?_⟩
+  · intro s hs; exact hgB s (Or.inl (Or.inl hs))
+  · intro s v hv w hw hs; exact hgB s (Or.inl (Or.inr ⟨(⟨v,hv⟩,⟨w,hw⟩), hs⟩))
+  · intro s v hv hs; exact hgB s (Or.inr ⟨⟨v,hv⟩, hs⟩)
+  · intro v hv; by_contra h
+    exact hg (Or.inr ⟨⟨v,hv⟩, lt_of_not_ge h⟩)
+
+end ExtraSelection
+
+variable {m : ℕ}
+local notation "E" => EuclideanSpace ℝ (Fin m)
+
+lemma select_source_nets_pivot (hm : 1000000 ≤ m) (hlog : 1 ≤ Real.log m)
+    (hmajor : 2*(m : ℝ)^9*Real.exp (-(m : ℝ)/8) +
+      6*(m : ℝ)^3*Real.exp (-(m : ℝ)) + 2/(m:ℝ)^20 < 1)
+    (V W : Finset E) (hV : ∀ v ∈ V, ‖v‖ = 1)
+    (hVc : (V.card : ℝ) ≤ Real.exp (6*(m : ℝ)^2))
+    (hWc : (W.card : ℝ) ≤ Real.exp (48*(m : ℝ)^2)) :
+    ∃ g : Fin (m^3) → Fin (m^6) → E,
+      (∀ s a b, a ≠ b → ∀ t : ℝ, g s a ≠ t • g s b) ∧
+      (∀ s i j, 1/(m:ℝ)^30 < |g s i j|) ∧
+      (∀ s, g s ∉ normBad) ∧
+      (∀ s, ∀ v ∈ V, ∀ w ∈ W, g s ∉ fourierBad (1/(2*Real.sqrt m)) v w) ∧
+      (∀ s, ∀ v ∈ V, g s ∉ covarianceBad v) ∧
+      (∀ v ∈ V, (badCount (projectionBad (10*Real.sqrt (Real.log m)) v) g : ℝ) ≤
+        ((m^3 : ℕ) : ℝ)/2) := by
+  have hm0 : 0 < m := by omega
+  have hsmall := all_coordinate_small_ball (m := m) (N := m^6) (S := m^3) (by positivity : (0:ℝ) ≤ 1/(m:ℝ)^30)
+  have hp : ((m^3:ℕ):ℝ)*(((m^6:ℕ):ℝ)*((m:ℝ)*(2*(1/(m:ℝ)^30)))) = 2/(m:ℝ)^20 := by
+    push_cast; field_simp
+  rw [hp] at hsmall
+  obtain ⟨g,hg,hQ,hrest⟩  := select_on_nets_extra (N := m^6) (S := m^3) hm0 (pow_pos hm0 _) (pow_pos hm0 _)
+    V W hV (by positivity : (0:ℝ) ≤ 1/(2*Real.sqrt m))
+    (by positivity : (0:ℝ) ≤ 10*Real.sqrt (Real.log m))
+    (by
+      simpa only [Nat.cast_pow] using (projection_failure_bound (show 2 ≤ m by omega)
+        (show 0 ≤ Real.log m by linarith)))
+    (GaussianNonparallel.charts_pairwise_nonparallel (show 2 ≤ m by omega))
+    {g | ∃ s i j, |g s i j| ≤ 1/(m:ℝ)^30} hsmall (by
+      simp only [Nat.cast_pow]
+      rw [normalized_fourier_exponent hm0, normalized_covariance_exponent m hm0]
+      exact (add_le_add_left (probability_majorization hm (Nat.cast_nonneg _) (Nat.cast_nonneg _) hVc hWc) _).trans_lt hmajor)
+  refine ⟨g,hg,?_,hrest⟩
+  intro s i j
+  exact lt_of_not_ge (fun h => hQ ⟨s,i,j,h⟩)
+
+structure PFamily (m : ℕ) extends Family m where
+  pivot : ∀ s i j, 1/(m:ℝ)^30 < |g s i j|
+
+lemma pivot_family_at_large (hm : 1000000 ≤ m) (hlog : 1 ≤ Real.log m)
+    (hbias : 16*Real.exp (-(m : ℝ)/12) ≤ 1/(8*(m : ℝ)))
+    (hmajor : 2*(m : ℝ)^9*Real.exp (-(m : ℝ)/8) +
+      6*(m : ℝ)^3*Real.exp (-(m : ℝ)) + 2/(m:ℝ)^20 < 1) : Nonempty (PFamily m) := by
+  classical
+  obtain ⟨V,W,hV,hVc,hWc,hVnet,hWnet⟩ := source_nets (show 2 ≤ m by omega)
+  obtain ⟨g,hpar,hpivot,hg,hfour,hcov,hgood⟩ := select_source_nets_pivot hm hlog hmajor V W hV hVc hWc
+  have hm0 : 0 < m := by omega
+  have hm0' : (0 : ℝ) < m := by exact_mod_cast hm0
+  have hn : 0 < m^6 := pow_pos hm0 _
+  have hu (s : Fin (m^3)) (i : Fin (m^6)) : ‖g s i‖^2 ≤ 4*(m : ℝ) :=
+    (normBounds_of_not_bad (hg s) i).2
+  refine ⟨{ g := g, norms := ?_, nonparallel := hpar, covariance := ?_, fourier := ?_, good := ?_, pivot := hpivot }⟩
+  · intro s i
+    have h := normBounds_of_not_bad (hg s) i
+    have hs := Real.sq_sqrt hm0'.le
+    constructor <;> nlinarith [Real.sqrt_nonneg (m : ℝ), norm_nonneg (g s i)]
+  · intro s v hv
+    have hh := covariance_net_bound hn (g s) (hu s) (by positivity) V hV hVnet
+      (fun v hv => net_covariance_scalar (hg s) v (hV v hv) (hcov s v hv)) v hv
+    have herr := covariance_net_error (show 1000 ≤ m by omega) hbias
+    have heq : 2*(4*(m : ℝ))*(1/(m : ℝ)^3) = 8*(m : ℝ)*(1/(m : ℝ)^3) := by ring
+    rw [heq] at hh
+    have hab := abs_le.mp (hh.trans herr)
+    constructor <;> linarith
+  · intro s w hw
+    have hρ : 1/(m : ℝ)^3 < 1 := by
+      apply (div_lt_one (by positivity)).mpr
+      have hx : (2 : ℝ) ≤ m := by exact_mod_cast (show 2 ≤ m by omega)
+      have hh := pow_le_pow_left₀ (by norm_num : (0 : ℝ) ≤ 2) hx 3
+      norm_num at hh; linarith
+    have hh := fourier_net_bound hn (g s) (hu s) (by positivity) (by positivity) hρ V W
+      hVnet hWnet (fun v hv w hw => net_fourier_scalar hm0 (hg s) v w (hV v hv) (hfour s v hv w hw)) w hw
+    have herr := scalar_net_error (show 1000 ≤ m by omega) hbias
+    have heq : 4*(m : ℝ)+(m : ℝ) = 5*(m : ℝ) := by ring
+    rw [heq] at hh
+    exact hh.trans herr
+  · intro v hv
+    obtain ⟨v',hv',hd⟩ := hVnet v hv
+    have hh := good_chart_interpolation g hg hd (projection_net_error (show 1000 ≤ m by omega) hlog)
+    exact (Nat.cast_le.mpr hh).trans (hgood v' hv')
+
+lemma pivot_majorant_tendsto :
+    Tendsto (fun m : ℕ => 2*(m : ℝ)^9*Real.exp (-(m : ℝ)/8) +
+      6*(m : ℝ)^3*Real.exp (-(m : ℝ)) + 2/(m:ℝ)^20) atTop (𝓝 0) := by
+  have hi : Tendsto (fun m : ℕ => (m:ℝ)⁻¹) atTop (𝓝 0) :=
+    tendsto_inv_atTop_zero.comp tendsto_natCast_atTop_atTop
+  have hh := (hi.pow 20).const_mul 2
+  have h := selection_majorant_tendsto.add hh
+  simpa [div_eq_mul_inv,inv_pow] using h
+
+theorem pivot_directions_exist : ∀ᶠ m : ℕ in atTop, Nonempty (PFamily m) := by
+  have hlog : ∀ᶠ m : ℕ in atTop, 1 ≤ Real.log m :=
+    (Real.tendsto_log_atTop.comp tendsto_natCast_atTop_atTop).eventually (eventually_ge_atTop 1)
+  have hmajor := pivot_majorant_tendsto.eventually (gt_mem_nhds (by norm_num : (0:ℝ) < 1))
+  filter_upwards [eventually_ge_atTop 1000000,hlog,eventual_bias_bound,hmajor] with m hm hl hb hp
+  exact pivot_family_at_large hm hl hb.2 hp
+
+end UniformSparsestCut.PivotFamily
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/PositiveKernels.lean

@@ -0,0 +1,164 @@
+import OAI.Combinatorics.SparsestCut.RoundedCharts
+
+namespace OAI
+
+universe u1 u2 u3 u4
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut
+namespace TriangleRepair
+
+variable {ι : Type u1} [Fintype ι]
+
+lemma gram_posSemidef {H : Type u2} [NormedAddCommGroup H] [InnerProductSpace ℝ H]
+    (x : ι → H) : (Matrix.of (fun i j => ⟪x i, x j⟫_ℝ)).PosSemidef := by
+  apply Matrix.PosSemidef.of_dotProduct_mulVec_nonneg
+  · apply Matrix.IsHermitian.ext
+    intro i j
+    simp [real_inner_comm]
+  · intro c
+    have h := real_inner_self_nonneg (x := ∑ i, c i • x i)
+    simp only [sum_inner, inner_sum, real_inner_smul_left, real_inner_smul_right] at h
+    simp only [Matrix.mulVec, Matrix.of_apply, dotProduct, Finset.mul_sum, Pi.star_apply,
+      star_trivial]
+    convert h using 1
+    try rfl
+    apply Finset.sum_congr rfl
+    intro i hi
+    apply Finset.sum_congr rfl
+    intro j hj
+    rw [real_inner_comm (x j) (x i)]
+    ring
+
+lemma ones_posSemidef : (Matrix.of (fun _ _ : ι => (1 : ℝ))).PosSemidef := by
+  convert Matrix.posSemidef_vecMulVec_self_star (fun _ : ι => (1 : ℝ)) using 1
+  ext i j
+  change (1 : ℝ) = 1 * 1
+  ring
+
+lemma entrywise_pow_posSemidef {A : Matrix ι ι ℝ} (hA : A.PosSemidef) (k : ℕ) :
+    Matrix.PosSemidef (fun i j => (A i j) ^ k) := by
+  induction k with
+  | zero => convert (ones_posSemidef (ι := ι)) using 1; rfl
+  | succ k hk => convert hk.hadamard hA using 1; rfl
+
+omit [Fintype ι] in
+lemma sum_posSemidef {κ : Type u3} (s : Finset κ) (A : κ → Matrix ι ι ℝ)
+    (hA : ∀ k ∈ s, (A k).PosSemidef) : (∑ k ∈ s, A k).PosSemidef := by
+  classical
+  induction s using Finset.induction_on with
+  | empty => simpa using (Matrix.PosSemidef.zero : (0 : Matrix ι ι ℝ).PosSemidef)
+  | @insert a s ha hs =>
+    rw [Finset.sum_insert ha]
+    exact (hA a (Finset.mem_insert_self a s)).add
+      (hs (fun k hk => hA k (Finset.mem_insert_of_mem hk)))
+
+lemma posSemidef_of_tendsto {A : ℕ → Matrix ι ι ℝ} {B : Matrix ι ι ℝ}
+    (ha : ∀ k, (A k).PosSemidef)
+    (hab : ∀ i j, Tendsto (fun k => A k i j) atTop (nhds (B i j))) : B.PosSemidef := by
+  apply Matrix.PosSemidef.of_dotProduct_mulVec_nonneg
+  · apply Matrix.IsHermitian.ext
+    intro i j
+    simp only [star_trivial]
+    apply tendsto_nhds_unique (hab j i)
+    have heq : (fun k => A k j i) = (fun k => A k i j) := by
+      funext k
+      simpa using (ha k).isHermitian.apply i j
+    simpa [heq] using hab i j
+  · intro c
+    have ht : Tendsto (fun k => star c ⬝ᵥ (A k *ᵥ c)) atTop
+        (nhds (star c ⬝ᵥ (B *ᵥ c))) := by
+      simp only [dotProduct, Matrix.mulVec]
+      exact tendsto_finsetSum _ fun i _ => tendsto_const_nhds.mul
+        (tendsto_finsetSum _ fun j _ => (hab i j).mul tendsto_const_nhds)
+    exact ge_of_tendsto' ht (fun k => (ha k).dotProduct_mulVec_nonneg c)
+
+lemma entrywise_exp_posSemidef {A : Matrix ι ι ℝ} (hA : A.PosSemidef) :
+    Matrix.PosSemidef (fun i j => Real.exp (A i j)) := by
+  let P (k : ℕ) : Matrix ι ι ℝ := fun i j => A i j ^ k / (k.factorial : ℝ)
+  have hp (k : ℕ) : (P k).PosSemidef := by
+    have h := (entrywise_pow_posSemidef hA k).smul
+      (inv_nonneg.mpr (Nat.cast_nonneg (α := ℝ) k.factorial))
+    convert h using 1
+    ext i j
+    change A i j ^ k / (k.factorial : ℝ) = (k.factorial : ℝ)⁻¹ * A i j ^ k
+    exact div_eq_inv_mul _ _
+  apply posSemidef_of_tendsto (A := fun k => ∑ l ∈ Finset.range k, P l)
+    (fun k => sum_posSemidef _ _ (fun l _ => hp l))
+  intro i j
+  have h := (NormedSpace.expSeries_div_hasSum_exp (A i j)).tendsto_sum_nat
+  convert h using 1
+  · funext k
+    exact Matrix.sum_apply i j (Finset.range k) P
+  · rw [Real.exp_eq_exp_ℝ]
+
+lemma gaussian_posSemidef {H : Type u4} [NormedAddCommGroup H] [InnerProductSpace ℝ H]
+    (x : ι → H) {l : ℝ} (hl : 0 < l) :
+    Matrix.PosSemidef (fun i j => Real.exp (-‖x i - x j‖ ^ 2 / l)) := by
+  let a : ι → ℝ := fun i => Real.exp (-‖x i‖ ^ 2 / l)
+  have hgram := (gram_posSemidef x).smul (show 0 ≤ 2 / l by positivity)
+  have hexp := entrywise_exp_posSemidef hgram
+  have hrank := Matrix.posSemidef_vecMulVec_self_star a
+  have heq : (fun i j => Real.exp (-‖x i - x j‖ ^ 2 / l) : Matrix ι ι ℝ) =
+      Matrix.vecMulVec a (star a) ⊙ (fun i j => Real.exp ((2 / l) * ⟪x i, x j⟫_ℝ)) := by
+    ext i j
+    change Real.exp (-‖x i - x j‖ ^ 2 / l) =
+      (a i * a j) * Real.exp ((2 / l) * ⟪x i, x j⟫_ℝ)
+    simp only [a, ← Real.exp_add]
+    congr 1
+    rw [norm_sub_sq_real]
+    ring
+  rw [heq]
+  convert hrank.hadamard hexp using 1
+  rfl
+
+open MeasureTheory
+
+lemma integral_posSemidef (K : ℝ → Matrix ι ι ℝ) {r : ℝ} (hr : 0 ≤ r)
+    (hK : ∀ l ∈ Set.Icc 0 r, (K l).PosSemidef)
+    (hi : ∀ i j, IntervalIntegrable (fun l => K l i j) volume 0 r) :
+    Matrix.PosSemidef (fun i j => ∫ l in (0 : ℝ)..r, K l i j) := by
+  apply Matrix.PosSemidef.of_dotProduct_mulVec_nonneg
+  · apply Matrix.IsHermitian.ext
+    intro i j
+    simp only [star_trivial]
+    apply intervalIntegral.integral_congr
+    intro l hl
+    simpa using (hK l (by simpa [Set.uIcc_of_le hr] using hl)).isHermitian.apply i j
+  · intro c
+    have h : 0 ≤ ∫ l in (0 : ℝ)..r, star c ⬝ᵥ (K l *ᵥ c) :=
+      intervalIntegral.integral_nonneg hr (fun l hl => (hK l hl).dotProduct_mulVec_nonneg c)
+    simp only [dotProduct, Matrix.mulVec, Pi.star_apply, star_trivial] at h ⊢
+    have hrow (i : ι) : IntervalIntegrable
+        (fun l => ∑ j, K l i j * c j) volume 0 r := by
+      convert IntervalIntegrable.sum Finset.univ (fun j _ => (hi i j).mul_const (c j)) using 1
+      try rfl
+      funext l
+      simp only [Finset.sum_apply]
+    rw [intervalIntegral.integral_finsetSum (fun i _ => (hrow i).const_mul (c i))] at h
+    simp_rw [intervalIntegral.integral_const_mul] at h
+    simp_rw [intervalIntegral.integral_finsetSum (fun j _ => (hi _ j).mul_const (c j)),
+      intervalIntegral.integral_mul_const] at h
+    exact h
+
+open scoped MatrixOrder in
+
+lemma exists_gram {A : Matrix ι ι ℝ} (hA : A.PosSemidef) :
+    ∃ q : ι → EuclideanSpace ℝ ι, ∀ i j, ⟪q i, q j⟫_ℝ = A i j := by
+  classical
+  obtain ⟨B, hB⟩ := CStarAlgebra.nonneg_iff_eq_star_mul_self.mp hA.nonneg
+  refine ⟨fun i => WithLp.toLp 2 (fun k => B k i), ?_⟩
+  intro i j
+  rw [hB]
+  simp [PiLp.inner_apply, Matrix.mul_apply, Matrix.star_eq_conjTranspose, mul_comm]
+
+end TriangleRepair
+end UniformSparsestCut
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/ProductSlice.lean

@@ -0,0 +1,135 @@
+import OAI.Combinatorics.SparsestCut.SliceCoefficients
+
+namespace OAI
+
+universe u1 u2 u3
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.ProductSlice
+open MeasureTheory Set
+open scoped BigOperators
+noncomputable section
+variable {Z : Type u1} {I : Type u2} {K : Type u3} [NormedAddCommGroup Z] [NormedSpace ℝ Z]
+  [FiniteDimensional ℝ Z] [MeasureSpace Z] [BorelSpace Z] [(volume : Measure Z).IsAddHaarMeasure]
+  [Fintype I] [Fintype K] [DecidableEq I] [DecidableEq K]
+
+def form (B : Z →L[ℝ] ℝ) : (ℝ × Z) →L[ℝ] ℝ :=
+  ContinuousLinearMap.fst ℝ ℝ Z-B.comp (ContinuousLinearMap.snd ℝ ℝ Z)
+omit [FiniteDimensional ℝ Z] [MeasureSpace Z] [BorelSpace Z] [(volume : Measure Z).IsAddHaarMeasure] in
+@[simp] lemma form_apply (B : Z →L[ℝ] ℝ) (x : ℝ × Z) : form B x=x.1-B x.2 := rfl
+
+def cell (B : I → Z →L[ℝ] ℝ) (q : I → K → ℝ) (F : Finset (I × K) → ℝ) (x : ℝ × Z) : ℝ :=
+  F (Finset.univ.filter (fun p => form (B p.1) x+q p.1 p.2<0))
+omit [(volume : Measure Z).IsAddHaarMeasure] in
+lemma cell_measurable (B : I → Z →L[ℝ] ℝ) (q : I → K → ℝ) (F : Finset (I × K) → ℝ) :
+    Measurable (cell B q F) := by
+  unfold cell
+  apply InterfaceStep.measurable_filter_apply
+  intro p
+  exact measurableSet_lt ((form (B p.1)).measurable.add_const (q p.1 p.2)) measurable_const
+
+omit [(volume : Measure Z).IsAddHaarMeasure] in
+lemma cell_locallyIntegrable (B : I → Z →L[ℝ] ℝ) (q : I → K → ℝ)
+    (F : Finset (I × K) → ℝ) {M : ℝ} (hM : ∀ a, |F a|≤M)
+    (ν : Measure (ℝ × Z)) [IsLocallyFiniteMeasure ν] : LocallyIntegrable (cell B q F) ν := by
+  apply (continuous_const (y := M)).locallyIntegrable.mono (cell_measurable B q F).aestronglyMeasurable
+  filter_upwards with x
+  exact (show |cell B q F x|≤M from hM _).trans (le_abs_self M)
+
+omit [FiniteDimensional ℝ Z] [MeasureSpace Z] [BorelSpace Z] [(volume : Measure Z).IsAddHaarMeasure] [DecidableEq I] [DecidableEq K] in
+lemma cell_translate (B : I → Z →L[ℝ] ℝ) (q : I → K → ℝ)
+    (F : Finset (I × K) → ℝ) (θ : ℝ × Z) (x : ℝ) (z : Z) :
+    cell B q F (θ-(x,z)) =
+      F (Finset.univ.filter (fun p => form (B p.1) θ+B p.1 z+q p.1 p.2<x)) := by
+  unfold cell
+  congr 1
+  apply Finset.filter_congr
+  intro p _
+  change (θ.1-x-B p.1 (θ.2-z)+q p.1 p.2<0) ↔
+    (θ.1-B p.1 θ.2+B p.1 z+q p.1 p.2<x)
+  rw [map_sub]
+  constructor <;> intro hp <;> linarith
+
+def law (ψ : Z → ℝ) (ν : Measure Z) : Measure Z := ν.withDensity (fun z => ENNReal.ofReal (ψ z))
+omit [NormedAddCommGroup Z] [NormedSpace ℝ Z] [FiniteDimensional ℝ Z] [BorelSpace Z] [(volume : Measure Z).IsAddHaarMeasure] in
+lemma law_ac (ψ : Z → ℝ) (ν : Measure Z) : law ψ ν ≪ ν := withDensity_absolutelyContinuous _ _
+omit [NormedAddCommGroup Z] [NormedSpace ℝ Z] [FiniteDimensional ℝ Z] [BorelSpace Z] [(volume : Measure Z).IsAddHaarMeasure] in
+lemma law_integral {ψ : Z → ℝ} (hm : Measurable ψ) (hn : ∀ z, 0≤ψ z)
+    (ν : Measure Z) (f : Z → ℝ) :
+    (∫ z, f z ∂law ψ ν) = ∫ z, ψ z*f z ∂ν := by
+  rw [law,integral_withDensity_eq_integral_toReal_smul (hm.ennreal_ofReal)
+    (ae_of_all _ (fun _ => ENNReal.ofReal_lt_top))]
+  simp only [ENNReal.toReal_ofReal (hn _),smul_eq_mul]
+omit [NormedAddCommGroup Z] [NormedSpace ℝ Z] [FiniteDimensional ℝ Z] [BorelSpace Z] [(volume : Measure Z).IsAddHaarMeasure] in
+lemma law_probability {ψ : Z → ℝ} (_hm : Measurable ψ) (hn : ∀ z, 0≤ψ z)
+    (ν : Measure Z) (hi : Integrable ψ ν) (h1 : ∫ z, ψ z ∂ν=1) :
+    IsProbabilityMeasure (law ψ ν) := by
+  refine ⟨?_⟩
+  change (ν.withDensity (fun z => ENNReal.ofReal (ψ z))) Set.univ = 1
+  rw [withDensity_apply _ MeasurableSet.univ,Measure.restrict_univ]
+  rw [← ofReal_integral_eq_lintegral_ofReal hi (ae_of_all _ hn),h1]
+  simp
+
+lemma convolution_slice (B : I → Z →L[ℝ] ℝ) (q : I → K → ℝ)
+    (F : Finset (I × K) → ℝ) {M : ℝ} (_hM0 : 0 ≤ M) (hM : ∀ a, |F a| ≤ M)
+    {φ : ℝ → ℝ} {ψ : Z → ℝ} (hmφ : Measurable φ) (hmψ : Measurable ψ)
+    (hφ : Integrable φ) (hψ : Integrable ψ) (hnψ : ∀ z, 0≤ψ z) (θ : ℝ × Z) :
+    convolution (fun p : ℝ × Z => φ p.1*ψ p.2) (cell B q F)
+        (ContinuousLinearMap.mul ℝ ℝ) volume θ =
+      ∫ z, (∫ x, φ x*F (Finset.univ.filter
+        (fun p => form (B p.1) θ+B p.1 z+q p.1 p.2<x))) ∂law ψ volume := by
+  have hi : Integrable (fun p : ℝ × Z => (φ p.1*ψ p.2)*cell B q F (θ-p)) := by
+    apply (((hφ.abs).mul_prod hψ.abs).mul_const M).mono'
+      (((hmφ.comp measurable_fst).mul (hmψ.comp measurable_snd)).mul
+        ((cell_measurable B q F).comp (measurable_const.sub measurable_id))).aestronglyMeasurable
+    filter_upwards with p
+    change |φ p.1*ψ p.2*cell B q F (θ-p)| ≤ |φ p.1| * |ψ p.2| * M
+    simp only [abs_mul]
+    exact mul_le_mul_of_nonneg_left (hM _) (mul_nonneg (abs_nonneg _) (abs_nonneg _))
+  change (∫ p : ℝ × Z, (φ p.1*ψ p.2)*cell B q F (θ-p) ∂(volume : Measure ℝ).prod (volume : Measure Z)) = _
+  rw [integral_prod_symm _ hi,law_integral hmψ hnψ]
+  apply integral_congr_ae
+  filter_upwards with z
+  rw [← integral_const_mul]
+  apply integral_congr_ae
+  filter_upwards with x
+  rw [cell_translate]
+  ring
+
+lemma convolution_derivative (B : I → Z →L[ℝ] ℝ) (hB : Function.Injective B)
+    (q : I → K → ℝ) (hq : ∀ i, Function.Injective (q i))
+    (F : Finset (I × K) → ℝ) {M C : ℝ} (hM0 : 0≤M) (hC : 0≤C)
+    (hM : ∀ a, |F a|≤M) {φ : ℝ → ℝ} {ψ : Z → ℝ}
+    (hφ : Integrable φ) (hcφ : Continuous φ) (hφC : ∀ t, |φ t|≤C)
+    (hmψ : Measurable ψ) (hnψ : ∀ z, 0≤ψ z) (hψ : Integrable ψ) (hψ1 : ∫ z, ψ z=1)
+    (θ : ℝ × Z) :
+    HasFDerivAt (convolution (fun p : ℝ × Z => φ p.1*ψ p.2) (cell B q F)
+      (ContinuousLinearMap.mul ℝ ℝ) volume)
+      (∑ i, (∑ k, ∫ z, -(φ (form (B i) θ+B i z+q i k)*
+        (F (Finset.univ.filter (fun p => form (B p.1) θ+B p.1 z+q p.1 p.2 ≤ form (B i) θ+B i z+q i k))-
+          F (Finset.univ.filter (fun p => form (B p.1) θ+B p.1 z+q p.1 p.2 < form (B i) θ+B i z+q i k))))
+        ∂law ψ volume) • form (B i)) θ := by
+  let := law_probability hmψ hnψ volume hψ hψ1
+  have he : convolution (fun p : ℝ × Z => φ p.1*ψ p.2) (cell B q F)
+      (ContinuousLinearMap.mul ℝ ℝ) volume =
+      (fun θ => ∫ z, (∫ x, φ x*F (Finset.univ.filter
+        (fun p => form (B p.1) θ+B p.1 z+q p.1 p.2<x))) ∂law ψ volume) :=
+    funext (convolution_slice B q F hM0 hM hcφ.measurable hmψ hφ hψ hnψ)
+  rw [he]
+  have hi : ∀ᵐ z ∂law ψ volume, Function.Injective
+      (fun p : I × K => form (B p.1) θ+(B p.1 z+q p.1 p.2)) := by
+    simpa only [add_assoc] using SliceCoefficients.thresholds_injective_ae
+      (fun i => form (B i)) B q hq hB volume (law ψ volume) (law_ac ψ volume) θ
+  simpa only [add_assoc] using SliceCoefficients.family_derivative (fun i => form (B i))
+    (fun p z => B p.1 z+q p.1 p.2) (fun p => (B p.1).measurable.add_const _) F
+    hφ hcφ hM0 hC hM hφC (law ψ volume) θ hi
+end
+end UniformSparsestCut.ProductSlice
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/Profiles.lean

@@ -0,0 +1,348 @@
+import OAI.Combinatorics.SparsestCut.CommonKernel
+
+namespace OAI
+
+universe u1 u2 u3 u4 u5 u6 u7
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.Profile
+variable {E : Type u1} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+variable {ι : Type u2} [Fintype ι]
+
+def pairing (g : ι → E) (q ε σ : ℝ) (θ η : E) (α β : ι → ℝ) : ℝ :=
+  q*Real.exp (-‖η-θ‖^2/(2*σ^2)) + ε/σ*(∑ i, (
+    (1+α i*β i)*Real.cos (inner ℝ (g i) (η-θ)/σ) +
+      (α i-β i)*Real.sin (inner ℝ (g i) (η-θ)/σ)))
+
+def differential (g : ι → E) (q ε σ : ℝ) (θ η v : E)
+    (α β δ : ι → ℝ) : ℝ :=
+  q/σ*(inner ℝ ((σ⁻¹:ℝ) • (η-θ)) v)*Real.exp (-‖η-θ‖^2/(2*σ^2)) +
+    ε/σ*(∑ i, (δ i*(β i*Real.cos (inner ℝ (g i) (η-θ)/σ)+Real.sin (inner ℝ (g i) (η-θ)/σ)) +
+      (inner ℝ (g i) v/σ)*((1+α i*β i)*Real.sin (inner ℝ (g i) (η-θ)/σ)-
+        (α i-β i)*Real.cos (inner ℝ (g i) (η-θ)/σ))))
+
+lemma pairing_hasDeriv (g : ι → E) (q ε σ : ℝ) (θ η v : E)
+    (α β δ : ι → ℝ) (t : ℝ) :
+    HasDerivAt (fun t => pairing g q ε σ (θ+t • v) η (fun i => α i+t*δ i) β)
+      (differential g q ε σ (θ+t • v) η v (fun i => α i+t*δ i) β δ) t := by
+  have hx : HasDerivAt (fun t : ℝ => η-(θ+t • v)) (-v) t :=
+    by simpa using (((hasDerivAt_id t).smul_const v).const_add θ).const_sub η
+  have hn := hx.norm_sq.neg.div_const (2*σ^2)
+  have he := hn.exp.const_mul q
+  have hi (i : ι) : HasDerivAt (fun t : ℝ => inner ℝ (g i) (η-(θ+t • v))/σ)
+      (-inner ℝ (g i) v/σ) t := by
+    convert ((innerSL ℝ (g i)).hasFDerivAt.comp_hasDerivAt t hx).div_const σ using 1 <;> try rfl
+    simp only [innerSL_apply_apply, inner_neg_right]
+  have hd (i : ι) : HasDerivAt (fun t : ℝ => α i+t*δ i) (δ i) t := by
+    simpa using ((hasDerivAt_id t).mul_const (δ i)).const_add (α i)
+  have hs (i : ι) := ((((hd i).mul_const (β i)).const_add 1).mul (hi i).cos).add
+    (((hd i).sub_const (β i)).mul (hi i).sin)
+  have hsum := (HasDerivAt.sum (u := Finset.univ) (fun i _ => hs i)).const_mul (ε/σ)
+  convert he.add hsum using 1 <;> try rfl
+  · funext z; simp [pairing, Finset.sum_apply]
+  · simp only [differential, real_inner_smul_left, inner_neg_right, Pi.neg_apply]
+    congr 1
+    · ring
+    · congr 1; apply Finset.sum_congr rfl; intro i _; ring
+
+lemma differential_correction (g : ι → E) {q ε σ : ℝ} (hε : 0 ≤ ε) (hσ : 0 < σ)
+    (θ η v : E) (α β δ : ι → ℝ) :
+    |differential g q ε σ θ η v α β δ - differential g q ε σ θ η v 0 0 δ| ≤
+      ε/σ*(∑ i, (|δ i| * |β i| + |inner ℝ (g i) v|/σ*(|α i| * |β i| + |α i| + |β i|))) := by
+  have heq : differential g q ε σ θ η v α β δ - differential g q ε σ θ η v 0 0 δ =
+      ε/σ*(∑ i, (δ i*β i*Real.cos (inner ℝ (g i) (η-θ)/σ) +
+       (inner ℝ (g i) v/σ)*(α i*β i*Real.sin (inner ℝ (g i) (η-θ)/σ)-
+         α i*Real.cos (inner ℝ (g i) (η-θ)/σ)+β i*Real.cos (inner ℝ (g i) (η-θ)/σ)))) := by
+    unfold differential
+    simp only [Pi.zero_apply, mul_zero, zero_mul, add_zero, sub_zero]
+    rw [show ∀ a b c : ℝ, (a+b)-(a+c)=b-c by intros; ring]
+    rw [← mul_sub, ← Finset.sum_sub_distrib]
+    congr 1
+    apply Finset.sum_congr rfl
+    intro i _; ring
+  rw [heq, abs_mul, abs_of_nonneg (div_nonneg hε hσ.le)]
+  apply mul_le_mul_of_nonneg_left _ (div_nonneg hε hσ.le)
+  refine (Finset.abs_sum_le_sum_abs _ _).trans (Finset.sum_le_sum fun i _ => ?_)
+  let t := inner ℝ (g i) (η-θ)/σ
+  have hc : |Real.cos t| ≤ 1 := Real.abs_cos_le_one t
+  have hs : |Real.sin t| ≤ 1 := Real.abs_sin_le_one t
+  have hp : |α i*β i*Real.sin t-α i*Real.cos t+β i*Real.cos t| ≤
+      |α i| * |β i| + |α i| + |β i| := by
+    calc
+      _ ≤ |α i*β i*Real.sin t| + |α i*Real.cos t| + |β i*Real.cos t| :=
+        (abs_add_le _ _).trans (add_le_add (abs_sub _ _) le_rfl)
+      _ ≤ _ := by
+        simp only [abs_mul]
+        exact add_le_add (add_le_add
+          (mul_le_of_le_one_right (mul_nonneg (abs_nonneg _) (abs_nonneg _)) hs)
+          (mul_le_of_le_one_right (abs_nonneg _) hc))
+          (mul_le_of_le_one_right (abs_nonneg _) hc)
+  calc
+    _ ≤ |δ i*β i*Real.cos t| + |(inner ℝ (g i) v/σ)*
+        (α i*β i*Real.sin t-α i*Real.cos t+β i*Real.cos t)| := abs_add_le _ _
+    _ = |δ i| * |β i| * |Real.cos t| + |inner ℝ (g i) v|/σ*
+        |α i*β i*Real.sin t-α i*Real.cos t+β i*Real.cos t| := by
+      simp only [abs_mul, abs_div, abs_of_pos hσ]
+    _ ≤ _ := add_le_add
+      (mul_le_of_le_one_right (mul_nonneg (abs_nonneg _) (abs_nonneg _)) hc)
+      (mul_le_mul_of_nonneg_left hp (div_nonneg (abs_nonneg _) hσ.le))
+
+lemma cancellation (g : ι → E) (q ε σ k : ℝ) (θ η v : E) (h : ι → ℝ)
+    (hq : q ≠ 0) (hσ : σ ≠ 0) (hk : k = q^2/(Fintype.card ι : ℝ))
+    (hε : ε ≠ 0) :
+    differential g q ε σ θ η v 0 0
+      (fun i => k/ε*(h i-inner ℝ (g i) v/q)) =
+    k/σ*(∑ i, h i*Real.sin (inner ℝ (g i) (η-θ)/σ)) +
+    q/σ*inner ℝ
+      (Real.exp (-‖(σ⁻¹:ℝ) • (η-θ)‖^2/2) • ((σ⁻¹:ℝ) • (η-θ)) -
+       ((Fintype.card ι : ℝ)⁻¹) • ∑ i, Real.sin (inner ℝ (g i) (η-θ)/σ) • g i) v +
+    ε/σ^2*(∑ i, inner ℝ (g i) v*Real.sin (inner ℝ (g i) (η-θ)/σ)) := by
+  have hn : ‖(σ⁻¹:ℝ) • (η-θ)‖^2 = ‖η-θ‖^2/σ^2 := by
+    rw [norm_smul, mul_pow, Real.norm_eq_abs, sq_abs, inv_pow]; ring
+  simp only [differential, Pi.zero_apply, mul_zero, zero_mul, add_zero, sub_zero,
+    zero_add, one_mul, inner_sub_left, real_inner_smul_left, sum_inner, hn]
+  have he : - (‖η-θ‖^2/σ^2)/2 = -‖η-θ‖^2/(2*σ^2) := by ring
+  rw [he]
+  simp only [Finset.mul_sum]
+  have hterm (i : ι) : ε/σ * (k/ε*(h i-inner ℝ (g i) v/q)*Real.sin (inner ℝ (g i) (η-θ)/σ) +
+      (inner ℝ (g i) v/σ)*Real.sin (inner ℝ (g i) (η-θ)/σ)) =
+      k/σ*(h i*Real.sin (inner ℝ (g i) (η-θ)/σ)) -
+      q/σ*((Fintype.card ι : ℝ)⁻¹)*(Real.sin (inner ℝ (g i) (η-θ)/σ)*inner ℝ (g i) v) +
+      ε/σ^2*(inner ℝ (g i) v*Real.sin (inner ℝ (g i) (η-θ)/σ)) := by
+    rw [hk]
+    field_simp
+
+  simp_rw [hterm]
+  simp only [Finset.sum_add_distrib, Finset.sum_sub_distrib, ← Finset.mul_sum]
+  ring
+
+end UniformSparsestCut.Profile
+
+namespace UniformSparsestCut.Profile
+variable {E : Type u3} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+variable {S : Type u4} {N : Type u5} [Fintype S] [DecidableEq S] [Fintype N]
+
+lemma active_cancellation (g : S → N → E) (s : S) (q ε σ k : ℝ)
+    (θ η v : E) (h : N → ℝ) (hq : q ≠ 0) (hσ : σ ≠ 0)
+    (hk : k = q^2/(Fintype.card N : ℝ)) (hε : ε ≠ 0) :
+    differential (fun j : S × N => g j.1 j.2) q ε σ θ η v 0 0
+      (fun j => if j.1 = s then k/ε*(h j.2-inner ℝ (g j.1 j.2) v/q) else 0) =
+    k/σ*(∑ i, h i*Real.sin (inner ℝ (g s i) (η-θ)/σ)) +
+    q/σ*inner ℝ
+      (Real.exp (-‖(σ⁻¹:ℝ) • (η-θ)‖^2/2) • ((σ⁻¹:ℝ) • (η-θ)) -
+       ((Fintype.card N : ℝ)⁻¹) • ∑ i, Real.sin (inner ℝ (g s i) (η-θ)/σ) • g s i) v +
+    ε/σ^2*(∑ j : S × N, inner ℝ (g j.1 j.2) v*Real.sin (inner ℝ (g j.1 j.2) (η-θ)/σ)) := by
+  have hn : ‖(σ⁻¹:ℝ) • (η-θ)‖^2 = ‖η-θ‖^2/σ^2 := by
+    rw [norm_smul, mul_pow, Real.norm_eq_abs, sq_abs, inv_pow]; ring
+  have he : -(‖η-θ‖^2/σ^2)/2 = -‖η-θ‖^2/(2*σ^2) := by ring
+  simp only [differential, Pi.zero_apply, mul_zero, zero_mul, add_zero,
+    sub_zero, zero_add, one_mul, Finset.sum_add_distrib]
+  have hd : (∑ j : S × N, (if j.1 = s then k/ε*(h j.2-inner ℝ (g j.1 j.2) v/q) else 0) *
+      Real.sin (inner ℝ (g j.1 j.2) (η-θ)/σ)) =
+      k/ε*∑ i, (h i-inner ℝ (g s i) v/q)*Real.sin (inner ℝ (g s i) (η-θ)/σ) := by
+    simp only [Fintype.sum_prod_type, ite_mul, zero_mul]
+    simp only [Finset.sum_ite_irrel, Finset.sum_const_zero, Finset.sum_ite_eq', Finset.mem_univ, ite_true]
+    rw [Finset.mul_sum]; apply Finset.sum_congr rfl; intros; ring
+  rw [hd]
+  simp only [inner_sub_left, real_inner_smul_left, sum_inner, hn, he]
+  simp only [sub_mul, Finset.sum_sub_distrib, div_mul_eq_mul_div,
+    ← Finset.sum_div]
+  have hs : (∑ i, Real.sin (inner ℝ (g s i) (η-θ)/σ)*inner ℝ (g s i) v) =
+      ∑ i, inner ℝ (g s i) v*Real.sin (inner ℝ (g s i) (η-θ)/σ) := by
+    apply Finset.sum_congr rfl; intros; ring
+  rw [hs, hk]
+  field_simp
+  ring
+
+lemma active_bound (g : S → N → E) (s : S) {q ε σ k γ G : ℝ}
+    (θ η v : E) (h : N → ℝ) (hq : 0 < q) (hε : 0 < ε) (hσ : 0 < σ)
+    (hk : k = q^2/(Fintype.card N : ℝ)) (hg : ∀ s i, ‖g s i‖ ≤ G)
+    (hf : ‖Real.exp (-‖(σ⁻¹:ℝ) • (η-θ)‖^2/2) • ((σ⁻¹:ℝ) • (η-θ)) -
+       ((Fintype.card N : ℝ)⁻¹) • ∑ i, Real.sin (inner ℝ (g s i) (η-θ)/σ) • g s i‖ ≤ γ) :
+    |differential (fun j : S × N => g j.1 j.2) q ε σ θ η v 0 0
+      (fun j => if j.1 = s then k/ε*(h j.2-inner ℝ (g j.1 j.2) v/q) else 0)| ≤
+      k/σ*(∑ i, |h i|) + q*γ/σ*‖v‖ +
+        ε/σ^2*((Fintype.card S : ℝ)*(Fintype.card N : ℝ)*G)*‖v‖ := by
+  have hk0 : 0 ≤ k := by rw [hk]; positivity
+  rw [active_cancellation g s q ε σ k θ η v h hq.ne' hσ.ne' hk hε.ne']
+  have hsum : |∑ i, h i*Real.sin (inner ℝ (g s i) (η-θ)/σ)| ≤ ∑ i, |h i| := by
+    refine (Finset.abs_sum_le_sum_abs _ _).trans (Finset.sum_le_sum fun i _ => ?_)
+    rw [abs_mul]; exact mul_le_of_le_one_right (abs_nonneg _) (Real.abs_sin_le_one _)
+  have hfour := (abs_real_inner_le_norm _ v).trans (mul_le_mul_of_nonneg_right hf (norm_nonneg v))
+  have hglobal : |∑ j : S × N, inner ℝ (g j.1 j.2) v*Real.sin (inner ℝ (g j.1 j.2) (η-θ)/σ)| ≤
+      (Fintype.card S : ℝ)*(Fintype.card N : ℝ)*G*‖v‖ := by
+    calc
+      _ ≤ ∑ j : S × N, |inner ℝ (g j.1 j.2) v*Real.sin (inner ℝ (g j.1 j.2) (η-θ)/σ)| :=
+        Finset.abs_sum_le_sum_abs _ _
+      _ ≤ ∑ _j : S × N, G*‖v‖ := by
+        apply Finset.sum_le_sum; intro j _
+        rw [abs_mul]
+        exact (mul_le_of_le_one_right (abs_nonneg _) (Real.abs_sin_le_one _)).trans
+          ((abs_real_inner_le_norm _ _).trans (mul_le_mul_of_nonneg_right (hg j.1 j.2) (norm_nonneg v)))
+      _ = _ := by simp [Fintype.card_prod]; ring
+  calc
+    _ ≤ |k/σ*(∑ i, h i*Real.sin (inner ℝ (g s i) (η-θ)/σ))| +
+        |q/σ*inner ℝ (Real.exp (-‖(σ⁻¹:ℝ) • (η-θ)‖^2/2) • ((σ⁻¹:ℝ) • (η-θ)) -
+       ((Fintype.card N : ℝ)⁻¹) • ∑ i, Real.sin (inner ℝ (g s i) (η-θ)/σ) • g s i) v| +
+       |ε/σ^2*(∑ j : S × N, inner ℝ (g j.1 j.2) v*Real.sin (inner ℝ (g j.1 j.2) (η-θ)/σ))| :=
+      (abs_add_le _ _).trans (add_le_add (abs_add_le _ _) le_rfl)
+    _ ≤ k/σ*(∑ i, |h i|) + q/σ*(γ*‖v‖) +
+        ε/σ^2*((Fintype.card S : ℝ)*(Fintype.card N : ℝ)*G*‖v‖) := by
+      simp only [abs_mul, abs_of_nonneg (div_nonneg hk0 hσ.le),
+        abs_of_pos (div_pos hq hσ), abs_of_pos (div_pos hε (sq_pos_of_pos hσ))]
+      exact add_le_add (add_le_add (mul_le_mul_of_nonneg_left hsum (div_nonneg hk0 hσ.le))
+        (mul_le_mul_of_nonneg_left hfour (div_nonneg hq.le hσ.le)))
+        (mul_le_mul_of_nonneg_left hglobal (div_nonneg hε.le (sq_nonneg σ)))
+    _ = _ := by ring
+
+end UniformSparsestCut.Profile
+
+namespace UniformSparsestCut.Profile
+variable {E : Type u6} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+variable {ι : Type u7} [Fintype ι]
+
+def kernel (g : ι → E) (q ε a b : ℝ) (θ η : E) (α β : ι → ℝ) : ℝ :=
+  ∫ σ in a..b, pairing g q ε σ θ η α β
+
+lemma pairing_continuousOn (g : ι → E) (q ε : ℝ) (θ η : E) (α β : ι → ℝ)
+    {a b : ℝ} (ha : 0 < a) : ContinuousOn (fun σ => pairing g q ε σ θ η α β) (Icc a b) := by
+  have hn : ∀ σ ∈ Icc a b, σ ≠ 0 := fun σ h => (ha.trans_le h.1).ne'
+  have hnp : ∀ σ ∈ Icc a b, 2*σ^2 ≠ 0 := fun σ h => mul_ne_zero (by norm_num) (pow_ne_zero _ (hn σ h))
+  unfold pairing
+  refine (continuousOn_const.mul (Real.continuous_exp.comp_continuousOn
+    (continuousOn_const.div (by fun_prop) hnp))).add ?_
+  apply (continuousOn_const.div continuousOn_id hn).mul
+  apply continuousOn_finsetSum
+  intro i _
+  have hc := continuousOn_const.div continuousOn_id hn (f := fun _ : ℝ => inner ℝ (g i) (η-θ))
+  exact (continuousOn_const.mul (Real.continuous_cos.comp_continuousOn hc)).add
+    (continuousOn_const.mul (Real.continuous_sin.comp_continuousOn hc))
+
+lemma pairing_integrable (g : ι → E) (q ε : ℝ) (θ η : E) (α β : ι → ℝ)
+    {a b : ℝ} (ha : 0 < a) (hab : a ≤ b) :
+    IntervalIntegrable (fun σ => pairing g q ε σ θ η α β) volume a b := by
+  apply ContinuousOn.intervalIntegrable
+  rw [uIcc_of_le hab]
+  exact pairing_continuousOn g q ε θ η α β ha
+
+lemma pairing_correction (g : ι → E) {q ε σ : ℝ} (hε : 0 ≤ ε) (hσ : 0 < σ)
+    (θ η : E) (α β : ι → ℝ) :
+    |pairing g q ε σ θ η α β - pairing g q ε σ θ η 0 0| ≤
+      ε/σ*∑ i, (|α i| * |β i|+|α i|+|β i|) := by
+  have he : pairing g q ε σ θ η α β - pairing g q ε σ θ η 0 0 =
+      ε/σ*∑ i, (α i*β i*Real.cos (inner ℝ (g i) (η-θ)/σ) +
+        α i*Real.sin (inner ℝ (g i) (η-θ)/σ)-β i*Real.sin (inner ℝ (g i) (η-θ)/σ)) := by
+    unfold pairing
+    simp only [Pi.zero_apply, mul_zero, add_zero, zero_mul, sub_zero, one_mul]
+    rw [show ∀ c d e : ℝ, (c+d)-(c+e)=d-e by intros; ring, ← mul_sub, ← Finset.sum_sub_distrib]
+    congr 1; apply Finset.sum_congr rfl; intro i _; ring
+  rw [he, abs_mul, abs_of_nonneg (div_nonneg hε hσ.le)]
+  apply mul_le_mul_of_nonneg_left _ (div_nonneg hε hσ.le)
+  refine (Finset.abs_sum_le_sum_abs _ _).trans (Finset.sum_le_sum fun i _ => ?_)
+  calc
+    _ ≤ |α i*β i*Real.cos (inner ℝ (g i) (η-θ)/σ)| +
+        |α i*Real.sin (inner ℝ (g i) (η-θ)/σ)|+|β i*Real.sin (inner ℝ (g i) (η-θ)/σ)| :=
+      (abs_sub _ _).trans (add_le_add (abs_add_le _ _) le_rfl)
+    _ ≤ _ := by
+      simp only [abs_mul]
+      exact add_le_add (add_le_add
+        (mul_le_of_le_one_right (mul_nonneg (abs_nonneg _) (abs_nonneg _)) (Real.abs_cos_le_one _))
+        (mul_le_of_le_one_right (abs_nonneg _) (Real.abs_sin_le_one _)))
+        (mul_le_of_le_one_right (abs_nonneg _) (Real.abs_sin_le_one _))
+
+lemma kernel_correction (g : ι → E) {q ε a b A : ℝ}
+    (hε : 0 ≤ ε) (ha : 0 < a) (hab : a ≤ b) (hA : 0 ≤ A)
+    (θ η : E) (α β : ι → ℝ) (hα : ∀ i, |α i| ≤ A) (hβ : ∀ i, |β i| ≤ A) :
+    |kernel g q ε a b θ η α β - kernel g q ε a b θ η 0 0| ≤
+      ε*(Fintype.card ι : ℝ)*(A^2+2*A)*Real.log (b/a) := by
+  have hip := pairing_integrable g q ε θ η α β ha hab
+  have hiz := pairing_integrable g q ε θ η 0 0 ha hab
+  have hiinv : IntervalIntegrable (fun σ : ℝ => σ⁻¹) volume a b := by
+    apply ContinuousOn.intervalIntegrable
+    rw [uIcc_of_le hab]
+    exact continuousOn_id.inv₀ (fun σ h => (ha.trans_le h.1).ne')
+  have hi := hiinv.const_mul (ε*(Fintype.card ι : ℝ)*(A^2+2*A))
+  unfold kernel
+  rw [← intervalIntegral.integral_sub hip hiz]
+  calc
+    _ ≤ ∫ σ in a..b, |pairing g q ε σ θ η α β-pairing g q ε σ θ η 0 0| :=
+      intervalIntegral.abs_integral_le_integral_abs hab
+    _ ≤ ∫ σ in a..b, ε*(Fintype.card ι : ℝ)*(A^2+2*A)*σ⁻¹ := by
+      apply intervalIntegral.integral_mono_on hab (hip.sub hiz).abs hi
+      intro σ hσ
+      have hp := ha.trans_le hσ.1
+      have hs : (∑ i, (|α i| * |β i|+|α i|+|β i|)) ≤ (Fintype.card ι : ℝ)*(A^2+2*A) := by
+        calc
+          _ ≤ ∑ _i : ι, (A^2+2*A) := by
+            apply Finset.sum_le_sum; intro i _
+            have hm := mul_le_mul (hα i) (hβ i) (abs_nonneg _) hA
+            nlinarith [hα i, hβ i]
+          _ = _ := by simp; ring
+      calc
+        _ ≤ ε/σ*∑ i, (|α i| * |β i|+|α i|+|β i|) := pairing_correction g hε hp θ η α β
+        _ ≤ ε/σ*((Fintype.card ι : ℝ)*(A^2+2*A)) := mul_le_mul_of_nonneg_left hs (div_nonneg hε hp.le)
+        _ = _ := by ring
+    _ = _ := by rw [intervalIntegral.integral_const_mul, integral_inv_of_pos ha (ha.trans_le hab)]
+
+lemma integral_inv_sq {a b : ℝ} (ha : 0 < a) (hab : a ≤ b) :
+    (∫ σ in a..b, (σ^2)⁻¹) = a⁻¹-b⁻¹ := by
+  have hd (σ : ℝ) (hσ : σ ∈ Icc a b) : HasDerivAt (fun σ : ℝ => -σ⁻¹) ((σ^2)⁻¹) σ := by
+    convert ((hasDerivAt_id σ).inv (ha.trans_le hσ.1).ne').neg using 1 <;> try rfl
+    simp; ring
+  have hi : IntervalIntegrable (fun σ : ℝ => (σ^2)⁻¹) volume a b := by
+    apply ContinuousOn.intervalIntegrable
+    rw [uIcc_of_le hab]
+    exact (continuousOn_id.pow 2).inv₀ (fun σ h => pow_ne_zero _ (ha.trans_le h.1).ne')
+  have h := intervalIntegral.integral_eq_sub_of_hasDerivAt
+    (fun σ hσ => hd σ (by simpa only [uIcc_of_le hab] using hσ)) hi
+  convert h using 1 ; ring
+
+lemma kernel_segment_bound (g : ι → E) {q ε a b C D : ℝ} (ha : 0 < a) (hab : a ≤ b)
+    (hD : 0 ≤ D) (θ η v : E) (α β δ : ι → ℝ)
+    (hd : ∀ t ∈ Icc (0 : ℝ) 1, ∀ σ ∈ Icc a b,
+      |differential g q ε σ (θ+t • v) η v (fun i => α i+t*δ i) β δ| ≤ C/σ+D/σ^2) :
+    |kernel g q ε a b (θ+v) η (fun i => α i+δ i) β-kernel g q ε a b θ η α β| ≤
+      C*Real.log (b/a)+D/a := by
+  have hip := pairing_integrable g q ε (θ+v) η (fun i => α i+δ i) β ha hab
+  have hiz := pairing_integrable g q ε θ η α β ha hab
+  have hii : IntervalIntegrable (fun σ : ℝ => σ⁻¹) volume a b := by
+    apply ContinuousOn.intervalIntegrable
+    rw [uIcc_of_le hab]
+    exact continuousOn_id.inv₀ (fun σ h => (ha.trans_le h.1).ne')
+  have hiis : IntervalIntegrable (fun σ : ℝ => (σ^2)⁻¹) volume a b := by
+    apply ContinuousOn.intervalIntegrable
+    rw [uIcc_of_le hab]
+    exact (continuousOn_id.pow 2).inv₀ (fun σ h => pow_ne_zero _ (ha.trans_le h.1).ne')
+  have hi := (hii.const_mul C).add (hiis.const_mul D)
+  have hbound (σ : ℝ) (hσ : σ ∈ Icc a b) :
+      |pairing g q ε σ (θ+v) η (fun i => α i+δ i) β-pairing g q ε σ θ η α β| ≤ C/σ+D/σ^2 := by
+    have h := norm_image_sub_le_of_norm_deriv_le_segment_01'
+      (fun t ht => (pairing_hasDeriv g q ε σ θ η v α β δ t).hasDerivWithinAt)
+      (fun t ht => by simpa only [Real.norm_eq_abs] using hd t ⟨ht.1, ht.2.le⟩ σ hσ)
+    simpa only [one_smul, one_mul, zero_smul, add_zero, zero_mul, Real.norm_eq_abs] using h
+  unfold kernel
+  rw [← intervalIntegral.integral_sub hip hiz]
+  calc
+    _ ≤ ∫ σ in a..b, |pairing g q ε σ (θ+v) η (fun i => α i+δ i) β-pairing g q ε σ θ η α β| :=
+      intervalIntegral.abs_integral_le_integral_abs hab
+    _ ≤ ∫ σ in a..b, C*σ⁻¹+D*(σ^2)⁻¹ := by
+      apply intervalIntegral.integral_mono_on hab (hip.sub hiz).abs hi
+      intro σ hσ; simpa only [div_eq_mul_inv] using hbound σ hσ
+    _ = C*Real.log (b/a)+D*(a⁻¹-b⁻¹) := by
+      rw [intervalIntegral.integral_add (hii.const_mul C) (hiis.const_mul D),
+        intervalIntegral.integral_const_mul, intervalIntegral.integral_const_mul,
+        integral_inv_of_pos ha (ha.trans_le hab), integral_inv_sq ha hab]
+    _ ≤ _ := by
+      simp only [div_eq_mul_inv]
+      have := mul_nonneg hD (inv_nonneg.mpr (ha.trans_le hab).le)
+      nlinarith
+
+end UniformSparsestCut.Profile
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/Replication.lean

@@ -0,0 +1,172 @@
+import OAI.Combinatorics.SparsestCut.CutDuality
+
+namespace OAI
+
+universe u1 u2 u3 u4
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.Replication
+variable {V : Type u1} [Fintype V]
+def count (M : ℕ) (w : V → ℝ) (v : V) : ℕ := 1+⌊(M:ℝ)*w v⌋₊
+def Copies (M : ℕ) (w : V → ℝ) := (v : V) × Fin (count M w v)
+instance (M : ℕ) (w : V → ℝ) : Fintype (Copies M w) := inferInstanceAs (Fintype (Sigma _))
+def n (M : ℕ) (w : V → ℝ) : ℕ := Fintype.card (Copies M w)
+def q (M : ℕ) (w : V → ℝ) (v : V) : ℝ := (count M w v:ℝ)/(n M w:ℝ)
+omit [Fintype V] in
+lemma count_pos (M : ℕ) (w : V → ℝ) (v : V) : 0<count M w v := by unfold count; omega
+lemma n_sum (M : ℕ) (w : V → ℝ) : n M w=∑ v, count M w v := by
+  change Fintype.card ((v : V) × Fin (count M w v)) = _
+  simp [Fintype.card_sigma]
+omit [Fintype V] in
+lemma count_error (M : ℕ) (w : V → ℝ) (hw : ∀ v, 0≤w v) (v : V) :
+    0<(count M w v:ℝ)-(M:ℝ)*w v ∧ (count M w v:ℝ)-(M:ℝ)*w v≤1 := by
+  have h0 : 0≤(M:ℝ)*w v := mul_nonneg (Nat.cast_nonneg _) (hw v)
+  have h1 := Nat.floor_le h0
+  have h2 := Nat.lt_floor_add_one ((M:ℝ)*w v)
+  simp only [count,Nat.cast_add,Nat.cast_one]
+  constructor <;> linarith
+lemma n_bounds (M : ℕ) (w : V → ℝ) (hw : ∀ v, 0≤w v) (hws : ∑ v, w v=1) :
+    M≤n M w ∧ n M w≤M+Fintype.card V := by
+  have hs : (n M w:ℝ)-(M:ℝ)=∑ v, ((count M w v:ℝ)-(M:ℝ)*w v) := by
+    rw [Finset.sum_sub_distrib,← Finset.mul_sum,hws,mul_one,n_sum,Nat.cast_sum]
+  have h0 : 0≤(n M w:ℝ)-(M:ℝ) := by rw [hs]; exact Finset.sum_nonneg (fun v _ => (count_error M w hw v).1.le)
+  have h1 : (n M w:ℝ)-(M:ℝ)≤Fintype.card V := by
+    rw [hs]
+    calc
+      _ ≤ ∑ _v : V, (1:ℝ) := Finset.sum_le_sum (fun v _ => (count_error M w hw v).2)
+      _ = _ := by simp
+  constructor
+  · exact_mod_cast (show (M:ℝ)≤n M w by linarith)
+  · exact_mod_cast (show (n M w:ℝ)≤(M:ℝ)+Fintype.card V by linarith)
+lemma q_nonneg (M : ℕ) (w : V → ℝ) (v : V) : 0≤q M w v := by unfold q; positivity
+lemma q_sum (M : ℕ) (w : V → ℝ) (hn : 0<n M w) : ∑ v, q M w v=1 := by
+  simp only [q,← Finset.sum_div,← Nat.cast_sum,← n_sum]
+  exact div_self (by exact_mod_cast hn.ne')
+lemma q_l1_bound (M : ℕ) (hM : 0<M) (w : V → ℝ) (hw : ∀ v, 0≤w v) (hws : ∑ v, w v=1) :
+    (∑ v, |q M w v-w v|)≤2*(Fintype.card V:ℝ)/M := by
+  have hb := n_bounds M w hw hws
+  have hMr : (0:ℝ)<M := by exact_mod_cast hM
+  have hn : (0:ℝ)<n M w := lt_of_lt_of_le hMr (by exact_mod_cast hb.1)
+  have hE : (n M w:ℝ)-(M:ℝ)=∑ v, ((count M w v:ℝ)-(M:ℝ)*w v) := by
+    rw [Finset.sum_sub_distrib,← Finset.mul_sum,hws,mul_one,n_sum,Nat.cast_sum]
+  have hE0 : 0≤(n M w:ℝ)-(M:ℝ) := by
+    have hh : (M:ℝ)≤n M w := by exact_mod_cast hb.1
+    linarith
+  have he (v : V) : |q M w v-w v|≤
+      (((count M w v:ℝ)-(M:ℝ)*w v)+((n M w:ℝ)-(M:ℝ))*w v)/(n M w:ℝ) := by
+    have heq : q M w v-w v=
+        (((count M w v:ℝ)-(M:ℝ)*w v)-((n M w:ℝ)-(M:ℝ))*w v)/(n M w:ℝ) := by
+      unfold q; field_simp; ring
+    rw [heq,abs_div,abs_of_pos hn]
+    apply div_le_div_of_nonneg_right _ hn.le
+    exact (abs_sub _ _).trans_eq (by rw [abs_of_nonneg (count_error M w hw v).1.le,abs_of_nonneg (mul_nonneg hE0 (hw v))])
+  calc
+    _ ≤ ∑ v, (((count M w v:ℝ)-(M:ℝ)*w v)+((n M w:ℝ)-(M:ℝ))*w v)/(n M w:ℝ) := Finset.sum_le_sum (fun v _ => he v)
+    _ = 2*((n M w:ℝ)-(M:ℝ))/(n M w:ℝ) := by
+      rw [← Finset.sum_div,Finset.sum_add_distrib,← Finset.mul_sum,hws,mul_one,← hE]; ring
+    _ ≤ 2*(Fintype.card V:ℝ)/(n M w:ℝ) := by
+      apply div_le_div_of_nonneg_right _ hn.le
+      have h : (n M w:ℝ)≤(M:ℝ)+Fintype.card V := by exact_mod_cast hb.2
+      linarith
+    _ ≤ _ := div_le_div_of_nonneg_left (by positivity) hMr (by exact_mod_cast hb.1)
+
+lemma product_expectation_bound (p q : V → ℝ) (hp : ∀ v, 0≤p v) (hq : ∀ v, 0≤q v)
+    (hps : ∑ v, p v=1) (hqs : ∑ v, q v=1) (g : V → V → ℝ) {D : ℝ}
+    (_hD : 0≤D) (hg : ∀ v z, |g v z|≤D) :
+    |(∑ v, ∑ z, p v*p z*g v z)-(∑ v, ∑ z, q v*q z*g v z)|≤
+      2*D*(∑ v, |p v-q v|) := by
+  have he (v z : V) : p v*p z*g v z-q v*q z*g v z=
+      (p v-q v)*p z*g v z+q v*(p z-q z)*g v z := by ring
+  calc
+    _ = |∑ v, ∑ z, ((p v-q v)*p z*g v z+q v*(p z-q z)*g v z)| := by
+      simp only [← Finset.sum_sub_distrib,he]
+    _ ≤ ∑ v, ∑ z, |(p v-q v)*p z*g v z+q v*(p z-q z)*g v z| :=
+      (Finset.abs_sum_le_sum_abs _ _).trans (Finset.sum_le_sum (fun v _ => Finset.abs_sum_le_sum_abs _ _))
+    _ ≤ ∑ v, ∑ z, (|p v-q v| *p z*D+q v*|p z-q z| *D) := by
+      apply Finset.sum_le_sum; intro v hv
+      apply Finset.sum_le_sum; intro z hz
+      calc
+        _ ≤ |(p v-q v)*p z*g v z|+|q v*(p z-q z)*g v z| := abs_add_le _ _
+        _ ≤ _ := by
+          rw [abs_mul,abs_mul,abs_mul,abs_mul,abs_of_nonneg (hp z),abs_of_nonneg (hq v)]
+          exact add_le_add (mul_le_mul_of_nonneg_left (hg v z) (mul_nonneg (abs_nonneg _) (hp z)))
+            (mul_le_mul_of_nonneg_left (hg v z) (mul_nonneg (hq v) (abs_nonneg _)))
+    _ = _ := by
+      simp only [Finset.sum_add_distrib,← Finset.sum_mul,← Finset.mul_sum,hps,hqs,mul_one,one_mul]
+      ring
+end UniformSparsestCut.Replication
+
+namespace UniformSparsestCut.Replication
+open scoped BigOperators RealInnerProductSpace
+noncomputable section
+variable {V : Type u2} [Fintype V]
+def rep (M : ℕ) (w : V → ℝ) (i : Fin (n M w)) : V := ((Fintype.equivFin (Copies M w)).symm i).1
+def representative (M : ℕ) (w : V → ℝ) (v : V) : Fin (n M w) :=
+  (Fintype.equivFin (Copies M w)) ⟨v,⟨0,count_pos M w v⟩⟩
+lemma rep_section (M : ℕ) (w : V → ℝ) (v : V) : rep M w (representative M w v)=v := by
+  exact congrArg (fun copy : Copies M w => copy.1)
+    ((Fintype.equivFin (Copies M w)).symm_apply_apply ⟨v, ⟨0, count_pos M w v⟩⟩)
+lemma sum_rep (M : ℕ) (w : V → ℝ) (g : V → ℝ) :
+    (∑ i : Fin (n M w), g (rep M w i))=∑ v, (count M w v:ℝ)*g v := by
+  classical
+  calc
+    _ = ∑ c : Copies M w, g (rep M w ((Fintype.equivFin (Copies M w)) c)) :=
+      ((Fintype.equivFin (Copies M w)).sum_comp (fun i => g (rep M w i))).symm
+    _ = ∑ c : Copies M w, g c.1 := Finset.sum_congr rfl (fun copy _ =>
+      congrArg (fun copy : Copies M w => g copy.1)
+        ((Fintype.equivFin (Copies M w)).symm_apply_apply copy))
+    _ = _ := by
+      change (∑ c : (v : V) × Fin (count M w v), g c.1) = _
+      simp [Fintype.sum_sigma]
+lemma ordered_sum (M : ℕ) (w : V → ℝ) (hn : 0 < n M w) (g : V → V → ℝ) :
+    (∑ i : Fin (n M w), ∑ j, g (rep M w i) (rep M w j))=
+      (n M w:ℝ)^2*(∑ v, ∑ z, q M w v*q M w z*g v z) := by
+  have hn0 : (n M w:ℝ)≠0 := by exact_mod_cast hn.ne'
+  calc
+    _ = ∑ i : Fin (n M w), ∑ z, (count M w z:ℝ)*g (rep M w i) z :=
+      Finset.sum_congr rfl (fun i _ => sum_rep M w (g (rep M w i)))
+    _ = ∑ v, (count M w v:ℝ)*(∑ z, (count M w z:ℝ)*g v z) :=
+      sum_rep M w (fun v => ∑ z, (count M w z:ℝ)*g v z)
+    _ = _ := by
+      simp only [Finset.mul_sum,q]
+      apply Finset.sum_congr rfl
+      intro v hv
+      apply Finset.sum_congr rfl
+      intro z hz
+      field_simp
+
+lemma collapse (M : ℕ) (w : V → ℝ) (d : V → V → ℝ) (hself : ∀ v, d v v=0)
+    {A : Type u3} [Fintype A] (F : Fin (n M w) → A → ℝ)
+    (hF : ∀ i j, (∑ a, |F i a-F j a|)≤d (rep M w i) (rep M w j)) (i : Fin (n M w)) (a : A) :
+    F i a=F (representative M w (rep M w i)) a := by
+  classical
+  have h := hF i (representative M w (rep M w i))
+  rw [rep_section,hself] at h
+  have hh := (Finset.single_le_sum (fun b _ => abs_nonneg (F i b-F (representative M w (rep M w i)) b)) (Finset.mem_univ a)).trans h
+  exact sub_eq_zero.mp (abs_nonpos_iff.mp hh)
+lemma descend_contraction (M : ℕ) (w : V → ℝ) (d : V → V → ℝ)
+    {A : Type u4} [Fintype A] (F : Fin (n M w) → A → ℝ)
+    (hF : ∀ i j, (∑ a, |F i a-F j a|)≤d (rep M w i) (rep M w j)) :
+    ∀ v z, (∑ a, |F (representative M w v) a-F (representative M w z) a|)≤d v z := by
+  intro v z
+  simpa only [rep_section] using hF (representative M w v) (representative M w z)
+lemma expectation_error (M : ℕ) (hM : 0 < M) (w : V → ℝ) (hw : ∀ v, 0≤w v) (hws : (∑ v,w v)=1)
+    (g : V → V → ℝ) {D : ℝ} (hD : 0≤D) (hg : ∀ v z, |g v z|≤D) :
+    |(∑ v, ∑ z, q M w v*q M w z*g v z)-(∑ v, ∑ z, w v*w z*g v z)|≤
+      4*D*(Fintype.card V:ℝ)/M := by
+  have hn : 0 < n M w := hM.trans_le (n_bounds M w hw hws).1
+  have h := product_expectation_bound (q M w) w (q_nonneg M w) hw (q_sum M w hn) hws g hD hg
+  calc
+    _ ≤ 2*D*(∑ v, |q M w v-w v|) := h
+    _ ≤ 2*D*(2*(Fintype.card V:ℝ)/M) := mul_le_mul_of_nonneg_left (q_l1_bound M hM w hw hws) (by positivity)
+    _ = _ := by ring
+end
+end UniformSparsestCut.Replication
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/RoundedCharts.lean

@@ -0,0 +1,321 @@
+import OAI.Combinatorics.SparsestCut.ChartLinear
+
+namespace OAI
+
+universe u1 u2
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.SourceCharts
+open scoped BigOperators RealInnerProductSpace
+open Filter Set
+noncomputable section
+variable {m : ℕ} (f : PivotFamily.PFamily m) (hm : 0 < m)
+local notation "E" => EuclideanSpace ℝ (Fin m)
+local notation "F" => EuclideanSpace ℝ (Fin (m^6))
+def u (s : Fin (m^3)) (i : Fin (m^6)) : E := (Real.sqrt m)⁻¹ • f.g s i
+def lower (m : ℕ) : ℝ := (m:ℝ)^6/(2*m)
+include hm
+lemma lower_pos : 0<lower m := by unfold lower; positivity
+lemma energy (s : Fin (m^3)) (x : E) : lower m*‖x‖^2≤‖FrameCharts.chart (u f s) x‖^2 := by
+  have hc (v : E) (hv : ‖v‖=1) := f.covariance s v hv
+  have h := (FrameCharts.normalized_bounds (f.g s) hm (pow_pos hm _) (by
+    intro v hv
+    simpa only [DirectionInterpolation.empiricalCov,real_inner_comm,div_eq_mul_inv,mul_comm] using hc v hv) x).1
+  change (m:ℝ)^6/(2*m)*‖x‖^2≤‖FrameCharts.chart (fun i => (Real.sqrt m)⁻¹ • f.g s i) x‖^2
+  simpa only [Nat.cast_pow] using h
+def B (s : Fin (m^3)) : F →L[ℝ] E :=
+  ChartLinear.pseudoInverse (FrameCharts.chart (u f s)) (lower_pos hm) (energy f hm s)
+lemma B_left (s : Fin (m^3)) (x : E) : B f hm s (FrameCharts.chart (u f s) x)=x := by
+  have h := ChartLinear.pseudoInverse_comp (FrameCharts.chart (u f s)) (lower_pos hm) (energy f hm s)
+  exact congrArg (fun L : E →L[ℝ] E => L x) h
+lemma u_norm (s : Fin (m^3)) (i : Fin (m^6)) : 1/2≤‖u f s i‖ ∧ ‖u f s i‖≤2 :=
+  FrameCharts.normalized_norms (f.g s) hm (f.norms s) i
+lemma u_nonzero (s : Fin (m^3)) (i : Fin (m^6)) : u f s i≠0 := by
+  have h := (u_norm f hm s i).1
+  intro hz; rw [hz,norm_zero] at h; norm_num at h
+lemma u_nonparallel (s : Fin (m^3)) (i j : Fin (m^6)) (hij : i≠j) (t : ℝ) :
+    u f s i≠t • u f s j := by
+  intro h
+  apply f.nonparallel s i j hij t
+  have hq : (Real.sqrt m)⁻¹≠0 := inv_ne_zero (ne_of_gt (Real.sqrt_pos.mpr (by exact_mod_cast hm)))
+  have he := congrArg (fun x : E => Real.sqrt m • x) h
+  have hq0 : Real.sqrt (m:ℝ)≠0 := ne_of_gt (Real.sqrt_pos.mpr (by exact_mod_cast hm))
+  have hmul : Real.sqrt (m:ℝ)*(t*(Real.sqrt (m:ℝ))⁻¹)=t := by field_simp
+  simpa only [u,smul_smul,mul_inv_cancel₀ hq0,hmul,one_smul] using he
+lemma u_pivot (s : Fin (m^3)) (i : Fin (m^6)) (j : Fin m ) :
+    1/((m:ℝ)^30*Real.sqrt m) < |u f s i j| := by
+  have hq : 0<Real.sqrt m := Real.sqrt_pos.mpr (by exact_mod_cast hm)
+  change _ < |(Real.sqrt m)⁻¹*(f.g s i j)|
+  rw [abs_mul,abs_of_pos (inv_pos.mpr hq)]
+  simpa only [one_div,mul_inv,mul_comm] using mul_lt_mul_of_pos_left (f.pivot s i j) (inv_pos.mpr hq)
+lemma B_column (s : Fin (m^3)) (i : Fin (m^6)) :
+    ‖B f hm s (EuclideanSpace.single i 1)‖≤4*((m:ℝ)/(m:ℝ)^6) := by
+  have h := ChartLinear.pseudoInverse_column (FrameCharts.chart (u f s)) (lower_pos hm) (energy f hm s) (EuclideanSpace.single i 1)
+  rw [FrameCharts.chart_adjoint_single] at h
+  calc
+    _ ≤ 2/lower m := h.trans (div_le_div_of_nonneg_right (u_norm f hm s i).2 (lower_pos hm).le)
+    _ = _ := by unfold lower; field_simp; ring
+lemma B_norm (s : Fin (m^3)) (x : F) : ‖B f hm s x‖≤‖x‖/Real.sqrt (lower m) :=
+  ChartLinear.pseudoInverse_norm _ (lower_pos hm) (energy f hm s) x
+lemma residual_norm (s : Fin (m^3)) (x : F) :
+    ‖x-FrameCharts.chart (u f s) (B f hm s x)‖≤‖x‖ :=
+  ChartLinear.residual_norm _ (lower_pos hm) (energy f hm s) x
+end
+end UniformSparsestCut.SourceCharts
+
+namespace UniformSparsestCut.HyperplaneCount
+variable {E : Type u1} {ι : Type u2} [AddCommGroup E] [Module ℝ E] [FiniteDimensional ℝ E]
+  [Fintype ι] [DecidableEq ι]
+
+omit [FiniteDimensional ℝ E] [Fintype ι] in
+lemma shattered_independent (f : ι → E →ₗ[ℝ] ℝ) (A : Finset (Finset ι))
+    (hA : ∀ u ∈ A, ∃ x : E, ∀ i, f i x ≠ 0 ∧ (0 < f i x ↔ i ∈ u))
+    {s : Finset ι} (hs : A.Shatters s) : LinearIndependent ℝ (fun i : s => f i) := by
+  classical
+  rw [Fintype.linearIndependent_iff]
+  intro c hc j
+  by_contra hj
+  let t := s.filter (fun i => ∀ hi : i ∈ s, 0 < c ⟨i,hi⟩)
+  obtain ⟨u,hu,htu⟩ := hs (t := t) (Finset.filter_subset _ _)
+  obtain ⟨x,hx⟩ := hA u hu
+  have hsign (i : s) : 0 < f i x ↔ 0 < c i := by
+    rw [(hx i).2]
+    have he : i.val ∈ s ∩ u ↔ i.val ∈ t := by rw [htu]
+    simp only [Finset.mem_inter, i.property, true_and, t, Finset.mem_filter] at he
+    exact he.trans ⟨fun h => h trivial, fun h _ => h⟩
+  have hprod (i : s) : 0 ≤ c i * f i x := by
+    by_cases hp : 0 < c i
+    · exact le_of_lt (mul_pos hp ((hsign i).mpr hp))
+    · exact mul_nonneg_of_nonpos_of_nonpos (le_of_not_gt hp)
+        (le_of_not_gt (mt (hsign i).mp hp))
+  have hpj : 0 < c j * f j x := by
+    by_cases hp : 0 < c j
+    · exact mul_pos hp ((hsign j).mpr hp)
+    · have hn : c j < 0 := lt_of_le_of_ne (le_of_not_gt hp) hj
+      have hf : f j x < 0 := lt_of_le_of_ne (le_of_not_gt (mt (hsign j).mp hp)) (hx j).1
+      exact mul_pos_of_neg_of_neg hn hf
+  have hp : 0 < ∑ i : s, c i * f i x :=
+    Finset.sum_pos' (fun i _ => hprod i) ⟨j, Finset.mem_univ _, hpj⟩
+  have hz := congrArg (fun L : E →ₗ[ℝ] ℝ => L x) hc
+  simp only [LinearMap.sum_apply, LinearMap.smul_apply, smul_eq_mul, LinearMap.zero_apply] at hz
+  linarith
+
+omit [Fintype ι] in
+lemma vcDim_le (f : ι → E →ₗ[ℝ] ℝ) (A : Finset (Finset ι))
+    (hA : ∀ u ∈ A, ∃ x : E, ∀ i, f i x ≠ 0 ∧ (0 < f i x ↔ i ∈ u)) :
+    A.vcDim ≤ Module.finrank ℝ E := by
+  apply Finset.sup_le
+  intro s hs
+  have h := (shattered_independent f A hA (Finset.mem_shatterer.mp hs)).fintype_card_le_finrank
+  simpa using h
+
+lemma sign_patterns_bound (f : ι → E →ₗ[ℝ] ℝ) (A : Finset (Finset ι))
+    (hA : ∀ u ∈ A, ∃ x : E, ∀ i, f i x ≠ 0 ∧ (0 < f i x ↔ i ∈ u)) :
+    A.card ≤ ∑ k ∈ Finset.Iic (Module.finrank ℝ E), (Fintype.card ι).choose k := by
+  have hv := vcDim_le f A hA
+  exact (Finset.card_le_card_shatterer A).trans
+    (Finset.card_shatterer_le_sum_vcDim.trans
+      (Finset.sum_le_sum_of_subset (Finset.Iic_subset_Iic.mpr hv)))
+
+end UniformSparsestCut.HyperplaneCount
+
+namespace UniformSparsestCut.RoundedCharts
+open MeasureTheory Set Filter
+open scoped Topology BigOperators RealInnerProductSpace
+variable {m N S : ℕ}
+local notation "E" => EuclideanSpace ℝ (Fin m)
+local notation "F" => EuclideanSpace ℝ (Fin N)
+
+def cube (R : ℝ) : Set E := {θ | ∀ j, |θ j| < R}
+
+def regular (u : Fin N → E) (τ : ℝ) (θ : E) : Prop :=
+  ∀ i (k : ℤ), inner ℝ (u i) θ ≠ (k:ℝ)*τ
+
+def integerLabel (u : Fin N → E) (τ : ℝ) (θ : E) (i : Fin N) : ℤ :=
+  ⌊inner ℝ (u i) θ/τ⌋
+
+def rounded (u : Fin N → E) (τ : ℝ) (θ : E) : F :=
+  WithLp.toLp 2 (fun i => τ*(integerLabel u τ θ i : ℝ))
+
+def Vertex (u : Fin S → Fin N → E) (τ : ℝ) :=
+  {p : Fin S × (Fin N → ℤ) // ∃ θ ∈ cube 2, regular (u p.1) τ θ ∧ integerLabel (u p.1) τ θ = p.2}
+
+def coordinate (u : Fin S → Fin N → E) (τ : ℝ) (v : Vertex u τ) : F :=
+  WithLp.toLp 2 (fun i => τ*(v.val.2 i : ℝ))
+
+lemma cube_norm {R : ℝ} (hR : 0 ≤ R) {θ : E} (hθ : θ ∈ cube R) :
+    ‖θ‖ ≤ R*Real.sqrt m := by
+  have hs : ‖θ‖^2 ≤ (m:ℝ)*R^2 := by
+    rw [EuclideanSpace.norm_sq_eq]
+    calc
+      _ ≤ ∑ _j : Fin m, R^2 := by
+        apply Finset.sum_le_sum; intro j _
+        rw [Real.norm_eq_abs]
+        exact pow_le_pow_left₀ (abs_nonneg _) (hθ j).le _
+      _ = _ := by simp
+  have hroot := Real.sq_sqrt (Nat.cast_nonneg m)
+  have hp : 0 ≤ R*Real.sqrt m := mul_nonneg hR (Real.sqrt_nonneg _)
+  have he : (R*Real.sqrt m)^2 = (m:ℝ)*R^2 := by rw [mul_pow,hroot]; ring
+  nlinarith [norm_nonneg θ]
+
+lemma hyperplane_null (u : E) (hu : u ≠ 0) (t : ℝ) :
+    volume {x : E | inner ℝ u x = t} = 0 := by
+  let H : AffineSubspace ℝ E :=
+    { carrier := {x | inner ℝ u x = t}
+      smul_vsub_vadd_mem' := by
+        intro c x y z hx hy hz
+        change inner ℝ u x = t at hx
+        change inner ℝ u y = t at hy
+        change inner ℝ u z = t at hz
+        change inner ℝ u (c • (x-y)+z) = t
+        simp only [inner_add_right, inner_smul_right, inner_sub_right, hx, hy, hz]
+        ring }
+  have ht : H ≠ ⊤ := by
+    intro he
+    have hzero : (0:E) ∈ H := by rw [he]; trivial
+    have hone : u ∈ H := by rw [he]; trivial
+    change inner ℝ u 0 = t at hzero
+    change inner ℝ u u = t at hone
+    rw [inner_zero_right] at hzero
+    have := ((inner_self_eq_zero (𝕜 := ℝ)).mp (hone.trans hzero.symm))
+    exact hu this
+  exact Measure.addHaar_affineSubspace volume H ht
+
+lemma ae_regular (u : Fin N → E) (τ : ℝ) (hu : ∀ i, u i ≠ 0) :
+    ∀ᵐ θ : E, regular u τ θ := by
+  have hi (i : Fin N) (k : ℤ) : ∀ᵐ θ : E, inner ℝ (u i) θ ≠ (k:ℝ)*τ := by
+    rw [ae_iff]
+    simpa only [not_not] using hyperplane_null (u i) (hu i) ((k:ℝ)*τ)
+  have hi' (i : Fin N) : ∀ᵐ θ : E, ∀ k : ℤ, inner ℝ (u i) θ ≠ (k:ℝ)*τ :=
+    ae_all_iff.mpr (hi i)
+  exact ae_all_iff.mpr hi'
+
+lemma rounded_error_coordinate (u : Fin N → E) {τ : ℝ} (hτ : 0 < τ) (θ : E) (i : Fin N) :
+    0 ≤ inner ℝ (u i) θ-rounded u τ θ i ∧ inner ℝ (u i) θ-rounded u τ θ i < τ := by
+  have hlo := Int.floor_le (inner ℝ (u i) θ/τ)
+  have hhi := Int.lt_floor_add_one (inner ℝ (u i) θ/τ)
+  have hl := (le_div_iff₀ hτ).mp hlo
+  have hh := (div_lt_iff₀ hτ).mp hhi
+  change 0 ≤ inner ℝ (u i) θ-τ*(⌊inner ℝ (u i) θ/τ⌋:ℝ) ∧
+    inner ℝ (u i) θ-τ*(⌊inner ℝ (u i) θ/τ⌋:ℝ) < τ
+  constructor <;> nlinarith
+
+lemma rounded_error (u : Fin N → E) {τ : ℝ} (hτ : 0 < τ) (θ : E) :
+    ‖rounded u τ θ - FrameCharts.chart u θ‖ ≤ Real.sqrt N*τ := by
+  have hs : ‖rounded u τ θ - FrameCharts.chart u θ‖^2 ≤ (N:ℝ)*τ^2 := by
+    rw [EuclideanSpace.norm_sq_eq]
+    calc
+      _ ≤ ∑ _i : Fin N, τ^2 := by
+        apply Finset.sum_le_sum; intro i _
+        simp only [PiLp.sub_apply, FrameCharts.chart_apply, Real.norm_eq_abs, sq_abs]
+        have hh := rounded_error_coordinate u hτ θ i
+        nlinarith
+      _ = _ := by simp
+  have hr := Real.sq_sqrt (Nat.cast_nonneg N)
+  have hp : 0 ≤ Real.sqrt N*τ := mul_nonneg (Real.sqrt_nonneg _) hτ.le
+  have he : (Real.sqrt N*τ)^2 = (N:ℝ)*τ^2 := by rw [mul_pow,hr]
+  nlinarith [norm_nonneg (rounded u τ θ-FrameCharts.chart u θ)]
+
+lemma integerLabel_bound (u : Fin N → E) {τ : ℝ} (hτ : 0 < τ) (hu : ∀ i, ‖u i‖ ≤ 2)
+    {θ : E} (hθ : θ ∈ cube 2) (i : Fin N) :
+    |(integerLabel u τ θ i : ℝ)| ≤ 4*Real.sqrt m/τ+1 := by
+  have hn := cube_norm (by norm_num : (0:ℝ) ≤ 2) hθ
+  have hh : |inner ℝ (u i) θ| ≤ 4*Real.sqrt m := by
+    calc
+      _ ≤ ‖u i‖*‖θ‖ := abs_real_inner_le_norm _ _
+      _ ≤ 2*(2*Real.sqrt m) := mul_le_mul (hu i) hn (norm_nonneg θ) (by norm_num)
+      _ = _ := by ring
+  have hf := Int.floor_le (inner ℝ (u i) θ/τ)
+  have hfl := Int.lt_floor_add_one (inner ℝ (u i) θ/τ)
+  have hab : |inner ℝ (u i) θ/τ| ≤ 4*Real.sqrt m/τ := by
+    rw [abs_div, abs_of_pos hτ]
+    exact div_le_div_of_nonneg_right hh hτ.le
+  change |(⌊inner ℝ (u i) θ/τ⌋:ℝ)| ≤ _
+  rw [abs_le] at hab ⊢
+  constructor <;> linarith
+
+lemma vertex_finite (u : Fin S → Fin N → E) {τ : ℝ} (hτ : 0 < τ)
+    (hu : ∀ s i, ‖u s i‖ ≤ 2) : Finite (Vertex u τ) := by
+  let B : ℤ := ⌈4*Real.sqrt m/τ+1⌉
+  let f : Vertex u τ → Fin S × (Fin N → ↥(Finset.Icc (-B) B)) := fun v =>
+    (v.val.1, fun i => ⟨v.val.2 i, by
+      obtain ⟨θ,hθ,hr,hlabel⟩ := v.property
+      have hb := integerLabel_bound (u v.val.1) hτ (hu v.val.1) hθ i
+      have hB := Int.le_ceil (4*Real.sqrt m/τ+1)
+      have hv : |(v.val.2 i:ℝ)| ≤ (B:ℝ) := by rw [← hlabel]; exact hb.trans hB
+      have hlo : -B ≤ v.val.2 i := by exact_mod_cast (abs_le.mp hv).1
+      have hhi : v.val.2 i ≤ B := by exact_mod_cast (abs_le.mp hv).2
+      exact Finset.mem_Icc.mpr ⟨hlo,hhi⟩⟩)
+  apply Finite.of_injective f
+  intro v w h
+  apply Subtype.ext
+  apply Prod.ext
+  · exact congrArg (fun z : Fin S × (Fin N → ↥(Finset.Icc (-B) B)) => z.1) h
+  · funext i
+    exact congrArg (fun z : Fin S × (Fin N → ↥(Finset.Icc (-B) B)) => (z.2 i).val) h
+
+lemma representative (u : Fin S → Fin N → E) (τ : ℝ) (v : Vertex u τ) :
+    ∃ θ ∈ cube 2, regular (u v.val.1) τ θ ∧ coordinate u τ v = rounded (u v.val.1) τ θ := by
+  obtain ⟨θ,hθ,hr,hl⟩ := v.property
+  refine ⟨θ,hθ,hr,?_⟩
+  ext i
+  change τ*(v.val.2 i : ℝ) = τ*(integerLabel (u v.val.1) τ θ i : ℝ)
+  rw [hl]
+
+end UniformSparsestCut.RoundedCharts
+
+namespace UniformSparsestCut.SourceCharts
+open scoped BigOperators RealInnerProductSpace
+noncomputable section
+variable {m : ℕ} (f : PivotFamily.PFamily m) (hm : 0 < m)
+local notation "E" => EuclideanSpace ℝ (Fin m)
+local notation "F" => EuclideanSpace ℝ (Fin (m^6))
+lemma lower_ge_one (hm2 : 2 ≤ m) : 1≤lower m := by
+  have hx : (2:ℝ) ≤ m := by exact_mod_cast hm2
+  have hp := pow_le_pow_right₀ (by linarith : (1:ℝ) ≤ m) (show 2≤6 by norm_num)
+  unfold lower
+  apply (le_div_iff₀ (by positivity : (0:ℝ)<2*m)).mpr
+  nlinarith
+lemma B_norm_le (hm2 : 2 ≤ m) (s : Fin (m^3)) (x : F) : ‖B f hm s x‖≤‖x‖ := by
+  exact (B_norm f hm s x).trans (div_le_self (norm_nonneg _) ((Real.one_le_sqrt).mpr (lower_ge_one hm2)))
+lemma rounded_B_error (hm2 : 2 ≤ m) {τ : ℝ} (hτ : 0<τ) (s : Fin (m^3)) (θ : E) :
+    ‖B f hm s (RoundedCharts.rounded (u f s) τ θ)-θ‖≤Real.sqrt (m^6:ℕ)*τ := by
+  have he : B f hm s (RoundedCharts.rounded (u f s) τ θ)-θ=
+      B f hm s (RoundedCharts.rounded (u f s) τ θ-FrameCharts.chart (u f s) θ) := by
+    rw [map_sub,B_left]
+  rw [he]
+  exact (B_norm_le f hm hm2 s _).trans (RoundedCharts.rounded_error _ hτ θ)
+lemma rounded_residual_error {τ : ℝ} (hτ : 0<τ) (s : Fin (m^3)) (θ : E) :
+    ‖RoundedCharts.rounded (u f s) τ θ-FrameCharts.chart (u f s) (B f hm s (RoundedCharts.rounded (u f s) τ θ))‖≤
+      Real.sqrt (m^6:ℕ)*τ := by
+  let x := RoundedCharts.rounded (u f s) τ θ
+  have he : x-FrameCharts.chart (u f s) (B f hm s x)=
+      (x-FrameCharts.chart (u f s) θ)-FrameCharts.chart (u f s) (B f hm s (x-FrameCharts.chart (u f s) θ)) := by
+    rw [map_sub,B_left,map_sub]
+    abel
+  change ‖x-FrameCharts.chart (u f s) (B f hm s x)‖≤_
+  rw [he]
+  exact (residual_norm f hm s _).trans (RoundedCharts.rounded_error _ hτ θ)
+lemma vertex_B_bound (hm2 : 2 ≤ m) {τ : ℝ} (hτ : 0<τ) (v : RoundedCharts.Vertex (u f) τ) :
+    ‖B f hm v.val.1 (RoundedCharts.coordinate (u f) τ v)‖≤2*Real.sqrt m+Real.sqrt (m^6:ℕ)*τ := by
+  obtain ⟨θ,hθ,hr,hx⟩ := RoundedCharts.representative (u f) τ v
+  rw [hx]
+  have h := rounded_B_error f hm hm2 hτ v.val.1 θ
+  have ht := RoundedCharts.cube_norm (by norm_num : (0:ℝ)≤2) hθ
+  exact (norm_le_norm_sub_add _ θ).trans (by linarith)
+lemma vertex_residual_bound {τ : ℝ} (hτ : 0<τ) (v : RoundedCharts.Vertex (u f) τ) :
+    ‖RoundedCharts.coordinate (u f) τ v-FrameCharts.chart (u f v.val.1) (B f hm v.val.1 (RoundedCharts.coordinate (u f) τ v))‖≤
+      Real.sqrt (m^6:ℕ)*τ := by
+  obtain ⟨θ,hθ,hr,hx⟩ := RoundedCharts.representative (u f) τ v
+  rw [hx]
+  exact rounded_residual_error f hm hτ v.val.1 θ
+end
+end UniformSparsestCut.SourceCharts
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/Semimetrics.lean

@@ -0,0 +1,193 @@
+import OAI.Combinatorics.SparsestCut.CutSums
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut
+
+section SemimetricBounds
+
+variable {n : ℕ}
+
+def IsSemimetric (d : Fin n → Fin n → ℝ) : Prop :=
+  (∀ i j, 0 ≤ d i j) ∧ (∀ i j, d i j = d j i) ∧
+    (∀ i, d i i = 0) ∧ (∀ i j k, d i k ≤ d i j + d j k)
+
+lemma NegativeType.semimetric {d : Fin n → Fin n → ℝ} (hd : NegativeType d) :
+    IsSemimetric d := by
+  obtain ⟨x,hx⟩ := hd.1
+  refine ⟨fun i j => by rw [hx]; positivity, ?_, ?_, hd.2⟩
+  · intro i j; rw [hx, hx, norm_sub_rev]
+  · intro i; simp [hx]
+
+lemma NegativeType.scale {d : Fin n → Fin n → ℝ} (hd : NegativeType d)
+    {a : ℝ} (ha : 0 ≤ a) : NegativeType (fun i j => a * d i j) := by
+  obtain ⟨x,hx⟩ := hd.1
+  refine ⟨⟨fun i => Real.sqrt a • x i, ?_⟩, ?_⟩
+  · intro i j
+    change a * d i j = _
+    rw [← smul_sub, norm_smul, mul_pow, Real.norm_eq_abs,
+      abs_of_nonneg (Real.sqrt_nonneg a), Real.sq_sqrt ha, hx]
+  · intro i j k
+    simpa [mul_add] using mul_le_mul_of_nonneg_left (hd.2 i j k) ha
+
+lemma cutDist_negativeType (B : Finset (Fin n)) (hn : 0 < n) : NegativeType (cutDist B) := by
+  classical
+  let i0 : Fin n := ⟨0,hn⟩
+  refine ⟨⟨fun i => EuclideanSpace.single i0 (cutIndicator B i), ?_⟩,
+    cutDist_triangle B⟩
+  intro i j
+  change cutDist B i j = ‖PiLp.single (β := fun _ : Fin n => ℝ) 2 i0 (cutIndicator B i) -
+    PiLp.single (β := fun _ : Fin n => ℝ) 2 i0 (cutIndicator B j)‖ ^ 2
+  rw [← PiLp.single_sub]
+  change cutDist B i j = ‖EuclideanSpace.single i0
+    (cutIndicator B i - cutIndicator B j)‖ ^ 2
+  rw [PiLp.norm_single, Real.norm_eq_abs]
+  change cutDist B i j = cutDist B i j ^ 2
+  rcases cutDist_binary B i j with h | h <;> rw [h] <;> norm_num
+
+lemma cut_nonempty (hn : 2 ≤ n) : Nonempty (Cut n) := by
+  classical
+  let i : Fin n := ⟨0,by omega⟩
+  refine ⟨⟨{i}, Finset.singleton_nonempty i, ?_⟩⟩
+  intro he
+  have hh := congrArg Finset.card he
+  simp only [Finset.card_singleton, Finset.card_univ, Fintype.card_fin] at hh
+  omega
+
+lemma feasible_nonempty (hn : 2 ≤ n) : ∃ d : Fin n → Fin n → ℝ, Feasible d := by
+  classical
+  obtain ⟨B⟩ := cut_nonempty hn
+  refine ⟨fun i j => (cutDemand B.1)⁻¹ * cutDist B.1 i j, ?_, ?_⟩
+  · exact (cutDist_negativeType B.1 (by omega)).scale (inv_nonneg.mpr (cutDemand_pos B).le)
+  · rw [pairSum_smul, pairSum_cut, inv_mul_cancel₀ (cutDemand_pos B).ne']
+
+lemma normalized_pair_le_one {d : Fin n → Fin n → ℝ} (hd : IsSemimetric d)
+    (hD : pairSum d = 1) (i j : Fin n) : d i j ≤ 1 := by
+  rcases lt_trichotomy i j with h | h | h
+  · simpa [hD] using le_pairSum hd.1 h
+  · subst j; rw [hd.2.2.1]; norm_num
+  · rw [hd.2.1 i j]; simpa [hD] using le_pairSum hd.1 h
+
+lemma continuous_pairSum : Continuous (pairSum (n := n)) := by
+  unfold pairSum
+  apply continuous_finsetSum
+  intro i hi
+  apply continuous_finsetSum
+  intro j hj
+  split_ifs
+  · exact (continuous_apply j).comp (continuous_apply i)
+  · exact continuous_const
+
+lemma semimetric_closed : IsClosed {d : Fin n → Fin n → ℝ | IsSemimetric d} := by
+  unfold IsSemimetric
+  simp only [ofPred_and, ofPred_forall]
+  refine IsClosed.inter ?_ (IsClosed.inter ?_ (IsClosed.inter ?_ ?_))
+  · apply isClosed_iInter; intro i; apply isClosed_iInter; intro j
+    exact isClosed_le continuous_const ((continuous_apply j).comp (continuous_apply i))
+  · apply isClosed_iInter; intro i; apply isClosed_iInter; intro j
+    exact isClosed_eq ((continuous_apply j).comp (continuous_apply i))
+      ((continuous_apply i).comp (continuous_apply j))
+  · apply isClosed_iInter; intro i
+    exact isClosed_eq ((continuous_apply i).comp (continuous_apply i)) continuous_const
+  · apply isClosed_iInter; intro i; apply isClosed_iInter; intro j
+    apply isClosed_iInter; intro k
+    exact isClosed_le (by fun_prop) (by fun_prop)
+
+lemma normalized_semimetric_compact :
+    IsCompact {d : Fin n → Fin n → ℝ | IsSemimetric d ∧ pairSum d = 1} := by
+  have hclosed : IsClosed {d : Fin n → Fin n → ℝ | IsSemimetric d ∧ pairSum d = 1} :=
+    semimetric_closed.inter (isClosed_eq continuous_pairSum continuous_const)
+  apply (isCompact_Icc : IsCompact (Icc (0 : Fin n → Fin n → ℝ) (fun _ _ => 1))).of_isClosed_subset hclosed
+  intro d hd
+  exact ⟨hd.1.1, normalized_pair_le_one hd.1 hd.2⟩
+
+lemma objective_nonneg (C : Capacity n) {d : Fin n → Fin n → ℝ} (hd : IsSemimetric d) :
+    0 ≤ pairSum (fun i j => C.cap i j * d i j) :=
+  pairSum_nonneg (fun i j => mul_nonneg (C.nonneg i j) (hd.1 i j))
+
+lemma objective_pos_of_cuts (C : Capacity n)
+    (hC : ∀ B : Cut n, cutDemand B.1 ≤ ∑ i ∈ B.1, ∑ j ∈ B.1ᶜ, C.cap i j)
+    {d : Fin n → Fin n → ℝ} (hd : IsSemimetric d) (hD : pairSum d = 1) :
+    0 < pairSum (fun i j => C.cap i j * d i j) := by
+  classical
+  have hnonneg := objective_nonneg C hd
+  by_contra! hnot
+  have hzero := le_antisymm hnot hnonneg
+  have hp (i j : Fin n) : C.cap i j * d i j = 0 := by
+    have h0 : 0 ≤ C.cap i j * d i j := mul_nonneg (C.nonneg i j) (hd.1 i j)
+    rcases lt_trichotomy i j with h | h | h
+    · have hh := le_pairSum (fun i j => mul_nonneg (C.nonneg i j) (hd.1 i j)) h
+      rw [hzero] at hh
+      exact le_antisymm hh h0
+    · subst j; simp [C.diagonal]
+    · rw [C.symm i j, hd.2.1 i j]
+      have hh := le_pairSum (fun i j => mul_nonneg (C.nonneg i j) (hd.1 i j)) h
+      rw [hzero] at hh
+      exact le_antisymm hh (mul_nonneg (C.nonneg _ _) (hd.1 _ _))
+  have hd0 : ∀ i j, d i j = 0 := by
+    intro i j
+    let B : Finset (Fin n) := Finset.univ.filter (fun k => d i k = 0)
+    have hi : i ∈ B := by simp [B, hd.2.2.1]
+    have hBall : B = Finset.univ := by
+      by_contra hne
+      let B' : Cut n := ⟨B, ⟨i,hi⟩, hne⟩
+      have hjump (u : Fin n) (hu : u ∈ B) (v : Fin n) (hv : v ∈ Bᶜ) : C.cap u v = 0 := by
+        have hu0 : d i u = 0 := (Finset.mem_filter.mp hu).2
+        have hv0 : d i v ≠ 0 := by simpa [B] using hv
+        have hduv : d u v ≠ 0 := by
+          intro huv
+          have ht := hd.2.2.2 i u v
+          rw [hu0,huv] at ht
+          exact hv0 (le_antisymm (by simpa using ht) (hd.1 i v))
+        exact (mul_eq_zero.mp (hp u v)).resolve_right hduv
+      have hsum : (∑ u ∈ B, ∑ v ∈ Bᶜ, C.cap u v) = 0 := by
+        apply Finset.sum_eq_zero
+        intro u hu
+        exact Finset.sum_eq_zero (fun v hv => hjump u hu v hv)
+      have hh := hC B'
+      change cutDemand B ≤ _ at hh
+      rw [hsum] at hh
+      exact (cutDemand_pos B').not_ge hh
+    have hj : j ∈ B := by rw [hBall]; exact Finset.mem_univ j
+    exact (Finset.mem_filter.mp hj).2
+  simp [pairSum,hd0] at hD
+
+lemma glValue_pos_of_cuts (C : Capacity n) (hn : 2 ≤ n)
+    (hC : ∀ B : Cut n, cutDemand B.1 ≤ ∑ i ∈ B.1, ∑ j ∈ B.1ᶜ, C.cap i j) :
+    0 < glValue C := by
+  obtain ⟨d0,hd0⟩ := feasible_nonempty hn
+  have hobj : Continuous (fun d : Fin n → Fin n → ℝ => pairSum (fun i j => C.cap i j * d i j)) := by
+    apply continuous_pairSum.comp
+    apply continuous_pi; intro i; apply continuous_pi; intro j
+    exact continuous_const.mul ((continuous_apply j).comp (continuous_apply i))
+  obtain ⟨d,hd,hmin⟩ := normalized_semimetric_compact.exists_isMinOn
+    ⟨d0,hd0.1.semimetric,hd0.2⟩ hobj.continuousOn
+  apply (objective_pos_of_cuts C hC hd.1 hd.2).trans_le
+  apply le_csInf
+  · exact ⟨_,d0,hd0,rfl⟩
+  · rintro b ⟨d',hd',rfl⟩
+    exact hmin ⟨hd'.1.semimetric,hd'.2⟩
+
+lemma OPT_ge_one_of_cuts (C : Capacity n) (hn : 2 ≤ n)
+    (hC : ∀ B : Cut n, cutDemand B.1 ≤ ∑ i ∈ B.1, ∑ j ∈ B.1ᶜ, C.cap i j) :
+    1 ≤ OPT C := by
+  obtain ⟨B0⟩ := cut_nonempty hn
+  apply le_csInf
+  · exact ⟨_,B0.1,B0.2.1,B0.2.2,rfl⟩
+  · rintro b ⟨B,hB,hB',rfl⟩
+    unfold cutRatio
+    rw [← cutDemand_eq]
+    exact (one_le_div (cutDemand_pos ⟨B,hB,hB'⟩)).mpr (hC ⟨B,hB,hB'⟩)
+
+end SemimetricBounds
+
+end UniformSparsestCut
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/SliceCoefficients.lean

@@ -0,0 +1,137 @@
+import OAI.Combinatorics.SparsestCut.InterfaceStep
+
+namespace OAI
+
+universe u1 u2 u3 u4 u5
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.SliceCoefficients
+open MeasureTheory Set
+open scoped BigOperators Topology
+variable {X : Type u1} {Z : Type u2} {I : Type u3} {K : Type u4} {A : Type u5} [NormedAddCommGroup X] [NormedSpace ℝ X]
+  [NormedAddCommGroup Z] [NormedSpace ℝ Z] [FiniteDimensional ℝ Z]
+  [MeasurableSpace Z] [BorelSpace Z] [Fintype I] [Fintype K] [Fintype A]
+  [DecidableEq I] [DecidableEq K]
+
+lemma affine_hyperplane_null (L : Z →L[ℝ] ℝ) (hL : L ≠ 0) (t : ℝ)
+    (ν : Measure Z) [ν.IsAddHaarMeasure] : ν {z | L z=t}=0 := by
+  let H : AffineSubspace ℝ Z :=
+    { carrier := {z | L z=t}
+      smul_vsub_vadd_mem' := by
+        intro c x y z hx hy hz
+        change L x=t at hx
+        change L y=t at hy
+        change L z=t at hz
+        change L (c • (x-y)+z)=t
+        simp only [map_add,map_smul,map_sub,smul_eq_mul,hx,hy,hz]
+        ring }
+  have ht : H ≠ ⊤ := by
+    intro he
+    have hzero : (0:Z) ∈ H := by rw [he]; trivial
+    change L 0=t at hzero
+    rw [map_zero] at hzero
+    apply hL
+    ext x
+    have hx : x ∈ H := by rw [he]; trivial
+    change L x=t at hx
+    simpa [← hzero] using hx
+  exact Measure.addHaar_affineSubspace ν H ht
+
+lemma thresholds_injective_ae (L : I → X →L[ℝ] ℝ) (B : I → Z →L[ℝ] ℝ)
+    (q : I → K → ℝ) (hq : ∀ i, Function.Injective (q i))
+    (hB : Function.Injective B) (ν : Measure Z) [ν.IsAddHaarMeasure]
+    (μ : Measure Z) (hμ : μ ≪ ν) (y : X) :
+    ∀ᵐ z ∂μ, Function.Injective (fun p : I × K => L p.1 y+B p.1 z+q p.1 p.2) := by
+  have hp (p r : I × K) (hpr : p ≠ r) :
+      ∀ᵐ z ∂μ, L p.1 y+B p.1 z+q p.1 p.2 ≠ L r.1 y+B r.1 z+q r.1 r.2 := by
+    by_cases hi : p.1=r.1
+    · filter_upwards with z hz
+      have hk : p.2=r.2 := hq p.1 (by rw [← hi] at hz; linarith)
+      exact hpr (Prod.ext hi hk)
+    · have hn : B p.1-B r.1 ≠ 0 := sub_ne_zero.mpr (fun he => hi (hB he))
+      have hnul := affine_hyperplane_null (B p.1-B r.1) hn
+        (L r.1 y+q r.1 r.2-(L p.1 y+q p.1 p.2)) ν
+      have hae : ∀ᵐ z ∂ν, (B p.1-B r.1) z ≠ L r.1 y+q r.1 r.2-(L p.1 y+q p.1 p.2) := by
+        rw [ae_iff]; simpa only [not_not] using hnul
+      filter_upwards [hμ.ae_le hae] with z hz he
+      apply hz
+      simp only [_root_.sub_apply]
+      linarith
+  have ha (p r : I × K) : ∀ᵐ z ∂μ,
+      L p.1 y+B p.1 z+q p.1 p.2 = L r.1 y+B r.1 z+q r.1 r.2 → p=r := by
+    by_cases hpr : p=r
+    · exact ae_of_all _ (fun _ _ => hpr)
+    · filter_upwards [hp p r hpr] with z hz he using (hz he).elim
+  exact ae_all_iff.mpr (fun p => ae_all_iff.mpr (ha p))
+
+omit [NormedAddCommGroup Z] [NormedSpace ℝ Z] [FiniteDimensional ℝ Z] [BorelSpace Z] in
+
+lemma family_derivative (L : I → X →L[ℝ] ℝ) (b : I × K → Z → ℝ)
+    (hb : ∀ p, Measurable (b p)) (F : Finset (I × K) → ℝ)
+    {φ : ℝ → ℝ} (hφ : Integrable φ) (hc : Continuous φ)
+    {M C : ℝ} (hM0 : 0 ≤ M) (hC : 0 ≤ C)
+    (hM : ∀ a, |F a| ≤ M) (hφC : ∀ x, |φ x| ≤ C)
+    (μ : Measure Z) [IsFiniteMeasure μ] (y : X)
+    (hi : ∀ᵐ z ∂μ, Function.Injective (fun p : I × K => L p.1 y+b p z)) :
+    HasFDerivAt (fun y => ∫ z, (∫ x, φ x*F (Finset.univ.filter (fun p => L p.1 y+b p z<x))) ∂μ)
+      (∑ i, (∑ k, ∫ z, -(φ (L i y+b (i,k) z)*
+        (F (Finset.univ.filter (fun p => L p.1 y+b p z ≤ L i y+b (i,k) z))-
+          F (Finset.univ.filter (fun p => L p.1 y+b p z < L i y+b (i,k) z)))) ∂μ) • L i) y := by
+  have hd := InterfaceStep.averaged_threshold_derivative Finset.univ (fun p : I × K => L p.1)
+    b hb F hφ hc hM0 hC hM hφC μ y (hi.mono (fun z hz => hz.injOn))
+  rw [Fintype.sum_prod_type] at hd
+  simp only [← Finset.sum_smul] at hd
+  exact hd
+
+omit [NormedAddCommGroup Z] [NormedSpace ℝ Z] [FiniteDimensional ℝ Z] [BorelSpace Z] [DecidableEq K] in
+
+lemma coefficient_budget (μ : Measure Z) [IsProbabilityMeasure μ]
+    (w : K → Z → ℝ) (Δ : K → Z → A → ℝ) {J B : ℝ}
+    (hJ : 0 ≤ J) (hw : ∀ k z, 0 ≤ w k z)
+    (_hiw : ∀ k, Integrable (w k) μ)
+    (hid : ∀ k a, Integrable (fun z => w k z*Δ k z a) μ)
+    (hj : ∀ᵐ z ∂μ, ∀ k, w k z ≠ 0 → ∑ a, |Δ k z a| ≤ J)
+    (hs : ∀ᵐ z ∂μ, ∑ k, w k z ≤ B) :
+    (∑ a, |∑ k, ∫ z, -(w k z*Δ k z a) ∂μ|) ≤ J*B := by
+  have hle (a : A) : |∑ k, ∫ z, -(w k z*Δ k z a) ∂μ| ≤
+      ∑ k, ∫ z, w k z*|Δ k z a| ∂μ := by
+    calc
+      _ ≤ ∑ k, |∫ z, -(w k z*Δ k z a) ∂μ| := Finset.abs_sum_le_sum_abs _ _
+      _ ≤ _ := Finset.sum_le_sum (fun k _ => by
+        simpa only [Real.norm_eq_abs,abs_neg,abs_mul,abs_of_nonneg (hw k _)] using
+          norm_integral_le_integral_norm (fun z => -(w k z*Δ k z a)))
+  have hia (k : K) (a : A) : Integrable (fun z => w k z*|Δ k z a|) μ := by
+    simpa only [abs_mul,abs_of_nonneg (hw k _)] using (hid k a).abs
+  have hisum : Integrable (fun z => ∑ k, w k z*(∑ a, |Δ k z a|)) μ := by
+    simp_rw [Finset.mul_sum]
+    exact integrable_finsetSum _ (fun k _ => integrable_finsetSum _ (fun a _ => hia k a))
+  calc
+    _ ≤ ∑ a, ∑ k, ∫ z, w k z*|Δ k z a| ∂μ := Finset.sum_le_sum (fun a _ => hle a)
+    _ = ∫ z, ∑ k, w k z*(∑ a, |Δ k z a|) ∂μ := by
+      rw [Finset.sum_comm]
+      simp_rw [Finset.mul_sum]
+      rw [integral_finsetSum _ (fun k _ => integrable_finsetSum _ (fun a _ => hia k a))]
+      apply Finset.sum_congr rfl
+      intro k _
+      exact (integral_finsetSum _ (fun a _ => hia k a)).symm
+    _ ≤ ∫ z, J*B ∂μ := by
+      apply integral_mono_ae hisum (integrable_const _)
+      filter_upwards [hj,hs] with z hz hzB
+      calc
+        _ ≤ ∑ k, w k z*J := Finset.sum_le_sum (fun k _ => by
+          by_cases hk : w k z=0
+          · simp [hk]
+          · exact mul_le_mul_of_nonneg_left (hz k hk) (hw k z))
+        _ = J*∑ k, w k z := by rw [← Finset.sum_mul]; ring
+        _ ≤ J*B := mul_le_mul_of_nonneg_left hzB hJ
+    _ = J*B := by simp
+
+end UniformSparsestCut.SliceCoefficients
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/SliceIntegration.lean

@@ -0,0 +1,98 @@
+import OAI.Combinatorics.SparsestCut.LatticeDensity
+
+namespace OAI
+
+universe u1 u2 u3 u4
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.ProductSlice
+open MeasureTheory Set
+open scoped BigOperators
+noncomputable section
+variable {Z : Type u1} {I : Type u2} {K : Type u3} {A : Type u4} [NormedAddCommGroup Z] [NormedSpace ℝ Z]
+  [FiniteDimensional ℝ Z] [MeasureSpace Z] [BorelSpace Z] [(volume : Measure Z).IsAddHaarMeasure]
+  [Fintype I] [Fintype K] [Fintype A] [DecidableEq I] [DecidableEq K]
+
+def jump (B : I → Z →L[ℝ] ℝ) (q : I → K → ℝ) (F : Finset (I × K) → A → ℝ)
+    (θ : ℝ × Z) (i : I) (k : K) (z : Z) (α : A) : ℝ :=
+  F (Finset.univ.filter (fun p => form (B p.1) θ+B p.1 z+q p.1 p.2 ≤ form (B i) θ+B i z+q i k)) α-
+  F (Finset.univ.filter (fun p => form (B p.1) θ+B p.1 z+q p.1 p.2 < form (B i) θ+B i z+q i k)) α
+omit [FiniteDimensional ℝ Z] [(volume : Measure Z).IsAddHaarMeasure] [Fintype A] in
+lemma jump_measurable (B : I → Z →L[ℝ] ℝ) (q : I → K → ℝ) (F : Finset (I × K) → A → ℝ)
+    (θ : ℝ × Z) (i : I) (k : K) (α : A) : Measurable (fun z => jump B q F θ i k z α) := by
+  unfold jump
+  apply Measurable.sub
+  · apply InterfaceStep.measurable_filter_apply Finset.univ _ _ (fun a => F a α)
+    intro p
+    exact measurableSet_le ((measurable_const.add (B p.1).measurable).add_const _)
+      ((measurable_const.add (B i).measurable).add_const _)
+  · apply InterfaceStep.measurable_filter_apply Finset.univ _ _ (fun a => F a α)
+    intro p
+    exact measurableSet_lt ((measurable_const.add (B p.1).measurable).add_const _)
+      ((measurable_const.add (B i).measurable).add_const _)
+
+omit [FiniteDimensional ℝ Z] [MeasureSpace Z] [BorelSpace Z] [(volume : Measure Z).IsAddHaarMeasure] [Fintype A] [DecidableEq I] [DecidableEq K] in
+lemma jump_bound (B : I → Z →L[ℝ] ℝ) (q : I → K → ℝ) (F : Finset (I × K) → A → ℝ)
+    {M : ℝ} (hM : ∀ a α, |F a α|≤M) (θ : ℝ × Z) (i : I) (k : K) (z : Z) (α : A) :
+    |jump B q F θ i k z α|≤2*M := by
+  unfold jump
+  exact (abs_sub _ _).trans (add_le_add (hM _ α) (hM _ α) |>.trans (by ring_nf; rfl))
+
+omit [FiniteDimensional ℝ Z] [(volume : Measure Z).IsAddHaarMeasure] in
+
+lemma common_coefficient_budget (B : I → Z →L[ℝ] ℝ) (s : Finset ℤ)
+    (pivot : I → ℝ) (hp : ∀ i, pivot i≠0) {τ : ℝ} (hτ : 0<τ)
+    (F : Finset (I × s) → A → ℝ) {M C J : ℝ}
+    (_hM0 : 0≤M) (hC : 0≤C) (hJ : 0≤J) (hM : ∀ a α, |F a α|≤M)
+    {φ φ' : ℝ → ℝ} (hd : ∀ t, HasDerivAt φ (φ' t) t) (hn : ∀ t, 0≤φ t)
+    (hi : Integrable φ) (hi' : Integrable φ') (h1 : ∫ t, φ t=1) (hφC : ∀ t, |φ t|≤C)
+    {ψ : Z → ℝ} (hmψ : Measurable ψ) (hnψ : ∀ z, 0≤ψ z) (hiψ : Integrable ψ) (hψ1 : ∫ z, ψ z=1)
+    (θ : ℝ × Z) (i : I)
+    (hj : ∀ᵐ z ∂law ψ volume, ∀ k : s,
+      φ (form (B i) θ+B i z-(k:ℤ)*τ/pivot i)≠0 →
+        (∑ α, |jump B (fun i (k : s) => -((k:ℤ)*τ/pivot i)) F θ i k z α|)≤J)
+    (hsmall : τ/|pivot i| *(∫ t, |φ' t|)≤1) :
+    (∑ α, |(pivot i)⁻¹ * ∑ k : s, ∫ z,
+      -(φ (form (B i) θ+B i z-(k:ℤ)*τ/pivot i)*
+        jump B (fun i (k : s) => -((k:ℤ)*τ/pivot i)) F θ i k z α) ∂law ψ volume|) ≤ 2*J/τ := by
+  let μ := law ψ volume
+  let q : I → s → ℝ := fun i (k : s) => -((k:ℤ)*τ/pivot i)
+  let w : s → Z → ℝ := fun k z => φ (form (B i) θ+B i z-(k:ℤ)*τ/pivot i)
+  have : IsProbabilityMeasure μ := law_probability hmψ hnψ volume hiψ hψ1
+  have hcφ : Continuous φ := continuous_iff_continuousAt.mpr (fun t => (hd t).continuousAt)
+  have hw (k : s) : Measurable (w k) :=
+    hcφ.measurable.comp ((measurable_const.add (B i).measurable).sub_const _)
+  have hiw (k : s) : Integrable (w k) μ :=
+    (integrable_const C).mono' (hw k).aestronglyMeasurable (ae_of_all _ (fun z => hφC _))
+  have hid (k : s) (α : A) : Integrable (fun z => w k z*jump B q F θ i k z α) μ := by
+    apply (integrable_const (C*(2*M))).mono' ((hw k).mul (jump_measurable B q F θ i k α)).aestronglyMeasurable
+    filter_upwards with z
+    simp only [Pi.mul_apply, Real.norm_eq_abs,abs_mul]
+    exact mul_le_mul (hφC _) (jump_bound B q F hM θ i k z α) (abs_nonneg _) hC
+  have hs (z : Z) : (∑ k : s, w k z)≤2*|pivot i|/τ := by
+    have h := LatticeDensity.affine_lattice_bound hd hn hi hi' h1 hτ (hp i) (form (B i) θ+B i z) s
+    rw [← Finset.sum_coe_sort] at h
+    have hp0 : 0 < |pivot i| := abs_pos.mpr (hp i)
+    have hmul : τ/|pivot i| *(∑ k : s, w k z)≤2 := by exact h.trans (by linarith)
+    apply (le_div_iff₀ hτ).mpr
+    have hh := mul_le_mul_of_nonneg_right hmul hp0.le
+    have he : (τ/|pivot i| *(∑ k : s, w k z))*|pivot i| = (∑ k : s, w k z)*τ := by
+      field_simp
+    rwa [he] at hh
+  have hb := SliceCoefficients.coefficient_budget μ w (jump B q F θ i) hJ
+    (fun k z => hn _) hiw hid hj (ae_of_all _ hs)
+  simp_rw [abs_mul,abs_inv,← Finset.mul_sum]
+  calc
+    _ ≤ |pivot i|⁻¹*(J*(2*|pivot i|/τ)) := mul_le_mul_of_nonneg_left hb (inv_nonneg.mpr (abs_nonneg _))
+    _ = _ := by field_simp [abs_ne_zero.mpr (hp i)]
+
+end
+end UniformSparsestCut.ProductSlice
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/Smoothing.lean

@@ -0,0 +1,128 @@
+import OAI.Combinatorics.SparsestCut.CellInterface
+
+namespace OAI
+
+universe u1 u2 u3
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.ProductSlice
+open MeasureTheory Set CellInterface
+open scoped BigOperators
+noncomputable section
+variable {Z : Type u1} {I : Type u2} {A : Type u3} [NormedAddCommGroup Z] [NormedSpace ℝ Z]
+  [FiniteDimensional ℝ Z] [MeasureSpace Z] [BorelSpace Z] [(volume : Measure Z).IsAddHaarMeasure]
+  [Fintype I] [Fintype A] [DecidableEq I]
+
+def ell (B : I → Z →L[ℝ] ℝ) (pivot : I → ℝ) (i : I) : (ℝ × Z) →L[ℝ] ℝ :=
+  pivot i • form (B i)
+omit [FiniteDimensional ℝ Z] [MeasureSpace Z] [BorelSpace Z] [(volume : Measure Z).IsAddHaarMeasure] [Fintype I] [DecidableEq I] in
+@[simp] lemma ell_apply (B : I → Z →L[ℝ] ℝ) (pivot : I → ℝ) (i : I) (x : ℝ × Z) :
+    ell B pivot i x=pivot i*(x.1-B i x.2) := rfl
+
+omit [FiniteDimensional ℝ Z] [MeasureSpace Z] [BorelSpace Z] [(volume : Measure Z).IsAddHaarMeasure] [Fintype I] [DecidableEq I] in
+lemma normalized_ell (B : I → Z →L[ℝ] ℝ) (pivot : I → ℝ) (hp : ∀ i, pivot i≠0)
+    (τ : ℝ) (i : I) (k : ℤ) (x : ℝ × Z) :
+    (ell B pivot i x-(k:ℝ)*τ)/pivot i=form (B i) x-(k:ℝ)*τ/pivot i := by
+  simp only [ell,_root_.smul_apply,smul_eq_mul,sub_div,mul_div_cancel_left₀ _ (hp i)]
+
+omit [Fintype A] [FiniteDimensional ℝ Z] [MeasureSpace Z] [BorelSpace Z] [(volume : Measure Z).IsAddHaarMeasure] [DecidableEq I] in
+lemma cell_eq_extension (B : I → Z →L[ℝ] ℝ) (pivot : I → ℝ) (hp : ∀ i, pivot i≠0)
+    (τ : ℝ) (s : Finset ℤ) (U : Set (ℝ × Z)) (F : LabelVertex (ell B pivot) τ U → A → ℝ)
+    (x : ℝ × Z) (α : A) :
+    cell B (fun i (k : s) => -((k:ℤ)*τ/pivot i))
+      (fun P => extension (ell B pivot) pivot τ s U F P α) x =
+    extension (ell B pivot) pivot τ s U F (pattern (ell B pivot) pivot τ s x) α := by
+  unfold cell pattern
+  simp_rw [normalized_ell B pivot hp]
+  simp only [sub_eq_add_neg]
+
+def eventPoint (B : I → Z →L[ℝ] ℝ) (pivot : I → ℝ) (τ : ℝ)
+    (θ : ℝ × Z) (i : I) (k : ℤ) (z : Z) : ℝ × Z :=
+  θ-(form (B i) θ+B i z-(k:ℝ)*τ/pivot i,z)
+
+omit [FiniteDimensional ℝ Z] [MeasureSpace Z] [BorelSpace Z] [(volume : Measure Z).IsAddHaarMeasure] [Fintype I] [DecidableEq I] in
+lemma event_form (B : I → Z →L[ℝ] ℝ) (pivot : I → ℝ) (τ : ℝ)
+    (θ : ℝ × Z) (i : I) (k : ℤ) (z : Z) (j : I) :
+    form (B j) (eventPoint B pivot τ θ i k z) =
+      form (B j) θ+B j z-(form (B i) θ+B i z-(k:ℝ)*τ/pivot i) := by
+  simp only [eventPoint,form_apply,map_sub]
+  ring
+omit [FiniteDimensional ℝ Z] [MeasureSpace Z] [BorelSpace Z] [(volume : Measure Z).IsAddHaarMeasure] [Fintype I] [DecidableEq I] in
+lemma event_on_plane (B : I → Z →L[ℝ] ℝ) (pivot : I → ℝ) (hp : ∀ i, pivot i≠0)
+    (τ : ℝ) (θ : ℝ × Z) (i : I) (k : ℤ) (z : Z) :
+    ell B pivot i (eventPoint B pivot τ θ i k z)=(k:ℝ)*τ := by
+  change pivot i*form (B i) _=_
+  rw [event_form]
+  field_simp [hp i]
+  ring
+
+lemma event_other_regular (B : I → Z →L[ℝ] ℝ) (hB : Function.Injective B)
+    (pivot : I → ℝ) (hp : ∀ i, pivot i≠0) (τ : ℝ) (θ : ℝ × Z) (i : I) (k : ℤ)
+    (μ : Measure Z) (hμ : μ ≪ volume) :
+    ∀ᵐ z ∂μ, ∀ j, j≠i → ∀ l : ℤ, ell B pivot j (eventPoint B pivot τ θ i k z)≠(l:ℝ)*τ := by
+  apply ae_all_iff.mpr
+  intro j
+  by_cases hj : j=i
+  · simp [hj]
+  have hpair (l : ℤ) : ∀ᵐ z ∂μ, ell B pivot j (eventPoint B pivot τ θ i k z)≠(l:ℝ)*τ := by
+    have hn : B j-B i≠0 := sub_ne_zero.mpr (fun he => hj (hB he))
+    let t := (l:ℝ)*τ/pivot j-(k:ℝ)*τ/pivot i-form (B j) θ+form (B i) θ
+    have hnul := SliceCoefficients.affine_hyperplane_null (B j-B i) hn t volume
+    have hae : ∀ᵐ z ∂volume, (B j-B i) z≠t := by rw [ae_iff]; simpa only [not_not] using hnul
+    filter_upwards [hμ.ae_le hae] with z hz he
+    apply hz
+    change pivot j*form (B j) _=_ at he
+    rw [event_form] at he
+    have he' : form (B j) θ+B j z-(form (B i) θ+B i z-(k:ℝ)*τ/pivot i)=(l:ℝ)*τ/pivot j :=
+      (eq_div_iff (hp j)).mpr (by nlinarith [he])
+    simp only [_root_.sub_apply]
+    dsimp only [t]
+    linarith
+  filter_upwards [ae_all_iff.mpr hpair] with z hz _ using hz
+
+omit [Fintype A] [FiniteDimensional ℝ Z] [MeasureSpace Z] [BorelSpace Z] [(volume : Measure Z).IsAddHaarMeasure] [DecidableEq I] in
+lemma jump_eq_traces (B : I → Z →L[ℝ] ℝ) (pivot : I → ℝ) (hp : ∀ i, pivot i≠0)
+    (τ : ℝ) (s : Finset ℤ) (U : Set (ℝ × Z)) (F : LabelVertex (ell B pivot) τ U → A → ℝ)
+    (θ : ℝ × Z) (i : I) (k : s) (z : Z) (α : A) :
+    jump B (fun i (k : s) => -((k:ℤ)*τ/pivot i))
+      (extension (ell B pivot) pivot τ s U F) θ i k z α =
+    extension (ell B pivot) pivot τ s U F
+      (weakPattern (ell B pivot) pivot τ s (eventPoint B pivot τ θ i k.val z)) α-
+    extension (ell B pivot) pivot τ s U F
+      (pattern (ell B pivot) pivot τ s (eventPoint B pivot τ θ i k.val z)) α := by
+  unfold jump weakPattern pattern
+  congr 2 <;> apply Finset.filter_congr <;> intro p _ <;>
+    rw [normalized_ell B pivot hp,event_form] <;> constructor <;> intro h <;> linarith
+
+lemma actual_jump_budget (B : I → Z →L[ℝ] ℝ) (hB : Function.Injective B)
+    (pivot : I → ℝ) (hp : ∀ i, pivot i≠0) {τ : ℝ} (hτ : 0<τ) (s : Finset ℤ)
+    {U : Set (ℝ × Z)} (hU : IsOpen U)
+    (hb : ∀ x∈U, regular (ell B pivot) τ x → ∀ i, label (ell B pivot) τ x i∈s)
+    (F : LabelVertex (ell B pivot) τ U → A → ℝ) {J : ℝ}
+    (hF : ∀ (vp vm : LabelVertex (ell B pivot) τ U) (i : I), vp.val i=vm.val i+1 →
+      (∀ j, j≠i → vp.val j=vm.val j) → ∑ a, |F vp a-F vm a|≤J)
+    (φ : ℝ → ℝ) (ψ : Z → ℝ) (θ : ℝ × Z) (i : I)
+    (hsupp : ∀ᵐ z ∂law ψ volume, ∀ k : s,
+      φ (form (B i) θ+B i z-(k:ℤ)*τ/pivot i)≠0 → eventPoint B pivot τ θ i k.val z∈U) :
+    ∀ᵐ z ∂law ψ volume, ∀ k : s,
+      φ (form (B i) θ+B i z-(k:ℤ)*τ/pivot i)≠0 →
+        ∑ a, |jump B (fun i (k : s) => -((k:ℤ)*τ/pivot i))
+          (extension (ell B pivot) pivot τ s U F) θ i k z a|≤J := by
+  have hae := ae_all_iff.mpr (fun k : s => event_other_regular B hB pivot hp τ θ i k.val _ (law_ac ψ volume))
+  filter_upwards [hsupp,hae] with z hz hreg k hk
+  simp_rw [jump_eq_traces B pivot hp]
+  apply interface_jump_bound (ell B pivot) pivot hp hτ s hU hb F hF (hz k hk) i k.val
+    (event_on_plane B pivot hp τ θ i k.val z) (hreg k) (pivot i,0)
+  simp only [ell_apply,map_zero,sub_zero]
+  exact mul_self_pos.mpr (hp i)
+
+end
+end UniformSparsestCut.ProductSlice
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/TriangleRepair.lean

@@ -0,0 +1,473 @@
+import OAI.Combinatorics.SparsestCut.ChartAngles
+
+namespace OAI
+
+universe u1 u2 u3 u4 u5 u6 u7
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.TriangleRepair
+variable {ι : Type u1} [Fintype ι]
+lemma exp_distance_intervalIntegrable {d r : ℝ} (hd : 0 ≤ d) (hr : 0 ≤ r) :
+    IntervalIntegrable (fun l => Real.exp (-d / l)) volume 0 r := by
+  rw [intervalIntegrable_iff_integrableOn_Ioc_of_le hr]
+  apply (integrable_const (1 : ℝ)).mono'
+  · exact (Real.measurable_exp.comp (measurable_const.div measurable_id)).aestronglyMeasurable
+  · filter_upwards [ae_restrict_mem measurableSet_Ioc] with l hl
+    rw [Real.norm_eq_abs, abs_of_pos (Real.exp_pos _)]
+    exact Real.exp_le_one_iff.mpr (div_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr hd) hl.1.le)
+
+lemma min_posSemidef (u : ι → ℝ) (hu : ∀ i, 0 ≤ u i) :
+    (Matrix.of (fun i j => min (u i) (u j))).PosSemidef := by
+  classical
+  let R : ℝ := ∑ i, u i
+  have hR : 0 ≤ R := Finset.sum_nonneg (fun i _ => hu i)
+  have huR (i : ι) : u i ≤ R := Finset.single_le_sum (fun j _ => hu j) (Finset.mem_univ i)
+  let K : ℝ → Matrix ι ι ℝ := fun l => Matrix.of fun i j =>
+    (if l ≤ u i then 1 else 0) * (if l ≤ u j then 1 else 0)
+  have hk (l : ℝ) : (K l).PosSemidef := by
+    convert Matrix.posSemidef_vecMulVec_self_star
+      (fun i => if l ≤ u i then (1 : ℝ) else 0) using 1 ; try rfl
+  have hki (i j : ι) : (fun l => K l i j) =
+      (Set.Iic (min (u i) (u j))).indicator (fun _ => (1 : ℝ)) := by
+    funext l
+    simp only [K, Matrix.of_apply, Set.indicator_apply, Set.mem_Iic, le_min_iff]
+    split_ifs <;> norm_num <;> tauto
+  have hi (i j : ι) : IntervalIntegrable (fun l => K l i j) volume 0 R := by
+    rw [hki]
+    exact ⟨(intervalIntegrable_const (a := 0) (b := R) (c := (1 : ℝ))).1.indicator
+      measurableSet_Iic,
+      (intervalIntegrable_const (a := 0) (b := R) (c := (1 : ℝ))).2.indicator
+      measurableSet_Iic⟩
+  have h := integral_posSemidef K hR (fun l _ => hk l) hi
+  suffices he : Matrix.of (fun i j => min (u i) (u j)) =
+      (fun i j => ∫ l in (0 : ℝ)..R, K l i j) by
+    rw [he]
+    exact h
+  ext i j
+  rw [hki]
+  change min (u i) (u j) =
+    ∫ l in (0 : ℝ)..R, Set.indicator {l | l ≤ min (u i) (u j)} (fun _ => (1 : ℝ)) l
+  rw [intervalIntegral.integral_indicator
+    (show min (u i) (u j) ∈ Set.Icc 0 R from
+      ⟨le_min (hu i) (hu j), (min_le_left _ _).trans (huR i)⟩)]
+  simp
+
+lemma abs_sub_sq_hilbert (u : ι → ℝ) :
+    ∃ h : ι → EuclideanSpace ℝ ι, ∀ i j, ‖h i - h j‖ ^ 2 = |u i - u j| := by
+  let b : ℝ := ∑ i, |u i|
+  have hu (i : ι) : 0 ≤ u i + b := by
+    have hb : |u i| ≤ b := Finset.single_le_sum (fun j _ => abs_nonneg (u j))
+      (Finset.mem_univ i)
+    have := neg_abs_le (u i)
+    linarith
+  obtain ⟨h, hh⟩ := exists_gram (min_posSemidef (fun i => u i + b) hu)
+  refine ⟨h, fun i j => ?_⟩
+  rw [norm_sub_sq_real, ← real_inner_self_eq_norm_sq, ← real_inner_self_eq_norm_sq,
+    hh, hh, hh]
+  simp only [Matrix.of_apply, min_self]
+  rcases le_total (u i) (u j) with hij | hji
+  · rw [min_eq_left (add_le_add_left hij b), abs_of_nonpos (sub_nonpos.mpr hij)]
+    ring
+  · rw [min_eq_right (add_le_add_left hji b), abs_of_nonneg (sub_nonneg.mpr hji)]
+    ring
+
+lemma l1_sq_hilbert {κ : Type u2} [Fintype κ] (x : ι → κ → ℝ) {a : ℝ} (ha : 0 ≤ a) :
+    ∃ h : ι → EuclideanSpace ℝ (κ × ι),
+      ∀ i j, ‖h i - h j‖ ^ 2 = a * ∑ k, |x i k - x j k| := by
+  classical
+  choose h hh using fun k => abs_sub_sq_hilbert (fun i => x i k)
+  refine ⟨fun i => WithLp.toLp 2 (fun ki => Real.sqrt a * h ki.1 i ki.2), ?_⟩
+  intro i j
+  rw [EuclideanSpace.norm_sq_eq]
+  simp only [PiLp.sub_apply, Real.norm_eq_abs, sq_abs,
+    Fintype.sum_prod_type]
+  have hs : ∀ k, ∑ l, (Real.sqrt a * h k i l - Real.sqrt a * h k j l) ^ 2 =
+      a * |x i k - x j k| := by
+    intro k
+    simp_rw [← mul_sub, mul_pow, Real.sq_sqrt ha]
+    rw [← Finset.mul_sum, ← hh k i j, EuclideanSpace.norm_sq_eq]
+    simp [Real.norm_eq_abs]
+  simp_rw [hs]
+  exact (Finset.mul_sum _ _ _).symm
+
+lemma repair_integral_le {d r : ℝ} (hd : 0 ≤ d) (hr : 0 ≤ r) :
+    (∫ l in (0 : ℝ)..r, 1 - Real.exp (-d / l)) ≤ r := by
+  have hi := (intervalIntegrable_const (c := (1 : ℝ))).sub (exp_distance_intervalIntegrable hd hr)
+  have h := intervalIntegral.integral_mono_on hr hi
+    (intervalIntegrable_const (c := (1 : ℝ))) (fun l _ => by
+      have := (Real.exp_pos (-d / l)).le
+      linarith)
+  simpa using h
+
+lemma repair_integral_local {d r : ℝ} (hd : 0 < d) (hdr : d ≤ r) :
+    (∫ l in (0 : ℝ)..r, 1 - Real.exp (-d / l)) ≤
+      d * (1 + Real.log (r / d)) := by
+  have hr : 0 ≤ r := hd.le.trans hdr
+  have hi := (intervalIntegrable_const (c := (1 : ℝ))).sub (exp_distance_intervalIntegrable hd.le hr)
+  have hi₀ := (intervalIntegrable_const (c := (1 : ℝ))).sub (exp_distance_intervalIntegrable hd.le hd.le)
+  have hi₁ : IntervalIntegrable (fun l => 1 - Real.exp (-d / l)) volume d r :=
+    hi.mono_set (by
+      rw [Set.uIcc_of_le hdr, Set.uIcc_of_le hr]
+      exact Set.Icc_subset_Icc hd.le le_rfl)
+  have hn : 0 ∉ Set.uIcc d r := by
+    rw [Set.uIcc_of_le hdr]
+    exact fun h => (not_le_of_gt hd) h.1
+  have hj : IntervalIntegrable (fun l => d * l⁻¹) volume d r :=
+    (intervalIntegrable_inv_iff.mpr (Or.inr hn)).const_mul d
+  have hbound := intervalIntegral.integral_mono_on hdr hi₁ hj (fun l hl => by
+    have he := Real.one_sub_le_exp_neg (d / l)
+    rw [← neg_div] at he
+    rw [← div_eq_mul_inv]
+    linarith)
+  rw [intervalIntegral.integral_const_mul, integral_inv hn] at hbound
+  rw [← intervalIntegral.integral_add_adjacent_intervals hi₀ hi₁]
+  have hfirst := repair_integral_le hd.le hd.le
+  linarith
+
+section Charts
+
+variable {κ : Type u3} {H : Type u4} [Fintype κ] [DecidableEq κ]
+  [NormedAddCommGroup H] [InnerProductSpace ℝ H]
+
+noncomputable def chartKernel (c : ι → κ) (h : ι → H) (l : ℝ) : Matrix ι ι ℝ :=
+  Matrix.of fun i j => if c i = c j then Real.exp (-‖h i - h j‖ ^ 2 / l) else 0
+
+noncomputable def cappedDistance (c : ι → κ) (h : ι → H) (r : ℝ) (i j : ι) : ℝ :=
+  if c i = c j then min r (‖h i - h j‖ ^ 2) else r
+
+omit [Fintype κ] in
+lemma chartKernel_posSemidef (c : ι → κ) (h : ι → H) {l : ℝ} (hl : 0 ≤ l) :
+    (chartKernel c h l).PosSemidef := by
+  have hm := (Matrix.PosSemidef.one (n := κ) (R := ℝ)).submatrix c
+  rcases hl.eq_or_lt with rfl | hl
+  · convert hm using 1
+    ext i j
+    simp [chartKernel, Matrix.submatrix_apply, Matrix.one_apply]
+  · have hg := gaussian_posSemidef h hl
+    convert hm.hadamard hg using 1
+    ext i j
+    change (if c i = c j then _ else 0) =
+      (if c i = c j then (1 : ℝ) else 0) * _
+    split_ifs <;> simp
+
+omit [Fintype ι] [Fintype κ] [InnerProductSpace ℝ H] in
+lemma chartKernel_intervalIntegrable (c : ι → κ) (h : ι → H) {r : ℝ}
+    (hr : 0 ≤ r) (i j : ι) :
+    IntervalIntegrable (fun l => chartKernel c h l i j) volume 0 r := by
+  by_cases hij : c i = c j
+  · simpa [chartKernel, hij] using exp_distance_intervalIntegrable (sq_nonneg ‖h i - h j‖) hr
+  · simp only [chartKernel, Matrix.of_apply, hij, ite_false]
+    exact intervalIntegrable_const
+
+omit [Fintype ι] [Fintype κ] [InnerProductSpace ℝ H] in
+lemma chartKernel_nonneg (c : ι → κ) (h : ι → H) (l : ℝ) (i j : ι) :
+    0 ≤ chartKernel c h l i j := by
+  simp only [chartKernel, Matrix.of_apply]
+  split_ifs <;> positivity
+
+omit [Fintype ι] [Fintype κ] [InnerProductSpace ℝ H] in
+lemma chartKernel_le_one (c : ι → κ) (h : ι → H) {l : ℝ} (hl : 0 ≤ l) (i j : ι) :
+    chartKernel c h l i j ≤ 1 := by
+  simp only [chartKernel, Matrix.of_apply]
+  split_ifs
+  · exact Real.exp_le_one_iff.mpr (div_nonpos_of_nonpos_of_nonneg
+      (neg_nonpos.mpr (sq_nonneg _)) hl)
+  · norm_num
+
+omit [Fintype ι] [Fintype κ] [InnerProductSpace ℝ H] in
+lemma chartKernel_self (c : ι → κ) (h : ι → H) (l : ℝ) (i : ι) :
+    chartKernel c h l i i = 1 := by simp [chartKernel]
+
+omit [Fintype ι] [Fintype κ] [InnerProductSpace ℝ H] in
+lemma chartKernel_symm (c : ι → κ) (h : ι → H) (l : ℝ) (i j : ι) :
+    chartKernel c h l i j = chartKernel c h l j i := by
+  simp only [chartKernel, Matrix.of_apply, norm_sub_rev (h j) (h i)]
+  by_cases hij : c i = c j <;> simp [hij, eq_comm]
+
+omit [Fintype ι] [Fintype κ] [InnerProductSpace ℝ H] in
+lemma cappedDistance_nonneg (c : ι → κ) (h : ι → H) {r : ℝ} (hr : 0 ≤ r) (i j : ι) :
+    0 ≤ cappedDistance c h r i j := by
+  simp only [cappedDistance]
+  split_ifs
+  · exact le_min hr (sq_nonneg _)
+  · exact hr
+
+omit [Fintype ι] [Fintype κ] [InnerProductSpace ℝ H] in
+lemma cappedDistance_le (c : ι → κ) (h : ι → H) (r : ℝ) (i j : ι) :
+    cappedDistance c h r i j ≤ r := by
+  simp only [cappedDistance]
+  split_ifs
+  · exact min_le_left _ _
+  · rfl
+
+def ChartTriangle (c : ι → κ) (h : ι → H) : Prop :=
+  ∀ i j k, c i = c j → c j = c k →
+    ‖h i - h k‖ ^ 2 ≤ ‖h i - h j‖ ^ 2 + ‖h j - h k‖ ^ 2
+
+omit [Fintype ι] [Fintype κ] [InnerProductSpace ℝ H] in
+lemma chartKernel_mul_le (c : ι → κ) (h : ι → H) (ht : ChartTriangle c h)
+    {l : ℝ} (hl : 0 < l) (i j z : ι) :
+    chartKernel c h l i z * chartKernel c h l j z ≤ chartKernel c h l i j := by
+  by_cases hiz : c i = c z
+  · by_cases hjz : c j = c z
+    · simp only [chartKernel, Matrix.of_apply, hiz, hjz, ite_true]
+      rw [← Real.exp_add]
+      apply Real.exp_le_exp.mpr
+      rw [← add_div]
+      apply div_le_div_of_nonneg_right _ hl.le
+      have htri := ht i z j hiz hjz.symm
+      rw [norm_sub_rev (h z) (h j)] at htri
+      linarith
+    · simp only [chartKernel, Matrix.of_apply, hjz, ite_false, mul_zero]
+      split_ifs <;> positivity
+  · simp only [chartKernel, Matrix.of_apply, hiz, ite_false, zero_mul]
+    split_ifs <;> positivity
+
+omit [Fintype ι] [Fintype κ] [InnerProductSpace ℝ H] in
+lemma chartKernel_le_half (c : ι → κ) (h : ι → H) {r l : ℝ}
+    (hl : 0 < l) (i j : ι) (hle : l ≤ cappedDistance c h r i j) :
+    chartKernel c h l i j ≤ 1 / 2 := by
+  by_cases hij : c i = c j
+  · have hd : l ≤ ‖h i - h j‖ ^ 2 := by
+      exact le_trans hle (by simp [cappedDistance, hij])
+    simp only [chartKernel, Matrix.of_apply, hij, ite_true]
+    calc
+      Real.exp (-‖h i - h j‖ ^ 2 / l) ≤ Real.exp (-1) := by
+        apply Real.exp_le_exp.mpr
+        apply (div_le_iff₀ hl).mpr
+        linarith
+      _ ≤ 1 / 2 := by
+        rw [Real.exp_neg, ← one_div]
+        apply one_div_le_one_div_of_le (by norm_num : (0 : ℝ) < 2)
+        have := Real.add_one_le_exp (1 : ℝ)
+        norm_num at this ⊢
+        exact this
+  · simp [chartKernel, hij]
+
+def IsRepairGram (c : ι → κ) (h : ι → H) (r : ℝ)
+    (q : ι → EuclideanSpace ℝ ι) : Prop :=
+  ∀ i j, ⟪q i, q j⟫_ℝ = 4 * ∫ l in (0 : ℝ)..r, chartKernel c h l i j
+
+omit [Fintype κ] in
+lemma exists_repairGram (c : ι → κ) (h : ι → H) {r : ℝ} (hr : 0 ≤ r) :
+    ∃ q : ι → EuclideanSpace ℝ ι, IsRepairGram c h r q := by
+  have hi := integral_posSemidef (chartKernel c h) hr
+    (fun l hl => chartKernel_posSemidef c h hl.1) (chartKernel_intervalIntegrable c h hr)
+  obtain ⟨q, hq⟩ := exists_gram (hi.smul (by norm_num : (0 : ℝ) ≤ 4))
+  exact ⟨q, hq⟩
+
+omit [Fintype κ] [InnerProductSpace ℝ H] in
+lemma repairGram_norm_sq (c : ι → κ) (h : ι → H) {r : ℝ}
+    {q : ι → EuclideanSpace ℝ ι} (hq : IsRepairGram c h r q) (i : ι) :
+    ‖q i‖ ^ 2 = 4 * r := by
+  rw [← real_inner_self_eq_norm_sq, hq]
+  simp_rw [chartKernel_self]
+  simp
+
+omit [Fintype κ] [InnerProductSpace ℝ H] in
+lemma repairGram_distance (c : ι → κ) (h : ι → H) {r : ℝ} (hr : 0 ≤ r)
+    {q : ι → EuclideanSpace ℝ ι} (hq : IsRepairGram c h r q) (i j : ι) :
+    ‖q i - q j‖ ^ 2 = 8 * ∫ l in (0 : ℝ)..r, 1 - chartKernel c h l i j := by
+  rw [norm_sub_sq_real, repairGram_norm_sq c h hq, repairGram_norm_sq c h hq, hq,
+    intervalIntegral.integral_sub intervalIntegrable_const
+      (chartKernel_intervalIntegrable c h hr i j)]
+  simp only [intervalIntegral.integral_const, sub_zero, smul_eq_mul, mul_one]
+  ring
+
+omit [Fintype κ] [InnerProductSpace ℝ H] in
+lemma repairGram_distance_le (c : ι → κ) (h : ι → H) {r : ℝ} (hr : 0 ≤ r)
+    {q : ι → EuclideanSpace ℝ ι} (hq : IsRepairGram c h r q) (i j : ι) :
+    ‖q i - q j‖ ^ 2 ≤ 8 * r := by
+  rw [repairGram_distance c h hr hq]
+  have hi := (intervalIntegrable_const (c := (1 : ℝ))).sub
+    (chartKernel_intervalIntegrable c h hr i j)
+  have hb := intervalIntegral.integral_mono_on hr hi
+    (intervalIntegrable_const (c := (1 : ℝ))) (fun l _ => by
+      have := chartKernel_nonneg c h l i j
+      linarith)
+  simp only [intervalIntegral.integral_const, sub_zero, smul_eq_mul, mul_one] at hb
+  linarith
+
+omit [Fintype κ] [InnerProductSpace ℝ H] in
+lemma repairGram_local (c : ι → κ) (h : ι → H) {r : ℝ}
+    {q : ι → EuclideanSpace ℝ ι} (hq : IsRepairGram c h r q) {i j : ι}
+    (hij : c i = c j) (hd : 0 < ‖h i - h j‖ ^ 2) (hdr : ‖h i - h j‖ ^ 2 ≤ r) :
+    ‖q i - q j‖ ^ 2 ≤ 8 * ‖h i - h j‖ ^ 2 *
+      (1 + Real.log (r / ‖h i - h j‖ ^ 2)) := by
+  rw [repairGram_distance c h (hd.le.trans hdr) hq]
+  simp only [chartKernel, Matrix.of_apply, hij, ite_true]
+  have := repair_integral_local hd hdr
+  nlinarith
+
+omit [Fintype κ] [InnerProductSpace ℝ H] in
+lemma repairGram_eq_of_zero (c : ι → κ) (h : ι → H) {r : ℝ} (hr : 0 ≤ r)
+    {q : ι → EuclideanSpace ℝ ι} (hq : IsRepairGram c h r q) {i j : ι}
+    (hij : c i = c j) (hd : ‖h i - h j‖ ^ 2 = 0) : q i = q j := by
+  have hdq := repairGram_distance c h hr hq i j
+  simp only [chartKernel, Matrix.of_apply, hij, ite_true, hd, neg_zero, zero_div,
+    Real.exp_zero, sub_self, intervalIntegral.integral_zero, mul_zero] at hdq
+  exact sub_eq_zero.mp (norm_eq_zero.mp (sq_eq_zero_iff.mp hdq))
+
+noncomputable def angleIntegrand (c : ι → κ) (h : ι → H) (i j z : ι) (l : ℝ) : ℝ :=
+  1 - chartKernel c h l i z - chartKernel c h l j z + chartKernel c h l i j
+
+omit [Fintype ι] [Fintype κ] [InnerProductSpace ℝ H] in
+lemma angleIntegrand_integrable (c : ι → κ) (h : ι → H) {r : ℝ} (hr : 0 ≤ r)
+    (i j z : ι) : IntervalIntegrable (angleIntegrand c h i j z) volume 0 r :=
+  (((intervalIntegrable_const (c := (1 : ℝ))).sub (chartKernel_intervalIntegrable c h hr i z)).sub
+    (chartKernel_intervalIntegrable c h hr j z)).add (chartKernel_intervalIntegrable c h hr i j)
+
+omit [Fintype κ] [InnerProductSpace ℝ H] in
+lemma repairGram_angle (c : ι → κ) (h : ι → H) {r : ℝ} (hr : 0 ≤ r)
+    {q : ι → EuclideanSpace ℝ ι} (hq : IsRepairGram c h r q) (i j z : ι) :
+    ⟪q i - q z, q j - q z⟫_ℝ = 4 * ∫ l in (0 : ℝ)..r, angleIntegrand c h i j z l := by
+  rw [inner_sub_left, inner_sub_right, inner_sub_right, hq, hq, hq, hq]
+  simp_rw [chartKernel_self, chartKernel_symm c h _ z j]
+  rw [show (fun l => angleIntegrand c h i j z l) =
+      (fun l => 1 - chartKernel c h l i z - chartKernel c h l j z +
+        chartKernel c h l i j) from rfl]
+  rw [intervalIntegral.integral_add
+    (((intervalIntegrable_const (c := (1 : ℝ))).sub
+      (chartKernel_intervalIntegrable c h hr i z)).sub
+      (chartKernel_intervalIntegrable c h hr j z)) (chartKernel_intervalIntegrable c h hr i j)]
+  rw [intervalIntegral.integral_sub
+    ((intervalIntegrable_const (c := (1 : ℝ))).sub (chartKernel_intervalIntegrable c h hr i z))
+    (chartKernel_intervalIntegrable c h hr j z)]
+  rw [intervalIntegral.integral_sub intervalIntegrable_const
+    (chartKernel_intervalIntegrable c h hr i z)]
+  ring
+
+omit [Fintype ι] [Fintype κ] [InnerProductSpace ℝ H] in
+lemma angleIntegrand_nonneg (c : ι → κ) (h : ι → H) (ht : ChartTriangle c h)
+    {l : ℝ} (hl : 0 < l) (i j z : ι) : 0 ≤ angleIntegrand c h i j z l := by
+  have ha := chartKernel_le_one c h hl.le i z
+  have hb := chartKernel_le_one c h hl.le j z
+  have hc := chartKernel_mul_le c h ht hl i j z
+  have hp := mul_nonneg (sub_nonneg.mpr ha) (sub_nonneg.mpr hb)
+  dsimp only [angleIntegrand]
+  nlinarith
+
+omit [Fintype ι] [Fintype κ] [InnerProductSpace ℝ H] in
+lemma angleIntegrand_ge_quarter (c : ι → κ) (h : ι → H) (ht : ChartTriangle c h)
+    {r l : ℝ} (hl : 0 < l) (i j z : ι)
+    (hli : l ≤ cappedDistance c h r i z) (hlj : l ≤ cappedDistance c h r j z) :
+    1 / 4 ≤ angleIntegrand c h i j z l := by
+  have ha := chartKernel_le_half c h hl i z hli
+  have hb := chartKernel_le_half c h hl j z hlj
+  have hc := chartKernel_mul_le c h ht hl i j z
+  have hp := mul_le_mul
+    (show (1 / 2 : ℝ) ≤ 1 - chartKernel c h l i z by linarith)
+    (show (1 / 2 : ℝ) ≤ 1 - chartKernel c h l j z by linarith)
+    (by norm_num : (0 : ℝ) ≤ 1 / 2)
+    (show 0 ≤ 1 - chartKernel c h l i z by linarith)
+  dsimp only [angleIntegrand]
+  nlinarith
+
+omit [Fintype κ] [InnerProductSpace ℝ H] in
+lemma repairGram_angle_lower (c : ι → κ) (h : ι → H) (ht : ChartTriangle c h)
+    {r : ℝ} (hr : 0 ≤ r) {q : ι → EuclideanSpace ℝ ι} (hq : IsRepairGram c h r q)
+    (i j z : ι) :
+    min (cappedDistance c h r i z) (cappedDistance c h r j z) ≤
+      ⟪q i - q z, q j - q z⟫_ℝ := by
+  let t := min (cappedDistance c h r i z) (cappedDistance c h r j z)
+  have ht₀ : 0 ≤ t := le_min (cappedDistance_nonneg c h hr i z)
+    (cappedDistance_nonneg c h hr j z)
+  have htr : t ≤ r := (min_le_left _ _).trans (cappedDistance_le c h r i z)
+  have hf : (0 : ℝ → ℝ) ≤ᵐ[volume.restrict (Set.Ioc 0 r)] angleIntegrand c h i j z := by
+    filter_upwards [ae_restrict_mem measurableSet_Ioc] with l hl
+    exact angleIntegrand_nonneg c h ht hl.1 i j z
+  have hlower := intervalIntegral.integral_mono_ae_restrict ht₀
+    (intervalIntegrable_const (c := (1 / 4 : ℝ))) (angleIntegrand_integrable c h ht₀ i j z)
+    (show (fun _ => (1 / 4 : ℝ)) ≤ᵐ[volume.restrict (Set.Icc 0 t)]
+      angleIntegrand c h i j z from by
+      filter_upwards [ae_restrict_mem measurableSet_Icc,
+        ae_restrict_of_ae (volume.ae_ne (0 : ℝ))] with l hl hne
+      exact angleIntegrand_ge_quarter c h ht (lt_of_le_of_ne hl.1 (Ne.symm hne)) i j z
+        (hl.2.trans (min_le_left _ _)) (hl.2.trans (min_le_right _ _)))
+  have hmono := intervalIntegral.integral_mono_interval le_rfl ht₀ htr hf
+    (angleIntegrand_integrable c h hr i j z)
+  rw [repairGram_angle c h hr hq]
+  simp only [intervalIntegral.integral_const, sub_zero, smul_eq_mul] at hlower
+  dsimp only [t] at *
+  linarith
+
+omit [Fintype κ] [DecidableEq κ] in
+
+lemma chart_l1_sq_hilbert {ξ : Type u5} [Fintype ξ] (c : ι → κ) (x : ι → ξ → ℝ)
+    (a : κ → ℝ) (ha : ∀ s, 0 ≤ a s) :
+    ∃ h : ι → EuclideanSpace ℝ (ξ × ι),
+      (∀ i j, c i = c j → ‖h i - h j‖ ^ 2 = a (c i) * ∑ k, |x i k - x j k|) ∧
+      ChartTriangle c h := by
+  obtain ⟨g, hg⟩ := l1_sq_hilbert x (by norm_num : (0 : ℝ) ≤ 1)
+  let h : ι → EuclideanSpace ℝ (ξ × ι) := fun i => Real.sqrt (a (c i)) • g i
+  have hh (i j : ι) (hc : c i = c j) :
+      ‖h i - h j‖ ^ 2 = a (c i) * ∑ k, |x i k - x j k| := by
+    dsimp only [h]
+    rw [← hc, ← smul_sub, norm_smul, mul_pow, Real.norm_eq_abs, sq_abs,
+      Real.sq_sqrt (ha (c i)), hg]
+    ring
+  refine ⟨h, hh, fun i j k hij hjk => ?_⟩
+  rw [hh i k (hij.trans hjk), hh i j hij, hh j k hjk, ← hij, ← mul_add]
+  apply mul_le_mul_of_nonneg_left _ (ha (c i))
+  rw [← Finset.sum_add_distrib]
+  exact Finset.sum_le_sum (fun l _ => abs_sub_le (x i l) (x j l) (x k l))
+
+lemma sum_sq_hilbert {E : Type u6} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+    (P : ι → E) (q : ι → H) :
+    ∃ z : ι → EuclideanSpace ℝ ι, ∀ i j,
+      ‖z i - z j‖ ^ 2 = ‖P i - P j‖ ^ 2 + ‖q i - q j‖ ^ 2 := by
+  obtain ⟨z, hz⟩ := exists_gram ((gram_posSemidef P).add (gram_posSemidef q))
+  refine ⟨z, fun i j => ?_⟩
+  simp only [norm_sub_sq_real]
+  simp only [← real_inner_self_eq_norm_sq, hz, Matrix.add_apply, Matrix.of_apply]
+  ring
+
+lemma angle_triangle_slack (x y z : H) :
+    ‖x - y‖ ^ 2 + ‖z - y‖ ^ 2 - ‖x - z‖ ^ 2 = 2 * ⟪x - y, z - y⟫_ℝ := by
+  have he : x - z = (x - y) - (z - y) := by abel
+  rw [he, norm_sub_sq_real (x - y) (z - y)]
+  ring
+
+omit [Fintype κ] in
+
+theorem triangle_repair {E : Type u7} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+    (c : ι → κ) (h : ι → H) (ht : ChartTriangle c h) {r : ℝ} (hr : 0 < r)
+    (P : ι → E)
+    (hP : ∀ i j z, -min (cappedDistance c h r i z) (cappedDistance c h r j z) ≤
+      ⟪P i - P z, P j - P z⟫_ℝ) :
+    ∃ q z : ι → EuclideanSpace ℝ ι,
+      IsRepairGram c h r q ∧
+      (∀ i j, ‖z i - z j‖ ^ 2 = ‖P i - P j‖ ^ 2 + ‖q i - q j‖ ^ 2) ∧
+      (∀ i j k, ‖z i - z k‖ ^ 2 ≤ ‖z i - z j‖ ^ 2 + ‖z j - z k‖ ^ 2) ∧
+      (∀ i j, ‖q i - q j‖ ^ 2 = 8 * ∫ l in (0 : ℝ)..r, 1 - chartKernel c h l i j) ∧
+      (∀ i j, ‖q i - q j‖ ^ 2 ≤ 8 * r) ∧
+      (∀ i j, c i = c j → 0 < ‖h i - h j‖ ^ 2 → ‖h i - h j‖ ^ 2 ≤ r →
+        ‖q i - q j‖ ^ 2 ≤ 8 * ‖h i - h j‖ ^ 2 * (1 + Real.log (r / ‖h i - h j‖ ^ 2))) ∧
+      (∀ i j, c i = c j → ‖h i - h j‖ ^ 2 = 0 → q i = q j) := by
+  obtain ⟨q, hq⟩ := exists_repairGram c h hr.le
+  obtain ⟨z, hz⟩ := sum_sq_hilbert P q
+  refine ⟨q, z, hq, hz, ?_, repairGram_distance c h hr.le hq,
+    repairGram_distance_le c h hr.le hq,
+    fun _ _ hc hd hdr => repairGram_local c h hq hc hd hdr,
+    fun _ _ hc hd => repairGram_eq_of_zero c h hr.le hq hc hd⟩
+  intro i j k
+  rw [hz, hz, hz]
+  have hp := hP i k j
+  have hqangle := repairGram_angle_lower c h ht hr.le hq i k j
+  have hpAngle := angle_triangle_slack (P i) (P j) (P k)
+  have hqAngle := angle_triangle_slack (q i) (q j) (q k)
+  rw [norm_sub_rev (P k) (P j)] at hpAngle
+  rw [norm_sub_rev (q k) (q j)] at hqAngle
+  linarith
+
+end Charts
+
+end UniformSparsestCut.TriangleRepair
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/UniformMetric.lean

@@ -0,0 +1,89 @@
+import OAI.Combinatorics.SparsestCut.UniformReplication
+import OAI.Combinatorics.SparsestCut.VertexCount
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.SourceUniform
+open scoped BigOperators
+open SourceMetric SourceParameters
+noncomputable section
+lemma size_upper {d v : ℕ} (hd : 3≤d) (hv : v≤d^(4025*d)) :
+    d^d+d^2*v+v≤d^(4030*d) := by
+  have hd1 : 1≤d := by omega
+  have hp : d^d≤d^(4025*d+2) := Nat.pow_le_pow_right hd1 (by omega)
+  have hv' : v≤d^(4025*d+2) := hv.trans (Nat.pow_le_pow_right hd1 (by omega))
+  have hprod : d^2*v≤d^(4025*d+2) := by
+    calc
+      _ ≤ d^2*d^(4025*d) := Nat.mul_le_mul_left _ hv
+      _ = _ := by rw [←pow_add]; congr 1; omega
+  calc
+    _ ≤ 3*d^(4025*d+2) := by omega
+    _ ≤ d*d^(4025*d+2) := Nat.mul_le_mul_right _ hd
+    _ = d^(4025*d+3) := by rw [←pow_succ']
+    _ ≤ _ := Nat.pow_le_pow_right hd1 (by omega)
+
+lemma instance_exists {m : ℕ} (f : PivotFamily.PFamily (m+1))
+    (hm : 3000 ≤ m+1) (hl : 1≤Real.log (m+1:ℕ)) (hH : SourceContraction.H≤(m+1:ℕ))
+    (hD : 4*SourceWeighted.D≤(m+1:ℕ))
+    (ha : C₀+1≤KernelApprox.cstar/6*(m+1:ℕ)) :
+    ∃ (n : ℕ) (C : Capacity n), (m+1)^(m+1)≤n ∧ n≤(m+1)^(4030*(m+1)) ∧
+      2≤n ∧ 1≤OPT C ∧ 0<glValue C ∧
+      glValue C≤(SourceContraction.C+1)*SourceContraction.weight (m+1)/
+        (KernelApprox.cstar/6*(m+1:ℕ)) := by
+  classical
+  let d := m+1
+  have hd0 : 0<d := Nat.succ_pos m
+  have hx0 : (0:ℝ)<d := by exact_mod_cast hd0
+  have hd1 : 1≤d := by omega
+  have hx : (1:ℝ)≤d := by exact_mod_cast hd1
+  obtain ⟨Z,w,hw,hws,htri,hdiam,havg,hcon⟩ := SourceWeighted.weighted_instance f hm hl hH
+  let M := d^d+d^2*Fintype.card (V f)
+  have hM : 0<M := lt_of_lt_of_le (pow_pos hd0 _) (Nat.le_add_right _ _)
+  let n := Replication.n M w
+  let δ := fun i j : Fin n => ‖Z (Replication.rep M w i)-Z (Replication.rep M w j)‖^2
+  let ε : ℝ := 4*(SourceWeighted.D*d)*(Fintype.card (V f):ℝ)/M
+  have hε : ε≤1 := by
+    apply (div_le_one (by exact_mod_cast hM)).mpr
+    have hM' : (d:ℝ)^2*(Fintype.card (V f):ℝ)≤M := by
+      exact_mod_cast (Nat.le_add_left (d^2*Fintype.card (V f)) (d^d))
+    calc
+      _ = (4*SourceWeighted.D)*(d:ℝ)*(Fintype.card (V f):ℝ) := by ring
+      _ ≤ (d:ℝ)*(d:ℝ)*(Fintype.card (V f):ℝ) :=
+        mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right hD hx0.le) (Nat.cast_nonneg _)
+      _ = (d:ℝ)^2*(Fintype.card (V f):ℝ) := by ring
+      _ ≤ _ := hM'
+  have hsize := Replication.n_bounds M w hw hws
+  have hlo : d^d≤n := (Nat.le_add_right _ _).trans hsize.1
+  have hhi : n≤d^(4030*d) := hsize.2.trans (size_upper (by omega) (SourceCount.card_bound f (by omega)))
+  have hn : 2≤n := by
+    have hh : d≤d^d := by simpa using (Nat.pow_le_pow_right hd1 hd1 : d^1≤d^d)
+    omega
+  obtain ⟨hδ,hav,hco⟩ := UniformReplication.estimates M hM w hw hws Z htri
+    (mul_nonneg SourceWeighted.D_pos.le hx0.le) hdiam havg hcon
+  have ha0 : 0<KernelApprox.cstar/6*(d:ℝ) := mul_pos (div_pos KernelApprox.cstar_pos (by norm_num)) hx0
+  have hb0 : 0<(SourceContraction.C+1)*SourceContraction.weight d := by
+    have hc := SourceContraction.C_pos
+    have hw' := SourceContraction.weight_ge_one hd1 hl
+    positivity
+  have hlow : KernelApprox.cstar/6*(d:ℝ)≤KernelApprox.cstar/3*(d:ℝ)-C₀*p d 8-ε := by
+    have hp : C₀*p d 8≤C₀ := mul_le_of_le_one_right C₀_pos.le (p_one_le hx _)
+    linarith only [ha,hp,hε]
+  have hupp : SourceContraction.C*SourceContraction.weight d+ε≤
+      (SourceContraction.C+1)*SourceContraction.weight d := by
+    have hh := SourceContraction.weight_ge_one hd1 hl
+    linarith only [hh,hε]
+  obtain ⟨C,hopt,hgl,hbound⟩ := cut_cone_duality hn δ hδ ha0 hb0
+    ((mul_le_mul_of_nonneg_left hlow (sq_nonneg (n:ℝ))).trans hav)
+    (fun A hA F hF => (hco A F hF).trans (mul_le_mul_of_nonneg_left hupp (sq_nonneg (n:ℝ))))
+  exact ⟨n,C,hlo,hhi,hn,hopt,hgl,hbound⟩
+end
+end UniformSparsestCut.SourceUniform
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/UniformReplication.lean

@@ -0,0 +1,78 @@
+import OAI.Combinatorics.SparsestCut.Replication
+import OAI.Combinatorics.SparsestCut.PositiveKernels
+
+namespace OAI
+
+universe u1 u2 u3 u4
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.UniformReplication
+open scoped BigOperators RealInnerProductSpace
+noncomputable section
+lemma negative_pullback {V : Type u1} {H : Type u2} [NormedAddCommGroup H] [InnerProductSpace ℝ H]
+    (Z : V → H) (htri : ∀ v w z, ‖Z v-Z z‖^2 ≤ ‖Z v-Z w‖^2+‖Z w-Z z‖^2)
+    {n : ℕ} (r : Fin n → V) : NegativeType (fun i j => ‖Z (r i)-Z (r j)‖^2) := by
+  classical
+  obtain ⟨Y,hY⟩ := TriangleRepair.exists_gram (TriangleRepair.gram_posSemidef (fun i => Z (r i)))
+  refine ⟨⟨Y,?_⟩,fun i j k => htri (r i) (r j) (r k)⟩
+  intro i j
+  simp only [← real_inner_self_eq_norm_sq, inner_sub_left, inner_sub_right, hY, Matrix.of_apply]
+
+variable {V : Type u3} {H : Type u4} [Fintype V] [NormedAddCommGroup H] [InnerProductSpace ℝ H]
+lemma estimates (M : ℕ) (hM : 0<M) (w : V → ℝ) (hw : ∀ v, 0≤w v) (hws : (∑ v,w v)=1)
+    (Z : V → H) (htri : ∀ v w z, ‖Z v-Z z‖^2 ≤ ‖Z v-Z w‖^2+‖Z w-Z z‖^2)
+    {D a b : ℝ} (hD : 0≤D) (hdiam : ∀ v z, ‖Z v-Z z‖^2≤D)
+    (havg : a≤∑ v, ∑ z, w v*w z*‖Z v-Z z‖^2)
+    (hcon : ∀ (A : Type) [Fintype A] (F : V → A → ℝ),
+      (∀ v z, (∑ k, |F v k-F z k|)≤‖Z v-Z z‖^2) →
+      (∑ v, ∑ z, w v*w z*(∑ k, |F v k-F z k|))≤b) :
+    let n := Replication.n M w
+    let d := fun i j : Fin n => ‖Z (Replication.rep M w i)-Z (Replication.rep M w j)‖^2
+    let ε := 4*D*(Fintype.card V:ℝ)/M
+    NegativeType d ∧ (n:ℝ)^2*(a-ε)≤∑ i, ∑ j,d i j ∧
+      ∀ (A : Type) [Fintype A] (F : Fin n → A → ℝ),
+        (∀ i j, (∑ k, |F i k-F j k|)≤d i j) →
+        (∑ i, ∑ j, ∑ k, |F i k-F j k|)≤(n:ℝ)^2*(b+ε) := by
+  dsimp only
+  have hn : 0<Replication.n M w := hM.trans_le (Replication.n_bounds M w hw hws).1
+  refine ⟨negative_pullback Z htri _,?_,?_⟩
+  · rw [Replication.ordered_sum M w hn (fun v z => ‖Z v-Z z‖^2)]
+    apply mul_le_mul_of_nonneg_left _ (sq_nonneg _)
+    have he := Replication.expectation_error M hM w hw hws
+      (fun v z => ‖Z v-Z z‖^2) hD (fun v z => by rw [abs_of_nonneg (sq_nonneg _)]; exact hdiam v z)
+    linarith [(abs_le.mp he).1]
+  · intro A hA F hF
+    let G : V → A → ℝ := fun v k => F (Replication.representative M w v) k
+    have hG : ∀ v z, (∑ k, |G v k-G z k|)≤‖Z v-Z z‖^2 :=
+      Replication.descend_contraction M w _ F hF
+    have he : (∑ i, ∑ j, ∑ k, |F i k-F j k|)=
+        ∑ i, ∑ j, ∑ k, |G (Replication.rep M w i) k-G (Replication.rep M w j) k| := by
+      apply Finset.sum_congr rfl
+      intro i hi
+      apply Finset.sum_congr rfl
+      intro j hj
+      apply Finset.sum_congr rfl
+      intro k hk
+      have h1 := Replication.collapse M w (fun v z => ‖Z v-Z z‖^2) (by simp) F hF i k
+      have h2 := Replication.collapse M w (fun v z => ‖Z v-Z z‖^2) (by simp) F hF j k
+      change |F i k-F j k|=|F (Replication.representative M w (Replication.rep M w i)) k-
+        F (Replication.representative M w (Replication.rep M w j)) k|
+      rw [h1,h2]
+    rw [he,Replication.ordered_sum M w hn (fun v z => ∑ k, |G v k-G z k|)]
+    apply mul_le_mul_of_nonneg_left _ (sq_nonneg _)
+    have herr := Replication.expectation_error M hM w hw hws
+      (fun v z => ∑ k, |G v k-G z k|) hD (fun v z => by
+        rw [abs_of_nonneg (Finset.sum_nonneg (fun k _ => abs_nonneg _))]
+        exact (hG v z).trans (hdiam v z))
+    have hbound := hcon A G hG
+    linarith [(abs_le.mp herr).2]
+end
+end UniformSparsestCut.UniformReplication
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/VertexCount.lean

@@ -0,0 +1,75 @@
+import OAI.Combinatorics.SparsestCut.LabelCount
+
+namespace OAI
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.SourceCount
+open SourceCharts SourceParameters SourceMetric
+open scoped BigOperators
+noncomputable section
+variable {m : ℕ} (f : PivotFamily.PFamily m) [NeZero m]
+lemma integer_bound (hm : 5 ≤ m) (v : V f) (i : Fin (m^6)) : |(v.val.2 i:ℝ)|≤(m:ℝ)^2003 := by
+  have hm0 := NeZero.pos m
+  have hx : (1:ℝ) ≤ m := by exact_mod_cast (show 1 ≤ m by omega)
+  have hx5 : (5:ℝ) ≤ m := by exact_mod_cast hm
+  have hx0 : (0:ℝ)< m := by exact_mod_cast hm0
+  obtain ⟨θ,hθ,hr,he⟩ := v.property
+  have h := RoundedCharts.integerLabel_bound (u f v.val.1) (p_pos hx0 2000)
+    (fun i => (u_norm f hm0 v.val.1 i).2) hθ i
+  rw [he] at h
+  calc
+    _ ≤ 4*Real.sqrt m/p m 2000+1 := h
+    _ ≤ 4*(m:ℝ)/p m 2000+1 := by
+      apply add_le_add_left
+      apply div_le_div_of_nonneg_right _ (p_nonneg hx0.le _)
+      exact mul_le_mul_of_nonneg_left (sqrt_le hx) (by norm_num)
+    _ = 4*(m:ℝ)^2001+1 := by unfold p; field_simp
+    _ ≤ 5*(m:ℝ)^2001 := by nlinarith [one_le_pow₀ hx (n:=2001)]
+    _ ≤ (m:ℝ)*(m:ℝ)^2001 := mul_le_mul_of_nonneg_right hx5 (by positivity)
+    _ = (m:ℝ)^2002 := by ring
+    _ ≤ _ := pow_le_pow_right₀ hx (by norm_num)
+lemma card_bound (hm : 5 ≤ m) : Fintype.card (V f)≤ m^(4025*m) := by
+  have hm0 := NeZero.pos m
+  have hx0 : (0:ℝ)< m := by exact_mod_cast hm0
+  let B : ℤ := (m:ℤ)^2003
+  have hB : ∀ v : V f, ∀ i, v.val.2 i∈Finset.Icc (-B) B := by
+    intro v i
+    have h := integer_bound f hm v i
+    have h' : |v.val.2 i|≤B := by exact_mod_cast h
+    simpa only [Finset.mem_Icc,abs_le] using h'
+  have h := LabelCount.vertex_count (u f) (p_pos hx0 2000) B hB
+  have hI : (Finset.Icc (-B) B).card=2*m^2003+1 := by
+    rw [Int.card_Icc]
+    dsimp [B]
+    have he : (m:ℤ)^2003+1-(-(m:ℤ)^2003)=((2*m^2003+1:ℕ):ℤ) := by push_cast; ring
+    rw [he,Int.toNat_natCast]
+  rw [hI] at h
+  have hm1 : 1 ≤ m := by omega
+  have hp : 1≤ m^2003 := one_le_pow₀ hm1
+  have hI' : 2*m^2003+1≤ m^2004 := by
+    calc
+      _ ≤ 3*m^2003 := by omega
+      _ ≤ m*m^2003 := Nat.mul_le_mul_right _ (by omega)
+      _ = _ := by ring
+  have hH : m^6*(2*m^2003+1)+1≤ m^2011 := by
+    calc
+      _ ≤ m^6*m^2004+1 := Nat.add_le_add_right (Nat.mul_le_mul_left _ hI') _
+      _ = m^2010+1 := by ring
+      _ ≤ 2*m^2010 := by have hh := one_le_pow₀ hm1 (n:=2010); omega
+      _ ≤ m*m^2010 := Nat.mul_le_mul_right _ (by omega)
+      _ = _ := by ring
+  calc
+    _ ≤ m^3*(m^6*(2*m^2003+1)+1)^(m+1) := h
+    _ ≤ m^3*(m^2011)^(m+1) := Nat.mul_le_mul_left _ (Nat.pow_le_pow_left hH _)
+    _ = m^(3+2011*(m+1)) := by rw [← pow_mul,← pow_add]
+    _ ≤ _ := Nat.pow_le_pow_right hm1 (by omega)
+end
+end UniformSparsestCut.SourceCount
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/VertexMeasure.lean

@@ -0,0 +1,96 @@
+import OAI.Combinatorics.SparsestCut.ContractionAverage
+
+namespace OAI
+
+universe u1
+
+open scoped BigOperators Topology NNReal RealInnerProductSpace InnerProductSpace Matrix ContDiff ENNReal
+open MeasureTheory ProbabilityTheory Set Filter Matrix
+
+noncomputable section
+
+namespace UniformSparsestCut.VertexMeasure
+open MeasureTheory Set Filter
+open scoped BigOperators RealInnerProductSpace
+noncomputable section
+variable {m N S : ℕ}
+local notation "E" => EuclideanSpace ℝ (Fin m)
+local notation "μ" => (CubePoincare.cube (m:=m))
+local instance {u : Fin S → Fin N → E} {τ : ℝ} : MeasurableSpace (RoundedCharts.Vertex u τ) := by unfold RoundedCharts.Vertex; infer_instance
+local instance {u : Fin S → Fin N → E} {τ : ℝ} : MeasurableSingletonClass (RoundedCharts.Vertex u τ) := by unfold RoundedCharts.Vertex; infer_instance
+lemma cube_measurable (R : ℝ) : MeasurableSet (RoundedCharts.cube (m:=m) R) := by
+  rw [show RoundedCharts.cube (m:=m) R=(⋂ j : Fin m, {x : E | |x j|<R}) by ext x; simp [RoundedCharts.cube]]
+  apply MeasurableSet.iInter
+  intro j
+  exact measurableSet_lt (by fun_prop) measurable_const
+lemma regular_measurable (u : Fin N → E) (τ : ℝ) : MeasurableSet {x | RoundedCharts.regular u τ x} := by
+  rw [show {x | RoundedCharts.regular u τ x}=(⋂ i : Fin N, ⋂ k : ℤ, {x : E | inner ℝ (u i) x ≠ (k:ℝ)*τ}) by ext x; simp [RoundedCharts.regular]]
+  apply MeasurableSet.iInter
+  intro i
+  apply MeasurableSet.iInter
+  intro k
+  exact (isClosed_eq (by fun_prop : Continuous (fun x : E => inner ℝ (u i) x)) continuous_const).measurableSet.compl
+lemma integer_measurable (u : Fin N → E) (τ : ℝ) : Measurable (RoundedCharts.integerLabel u τ) := by
+  apply Measurable.of_eval
+  intro i
+  exact Int.measurable_floor.comp (by fun_prop)
+open Classical in
+def label (u : Fin S → Fin N → E) (τ : ℝ) (s : Fin S) (v₀ : RoundedCharts.Vertex u τ) (x : E) : RoundedCharts.Vertex u τ :=
+  if h : x∈RoundedCharts.cube 2 ∧ RoundedCharts.regular (u s) τ x then
+    ⟨(s,RoundedCharts.integerLabel (u s) τ x),x,h.1,h.2,rfl⟩ else v₀
+lemma label_measurable (u : Fin S → Fin N → E) (τ : ℝ) (s : Fin S) (v₀ : RoundedCharts.Vertex u τ) :
+    Measurable (label u τ s v₀) := by
+  classical
+  have hh : Measurable (fun x : E => if x∈RoundedCharts.cube 2 ∧ RoundedCharts.regular (u s) τ x then
+      (s,RoundedCharts.integerLabel (u s) τ x) else v₀.val) :=
+    (measurable_const.prodMk (integer_measurable (u s) τ)).ite ((cube_measurable 2).inter (regular_measurable (u s) τ)) measurable_const
+  have hval : Measurable (fun x => (label u τ s v₀ x).val) := by
+    convert hh using 1
+    funext x
+    by_cases hgood : x ∈ RoundedCharts.cube 2 ∧ RoundedCharts.regular (u s) τ x <;>
+      simp [label, hgood]
+  exact hval.subtype_mk
+lemma ae_good (u : Fin N → E) (hu : ∀ i, u i≠0) (τ : ℝ) :
+    ∀ᵐ x : E ∂μ, x∈RoundedCharts.cube 2 ∧ RoundedCharts.regular u τ x := by
+  filter_upwards [CubeGeometry.cube_mem (m:=m), CubeGeometry.cube_ac.ae_le (RoundedCharts.ae_regular u τ hu)] with x hx hr
+  exact ⟨fun j => (hx j).trans (by norm_num),hr⟩
+lemma vertex_nonempty (u : Fin S → Fin N → E) (hu : ∀ s i, u s i≠0) (τ : ℝ) (s : Fin S) :
+    Nonempty (RoundedCharts.Vertex u τ) := by
+  obtain ⟨x,hx,hr⟩ := (ae_good (u s) (hu s) τ).exists
+  exact ⟨⟨(s,RoundedCharts.integerLabel (u s) τ x),x,hx,hr,rfl⟩⟩
+def measure (u : Fin S → Fin N → E) (τ : ℝ) (s : Fin S) (v₀ : RoundedCharts.Vertex u τ) : Measure (RoundedCharts.Vertex u τ) :=
+  (μ).map (label u τ s v₀)
+instance probability (u : Fin S → Fin N → E) (τ : ℝ) (s : Fin S) (v₀ : RoundedCharts.Vertex u τ) :
+    IsProbabilityMeasure (measure u τ s v₀) := by
+  change IsProbabilityMeasure ((μ).map (label u τ s v₀))
+  infer_instance
+lemma finite_weights {V : Type u1} [Fintype V] [MeasurableSpace V] [MeasurableSingletonClass V]
+    (ν : Measure V) [IsProbabilityMeasure ν] : (∑ v, ν.real {v})=1 := by
+  have h : (∫ _ : V, (1:ℝ) ∂ν)=∑ v, ν.real {v} • (1:ℝ) := integral_fintype (integrable_const _)
+  simp
+lemma pair_average (u : Fin S → Fin N → E) (τ : ℝ) (s : Fin S) (v₀ : RoundedCharts.Vertex u τ)
+    [Fintype (RoundedCharts.Vertex u τ)] (d : RoundedCharts.Vertex u τ → RoundedCharts.Vertex u τ → ℝ) :
+    (∑ v, ∑ w, (measure u τ s v₀).real {v}*(measure u τ s v₀).real {w}*d v w)=
+      ∫ z : E × E, d (label u τ s v₀ z.1) (label u τ s v₀ z.2) ∂(μ).prod μ := by
+  let ν := measure u τ s v₀
+  calc
+    _ = ∫ z : RoundedCharts.Vertex u τ × RoundedCharts.Vertex u τ, d z.1 z.2 ∂ν.prod ν := by
+      rw [integral_fintype Integrable.of_finite, Fintype.sum_prod_type]
+      apply Finset.sum_congr rfl
+      intro v hv
+      apply Finset.sum_congr rfl
+      intro w hw
+      rw [show ({(v,w)} : Set (RoundedCharts.Vertex u τ × RoundedCharts.Vertex u τ))={v}×ˢ{w} by ext z; simp]
+      rw [measureReal_prod_prod]
+      rfl
+    _ = _ := by
+      change (∫ z, d z.1 z.2 ∂((μ).map (label u τ s v₀)).prod ((μ).map (label u τ s v₀)))=_
+      rw [Measure.map_prod_map μ μ (label_measurable u τ s v₀) (label_measurable u τ s v₀)]
+      exact integral_map ((label_measurable u τ s v₀).prodMap (label_measurable u τ s v₀)).aemeasurable
+        (measurable_of_countable _).aestronglyMeasurable
+end
+end UniformSparsestCut.VertexMeasure
+
+end
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/WeightNormalization.lean

@@ -0,0 +1,79 @@
+/-
+Copyright (c) 2026 OpenAI. All rights reserved.
+Authors: OpenAI
+-/
+import OAI.Combinatorics.SparsestCut.FiniteWeights
+import Mathlib.Algebra.BigOperators.Field
+
+namespace OAI
+
+/-!
+# Normalization of finite weights
+
+A lower approximation to a probability law retains coordinatewise domination and
+setwise lower bounds after normalization. These are the retained-demand estimates
+in Section 7 of OpenAI's *Constant-factor hardness of uniform sparsest cut*.
+-/
+
+open scoped BigOperators
+
+namespace UniformSparsestCut.FiniteWeights
+
+variable {ι : Type*} [Fintype ι]
+
+noncomputable def normalized (l : ι → ℝ) : ι → ℝ := fun i => l i / total l
+
+theorem normalized_nonneg {l : ι → ℝ} (hl : ∀ i, 0 ≤ l i) (hL : 0 < total l) :
+    ∀ i, 0 ≤ normalized l i :=
+  fun i => div_nonneg (hl i) hL.le
+
+theorem normalized_total {l : ι → ℝ} (hL : 0 < total l) : total (normalized l) = 1 := by
+  change (∑ i, l i / total l) = 1
+  rw [← Finset.sum_div]
+  exact div_self (ne_of_gt hL)
+
+theorem normalized_mass (l : ι → ℝ) (h : ι → Bool) :
+    mass (normalized l) h = mass l h / total l := by
+  change (∑ i, l i / total l * indicator (h i)) = mass l h / total l
+  simp_rw [div_mul_eq_mul_div]
+  rw [← Finset.sum_div]
+  rfl
+
+/-- Normalization of a sufficiently large lower approximation increases each weight
+by at most a factor of two. -/
+theorem normalized_le_twice {μ l : ι → ℝ} {ε : ℝ}
+    (hμ : ∀ i, 0 ≤ μ i) (hle : ∀ i, l i ≤ μ i)
+    (hε : ε ≤ 1 / 2) (hL : 1 - ε ≤ total l) :
+    ∀ i, normalized l i ≤ 2 * μ i := by
+  have hpos : 0 < total l := by linarith
+  intro i
+  apply (div_le_iff₀ hpos).mpr
+  have hh := mul_nonneg (hμ i) (show 0 ≤ 2 * total l - 1 by linarith)
+  nlinarith only [hh, hle i]
+
+/-- Every finite event loses at most the discarded mass after normalization. -/
+theorem normalized_event_lower {μ l : ι → ℝ} {ε : ℝ}
+    (hl : ∀ i, 0 ≤ l i) (hle : ∀ i, l i ≤ μ i) (hμ₁ : total μ = 1)
+    (hε : ε ≤ 1 / 2) (hL : 1 - ε ≤ total l) (E : Finset ι) :
+    (∑ i ∈ E, μ i) - ε ≤ ∑ i ∈ E, normalized l i := by
+  have hpos : 0 < total l := by linarith
+  have hL₁ : total l ≤ 1 := by simpa [hμ₁] using total_mono hle
+  have herr : (∑ i ∈ E, (μ i - l i)) ≤ 1 - total l := by
+    calc
+      _ ≤ ∑ i, (μ i - l i) :=
+        Finset.sum_le_univ_sum_of_nonneg (fun i => sub_nonneg.mpr (hle i))
+      _ = _ := by
+        rw [Finset.sum_sub_distrib]
+        change total μ - total l = 1 - total l
+        rw [hμ₁]
+  have hgain : (∑ i ∈ E, l i) ≤ ∑ i ∈ E, normalized l i := by
+    apply Finset.sum_le_sum
+    intro i _
+    apply (le_div_iff₀ hpos).mpr
+    simpa using mul_le_mul_of_nonneg_left hL₁ (hl i)
+  rw [Finset.sum_sub_distrib] at herr
+  linarith
+
+end UniformSparsestCut.FiniteWeights
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/WeightReplacement.lean

@@ -0,0 +1,171 @@
+import OAI.Combinatorics.SparsestCut.FiniteWeights
+
+namespace OAI
+
+/-!
+# Replacing vertices of zero retained demand
+
+The replacement coupling of Section 7 of OpenAI's
+*Constant-factor hardness of uniform sparsest cut* keeps a draw of positive
+retained demand and replaces every other draw by an independent retained-demand
+draw. Its color-change probability controls the change in Boolean variance.
+-/
+
+namespace UniformSparsestCut.FiniteWeights
+
+variable {ι : Type*} [Fintype ι]
+
+/-- The original law restricted to keys with zero retained demand. -/
+noncomputable def auxiliaryWeights (w retained : ι → ℝ) : ι → ℝ := by
+  classical
+  exact fun i => if retained i = 0 then w i else 0
+
+/-- The original law restricted to keys with nonzero retained demand. -/
+noncomputable def supportedWeights (w retained : ι → ℝ) : ι → ℝ := by
+  classical
+  exact fun i => if retained i = 0 then 0 else w i
+
+/-- Retain supported draws and replace all others by an independent retained-demand draw. -/
+noncomputable def replacementWeights (w retained : ι → ℝ) : ι → ℝ :=
+  fun i => supportedWeights w retained i + total (auxiliaryWeights w retained) * retained i
+
+omit [Fintype ι] in
+theorem weights_decomposition (w retained : ι → ℝ) (i : ι) :
+    supportedWeights w retained i + auxiliaryWeights w retained i = w i := by
+  classical
+  by_cases hi : retained i = 0 <;> simp [supportedWeights, auxiliaryWeights, hi]
+
+theorem total_decomposition (w retained : ι → ℝ) :
+    total (supportedWeights w retained) + total (auxiliaryWeights w retained) = total w := by
+  rw [← total_add]
+  congr 1
+  funext i
+  exact weights_decomposition w retained i
+
+theorem mass_decomposition (w retained : ι → ℝ) (h : ι → Bool) :
+    mass (supportedWeights w retained) h + mass (auxiliaryWeights w retained) h = mass w h := by
+  rw [← mass_add]
+  congr 1
+  funext i
+  exact weights_decomposition w retained i
+
+omit [Fintype ι] in
+theorem auxiliary_nonneg {w : ι → ℝ} (hw : ∀ i, 0 ≤ w i) (retained : ι → ℝ) :
+    ∀ i, 0 ≤ auxiliaryWeights w retained i := by
+  classical
+  intro i
+  dsimp [auxiliaryWeights]
+  split
+  · exact hw i
+  · exact le_rfl
+
+omit [Fintype ι] in
+theorem supported_nonneg {w : ι → ℝ} (hw : ∀ i, 0 ≤ w i) (retained : ι → ℝ) :
+    ∀ i, 0 ≤ supportedWeights w retained i := by
+  classical
+  intro i
+  dsimp [supportedWeights]
+  split
+  · exact le_rfl
+  · exact hw i
+
+omit [Fintype ι] in
+theorem auxiliary_le {w : ι → ℝ} (hw : ∀ i, 0 ≤ w i) (retained : ι → ℝ) :
+    ∀ i, auxiliaryWeights w retained i ≤ w i := by
+  classical
+  intro i
+  dsimp [auxiliaryWeights]
+  split
+  · exact le_rfl
+  · exact hw i
+
+theorem auxiliary_total_le_one {w : ι → ℝ} (hw : ∀ i, 0 ≤ w i)
+    (hw₁ : total w = 1) (retained : ι → ℝ) : total (auxiliaryWeights w retained) ≤ 1 := by
+  simpa [hw₁] using total_mono (auxiliary_le hw retained)
+
+theorem replacement_nonneg {w retained : ι → ℝ} (hw : ∀ i, 0 ≤ w i)
+    (hr : ∀ i, 0 ≤ retained i) : ∀ i, 0 ≤ replacementWeights w retained i := by
+  intro i
+  exact add_nonneg (supported_nonneg hw retained i)
+    (mul_nonneg (total_nonneg (auxiliary_nonneg hw retained)) (hr i))
+
+theorem replacement_total {w retained : ι → ℝ} (hw₁ : total w = 1)
+    (hr₁ : total retained = 1) : total (replacementWeights w retained) = 1 := by
+  change total (fun i => supportedWeights w retained i +
+    total (auxiliaryWeights w retained) * retained i) = 1
+  rw [total_add, total_smul, hr₁, mul_one,
+    total_decomposition, hw₁]
+
+theorem replacement_mass (w retained : ι → ℝ) (h : ι → Bool) :
+    mass (replacementWeights w retained) h = mass (supportedWeights w retained) h +
+      total (auxiliaryWeights w retained) * mass retained h := by
+  change mass (fun i => supportedWeights w retained i +
+    total (auxiliaryWeights w retained) * retained i) h = _
+  rw [mass_add, mass_smul]
+
+/-- Domination of the replacement law before comparison with the original score law. -/
+theorem replacement_le_three {w retained : ι → ℝ} (hw : ∀ i, 0 ≤ w i)
+    (hw₁ : total w = 1) (hr : ∀ i, 0 ≤ retained i)
+    (hrep : ∀ i, 0 < retained i → w i ≤ 2 * retained i) :
+    ∀ i, replacementWeights w retained i ≤ 3 * retained i := by
+  classical
+  intro i
+  have hs : supportedWeights w retained i ≤ 2 * retained i := by
+    by_cases hi : retained i = 0
+    · simp [supportedWeights, hi]
+    · simpa [supportedWeights, hi] using hrep i (lt_of_le_of_ne (hr i) (Ne.symm hi))
+  have ha : total (auxiliaryWeights w retained) * retained i ≤ retained i := by
+    simpa using mul_le_mul_of_nonneg_right (auxiliary_total_le_one hw hw₁ retained) (hr i)
+  dsimp [replacementWeights]
+  linarith only [hs, ha]
+
+/-- The actual color-change cost of the replacement experiment bounds both signed
+changes in the probability of color one. -/
+theorem replacement_mass_change {w retained : ι → ℝ} (hw : ∀ i, 0 �� w i)
+    (hr : ∀ i, 0 ≤ retained i) (hr₁ : total retained = 1) (h : ι → Bool) :
+    mass w h - mass (replacementWeights w retained) h ≤
+        disagreement (auxiliaryWeights w retained) retained h ∧
+    mass (replacementWeights w retained) h - mass w h ≤
+        disagreement (auxiliaryWeights w retained) retained h := by
+  rw [replacement_mass, disagreement_eq, hr₁]
+  have hdec := mass_decomposition w retained h
+  have haux := auxiliary_nonneg hw retained
+  have ht : 0 ≤ 1 - mass retained h := sub_nonneg.mpr (hr₁ ▸ mass_le_total hr h)
+  have hp := mul_nonneg (mass_nonneg haux h) ht
+  have hq := mul_nonneg (sub_nonneg.mpr (mass_le_total haux h)) (mass_nonneg hr h)
+  constructor <;> nlinarith only [hdec, hp, hq]
+
+/-- Variance transfer for the replacement coupling in Section 7 of
+*Constant-factor hardness of uniform sparsest cut*.
+
+Here `w` is the counting law on clusters, `μ` the original score demand law, and
+`retained` the normalized retained demand.  Zero retained mass is allowed.
+The final term is the probability that replacement changes the color, denoted
+`L_aux` in the paper.
+-/
+theorem variance_transfer {w μ retained : ι → ℝ}
+    (hw : ∀ i, 0 ≤ w i) (hμ : ∀ i, 0 ≤ μ i) (hr : ∀ i, 0 ≤ retained i)
+    (hw₁ : total w = 1) (hμ₁ : total μ = 1) (hr₁ : total retained = 1)
+    (hret : ∀ i, retained i ≤ 2 * μ i)
+    (hrep : ∀ i, 0 < retained i → w i ≤ 2 * retained i) (h : ι → Bool) :
+    variance w h ≤ 36 * variance μ h + disagreement (auxiliaryWeights w retained) retained h := by
+  have hρ := replacement_nonneg hw hr
+  have hρ₁ := replacement_total hw₁ hr₁
+  have hdom : ∀ i, replacementWeights w retained i ≤ 6 * μ i := by
+    intro i
+    have hthree := replacement_le_three hw hw₁ hr hrep i
+    linarith only [hthree, hret i]
+  have hv : variance (replacementWeights w retained) h ≤ 36 * variance μ h := by
+    have hv' := variance_domination hρ hμ hρ₁ hμ₁ (by norm_num : (0 : ℝ) ≤ 6) hdom h
+    norm_num at hv'
+    exact hv'
+  have hd := replacement_mass_change hw hr hr₁ h
+  have hc : variance w h ≤ variance (replacementWeights w retained) h +
+      disagreement (auxiliaryWeights w retained) retained h :=
+    variance_change (mass_nonneg hw h) (hw₁ ▸ mass_le_total hw h)
+      (mass_nonneg hρ h) (hρ₁ ▸ mass_le_total hρ h) hd.1 hd.2
+  exact hc.trans (add_le_add hv le_rfl)
+
+end UniformSparsestCut.FiniteWeights
+
+end OAI

lean/OAI/Combinatorics/SparsestCut/WeightReplication.lean

@@ -0,0 +1,133 @@
+/-
+Copyright (c) 2026 OpenAI. All rights reserved.
+Authors: OpenAI
+-/
+import OAI.Combinatorics.SparsestCut.WeightReplacement
+import Mathlib.Algebra.BigOperators.Field
+import Mathlib.Algebra.Order.Archimedean.Real.Basic
+import Mathlib.Algebra.Order.Floor.Semiring
+
+namespace OAI
+
+/-!
+# Replication of finite weights
+
+Ceilings produce integer cluster sizes while giving one copy to every key of zero
+weight. The resulting counting law satisfies the multiplicative and auxiliary-mass
+estimates from Section 7 of OpenAI's *Constant-factor hardness of uniform sparsest cut*.
+-/
+
+open scoped BigOperators
+
+namespace UniformSparsestCut.FiniteWeights
+
+variable {ι : Type*} [Fintype ι]
+
+noncomputable def copies (K : ℕ) (p : ℝ) : ℕ := if 0 < p then ⌈(K : ℝ) * p⌉₊ else 1
+
+noncomputable def population (K : ℕ) (p : ι → ℝ) : ℕ := ∑ i, copies K (p i)
+
+noncomputable def countingWeights (K : ℕ) (p : ι → ℝ) : ι → ℝ :=
+  fun i => (copies K (p i) : ℝ) / population K p
+
+omit [Fintype ι] in
+theorem copies_zero (K : ℕ) : copies K 0 = 1 := by simp [copies]
+
+omit [Fintype ι] in
+theorem copies_pos (K : ℕ) (hK : 0 < K) (p : ℝ) : 0 < copies K p := by
+  by_cases hp : 0 < p
+  · simpa [copies, hp] using Nat.ceil_pos.mpr (mul_pos (Nat.cast_pos.mpr hK) hp)
+  · simp [copies, hp]
+
+omit [Fintype ι] in
+theorem copies_lower (K : ℕ) {p : ℝ} (hp : 0 ≤ p) : (K : ℝ) * p ≤ copies K p := by
+  by_cases hpos : 0 < p
+  · simpa [copies, hpos] using Nat.le_ceil ((K : ℝ) * p)
+  · have heq : p = 0 := le_antisymm (le_of_not_gt hpos) hp
+    simp [heq, copies_zero]
+
+omit [Fintype ι] in
+theorem copies_upper (K : ℕ) {p : ℝ} (hp : 0 ≤ p) : (copies K p : ℝ) ≤ (K : ℝ) * p + 1 := by
+  by_cases hpos : 0 < p
+  · simpa [copies, hpos] using (Nat.ceil_lt_add_one (mul_nonneg (Nat.cast_nonneg K) hp)).le
+  · have heq : p = 0 := le_antisymm (le_of_not_gt hpos) hp
+    simp [heq, copies_zero]
+
+theorem population_eq_total (K : ℕ) (p : ι → ℝ) :
+    (population K p : ℝ) = total (fun i => (copies K (p i) : ℝ)) := by
+  simp [population, total]
+
+theorem population_bounds (K : ℕ) {p : ι → ℝ} (hp : ∀ i, 0 ≤ p i) (hp₁ : total p = 1) :
+    (K : ℝ) ≤ population K p ∧ (population K p : ℝ) ≤ K + Fintype.card ι := by
+  constructor
+  · calc
+      (K : ℝ) = total (fun i => (K : ℝ) * p i) := by rw [total_smul, hp₁, mul_one]
+      _ ≤ total (fun i => (copies K (p i) : ℝ)) := total_mono (fun i => copies_lower K (hp i))
+      _ = _ := (population_eq_total K p).symm
+  · calc
+      (population K p : ℝ) = total (fun i => (copies K (p i) : ℝ)) := population_eq_total K p
+      _ ≤ total (fun i => (K : ℝ) * p i + 1) := total_mono (fun i => copies_upper K (hp i))
+      _ = _ := by rw [total_add, total_smul, hp₁, mul_one]; simp [total]
+
+theorem population_pos (K : ℕ) (hK : 0 < K) {p : ι → ℝ}
+    (hp : ∀ i, 0 ≤ p i) (hp₁ : total p = 1) : (0 : ℝ) < population K p :=
+  lt_of_lt_of_le (Nat.cast_pos.mpr hK) (population_bounds K hp hp₁).1
+
+theorem counting_nonneg (K : ℕ) (p : ι → ℝ) : ∀ i, 0 ≤ countingWeights K p i := by
+  intro i
+  exact div_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _)
+
+theorem counting_total (K : ℕ) (hK : 0 < K) {p : ι → ℝ}
+    (hp : ∀ i, 0 ≤ p i) (hp₁ : total p = 1) : total (countingWeights K p) = 1 := by
+  change (∑ i, (copies K (p i) : ℝ) / population K p) = 1
+  rw [← Finset.sum_div]
+  change total (fun i => (copies K (p i) : ℝ)) / population K p = 1
+  rw [← population_eq_total]
+  exact div_self (ne_of_gt (population_pos K hK hp hp₁))
+
+/-- On a key of positive weight, the counting law lies within a factor of two
+of the original probability law. -/
+theorem counting_bounds (K : ℕ) (hK : 0 < K) {p : ι → ℝ}
+    (hp : ∀ i, 0 ≤ p i) (hp₁ : total p = 1) (hKm : Fintype.card ι ≤ K)
+    (hKp : ∀ i, 0 < p i → 1 ≤ (K : ℝ) * p i) (i : ι) (hpi : 0 < p i) :
+    p i / 2 ≤ countingWeights K p i ∧ countingWeights K p i ≤ 2 * p i := by
+  have hN₀ := population_pos K hK hp hp₁
+  have hN := population_bounds K hp hp₁
+  have hKm' : (Fintype.card ι : ℝ) ≤ K := by exact_mod_cast hKm
+  have hN₂ : (population K p : ℝ) ≤ 2 * K := by linarith only [hN.2, hKm']
+  have hlow := copies_lower K (hp i)
+  have hupp := copies_upper K (hp i)
+  have hmin := hKp i hpi
+  constructor
+  · apply (le_div_iff₀ hN₀).mpr
+    have hn := mul_le_mul_of_nonneg_right hN₂ (hp i)
+    nlinarith only [hn, hlow]
+  · apply (div_le_iff₀ hN₀).mpr
+    have hn := mul_le_mul_of_nonneg_right hN.1 (hp i)
+    nlinarith only [hn, hmin, hupp]
+
+/-- The total counting mass of auxiliary (zero-retained-demand) vertices. -/
+theorem auxiliary_counting_bound (K : ℕ) (hK : 0 < K) {p : ι → ℝ} {κ : ℝ}
+    (hp : ∀ i, 0 ≤ p i) (hp₁ : total p = 1) (hκ : 0 < κ)
+    (hKlarge : 4 * κ * Fintype.card ι ≤ K) :
+    total (auxiliaryWeights (countingWeights K p) p) ≤ 1 / (4 * κ) := by
+  classical
+  have hN₀ := population_pos K hK hp hp₁
+  have hN := (population_bounds K hp hp₁).1
+  have ha : ∀ i, auxiliaryWeights (countingWeights K p) p i ≤ 1 / population K p := by
+    intro i
+    by_cases hi : p i = 0
+    · simp [auxiliaryWeights, hi, countingWeights, copies_zero]
+    · simp [auxiliaryWeights, hi, le_of_lt hN₀]
+  have hasum : total (auxiliaryWeights (countingWeights K p) p) ≤
+      (Fintype.card ι : ℝ) / population K p := by
+    simpa [total, div_eq_mul_inv] using total_mono ha
+  have hpop : 4 * κ * Fintype.card ι ≤ (population K p : ℝ) := hKlarge.trans hN
+  have hbound : (Fintype.card ι : ℝ) / population K p ≤ 1 / (4 * κ) := by
+    apply (div_le_div_iff₀ hN₀ (mul_pos (by norm_num : (0 : ℝ) < 4) hκ)).mpr
+    nlinarith only [hpop]
+  exact hasum.trans hbound
+
+end UniformSparsestCut.FiniteWeights
+
+end OAI