import OAI.Combinatorics.ListHadwiger.Fractional

namespace OAI

namespace LinearListHadwiger.Fractional
open scoped BigOperators
variable {V : Type} [Fintype V] [DecidableEq V]

lemma Dual.extend {G : SimpleGraph V} {S : Set V} [DecidablePred (· ∈ S)] {w : S → ℝ}
    (h : Dual (G.induce S) w) :
    Dual G (fun v => if hv : v ∈ S then w ⟨v,hv⟩ else 0) := by
  classical
  refine ⟨?_,?_⟩
  · intro v
    dsimp only
    split_ifs
    · exact h.1 _
    · exact le_rfl
  · intro I hI
    let J : Finset S := Finset.univ.filter fun v => v.val ∈ I
    have hJ : Stable (G.induce S) J := by
      intro v hv u hu hadj
      exact hI _ (Finset.mem_filter.mp hv).2 _ (Finset.mem_filter.mp hu).2 hadj
    have hs : (∑ v ∈ I, if hv : v ∈ S then w ⟨v,hv⟩ else 0) = ∑ v ∈ J, w v := by
      calc
        _ = ∑ v ∈ I.filter (· ∈ S), if hv : v ∈ S then w ⟨v,hv⟩ else 0 := by
          rw [Finset.sum_filter]
          apply Finset.sum_congr rfl
          intro v _
          by_cases hv : v ∈ S <;> simp [hv]
        _ = _ := by
          apply Finset.sum_bij (fun v hv => (⟨v,(Finset.mem_filter.mp hv).2⟩ : S))
          · intro v hv
            exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,(Finset.mem_filter.mp hv).1⟩
          · intro v hv u hu he
            exact congrArg Subtype.val he
          · intro v hv
            exact ⟨v.val,Finset.mem_filter.mpr ⟨(Finset.mem_filter.mp hv).2,v.property⟩,rfl⟩
          · intro v hv
            simp only [dite_eq_left (Finset.mem_filter.mp hv).2]
    rw [hs]
    exact h.2 J hJ

theorem induced_duality (G : SimpleGraph V) (S : Finset V) :
    ∃ w : V → ℝ, Dual G w ∧ (∀ v ∉ S, w v = 0) ∧
      (∑ v ∈ S, w v) = number (G.induce (S : Set V)) := by
  classical
  obtain ⟨w,hw,heq⟩ := duality (G.induce (S : Set V))
  refine ⟨fun v => if hv : v ∈ S then w ⟨v,hv⟩ else 0,hw.extend,?_,?_⟩
  · intro v hv
    simp [hv]
  · rw [← heq]
    calc
      _ = ∑ v : (S : Set V), (if hv : v.val ∈ S then w ⟨v.val,hv⟩ else 0) :=
        (Finset.sum_coe_sort S _).symm
      _ = _ := by
        apply Finset.sum_congr rfl
        intro v _
        split_ifs with hv
        · rfl
        · exact (hv v.property).elim

lemma Dual.restrict_sum {G : SimpleGraph V} {w : V → ℝ} (hw : Dual G w)
    (S : Finset V) : (∑ v ∈ S, w v) ≤ number (G.induce (S : Set V)) := by
  classical
  obtain ⟨μ,hμ,hcost⟩ := optimum_exists (G.induce (S : Set V))
  have h := weak_duality hμ (hw.comap Subtype.val Subtype.val_injective)
  rw [hcost] at h
  have he : (∑ v : (S : Set V), w v.val) = ∑ v ∈ S, w v :=
    (Finset.sum_subtype S (fun v => Iff.rfl) w).symm
  rw [he] at h
  exact h

