import OAI.Combinatorics.FiniteCircle.Windows

namespace OAI

namespace FiniteCircle

open scoped BigOperators List
open scoped ComplexConjugate
open RCLike Module
open Classical

structure FiniteLaw (Ω : Type*) [Fintype Ω] where
  weight : Ω → ℝ
  nonneg : ∀ ω, 0 ≤ weight ω
  total : ∑ ω, weight ω = 1

namespace FiniteLaw
variable {Ω : Type*} [Fintype Ω]

noncomputable def expect (μ : FiniteLaw Ω) (f : Ω → ℝ) : ℝ := ∑ ω, μ.weight ω * f ω

noncomputable def event (μ : FiniteLaw Ω) (P : Ω → Prop) : ℝ := by
  classical
  exact ∑ ω, if P ω then μ.weight ω else 0

theorem event_eq_expect (μ : FiniteLaw Ω) (P : Ω → Prop) [DecidablePred P] :
    μ.event P = μ.expect (fun ω => if P ω then 1 else 0) := by
  classical
  unfold event expect
  apply Finset.sum_congr rfl
  intro ω _
  by_cases h : P ω <;> simp [h]

theorem expect_nonneg (μ : FiniteLaw Ω) {f : Ω → ℝ} (hf : ∀ ω, 0 ≤ f ω) :
    0 ≤ μ.expect f := Finset.sum_nonneg (fun ω _ => mul_nonneg (μ.nonneg ω) (hf ω))

theorem expect_mono (μ : FiniteLaw Ω) {f g : Ω → ℝ} (h : ∀ ω, f ω ≤ g ω) :
    μ.expect f ≤ μ.expect g :=
  Finset.sum_le_sum (fun ω _ => mul_le_mul_of_nonneg_left (h ω) (μ.nonneg ω))

@[simp] theorem expect_const (μ : FiniteLaw Ω) (a : ℝ) : μ.expect (fun _ => a) = a := by
  simp only [expect, ← Finset.sum_mul, μ.total, one_mul]

theorem expect_add (μ : FiniteLaw Ω) (f g : Ω → ℝ) :
    μ.expect (fun ω => f ω + g ω) = μ.expect f + μ.expect g := by
  simp only [expect, mul_add, Finset.sum_add_distrib]

theorem expect_sub (μ : FiniteLaw Ω) (f g : Ω → ℝ) :
    μ.expect (fun ω => f ω - g ω) = μ.expect f - μ.expect g := by
  simp only [expect, mul_sub, Finset.sum_sub_distrib]

theorem expect_smul (μ : FiniteLaw Ω) (a : ℝ) (f : Ω → ℝ) :
    μ.expect (fun ω => a * f ω) = a * μ.expect f := by
  simp only [expect, mul_left_comm _ a, Finset.mul_sum]

theorem expect_sum {ι : Type*} (μ : FiniteLaw Ω) (s : Finset ι) (f : ι → Ω → ℝ) :
    μ.expect (fun ω => ∑ i ∈ s, f i ω) = ∑ i ∈ s, μ.expect (f i) := by
  simp only [expect, Finset.mul_sum]
  exact Finset.sum_comm

theorem event_nonneg (μ : FiniteLaw Ω) (P : Ω → Prop) : 0 ≤ μ.event P := by
  classical
  apply Finset.sum_nonneg
  intro ω _
  split <;> first | exact μ.nonneg ω | exact le_rfl

theorem event_mono (μ : FiniteLaw Ω) {P Q : Ω → Prop} (h : ∀ ω, P ω → Q ω) :
    μ.event P ≤ μ.event Q := by
  classical
  apply Finset.sum_le_sum
  intro ω _
  by_cases hp : P ω <;> by_cases hq : Q ω <;> simp [hp, hq]
  · exact (hq (h ω hp)).elim
  · exact μ.nonneg ω

@[simp] theorem event_true (μ : FiniteLaw Ω) : μ.event (fun _ => True) = 1 := by
  simp [event, μ.total]

@[simp] theorem event_false (μ : FiniteLaw Ω) : μ.event (fun _ => False) = 0 := by simp [event]

theorem event_le_one (μ : FiniteLaw Ω) (P : Ω → Prop) : μ.event P ≤ 1 := by
  simpa only [event_true] using μ.event_mono (P := P) (Q := fun _ => True) (fun _ _ => trivial)

theorem event_compl (μ : FiniteLaw Ω) (P : Ω → Prop) :
    μ.event (fun ω => ¬P ω) = 1 - μ.event P := by
  classical
  rw [← μ.total]
  unfold event
  rw [← Finset.sum_sub_distrib]
  apply Finset.sum_congr rfl
  intro ω _
  by_cases h : P ω <;> simp [h]

theorem event_exists_le_sum {ι : Type*} [Fintype ι] (μ : FiniteLaw Ω) (P : ι → Ω → Prop) :
    μ.event (fun ω => ∃ i, P i ω) ≤ ∑ i, μ.event (P i) := by
  classical
  simp only [event_eq_expect]
  rw [← μ.expect_sum]
  apply μ.expect_mono
  intro ω
  by_cases h : ∃ i, P i ω
  · obtain ⟨i, hi⟩ := h
    rw [ite_eq_left ⟨i, hi⟩]
    exact (by simpa only [ite_eq_left hi] using
      (Finset.single_le_sum (f := fun j : ι => if P j ω then (1 : ℝ) else 0)
        (fun j _ => by split <;> norm_num) (Finset.mem_univ i)))
  · simp [show ∀ i, ¬ P i ω from fun i hi => h ⟨i, hi⟩]
