import Mathlib.Data.Fintype.BigOperators
import Mathlib.Data.Fintype.Sigma
import Mathlib.Tactic.Choose
import Mathlib.Tactic.NormNum
import OAI.Computability.PerfectCompleteness.Reduction.OccurrenceGame
import OAI.Computability.PerfectCompleteness.Sampling.CompletionProbability

namespace OAI


namespace PerfectCompleteness.CompletionSoundness

open scoped BigOperators Classical
open UniqueGamesTheorem.Foundations.Games
open CompletionProbability

noncomputable section

section SeedLaws
variable {E : Type*} {Seed : E → Type*}
  [Fintype E] [∀ e, Fintype (Seed e)]

def sigmaLaw (μ : FiniteDistribution E) (ν : ∀ e, FiniteDistribution (Seed e)) :
    FiniteDistribution (Σ e, Seed e) where
  weight es := μ.weight es.1 * (ν es.1).weight es.2
  nonnegative es := mul_nonneg (μ.nonnegative es.1) ((ν es.1).nonnegative es.2)
  normalized := by
    rw [Fintype.sum_sigma]
    calc
      _ = ∑ e, μ.weight e := by
        apply Finset.sum_congr rfl
        intro e _
        change (∑ seed : Seed e, μ.weight e * (ν e).weight seed) = μ.weight e
        rw [← Finset.mul_sum, (ν e).normalized, mul_one]
      _ = 1 := μ.normalized

theorem sigmaLaw_probability (μ : FiniteDistribution E)
    (ν : ∀ e, FiniteDistribution (Seed e)) (event : (Σ e, Seed e) → Bool) :
    (sigmaLaw μ ν).probability event =
      μ.expectation (fun e => (ν e).probability (fun seed => event ⟨e, seed⟩)) := by
  simp only [FiniteDistribution.probability, FiniteDistribution.expectation,
    sigmaLaw, Fintype.sum_sigma, Finset.mul_sum, mul_ite, mul_zero]

theorem sigmaLaw_probability_first (μ : FiniteDistribution E)
    (ν : ∀ e, FiniteDistribution (Seed e)) (event : E → Bool) :
    (sigmaLaw μ ν).probability (fun es => event es.1) = μ.probability event := by
  rw [sigmaLaw_probability]
  simp only [FiniteDistribution.expectation, FiniteDistribution.probability]
  apply Finset.sum_congr rfl
  intro e _
  by_cases he : event e = true <;> simp [he, (ν e).normalized]

end SeedLaws

theorem probability_uniform_eq_uniformProbability {Ω : Type*}
    [Fintype Ω] [Nonempty Ω] (event : Ω → Prop) :
    (FiniteDistribution.uniform Ω).probability (fun x => decide (event x)) =
      uniformProbability event := by
  calc
    _ = (FiniteDistribution.uniform Ω).expectation
        (fun x => if event x then (1 : ℝ) else 0) := by
      unfold FiniteDistribution.probability FiniteDistribution.expectation
      apply Finset.sum_congr rfl
      intro x _
      by_cases hx : event x <;> simp [hx]
    _ = (∑ x, if event x then (1 : ℝ) else 0) / (Fintype.card Ω : ℝ) :=
      FiniteDistribution.expectation_uniform _
    _ = uniformProbability event := by
      simp only [uniformProbability, Fintype.card_subtype, Finset.sum_boole]

theorem probability_decide_const {Ω : Type*} [Fintype Ω]
    (μ : FiniteDistribution Ω) (P : Prop) :
    μ.probability (fun _ => decide P) = if P then 1 else 0 := by
  by_cases h : P <;> simp [h]

def roundLabel {L A : Type*} (legal : L ↪ A) (default : L) (a : A) : L :=
  if h : ∃ l, legal l = a then Classical.choose h else default

@[simp] theorem roundLabel_legal {L A : Type*} (legal : L ↪ A)
    (default l : L) : roundLabel legal default (legal l) = l := by
  have h : ∃ l', legal l' = legal l := ⟨l, rfl⟩
  simp only [roundLabel, dite_eq_left h]
  exact legal.injective (Classical.choose_spec h)

