import Mathlib.Analysis.Complex.Exponential
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Tactic.FieldSimp
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.Ring
import OAI.Computability.UniqueGames.Foundations.SamplingLemmas
import OAI.Computability.UniqueGames.Games.FinishBoundsLemmas

namespace OAI

section

namespace UniqueGamesTheorem.Clean

open Foundations.Games
open scoped BigOperators

noncomputable section

/-- `true` is the singleton branch. -/
def bernoulli (p : ℝ) (hp₀ : 0 ≤ p) (hp₁ : p ≤ 1) :
    FiniteDistribution Bool where
  weight b := if b then p else 1 - p
  nonnegative b := by cases b <;> simp [hp₀, sub_nonneg.mpr hp₁]
  normalized := by simp

/-- The exact mask, including the empty mask at `k = 0`. -/
def maskCount {k : ℕ} (mask : Fin k → Bool) : ℕ :=
  (Finset.univ.filter fun i => mask i = true).card

theorem product_mask {k : ℕ} (mask : Fin k → Bool) (ρ : ℝ) :
    (∏ i, if mask i then ρ else 1) = ρ ^ maskCount mask := by
  classical
  simp [maskCount, Finset.prod_ite]

/-- The finite product identity underlying the binomial generating function. -/
theorem iid_product_moment {Ω : Type*} [Fintype Ω]
    (μ : FiniteDistribution Ω) (f : Ω → ℝ) (k : ℕ) :
    (μ.iid k).expectation (fun x => ∏ i, f (x i)) = μ.expectation f ^ k := by
  classical
  unfold FiniteDistribution.expectation FiniteDistribution.iid
  rw [Fintype.sum_pow]
  apply Finset.sum_congr rfl
  intro x _
  rw [Finset.prod_mul_distrib]

theorem bernoulli_mask_moment (p : ℝ) (hp₀ : 0 ≤ p) (hp₁ : p ≤ 1)
    (k : ℕ) (ρ : ℝ) :
    ((bernoulli p hp₀ hp₁).iid k).expectation (fun mask => ρ ^ maskCount mask) =
      (1 - p * (1 - ρ)) ^ k := by
  calc
    _ = ((bernoulli p hp₀ hp₁).iid k).expectation
        (fun mask => ∏ i, if mask i then ρ else 1) :=
      FiniteDistribution.expectation_congr _ (fun mask => (product_mask mask ρ).symm)
    _ = ((bernoulli p hp₀ hp₁).expectation (fun b => if b then ρ else 1)) ^ k :=
      iid_product_moment (bernoulli p hp₀ hp₁) (fun b : Bool => if b then ρ else 1) k
    _ = _ := by
      congr 1
      simp [FiniteDistribution.expectation, bernoulli]
      ring

variable {E : Type*} [Fintype E] [Nonempty E]

def cleanProbability (β : ℝ) (E : Type*) [Fintype E] : ℝ :=
  β / (Fintype.card E : ℝ)

omit [Nonempty E] in
theorem cleanProbability_nonneg {β : ℝ} (hβ₀ : 0 ≤ β) :
    0 ≤ cleanProbability β E :=
  div_nonneg hβ₀ (Nat.cast_nonneg _)

theorem cleanProbability_le_one {β : ℝ} (hβ₁ : β ≤ 1) :
    cleanProbability β E ≤ 1 := by
  have hc : (1 : ℝ) ≤ Fintype.card E := by
    exact_mod_cast Fintype.card_pos (α := E)
  apply (div_le_iff₀ (lt_of_lt_of_le zero_lt_one hc)).mpr
  simpa using hβ₁.trans hc

/-- Independent singleton choice and uniform advice slope. -/
def singletonSlopeLaw (β : ℝ) (hβ₀ : 0 ≤ β) (hβ₁ : β ≤ 1) :
    FiniteDistribution (Bool × E) :=
  (bernoulli β hβ₀ hβ₁).product (FiniteDistribution.uniform E)

