import Mathlib.Algebra.Order.BigOperators.Ring.Finset
import Mathlib.Algebra.BigOperators.Ring.Finset
import Mathlib.Data.Fintype.Pi
import Mathlib.Tactic

namespace OAI

/-!
# Finite weighted sampling for the random-prime rank argument

The prime labels in the rank argument have a nonuniform reciprocal law.
Finite-sum probability identities describe the resulting sampling law.
-/

namespace TwoPointCorrelations

open Finset

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

namespace FiniteLaw

variable {α β ι : Type*} [Fintype α] [Fintype β] [Fintype ι]

noncomputable def average (μ : FiniteLaw α) (f : α → ℝ) : ℝ :=
  ∑ x, μ.weight x * f x

noncomputable def probability (μ : FiniteLaw α) (E : α → Prop) : ℝ := by
  classical
  exact μ.average (fun x => if E x then 1 else 0)

lemma average_nonneg (μ : FiniteLaw α) {f : α → ℝ} (hf : ∀ x, 0 ≤ f x) :
    0 ≤ μ.average f := sum_nonneg (fun x _ => mul_nonneg (μ.nonneg x) (hf x))

lemma average_mono (μ : FiniteLaw α) {f g : α → ℝ} (h : ∀ x, f x ≤ g x) :
    μ.average f ≤ μ.average g := sum_le_sum (fun x _ => mul_le_mul_of_nonneg_left (h x) (μ.nonneg x))

@[simp] lemma average_const (μ : FiniteLaw α) (c : ℝ) : μ.average (fun _ => c) = c := by
  simp [average, ← sum_mul, μ.total]

lemma average_sum (μ : FiniteLaw α) (f : ι → α → ℝ) :
    μ.average (fun x => ∑ i, f i x) = ∑ i, μ.average (f i) := by
  simp only [average, mul_sum]
  rw [sum_comm]

lemma average_mul_const (μ : FiniteLaw α) (f : α → ℝ) (c : ℝ) :
    μ.average (fun x => f x * c) = μ.average f * c := by
  simp only [average, mul_assoc, sum_mul]

lemma average_comm (μ : FiniteLaw α) (ν : FiniteLaw β) (f : α → β → ℝ) :
    μ.average (fun x => ν.average (f x)) = ν.average (fun y => μ.average (fun x => f x y)) := by
  simp only [average, mul_sum]
  rw [sum_comm]
  congr 1
  funext y
  apply sum_congr rfl
  intro x _
  ring

/-- Weighted Cauchy--Schwarz against the constant function one. -/
lemma square_average_le (μ : FiniteLaw α) (f : α → ℝ) :
    (μ.average f) ^ 2 ≤ μ.average (fun x => f x ^ 2) := by
  have h := sum_sq_le_sum_mul_sum_of_sq_le_mul univ
    (f := μ.weight) (g := fun x => μ.weight x * f x ^ 2)
    (r := fun x => μ.weight x * f x)
    (fun x _ => μ.nonneg x)
    (fun x _ => mul_nonneg (μ.nonneg x) (sq_nonneg _))
    (fun x _ => le_of_eq (by ring))
  simpa only [average, μ.total, one_mul] using h

lemma square_average_eq (μ : FiniteLaw α) (f : α → ℝ) :
    (μ.average f) ^ 2 = μ.average (fun x => μ.average (fun y => f x * f y)) := by
  simp only [average, pow_two, mul_sum, sum_mul]
  apply sum_congr rfl
  intro x _
  apply sum_congr rfl
  intro y _
  ring

/-- Repeating the second sample removes every term depending only on the
first sample. This is the Cauchy--Schwarz step of `q:rank-probability`. -/
theorem two_sample_bound (μ : FiniteLaw α) (ν : FiniteLaw β)
    (E : α → β → Prop) (D : α → β → β → Prop)
    (hD : ∀ c y z, E c y → E c z → D c y z) :
    (μ.average (fun c => ν.probability (E c))) ^ 2 ≤
      μ.average (fun c => ν.average (fun y => ν.probability (D c y))) := by
  classical
  apply (μ.square_average_le _).trans
  apply μ.average_mono
  intro c
  rw [probability, ν.square_average_eq]
  apply ν.average_mono
  intro y
  apply ν.average_mono
  intro z
  by_cases hy : E c y <;> by_cases hz : E c z
  · simp [hy, hz, hD c y z hy hz]
  · simp [hy, hz]; split_ifs <;> norm_num
  · simp [hy, hz]; split_ifs <;> norm_num
  · simp [hy, hz]; split_ifs <;> norm_num

noncomputable def product (μ : FiniteLaw α) (ν : FiniteLaw β) : FiniteLaw (α × β) where
  weight x := μ.weight x.1 * ν.weight x.2
  nonneg x := mul_nonneg (μ.nonneg _) (ν.nonneg _)
  total := by simp [Fintype.sum_prod_type, ← mul_sum, μ.total, ν.total]

lemma average_product (μ : FiniteLaw α) (ν : FiniteLaw β) (f : α × β → ℝ) :
    (μ.product ν).average f = μ.average (fun x => ν.average (fun y => f (x, y))) := by
  simp only [average, product, Fintype.sum_prod_type, mul_sum, mul_assoc]

noncomputable def independent [DecidableEq ι] (μ : ι → FiniteLaw α) : FiniteLaw (ι → α) where
  weight x := ∏ i, (μ i).weight (x i)
  nonneg x := prod_nonneg (fun i _ => (μ i).nonneg _)
  total := by
    rw [← Fintype.prod_sum (fun i x => (μ i).weight x)]
    simp only [FiniteLaw.total, prod_const_one]

lemma independent_average_product [DecidableEq ι] (μ : ι → FiniteLaw α) (f : ι → α → ℝ) :
    (independent μ).average (fun x => ∏ i, f i (x i)) = ∏ i, (μ i).average (f i) := by
  simp only [average, independent, ← prod_mul_distrib]
  exact (Fintype.prod_sum (fun i x => (μ i).weight x * f i x)).symm

lemma probability_nonneg (μ : FiniteLaw α) (E : α → Prop) : 0 ≤ μ.probability E := by
  classical
  apply μ.average_nonneg
  intro x
  split_ifs <;> norm_num

lemma probability_le_one (μ : FiniteLaw α) (E : α → Prop) : μ.probability E ≤ 1 := by
  classical
  apply (μ.average_mono (g := fun _ => 1) ?_).trans_eq (μ.average_const 1)
  intro x
  split_ifs <;> norm_num

/-- If an event contains at most one atom, its mass is bounded by the
largest allowed atom. This is used after fixing the nonpivot labels. -/
lemma probability_le_atom_bound (μ : FiniteLaw α) (E : α → Prop) (a : ℝ)
    (ha : 0 ≤ a) (hatom : ∀ x, μ.weight x ≤ a)
    (hunique : ∀ x y, E x → E y → x = y) : μ.probability E ≤ a := by
  classical
  by_cases he : ∃ x, E x
  · obtain ⟨x, hx⟩ := he
    have hE (y : α) : E y ↔ y = x := ⟨fun hy => hunique y x hy hx, fun hy => hy ▸ hx⟩
    simpa [probability, average, hE] using hatom x
  · have hE (x : α) : ¬ E x := fun hx => he ⟨x, hx⟩
    simpa [probability, average, hE] using ha

end FiniteLaw

end TwoPointCorrelations

end OAI