import Mathlib.Algebra.BigOperators.Expect
import Mathlib.Basic.Real.Basic
import OAI.Computability.PerfectCompleteness.Foundations.DummyEliminationLemmas
import OAI.Computability.PerfectCompleteness.Reduction.CompletionSoundness
import OAI.Computability.PerfectCompleteness.Sampling.DensityVariation

namespace OAI


namespace PerfectCompleteness.CommonProductVariation

open scoped BigOperators
open UniqueGamesTheorem.Foundations.Games

noncomputable section

variable {S A Γ : Type*} [Fintype S] [Fintype A] [Fintype Γ]

theorem product_totalVariation (μ : FiniteDistribution S)
    (P Q : FiniteDistribution A) :
    (μ.product P).totalVariation (μ.product Q) = P.totalVariation Q := by
  change (∑ z : S × A,
    |μ.weight z.1 * P.weight z.2 - μ.weight z.1 * Q.weight z.2|) / 2 =
      (∑ a : A, |P.weight a - Q.weight a|) / 2
  rw [Fintype.sum_prod_type]
  simp_rw [← mul_sub, abs_mul, abs_of_nonneg (μ.nonnegative _), ← Finset.mul_sum]
  rw [← Finset.sum_mul, μ.normalized, one_mul]

theorem observed_product_le (μ : FiniteDistribution S)
    (P Q : FiniteDistribution A) (observe : S × A → Γ) :
    ((μ.product P).pushforward observe).totalVariation
      ((μ.product Q).pushforward observe) ≤ P.totalVariation Q :=
  (DensityVariation.variation_pushforward_le _ _ observe).trans_eq
    (product_totalVariation μ P Q)

theorem observed_product_le_of_bound (μ : FiniteDistribution S)
    (P Q : FiniteDistribution A) (observe : S × A → Γ)
    {error : ℝ} (herror : P.totalVariation Q ≤ error) :
    ((μ.product P).pushforward observe).totalVariation
      ((μ.product Q).pushforward observe) ≤ error :=
  (observed_product_le μ P Q observe).trans herror

end
end PerfectCompleteness.CommonProductVariation


namespace PerfectCompleteness.ConditionalVariation

open scoped BigOperators
open UniqueGamesTheorem.Foundations.Games
open CompletionSoundness

noncomputable section

variable {S : Type*} [Fintype S] {Ω : S → Type*} [∀ s, Fintype (Ω s)]

theorem sigma_totalVariation (μ : FiniteDistribution S)
    (P Q : (s : S) → FiniteDistribution (Ω s)) :
    (sigmaLaw μ P).totalVariation (sigmaLaw μ Q) =
      μ.expectation (fun s => (P s).totalVariation (Q s)) := by
  change (∑ z : Σ s, Ω s,
    |μ.weight z.1 * (P z.1).weight z.2 - μ.weight z.1 * (Q z.1).weight z.2|) / 2 =
      ∑ s, μ.weight s * ((∑ x : Ω s, |(P s).weight x - (Q s).weight x|) / 2)
  rw [Fintype.sum_sigma, div_eq_mul_inv, Finset.sum_mul]
  apply Finset.sum_congr rfl
  intro s _
  simp_rw [← mul_sub, abs_mul, abs_of_nonneg (μ.nonnegative s)]
  rw [← Finset.mul_sum]
  simp only [div_eq_mul_inv, mul_assoc]

theorem observed_sigma_le {Γ : Type*} [Fintype Γ]
    (μ : FiniteDistribution S) (P Q : (s : S) → FiniteDistribution (Ω s))
    (observe : (Σ s, Ω s) → Γ) :
    ((sigmaLaw μ P).pushforward observe).totalVariation
      ((sigmaLaw μ Q).pushforward observe) ≤
        μ.expectation (fun s => (P s).totalVariation (Q s)) := by
  rw [← sigma_totalVariation μ P Q]
  exact DensityVariation.variation_pushforward_le _ _ observe

theorem observed_sigma_le_of_bound {Γ : Type*} [Fintype Γ]
    (μ : FiniteDistribution S) (P Q : (s : S) → FiniteDistribution (Ω s))
    (error : S → ℝ) (bound : ∀ s, (P s).totalVariation (Q s) ≤ error s)
    (observe : (Σ s, Ω s) → Γ) :
    ((sigmaLaw μ P).pushforward observe).totalVariation
      ((sigmaLaw μ Q).pushforward observe) ≤ μ.expectation error :=
  (observed_sigma_le μ P Q observe).trans (SmallBias.expectation_mono μ bound)

