import OAI.Computability.PerfectCompleteness.Foundations.OddLists
import OAI.Computability.PerfectCompleteness.Foundations.RecursiveSpaceEquivLemmas
import OAI.Computability.PerfectCompleteness.Repetition.RepetitionRateLemmas
import OAI.Computability.PerfectCompleteness.Sampling.FiniteListSampling

namespace OAI

section

namespace PerfectCompleteness.OddListGame

open scoped BigOperators
open UniqueGamesTheorem.Foundations.Games
open OddLists FiniteListSampling

noncomputable section

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

def base (μ : FiniteDistribution E) (left : E → Q₁) (right : E → Q₂)
    (projection : E → A₁ → A₂) : OccurrenceGame E Q₁ Q₂ A₁ A₂ :=
  OccurrenceGame.ofProjection μ left right projection

def game (s : Nat) (μ : FiniteDistribution E) (left : E → Q₁) (right : E → Q₂)
    (projection : E → A₁ → A₂) :
    OccurrenceGame E Q₁ Q₂ (OddList s A₁) (OddList s A₂) :=
  OccurrenceGame.ofProjection μ left right (fun e => OddList.map (projection e))

def responses {Q A : Type*} [Fintype A] [DecidableEq A] {s : Nat}
    (lists : Q → OddList s A) (q : Q) : FiniteDistribution A :=
  uniformList (lists q).val (lists q).nonempty

omit [DecidableEq Q₁] [DecidableEq Q₂] [DecidableEq A₁] in
theorem accepted_pair {s : Nat} (μ : FiniteDistribution E)
    (left : E → Q₁) (right : E → Q₂) (projection : E → A₁ → A₂)
    (strategy : Strategy Q₁ Q₂ (OddList s A₁) (OddList s A₂)) (e : E)
    (accepted : (game s μ left right projection).wins strategy e = true) :
    ∃ a ∈ (strategy.1 (left e)).val, ∃ b ∈ (strategy.2 (right e)).val,
      (base μ left right projection).accepts e a b = true := by
  have hmap : OddList.map (projection e) (strategy.1 (left e)) = strategy.2 (right e) := by
    simpa only [game, OccurrenceGame.wins, OccurrenceGame.ofProjection, decide_eq_true_eq]
      using accepted
  obtain ⟨a, ha, b, hb, hab⟩ := OddList.exists_accepting_pair_of_eq
    (projection e) (strategy.1 (left e)) (strategy.2 (right e)) hmap
  exact ⟨a, ha, b, hb, by simpa [base, OccurrenceGame.ofProjection] using hab⟩

omit [DecidableEq Q₁] [DecidableEq Q₂] in
theorem success_le_randomized {s : Nat} [NeZero s] (μ : FiniteDistribution E)
    (left : E → Q₁) (right : E → Q₂) (projection : E → A₁ → A₂)
    (strategy : Strategy Q₁ Q₂ (OddList s A₁) (OddList s A₂)) :
    (game s μ left right projection).success strategy ≤
      (s : ℝ) ^ 2 * (base μ left right projection).stochasticSuccess
        (responses strategy.1) (responses strategy.2) := by
  let G := base μ left right projection
  let pair := fun e => pairAcceptance (responses strategy.1 (left e))
    (responses strategy.2 (right e)) (G.accepts e)
  have hs : 0 < (s : ℝ) ^ 2 := pow_pos (Nat.cast_pos.mpr (Nat.pos_of_neZero s)) 2
  have hpoint (e : E) :
      (if (game s μ left right projection).wins strategy e then (1 : ℝ) else 0) ≤
        (s : ℝ) ^ 2 * pair e := by
    by_cases hwin : (game s μ left right projection).wins strategy e = true
    · simp only [hwin, ite_true]
      have h := bounded_uniform_pair_lower
        (strategy.1 (left e)).val (strategy.2 (right e)).val
        (strategy.1 (left e)).nonempty (strategy.2 (right e)).nonempty s
        (strategy.1 (left e)).card_le (strategy.2 (right e)).card_le (G.accepts e)
        (accepted_pair μ left right projection strategy e hwin)
      have hscaled := (div_le_iff₀ hs).mp h
      change 1 ≤ (s : ℝ) ^ 2 *
        pairAcceptance (uniformList (strategy.1 (left e)).val (strategy.1 (left e)).nonempty)
          (uniformList (strategy.2 (right e)).val (strategy.2 (right e)).nonempty) (G.accepts e)
      exact hscaled.trans_eq (mul_comm _ _)
    · simp only [hwin]
      exact mul_nonneg (sq_nonneg _) (pairAcceptance_nonnegative _ _ _)
  have hpair : μ.expectation pair = G.stochasticSuccess
      (responses strategy.1) (responses strategy.2) := by
    unfold OccurrenceGame.stochasticSuccess
    apply FiniteDistribution.expectation_congr
    intro e
    exact pairAcceptance_eq_expectation _ _ _
  calc
    _ = μ.expectation
        (fun e => if (game s μ left right projection).wins strategy e then 1 else 0) :=
      (game s μ left right projection).success_eq_occurrence_expectation strategy
    _ ≤ μ.expectation (fun e => (s : ℝ) ^ 2 * pair e) :=
      SmallBias.expectation_mono μ hpoint
    _ = (s : ℝ) ^ 2 * μ.expectation pair := by
      simp only [FiniteDistribution.expectation, Finset.mul_sum]
      apply Finset.sum_congr rfl
      intro e _
      ring
    _ = _ := by rw [hpair]