lemma induced_number_le (G : SimpleGraph V) (S T : Finset V) :
    number (G.induce (S : Set V)) ≤ number (G.induce (T : Set V)) + (S \ T).card := by
  classical
  obtain ⟨w,hw,hzero,hmax⟩ := induced_duality G S
  have hsplit : (∑ v ∈ S, w v) = (∑ v ∈ S ∩ T, w v) + ∑ v ∈ S \ T, w v := by
    have hd : Disjoint (S ∩ T) (S \ T) := by
      apply Finset.disjoint_left.mpr
      intro v hv ht
      exact (Finset.mem_sdiff.mp ht).2 (Finset.mem_inter.mp hv).2
    rw [← Finset.sum_union hd]
    congr 1
    ext v
    simp only [Finset.mem_union,Finset.mem_inter,Finset.mem_sdiff]
    tauto
  have hT : (∑ v ∈ S ∩ T, w v) ≤ number (G.induce (T : Set V)) := by
    exact (Finset.sum_le_sum_of_subset_of_nonneg Finset.inter_subset_right
      (fun v _ _ => hw.1 v)).trans (hw.restrict_sum T)
  have hD : (∑ v ∈ S \ T, w v) ≤ (S \ T).card := by
    calc
      _ ≤ ∑ _v ∈ S \ T, (1 : ℝ) := Finset.sum_le_sum (fun v _ => hw.le_one v)
      _ = _ := by simp
  rw [← hmax,hsplit]
  linarith

lemma induced_number_abs_sub_le (G : SimpleGraph V) (S T : Finset V) :
    |number (G.induce (S : Set V)) - number (G.induce (T : Set V))| ≤
      (S \ T).card + (T \ S).card := by
  have hST := induced_number_le G S T
  have hTS := induced_number_le G T S
  rw [abs_le]
  constructor <;> linarith [Nat.cast_nonneg (α := ℝ) (S \ T).card,
    Nat.cast_nonneg (α := ℝ) (T \ S).card]

end LinearListHadwiger.Fractional

namespace LinearListHadwiger.Sampling
open scoped BigOperators
variable {ι Ω : Type} [Fintype ι] [Fintype Ω] [DecidableEq ι]

noncomputable def productMass (μ : ι → Ω → ℝ) (x : ι → Ω) : ℝ := ∏ i, μ i (x i)
noncomputable def expectation (μ f : Ω → ℝ) : ℝ := ∑ ω, μ ω * f ω
noncomputable def probability (μ : Ω → ℝ) (A : Ω → Prop) : ℝ :=
  by classical exact ∑ ω, if A ω then μ ω else 0

lemma productMass_nonneg {ι Ω : Type} [Fintype ι] [Fintype Ω] [DecidableEq ι] {μ : ι → Ω → ℝ} (h : ∀ i ω, 0 ≤ μ i ω) (x : ι → Ω) :
    0 ≤ productMass μ x := Finset.prod_nonneg (fun i _ => h i _)

lemma productMass_sum {μ : ι → Ω → ℝ} (h : ∀ i, ∑ ω, μ i ω = 1) :
    ∑ x, productMass μ x = 1 := by
  classical
  change (∑ x : ι → Ω, ∏ i, μ i (x i)) = 1
  rw [← Fintype.prod_sum]
  simp [h]

lemma expectation_product (μ f : ι → Ω → ℝ) :
    expectation (productMass μ) (fun x => ∏ i, f i (x i)) =
      ∏ i, expectation (μ i) (f i) := by
  classical
  simp only [expectation,productMass,← Finset.prod_mul_distrib]
  exact (Fintype.prod_sum (ι := ι) (κ := fun _ => Ω) (fun i a => μ i a * f i a)).symm

lemma expectation_coordinate {μ : ι → Ω → ℝ} (h : ∀ i, ∑ ω, μ i ω = 1)
    (i : ι) (f : Ω → ℝ) :
    expectation (productMass μ) (fun x => f (x i)) = expectation (μ i) f := by
  classical
  have he (x : ι → Ω) : (∏ j : ι, if j = i then f (x j) else 1) = f (x i) := by simp
  calc
    _ = expectation (productMass μ) (fun x => ∏ j, if j = i then f (x j) else 1) := by
      congr 1
      funext x
      exact (he x).symm
    _ = ∏ j, expectation (μ j) (fun ω => if j = i then f ω else 1) :=
      expectation_product μ (fun j ω => if j = i then f ω else 1)
    _ = expectation (μ i) f := by
      rw [Finset.prod_eq_single i]
      · simp
      · intro j _ hji
        simp [expectation,hji,h]
      · simp

