import Mathlib
import OAI.Probability.Perceptron.Variational.IndexedDiagonalField

namespace OAI

noncomputable section
namespace SphericalPerceptronFreeEnergy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology NNReal ENNReal BigOperators BoundedContinuousFunction

def enrichedDisorderLaw (n k : ℕ) (p : Fin (n+1) → ℕ) (z : Fin k → ℝ) :
    Measure (EnrichedMark (n+1) (n+1) p × DecoratedCascade (EnrichedMark (n+1) (n+1) p) k) :=
  (stdGaussian (EnrichedMark (n+1) (n+1) p)).prod
    (decoratedCascadeLaw (gaussianMarkLaw : ProbabilityMeasure (EnrichedMark (n+1) (n+1) p)) k z)

instance (n k : ℕ) (p : Fin (n+1) → ℕ) (z : Fin k → ℝ) :
    IsProbabilityMeasure (enrichedDisorderLaw n k p z) := by
  unfold enrichedDisorderLaw
  infer_instance

lemma enrichedCascadeLog_joint_mean (n M k : ℕ) (f : ℝ →ᵇ ℝ)
    (g : Fin M → Fin (n+1) → ℝ) (p d : Fin (n+1) → ℕ) (u : Fin (n+1) → ℝ)
    (h : Fin (k+1) → ℝ) (z : Fin k → ℝ)
    (hz : StrictMono z) (hz0 : ∀ i, 0<z i) (hz1 : ∀ i, z i<1) :
    Integrable (enrichedCascadeLog n M k f g p d u h) (enrichedDisorderLaw n k p z) ∧
    (∫ a, enrichedCascadeLog n M k f g p d u h a ∂enrichedDisorderLaw n k p z)=
      ∫ a, gaussianLinearBackward (stdGaussian (EnrichedMark (n+1) (n+1) p))
        (linearCascadeWord (enrichedIncrementMap p d h) k z)
        (enrichedTerminal n M f g p u (h (Fin.last k))) (enrichedRootMap p d h a)
        ∂stdGaussian (EnrichedMark (n+1) (n+1) p) := by
  exact gaussianLinearCascadeLog_mean (enrichedIncrementMap p d h) (enrichedRootMap p d h)
    (enrichedTerminal_lipschitz n M f g p u _) k z hz hz0 hz1

lemma enrichedCascadeLog_measurable (n M k : ℕ) (f : ℝ →ᵇ ℝ)
    (g : Fin M → Fin (n+1) → ℝ) (p d : Fin (n+1) → ℕ) (u : Fin (n+1) → ℝ)
    (h : Fin (k+1) → ℝ) (z : Fin k → ℝ) :
    Measurable (enrichedCascadeLog n M k f g p d u h) := by
  exact gaussianLinearCascadeLog_measurable (enrichedIncrementMap p d h) (enrichedRootMap p d h)
    (enrichedTerminal_lipschitz n M f g p u _).continuous.measurable k z

lemma enrichedCascadeLog_conditional_square (n M k : ℕ) (f : ℝ →ᵇ ℝ)
    (g : Fin M → Fin (n+1) → ℝ) (p d : Fin (n+1) → ℕ) (u : Fin (n+1) → ℝ)
    (h : Fin (k+1) → ℝ) (z : Fin k → ℝ)
    (hz : StrictMono z) (hz0 : ∀ i, 0<z i) (hz1 : ∀ i, z i<1)
    (a : EnrichedMark (n+1) (n+1) p) :
    let ν : ProbabilityMeasure (EnrichedMark (n+1) (n+1) p) := gaussianMarkLaw
    let G := gaussianLinearBackward (ν:Measure _) (linearCascadeWord (enrichedIncrementMap p d h) k z)
      (enrichedTerminal n M f g p u (h (Fin.last k))) (enrichedRootMap p d h a)
    MemLp (fun η => enrichedCascadeLog n M k f g p d u h (a,η)) 2
      (decoratedCascadeLaw ν k z : Measure _) ∧
    (∫ η, (enrichedCascadeLog n M k f g p d u h (a,η)-G)^2
      ∂decoratedCascadeLaw ν k z) ≤ cascadeLogFluctuationConstant k z := by
  let ν : ProbabilityMeasure (EnrichedMark (n+1) (n+1) p) := gaussianMarkLaw
  let : IsGaussian (ν:Measure (EnrichedMark (n+1) (n+1) p)) := (inferInstance : IsGaussian (stdGaussian (EnrichedMark (n+1) (n+1) p)))
  have hf := enrichedTerminal_lipschitz n M f g p u (h (Fin.last k))
  have hr := gaussianLinearRecursion_realization ν (enrichedIncrementMap p d h) hf k z hz0
  have H := finiteCascade_terminal_log_second_moment_bound ν
    (gaussianLinearMarkStep (enrichedIncrementMap p d h))
    (gaussianLinearMarkStep_measurable _) k z hz hz0 hz1
    (hf.continuous.measurable.comp (measurable_pi_apply 0)) hr.2
    (fun _ => enrichedRootMap p d h a)
  simp only [Function.comp_def] at H
  rw [hr.1] at H
  exact H