/-- `origin` is instantiated by the zero advice slope. Keeping it explicit also
shows that every specified slope has exactly the same chance. -/
def cleanBit (origin : E) (sample : Bool × E) : Bool := by
  classical
  exact sample.1 && decide (sample.2 = origin)

theorem clean_pushforward (β : ℝ) (hβ₀ : 0 ≤ β) (hβ₁ : β ≤ 1) (origin : E) :
    (singletonSlopeLaw (E := E) β hβ₀ hβ₁).pushforward (cleanBit origin) =
      bernoulli (cleanProbability β E)
        (cleanProbability_nonneg hβ₀) (cleanProbability_le_one hβ₁) := by
  classical
  let μ := (singletonSlopeLaw (E := E) β hβ₀ hβ₁).pushforward (cleanBit origin)
  have ht : μ.weight true = cleanProbability β E := by
    simp [μ, FiniteDistribution.pushforward, singletonSlopeLaw,
      FiniteDistribution.product, Fintype.sum_prod_type,
      bernoulli, cleanBit, FiniteDistribution.uniform, cleanProbability, div_eq_mul_inv]
  apply FiniteDistribution.eq_of_weight_eq
  intro b
  cases b with
  | false =>
      change μ.weight false = 1 - cleanProbability β E
      have hn := μ.normalized
      simp only [Fintype.sum_bool] at hn
      linarith
  | true => exact ht

/-- In particular, the *whole* mask has the independent Bernoulli law. -/
theorem clean_mask_law (β : ℝ) (hβ₀ : 0 ≤ β) (hβ₁ : β ≤ 1)
    (origin : E) (k : ℕ) :
    ((singletonSlopeLaw (E := E) β hβ₀ hβ₁).iid k).pushforward
        (fun sample i => cleanBit origin (sample i)) =
      (bernoulli (cleanProbability β E)
        (cleanProbability_nonneg hβ₀) (cleanProbability_le_one hβ₁)).iid k := by
  rw [← FiniteDistribution.iid_pushforward, clean_pushforward]

theorem clean_mask_moment (β : ℝ) (hβ₀ : 0 ≤ β) (hβ₁ : β ≤ 1)
    (origin : E) (k : ℕ) (ρ : ℝ) :
    ((singletonSlopeLaw (E := E) β hβ₀ hβ₁).iid k).expectation
        (fun sample => ρ ^ maskCount (fun i => cleanBit origin (sample i))) =
      (1 - cleanProbability β E * (1 - ρ)) ^ k := by
  rw [← FiniteDistribution.expectation_pushforward
    ((singletonSlopeLaw (E := E) β hβ₀ hβ₁).iid k)
    (fun sample i => cleanBit origin (sample i)) (fun mask => ρ ^ maskCount mask)]
  rw [clean_mask_law, bernoulli_mask_moment]

theorem cleanProbability_ge_of_card_le {β : ℝ} (hβ₀ : 0 ≤ β) {N : ℝ}
    (hcard : (Fintype.card E : ℝ) ≤ N) :
    β / N ≤ cleanProbability β E := by
  exact div_le_div_of_nonneg_left hβ₀
    (Nat.cast_pos.mpr Fintype.card_pos) hcard

theorem cleanProbability_ge_dimension {β : ℝ} (hβ₀ : 0 ≤ β) (dimW rs : ℕ)
    (hcard : Fintype.card E ≤ 2 ^ (dimW + rs)) :
    β * (2 : ℝ) ^ (-((dimW + rs : ℕ) : ℤ)) ≤ cleanProbability β E := by
  rw [zpow_neg, zpow_natCast, ← div_eq_mul_inv]
  apply cleanProbability_ge_of_card_le hβ₀
  exact_mod_cast hcard

/-- Larger clean probability decreases the moment for a rate in `[0,1]`. -/
theorem mask_rate_antitone {p q ρ : ℝ} (hp₀ : 0 ≤ p) (hp₁ : p ≤ 1)
    (hqp : q ≤ p) (hρ₀ : 0 ≤ ρ) (hρ₁ : ρ ≤ 1) (k : ℕ) :
    (1 - p * (1 - ρ)) ^ k ≤ (1 - q * (1 - ρ)) ^ k := by
  have hl : 0 ≤ 1 - p * (1 - ρ) := by
    nlinarith [mul_nonneg hp₀ hρ₀]
  apply pow_le_pow_left₀ hl
  exact sub_le_sub_left (mul_le_mul_of_nonneg_right hqp (sub_nonneg.mpr hρ₁)) 1