lemma expectation_pair {μ : ι → Ω → ℝ} (h : ∀ i, ∑ ω, μ i ω = 1)
    {i j : ι} (hij : i ≠ j) (f g : Ω → ℝ) :
    expectation (productMass μ) (fun x => f (x i) * g (x j)) =
      expectation (μ i) f * expectation (μ j) g := by
  classical
  have he (x : ι → Ω) :
      (∏ k : ι, (if k = i then f (x k) else 1) * (if k = j then g (x k) else 1)) =
        f (x i) * g (x j) := by rw [Finset.prod_mul_distrib]; simp
  calc
    _ = expectation (productMass μ) (fun x => ∏ k,
        (if k = i then f (x k) else 1) * (if k = j then g (x k) else 1)) := by
      congr 1
      funext x
      exact (he x).symm
    _ = ∏ k, expectation (μ k) (fun ω =>
        (if k = i then f ω else 1) * (if k = j then g ω else 1)) := expectation_product μ
          (fun k ω => (if k = i then f ω else 1) * (if k = j then g ω else 1))
    _ = ∏ k, (if k = i then expectation (μ i) f else 1) *
        (if k = j then expectation (μ j) g else 1) := by
      apply Finset.prod_congr rfl
      intro k _
      by_cases hki : k = i
      · subst k; simp [hij,expectation]
      · by_cases hkj : k = j
        · subst k; simp [hki,expectation]
        · simp [hki,hkj,expectation,h]
    _ = _ := by rw [Finset.prod_mul_distrib]; simp

lemma expectation_nonneg {μ f : Ω → ℝ} (hμ : ∀ ω, 0 ≤ μ ω) (hf : ∀ ω, 0 ≤ f ω) :
    0 ≤ expectation μ f := Finset.sum_nonneg fun ω _ => mul_nonneg (hμ ω) (hf ω)

lemma expectation_mono {μ f g : Ω → ℝ} (hμ : ∀ ω, 0 ≤ μ ω) (hfg : ∀ ω, f ω ≤ g ω) :
    expectation μ f ≤ expectation μ g :=
  Finset.sum_le_sum fun ω _ => mul_le_mul_of_nonneg_left (hfg ω) (hμ ω)

lemma expectation_sum {κ : Type} (s : Finset κ) (μ : Ω → ℝ) (f : κ → Ω → ℝ) :
    expectation μ (fun ω => ∑ k ∈ s, f k ω) = ∑ k ∈ s, expectation μ (f k) := by
  simp only [expectation,Finset.mul_sum]
  exact Finset.sum_comm

lemma probability_eq_expectation (μ : Ω → ℝ) (A : Ω → Prop) [DecidablePred A] :
    probability μ A = expectation μ (fun ω => if A ω then 1 else 0) := by
  classical
  simp only [probability,expectation]
  apply Finset.sum_congr rfl
  intro ω _
  split_ifs <;> simp

lemma probability_nonneg {μ : Ω → ℝ} (hμ : ∀ ω, 0 ≤ μ ω) (A : Ω → Prop) :
    0 ≤ probability μ A := by
  classical
  exact Finset.sum_nonneg fun ω _ => by split_ifs; exact hμ ω; exact le_rfl

lemma probability_mono {μ : Ω → ℝ} (hμ : ∀ ω, 0 ≤ μ ω) {A B : Ω → Prop}
    (hAB : ∀ ω, A ω → B ω) : probability μ A ≤ probability μ B := by
  classical
  apply Finset.sum_le_sum
  intro ω _
  by_cases hA : A ω
  · simp [hA,hAB ω hA]
  · simp only [hA,ite_false]
    split_ifs; exact hμ ω; exact le_rfl