lemma normalizedPatternEnergy_source (α β : ℝ) (φ : ℝ →ᵇ ℝ) (n : ℕ)
    (g : Patterns α (n+1)) (x : NormalizedSpin (n+1)) :
    normalizedPatternEnergy (n+1) (patternCount α (n+1)) (β • φ) g x=
      β*hamiltonian α φ (n+1) g (Real.sqrt (n+1:ℕ) • x.val) := by
  have hn : Real.sqrt ((n+1:ℕ):ℝ) ≠ 0 := (Real.sqrt_pos.mpr (by positivity)).ne'
  have he (a : Fin (patternCount α (n+1))) :
      patternField g a (Real.sqrt (n+1:ℕ) • x.val) = ∑ i, g a i*x.val i := by
    unfold patternField
    simp only [PiLp.smul_apply,smul_eq_mul]
    have hs : (∑ i, g a i*(Real.sqrt (n+1:ℕ)*x.val i)) =
        (∑ i, g a i*x.val i)*Real.sqrt (n+1:ℕ) := by
      rw [Finset.sum_mul]
      apply Finset.sum_congr rfl
      intro i _
      ring
    rw [hs,mul_div_cancel_right₀ _ hn]
  simp only [normalizedPatternEnergy,BoundedContinuousFunction.coe_smul,smul_eq_mul,
    hamiltonian,he,Finset.mul_sum]

variable {E : Type} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
  (μ : Measure E) [IsGaussian μ]