theorem seed_acceptance_le {L R A B Ω : Type*} [Fintype Ω]
    (ν : FiniteDistribution Ω) (legalL : L ↪ A) (legalR : R ↪ B)
    (defaultL : L) (defaultR : R) (p : L → R) (complete : Ω → A → B)
    (agrees : ∀ seed l, complete seed (legalL l) = legalR (p l))
    (ε : ℝ) (hε : 0 ≤ ε)
    (marginal : ∀ a, a ∉ Set.range legalL → ∀ b,
      ν.probability (fun seed => decide (complete seed a = b)) ≤ ε)
    (a : A) (b : B) :
    ν.probability (fun seed => decide (complete seed a = b)) ≤
      (if p (roundLabel legalL defaultL a) = roundLabel legalR defaultR b then 1 else 0) + ε := by
  by_cases ha : a ∈ Set.range legalL
  · obtain ⟨l, rfl⟩ := ha
    have hdom : ν.probability (fun seed => decide (complete seed (legalL l) = b)) ≤
        ν.probability (fun _ =>
          decide (p (roundLabel legalL defaultL (legalL l)) =
            roundLabel legalR defaultR b)) := by
      apply ν.probability_mono
      intro seed hwin
      have hw : complete seed (legalL l) = b := of_decide_eq_true hwin
      have hb : legalR (p l) = b := (agrees seed l).symm.trans hw
      apply decide_eq_true_iff.mpr
      rw [roundLabel_legal, ← hb, roundLabel_legal]
    rw [probability_decide_const] at hdom
    exact hdom.trans (le_add_of_nonneg_right hε)
  · have h := marginal a ha b
    have hind : (0 : ℝ) ≤
        if p (roundLabel legalL defaultL a) = roundLabel legalR defaultR b then 1 else 0 := by
      split <;> norm_num
    exact h.trans (le_add_of_nonneg_left hind)

structure LegalProjectionGame (E Q₁ Q₂ : Type*)
    (L : Q₁ → Type*) (R : Q₂ → Type*) [Fintype E] where
  occurrences : FiniteDistribution E
  left : E → Q₁
  right : E → Q₂
  projection : ∀ e, L (left e) → R (right e)

abbrev LegalStrategy {Q₁ Q₂ : Type*} (L : Q₁ → Type*) (R : Q₂ → Type*) :=
  (∀ x, L x) × (∀ y, R y)

namespace LegalProjectionGame

variable {E Q₁ Q₂ : Type*} {L : Q₁ → Type*} {R : Q₂ → Type*}
  [Fintype E] (G : LegalProjectionGame E Q₁ Q₂ L R)

def wins (s : LegalStrategy L R) (e : E) : Bool :=
  decide (G.projection e (s.1 (G.left e)) = s.2 (G.right e))

def success (s : LegalStrategy L R) : ℝ := G.occurrences.probability (G.wins s)

section Value
variable [Fintype Q₁] [Fintype Q₂] [∀ x, Fintype (L x)] [∀ y, Fintype (R y)]
  [∀ x, Nonempty (L x)] [∀ y, Nonempty (R y)]

def value : ℝ := Finset.univ.sup' Finset.univ_nonempty G.success

theorem success_le_value (s : LegalStrategy L R) : G.success s ≤ G.value :=
  Finset.le_sup' G.success (Finset.mem_univ s)

theorem exists_optimal_strategy : ∃ s : LegalStrategy L R, G.success s = G.value := by
  obtain ⟨s, _, hs⟩ := Finset.exists_mem_eq_sup'
    (s := (Finset.univ : Finset (LegalStrategy L R))) Finset.univ_nonempty G.success
  exact ⟨s, hs.symm⟩

end Value

section Completion
variable [Fintype Q₁] [Fintype Q₂]
  {A B : Type*} [Fintype A] [Fintype B]
  {Seed : E → Type*} [∀ e, Fintype (Seed e)]

def completedGame (ν : ∀ e, FiniteDistribution (Seed e))
    (complete : ∀ e, Seed e → A → B) :
    OccurrenceGame (Σ e, Seed e) Q₁ Q₂ A B :=
  OccurrenceGame.ofProjection (sigmaLaw G.occurrences ν)
    (fun es => G.left es.1) (fun es => G.right es.1)
    (fun es => complete es.1 es.2)

theorem completed_success (ν : ∀ e, FiniteDistribution (Seed e))
    (complete : ∀ e, Seed e → A → B) (s : Strategy Q₁ Q₂ A B) :
    (G.completedGame ν complete).success s =
      G.occurrences.expectation (fun e => (ν e).probability
        (fun seed => decide (complete e seed (s.1 (G.left e)) = s.2 (G.right e)))) := by
  change (sigmaLaw G.occurrences ν).probability _ = _
  exact sigmaLaw_probability G.occurrences ν _

