import Mathlib

namespace OAI

section

namespace PlanarL1.FiniteRandom

attribute [local instance] Classical.propDecidable

noncomputable def event {Ω : Type*} [Fintype Ω] (P : Ω → Prop) : Finset Ω := by
  classical
  exact Finset.univ.filter P

lemma mem_event {Ω : Type*} [Fintype Ω] (P : Ω → Prop) (w : Ω) : w ∈ event P ↔ P w := by
  classical
  simp [event]

noncomputable def prob {Ω : Type*} [Fintype Ω] (P : Ω → Prop) : ℝ := by
  classical
  exact ((event P).card : ℝ) / Fintype.card Ω

lemma prob_nonneg {Ω : Type*} [Fintype Ω] (P : Ω → Prop) : 0 ≤ prob P := by
  unfold prob
  positivity

lemma prob_eq_sum {Ω : Type*} [Fintype Ω] (P : Ω → Prop) :
    prob P = (∑ w, if P w then (1 : ℝ) else 0) / Fintype.card Ω := by
  classical
  simp [prob, event, Finset.sum_boole]

lemma prob_mono {Ω : Type*} [Fintype Ω] {P Q : Ω → Prop} (h : ∀ w, P w → Q w) :
    prob P ≤ prob Q := by
  classical
  apply div_le_div_of_nonneg_right _ (Nat.cast_nonneg _)
  exact_mod_cast Finset.card_le_card (show event P ⊆ event Q from
    fun w hw => (mem_event Q w).mpr (h w ((mem_event P w).mp hw)))

lemma prob_equiv {Ω Λ : Type*} [Fintype Ω] [Fintype Λ] (e : Ω ≃ Λ) (P : Λ → Prop) :
    prob (fun w => P (e w)) = prob P := by
  classical
  rw [prob_eq_sum, prob_eq_sum, Fintype.card_congr e]
  exact congrArg (fun z : ℝ => z / Fintype.card Λ)
    (e.sum_comp (fun z : Λ => if P z then (1 : ℝ) else 0))

lemma prob_prod {Ω Λ : Type*} [Fintype Ω] [Fintype Λ] (P : Ω × Λ → Prop) :
    prob P = (∑ w : Ω, prob (fun z : Λ => P (w,z))) / Fintype.card Ω := by
  classical
  simp only [prob_eq_sum, Fintype.sum_prod_type, Fintype.card_prod, Nat.cast_mul]
  rw [← Finset.sum_div]
  ring

lemma prob_prod_bound {Ω Λ : Type*} [Fintype Ω] [Nonempty Ω] [Fintype Λ]
    (P : Ω × Λ → Prop) {b : ℝ} (h : ∀ w, prob (fun z : Λ => P (w,z)) ≤ b) :
    prob P ≤ b := by
  rw [prob_prod]
  have hc : (0 : ℝ) < Fintype.card Ω := by exact_mod_cast Fintype.card_pos
  apply (div_le_iff₀ hc).mpr
  calc
    ∑ w : Ω, prob (fun z : Λ => P (w,z)) ≤ ∑ _w : Ω, b := Finset.sum_le_sum (fun w _ => h w)
    _ = b * Fintype.card Ω := by simp [mul_comm]

lemma prob_union_bound {Ω ι : Type*} [Fintype Ω] (S : Finset ι) (P : ι → Ω → Prop) :
    prob (fun w => ∃ i ∈ S, P i w) ≤ ∑ i ∈ S, prob (P i) := by
  classical
  unfold prob
  rw [← Finset.sum_div]
  apply div_le_div_of_nonneg_right _ (Nat.cast_nonneg _)
  have he : event (fun w => ∃ i ∈ S, P i w) =
      S.biUnion (fun i => event (P i)) := by
    ext w
    simp [mem_event]
  rw [he]
  exact_mod_cast (Finset.card_biUnion_le :
    (S.biUnion (fun i => event (P i))).card ≤
      ∑ i ∈ S, (event (P i)).card)

/-- Cardinality of a grid subset is controlled by the span of its indices. -/
lemma grid_card_span (s : Finset ℕ) {a b : ℕ} (h : ∀ i ∈ s, a ≤ i ∧ i ≤ b) :
    s.card ≤ b + 1 - a := by
  have hs : s ⊆ Finset.Icc a b := fun i hi => Finset.mem_Icc.mpr (h i hi)
  simpa using Finset.card_le_card hs