theorem value_le {s : Nat} [NeZero s] [Nonempty A₁] [Nonempty A₂]
    (μ : FiniteDistribution E) (left : E → Q₁) (right : E → Q₂)
    (projection : E → A₁ → A₂) :
    (game s μ left right projection).value ≤
      (s : ℝ) ^ 2 * (base μ left right projection).value := by
  apply ((game s μ left right projection).value_le_iff _).mpr
  intro strategy
  exact (success_le_randomized μ left right projection strategy).trans
    (mul_le_mul_of_nonneg_left
      ((base μ left right projection).stochasticSuccess_le_value
        (responses strategy.1) (responses strategy.2)) (sq_nonneg _))

omit [DecidableEq Q₁] [DecidableEq Q₂] [DecidableEq A₁] in
theorem endpointDetermined {s : Nat} (μ : FiniteDistribution E)
    (left : E → Q₁) (right : E → Q₂) (projection : E → A₁ → A₂)
    (determined : (base μ left right projection).EndpointDetermined) :
    (game s μ left right projection).EndpointDetermined := by
  intro e e' hl hr L R
  have hprojection : projection e = projection e' := by
    funext a
    have h := determined e e' hl hr a (projection e a)
    have htrue : (base μ left right projection).accepts e' a (projection e a) = true := by
      rw [← h]
      simp [base, OccurrenceGame.ofProjection]
    have heq : projection e' a = projection e a := by
      simpa only [base, OccurrenceGame.ofProjection, decide_eq_true_eq] using htrue
    exact heq.symm
  simp only [game, OccurrenceGame.ofProjection, hprojection]
  by_cases h : OddList.map (projection e') L = R <;> simp only [h, decide_true, decide_false]

theorem repetition_halfRate {s L : Nat} [NeZero s] [Nonempty A₁] [Nonempty A₂]
    (μ : FiniteDistribution E) (left : E → Q₁) (right : E → Q₂)
    (projection : E → A₁ → A₂)
    (determined : (base μ left right projection).EndpointDetermined)
    (gap : (s : ℝ) ^ 2 * (base μ left right projection).value ≤ 1 / 2)
    (hL : 0 < L)
    (alphabet : UniqueGamesTheorem.Foundations.Repetition.logTwo
      ((Fintype.card (OddList s A₁) : ℝ) * (Fintype.card (OddList s A₂) : ℝ)) ≤ L)
    (n : Nat) :
    ((game s μ left right projection).repetition n).value ≤
      (RepetitionRate.halfRate L : ℝ) ^ n := by
  exact RepetitionRate.occurrence_repetition_halfRate (game s μ left right projection)
    ((game s μ left right projection).presentationOfDetermined
      (endpointDetermined μ left right projection determined)) hL alphabet
    ((value_le μ left right projection).trans gap) n

end
end PerfectCompleteness.OddListGame

end

end OAI