lemma probability_coordinate {μ : ι → Ω → ℝ} (h : ∀ i, ∑ ω, μ i ω = 1)
    (i : ι) (A : Ω → Prop) :
    probability (productMass μ) (fun x => A (x i)) = probability (μ i) A := by
  classical
  simp_rw [probability_eq_expectation]
  exact expectation_coordinate h i (fun ω => if A ω then (1 : ℝ) else 0)

lemma probability_union_le {κ : Type} [Fintype κ] {μ : Ω → ℝ}
    (hμ : ∀ ω, 0 ≤ μ ω) (A : κ → Ω → Prop) :
    probability μ (fun ω => ∃ k, A k ω) ≤ ∑ k, probability μ (A k) := by
  classical
  simp only [probability]
  rw [Finset.sum_comm]
  apply Finset.sum_le_sum
  intro ω _
  by_cases hA : ∃ k, A k ω
  · obtain ⟨k,hk⟩ := hA
    rw [ite_eq_left ⟨k,hk⟩]
    have hh := Finset.single_le_sum (s := (Finset.univ : Finset κ))
        (f := fun k => if A k ω then μ ω else 0)
        (fun k _ => by split_ifs; exact hμ ω; exact le_rfl) (Finset.mem_univ k)
    simpa only [ite_eq_left hk] using hh
  · simp only [ite_eq_right hA]
    exact Finset.sum_nonneg (fun k _ => by split_ifs; exact hμ ω; exact le_rfl)

lemma probability_or_le {μ : Ω → ℝ} (hμ : ∀ ω, 0 ≤ μ ω) (A B : Ω → Prop) :
    probability μ (fun ω => A ω ∨ B ω) ≤ probability μ A + probability μ B := by
  classical
  simp only [probability,← Finset.sum_add_distrib]
  apply Finset.sum_le_sum
  intro ω _
  by_cases hA : A ω <;> by_cases hB : B ω <;> simp [hA,hB,hμ ω]

lemma markov {μ f : Ω → ℝ} (hμ : ∀ ω, 0 ≤ μ ω) (hf : ∀ ω, 0 ≤ f ω)
    {a : ℝ} (ha : 0 < a) :
    probability μ (fun ω => a ≤ f ω) ≤ expectation μ f / a := by
  classical
  apply (le_div_iff₀ ha).mpr
  simp only [probability,Finset.sum_mul,expectation]
  apply Finset.sum_le_sum
  intro ω _
  by_cases h : a ≤ f ω
  · simp only [ite_eq_left h]
    exact mul_le_mul_of_nonneg_left h (hμ ω)
  · simp only [ite_eq_right h,zero_mul]
    exact mul_nonneg (hμ ω) (hf ω)

lemma exists_positive_avoiding {μ : Ω → ℝ} (hμ : ∀ ω, 0 ≤ μ ω)
    (hs : ∑ ω, μ ω = 1) {A : Ω → Prop} (hA : probability μ A < 1) :
    ∃ ω, 0 < μ ω ∧ ¬A ω := by
  classical
  by_contra hn
  push Not at hn
  have he : probability μ A = 1 := by
    rw [← hs]
    apply Finset.sum_congr rfl
    intro ω _
    by_cases h : 0 < μ ω
    · simp only [ite_eq_left (hn ω h)]
    · have hz : μ ω = 0 := le_antisymm (le_of_not_gt h) (hμ ω)
      simp [hz]
  linarith

end LinearListHadwiger.Sampling

namespace LinearListHadwiger.Sampling
open scoped BigOperators
open Fractional
variable {ι Ω V : Type} [Fintype ι] [Fintype Ω] [Fintype V]
  [DecidableEq ι] [DecidableEq V]

lemma expectation_const {μ : Ω → ℝ} (hs : ∑ ω, μ ω = 1) (c : ℝ) :
    expectation μ (fun _ => c) = c := by simp [expectation,← Finset.sum_mul,hs]