/-- An interval of radius t meets at most 2t/step+1 equally spaced points.
This argument is exact and includes both endpoints of the grid. -/
lemma grid_count (m : ℕ) {step t : ℝ} (hstep : 0 < step) (ht : 0 ≤ t) (c : ℝ) :
    ((event (fun i : Fin (m + 1) => |c + step * i.val| ≤ t)).card : ℝ) * step ≤
      2 * t + step := by
  classical
  let A := event (fun i : Fin (m + 1) => |c + step * i.val| ≤ t)
  by_cases hA : A.Nonempty
  · let a := A.min' hA
    let b := A.max' hA
    have ha : a ∈ A := A.min'_mem hA
    have hb : b ∈ A := A.max'_mem hA
    have hab : a.val ≤ b.val := A.min'_le b hb
    have hsub : A.image Fin.val ⊆ Finset.Icc a.val b.val := by
      rintro i hi
      obtain ⟨z, hz, rfl⟩ := Finset.mem_image.mp hi
      exact Finset.mem_Icc.mpr ⟨A.min'_le z hz, A.le_max' z hz⟩
    have hcard : A.card ≤ b.val + 1 - a.val := by
      have hc := Finset.card_le_card hsub
      simpa only [Finset.card_image_of_injective _ Fin.val_injective, Nat.card_Icc] using hc
    have hcard' : (A.card : ℝ) ≤ (b.val : ℝ) - a.val + 1 := by
      have he : b.val + 1 - a.val + a.val = b.val + 1 := Nat.sub_add_cancel (by omega)
      have hh : (b.val + 1 - a.val : ℕ) + a.val ≤ b.val + 1 := he.le
      have hi : A.card + a.val ≤ b.val + 1 := by omega
      have hir : (A.card : ℝ) + a.val ≤ (b.val : ℝ) + 1 := by exact_mod_cast hi
      linarith
    have ham : |c + step * a.val| ≤ t := (mem_event _ a).mp ha
    have hbm : |c + step * b.val| ≤ t := (mem_event _ b).mp hb
    have ha' := (abs_le.mp ham).1
    have hb' := (abs_le.mp hbm).2
    have hm := mul_le_mul_of_nonneg_right hcard' hstep.le
    change (A.card : ℝ) * step ≤ 2 * t + step
    nlinarith
  · have he : A = ∅ := Finset.not_nonempty_iff_eq_empty.mp hA
    change (A.card : ℝ) * step ≤ 2 * t + step
    rw [he]
    simp only [Finset.card_empty, Nat.cast_zero, zero_mul]
    linarith