lemma gaussianLinearEntropic_C1 {f : E → ℝ} {D : E → StrongDual ℝ E} {L : ℝ≥0}
    (hf : LipschitzWith L f) (hd : ∀ x, HasFDerivAt f (D x) x) (hD : Continuous D)
    {b : ℝ} (hb : 0<b) (A : E →L[ℝ] E) :
    ∃ D' : E → StrongDual ℝ E, Continuous D' ∧
      (∀ x, HasFDerivAt (gaussianLinearEntropic μ b A f) (D' x) x) ∧
      (∀ x, ‖D' x‖ ≤ L) := by
  have hfc : Continuous f := hf.continuous
  have hDC (x : E) : ‖D x‖ ≤ L := by
    rw [← (hd x).fderiv]
    exact norm_fderiv_le_of_lipschitz ℝ hf
  let Z := fun x => ∫ y, Real.exp (b*f (x+A y)) ∂μ
  let ZD := fun x => ∫ y, Real.exp (b*f (x+A y)) • (b • D (x+A y)) ∂μ
  have hZpos (x : E) : 0<Z x := by
    apply integral_pos_iff_support_of_nonneg (fun y => (Real.exp_pos _).le)
      (gaussian_integrable_exp_linear_shift μ hf A b x) |>.mpr
    simp [Function.support,Real.exp_ne_zero]
  have hdom (x₀ x y : E) (hx : x ∈ Metric.ball x₀ 1) :
      ‖Real.exp (b*f (x+A y)) • (b • D (x+A y))‖ ≤
        (Real.exp (b*L)*(b*L))*Real.exp (b*f (x₀+A y)) := by
    have hh := hf.dist_le_mul (x+A y) (x₀+A y)
    rw [dist_add_right,Real.dist_eq] at hh
    have hx' : dist x x₀ ≤ 1 := (Metric.mem_ball.mp hx).le
    have hff : f (x+A y)-f (x₀+A y) ≤ L :=
      (le_abs_self _).trans (hh.trans (by simpa using mul_le_mul_of_nonneg_left hx' L.coe_nonneg))
    have hExp : Real.exp (b*f (x+A y)) ≤ Real.exp (b*L)*Real.exp (b*f (x₀+A y)) := by
      rw [← Real.exp_add]
      apply Real.exp_le_exp.mpr
      nlinarith
    simp only [norm_smul,Real.norm_eq_abs,abs_of_pos (Real.exp_pos _),abs_of_pos hb]
    calc
      _ ≤ (Real.exp (b*L)*Real.exp (b*f (x₀+A y)))*(b*L) :=
        mul_le_mul hExp (mul_le_mul_of_nonneg_left (hDC _) hb.le) (by positivity) (by positivity)
      _ = _ := by ring
  have hZ (x : E) : HasFDerivAt Z (ZD x) x := by
    apply hasFDerivAt_integral_of_dominated_of_fderiv_le
      (F' := fun x y => Real.exp (b*f (x+A y)) • (b • D (x+A y)))
      (bound := fun y => (Real.exp (b*L)*(b*L))*Real.exp (b*f (x+A y)))
      (Metric.ball_mem_nhds x zero_lt_one)
    · exact Eventually.of_forall fun x => by fun_prop
    · exact gaussian_integrable_exp_linear_shift μ hf A b x
    · fun_prop
    · exact ae_of_all _ fun y x' hx' => hdom x x' y hx'
    · exact (gaussian_integrable_exp_linear_shift μ hf A b x).const_mul _
    · exact ae_of_all _ fun y x' _ => by
        have hh := (hd (x'+A y)).comp x' ((hasFDerivAt_id x').add_const (A y))
        simpa using (hh.const_mul b).exp
  have hZD : Continuous ZD := by
    apply continuous_iff_continuousAt.mpr
    intro x
    apply continuousAt_of_dominated
      (bound := fun y => (Real.exp (b*L)*(b*L))*Real.exp (b*f (x+A y)))
    · exact Eventually.of_forall fun x => by fun_prop
    · filter_upwards [Metric.ball_mem_nhds x zero_lt_one] with x' hx'
      exact ae_of_all _ fun y => hdom x x' y hx'
    · exact (gaussian_integrable_exp_linear_shift μ hf A b x).const_mul _
    · exact ae_of_all _ fun y => by fun_prop
  let D' := fun x => b⁻¹ • ((Z x)⁻¹ • ZD x)
  have he : gaussianLinearEntropic μ b A f = fun x => Real.log (Z x)/b := by
    funext x
    exact entropicMean_eq_div μ (fun s => gaussian_integrable_exp_linear_shift μ hf A s x) hb.ne'
  have hd' (x : E) : HasFDerivAt (gaussianLinearEntropic μ b A f) (D' x) x := by
    rw [he]
    have hh := ((hZ x).log (hZpos x).ne').const_mul b⁻¹
    simpa only [D',div_eq_mul_inv,mul_comm] using hh
  refine ⟨D',?_,hd',?_⟩
  · have hcZ : Continuous Z := continuous_iff_continuousAt.mpr (fun x => (hZ x).continuousAt)
    change Continuous (fun x => b⁻¹ • ((Z x)⁻¹ • ZD x))
    exact (continuous_const : Continuous (fun _ : E => (b⁻¹ : ℝ))).smul
      ((hcZ.inv₀ (fun x => (hZpos x).ne')).smul hZD)
  · intro x
    rw [← (hd' x).fderiv]
    exact norm_fderiv_le_of_lipschitz ℝ (gaussianLinearEntropic_lipschitz μ hf hb.le A)

lemma gaussianLinearBackward_C1 {f : E → ℝ} {D : E → StrongDual ℝ E} {L : ℝ≥0}
    (hf : LipschitzWith L f) (hd : ∀ x, HasFDerivAt f (D x) x) (hD : Continuous D)
    (l : List (ℝ×(E →L[ℝ] E))) (hl : ∀ c ∈ l, 0<c.1) :
    ∃ D' : E → StrongDual ℝ E, Continuous D' ∧
      (∀ x, HasFDerivAt (gaussianLinearBackward μ l f) (D' x) x) ∧
      (∀ x, ‖D' x‖ ≤ L) := by
  induction l with
  | nil =>
    exact ⟨D,hD,hd,fun x => by
      rw [← (hd x).fderiv]
      exact norm_fderiv_le_of_lipschitz ℝ hf⟩
  | cons c l ih =>
    have hl' : ∀ d ∈ l, 0<d.1 := fun d hd => hl d (List.mem_cons_of_mem c hd)
    obtain ⟨D',hD',hd',_⟩ := ih hl'
    exact gaussianLinearEntropic_C1 μ
      (gaussianLinearBackward_lipschitz μ hf l (fun d hd => (hl' d hd).le))
      hd' hD' (hl c List.mem_cons_self) c.2

lemma gaussianLinearBackward_root_variance {f : E → ℝ} {D : E → StrongDual ℝ E}
    {L : ℝ≥0} (hf : LipschitzWith L f) (hd : ∀ x, HasFDerivAt f (D x) x)
    (hD : Continuous D) (l : List (ℝ×(E →L[ℝ] E))) (hl : ∀ c ∈ l, 0<c.1)
    (R : E →L[ℝ] E) :
    variance (fun x => gaussianLinearBackward μ l f (R x)) (stdGaussian E) ≤
      (Real.pi^2/8)*((L:ℝ)*‖R‖)^2 := by
  obtain ⟨D',hD',hd',hb⟩ := gaussianLinearBackward_C1 μ hf hd hD l hl
  apply stdGaussian_variance_le_of_fderiv_bound
    (D := fun x => (D' (R x)).comp R)
    (fun x => (hd' (R x)).comp x R.hasFDerivAt)
  · exact Continuous.clm_comp (hD'.comp R.continuous) continuous_const
  · positivity
  · intro x
    exact (ContinuousLinearMap.opNorm_comp_le _ _).trans
      (mul_le_mul_of_nonneg_right (hb _) (norm_nonneg R))

end SphericalPerceptronFreeEnergy

end

end OAI