noncomputable def otherCopies (W : Ω → Finset V) (i : ι) (x : ι → Ω) : Finset V :=
  (Finset.univ.erase i).biUnion fun j => W (x j)

noncomputable def privateCopy (W : Ω → Finset V) (i : ι) (x : ι → Ω) : Finset V :=
  W (x i) \ otherCopies W i x

noncomputable def collision (W : Ω → Finset V) (φ : Ω → V → ℝ) (i : ι)
    (x : ι → Ω) : ℝ := ∑ j ∈ Finset.univ.erase i, ∑ v,
      φ (x i) v * (if v ∈ W (x j) then 1 else 0)

lemma collision_nonneg {ι Ω V : Type} [Fintype ι] [Fintype Ω] [Fintype V] [DecidableEq ι] [DecidableEq V] (W : Ω → Finset V) {φ : Ω → V → ℝ}
    (hφ : ∀ ω v, 0 ≤ φ ω v) (i : ι) (x : ι → Ω) : 0 ≤ collision W φ i x := by
  apply Finset.sum_nonneg
  intro j _
  apply Finset.sum_nonneg
  intro v _
  split_ifs <;> simp [hφ]

lemma expectation_collision {μ : Ω → ℝ} (hμ : ∀ ω, 0 ≤ μ ω) (hs : ∑ ω, μ ω = 1)
    (W : Ω → Finset V) {φ : Ω → V → ℝ} (hφ : ∀ ω v, 0 ≤ φ ω v)
    (hφsum : ∀ ω, ∑ v, φ ω v ≤ 1) {p : ℝ} (hp : 0 ≤ p)
    (hmarg : ∀ v, probability μ (fun ω => v ∈ W ω) ≤ p) (i : ι) :
    expectation (productMass (fun _ : ι => μ)) (collision W φ i) ≤
      (Fintype.card ι - 1 : ℕ) * p := by
  classical
  unfold collision
  rw [expectation_sum]
  calc
    _ ≤ ∑ _j ∈ Finset.univ.erase i, p := by
      apply Finset.sum_le_sum
      intro j hj
      have hij : i ≠ j := Ne.symm (Finset.mem_erase.mp hj).1
      rw [expectation_sum]
      calc
        _ = ∑ v, expectation μ (fun ω => φ ω v) * probability μ (fun ω => v ∈ W ω) := by
          apply Finset.sum_congr rfl
          intro v _
          rw [expectation_pair (μ := fun _ : ι => μ) (f := fun ω => φ ω v)
            (g := fun ω => if v ∈ W ω then 1 else 0) (fun _ => hs) hij,
            probability_eq_expectation]
        _ ≤ ∑ v, expectation μ (fun ω => φ ω v) * p := by
          apply Finset.sum_le_sum
          intro v _
          exact mul_le_mul_of_nonneg_left (hmarg v) (expectation_nonneg hμ (fun ω => hφ ω v))
        _ = expectation μ (fun ω => ∑ v, φ ω v) * p := by
          rw [← Finset.sum_mul,expectation_sum]
        _ ≤ 1 * p := by
          apply mul_le_mul_of_nonneg_right _ hp
          exact (expectation_mono hμ hφsum).trans_eq (expectation_const hs 1)
        _ = p := one_mul p
    _ = _ := by simp

lemma sum_on_eq (S : Finset V) (f : V → ℝ) :
    (∑ v ∈ S, f v) = ∑ v, if v ∈ S then f v else 0 := by
  classical
  rw [← Finset.sum_filter]
  congr 1
  ext v
  simp