end FiniteLaw

noncomputable def selectionWeight {I : Type*} [Fintype I] (q : I → ℝ) (s : I → Bool) : ℝ :=
  ∏ i, if s i then 1 - q i else q i

def selectionLabel {I X : Type*} (c : I → X → Bool) (s : I → Bool) (x : X) : I → Bool :=
  fun i => s i && c i x

theorem selectionWeight_nonneg {I : Type*} [Fintype I] (q : I → ℝ)
    (hq : ∀ i, 0 ≤ q i ∧ q i ≤ 1) (s : I → Bool) : 0 ≤ selectionWeight q s := by
  apply Finset.prod_nonneg
  intro i _
  split
  · exact sub_nonneg.mpr (hq i).2
  · exact (hq i).1

theorem selectionWeight_total {I : Type*} [Fintype I] [DecidableEq I] (q : I → ℝ) :
    ∑ s : I → Bool, selectionWeight q s = 1 := by
  unfold selectionWeight
  rw [← Fintype.prod_sum (fun i (b : Bool) => if b then 1 - q i else q i)]
  simp

theorem selection_collision {I X : Type*} [Fintype I] [DecidableEq I]
    (q : I → ℝ) (c : I → X → Bool) (x y : X) :
    (∑ s : I → Bool, if selectionLabel c s x = selectionLabel c s y then selectionWeight q s else 0) =
      ∏ i, if c i x = c i y then 1 else q i := by
  classical
  have hterm (s : I → Bool) :
      (if selectionLabel c s x = selectionLabel c s y then selectionWeight q s else 0) =
      ∏ i, if (s i && c i x) = (s i && c i y) then
        (if s i then 1 - q i else q i) else 0 := by
    rw [Fintype.prod_ite_zero]
    simp only [selectionLabel, selectionWeight, funext_iff]
  simp_rw [hterm]
  rw [← Fintype.prod_sum (fun i (b : Bool) =>
    if (b && c i x) = (b && c i y) then (if b then 1 - q i else q i) else 0)]
  apply Finset.prod_congr rfl
  intro i _
  simp only [Fintype.sum_bool]
  cases hcx : c i x <;> cases hcy : c i y <;> simp

abbrev PartitionSpace (X : Type*) := (X → Bool) → Bool

theorem finite_partition {X : Type*} [Fintype X] {ρ : X → X → ℝ}
    (hρ : HasCutRepresentation ρ) (α : ℝ) (hα : 0 ≤ α) : by
  classical
  exact ∃ (μ : FiniteLaw (PartitionSpace X)) (label : PartitionSpace X → X → PartitionSpace X),
      ∀ x y, μ.event (fun ω => label ω x = label ω y) = Real.exp (-α * ρ x y) := by
  classical
  obtain ⟨a, ha, hrep⟩ := hρ
  let q : (X → Bool) → ℝ := fun c => Real.exp (-α * a c)
  have hq (c : X → Bool) : 0 ≤ q c ∧ q c ≤ 1 := by
    constructor
    · exact (Real.exp_pos _).le
    · apply Real.exp_le_one_iff.mpr
      exact mul_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr hα) (ha c)
  let μ : FiniteLaw (PartitionSpace X) :=
    ⟨selectionWeight q, selectionWeight_nonneg q hq, selectionWeight_total q⟩
  refine ⟨μ, selectionLabel (fun c => c), ?_⟩
  intro x y
  dsimp only [FiniteLaw.event, μ]
  trans ∏ c : X → Bool, if c x = c y then (1 : ℝ) else q c
  · convert selection_collision q (fun c : X → Bool => c) x y using 1
    apply Finset.sum_congr rfl
    intro ω _
    by_cases h : selectionLabel (fun c : X → Bool => c) ω x = selectionLabel (fun c => c) ω y <;> simp [h]
  have he (c : X → Bool) : (if c x = c y then (1 : ℝ) else q c) =
      Real.exp (-α * (a c * cutDistance c x y)) := by
    by_cases h : c x = c y <;> simp [h, cutDistance, q]
  simp_rw [he]
  rw [← Real.exp_sum, ← Finset.mul_sum]
  congr 2
  exact (hrep x y).symm

theorem partition_separation_le {X Ω Y : Type*} [Fintype Ω]
    (μ : FiniteLaw Ω) (label : Ω → X → Y) (ρ : X → X → ℝ) (α : ℝ)
    (he : ∀ x y, μ.event (fun ω => label ω x = label ω y) = Real.exp (-α * ρ x y))
    (x y : X) : μ.event (fun ω => label ω x ≠ label ω y) ≤ α * ρ x y := by
  rw [μ.event_compl, he]
  have h := Real.add_one_le_exp (-α * ρ x y)
  linarith

end FiniteCircle

end OAI