import Mathlib
import OAI.Computability.MinUncut.Analysis.LowGradient
import OAI.Computability.MinUncut.Encoding.LocalDecoder

namespace OAI

noncomputable section
open scoped BigOperators
namespace MinUncut.Inner
open MeasureTheory ProbabilityTheory GaussianHermite RowNoise
attribute [local instance] Classical.propDecidable
attribute [local irreducible] query pullQuery
variable {V A V' A' : Type*} [AddCommGroup V] [Module F₂ V] [AddTorsor V A] [Fintype A]
  [AddCommGroup V'] [Module F₂ V'] [AddTorsor V' A'] [Fintype A'] {m n : ℕ}

def comparisonFailure (f : FoldedProof A) (g : FoldedProof A')
    (B : FaceArray A m n) (C : FaceArray A' m n) (σ η : ℝ)
    (c : Point m n → ℝ) (p : (Point m n → ℝ) × (Code m n → ℝ)) : ℝ :=
  if f.answer (pullQuery B (c+σ•p.1) (η•p.2)) =
    g.answer (pullQuery C (c+σ•p.1) (η•p.2)) then 0 else 1

def comparisonRejection (f : FoldedProof A) (g : FoldedProof A')
    (B : FaceArray A m n) (C : FaceArray A' m n) (σ η : ℝ)
    (c : Point m n → ℝ) : ℝ :=
  ∫ p, comparisonFailure f g B C σ η c p ∂(gauss (Point m n)).prod (gauss (Code m n))

omit [Fintype A] [Fintype A'] in
lemma comparisonFailure_eq (f : FoldedProof A) (g : FoldedProof A')
    (B : FaceArray A m n) (C : FaceArray A' m n) (σ η : ℝ)
    (c : Point m n → ℝ) (p : (Point m n → ℝ) × (Code m n → ℝ)) :
    (coupledAnswer f B σ η c p-coupledAnswer g C σ η c p)^2 =
      4*comparisonFailure f g B C σ η c p := by
  unfold coupledAnswer comparisonFailure
  cases f.answer (pullQuery B (c+σ•p.1) (η•p.2)) <;>
    cases g.answer (pullQuery C (c+σ•p.1) (η•p.2)) <;> norm_num [bitSign]

theorem gradient_comparison (f : FoldedProof A) (g : FoldedProof A')
    (B : FaceArray A m n) (C : FaceArray A' m n)
    (hn : 0 < n) {σ : ℝ} (hσ : σ≠0) (η : ℝ) (c : Point m n → ℝ) :
    spatialEnergy (fun x => gradient f B σ η c x-gradient g C σ η c x) ≤
      4*σ⁻¹^2*comparisonRejection f g B C σ η c := by
  let μ := (gauss (Point m n)).prod (gauss (Code m n))
  let D := fun p => coupledAnswer f B σ η c p-coupledAnswer g C σ η c p
  have hD : MemLp D 2 μ := (coupledAnswer_memLp f B σ η c).sub (coupledAnswer_memLp g C σ η c)
  have hX (x : Point m n) : MemLp (fun p => p.1 x) 2 μ :=
    (GaussianSmoothing.coordinate_memLp_two x).comp_fst (gauss (Code m n))
  have hXX (x y : Point m n) : (∫ p, p.1 x*p.1 y ∂μ)=if x=y then 1 else 0 := by
    have hi : Integrable (fun p : (Point m n → ℝ) × (Code m n → ℝ) => p.1 x*p.1 y) μ :=
      (hX x).integrable_mul (hX y)
    change (∫ p, p.1 x*p.1 y ∂(gauss (Point m n)).prod (gauss (Code m n)))=_
    rw [integral_prod _ hi]
    simpa only [integral_const,MeasureTheory.probReal_univ,one_smul,gauss,GaussianSmoothing.gamma] using GaussianSmoothing.coordinate_second_moment x y
  have hS := GaussianSmoothing.integral_bessel hX hXX hD
  have hN : (0 : ℝ)<(n^m:ℕ) := by exact_mod_cast pow_pos hn m
  have hd (x : Point m n) :
      gradient f B σ η c x-gradient g C σ η c x =
      Real.sqrt (n^m:ℕ)/σ*(∫ p, p.1 x*D p ∂μ) := by
    rw [gradient_coupled_score f B hσ,gradient_coupled_score g C hσ]
    simp only [D,mul_sub]
    rw [integral_sub (coupled_score_integrable f B σ η c x) (coupled_score_integrable g C σ η c x)]
    ring
  have he : spatialEnergy (fun x => gradient f B σ η c x-gradient g C σ η c x) =
      σ⁻¹^2*∑ x, (∫ p, p.1 x*D p ∂μ)^2 := by
    simp only [spatialEnergy,hd,mul_pow,div_pow,Real.sq_sqrt hN.le,← Finset.mul_sum]
    field_simp
  rw [he]
  calc
    _ ≤ σ⁻¹^2*(∫ p, (D p)^2 ∂μ) := mul_le_mul_of_nonneg_left hS (sq_nonneg _)
    _ = _ := by
      simp_rw [D,comparisonFailure_eq]
      rw [integral_const_mul]
      change σ⁻¹^2*(4*comparisonRejection f g B C σ η c)=_
      ring

def pullbackFaces (π : A →ᵃ[F₂] A') (C : FaceArray A' m n) : FaceArray A m n :=
  fun r => formPullback π (C r)

omit [Fintype A] [Fintype A'] in
@[simp] lemma labelCode_pullbackFaces (π : A →ᵃ[F₂] A') (C : FaceArray A' m n) (a : A) :
    labelCode (pullbackFaces π C) a = labelCode C (π a) := rfl

omit [Fintype A] [Fintype A'] in
@[simp] lemma pullQuery_pullbackFaces (π : A →ᵃ[F₂] A') (C : FaceArray A' m n)
    (u : Point m n → ℝ) (d : Code m n → ℝ) :
    pullQuery (pullbackFaces π C) u d = (pullQuery C u d) ∘ π := by
  funext a
  unfold pullQuery
  rw [labelCode_pullbackFaces]
  rfl

omit [Fintype A] [Fintype A'] in
lemma pullbackFaces_joinRow (π : A →ᵃ[F₂] A') (r : Row m n) (b : Forms A')
    (D : Rest (W := Forms A') r) :
    pullbackFaces π (joinRow r b D) =
      joinRow r (formPullback π b) (fun t => formPullback π (D t)) := by
  funext t
  by_cases ht : t=r
  · subst t
    simp [pullbackFaces]
  · simp only [pullbackFaces, joinRow_other r b D ⟨t,ht⟩,
      joinRow_other r (formPullback π b) (fun s => formPullback π (D s)) ⟨t,ht⟩]

def comparisonRow (f : FoldedProof A) (σ η : ℝ) (c : Point m n → ℝ)
    (x : Point m n) (r : Row m n) (D : Rest (W := Forms A) r) (b : Forms A) : ℝ :=
  gradient f (joinRow r b D) σ η c x

omit [Fintype A] [Fintype A'] in
lemma comparisonRow_pullback (π : A →ᵃ[F₂] A') (f : FoldedProof A)
    (σ η : ℝ) (c : Point m n → ℝ) (x : Point m n) (r : Row m n)
    (D : Rest (W := Forms A') r) (b : Forms A') :
    comparisonRow f σ η c x r (fun t => formPullback π (D t)) (formPullback π b) =
      gradient f (pullbackFaces π (joinRow r b D)) σ η c x := by
  rw [pullbackFaces_joinRow]
  rfl

omit [Fintype A] in
lemma comparisonRow_average (π : A →ᵃ[F₂] A') (f : FoldedProof A) (g : FoldedProof A')
    (σ η : ℝ) (c : Point m n → ℝ) (x : Point m n) (r : Row m n) :
    (𝔼 D : Rest (W := Forms A') r, 𝔼 b : Forms A',
      (comparisonRow f σ η c x r (fun t => formPullback π (D t)) (formPullback π b) -
        comparisonRow g σ η c x r D b)^2) =
    𝔼 C : FaceArray A' m n,
      (gradient f (pullbackFaces π C) σ η c x-gradient g C σ η c x)^2 := by
  simp_rw [comparisonRow_pullback]
  rw [Finset.expect_comm, expect_splitRow r]
  rfl

omit [Fintype A] [Fintype A'] in
lemma comparisonFailure_indicator (f : FoldedProof A) (g : FoldedProof A')
    (B : FaceArray A m n) (C : FaceArray A' m n) (σ η : ℝ)
    (c : Point m n → ℝ) (p : (Point m n → ℝ) × (Code m n → ℝ)) :
    comparisonFailure f g B C σ η c p =
      (coupledAnswer f B σ η c p-coupledAnswer g C σ η c p)^2/4 := by
  have h := comparisonFailure_eq f g B C σ η c p
  linarith

lemma comparisonRejection_measurable (f : FoldedProof A) (g : FoldedProof A')
    (B : FaceArray A m n) (C : FaceArray A' m n) (σ η : ℝ) :
    Measurable (comparisonRejection f g B C σ η) := by
  have hf : Measurable
      (fun u : (Point m n → ℝ) × ((Point m n → ℝ) × (Code m n → ℝ)) =>
        coupledAnswer f B σ η u.1 u.2) := by
    have hm : Measurable (fun u : (Point m n → ℝ) × ((Point m n → ℝ) × (Code m n → ℝ)) =>
        (u.1+σ•u.2.1,u.2.2)) := by fun_prop
    exact (measurable_answer f B η).comp hm
  have hg : Measurable
      (fun u : (Point m n → ℝ) × ((Point m n → ℝ) × (Code m n → ℝ)) =>
        coupledAnswer g C σ η u.1 u.2) := by
    have hm : Measurable (fun u : (Point m n → ℝ) × ((Point m n → ℝ) × (Code m n → ℝ)) =>
        (u.1+σ•u.2.1,u.2.2)) := by fun_prop
    exact (measurable_answer g C η).comp hm
  have hm : Measurable (fun u : (Point m n → ℝ) × ((Point m n → ℝ) × (Code m n → ℝ)) =>
      comparisonFailure f g B C σ η u.1 u.2) := by
    simp_rw [comparisonFailure_indicator]
    exact (hf.sub hg).pow_const 2 |>.div_const 4
  exact hm.stronglyMeasurable.integral_prod_right.measurable

lemma comparisonRejection_range (f : FoldedProof A) (g : FoldedProof A')
    (B : FaceArray A m n) (C : FaceArray A' m n) (σ η : ℝ)
    (c : Point m n → ℝ) :
    0≤ comparisonRejection f g B C σ η c ∧ comparisonRejection f g B C σ η c≤1 := by
  have hm : Measurable (comparisonFailure f g B C σ η c) := by
    change Measurable (fun p => comparisonFailure f g B C σ η c p)
    simp_rw [comparisonFailure_indicator]
    exact ((coupledAnswer_measurable f B σ η c).sub
      (coupledAnswer_measurable g C σ η c)).pow_const 2 |>.div_const 4
  have hb (p : (Point m n → ℝ) × (Code m n → ℝ)) :
      0≤ comparisonFailure f g B C σ η c p ∧ comparisonFailure f g B C σ η c p≤1 := by
    unfold comparisonFailure; split_ifs <;> norm_num
  have hi : Integrable (comparisonFailure f g B C σ η c)
      ((gauss (Point m n)).prod (gauss (Code m n))) :=
    Integrable.of_bound hm.aestronglyMeasurable 1 (ae_of_all _ (fun p => by
      rw [Real.norm_eq_abs,abs_of_nonneg (hb p).1]; exact (hb p).2))
  constructor
  · exact integral_nonneg (fun p => (hb p).1)
  · unfold comparisonRejection
    simpa only [integral_const,MeasureTheory.probReal_univ,one_smul] using
      integral_mono hi (integrable_const 1) (fun p => (hb p).2)

lemma comparisonRejection_integrable (f : FoldedProof A) (g : FoldedProof A')
    (B : FaceArray A m n) (C : FaceArray A' m n) (σ η : ℝ) :
    Integrable (comparisonRejection f g B C σ η) (gauss (Point m n)) :=
  Integrable.of_bound (comparisonRejection_measurable f g B C σ η).aestronglyMeasurable 1
    (ae_of_all _ (fun c => by
      rw [Real.norm_eq_abs,abs_of_nonneg (comparisonRejection_range f g B C σ η c).1]
      exact (comparisonRejection_range f g B C σ η c).2))

def fourthError (π : A →ᵃ[F₂] A') (f : FoldedProof A) (g : FoldedProof A')
    (σ η : ℝ) : ℝ :=
  𝔼 C : FaceArray A' m n, ∫ c,
    comparisonRejection f g (pullbackFaces π C) C σ η c ∂gauss (Point m n)

lemma averaged_comparison (π : A →ᵃ[F₂] A') (f : FoldedProof A) (g : FoldedProof A')
    (hn : 0<n) {σ : ℝ} (hσ : σ≠0) (η : ℝ) :
    averagedEnergy (m := m) (n := n) (fun C c x => gradient f (pullbackFaces π C) σ η c x-
      gradient g C σ η c x) ≤ 4*σ⁻¹^2*fourthError (m := m) (n := n) π f g σ η := by
  have he (C : FaceArray A' m n) :
      (∫ c, spatialEnergy (fun x => gradient f (pullbackFaces π C) σ η c x-
          gradient g C σ η c x) ∂gauss (Point m n)) ≤
        4*σ⁻¹^2*(∫ c, comparisonRejection f g (pullbackFaces π C) C σ η c ∂gauss (Point m n)) := by
    have hi : Integrable (fun c => spatialEnergy (fun x =>
        gradient f (pullbackFaces π C) σ η c x-gradient g C σ η c x)) (gauss (Point m n)) := by
      apply Integrable.const_mul
      apply integrable_finsetSum
      intro x _
      exact ((gradient_memLp f (pullbackFaces π C) hσ η x).sub
        (gradient_memLp g C hσ η x)).integrable_sq
    rw [← integral_const_mul]
    exact integral_mono hi ((comparisonRejection_integrable f g _ _ σ η).const_mul _)
      (fun c => gradient_comparison f g _ _ hn hσ η c)
  simpa only [averagedEnergy,fourthError,← Finset.mul_expect] using
    Finset.expect_le_expect (s := Finset.univ) (fun C _ => he C)

omit [Fintype A] in
lemma comparisonRow_spatial_average (π : A →ᵃ[F₂] A') (f : FoldedProof A)
    (g : FoldedProof A') (σ η : ℝ) (c : Point m n → ℝ)
    (r : Point m n → Row m n) :
    (𝔼 x : Point m n, 𝔼 D : Rest (W := Forms A') (r x), 𝔼 b : Forms A',
      (comparisonRow f σ η c x (r x) (fun t => formPullback π (D t)) (formPullback π b)-
        comparisonRow g σ η c x (r x) D b)^2) =
    𝔼 C : FaceArray A' m n, spatialEnergy (fun x =>
      gradient f (pullbackFaces π C) σ η c x-gradient g C σ η c x) := by
  simp_rw [comparisonRow_average]
  rw [Finset.expect_comm]
  congr 1
  funext C
  simp only [Fintype.expect_eq_sum_div_card,spatialEnergy,Fintype.card_fun,Fintype.card_fin,
    div_eq_mul_inv,mul_comm]

end MinUncut.Inner

open scoped BigOperators
namespace MinUncut.Composition
open BinaryFourier hiding F₂
open MinUncut.Inner RowNoise
attribute [local instance] Classical.propDecidable BinaryFourier.dualFintype
variable {V W A B : Type*}
  [AddCommGroup V] [Module F₂ V] [AddTorsor V A] [Fintype A]
  [AddCommGroup W] [Module F₂ W] [AddTorsor W B] [Fintype B]

def listMatch (π : A →ᵃ[F₂] B) (f : Forms A → ℝ) (g : Forms B → ℝ) (u θ : ℝ) : Prop :=
  ∃ a ∈ labelList f u, ∃ b ∈ labelList g θ, π a=b

def rowDistance (π : A →ᵃ[F₂] B) (f : Forms A → ℝ) (g : Forms B → ℝ) : ℝ :=
  𝔼 z : Forms B, (g z-f (formPullback π z))^2

def restrictedFourth (π : A →ᵃ[F₂] B) (f : Forms A → ℝ) (u : ℝ) : ℝ :=
  ∑ β : Module.Dual F₂ (Forms B), coefficient (fun z => remainder f u (formPullback π z)) β ^4

omit [Fintype A] in
lemma rowDistance_nonneg (π : A →ᵃ[F₂] B) (f : Forms A → ℝ) (g : Forms B → ℝ) :
    0≤rowDistance π f g := Finset.expect_nonneg (fun _ _ => sq_nonneg _)

lemma restrictedFourth_nonneg (π : A →ᵃ[F₂] B) (f : Forms A → ℝ) (u : ℝ) :
    0≤restrictedFourth π f u := Finset.sum_nonneg (fun _ _ => by positivity)

lemma coefficient_fourth_le (π : A →ᵃ[F₂] B) (f : Forms A → ℝ) (u : ℝ)
    (β : Module.Dual F₂ (Forms B)) :
    coefficient (fun z => remainder f u (formPullback π z)) β ^4 ≤ restrictedFourth π f u :=
  by
    unfold restrictedFourth
    exact Finset.single_le_sum (f := fun γ : Module.Dual F₂ (Forms B) =>
      coefficient (fun z => remainder f u (formPullback π z)) γ ^4)
      (fun _ _ => by positivity) (Finset.mem_univ β)

theorem atom_le_matching_charge (π : A →ᵃ[F₂] B) (f : Forms A → ℝ)
    (g : Forms B → ℝ) (u : ℝ) {θ : ℝ} (hθ : 0<θ) :
    (if (labelList g θ).Nonempty then (1 : ℝ) else 0) ≤
      (if listMatch π f g u θ then 1 else 0) +
      16/θ^2*rowDistance π f g + 256/θ^4*restrictedFourth π f u := by
  have hd := rowDistance_nonneg π f g
  have hr := restrictedFourth_nonneg π f u
  have hd0 : 0≤16/θ^2*rowDistance π f g := by positivity
  have hr0 : 0≤256/θ^4*restrictedFourth π f u := by positivity
  by_cases ha : (labelList g θ).Nonempty
  · rw [ite_eq_left ha]
    by_cases hm : listMatch π f g u θ
    · rw [ite_eq_left hm]; linarith
    rw [ite_eq_right hm,zero_add]
    obtain ⟨b,hb⟩ := ha
    by_cases hc : rowDistance π f g < (θ/4)^2
    · have hrem : θ/4 ≤ |coefficient (fun z => remainder f u (formPullback π z))
          (labelFrequency b)| := by
        by_contra hn
        obtain ⟨a,ha,hab⟩ := local_matching π f g hθ b hb hc (lt_of_not_ge hn)
        exact hm ⟨a,ha,b,hb,hab⟩
      have hpow := pow_le_pow_left₀ (by positivity : 0≤θ/4) hrem 4
      rw [pow_abs,abs_of_nonneg (by positivity)] at hpow
      have hfour := coefficient_fourth_le π f u (labelFrequency b)
      have hlow : θ^4 ≤ 256*restrictedFourth π f u := by nlinarith
      have hcharge : 1≤256/θ^4*restrictedFourth π f u := by
        rw [div_mul_eq_mul_div,le_div_iff₀ (pow_pos hθ 4),one_mul]
        exact hlow
      linarith
    · have hlow : θ^2≤16*rowDistance π f g := by
        have hh := le_of_not_gt hc
        nlinarith
      have hcharge : 1≤16/θ^2*rowDistance π f g := by
        rw [div_mul_eq_mul_div,le_div_iff₀ (pow_pos hθ 2),one_mul]
        exact hlow
      linarith
  · rw [ite_eq_right ha]
    have hm0 : (0 : ℝ) ≤ (if listMatch π f g u θ then 1 else 0) := by split_ifs <;> norm_num
    linarith

end MinUncut.Composition

end

end OAI