import Mathlib
import OAI.Computability.MinUncut.Games.HintSoundness

namespace OAI

noncomputable section
open scoped BigOperators
namespace MinUncut.Outer
open MinUncut.Inner
attribute [local instance] Classical.propDecidable BinaryFourier.dualFintype

def paddedChoice {A : Type*} [Nonempty A] (S : Finset A) {L : ℕ} (i : Fin L) : A :=
  if h : i.val<S.card then ((Finset.equivFin S).symm ⟨i.val,h⟩).val else Classical.ofNonempty

lemma paddedChoice_covers {A : Type*} [Nonempty A] (S : Finset A) {L : ℕ}
    (hS : S.card≤L) (a : A) (ha : a ∈ S) : ∃ i : Fin L, paddedChoice S i=a := by
  let j := (Finset.equivFin S) ⟨a,ha⟩
  let i : Fin L := ⟨j.val,j.isLt.trans_le hS⟩
  refine ⟨i,?_⟩
  simp only [paddedChoice,i,dite_eq_left j.isLt]
  exact congrArg Subtype.val ((Finset.equivFin S).symm_apply_apply ⟨a,ha⟩)

variable {Name I : Type*} [Fintype I]

structure HintLists (Name I : Type*) [Fintype I] (q : ℕ) where
  first : (U : I → Equation Name) → (Fin q → Forms (FirstAlphabet U)) → Finset (FirstAlphabet U)
  second : (V : I → SecondQuestion Name) → (Fin q → Forms (SecondAlphabet V)) → Finset (SecondAlphabet V)

def HintLists.strategy {q L R : ℕ} (lists : HintLists Name I q) (z : Fin L × Fin R) :
    HintedStrategy Name I q where
  first U B := paddedChoice (lists.first U B) z.1
  second V B := paddedChoice (lists.second V B) z.2

def HintLists.matches {q : ℕ} (lists : HintLists Name I q)
    (U : I → Equation Name) (hidden : I → Bool) (pos : I → Fin 3)
    (B : Fin q → Forms (SecondAlphabet (secondQuestion U hidden pos))) : Prop :=
  ∃ a ∈ lists.first U (fun j => formPullback (projection U hidden pos) (B j)),
    ∃ b ∈ lists.second (secondQuestion U hidden pos) B, projection U hidden pos a=b

lemma HintLists.matching_le_sum {q L R : ℕ} (lists : HintLists Name I q)
    (hL : ∀ U B, (lists.first U B).card≤L)
    (hR : ∀ V B, (lists.second V B).card≤R)
    (U : I → Equation Name) (hidden : I → Bool) (pos : I → Fin 3)
    (B : Fin q → Forms (SecondAlphabet (secondQuestion U hidden pos))) :
    (if lists.matches U hidden pos B then (1 : ℝ) else 0) ≤
      ∑ z : Fin L × Fin R, if hintedAcceptance (lists.strategy z) U hidden pos B then 1 else 0 := by
  classical
  by_cases hm : lists.matches U hidden pos B
  · rw [ite_eq_left hm]
    obtain ⟨a,ha,b,hb,hab⟩ := hm
    obtain ⟨i,hi⟩ := paddedChoice_covers _ (hL _ _) a ha
    obtain ⟨j,hj⟩ := paddedChoice_covers _ (hR _ _) b hb
    have hwin : hintedAcceptance (lists.strategy (i,j)) U hidden pos B := by
      change projection U hidden pos (paddedChoice _ i)=paddedChoice _ j
      rw [hi,hj]
      exact hab
    have hs := Finset.single_le_sum (s := Finset.univ) (f := fun z : Fin L × Fin R =>
      if hintedAcceptance (lists.strategy z) U hidden pos B then (1 : ℝ) else 0)
      (fun _ _ => by positivity) (Finset.mem_univ (i,j))
    simpa only [ite_eq_left hwin] using hs
  · rw [ite_eq_right hm]
    exact Finset.sum_nonneg (fun _ _ => by positivity)