def roundStrategy (legalL : ∀ x, L x ↪ A) (legalR : ∀ y, R y ↪ B)
    (defaultL : ∀ x, L x) (defaultR : ∀ y, R y)
    (s : Strategy Q₁ Q₂ A B) : LegalStrategy L R :=
  (fun x => roundLabel (legalL x) (defaultL x) (s.1 x),
   fun y => roundLabel (legalR y) (defaultR y) (s.2 y))

def liftStrategy (legalL : ∀ x, L x ↪ A) (legalR : ∀ y, R y ↪ B)
    (s : LegalStrategy L R) : Strategy Q₁ Q₂ A B :=
  (fun x => legalL x (s.1 x), fun y => legalR y (s.2 y))

theorem completed_success_le (ν : ∀ e, FiniteDistribution (Seed e))
    (complete : ∀ e, Seed e → A → B)
    (legalL : ∀ x, L x ↪ A) (legalR : ∀ y, R y ↪ B)
    (defaultL : ∀ x, L x) (defaultR : ∀ y, R y)
    (agrees : ∀ e seed l, complete e seed (legalL (G.left e) l) =
      legalR (G.right e) (G.projection e l))
    (ε : E → ℝ) (hε : ∀ e, 0 ≤ ε e)
    (marginal : ∀ e a, a ∉ Set.range (legalL (G.left e)) → ∀ b,
      (ν e).probability (fun seed => decide (complete e seed a = b)) ≤ ε e)
    (s : Strategy Q₁ Q₂ A B) :
    (G.completedGame ν complete).success s ≤
      G.success (roundStrategy legalL legalR defaultL defaultR s) + G.occurrences.expectation ε := by
  rw [G.completed_success]
  unfold FiniteDistribution.expectation success wins FiniteDistribution.probability
  calc
    _ ≤ ∑ e, G.occurrences.weight e *
        ((if G.projection e (roundLabel (legalL (G.left e)) (defaultL (G.left e))
            (s.1 (G.left e))) = roundLabel (legalR (G.right e)) (defaultR (G.right e))
            (s.2 (G.right e)) then 1 else 0) + ε e) := by
      apply Finset.sum_le_sum
      intro e _
      exact mul_le_mul_of_nonneg_left
        (seed_acceptance_le (ν e) (legalL (G.left e)) (legalR (G.right e))
          (defaultL (G.left e)) (defaultR (G.right e)) (G.projection e) (complete e)
          (agrees e) (ε e) (hε e) (marginal e) _ _) (G.occurrences.nonnegative e)
    _ = _ := by
      simp only [roundStrategy, mul_add, Finset.sum_add_distrib, mul_ite,
        mul_one, mul_zero]
      apply congrArg (fun z : ℝ => z + ∑ e, G.occurrences.weight e * ε e)
      apply Finset.sum_congr rfl
      intro e _
      by_cases h : G.projection e
          (roundLabel (legalL (G.left e)) (defaultL (G.left e)) (s.1 (G.left e))) =
          roundLabel (legalR (G.right e)) (defaultR (G.right e)) (s.2 (G.right e))
      · simp [h]
      · simp [h]

theorem completed_success_lift (ν : ∀ e, FiniteDistribution (Seed e))
    (complete : ∀ e, Seed e → A → B)
    (legalL : ∀ x, L x ↪ A) (legalR : ∀ y, R y ↪ B)
    (agrees : ∀ e seed l, complete e seed (legalL (G.left e) l) =
      legalR (G.right e) (G.projection e l))
    (s : LegalStrategy L R) :
    (G.completedGame ν complete).success (liftStrategy legalL legalR s) = G.success s := by
  change (sigmaLaw G.occurrences ν).probability
    (fun es => decide (complete es.1 es.2 (legalL (G.left es.1) (s.1 (G.left es.1))) =
      legalR (G.right es.1) (s.2 (G.right es.1)))) = G.success s
  have hpoint : (fun es : Σ e, Seed e =>
      decide (complete es.1 es.2 (legalL (G.left es.1) (s.1 (G.left es.1))) =
        legalR (G.right es.1) (s.2 (G.right es.1)))) =
      (fun es => G.wins s es.1) := by
    funext es
    simp only [agrees, wins, (legalR (G.right es.1)).injective.eq_iff]
  rw [hpoint, sigmaLaw_probability_first]
  rfl

variable [∀ x, Fintype (L x)] [∀ y, Fintype (R y)]
  [∀ x, Nonempty (L x)] [∀ y, Nonempty (R y)] [Nonempty A] [Nonempty B]

