import Mathlib
import OAI.Probability.SKRatio.Quantization.BinTail
import OAI.Probability.SKRatio.Variational.ScalarCoherent

namespace OAI

noncomputable section
open scoped BigOperators Matrix ENNReal
open MeasureTheory ProbabilityTheory Filter Real
namespace SKRatio.Bins
open Planted Scalar SKRatioClock.Regression MatrixNet Calculus
attribute [local instance] Classical.propDecidable

lemma independent_finite_selection_bound
    {Ω A D : Type*} [MeasurableSpace Ω] [MeasurableSpace A]
    [Fintype D] [MeasurableSpace D] [MeasurableSingletonClass D]
    {μ : Measure Ω} [IsProbabilityMeasure μ] {R : Ω → A} {X : Ω → D}
    (hX : Measurable X) (hRX : IndepFun R X μ)
    (E : D → Set A) (hE : ∀ d, MeasurableSet (E d))
    {B : ℝ} (hB : ∀ d, μ.real (R ⁻¹' E d) ≤ B) :
    μ.real {ω | R ω ∈ E (X ω)} ≤ B := by
  have hall : (⋃ d : D, X ⁻¹' {d}) = Set.univ := by
    ext ω
    simp
  have hdis : Pairwise (Function.onFun Disjoint (fun d : D => X ⁻¹' {d})) := by
    intro d e hde
    exact Set.disjoint_left.mpr (fun ω hd he => hde ((Set.mem_singleton_iff.mp hd).symm.trans
      (Set.mem_singleton_iff.mp he)))
  have hsum : (∑ d, μ.real (X ⁻¹' {d})) = 1 := by
    rw [←measureReal_iUnion_fintype hdis (fun d => (MeasurableSet.singleton d).preimage hX),hall]
    simp [Measure.real]
  have hb (d : D) : μ.real (R ⁻¹' E d ∩ X ⁻¹' {d}) ≤ B*μ.real (X ⁻¹' {d}) := by
    have hi := hRX.measure_inter_preimage_eq_mul (E d) {d} (hE d) (MeasurableSet.singleton d)
    change (μ _).toReal ≤ _
    rw [hi,ENNReal.toReal_mul]
    exact mul_le_mul_of_nonneg_right (hB d) ENNReal.toReal_nonneg
  calc
    _ ≤ μ.real (⋃ d : D, R ⁻¹' E d ∩ X ⁻¹' {d}) := by
      apply measureReal_mono _ (measure_ne_top _ _)
      intro ω hω
      exact Set.mem_iUnion.mpr ⟨X ω,hω,rfl⟩
    _ ≤ ∑ d, μ.real (R ⁻¹' E d ∩ X ⁻¹' {d}) := measureReal_iUnion_fintype_le _
    _ ≤ ∑ d, B*μ.real (X ⁻¹' {d}) := Finset.sum_le_sum (fun d _ => hb d)
    _ = B := by rw [←Finset.mul_sum,hsum,mul_one]

def residualFormBad {α : Type*} {n : ℕ} (β : ℝ) (h : α → ℝ)
    (σ : Fin n → α) (K C : ℝ) : Set ((Fin n × Fin n) → ℝ) :=
  {M | euclideanOpNorm (fun i j => M (i,j)) ≤ K ∧
    ∃ p : Fin n → ℝ, (∑ i, p i^2)=1 ∧ C <
      p ⬝ᵥ ((fun i j => M (i,j))*ᵥ (fun i => v (h (σ i))*p i))+
        correctedForm β (fun i => h (σ i)) p}

lemma residualFormBad_measurable {α : Type*} {n : ℕ}
    (β : ℝ) (h : α → ℝ) (σ : Fin n → α) (K C : ℝ) :
    MeasurableSet (residualFormBad β h σ K C) := by
  have hc : Continuous (fun M : (Fin n × Fin n) → ℝ =>
      euclideanOpNorm (fun i j => M (i,j))) := by
    have : ContinuousSMul ℝ (EuclideanSpace ℝ (Fin n)) :=
      IsBoundedSMul.continuousSMul
    have : ContinuousSMul ℝ (EuclideanSpace ℝ (Fin n) →L[ℝ] EuclideanSpace ℝ (Fin n)) :=
      ContinuousLinearMap.continuousSMul
    exact continuous_norm.comp
      (((Matrix.toEuclideanCLM (𝕜 := ℝ) (n := Fin n)).toAlgEquiv.toLinearEquiv.toLinearMap.continuous_of_finiteDimensional).comp
        (by fun_prop))
  have ho : IsOpen {M : (Fin n × Fin n) → ℝ |
      ∃ p : Fin n → ℝ, (∑ i, p i^2)=1 ∧ C <
        p ⬝ᵥ ((fun i j => M (i,j))*ᵥ (fun i => v (h (σ i))*p i))+
          correctedForm β (fun i => h (σ i)) p} := by
    have he : {M : (Fin n × Fin n) → ℝ | ∃ p : Fin n → ℝ, (∑ i, p i^2)=1 ∧ C <
        p ⬝ᵥ ((fun i j => M (i,j))*ᵥ (fun i => v (h (σ i))*p i))+
          correctedForm β (fun i => h (σ i)) p} =
        ⋃ p : {p : Fin n → ℝ // (∑ i, p i^2)=1}, {M | C <
        p.val ⬝ᵥ ((fun i j => M (i,j))*ᵥ (fun i => v (h (σ i))*p.val i))+
          correctedForm β (fun i => h (σ i)) p.val} := by
      ext M
      simp
    rw [he]
    apply isOpen_iUnion
    intro p
    apply isOpen_lt continuous_const
    unfold dotProduct Matrix.mulVec
    fun_prop
  exact (measurableSet_le hc.measurable measurable_const).inter ho.measurableSet

theorem random_binForm_tail {α : Type*} [Fintype α] [DecidableEq α]
    [MeasurableSpace α] [MeasurableSingletonClass α]
    {β K a C : ℝ} (hβ : 0<β) (hK : 0≤K) (ha : 0<a)
    (h : α → ℝ) (q : ℝ → α) (hq : Measurable q) :
    ∃ N : ℕ, ∀ {n : ℕ} (_hn : 0<n),
      (standardArrayLaw (Fin n × Fin n)).real {g |
        (∀ d, 2≤count (fun i => q (augmentedField β g i)) d) ∧
        (∀ z : Parameters α, finiteV β (binT (fun i => q (augmentedField β g i))) h z≤C) ∧
        g ∈ binFormBad β h (fun i => q (augmentedField β g i)) K (C+2*a)} ≤
      N*exp (-a^2*(n:ℝ)/(π^2*β^2)) := by
  obtain ⟨N,hN⟩ := binForm_tail hβ hK ha h
  refine ⟨N,?_⟩
  intro n hn
  let μ := standardArrayLaw (Fin n × Fin n)
  let R := fun g : (Fin n × Fin n) → ℝ => fun p : Fin n × Fin n =>
    (fieldProjection n*(β • goe g)*fieldProjection n) p.1 p.2
  let X := fun g : (Fin n × Fin n) → ℝ => fun i => q (augmentedField β g i)
  let good := fun σ : Fin n → α => (∀ d, 2≤count σ d) ∧
    (∀ z : Parameters α, finiteV β (binT σ) h z≤C)
  let E := fun σ : Fin n → α => if good σ then residualFormBad β h σ K (C+2*a) else ∅
  have hX : Measurable X := by
    apply Measurable.of_eval
    intro i
    apply hq.comp
    unfold augmentedField augmented goe
    fun_prop
  have hi : IndepFun R X μ := by
    have ht := (field_residual_independent hn β).comp measurable_id
      (show Measurable (fun H : Fin n → ℝ => fun i => q (H i)) from
        Measurable.of_eval (fun i => hq.comp (measurable_pi_apply i)))
    exact ht
  have hE (σ : Fin n → α) : MeasurableSet (E σ) := by
    dsimp only [E]
    split_ifs
    · exact residualFormBad_measurable β h σ K (C+2*a)
    · exact MeasurableSet.empty
  have hb (σ : Fin n → α) : μ.real (R ⁻¹' E σ) ≤
      N*exp (-a^2*(n:ℝ)/(π^2*β^2)) := by
    dsimp only [E]
    split_ifs with hg
    · exact hN hn σ hg.1 C hg.2
    · simp only [Set.preimage_empty,measureReal_empty]
      positivity
  apply (measureReal_mono ?_ (measure_ne_top μ _)).trans
    (independent_finite_selection_bound hX hi E hE hb)
  intro g hg
  change R g ∈ E (X g)
  dsimp only [E]
  rw [ite_eq_left (show good (X g) from ⟨hg.1,hg.2.1⟩)]
  exact hg.2.2

end SKRatio.Bins

end

end OAI