theorem observed_sigma_le_const {Γ : Type*} [Fintype Γ]
    (μ : FiniteDistribution S) (P Q : (s : S) → FiniteDistribution (Ω s))
    (error : ℝ) (bound : ∀ s, (P s).totalVariation (Q s) ≤ error)
    (observe : (Σ s, Ω s) → Γ) :
    ((sigmaLaw μ P).pushforward observe).totalVariation
      ((sigmaLaw μ Q).pushforward observe) ≤ error := by
  simpa only [SmallBias.expectation_const] using
    observed_sigma_le_of_bound μ P Q (fun _ => error) bound observe

end
end PerfectCompleteness.ConditionalVariation


namespace PerfectCompleteness.DummyElimination.Slice

noncomputable section

open scoped BigOperators Classical

variable {𝕜 H D K R C : Type*} [Field 𝕜]
  [AddCommGroup H] [Module 𝕜 H] [AddCommGroup D] [Module 𝕜 D]
  [AddCommGroup K] [Module 𝕜 K] [AddCommGroup R] [Module 𝕜 R]
  [AddCommGroup C] [Module 𝕜 C]
  (S : DummyElimination.Slice 𝕜 H D K R C)

abbrev Lifted := {p : (H →ₗ[𝕜] K) × (D →ₗ[𝕜] K) // S.IsLift p.1 p.2}
abbrev ProjectedMatrices := {X : H →ₗ[𝕜] K // S.Projected X}
abbrev HomogeneousMaps := {Z : D →ₗ[𝕜] K // S.Homogeneous Z}

def chosenLift (hne : ∃ X Y, S.IsLift X Y) (X : S.ProjectedMatrices) :
    {Y : D →ₗ[𝕜] K // S.IsLift X.val Y} :=
  ⟨Classical.choose ((S.exists_lift_iff hne X.val).mpr X.property),
    Classical.choose_spec ((S.exists_lift_iff hne X.val).mpr X.property)⟩

def liftedEquivProduct (hne : ∃ X Y, S.IsLift X Y) :
    S.Lifted ≃ S.ProjectedMatrices × S.HomogeneousMaps where
  toFun p :=
    let X : S.ProjectedMatrices := ⟨p.val.1, IsLift.projected S p.property⟩
    (X, S.fiberEquivHomogeneous (S.chosenLift hne X).property ⟨p.val.2, p.property⟩)
  invFun p :=
    let Y := (S.fiberEquivHomogeneous (S.chosenLift hne p.1).property).symm p.2
    ⟨(p.1.val, Y.val), Y.property⟩
  left_inv p := by
    apply Subtype.ext
    apply Prod.ext
    · rfl
    · exact congrArg Subtype.val
        ((S.fiberEquivHomogeneous
          (S.chosenLift hne ⟨p.val.1, IsLift.projected S p.property⟩).property).symm_apply_apply
            ⟨p.val.2, p.property⟩)
  right_inv p := by
    apply Prod.ext
    · rfl
    · exact (S.fiberEquivHomogeneous (S.chosenLift hne p.1).property).apply_symm_apply p.2

@[simp] theorem liftedEquivProduct_fst (hne : ∃ X Y, S.IsLift X Y) (p : S.Lifted) :
    (S.liftedEquivProduct hne p).1.val = p.val.1 := rfl

theorem expect_projected [Fintype (H →ₗ[𝕜] K)] [Fintype (D →ₗ[𝕜] K)]
    (hne : ∃ X Y, S.IsLift X Y) (g : (H →ₗ[𝕜] K) → ℝ) :
    (𝔼 p : S.Lifted, g p.val.1) = (𝔼 X : S.ProjectedMatrices, g X.val) := by
  let : Nonempty S.HomogeneousMaps := ⟨⟨0, by simp [Homogeneous]⟩⟩
  calc
    _ = 𝔼 p : S.ProjectedMatrices × S.HomogeneousMaps, g p.1.val :=
      Fintype.expect_equiv (S.liftedEquivProduct hne) _ _ (fun _ => rfl)
    _ = 𝔼 X : S.ProjectedMatrices, 𝔼 _Z : S.HomogeneousMaps, g X.val := by
      simpa only [Finset.univ_product_univ] using
        (Finset.expect_product (Finset.univ : Finset S.ProjectedMatrices)
          (Finset.univ : Finset S.HomogeneousMaps) (fun p => g p.1.val))
    _ = _ := by simp only [Fintype.expect_const]

end
end PerfectCompleteness.DummyElimination.Slice

end OAI