/-- Section 5's numerical specialization. A bound on the number of possible
advice slopes gives a uniform bound over every fixed advice map. -/
theorem clean_mask_moment_le (β : ℝ) (hβ₀ : 0 ≤ β) (hβ₁ : β ≤ 1)
    (origin : E) (k : ℕ) {N : ℝ} (hcard : (Fintype.card E : ℝ) ≤ N) :
    ((singletonSlopeLaw (E := E) β hβ₀ hβ₁).iid k).expectation
        (fun sample => (1 - (1 : ℝ) / 3600) ^
          maskCount (fun i => cleanBit origin (sample i))) ≤
      (1 - (β / N) / 3600) ^ k := by
  rw [clean_mask_moment]
  have h := mask_rate_antitone (cleanProbability_nonneg (E := E) hβ₀)
    (cleanProbability_le_one (E := E) hβ₁)
    (cleanProbability_ge_of_card_le hβ₀ hcard)
    (ρ := 1 - (1 : ℝ) / 3600) (by norm_num) (by norm_num) k
  convert h using 1
  congr 1
  ring

/-- `2^(dim W + r_s)` is chosen before the particular advice-map rank. -/
theorem clean_mask_moment_le_dimension (β : ℝ) (hβ₀ : 0 ≤ β) (hβ₁ : β ≤ 1)
    (origin : E) (k dimW rs : ℕ) (hcard : Fintype.card E ≤ 2 ^ (dimW + rs)) :
    ((singletonSlopeLaw (E := E) β hβ₀ hβ₁).iid k).expectation
        (fun sample => (1 - (1 : ℝ) / 3600) ^
          maskCount (fun i => cleanBit origin (sample i))) ≤
      (1 - (β / (2 : ℝ) ^ (dimW + rs)) / 3600) ^ k := by
  apply clean_mask_moment_le β hβ₀ hβ₁ origin k
  exact_mod_cast hcard

/-- The exponential estimate uses nonnegativity of `1 - x` before raising to
a natural power. It also covers the empty mask. -/
theorem mask_rate_le_exp {x : ℝ} (hx : x ≤ 1) (k : ℕ) :
    (1 - x) ^ k ≤ Real.exp (-(k : ℝ) * x) := by
  calc
    (1 - x) ^ k ≤ Real.exp (-x) ^ k :=
      pow_le_pow_left₀ (sub_nonneg.mpr hx) (Real.one_sub_le_exp_neg x) k
    _ = Real.exp (-(k : ℝ) * x) := by
      rw [← Real.exp_nat_mul]
      congr 1
      ring

theorem clean_mask_moment_le_exp (β : ℝ) (hβ₀ : 0 ≤ β) (hβ₁ : β ≤ 1)
    (origin : E) (k : ℕ) {N : ℝ} (hcard : (Fintype.card E : ℝ) ≤ N) :
    ((singletonSlopeLaw (E := E) β hβ₀ hβ₁).iid k).expectation
        (fun sample => (1 - (1 : ℝ) / 3600) ^
          maskCount (fun i => cleanBit origin (sample i))) ≤
      Real.exp (-(k : ℝ) * (β / N) / 3600) := by
  have hN : 1 ≤ N := by
    have hc : (1 : ℝ) ≤ Fintype.card E := by
      exact_mod_cast Fintype.card_pos (α := E)
    exact hc.trans hcard
  have hq : β / N ≤ 1 := (div_le_iff₀ (by linarith)).mpr (by simpa using hβ₁.trans hN)
  have hx : β / N / 3600 ≤ 1 := (div_le_iff₀ (by norm_num)).mpr (by linarith)
  have h := (clean_mask_moment_le β hβ₀ hβ₁ origin k hcard).trans
    (mask_rate_le_exp hx k)
  simpa only [mul_div_assoc] using h