theorem HintLists.shared_soundness [Fintype Name]
    {S : Type*} [Fintype S] [Nonempty S] (equations : S → Equation Name)
    (hsound : ∀ s : Name → F₂, equationFraction equations s ≤ 3/4)
    {q L R : ℕ} (lists : HintLists Name I q)
    (hL : ∀ U B, (lists.first U B).card≤L)
    (hR : ∀ V B, (lists.second V B).card≤R) (hidden : I → Bool) :
    (𝔼 w : I → S × Fin 3,
      𝔼 B : Fin q → Forms (SecondAlphabet
        (secondQuestion (sampledEquations equations w) hidden (sampledPositions w))),
      if lists.matches (sampledEquations equations w) hidden (sampledPositions w) B
        then (1 : ℝ) else 0) ≤
      (L : ℝ)*(R : ℝ)*hintRate q ^ Fintype.card {i // hidden i=true} := by
  calc
    _ ≤ 𝔼 w : I → S × Fin 3,
        𝔼 B : Fin q → Forms (SecondAlphabet
          (secondQuestion (sampledEquations equations w) hidden (sampledPositions w))),
        ∑ z : Fin L × Fin R,
          if hintedAcceptance (lists.strategy z) (sampledEquations equations w) hidden
            (sampledPositions w) B then (1 : ℝ) else 0 := by
      apply Finset.expect_le_expect
      intro w _
      exact Finset.expect_le_expect (fun B _ => lists.matching_le_sum hL hR _ hidden _ B)
    _ = ∑ z : Fin L × Fin R, 𝔼 w : I → S × Fin 3,
        𝔼 B : Fin q → Forms (SecondAlphabet
          (secondQuestion (sampledEquations equations w) hidden (sampledPositions w))),
          if hintedAcceptance (lists.strategy z) (sampledEquations equations w) hidden
            (sampledPositions w) B then (1 : ℝ) else 0 := by
      simp_rw [Finset.expect_sum_comm]
    _ ≤ ∑ _z : Fin L × Fin R, hintRate q ^ Fintype.card {i // hidden i=true} := by
      apply Finset.sum_le_sum
      intro z _
      exact shared_hint_soundness equations hsound (lists.strategy z) hidden
    _ = _ := by simp [mul_assoc]


open scoped BigOperators
open MinUncut.Inner
attribute [local instance] Classical.propDecidable BinaryFourier.dualFintype
variable {Name I : Type*} [Fintype I]

abbrev CoordinateSlot (E : Equation Name) := Fin (Module.finrank F₂ (alphabet E).direction) → F₂
abbrev FirstCoordinateSpace (U : I → Equation Name) := ∀ i, CoordinateSlot (U i)

def firstCoordinates (U : I → Equation Name) :
    FirstCoordinateSpace U ≃ᵃ[F₂] FirstAlphabet U :=
  (LinearEquiv.piCongrRight (fun i => coordinates (U i))).toAffineEquiv.trans
    (AffineEquiv.vaddConst F₂ (fun i => origin (U i)))

omit [Fintype I] in
@[simp] lemma firstCoordinates_apply (U : I → Equation Name)
    (v : FirstCoordinateSpace U) (i : I) :
    (firstCoordinates U v i).val = directionEmbedding (U i) (v i) + (origin (U i)).val := rfl

omit [Fintype I] in
lemma firstCoordinates_symm_apply (U : I → Equation Name) (a : FirstAlphabet U) (i : I) :
    (firstCoordinates U).symm a i = (alphabetCoordinates (U i)).symm (a i) := rfl

def formsTransport {V W A B : Type*} [AddCommGroup V] [Module F₂ V] [AddTorsor V A]
    [AddCommGroup W] [Module F₂ W] [AddTorsor W B] (e : A ≃ᵃ[F₂] B) :
    Forms B ≃ₗ[F₂] Forms A where
  toFun f := f.comp e.toAffineMap
  invFun f := f.comp e.symm.toAffineMap
  left_inv f := by ext b; simp
  right_inv f := by ext a; simp
  map_add' f g := by ext a; rfl
  map_smul' c f := by ext a; rfl

def firstFormCoordinates (U : I → Equation Name) :
    (F₂ × (∀ i, Module.Dual F₂ (CoordinateSlot (U i)))) ≃ₗ[F₂] Forms (FirstAlphabet U) :=
  ((LinearEquiv.refl F₂ F₂).prodCongr
    (LinearMap.lsum F₂ (fun i => CoordinateSlot (U i)) F₂)).trans
    ((AffineMap.toConstProdLinearMap F₂).symm.trans (formsTransport (firstCoordinates U)).symm)

lemma firstFormCoordinates_apply (U : I → Equation Name) (κ : F₂)
    (b : ∀ i, Module.Dual F₂ (CoordinateSlot (U i))) (a : FirstAlphabet U) :
    firstFormCoordinates U (κ,b) a =
      (∑ i, b i ((alphabetCoordinates (U i)).symm (a i)))+κ := by
  change (∑ i, (b i).comp (LinearMap.proj i)) ((firstCoordinates U).symm a)+κ=_
  simp only [LinearMap.sum_apply,LinearMap.comp_apply,LinearMap.proj_apply,
    firstCoordinates_symm_apply]

abbrev TupleCoordinateData (U : I → Equation Name) (d : ℕ) :=
  (Fin d → F₂) × (∀ i, OuterSmoothness.JointForms.Block
    (Module.finrank F₂ (alphabet (U i)).direction) d)

def tupleCoordinateSlice (U : I → Equation Name) (d : ℕ) (k : Fin d) :
    TupleCoordinateData U d →ₗ[F₂] (F₂ × (∀ i, Module.Dual F₂ (CoordinateSlot (U i)))) where
  toFun z := (z.1 k,fun i => z.2 i k)
  map_add' _ _ := rfl
  map_smul' _ _ := rfl

def tupleCoordinateGenerator (U : I → Equation Name) (d : ℕ) :
    TupleCoordinateData U d →ₗ[F₂] (Fin d → Forms (FirstAlphabet U)) :=
  LinearMap.pi (fun k => (firstFormCoordinates U).toLinearMap.comp (tupleCoordinateSlice U d k))

lemma tupleCoordinateGenerator_surjective (U : I → Equation Name) (d : ℕ) :
    Function.Surjective (tupleCoordinateGenerator U d) := by
  intro f
  let z := fun k => (firstFormCoordinates U).symm (f k)
  refine ⟨(fun k => (z k).1,fun i k => (z k).2 i),?_⟩
  funext k
  exact (firstFormCoordinates U).apply_symm_apply (f k)

lemma uniform_tupleCoordinateGenerator (U : I → Equation Name) (d : ℕ)
    (f : (Fin d → Forms (FirstAlphabet U)) → ℝ) :
    (𝔼 z : TupleCoordinateData U d, f (tupleCoordinateGenerator U d z)) = 𝔼 L, f L :=
  IndependentSquares.expect_surjective_linear _ (tupleCoordinateGenerator_surjective U d) f

end MinUncut.Outer

end

end OAI