theorem completed_value_le (ν : ∀ e, FiniteDistribution (Seed e))
    (complete : ∀ e, Seed e → A → B)
    (legalL : ∀ x, L x ↪ A) (legalR : ∀ y, R y ↪ B)
    (agrees : ∀ e seed l, complete e seed (legalL (G.left e) l) =
      legalR (G.right e) (G.projection e l))
    (ε : E → ℝ) (hε : ∀ e, 0 ≤ ε e)
    (marginal : ∀ e a, a ∉ Set.range (legalL (G.left e)) → ∀ b,
      (ν e).probability (fun seed => decide (complete e seed a = b)) ≤ ε e) :
    (G.completedGame ν complete).value ≤ G.value + G.occurrences.expectation ε := by
  apply ((G.completedGame ν complete).value_le_iff _).2
  intro s
  let defaultL : ∀ x, L x := fun x => Classical.choice inferInstance
  let defaultR : ∀ y, R y := fun y => Classical.choice inferInstance
  exact (G.completed_success_le ν complete legalL legalR defaultL defaultR agrees ε hε marginal s).trans
    (add_le_add (G.success_le_value _) (le_refl _))

theorem completed_value_le_of_bound (ν : ∀ e, FiniteDistribution (Seed e))
    (complete : ∀ e, Seed e → A → B)
    (legalL : ∀ x, L x ↪ A) (legalR : ∀ y, R y ↪ B)
    (agrees : ∀ e seed l, complete e seed (legalL (G.left e) l) =
      legalR (G.right e) (G.projection e l))
    (ε : E → ℝ) (hε : ∀ e, 0 ≤ ε e)
    (marginal : ∀ e a, a ∉ Set.range (legalL (G.left e)) → ∀ b,
      (ν e).probability (fun seed => decide (complete e seed a = b)) ≤ ε e)
    (δ : ℝ) (hδ : ∀ e, ε e ≤ δ) :
    (G.completedGame ν complete).value ≤ G.value + δ := by
  apply (G.completed_value_le ν complete legalL legalR agrees ε hε marginal).trans
  apply add_le_add (le_refl G.value)
  unfold FiniteDistribution.expectation
  calc
    _ ≤ ∑ e, G.occurrences.weight e * δ := by
      apply Finset.sum_le_sum
      intro e _
      exact mul_le_mul_of_nonneg_left (hδ e) (G.occurrences.nonnegative e)
    _ = δ := by rw [← Finset.sum_mul, G.occurrences.normalized, one_mul]

theorem completed_value_eq_one (ν : ∀ e, FiniteDistribution (Seed e))
    (complete : ∀ e, Seed e → A → B)
    (legalL : ∀ x, L x ↪ A) (legalR : ∀ y, R y ↪ B)
    (agrees : ∀ e seed l, complete e seed (legalL (G.left e) l) =
      legalR (G.right e) (G.projection e l))
    (hcomplete : G.value = 1) : (G.completedGame ν complete).value = 1 := by
  apply le_antisymm (G.completedGame ν complete).value_le_one
  obtain ⟨s, hs⟩ := G.exists_optimal_strategy
  calc
    1 = G.success s := (hs.trans hcomplete).symm
    _ = (G.completedGame ν complete).success (liftStrategy legalL legalR s) :=
      (G.completed_success_lift ν complete legalL legalR agrees s).symm
    _ ≤ _ := (G.completedGame ν complete).success_le_value _

end Completion

variable [Fintype Q₁] [Fintype Q₂] [∀ x, Fintype (L x)]
  {A B : Type*} [Fintype A] [Fintype B]