lemma private_weight_loss {ι Ω V : Type} [Fintype ι] [Fintype Ω] [Fintype V] [DecidableEq ι] [DecidableEq V] (W : Ω → Finset V) {φ : Ω → V → ℝ}
    (hφ : ∀ ω v, 0 ≤ φ ω v) (i : ι) (x : ι → Ω) :
    (∑ v ∈ W (x i), φ (x i) v) ≤
      (∑ v ∈ privateCopy W i x, φ (x i) v) + collision W φ i x := by
  classical
  rw [sum_on_eq (W (x i)) (φ (x i)),
    sum_on_eq (privateCopy W i x) (φ (x i))]
  unfold collision
  rw [Finset.sum_comm,← Finset.sum_add_distrib]
  apply Finset.sum_le_sum
  intro v _
  have hnn : 0 ≤ ∑ j ∈ Finset.univ.erase i,
      φ (x i) v * (if v ∈ W (x j) then 1 else 0) := by
    apply Finset.sum_nonneg
    intro j _
    split_ifs <;> simp [hφ]
  by_cases hv : v ∈ W (x i)
  · simp only [ite_eq_left hv]
    by_cases hpr : v ∈ privateCopy W i x
    · simp only [ite_eq_left hpr]
      linarith
    · simp only [ite_eq_right hpr,zero_add]
      have hvO : v ∈ otherCopies W i x := by
        simpa only [privateCopy,Finset.mem_sdiff,hv,true_and,not_not] using hpr
      obtain ⟨j,hj,hvj⟩ := Finset.mem_biUnion.mp hvO
      have hh := Finset.single_le_sum
        (s := Finset.univ.erase i)
        (f := fun j => φ (x i) v * (if v ∈ W (x j) then 1 else 0))
        (fun j _ => by split_ifs <;> simp [hφ]) hj
      simpa only [ite_eq_left hvj,mul_one] using hh
  · simp only [ite_eq_right hv]
    have hc : 0 ≤ (if v ∈ privateCopy W i x then φ (x i) v else 0) := by
      split_ifs; exact hφ _ _; exact le_rfl
    linarith

lemma privateCopies_disjoint {ι Ω V : Type} [Fintype ι] [Fintype Ω] [Fintype V] [DecidableEq ι] [DecidableEq V] (W : Ω → Finset V) (x : ι → Ω) {i j : ι} (hij : i ≠ j) :
    Disjoint (privateCopy W i x) (privateCopy W j x) := by
  classical
  apply Finset.disjoint_left.mpr
  intro v hvi hvj
  obtain ⟨hi,hni⟩ := Finset.mem_sdiff.mp hvi
  obtain ⟨hj,hnj⟩ := Finset.mem_sdiff.mp hvj
  apply hni
  exact Finset.mem_biUnion.mpr ⟨j,Finset.mem_erase.mpr ⟨hij.symm,Finset.mem_univ _⟩,hj⟩