theorem cube_singleton_probability_nonneg (n : ℕ) : 0 ≤ (1 / (n : ℝ)) ^ 2 :=
  sq_nonneg _

theorem cube_singleton_probability_le_one {n : ℕ} (hn : 1 ≤ n) :
    (1 / (n : ℝ)) ^ 2 ≤ 1 := by
  have hn' : (1 : ℝ) ≤ n := by exact_mod_cast hn
  have hq₀ : 0 ≤ 1 / (n : ℝ) := div_nonneg zero_le_one (Nat.cast_nonneg _)
  have hq₁ : 1 / (n : ℝ) ≤ 1 :=
    (div_le_iff₀ (by linarith)).mpr (by simpa using hn')
  nlinarith [mul_nonneg hq₀ (sub_nonneg.mpr hq₁)]

/-- On cubes, `k = n^3` and `beta = n^(-2)`, so `k * beta = n`.
The advice-space size bound `N` is fixed independently of `n`. -/
theorem cube_mask_rate_le_exp {n : ℕ} (hn : 1 ≤ n) {N : ℝ} (hN : 1 ≤ N) :
    (1 - ((1 / (n : ℝ)) ^ 2 / N) / 3600) ^ (n ^ 3) ≤
      Real.exp (-(n : ℝ) / (3600 * N)) := by
  have hn₀ : (n : ℝ) ≠ 0 := by
    have hn' : (1 : ℝ) ≤ n := by exact_mod_cast hn
    linarith
  have hN₀ : N ≠ 0 := by linarith
  have hq : (1 / (n : ℝ)) ^ 2 / N ≤ 1 :=
    (div_le_iff₀ (by linarith)).mpr
      (by simpa using (cube_singleton_probability_le_one hn).trans hN)
  have hx : (1 / (n : ℝ)) ^ 2 / N / 3600 ≤ 1 :=
    (div_le_iff₀ (by norm_num)).mpr (by linarith)
  have he : -((n ^ 3 : ℕ) : ℝ) * ((1 / (n : ℝ)) ^ 2 / N / 3600) =
      -(n : ℝ) / (3600 * N) := by
    simp only [Nat.cast_pow]
    field_simp [hn₀, hN₀]
  calc
    _ ≤ Real.exp (-((n ^ 3 : ℕ) : ℝ) * ((1 / (n : ℝ)) ^ 2 / N / 3600)) :=
      mask_rate_le_exp hx (n ^ 3)
    _ = _ := congrArg Real.exp he

/-- A repetition cube can be selected after fixing only the advice-space size
bound and the required error. This is a scalar fact, not a game-value theorem. -/
theorem exists_cube_exponential_lt {N error : ℝ} (hN : 0 < N) (herror : 0 < error) :
    ∃ n : ℕ, 1 ≤ n ∧ Real.exp (-(n : ℝ) / (3600 * N)) < error := by
  let rate := Real.exp (-(1 / (3600 * N)))
  have hrate₀ : 0 ≤ rate := (Real.exp_pos _).le
  have hrate₁ : rate < 1 := Real.exp_lt_one_iff.mpr
    (neg_lt_zero.mpr (one_div_pos.mpr (mul_pos (by norm_num) hN)))
  have ht := tendsto_pow_atTop_nhds_zero_of_lt_one hrate₀ hrate₁
  obtain ⟨m, hm⟩ := (ht.eventually (gt_mem_nhds herror)).exists
  refine ⟨m + 1, Nat.succ_le_succ (Nat.zero_le m), ?_⟩
  have hp : rate ^ (m + 1) < error :=
    lt_of_le_of_lt (by
      rw [pow_succ]
      exact mul_le_of_le_one_right (pow_nonneg hrate₀ m) hrate₁.le) hm
  have he : Real.exp (-((m + 1 : ℕ) : ℝ) / (3600 * N)) = rate ^ (m + 1) := by
    rw [← Real.exp_nat_mul]
    congr 1
    ring
  rwa [he]

theorem exists_cube_mask_rate_lt {N error : ℝ} (hN : 1 ≤ N) (herror : 0 < error) :
    ∃ n : ℕ, 1 ≤ n ∧
      (1 - ((1 / (n : ℝ)) ^ 2 / N) / 3600) ^ (n ^ 3) < error := by
  obtain ⟨n, hn, he⟩ := exists_cube_exponential_lt (by linarith : 0 < N) herror
  exact ⟨n, hn, (cube_mask_rate_le_exp hn hN).trans_lt he⟩

end
end UniqueGamesTheorem.Clean

end

section

/-!
Assembling private decoders from an actual finite advice experiment.

The left response law accepts only the left observation and the right law only
the right observation. Their samples are independent conditional on those
observations. A positive conditional agreement bound on a positive-mass event
therefore gives ordinary deterministic local strategies, by finite averaging.
No hidden matrix, witness, or opposite-player observation is an argument of
either response law.
-/

namespace UniqueGamesTheorem.Decoder.StrategyAssembly

open UniqueGamesTheorem.Foundations.Games
open scoped BigOperators

noncomputable section

variable {Ω Q₁ Q₂ A₁ A₂ : Type*}
variable [Fintype Ω] [Fintype Q₁] [Fintype Q₂] [Fintype A₁] [Fintype A₂]

def observedGame (law : FiniteDistribution Ω) (leftObservation : Ω → Q₁)
    (rightObservation : Ω → Q₂) (accepts : Q₁ → Q₂ → A₁ → A₂ → Bool) :
    Game Q₁ Q₂ A₁ A₂ where
  questions := law.pushforward (fun ω => (leftObservation ω, rightObservation ω))
  accepts := accepts

def conditionalAgreement (left : Q₁ → FiniteDistribution A₁)
    (right : Q₂ → FiniteDistribution A₂)
    (accepts : Q₁ → Q₂ → A₁ → A₂ → Bool) (q₁ : Q₁) (q₂ : Q₂) : ℝ :=
  ((left q₁).product (right q₂)).probability (fun a => accepts q₁ q₂ a.1 a.2)

omit [Fintype Q₁] [Fintype Q₂] in
theorem conditionalAgreement_nonnegative (left : Q₁ → FiniteDistribution A₁)
    (right : Q₂ → FiniteDistribution A₂)
    (accepts : Q₁ → Q₂ → A₁ → A₂ → Bool) (q₁ : Q₁) (q₂ : Q₂) :
    0 ≤ conditionalAgreement left right accepts q₁ q₂ :=
  FiniteDistribution.probability_nonnegative _ _

omit [Fintype Q₁] [Fintype Q₂] in
theorem conditionalAgreement_le_one (left : Q₁ → FiniteDistribution A₁)
    (right : Q₂ → FiniteDistribution A₂)
    (accepts : Q₁ → Q₂ → A₁ → A₂ → Bool) (q₁ : Q₁) (q₂ : Q₂) :
    conditionalAgreement left right accepts q₁ q₂ ≤ 1 :=
  FiniteDistribution.probability_le_one _ _

theorem stochasticSuccess_eq_actual_expectation
    [DecidableEq Q₁] [DecidableEq Q₂]
    (law : FiniteDistribution Ω) (leftObservation : Ω → Q₁)
    (rightObservation : Ω → Q₂) (accepts : Q₁ → Q₂ → A₁ → A₂ → Bool)
    (left : Q₁ → FiniteDistribution A₁) (right : Q₂ → FiniteDistribution A₂) :
    (observedGame law leftObservation rightObservation accepts).stochasticSuccess left right =
      law.expectation (fun ω => conditionalAgreement left right accepts
        (leftObservation ω) (rightObservation ω)) := by
  unfold Game.stochasticSuccess observedGame
  rw [FiniteDistribution.expectation_pushforward]
  apply FiniteDistribution.expectation_congr
  intro ω
  simp only [conditionalAgreement, FiniteDistribution.probability,
    FiniteDistribution.product, FiniteDistribution.expectation, Fintype.sum_prod_type]
  apply Finset.sum_congr rfl
  intro a _
  rw [Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro b _
  by_cases h : accepts (leftObservation ω) (rightObservation ω) a b = true <;> simp [h]

/-- Averaging conditional independent decoder success over the actual advice
draw multiplies the two positive lower bounds. -/
theorem good_data_mass_lower
    [DecidableEq Q₁] [DecidableEq Q₂]
    (law : FiniteDistribution Ω) (leftObservation : Ω → Q₁)
    (rightObservation : Ω → Q₂) (accepts : Q₁ → Q₂ → A₁ → A₂ → Bool)
    (left : Q₁ → FiniteDistribution A₁) (right : Q₂ → FiniteDistribution A₂)
    (good : Ω → Bool) (γ₁ γ₂ : ℝ) (hγ₂ : 0 ≤ γ₂)
    (hmass : γ₁ ≤ law.probability good)
    (hagreement : ∀ ω, good ω = true → γ₂ ≤
      conditionalAgreement left right accepts (leftObservation ω) (rightObservation ω)) :
    γ₁ * γ₂ ≤
      (observedGame law leftObservation rightObservation accepts).stochasticSuccess left right := by
  rw [stochasticSuccess_eq_actual_expectation]
  have hweighted : law.probability good * γ₂ ≤ law.expectation
      (fun ω => conditionalAgreement left right accepts
        (leftObservation ω) (rightObservation ω)) := by
    unfold FiniteDistribution.probability FiniteDistribution.expectation
    rw [Finset.sum_mul]
    apply Finset.sum_le_sum
    intro ω _
    by_cases hgood : good ω = true
    · simp only [hgood, ↓reduceIte]
      exact mul_le_mul_of_nonneg_left (hagreement ω hgood) (law.nonnegative ω)
    · simp only [hgood, Bool.false_eq_true, ↓reduceIte, zero_mul]
      exact mul_nonneg (law.nonnegative ω) (conditionalAgreement_nonnegative _ _ _ _ _)
  exact (mul_le_mul_of_nonneg_right hmass hγ₂).trans hweighted

/-- The final strategies receive precisely their local observations. Private
sampling is eliminated by the existing finite response-table construction. -/
theorem exists_local_deterministic_strategies
    [DecidableEq Q₁] [DecidableEq Q₂] [Nonempty A₁] [Nonempty A₂]
    (law : FiniteDistribution Ω) (leftObservation : Ω → Q₁)
    (rightObservation : Ω → Q₂) (accepts : Q₁ → Q₂ → A₁ → A₂ → Bool)
    (left : Q₁ → FiniteDistribution A₁) (right : Q₂ → FiniteDistribution A₂)
    (good : Ω → Bool) (γ₁ γ₂ : ℝ) (hγ₂ : 0 ≤ γ₂)
    (hmass : γ₁ ≤ law.probability good)
    (hagreement : ∀ ω, good ω = true → γ₂ ≤
      conditionalAgreement left right accepts (leftObservation ω) (rightObservation ω)) :
    ∃ leftStrategy : Q₁ → A₁, ∃ rightStrategy : Q₂ → A₂,
      γ₁ * γ₂ ≤ law.probability (fun ω => accepts
        (leftObservation ω) (rightObservation ω)
        (leftStrategy (leftObservation ω)) (rightStrategy (rightObservation ω))) := by
  let G := observedGame law leftObservation rightObservation accepts
  obtain ⟨strategy, hstrategy⟩ := G.exists_deterministic_ge_stochastic left right
  refine ⟨strategy.1, strategy.2, ?_⟩
  have h := (good_data_mass_lower law leftObservation rightObservation accepts
    left right good γ₁ γ₂ hγ₂ hmass hagreement).trans hstrategy
  simpa only [G, Game.success, observedGame, FiniteDistribution.probability_pushforward,
    Game.wins] using h

end
end UniqueGamesTheorem.Decoder.StrategyAssembly

end

end OAI