import Mathlib

namespace OAI

section
section
noncomputable section
namespace LogConcaveSampling.SeedAbsorption
open MeasureTheory ProbabilityTheory Function
open scoped InnerProductSpace

variable {E F : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
  [NormedAddCommGroup F] [InnerProductSpace ℝ F]
  [FiniteDimensional ℝ F] [MeasurableSpace F] [BorelSpace F]

omit [MeasurableSpace E] [BorelSpace E] [MeasurableSpace F] [BorelSpace F] in
lemma dual_comp_norm (A : F →L[ℝ] E) (L : StrongDual ℝ E) :
    ‖L.comp A‖=‖A.adjoint ((InnerProductSpace.toDual ℝ E).symm L)‖ := by
  have he : L.comp A=(InnerProductSpace.toDual ℝ F)
      (A.adjoint ((InnerProductSpace.toDual ℝ E).symm L)) := by
    ext x
    change L (A x)=inner ℝ (A.adjoint ((InnerProductSpace.toDual ℝ E).symm L)) x
    rw [A.adjoint_inner_left,InnerProductSpace.toDual_symm_apply]
  rw [he,LinearIsometryEquiv.norm_map]

theorem restore_gaussian (P : E →L[ℝ] E) (U : F →L[ℝ] E)
    (hcov : P.comp P.adjoint+U.comp U.adjoint=ContinuousLinearMap.id ℝ E) :
    ((stdGaussian E).prod (stdGaussian F)).map (fun z : E × F => P z.1-U z.2)=
      stdGaussian E := by
  let A : E × F →L[ℝ] E := P.comp (ContinuousLinearMap.fst ℝ E F)-
    U.comp (ContinuousLinearMap.snd ℝ E F)
  change ((stdGaussian E).prod (stdGaussian F)).map A=stdGaussian E
  apply Measure.ext_of_charFunDual
  ext L
  have h₁ : (L.comp A).comp (ContinuousLinearMap.inl ℝ E F)=L.comp P := by
    ext x; simp [A]
  have h₂ : (L.comp A).comp (ContinuousLinearMap.inr ℝ E F)=-(L.comp U) := by
    ext x; simp [A]
  have hn : ‖L.comp P‖^2+‖L.comp U‖^2=‖L‖^2 := by
    let x := (InnerProductSpace.toDual ℝ E).symm L
    have he := congrArg (fun B : E →L[ℝ] E => inner ℝ x (B x)) hcov
    simp only [add_apply,ContinuousLinearMap.comp_apply,
      ContinuousLinearMap.id_apply,inner_add_right] at he
    rw [← P.adjoint_inner_left,← U.adjoint_inner_left] at he
    rw [real_inner_self_eq_norm_sq,real_inner_self_eq_norm_sq,
      real_inner_self_eq_norm_sq] at he
    simpa only [x,dual_comp_norm,LinearIsometryEquiv.norm_map] using he
  rw [charFunDual_map,charFunDual_prod,h₁,h₂]
  simp only [charFunDual_stdGaussian,norm_neg]
  rw [← Complex.exp_add]
  congr 1
  norm_cast
  linarith

theorem absorb_center_noise {Y : Type*} [MeasurableSpace Y]
    (P : E →L[ℝ] E) (U : F →L[ℝ] E)
    (hcov : P.comp P.adjoint+U.comp U.adjoint=ContinuousLinearMap.id ℝ E)
    (M : F → E → Y) (hM : Measurable (uncurry M)) (x : F)
    (n : ℝ) (shift : F →L[ℝ] E)
    (hU : U=n • shift)
    (hshift : ∀x Δ g,M (x+Δ) g=M x (g-shift Δ)) :
    ((stdGaussian E).prod (stdGaussian F)).map
      (fun z : E × F => M (x+n • z.2) (P z.1))=
      (stdGaussian E).map (M x) := by
  have hm : Measurable (M x) := hM.comp (measurable_const.prodMk measurable_id)
  have he : (fun z : E × F => M (x+n • z.2) (P z.1))=
      M x ∘ (fun z : E × F => P z.1-U z.2) := by
    funext z
    rw [hshift,hU]
    simp only [smul_apply,map_smul,comp_apply]
  rw [he,← Measure.map_map hm (by fun_prop),restore_gaussian P U hcov]
end LogConcaveSampling.SeedAbsorption

end

end

section

noncomputable section
namespace LogConcaveSampling.SeedAbsorption
open MeasureTheory ProbabilityTheory Function
open scoped InnerProductSpace

variable {E F : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E]
  [NormedAddCommGroup F] [InnerProductSpace ℝ F]
  [FiniteDimensional ℝ F]

def dampingCoefficient (t : ℝ) : ℝ := (1+Real.sqrt (1-t))⁻¹

def seedDamping (U : F →L[ℝ] E) (t : ℝ) : E →L[ℝ] E :=
  ContinuousLinearMap.id ℝ E-dampingCoefficient t • U.comp U.adjoint

lemma dampingCoefficient_identity {t : ℝ} (ht : t≤1) :
    2*dampingCoefficient t-(dampingCoefficient t)^2*t=1 := by
  have hsq := Real.sq_sqrt (show 0≤1-t by linarith)
  have hp : 0<1+Real.sqrt (1-t) := by positivity
  dsimp [dampingCoefficient]
  field_simp
  nlinarith

lemma seedDamping_adjoint (U : F →L[ℝ] E) (t : ℝ) :
    (seedDamping U t).adjoint=seedDamping U t := by
  simp only [seedDamping,map_sub,map_smulₛₗ,ContinuousLinearMap.adjoint_id,
    ContinuousLinearMap.adjoint_comp,ContinuousLinearMap.adjoint_adjoint]
  rfl

lemma seedDamping_covariance (U : F →L[ℝ] E) {t : ℝ} (ht : t≤1)
    (hU : U.adjoint.comp U=t • ContinuousLinearMap.id ℝ F) :
    (seedDamping U t).comp (seedDamping U t).adjoint+U.comp U.adjoint=
      ContinuousLinearMap.id ℝ E := by
  rw [seedDamping_adjoint]
  ext x
  have he : U.adjoint (U (U.adjoint x))=t • U.adjoint x :=
    congrArg (fun L : F →L[ℝ] F => L (U.adjoint x)) hU
  have hα := dampingCoefficient_identity ht
  simp only [seedDamping,ContinuousLinearMap.comp_apply,sub_apply,smul_apply,
    ContinuousLinearMap.id_apply,add_apply,map_sub,map_smul,he]
  calc
    _ = x+(1-dampingCoefficient t*2+dampingCoefficient t^2*t) • U (U.adjoint x) := by module
    _ = x := by rw [show 1-dampingCoefficient t*2+dampingCoefficient t^2*t=0 by nlinarith [hα]]; simp

lemma seedDamping_positive (U : F →L[ℝ] E) {t : ℝ} (ht0 : 0≤t) (ht1 : t<1)
    (hUn : ∀x,‖U.adjoint x‖^2≤t*‖x‖^2) (x : E) :
    Real.sqrt (1-t)*‖x‖^2≤ inner ℝ x (seedDamping U t x) := by
  have hsq := Real.sq_sqrt (show 0≤1-t by linarith)
  have hp : 0<1+Real.sqrt (1-t) := by positivity
  have he : 1-dampingCoefficient t*t=Real.sqrt (1-t) := by
    dsimp [dampingCoefficient]
    field_simp
    nlinarith
  have hα : 0≤dampingCoefficient t := by dsimp [dampingCoefficient]; positivity
  simp only [seedDamping,sub_apply,smul_apply,ContinuousLinearMap.comp_apply,ContinuousLinearMap.id_apply,
    inner_sub_right,inner_smul_right,← U.adjoint_inner_left,real_inner_self_eq_norm_sq]
  have hh := mul_le_mul (hUn x) (le_refl (dampingCoefficient t)) hα
    (mul_nonneg ht0 (sq_nonneg ‖x‖))
  rw [← he]
  nlinarith

variable [MeasurableSpace E] [BorelSpace E] [MeasurableSpace F] [BorelSpace F]

theorem seedDamping_restore (U : F →L[ℝ] E) {t : ℝ} (ht : t≤1)
    (hU : U.adjoint.comp U=t • ContinuousLinearMap.id ℝ F) :
    ((stdGaussian E).prod (stdGaussian F)).map
      (fun z : E × F => seedDamping U t z.1-U z.2)=stdGaussian E :=
  restore_gaussian _ U (seedDamping_covariance U ht hU)
end LogConcaveSampling.SeedAbsorption

end

end

section

noncomputable section
namespace LogConcaveSampling.SeedAbsorption
open MeasureTheory ProbabilityTheory Function
open scoped InnerProductSpace

variable {E F A : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
  [NormedAddCommGroup F] [InnerProductSpace ℝ F]
  [FiniteDimensional ℝ F] [MeasurableSpace F] [BorelSpace F]
  [MeasurableSpace A]

theorem restore_gaussian_with_anchor (μ : Measure A) [SFinite μ]
    (P : E →L[ℝ] E) (U : F →L[ℝ] E)
    (hcov : P.comp P.adjoint+U.comp U.adjoint=ContinuousLinearMap.id ℝ E) :
    (μ.prod ((stdGaussian E).prod (stdGaussian F))).map
      (fun z : A × (E × F) => (z.1,P z.2.1-U z.2.2))=μ.prod (stdGaussian E) := by
  have h := Measure.map_prod_map μ ((stdGaussian E).prod (stdGaussian F))
    (f:=id) (g:=fun z : E × F => P z.1-U z.2) measurable_id (by fun_prop)
  rw [Measure.map_id,restore_gaussian P U hcov] at h
  exact h.symm

theorem absorb_center_noise_with_anchor {Y : Type*} [MeasurableSpace Y]
    (μ : Measure A) [SFinite μ] (P : E →L[ℝ] E) (U : F →L[ℝ] E)
    (hcov : P.comp P.adjoint+U.comp U.adjoint=ContinuousLinearMap.id ℝ E)
    (M : F → E → Y) (hM : Measurable (uncurry M))
    (x : A → F) (hx : Measurable x) (n : ℝ) (shift : F →L[ℝ] E)
    (hU : U=n • shift)
    (hshift : ∀x Δ g,M (x+Δ) g=M x (g-shift Δ)) :
    (μ.prod ((stdGaussian E).prod (stdGaussian F))).map
      (fun z : A × (E × F) => (z.1,M (x z.1+n • z.2.2) (P z.2.1)))=
      (μ.prod (stdGaussian E)).map (fun z : A × E => (z.1,M (x z.1) z.2)) := by
  have he : (fun z : A × (E × F) => (z.1,M (x z.1+n • z.2.2) (P z.2.1)))=
      (fun z : A × E => (z.1,M (x z.1) z.2)) ∘
        (fun z : A × (E × F) => (z.1,P z.2.1-U z.2.2)) := by
    funext z
    rw [hshift,hU]
    simp only [smul_apply,map_smul,comp_apply]
  rw [he,← Measure.map_map]
  · rw [restore_gaussian_with_anchor μ P U hcov]
  · exact measurable_fst.prodMk (hM.comp ((hx.comp measurable_fst).prodMk measurable_snd))
  · fun_prop
end LogConcaveSampling.SeedAbsorption

end

end

section

noncomputable section
namespace LogConcaveSampling.SeedAbsorption
open MeasureTheory ProbabilityTheory Function
open scoped InnerProductSpace

variable {ι : Type*} [Fintype ι] {A F : Type*} [MeasurableSpace A]
  [NormedAddCommGroup F] [InnerProductSpace ℝ F] [FiniteDimensional ℝ F]
  [MeasurableSpace F] [BorelSpace F]
  {E : ι → Type*} [∀i,NormedAddCommGroup (E i)] [∀i,InnerProductSpace ℝ (E i)]
  [∀i,FiniteDimensional ℝ (E i)] [∀i,MeasurableSpace (E i)] [∀i,BorelSpace (E i)]

theorem restore_gaussian_blocks (P : ∀i,E i →L[ℝ] E i) (U : ∀i,F →L[ℝ] E i)
    (hcov : ∀i,(P i).comp (P i).adjoint+(U i).comp (U i).adjoint=ContinuousLinearMap.id ℝ (E i)) :
    (Measure.pi (fun i => (stdGaussian (E i)).prod (stdGaussian F))).map
      (fun z i => P i (z i).1-U i (z i).2)=Measure.pi (fun i => stdGaussian (E i)) := by
  exact (measurePreserving_pi
    (fun i => (stdGaussian (E i)).prod (stdGaussian F)) (fun i => stdGaussian (E i))
    (fun i => ⟨by fun_prop,restore_gaussian (P i) (U i) (hcov i)⟩)).map_eq

theorem restore_gaussian_blocks_with_anchor (μ : Measure A) [SFinite μ]
    (P : ∀i,E i →L[ℝ] E i) (U : ∀i,F →L[ℝ] E i)
    (hcov : ∀i,(P i).comp (P i).adjoint+(U i).comp (U i).adjoint=ContinuousLinearMap.id ℝ (E i)) :
    (μ.prod (Measure.pi (fun i => (stdGaussian (E i)).prod (stdGaussian F)))).map
      (fun z : A × (∀i,E i × F) => (z.1,fun i => P i (z.2 i).1-U i (z.2 i).2))=
        μ.prod (Measure.pi (fun i => stdGaussian (E i))) := by
  have h := Measure.map_prod_map μ (Measure.pi (fun i => (stdGaussian (E i)).prod (stdGaussian F)))
    (f:=id) (g:=fun z i => P i (z i).1-U i (z i).2) measurable_id (by fun_prop)
  rw [Measure.map_id,restore_gaussian_blocks P U hcov] at h
  exact h.symm

theorem absorb_center_noise_blocks {Y : ι → Type*} [∀i,MeasurableSpace (Y i)]
    (μ : Measure A) [SFinite μ] (P : ∀i,E i →L[ℝ] E i) (U : ∀i,F →L[ℝ] E i)
    (hcov : ∀i,(P i).comp (P i).adjoint+(U i).comp (U i).adjoint=ContinuousLinearMap.id ℝ (E i))
    (M : ∀i,F → E i → Y i) (hM : ∀i,Measurable (uncurry (M i)))
    (x : ι → A → F) (hx : ∀i,Measurable (x i)) (n : ι → ℝ)
    (shift : ∀i,F →L[ℝ] E i) (hU : ∀i,U i=n i • shift i)
    (hshift : ∀i x Δ g,M i (x+Δ) g=M i x (g-shift i Δ)) :
    (μ.prod (Measure.pi (fun i => (stdGaussian (E i)).prod (stdGaussian F)))).map
      (fun z : A × (∀i,E i × F) =>
        (z.1,fun i => M i (x i z.1+n i • (z.2 i).2) (P i (z.2 i).1)))=
      (μ.prod (Measure.pi (fun i => stdGaussian (E i)))).map
        (fun z : A × (∀i,E i) => (z.1,fun i => M i (x i z.1) (z.2 i))) := by
  let R : (A × (∀i,E i × F)) → (A × (∀i,E i)) :=
    fun z => (z.1,fun i => P i (z.2 i).1-U i (z.2 i).2)
  let C : (A × (∀i,E i)) → (A × (∀i,Y i)) :=
    fun z => (z.1,fun i => M i (x i z.1) (z.2 i))
  have he : (fun z : A × (∀i,E i × F) =>
      (z.1,fun i => M i (x i z.1+n i • (z.2 i).2) (P i (z.2 i).1)))=C ∘ R := by
    funext z
    apply Prod.ext
    · rfl
    funext i
    change M i (x i z.1+n i • (z.2 i).2) (P i (z.2 i).1)=
      M i (x i z.1) (P i (z.2 i).1-U i (z.2 i).2)
    rw [hshift,hU]
    simp only [smul_apply,map_smul]
  have hc : Measurable C := measurable_fst.prodMk (Measurable.of_eval
    (fun i => (hM i).comp (((hx i).comp measurable_fst).prodMk ((measurable_pi_apply i).comp measurable_snd))))
  rw [he,←Measure.map_map hc (by dsimp [R]; fun_prop)]
  change ((μ.prod (Measure.pi (fun i => (stdGaussian (E i)).prod (stdGaussian F)))).map R).map C=_
  rw [show (μ.prod (Measure.pi (fun i => (stdGaussian (E i)).prod (stdGaussian F)))).map R=
    μ.prod (Measure.pi (fun i => stdGaussian (E i))) from restore_gaussian_blocks_with_anchor μ P U hcov]
end LogConcaveSampling.SeedAbsorption

end

end

end

end OAI