lean/OAI/Probability/Perceptron/Pressure/PatternFree.lean

import Mathlib
import OAI.Probability.Perceptron.Variational.DensityDerivative
import OAI.Probability.Perceptron.Variational.StepDual
import OAI.Probability.Perceptron.Cascade.CascadeHeat

namespace OAI

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

def enrichedSpinProjection (N : ℕ) (p : Fin N→ℕ) : EnrichedMark N N p →L[ℝ] Spin N :=
  ({ toFun := fun a => WithLp.toLp 2 (fun i => a (.inl i))
     map_add' := by intros; rfl
     map_smul' := by intros; rfl } : EnrichedMark N N p →ₗ[ℝ] Spin N).toContinuousLinearMap

@[simp] lemma enrichedSpinProjection_apply (N : ℕ) (p : Fin N→ℕ)
    (a : EnrichedMark N N p) (i : Fin N) : enrichedSpinProjection N p a i=a (.inl i) := rfl

lemma enrichedSpinProjection_preserving (N : ℕ) (p : Fin N→ℕ) :
    MeasurePreserving (enrichedSpinProjection N p) (stdGaussian (EnrichedMark N N p))
      (stdGaussian (Spin N)) := by
  refine ⟨(enrichedSpinProjection N p).measurable,?_⟩
  have hi : (Measure.pi (fun _ : EnrichedIndex N N p => gaussianReal 0 1)).map
      (fun a i => a (Sum.inl i))=Measure.pi (fun _ : Fin N => gaussianReal 0 1) := by
    simpa only [Measure.infinitePi_eq_pi] using
      (Measure.map_infinitePi_infinitePi_of_inj
        (P := fun _ : EnrichedIndex N N p => gaussianReal 0 1)
        (f := (Sum.inl : Fin N→EnrichedIndex N N p)) Sum.inl_injective)
  rw [← map_pi_eq_stdGaussian,Measure.map_map (by fun_prop) (by fun_prop)]
  change (Measure.pi (fun _ : EnrichedIndex N N p => gaussianReal 0 1)).map
    ((WithLp.toLp 2) ∘ (fun a i => a (Sum.inl i)))=_
  rw [← Measure.map_map (by fun_prop) (by fun_prop),hi,map_pi_eq_stdGaussian]

section Transport
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 [BorelSpace E] in
lemma gaussianLinearBackward_projection (P : E →L[ℝ] F)
    (hp : MeasurePreserving P (stdGaussian E) (stdGaussian F))
    (A : ℕ→E →L[ℝ] E) (σ : ℕ→ℝ) (hA : ∀ j x, P (A j x)=σ j • P x)
    {f : F→ℝ} {L : ℝ≥0} (hf : LipschitzWith L f)
    (k : ℕ) (z : Fin k→ℝ) (hz : ∀ i, 0≤z i) (x : E) :
    gaussianLinearBackward (stdGaussian E) (linearCascadeWord A k z) (fun a => f (P a)) x=
      gaussianBackward (stdGaussian F) (cascadeHeatWord σ k z) f (P x) := by
  induction k generalizing x with
  | zero => rfl
  | succ k ih =>
    simp only [linearCascadeWord,gaussianLinearBackward,cascadeHeatWord,gaussianBackward,
      gaussianLinearEntropic,gaussianEntropic]
    simp_rw [ih (fun i => z i.succ) (fun i => hz i.succ),map_add,hA]
    let g := gaussianBackward (stdGaussian F) (cascadeHeatWord σ k (fun i => z i.succ)) f
    have hg : Continuous g := (gaussianBackward_lipschitz (stdGaussian F) hf _
      (cascadeHeatWord_nonneg σ k _ (fun i => hz i.succ))).continuous
    have hc : cgf (fun y => g (P x+σ k • P y)) (stdGaussian E)=
        cgf (fun y => g (P x+σ k • y)) (stdGaussian F) := by
      funext t
      unfold cgf mgf
      rw [← hp.map_eq,integral_map hp.measurable.aemeasurable (by
        exact (Real.continuous_exp.comp (continuous_const.mul
          (hg.comp (continuous_const.add (continuous_const.smul continuous_id))))).aestronglyMeasurable)]
    exact congrArg (fun c : ℝ→ℝ => ∫ t in (0:ℝ)..1, deriv c (z 0*t)) hc
end Transport

lemma enrichedSpinProjection_increment {N k : ℕ} (p d : Fin N→ℕ)
    (h : Fin (k+1)→ℝ) (j : ℕ) (a : EnrichedMark N N p) :
    enrichedSpinProjection N p (enrichedIncrementMap p d h j a)=
      stepFieldIncrement k h j • enrichedSpinProjection N p a := by
  ext i
  by_cases hj : j<k
  · simp only [enrichedIncrementMap,dite_eq_left hj,enrichedSpinProjection_apply,diagonalMark_apply,
      enrichedCoordinateLevel,stepFieldIncrement,PiLp.smul_apply,smul_eq_mul]
    congr 2
    have h₁ : (⟨k-j,by omega⟩ : Fin (k+1))=(Fin.rev ⟨j,hj⟩).succ := by
      ext; simp only [Fin.val_succ,Fin.val_rev]; omega
    have h₀ : (⟨k-j-1,by omega⟩ : Fin (k+1))=(Fin.rev ⟨j,hj⟩).castSucc := by
      ext; simp only [Fin.val_castSucc,Fin.val_rev]; omega
    rw [h₁,h₀]
    ring
  · simp [enrichedIncrementMap,stepFieldIncrement,hj]

lemma enrichedSpinProjection_root {N k : ℕ} (p d : Fin N→ℕ)
    (h : Fin (k+1)→ℝ) (a : EnrichedMark N N p) :
    enrichedSpinProjection N p (enrichedRootMap p d h a)=
      Real.sqrt (2*h 0) • enrichedSpinProjection N p a := by ext; rfl

lemma enrichedTerminal_patternFree (n : ℕ) (f : ℝ →ᵇ ℝ) (g : Fin 0→Fin (n+1)→ℝ)
    (p : Fin (n+1)→ℕ) (htop : ℝ) (a : EnrichedMark (n+1) (n+1) p) :
    enrichedTerminal n 0 f g p (fun _ => 0) htop a=
      logSphericalExp n (Real.sqrt (n+1:ℕ)) (enrichedSpinProjection (n+1) p a)-(n+1:ℕ)*htop := by
  unfold enrichedTerminal vectorLogPartition vectorPartition logSphericalExp sphericalExp
  congr 2
  apply integral_congr_ae
  exact ae_of_all _ fun x => by
    apply congrArg Real.exp
    simp only [normalizedPatternEnergy,Finset.univ_eq_empty,Finset.sum_empty,zero_add,
      sourceEnrichedFeature,innerSL_apply_apply,PiLp.inner_apply,enrichedFeature,
      Fintype.sum_sum_type,perturbationAmplitude,mul_zero,
      inner_zero_left,zero_mul,Finset.sum_const_zero,add_zero,enrichedSpinProjection_apply]
    rw [Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro i _
    change a (.inl i)*(Real.sqrt (n+1:ℕ)*x.val i)=
      Real.sqrt (n+1:ℕ)*(x.val i*a (.inl i))
    ring

lemma enrichedExpectedLog_patternFree (n k : ℕ) (f : ℝ →ᵇ ℝ)
    (g : Fin 0→Fin (n+1)→ℝ) (p d : Fin (n+1)→ℕ)
    (h : Fin (k+1)→ℝ) (z : Fin k→ℝ) (hz : StrictMono z)
    (hz0 : ∀ i, 0<z i) (hz1 : ∀ i, z i<1) :
    enrichedExpectedLog n 0 k f p d (fun _ => 0) h z g=
      (n+1:ℕ)*amplitudeSphereValue n k (stepFieldIncrement k h) z (Real.sqrt (2*h 0))-
        (n+1:ℕ)*h (Fin.last k) := by
  let F := logSphericalExp n (Real.sqrt (n+1:ℕ))
  let c := -((n+1:ℕ)*h (Fin.last k))
  have hF : LipschitzWith ⟨|Real.sqrt (n+1:ℕ)|,abs_nonneg _⟩ F :=
    logSphericalExp_lipschitz n (Real.sqrt (n+1:ℕ))
  have hFc : LipschitzWith ⟨|Real.sqrt (n+1:ℕ)|,abs_nonneg _⟩ (fun a => F a+c) := by
    intro a b
    simpa only [F,edist_add_right] using hF a b
  have hp := enrichedSpinProjection_preserving (n+1) p
  have hG := gaussianBackward_lipschitz (stdGaussian (Spin (n+1))) hF _
    (cascadeHeatWord_nonneg (stepFieldIncrement k h) k z (fun i => (hz0 i).le))
  have hroot : Continuous (fun a : Spin (n+1) =>
      gaussianBackward (stdGaussian (Spin (n+1))) (cascadeHeatWord (stepFieldIncrement k h) k z)
        F (Real.sqrt (2*h 0) • a)) := hG.continuous.comp (show Continuous (fun a : Spin (n+1) => Real.sqrt (2*h 0) • a) by fun_prop)
  unfold enrichedExpectedLog
  rw [(enrichedCascadeLog_joint_mean n 0 k f g p d (fun _ => 0) h z hz hz0 hz1).2]
  have ht : enrichedTerminal n 0 f g p (fun _ => 0) (h (Fin.last k))=
      (fun a => F (enrichedSpinProjection (n+1) p a)+c) := by
    funext a
    exact enrichedTerminal_patternFree n f g p (h (Fin.last k)) a
  rw [ht]
  change (∫ a, gaussianLinearBackward (stdGaussian (EnrichedMark (n+1) (n+1) p))
    (linearCascadeWord (enrichedIncrementMap p d h) k z)
    (fun a => F (enrichedSpinProjection (n+1) p a)+c) (enrichedRootMap p d h a)
      ∂stdGaussian (EnrichedMark (n+1) (n+1) p))=_
  simp_rw [gaussianLinearBackward_projection (enrichedSpinProjection (n+1) p) hp
    (enrichedIncrementMap p d h) (stepFieldIncrement k h) (enrichedSpinProjection_increment p d h)
    hFc k z (fun i => (hz0 i).le),enrichedSpinProjection_root,
    gaussianBackward_add_const (stdGaussian (Spin (n+1))) hF _
      (cascadeHeatWord_nonneg (stepFieldIncrement k h) k z (fun i => (hz0 i).le)) c]
  have hi : Integrable (fun a : Spin (n+1) =>
      gaussianBackward (stdGaussian (Spin (n+1))) (cascadeHeatWord (stepFieldIncrement k h) k z)
        F (Real.sqrt (2*h 0) • a)) (stdGaussian (Spin (n+1))) :=
    ((lipschitz_memLp_stdGaussian (hG.comp ((Real.sqrt (2*h 0) • ContinuousLinearMap.id ℝ (Spin (n+1))).lipschitzWith)))).integrable (by norm_num)
  have hi' : Integrable (fun a : EnrichedMark (n+1) (n+1) p =>
      gaussianBackward (stdGaussian (Spin (n+1))) (cascadeHeatWord (stepFieldIncrement k h) k z)
        F (Real.sqrt (2*h 0) • enrichedSpinProjection (n+1) p a))
      (stdGaussian (EnrichedMark (n+1) (n+1) p)) := by
    convert ((hp.integrable_comp hroot.aestronglyMeasurable).mpr hi) using 1
    rfl
  rw [integral_add hi' (integrable_const c),
    integral_const,probReal_univ,one_smul]
  have he : (∫ a, gaussianBackward (stdGaussian (Spin (n+1)))
      (cascadeHeatWord (stepFieldIncrement k h) k z) F (Real.sqrt (2*h 0) • enrichedSpinProjection (n+1) p a)
      ∂stdGaussian (EnrichedMark (n+1) (n+1) p))=
        (∫ a, gaussianBackward (stdGaussian (Spin (n+1)))
      (cascadeHeatWord (stepFieldIncrement k h) k z) F (Real.sqrt (2*h 0) • a)
      ∂stdGaussian (Spin (n+1))) := by
    have hm := integral_map (μ := stdGaussian (EnrichedMark (n+1) (n+1) p))
      hp.measurable.aemeasurable hroot.aestronglyMeasurable
    rw [hp.map_eq] at hm
    exact hm.symm
  rw [he,amplitudeSphereValue_eq_backward n k _ z hz hz0 hz1,
    gaussianBackward,gaussianEntropic_zero _ hG]
  simp only [zero_add]
  dsimp only [F,c]
  field_simp
  ring

lemma sourceCountExpectedLog_patternFree (n k : ℕ) (f : ℝ →ᵇ ℝ)
    (p d : Fin (n+1)→ℕ) (w h : Fin (k+1)→ℝ)
    (hw : ∀ i, 0<w i) (hw1 : ∑ i, w i=1) (hh : Monotone h) (hh0 : 0≤h 0) :
    (1/(n+1:ℕ))*sourceCountExpectedLog n k f p d h (stepCumulative w) (fun _ => 0) 0=
      finiteSphericalFieldValue n k w h := by
  have hz := stepCumulative_strictMono w hw
  have hz0 := stepCumulative_pos w hw
  have hz1 := stepCumulative_lt_one w hw hw1
  have hi := (enrichedPoissonLog_section_variance n 0 k f p d (fun _ => 0) h
    (stepCumulative w) hz hz0 hz1).1.integrable (by norm_num)
  have he : sourceCountExpectedLog n k f p d h (stepCumulative w) (fun _ => 0) 0=
      ∫ g, enrichedExpectedLog n 0 k f p d (fun _ => 0) h (stepCumulative w)
        (patternPrefix (n+1) 0 g) ∂infinitePatternRowsLaw (n+1) := integral_prod _ hi
  rw [he]
  simp_rw [enrichedExpectedLog_patternFree n k f _ p d h (stepCumulative w) hz hz0 hz1]
  rw [integral_const,probReal_univ,one_smul,amplitudeSphereValue_eq]
  have hnonneg (index : Fin (k+1)) : 0≤2*h index :=
    mul_nonneg (by norm_num) (hh0.trans (hh (Fin.zero_le index)))
  have hs : (⟨(Real.sqrt (2*h 0))^2,sq_nonneg _⟩ : ℝ≥0)=Real.toNNReal (2*h 0) := by
    apply NNReal.eq
    change (Real.sqrt (2*h 0))^2=(Real.toNNReal (2*h 0):ℝ)
    rw [Real.sq_sqrt (hnonneg 0),Real.toNNReal_of_nonneg (hnonneg 0)]
    rfl
  rw [hs]
  unfold finiteSphericalFieldValue
  field_simp

lemma sourceExpectedPressure_patternFree (n k : ℕ) (f : ℝ →ᵇ ℝ)
    (p d : Fin (n+1)→ℕ) (w h : Fin (k+1)→ℝ)
    (hw : ∀ i, 0<w i) (hw1 : ∑ i, w i=1) (hh : Monotone h) (hh0 : 0≤h 0) :
    sourceExpectedPressure n k f p d h (stepCumulative w) 0 (fun _ => 0)=
      finiteSphericalFieldValue n k w h := by
  rw [sourceExpectedPressure_poissonMean n k f p d h (stepCumulative w) (fun _ => 0)
    (stepCumulative_strictMono w hw) (stepCumulative_pos w hw) (stepCumulative_lt_one w hw hw1)]
  simp only [mul_zero,NNReal.coe_zero]
  simp only [poissonRealMean,neg_zero,Real.exp_zero,one_mul,zero_pow_eq,ite_div,zero_div,ite_mul,zero_mul]
  simp only [tsum_ite_eq,one_div,Nat.factorial_zero,Nat.cast_one,inv_one,one_mul]
  simpa only [one_div] using sourceCountExpectedLog_patternFree n k f p d w h hw hw1 hh hh0

end SphericalPerceptronFreeEnergy
end

end OAI