theorem embedded_fiber_le_two {L₀ R₀ B₀ : Type*} [Fintype L₀]
    (j : R₀ ↪ B₀) (p : L₀ → R₀)
    (hsmall : ∀ r, Fintype.card {l : L₀ // p l = r} ≤ 2) (b : B₀) :
    Fintype.card {l : L₀ // j (p l) = b} ≤ 2 := by
  by_cases hb : ∃ r : R₀, j r = b
  · obtain ⟨r, rfl⟩ := hb
    let e : {l : L₀ // j (p l) = j r} ≃ {l : L₀ // p l = r} :=
      Equiv.subtypeEquivRight (fun l =>
        ⟨fun h => j.injective h, fun h => congrArg j h⟩)
    exact (Fintype.card_congr e).le.trans (hsmall r)
  · have hzero : Fintype.card {l : L₀ // j (p l) = b} = 0 :=
      Fintype.card_eq_zero_iff.mpr ⟨fun l => hb ⟨p l.val, l.property⟩⟩
    rw [hzero]
    exact Nat.zero_le 2

structure CompletionFamily (legalL : ∀ x, L x ↪ A) (legalR : ∀ y, R y ↪ B) where
  size : E → Nat
  positive : ∀ e, 0 < size e
  map : ∀ e, Fin (size e) → A → B
  agrees : ∀ e seed l, map e seed (legalL (G.left e) l) =
    legalR (G.right e) (G.projection e l)
  exact_two : ∀ e seed b, Fintype.card {a : A // map e seed a = b} = 2
  illegal_probability : ∀ e (a : Illegal (legalL (G.left e))) (b : B),
    uniformProbability (fun seed => map e seed a.val = b) ≤
      2 / (Fintype.card A - Fintype.card (L (G.left e)) : Nat)

omit [Fintype Q₁] [Fintype Q₂] in
theorem completionFamily_nonempty
    (legalL : ∀ x, L x ↪ A) (legalR : ∀ y, R y ↪ B)
    (hsmall : ∀ e b, Fintype.card {l : L (G.left e) // G.projection e l = b} ≤ 2)
    (hcard : Fintype.card A = 2 * Fintype.card B) :
    Nonempty (G.CompletionFamily legalL legalR) := by
  have hexists (e : E) := exists_completion_sampler (legalL (G.left e))
    (fun l => legalR (G.right e) (G.projection e l))
    (embedded_fiber_le_two (legalR (G.right e)) (G.projection e) (hsmall e)) hcard
  choose n hn sampler hext hexact hprob using hexists
  refine ⟨{
    size := n
    positive := hn
    map := sampler
    agrees := hext
    exact_two := hexact
    illegal_probability := ?_ }⟩
  intro e a b
  simpa only [← Nat.card_eq_fintype_card] using (hprob e a b).2

namespace CompletionFamily
variable {G} {legalL : ∀ x, L x ↪ A} {legalR : ∀ y, R y ↪ B}

def seedLaw (F : G.CompletionFamily legalL legalR) (e : E) :
    FiniteDistribution (Fin (F.size e)) := by
  letI : Nonempty (Fin (F.size e)) := ⟨⟨0, F.positive e⟩⟩
  exact FiniteDistribution.uniform (Fin (F.size e))

def game (F : G.CompletionFamily legalL legalR) :
    OccurrenceGame (Σ e, Fin (F.size e)) Q₁ Q₂ A B :=
  G.completedGame F.seedLaw F.map

omit [Fintype Q₁] [Fintype Q₂] [Fintype B] in
theorem marginal (F : G.CompletionFamily legalL legalR) (e : E)
    (a : A) (ha : a ∉ Set.range (legalL (G.left e))) (b : B) :
    (F.seedLaw e).probability (fun seed => decide (F.map e seed a = b)) ≤
      2 / (Fintype.card A - Fintype.card (L (G.left e)) : Nat) := by
  let : Nonempty (Fin (F.size e)) := ⟨⟨0, F.positive e⟩⟩
  change (FiniteDistribution.uniform (Fin (F.size e))).probability _ ≤ _
  rw [probability_uniform_eq_uniformProbability]
  exact F.illegal_probability e ⟨a, ha⟩ b

variable [∀ y, Fintype (R y)] [∀ x, Nonempty (L x)] [∀ y, Nonempty (R y)]
  [Nonempty A] [Nonempty B]

theorem value_le (F : G.CompletionFamily legalL legalR) :
    F.game.value ≤ G.value + G.occurrences.expectation
      (fun e => 2 / (Fintype.card A - Fintype.card (L (G.left e)) : Nat)) := by
  apply G.completed_value_le F.seedLaw F.map legalL legalR F.agrees
  · intro e
    exact div_nonneg (by norm_num) (Nat.cast_nonneg _)
  · exact F.marginal

theorem value_le_of_bound (F : G.CompletionFamily legalL legalR)
    (δ : ℝ) (hδ : ∀ e,
      2 / (Fintype.card A - Fintype.card (L (G.left e)) : Nat) ≤ δ) :
    F.game.value ≤ G.value + δ := by
  apply G.completed_value_le_of_bound F.seedLaw F.map legalL legalR F.agrees
      (fun e => 2 / (Fintype.card A - Fintype.card (L (G.left e)) : Nat))
      (fun e => div_nonneg (by norm_num) (Nat.cast_nonneg _)) F.marginal δ hδ

theorem value_eq_one (F : G.CompletionFamily legalL legalR) (hcomplete : G.value = 1) :
    F.game.value = 1 :=
  G.completed_value_eq_one F.seedLaw F.map legalL legalR F.agrees hcomplete

end CompletionFamily

end LegalProjectionGame

end
end PerfectCompleteness.CompletionSoundness

end OAI