theorem private_fractional_failure (G : SimpleGraph V) {μ : Ω → ℝ}
    (hμ : ∀ ω, 0 ≤ μ ω) (hs : ∑ ω, μ ω = 1) (W : Ω → Finset V)
    {r p δ : ℝ} (hr : 0 < r) (hp : 0 ≤ p)
    (hmarg : ∀ v, probability μ (fun ω => v ∈ W ω) ≤ p)
    (hhigh : probability μ (fun ω => number (G.induce (W ω : Set V)) ≤ r/5) ≤ δ) :
    probability (productMass (fun _ : ι => μ))
      (fun x => ∃ i, number (G.induce (privateCopy W i x : Set V)) ≤ r/8) ≤
        (Fintype.card ι : ℝ) * δ + 4 * Fintype.card ι * (Fintype.card ι - 1 : ℕ) * p := by
  classical
  choose w hw hz heq using (fun ω => induced_duality G (W ω))
  let a : Ω → ℝ := fun ω => number (G.induce (W ω : Set V))
  let φ : Ω → V → ℝ := fun ω v => if 0 < a ω then w ω v / a ω else 0
  have hφ : ∀ ω v, 0 ≤ φ ω v := by
    intro ω v
    dsimp [φ]
    split_ifs with h
    · exact div_nonneg ((hw ω).1 v) h.le
    · exact le_rfl
  have hwtotal (ω : Ω) : (∑ v, w ω v) = a ω := by
    change (∑ v, w ω v) = number (G.induce (W ω : Set V))
    rw [← heq ω]
    symm
    apply Finset.sum_subset (Finset.subset_univ _)
    intro v _ hv
    exact hz ω v hv
  have hφsum : ∀ ω, ∑ v, φ ω v ≤ 1 := by
    intro ω
    by_cases ha : 0 < a ω
    · simp only [φ,ite_eq_left ha,← Finset.sum_div,hwtotal,div_self (ne_of_gt ha),le_refl]
    · simp [φ,ha]
  have hφW (ω : Ω) (ha : 0 < a ω) : (∑ v ∈ W ω, φ ω v) = 1 := by
    simp only [φ,ite_eq_left ha,← Finset.sum_div,heq]
    change a ω / a ω = 1
    exact div_self (ne_of_gt ha)
  let bad : ι → (ι → Ω) → Prop := fun i x =>
    a (x i) ≤ r/5 ∨ (1/4 : ℝ) ≤ collision W φ i x
  have hbad_sub (x : ι → Ω) :
      (∃ i, number (G.induce (privateCopy W i x : Set V)) ≤ r/8) → ∃ i, bad i x := by
    rintro ⟨i,hi⟩
    refine ⟨i,?_⟩
    by_contra hn
    have hh : r/5 < a (x i) := lt_of_not_ge (fun h => hn (Or.inl h))
    have hc : collision W φ i x < 1/4 := lt_of_not_ge (fun h => hn (Or.inr h))
    have ha : 0 < a (x i) := by linarith
    have hret := private_weight_loss W hφ i x
    rw [hφW (x i) ha] at hret
    have hweight : (∑ v ∈ privateCopy W i x, w (x i) v) ≤ r/8 :=
      ((hw (x i)).restrict_sum _).trans hi
    have hsum : (∑ v ∈ privateCopy W i x, φ (x i) v) =
        (∑ v ∈ privateCopy W i x, w (x i) v) / a (x i) := by
      simp only [φ,ite_eq_left ha,Finset.sum_div]
    rw [hsum] at hret
    have hpos : (3/4 : ℝ) <
        (∑ v ∈ privateCopy W i x, w (x i) v) / a (x i) := by linarith
    have hprod := (lt_div_iff₀ ha).mp hpos
    nlinarith
  have hbad (i : ι) : probability (productMass (fun _ : ι => μ)) (bad i) ≤
      δ + 4 * (Fintype.card ι - 1 : ℕ) * p := by
    have hor := probability_or_le (productMass_nonneg (fun _ => hμ))
      (fun x : ι → Ω => a (x i) ≤ r/5) (fun x => (1/4 : ℝ) ≤ collision W φ i x)
    have hfirst : probability (productMass (fun _ : ι => μ)) (fun x => a (x i) ≤ r/5) ≤ δ := by
      rw [probability_coordinate (μ := fun _ : ι => μ) (fun _ => hs) i
        (fun ω => a ω ≤ r/5)]
      exact hhigh
    have hmk := markov (productMass_nonneg (fun _ : ι => hμ)) (collision_nonneg W hφ i)
      (a := (1/4 : ℝ)) (by norm_num)
    have hexp := expectation_collision hμ hs W hφ hφsum hp hmarg i
    change probability (productMass (fun _ : ι => μ))
      (fun x => a (x i) ≤ r/5 ∨ (1/4 : ℝ) ≤ collision W φ i x) ≤ _
    linarith
  calc
    _ ≤ probability (productMass (fun _ : ι => μ)) (fun x => ∃ i, bad i x) :=
      probability_mono (productMass_nonneg (fun _ => hμ)) hbad_sub
    _ ≤ ∑ i, probability (productMass (fun _ : ι => μ)) (bad i) :=
      probability_union_le (productMass_nonneg (fun _ => hμ)) _
    _ ≤ ∑ _i : ι, (δ + 4 * (Fintype.card ι - 1 : ℕ) * p) :=
      Finset.sum_le_sum (fun i _ => hbad i)
    _ = _ := by simp; ring

end LinearListHadwiger.Sampling

end OAI