/-- Uniform endpoint grid estimate in the normalization used by the paper. -/
lemma grid_probability (m : ℕ) (hm : 0 < m) {q t : ℝ} (hq : 0 < q) (ht : 0 ≤ t) (c : ℝ) :
    prob (fun i : Fin (m + 1) => |c + q / m * i.val| ≤ t) ≤ (2 * t + q / m) / q := by
  have hm' : (0 : ℝ) < m := by exact_mod_cast hm
  have hs : 0 < q / m := div_pos hq hm'
  have hcount := grid_count m hs ht c
  have hc : (0 : ℝ) < (m + 1 : ℕ) := by positivity
  unfold prob
  rw [Fintype.card_fin]
  apply (div_le_iff₀ hc).mpr
  rw [div_mul_eq_mul_div]
  apply (le_div_iff₀ hq).mpr
  have hn : (0 : ℝ) ≤ (event (fun i : Fin (m + 1) => |c + q / m * i.val| ≤ t)).card :=
    Nat.cast_nonneg _
  have hh := mul_le_mul_of_nonneg_right hcount hm'.le
  have hmul : q / (m : ℝ) * m = q := div_mul_cancel₀ q (ne_of_gt hm')
  rw [mul_assoc, hmul] at hh
  push_cast
  nlinarith

end PlanarL1.FiniteRandom

namespace PlanarL1.FiniteRandom

attribute [local instance] Classical.propDecidable

/-- Independent uniform grid coordinates can be exposed one at a time by an
actual equivalence of finite sample spaces. -/
lemma coordinate_probability {I : Type*} [Fintype I] [DecidableEq I]
    (i : I) (m : ℕ) (hm : 0 < m) {q t : ℝ} (hq : 0 < q) (ht : 0 ≤ t)
    (F : (I → Fin (m + 1)) → ℝ)
    (hF : ∀ α : I → Fin (m + 1), ∃ c : ℝ,
      (∀ r : Fin (m + 1), F (Function.update α i r) = c + q / m * r.val) ∨
      (∀ r : Fin (m + 1), F (Function.update α i r) = c - q / m * r.val)) :
    prob (fun α => |F α| ≤ t) ≤ (2 * t + q / m) / q := by
  classical
  let e : (I → Fin (m + 1)) ≃ ({j : I // j ≠ i} → Fin (m + 1)) × Fin (m + 1) :=
    (Equiv.funSplitAt i (Fin (m + 1))).trans (Equiv.prodComm _ _)
  have he := prob_equiv e.symm (fun α => |F α| ≤ t)
  rw [← he]
  apply prob_prod_bound
  intro rest
  let α : I → Fin (m + 1) := e.symm (rest, 0)
  have hu (r : Fin (m + 1)) : e.symm (rest,r) = Function.update α i r := by
    funext j
    by_cases hj : j = i
    · subst j
      simp [e, α, Equiv.funSplitAt_symm_apply]
    · simp [e, α, Equiv.funSplitAt_symm_apply, hj]
  obtain ⟨c, hc⟩ := hF α
  rcases hc with hc | hc
  · have hp := prob_mono (fun r (hr : |F (e.symm (rest,r))| ≤ t) =>
      (show |c + q / m * r.val| ≤ t by simpa only [hu r, hc r] using hr))
    exact hp.trans (grid_probability m hm hq ht c)
  · have hp := prob_mono (fun r (hr : |F (e.symm (rest,r))| ≤ t) =>
      (show |-c + q / m * r.val| ≤ t by
        rw [hu r, hc r] at hr
        rw [show -c + q / m * r.val = -(c - q / m * r.val) by ring, abs_neg]
        exact hr))
    exact hp.trans (grid_probability m hm hq ht (-c))

lemma prob_false {Ω : Type*} [Fintype Ω] : prob (fun _ : Ω => False) = 0 := by
  simp [prob, event]

lemma prob_pair_bound {Ω ι : Type*} [Fintype Ω] [DecidableEq ι]
    (S : Finset ι) (P : ι → ι → Ω → Prop) {b : ℝ} (hb : 0 ≤ b)
    (h : ∀ i ∈ S, ∀ j ∈ S, i ≠ j → prob (P i j) ≤ b) :
    prob (fun w => ∃ i ∈ S, ∃ j ∈ S, i ≠ j ∧ P i j w) ≤ (S.card : ℝ)^2 * b := by
  classical
  have he : (fun w => ∃ i ∈ S, ∃ j ∈ S, i ≠ j ∧ P i j w) =
      (fun w => ∃ ij ∈ S ×ˢ S, ij.1 ≠ ij.2 ∧ P ij.1 ij.2 w) := by
    funext w
    simp only [Finset.mem_product, Prod.exists]
    aesop
  rw [he]
  calc
    prob (fun w => ∃ ij ∈ S ×ˢ S, ij.1 ≠ ij.2 ∧ P ij.1 ij.2 w) ≤
        ∑ ij ∈ S ×ˢ S, prob (fun w => ij.1 ≠ ij.2 ∧ P ij.1 ij.2 w) := prob_union_bound _ _
    _ ≤ ∑ _ij ∈ S ×ˢ S, b := by
      apply Finset.sum_le_sum
      intro ij hij
      by_cases heq : ij.1 = ij.2
      · have hz : prob (fun w => ij.1 ≠ ij.2 ∧ P ij.1 ij.2 w) = 0 := by
          simpa only [heq, ne_eq, not_true_eq_false, false_and] using (prob_false (Ω := Ω))
        rw [hz]
        exact hb
      · exact (prob_mono (fun _ hw => hw.2)).trans
          (h ij.1 (Finset.mem_product.mp hij).1 ij.2 (Finset.mem_product.mp hij).2 heq)
    _ = (S.card : ℝ)^2 * b := by simp [pow_two]

end PlanarL1.FiniteRandom

end

section

namespace PlanarL1.FiniteRandom
lemma prob_prod_bound_left {Ω Λ : Type*} [Fintype Ω] [Fintype Λ] [Nonempty Λ]
    (P : Ω × Λ → Prop) {b : ℝ} (h : ∀ z, prob (fun w : Ω => P (w,z)) ≤ b) :
    prob P ≤ b := by
  rw [← prob_equiv (Equiv.prodComm Λ Ω) P]
  exact prob_prod_bound _ h
end PlanarL1.FiniteRandom


end

section

namespace PlanarL1.FiniteRandom

/-- Expose one independent finite coordinate, retaining every other coordinate.
This is the conditional probability step used between distinct seed groups. -/
lemma prob_update_bound {I Ω : Type*} [Fintype I] [DecidableEq I]
    [Fintype Ω] [Nonempty Ω] (i : I) (P : (I → Ω) → Prop) {b : ℝ}
    (h : ∀ α, prob (fun r : Ω => P (Function.update α i r)) ≤ b) :
    prob P ≤ b := by
  classical
  let e : (I → Ω) ≃ ({j : I // j ≠ i} → Ω) × Ω :=
    (Equiv.funSplitAt i Ω).trans (Equiv.prodComm _ _)
  rw [← prob_equiv e.symm P]
  apply prob_prod_bound
  intro rest
  let α : I → Ω := e.symm (rest, Classical.arbitrary Ω)
  have hu (r : Ω) : e.symm (rest,r) = Function.update α i r := by
    funext j
    by_cases hj : j=i
    · subst j; simp [e,α,Equiv.funSplitAt_symm_apply]
    · simp [e,α,Equiv.funSplitAt_symm_apply,hj]
  simpa only [hu] using h α

end PlanarL1.FiniteRandom


end

section

namespace PlanarL1.FiniteRandom
attribute [local instance] Classical.propDecidable

lemma prob_singleton {Ω : Type*} [Fintype Ω] (x : Ω) :
    prob (fun ω => ω=x) = 1/(Fintype.card Ω : ℝ) := by
  classical
  have he : event (fun ω : Ω => ω=x)={x} := by
    ext ω
    simp only [mem_event,Finset.mem_singleton]
  rw [prob,he]
  simp

/-- Exact probability of any finite prescribed set of independent fair coins.
Unprescribed coins are unrestricted, so their number does not affect the bound. -/
lemma prob_prescribed {I : Type*} [Fintype I] (S : Finset I) (b : I → Bool) :
    prob (fun ω : I → Bool => ∀ i ∈ S, ω i=b i) = 1/(2:ℝ)^S.card := by
  classical
  let e : (I → Bool) ≃ ({i : I // i ∉ S} → Bool) × ({i : I // i ∈ S} → Bool) :=
    (Equiv.piEquivPiSubtypeProd (fun i => i ∈ S) (fun _ => Bool)).trans (Equiv.prodComm _ _)
  let f : {i : I // i ∈ S} → Bool := fun i => b i
  have he (ω : ({i : I // i ∉ S} → Bool) × ({i : I // i ∈ S} → Bool)) :
      (∀ i ∈ S, e.symm ω i=b i) ↔ ω.2=f := by
    constructor
    · intro h
      funext i
      simpa [e,f,Equiv.piEquivPiSubtypeProd] using h i i.property
    · intro h i hi
      simpa [e,f,Equiv.piEquivPiSubtypeProd,hi] using congrFun h ⟨i,hi⟩
  rw [← prob_equiv e.symm (fun ω : I → Bool => ∀ i ∈ S, ω i=b i)]
  simp_rw [he]
  rw [prob_prod]
  simp_rw [prob_singleton]
  have hc : (Fintype.card ({i : I // i ∉ S} → Bool) : ℝ) ≠ 0 := by positivity
  simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul]
  rw [mul_div_cancel_left₀ _ hc]
  simp

lemma prob_two_coins {I : Type*} [Fintype I] (i j : I) (hij : i ≠ j) (a b : Bool) :
    prob (fun ω : I → Bool => ω i=a ∧ ω j=b) = (1:ℝ)/4 := by
  classical
  have h := prob_prescribed ({i,j} : Finset I) (Function.update (fun _ => b) i a)
  have hp (ω : I → Bool) : (∀ k ∈ ({i,j} : Finset I),
      ω k=Function.update (fun _ => b) i a k) ↔ ω i=a ∧ ω j=b := by
    simp [Function.update,Ne.symm hij]
  have hc : ({i,j} : Finset I).card=2 := by simp [hij]
  simpa only [hp,hc,pow_two,show (2:ℝ)*2=4 by norm_num] using h

/-- Any event forced by at most k independently prescribed group/cell coins
has probability at least 2⁻ᵏ. -/
lemma prob_at_least_prescription {I : Type*} [Fintype I]
    (S : Finset I) (b : I → Bool) (P : (I → Bool) → Prop) {k : ℕ}
    (hk : S.card ≤ k) (h : ∀ ω, (∀ i ∈ S, ω i=b i) → P ω) :
    1/(2:ℝ)^k ≤ prob P := by
  calc
    _ ≤ 1/(2:ℝ)^S.card := by
      apply one_div_le_one_div_of_le (by positivity)
      exact pow_le_pow_right₀ (by norm_num) hk
    _ = prob (fun ω : I → Bool => ∀ i ∈ S, ω i=b i) := (prob_prescribed S b).symm
    _ ≤ prob P := prob_mono h

end PlanarL1.FiniteRandom



end

end OAI