import Mathlib
import OAI.Probability.IsingPerceptron.BoundedTiltAverage

namespace OAI

/-! Gaussian Family Generator. -/

noncomputable section

open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators Topology ENNReal NNReal
open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators Topology ENNReal NNReal
namespace IsingPerceptron

lemma gaussianFamily_hasFDerivAt {U T X XX : ℝ × ℝ → ℝ} {I : Set ℝ}
    (hI : IsOpen I) (hU : Measurable U) (hT : Measurable T) (hX : Measurable X) (hXX : Measurable XX)
    {K CT CX CXX : ℝ} (hK : ∀ p, |U p| ≤ K)
    (hCT : ∀ p, p.1 ∈ I → |T p| ≤ CT) (hCX : ∀ p, |X p| ≤ CX) (hCXX : ∀ p, |XX p| ≤ CXX)
    (hd : ∀ p, p.1 ∈ I → HasFDerivAt U (pairLinear (T p) (X p)) p)
    (dx : ∀ t y, HasDerivAt (fun x => U (t,x)) (X (t,y)) y)
    (dxx : ∀ t y, HasDerivAt (fun x => X (t,x)) (XX (t,y)) y)
    (a v d : ℝ) {m : ℝ} (hm : 0 < m) (hs : ∀ t ∈ I, m ≤ a+v*t)
    {p : ℝ × ℝ} (hp : p.1 ∈ I) :
    HasFDerivAt (fun q : ℝ × ℝ => gaussianTransform (a+v*q.1) d (fun y => U (q.1,y)) q.2)
      (pairLinear
        (gaussianTiltAverage (a+v*p.1) d (fun y => U (p.1,y)) (fun y => T (p.1,y)) p.2 +
          v/2*gaussianTiltAverage (a+v*p.1) d (fun y => U (p.1,y))
            (fun y => XX (p.1,y)+d*(X (p.1,y))^2) p.2)
        (gaussianTiltAverage (a+v*p.1) d (fun y => U (p.1,y)) (fun y => X (p.1,y)) p.2)) p := by
  let r := Real.sqrt (a+v*p.1)
  let ν := (gaussianReal 0 1).tilted (fun z => d*U (p.1,p.2+r*z))
  have hU0 : Measurable (fun z => U (p.1,p.2+r*z)) := hU.comp (by fun_prop)
  have hX0 : Measurable (fun z => X (p.1,p.2+r*z)) := hX.comp (by fun_prop)
  have hT0 : Measurable (fun z => T (p.1,p.2+r*z)) := hT.comp (by fun_prop)
  have hiX : Integrable (fun z => X (p.1,p.2+r*z)) ν :=
    integrable_tilt_of_bound (gaussianReal 0 1) hU0 hX0.aestronglyMeasurable
      (fun z => hK _) (B := fun _ => CX) (fun z => by simpa only [Real.norm_eq_abs] using hCX _)
      (integrable_const _) d
  have hiT : Integrable (fun z => T (p.1,p.2+r*z)) ν :=
    integrable_tilt_of_bound (gaussianReal 0 1) hU0 hT0.aestronglyMeasurable
      (fun z => hK _) (B := fun _ => CT) (fun z => by simpa only [Real.norm_eq_abs] using hCT (p.1,p.2+r*z) hp)
      (integrable_const _) d
  have hiZX : Integrable (fun z => z*X (p.1,p.2+r*z)) ν := by
    apply integrable_tilt_of_bound (gaussianReal 0 1) hU0 (measurable_id.mul hX0).aestronglyMeasurable
      (fun z => hK _) (B := fun z => |z| * CX) ?_ ?_ d
    · intro z
      change |z*X (p.1,p.2+r*z)| ≤ _
      rw [abs_mul]
      exact mul_le_mul_of_nonneg_left (hCX _) (abs_nonneg _)
    · exact (((memLp_id_gaussianReal 1).integrable le_rfl).abs).mul_const _
  have hefun : (fun z => T (p.1,p.2+r*z)+X (p.1,p.2+r*z)*(v/(2*r)*z)) =
      fun z => T (p.1,p.2+r*z)+(v/(2*r))*(z*X (p.1,p.2+r*z)) := by ext z; ring
  have hiA : Integrable (fun z => T (p.1,p.2+r*z)+X (p.1,p.2+r*z)*(v/(2*r)*z)) ν := by
    rw [hefun]; exact hiT.add (hiZX.const_mul _)
  have hraw := gaussianFamily_raw_hasFDerivAt hI hU hT hX hK hCT hCX hd a v d hm hs hp
  change HasFDerivAt _ (∫ z, pairLinear (T (p.1,p.2+r*z)+X (p.1,p.2+r*z)*(v/(2*r)*z))
    (X (p.1,p.2+r*z)) ∂ν) p at hraw
  rw [integral_pairLinear ν hiA hiX] at hraw
  have he : (∫ z, T (p.1,p.2+r*z)+X (p.1,p.2+r*z)*(v/(2*r)*z) ∂ν) =
      (∫ z, T (p.1,p.2+r*z) ∂ν) + v/2*(∫ z, XX (p.1,p.2+r*z)+d*(X (p.1,p.2+r*z))^2 ∂ν) := by
    rw [hefun,integral_add hiT (hiZX.const_mul _),integral_const_mul]
    have hibp := gaussian_tilted_ibp
      (U := fun y => U (p.1,y)) (D := fun y => X (p.1,y)) (DD := fun y => XX (p.1,y))
      (hU.comp (by fun_prop)) (hX.comp (by fun_prop)) (hXX.comp (by fun_prop))
      (fun y => hK _) (fun y => hCX _) (fun y => hCXX _) (dx p.1) (dxx p.1) r d p.2
    change (∫ z, z*X (p.1,p.2+r*z) ∂ν) = r*(∫ z, XX (p.1,p.2+r*z)+d*(X (p.1,p.2+r*z))^2 ∂ν) at hibp
    rw [hibp]
    have hr : r ≠ 0 := (Real.sqrt_pos.2 (hm.trans_le (hs _ hp))).ne'
    field_simp [hr]
  rw [he] at hraw
  exact hraw

end IsingPerceptron

 

 

open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators Topology ENNReal NNReal
namespace IsingPerceptron

 

structure GaussianFamily (I : Set ℝ) where
  U : ℝ × ℝ → ℝ
  X : ℝ × ℝ → ℝ
  XX : ℝ × ℝ → ℝ
  T : ℝ × ℝ → ℝ
  KU : ℝ
  KX : ℝ
  KXX : ℝ
  KT : ℝ
  mU : Measurable U
  mX : Measurable X
  mXX : Measurable XX
  mT : Measurable T
  bU : ∀ p, |U p| ≤ KU
  bX : ∀ p, |X p| ≤ KX
  bXX : ∀ p, |XX p| ≤ KXX
  bT : ∀ p, p.1 ∈ I → |T p| ≤ KT
  derivative : ∀ p, p.1 ∈ I → HasFDerivAt U (pairLinear (T p) (X p)) p
  spatial : ∀ t x, HasDerivAt (fun y => U (t,y)) (X (t,x)) x
  second : ∀ t x, HasDerivAt (fun y => X (t,y)) (XX (t,x)) x

def familyAverage (a v d : ℝ) (U A : ℝ × ℝ → ℝ) (p : ℝ × ℝ) : ℝ :=
  gaussianTiltAverage (a+v*p.1) d (fun y => U (p.1,y)) (fun y => A (p.1,y)) p.2

def familyTransform (a v d : ℝ) (U : ℝ × ℝ → ℝ) (p : ℝ × ℝ) : ℝ :=
  gaussianTransform (a+v*p.1) d (fun y => U (p.1,y)) p.2

lemma familyAverage_measurable {U A : ℝ × ℝ → ℝ} (hU : Measurable U)
    (hA : Measurable A) (a v d : ℝ) : Measurable (familyAverage a v d U A) := by
  exact measurable_gaussianTiltAverage_param (hU.comp (by fun_prop)) (hA.comp (by fun_prop))
    (by fun_prop) (by fun_prop) d

lemma familyTransform_measurable {U : ℝ × ℝ → ℝ} (hU : Measurable U)
    (a v d : ℝ) : Measurable (familyTransform a v d U) := by
  exact measurable_gaussianTransform_param (hU.comp (by fun_prop)) (by fun_prop) (by fun_prop) d

lemma familyAverage_bound {U A : ℝ × ℝ → ℝ} (hU : Measurable U)
    (hA : Measurable A) {K C : ℝ} (hK : ∀ p, |U p| ≤ K) (hC : ∀ p, |A p| ≤ C)
    (a v d : ℝ) (p : ℝ × ℝ) : |familyAverage a v d U A p| ≤ C := by
  exact gaussianTiltAverage_abs_le _ _ (hU.comp (by fun_prop)) (fun y => hK _)
    (hA.comp (by fun_prop)) (fun y => hC _) p.2

lemma familyAverage_local_bound {U A : ℝ × ℝ → ℝ} {I : Set ℝ} (hU : Measurable U)
    (hA : Measurable A) {K C : ℝ} (hK : ∀ p, |U p| ≤ K)
    (hC : ∀ p, p.1 ∈ I → |A p| ≤ C) (a v d : ℝ) {p : ℝ × ℝ} (hp : p.1 ∈ I) :
    |familyAverage a v d U A p| ≤ C := by
  exact gaussianTiltAverage_abs_le _ _ (hU.comp (by fun_prop)) (fun y => hK _)
    (hA.comp (by fun_prop)) (fun y => hC (p.1,y) hp) p.2

lemma square_bound {x C : ℝ} (h : |x| ≤ C) : |x^2| ≤ C^2 := by
  rw [abs_pow]
  exact pow_le_pow_left₀ (abs_nonneg _) h 2

namespace GaussianFamily
variable {I : Set ℝ} (F : GaussianFamily I)

def newX (a v d : ℝ) := familyAverage a v d F.U F.X

def newXX (a v d : ℝ) (p : ℝ × ℝ) :=
  familyAverage a v d F.U F.XX p +
    d*(familyAverage a v d F.U (fun q => (F.X q)^2) p - (F.newX a v d p)^2)

def newT (a v d : ℝ) (p : ℝ × ℝ) :=
  familyAverage a v d F.U F.T p +
    v/2*familyAverage a v d F.U (fun q => F.XX q+d*(F.X q)^2) p

lemma bound_newX (a v d : ℝ) (p : ℝ × ℝ) : |F.newX a v d p| ≤ F.KX :=
  familyAverage_bound F.mU F.mX F.bU F.bX a v d p

lemma bound_newXX (a v d : ℝ) (p : ℝ × ℝ) :
    |F.newXX a v d p| ≤ F.KXX+2*|d| * F.KX^2 := by
  have h1 := familyAverage_bound F.mU F.mXX F.bU F.bXX a v d p
  have h2 := familyAverage_bound F.mU (F.mX.pow_const 2) F.bU
    (fun q => square_bound (F.bX q)) a v d p
  have h3 := square_bound (F.bound_newX a v d p)
  unfold newXX
  refine (abs_add_le _ _).trans ?_
  rw [abs_mul]
  have hs := abs_sub (familyAverage a v d F.U (fun q => (F.X q)^2) p) ((F.newX a v d p)^2)
  calc
    _ ≤ F.KXX+|d| * (F.KX^2+F.KX^2) :=
      add_le_add h1 (mul_le_mul_of_nonneg_left (hs.trans (add_le_add h2 h3)) (abs_nonneg _))
    _ = _ := by ring

lemma bound_newT (a v d : ℝ) {p : ℝ × ℝ} (hp : p.1 ∈ I) :
    |F.newT a v d p| ≤ F.KT+|v|/2*(F.KXX+|d| * F.KX^2) := by
  have h1 := familyAverage_local_bound F.mU F.mT F.bU F.bT a v d hp
  have hB : ∀ q, |F.XX q+d*(F.X q)^2| ≤ F.KXX+|d| * F.KX^2 := by
    intro q
    refine (abs_add_le _ _).trans (add_le_add (F.bXX q) ?_)
    rw [abs_mul]
    exact mul_le_mul_of_nonneg_left (square_bound (F.bX q)) (abs_nonneg _)
  have h2 := familyAverage_bound F.mU (F.mXX.add (measurable_const.mul (F.mX.pow_const 2))) F.bU hB a v d p
  unfold newT
  refine (abs_add_le _ _).trans ?_
  rw [abs_mul,abs_div,abs_of_pos (by norm_num : (0:ℝ)<2)]
  exact add_le_add h1 (mul_le_mul_of_nonneg_left h2 (by positivity))

lemma spatial_newX (a v d t x : ℝ) :
    HasDerivAt (fun y => familyTransform a v d F.U (t,y)) (F.newX a v d (t,x)) x := by
  convert gaussianTransform_hasDerivAt (F.mU.comp (by fun_prop)) (F.mX.comp (by fun_prop))
    (fun y => F.bU _) (fun y => F.bX _) (F.spatial t) (a+v*t) d x using 1 <;> rfl

lemma spatial_newXX (a v d t x : ℝ) :
    HasDerivAt (fun y => F.newX a v d (t,y)) (F.newXX a v d (t,x)) x := by
  have h := gaussianTiltAverage_hasDerivAt (F.mU.comp (by fun_prop)) (F.mX.comp (by fun_prop))
    (F.mX.comp (by fun_prop)) (F.mXX.comp (by fun_prop))
    (fun y => F.bU _) (fun y => F.bX _) (fun y => F.bX _) (fun y => F.bXX _)
    (F.spatial t) (F.second t) (a+v*t) d x
  convert h using 1 <;> try rfl
  simp [newX,newXX,familyAverage,pow_two]
  rfl

lemma measurable_newXX (a v d : ℝ) : Measurable (F.newXX a v d) :=
  (familyAverage_measurable F.mU F.mXX _ _ _).add (measurable_const.mul
    ((familyAverage_measurable F.mU (F.mX.pow_const 2) _ _ _).sub
      ((familyAverage_measurable F.mU F.mX _ _ _).pow_const 2)))

lemma measurable_newT (a v d : ℝ) : Measurable (F.newT a v d) :=
  (familyAverage_measurable F.mU F.mT _ _ _).add (measurable_const.mul
    (familyAverage_measurable F.mU (F.mXX.add (measurable_const.mul (F.mX.pow_const 2))) _ _ _))

 
def transform (hI : IsOpen I) (a v : ℝ) {d : ℝ} (hd : 0 ≤ d)
    {m : ℝ} (hm : 0 < m) (hs : ∀ t ∈ I, m ≤ a+v*t) : GaussianFamily I where
  U := familyTransform a v d F.U
  X := F.newX a v d
  XX := F.newXX a v d
  T := F.newT a v d
  KU := F.KU
  KX := F.KX
  KXX := F.KXX+2*|d| * F.KX^2
  KT := F.KT+|v|/2*(F.KXX+|d| * F.KX^2)
  mU := familyTransform_measurable F.mU a v d
  mX := familyAverage_measurable F.mU F.mX a v d
  mXX := F.measurable_newXX a v d
  mT := F.measurable_newT a v d
  bU := fun p => gaussianTransform_abs_le (F.mU.comp (by fun_prop)) (fun y => F.bU _) _ hd _
  bX := F.bound_newX a v d
  bXX := F.bound_newXX a v d
  bT := fun p hp => F.bound_newT a v d hp
  derivative := fun p hp => gaussianFamily_hasFDerivAt hI F.mU F.mT F.mX F.mXX F.bU F.bT F.bX F.bXX
    F.derivative F.spatial F.second a v d hm hs hp
  spatial := F.spatial_newX a v d
  second := F.spatial_newXX a v d

end GaussianFamily
end IsingPerceptron

 

 

open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators Topology ENNReal NNReal
namespace IsingPerceptron

lemma gaussianTilt_integrable {U A : ℝ → ℝ} (hU : Measurable U) (hA : Measurable A)
    {K C : ℝ} (hK : ∀ y, |U y| ≤ K) (hC : ∀ y, |A y| ≤ C) (s d x : ℝ) :
    Integrable (fun z => A (x+Real.sqrt s*z))
      ((gaussianReal 0 1).tilted (fun z => d*U (x+Real.sqrt s*z))) := by
  exact integrable_tilt_of_bound (gaussianReal 0 1) (hU.comp (by fun_prop))
    (hA.comp (by fun_prop)).aestronglyMeasurable (fun z => hK _)
    (B := fun _ => C) (fun z => by simpa only [Real.norm_eq_abs,Function.comp_apply] using hC (x+Real.sqrt s*z)) (integrable_const _) d

lemma gaussianTiltAverage_add {U A B : ℝ → ℝ} (hU : Measurable U)
    (hA : Measurable A) (hB : Measurable B) {K CA CB : ℝ} (hK : ∀ y, |U y| ≤ K)
    (hCA : ∀ y, |A y| ≤ CA) (hCB : ∀ y, |B y| ≤ CB) (s d x : ℝ) :
    gaussianTiltAverage s d U (fun y => A y+B y) x =
      gaussianTiltAverage s d U A x+gaussianTiltAverage s d U B x :=
  integral_add (gaussianTilt_integrable hU hA hK hCA s d x) (gaussianTilt_integrable hU hB hK hCB s d x)

lemma gaussianTiltAverage_mul_const (s d c : ℝ) (U A : ℝ → ℝ) (x : ℝ) :
    gaussianTiltAverage s d U (fun y => A y*c) x = gaussianTiltAverage s d U A x*c :=
  integral_mul_const _ _

lemma gaussianTiltAverage_const_mul (s d c : ℝ) (U A : ℝ → ℝ) (x : ℝ) :
    gaussianTiltAverage s d U (fun y => c*A y) x = c*gaussianTiltAverage s d U A x :=
  integral_const_mul _ _

lemma gaussianTiltAverage_const {U : ℝ → ℝ} (hU : Measurable U)
    {K : ℝ} (hK : ∀ y, |U y| ≤ K) (s d c x : ℝ) :
    gaussianTiltAverage s d U (fun _ => c) x = c := by
  have hE : Integrable (fun z => Real.exp (d*U (x+Real.sqrt s*z))) (gaussianReal 0 1) :=
    exp_mul_integrable_of_bound _ (hU.comp (by fun_prop)) (fun z => hK _) d
  let : IsProbabilityMeasure ((gaussianReal 0 1).tilted (fun z => d*U (x+Real.sqrt s*z))) :=
    isProbabilityMeasure_tilted hE
  simp [gaussianTiltAverage]

lemma gaussianTiltAverage_nonneg (s d : ℝ) (U A : ℝ → ℝ) (hA : ∀ y, 0 ≤ A y) (x : ℝ) :
    0 ≤ gaussianTiltAverage s d U A x := integral_nonneg (fun _ => hA _)

lemma gaussianTiltAverage_mono {U A B : ℝ → ℝ} (hU : Measurable U)
    (hA : Measurable A) (hB : Measurable B) {K CA CB : ℝ} (hK : ∀ y, |U y| ≤ K)
    (hCA : ∀ y, |A y| ≤ CA) (hCB : ∀ y, |B y| ≤ CB) (hAB : ∀ y, A y ≤ B y) (s d x : ℝ) :
    gaussianTiltAverage s d U A x ≤ gaussianTiltAverage s d U B x :=
  integral_mono (gaussianTilt_integrable hU hA hK hCA s d x) (gaussianTilt_integrable hU hB hK hCB s d x)
    (fun _ => hAB _)

lemma gaussianTiltAverage_sq_le {U A : ℝ → ℝ} (hU : Measurable U) (hA : Measurable A)
    {K C : ℝ} (hK : ∀ y, |U y| ≤ K) (hC : ∀ y, |A y| ≤ C) (s d x : ℝ) :
    (gaussianTiltAverage s d U A x)^2 ≤ gaussianTiltAverage s d U (fun y => (A y)^2) x := by
  let m := gaussianTiltAverage s d U A x
  have hA2 : ∀ y, |(A y)^2| ≤ C^2 := by
    intro y
    rw [abs_pow]
    exact pow_le_pow_left₀ (abs_nonneg _) (hC y) 2
  have hAi := gaussianTilt_integrable hU hA hK hC s d x
  have hA2i := gaussianTilt_integrable hU (hA.pow_const 2) hK hA2 s d x
  have h : 0 ≤ gaussianTiltAverage s d U (fun y => (A y-m)^2) x :=
    gaussianTiltAverage_nonneg _ _ _ _ (fun y => sq_nonneg _) _
  have he : (fun y => (A y-m)^2) = (fun y => (A y)^2-(2*m)*A y+m^2) := by ext y; ring
  rw [he] at h
  unfold gaussianTiltAverage at h
  simp only at h
  erw [integral_add (hA2i.sub (hAi.const_mul (2*m))) (integrable_const (m^2)),
    integral_sub hA2i (hAi.const_mul (2*m)),integral_const_mul] at h
  have hc := gaussianTiltAverage_const hU hK s d (m^2) x
  change (∫ _ : ℝ, m^2 ∂(gaussianReal 0 1).tilted (fun z => d*U (x+Real.sqrt s*z))) = m^2 at hc
  rw [hc] at h
  change 0 ≤ gaussianTiltAverage s d U (fun y => (A y)^2) x - (2*m)*m + m^2 at h
  change m^2 ≤ _
  nlinarith

end IsingPerceptron

 

 

open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators Topology ENNReal NNReal
namespace IsingPerceptron

lemma familyAverage_add_at {U A B : ℝ × ℝ → ℝ} (hU : Measurable U)
    (hA : Measurable A) (hB : Measurable B) {K CA CB : ℝ} (hKU : ∀ q, |U q| ≤ K)
    (a v d : ℝ) (p : ℝ × ℝ) (hCA : ∀ y, |A (p.1,y)| ≤ CA)
    (hCB : ∀ y, |B (p.1,y)| ≤ CB) :
    familyAverage a v d U (fun q => A q+B q) p =
      familyAverage a v d U A p+familyAverage a v d U B p := by
  exact gaussianTiltAverage_add (hU.comp (by fun_prop)) (hA.comp (by fun_prop)) (hB.comp (by fun_prop))
    (fun y => hKU _) hCA hCB _ _ _

lemma familyAverage_const_mul (U A : ℝ × ℝ → ℝ) (a v d b : ℝ) (p : ℝ × ℝ) :
    familyAverage a v d U (fun q => b*A q) p = b*familyAverage a v d U A p :=
  gaussianTiltAverage_const_mul _ _ _ _ _ _

lemma familyAverage_sum {n : ℕ} {U : ℝ × ℝ → ℝ} {A : Fin n → ℝ × ℝ → ℝ}
    (hU : Measurable U) (hA : ∀ i, Measurable (A i)) {K : ℝ} {C : Fin n → ℝ}
    (hK : ∀ q, |U q| ≤ K) (hC : ∀ i q, |A i q| ≤ C i) (a v d : ℝ) (p : ℝ × ℝ) :
    familyAverage a v d U (fun q => ∑ i, A i q) p = ∑ i, familyAverage a v d U (A i) p := by
  apply integral_finsetSum
  intro i _
  exact gaussianTilt_integrable (hU.comp (by fun_prop)) ((hA i).comp (by fun_prop))
    (fun y => hK _) (fun y => hC i _) _ _ _

namespace GaussianFamily
variable {I : Set ℝ} (F : GaussianFamily I)

lemma average_generator (a v d e : ℝ) (p : ℝ × ℝ) :
    familyAverage a v d F.U (fun q => F.XX q+e*(F.X q)^2) p =
      familyAverage a v d F.U F.XX p + e*familyAverage a v d F.U (fun q => (F.X q)^2) p := by
  erw [familyAverage_add_at F.mU F.mXX (measurable_const.mul (F.mX.pow_const 2)) F.bU a v d p
    (fun y => F.bXX _) (CA := F.KXX) (CB := |e| * F.KX^2),familyAverage_const_mul]
  intro y
  change |e*(F.X (p.1,y))^2| ≤ _
  rw [abs_mul]
  exact mul_le_mul_of_nonneg_left (square_bound (F.bX _)) (abs_nonneg _)

lemma generator_identity (a v d : ℝ) (p : ℝ × ℝ) :
    F.newXX a v d p+d*(F.newX a v d p)^2 =
      familyAverage a v d F.U (fun q => F.XX q+d*(F.X q)^2) p := by
  rw [F.average_generator]
  unfold newXX
  ring

lemma cancellation (a v d b e : ℝ) {p : ℝ × ℝ} (hp : p.1 ∈ I) :
    F.newT a v d p+(b-v)/2*(F.newXX a v d p+d*(F.newX a v d p)^2) =
      familyAverage a v d F.U (fun q => F.T q+b/2*(F.XX q+e*(F.X q)^2)) p -
        ((e-d)*b)/2*familyAverage a v d F.U (fun q => (F.X q)^2) p := by
  have hbound : ∀ y, |b/2*(F.XX (p.1,y)+e*(F.X (p.1,y))^2)| ≤
      |b/2| * (F.KXX+|e| * F.KX^2) := by
    intro y
    rw [abs_mul]
    exact mul_le_mul_of_nonneg_left
      (bounded_generator (fun y => F.bX (p.1,y)) (fun y => F.bXX (p.1,y)) e y) (abs_nonneg _)
  erw [familyAverage_add_at F.mU F.mT
    (measurable_const.mul (F.mXX.add (measurable_const.mul (F.mX.pow_const 2)))) F.bU a v d p
    (fun y => F.bT (p.1,y) hp) hbound,familyAverage_const_mul,F.generator_identity]
  unfold newT
  erw [F.average_generator a v d d,F.average_generator a v d e]
  ring

lemma squared_newX_le (a v d : ℝ) (p : ℝ × ℝ) :
    (F.newX a v d p)^2 ≤ familyAverage a v d F.U (fun q => (F.X q)^2) p :=
  gaussianTiltAverage_sq_le (F.mU.comp (by fun_prop)) (F.mX.comp (by fun_prop))
    (fun y => F.bU _) (fun y => F.bX _) _ _ _

 
def terminal {f f' f'' : ℝ → ℝ} (hf : Measurable f) (hf' : Measurable f') (hf'' : Measurable f'')
    {K C D : ℝ} (hK : ∀ x, |f x| ≤ K) (hC : ∀ x, |f' x| ≤ C) (hD : ∀ x, |f'' x| ≤ D)
    (hder : ∀ x, HasDerivAt f (f' x) x) (hder' : ∀ x, HasDerivAt f' (f'' x) x) : GaussianFamily I where
  U := fun p => f p.2
  X := fun p => f' p.2
  XX := fun p => f'' p.2
  T := fun _ => 0
  KU := K
  KX := C
  KXX := D
  KT := 0
  mU := hf.comp measurable_snd
  mX := hf'.comp measurable_snd
  mXX := hf''.comp measurable_snd
  mT := measurable_const
  bU := fun p => hK _
  bX := fun p => hC _
  bXX := fun p => hD _
  bT := fun p _ => by simp
  derivative := fun p _ => by
    have h := (hder p.2).comp_hasFDerivAt p (hasFDerivAt_snd (𝕜 := ℝ))
    convert h using 1 <;> try rfl
    simp [pairLinear]
  spatial := fun t x => hder x
  second := fun t x => hder' x

end GaussianFamily
end IsingPerceptron

 

 

open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators Topology ENNReal NNReal
namespace IsingPerceptron

lemma monotone_fin_cons {n : ℕ} (a : ℝ) (c : Fin n → ℝ) (hm : Monotone c)
    (ha : ∀ i, a ≤ c i) : Monotone (Fin.cons a c) := by
  intro i
  refine Fin.cases ?_ (fun i => ?_) i
  · intro j
    refine Fin.cases ?_ (fun j => ?_) j
    · intro _; exact le_rfl
    · intro _; exact ha j
  · intro j
    refine Fin.cases ?_ (fun j => ?_) j
    · intro h
      exact False.elim (by simp at h)
    · intro h
      exact hm (Fin.succ_le_succ_iff.mp h)

lemma familyAverage_congr_fiber {U A B : ℝ × ℝ → ℝ} {a v d : ℝ} {p : ℝ × ℝ}
    (h : ∀ y, A (p.1,y)=B (p.1,y)) :
    familyAverage a v d U A p = familyAverage a v d U B p := by
  apply integral_congr_ae
  exact ae_of_all _ (fun z => h _)

lemma familyAverage_weightedSum {n : ℕ} {U : ℝ × ℝ → ℝ} {c : Fin n → ℝ × ℝ → ℝ}
    (hU : Measurable U) (hc : ∀ i, Measurable (c i)) {K C : ℝ}
    (hK : ∀ q, |U q| ≤ K) (hC : ∀ i q, |c i q| ≤ C) (w : Fin n → ℝ)
    (a v d : ℝ) (p : ℝ × ℝ) :
    familyAverage a v d U (fun q => ∑ i, w i*c i q) p =
      ∑ i, w i*familyAverage a v d U (c i) p := by
  erw [familyAverage_sum hU (fun i => measurable_const.mul (hc i)) hK
    (C := fun i => |w i| * C) (fun i q => ?_) a v d p]
  · apply Finset.sum_congr rfl
    intro i _
    exact familyAverage_const_mul U (c i) a v d (w i) p
  · change |w i*c i q| ≤ _
    rw [abs_mul]
    exact mul_le_mul_of_nonneg_left (hC i q) (abs_nonneg _)

 

structure VariationCertificate {I : Set ℝ} (F : GaussianFamily I) (n : ℕ)
    (b e : ℝ) (w : Fin n → ℝ) where
  c : Fin n → ℝ × ℝ → ℝ
  measurable : ∀ i, Measurable (c i)
  nonneg : ∀ i p, 0 ≤ c i p
  bound : ∀ i p, |c i p| ≤ F.KX^2
  monotone : ∀ p, Monotone (fun i => c i p)
  leading : ∀ i p, (F.X p)^2 ≤ c i p
  formula : ∀ p, p.1 ∈ I → F.T p+b/2*(F.XX p+e*(F.X p)^2) =
    -(1/2:ℝ)*∑ i, w i*c i p

namespace VariationCertificate
variable {I : Set ℝ} {F : GaussianFamily I} {n : ℕ} {b e : ℝ} {w : Fin n → ℝ}
  (V : VariationCertificate F n b e w)

def prependC (a v d : ℝ) : Fin (n+1) → ℝ × ℝ → ℝ :=
  Fin.cons (familyAverage a v d F.U (fun q => (F.X q)^2))
    (fun i => familyAverage a v d F.U (V.c i))

lemma measurable_prependC (a v d : ℝ) (i : Fin (n+1)) : Measurable (V.prependC a v d i) := by
  refine Fin.cases ?_ (fun i => ?_) i
  · exact familyAverage_measurable F.mU (F.mX.pow_const 2) _ _ _
  · exact familyAverage_measurable F.mU (V.measurable i) _ _ _

lemma nonneg_prependC (a v d : ℝ) (i : Fin (n+1)) (p : ℝ × ℝ) :
    0 ≤ V.prependC a v d i p := by
  refine Fin.cases ?_ (fun i => ?_) i
  · change 0 ≤ familyAverage a v d F.U (fun q => (F.X q)^2) p
    exact gaussianTiltAverage_nonneg (a+v*p.1) d (fun y => F.U (p.1,y))
      (fun y => (F.X (p.1,y))^2) (fun y => sq_nonneg _) p.2
  · change 0 ≤ familyAverage a v d F.U (V.c i) p
    exact gaussianTiltAverage_nonneg (a+v*p.1) d (fun y => F.U (p.1,y))
      (fun y => V.c i (p.1,y)) (fun y => V.nonneg i _) p.2

lemma bound_prependC (a v d : ℝ) (i : Fin (n+1)) (p : ℝ × ℝ) :
    |V.prependC a v d i p| ≤ F.KX^2 := by
  refine Fin.cases ?_ (fun i => ?_) i
  · exact familyAverage_bound F.mU (F.mX.pow_const 2) F.bU (fun q => square_bound (F.bX q)) _ _ _ _
  · exact familyAverage_bound F.mU (V.measurable i) F.bU (V.bound i) _ _ _ _

lemma head_le_prependTail (a v d : ℝ) (i : Fin n) (p : ℝ × ℝ) :
    familyAverage a v d F.U (fun q => (F.X q)^2) p ≤ familyAverage a v d F.U (V.c i) p := by
  exact gaussianTiltAverage_mono (F.mU.comp (by fun_prop)) ((F.mX.pow_const 2).comp (by fun_prop))
    ((V.measurable i).comp (by fun_prop)) (fun y => F.bU _) (fun y => square_bound (F.bX _))
    (fun y => V.bound i _) (fun y => V.leading i _) _ _ _

lemma leading_prependC (a v d : ℝ) (i : Fin (n+1)) (p : ℝ × ℝ) :
    (F.newX a v d p)^2 ≤ V.prependC a v d i p := by
  refine Fin.cases (F.squared_newX_le a v d p) (fun i => ?_) i
  exact (F.squared_newX_le a v d p).trans (V.head_le_prependTail a v d i p)

lemma monotone_prependC (a v d : ℝ) (p : ℝ × ℝ) : Monotone (fun i => V.prependC a v d i p) := by
  have hmono : Monotone (fun i => familyAverage a v d F.U (V.c i) p) := by
    intro i j hij
    exact gaussianTiltAverage_mono (F.mU.comp (by fun_prop)) ((V.measurable i).comp (by fun_prop))
      ((V.measurable j).comp (by fun_prop)) (fun y => F.bU _) (fun y => V.bound i _)
      (fun y => V.bound j _) (fun y => V.monotone _ hij) _ _ _
  have h := monotone_fin_cons (familyAverage a v d F.U (fun q => (F.X q)^2) p) _ hmono
    (fun i => V.head_le_prependTail a v d i p)
  convert h using 1
  ext i
  refine Fin.cases rfl (fun i => rfl) i

lemma formula_prependC (a v d : ℝ) {p : ℝ × ℝ} (hp : p.1 ∈ I) :
    F.newT a v d p+(b-v)/2*(F.newXX a v d p+d*(F.newX a v d p)^2) =
      -(1/2:ℝ)*∑ i : Fin (n+1), ((Fin.cons ((e-d)*b) w : Fin (n+1) → ℝ) i)*(V.prependC a v d i p) := by
  rw [F.cancellation a v d b e hp]
  have heq : familyAverage a v d F.U (fun q => F.T q+b/2*(F.XX q+e*(F.X q)^2)) p =
      familyAverage a v d F.U (fun q => -(1/2:ℝ)*∑ i, w i*V.c i q) p :=
    familyAverage_congr_fiber (fun y => V.formula (p.1,y) hp)
  rw [heq,familyAverage_const_mul,
    familyAverage_weightedSum F.mU V.measurable F.bU V.bound w a v d p,Fin.sum_univ_succ]
  simp only [Fin.cons_zero,Fin.cons_succ,prependC]
  ring

 

def prepend (hI : IsOpen I) (a v : ℝ) {d : ℝ} (hd : 0 ≤ d)
    {m : ℝ} (hm : 0 < m) (hs : ∀ t ∈ I, m ≤ a+v*t) :
    VariationCertificate (F.transform hI a v hd hm hs) (n+1) (b-v) d (Fin.cons ((e-d)*b) w) where
  c := V.prependC a v d
  measurable := V.measurable_prependC a v d
  nonneg := V.nonneg_prependC a v d
  bound := V.bound_prependC a v d
  leading := V.leading_prependC a v d
  monotone := V.monotone_prependC a v d
  formula := fun _ hp => V.formula_prependC a v d hp

 

def empty {G : GaussianFamily I} (hT : ∀ p, G.T p=0) (e : ℝ) :
    VariationCertificate G 0 0 e (fun i => Fin.elim0 i) where
  c := fun i => Fin.elim0 i
  measurable := fun i => Fin.elim0 i
  nonneg := fun i => Fin.elim0 i
  bound := fun i => Fin.elim0 i
  leading := fun i => Fin.elim0 i
  monotone := fun p i => Fin.elim0 i
  formula := fun p _ => by simp [hT p]

end VariationCertificate
end IsingPerceptron

 

 

open scoped BigOperators
namespace IsingPerceptron

 
def FinTailNonneg {n : ℕ} (w : Fin n → ℝ) : Prop :=
  ∀ j : Fin n, 0 ≤ ∑ i : Fin n, if j ≤ i then w i else 0

lemma FinTailNonneg.succ {n : ℕ} {w : Fin (n+1) → ℝ} (h : FinTailNonneg w) :
    FinTailNonneg (fun i : Fin n => w i.succ) := by
  intro j
  have hh := h j.succ
  simpa [Fin.sum_univ_succ,Fin.succ_le_succ_iff] using hh

lemma FinTailNonneg.total {n : ℕ} {w : Fin n → ℝ} (h : FinTailNonneg w) :
    0 ≤ ∑ i, w i := by
  cases n with
  | zero => simp
  | succ n => simpa using h 0

 
lemma finite_tail_pairing_nonneg {n : ℕ} (w c : Fin n → ℝ) (hw : FinTailNonneg w)
    (hc : ∀ i, 0 ≤ c i) (hm : Monotone c) : 0 ≤ ∑ i, w i*c i := by
  induction n with
  | zero => simp
  | succ n ih =>
    have hnext := ih (fun i : Fin n => w i.succ) (fun i => c i.succ-c 0) hw.succ
      (fun i => sub_nonneg.mpr (hm (Fin.zero_le _)))
      (fun i j hij => sub_le_sub_right (hm (Fin.succ_le_succ_iff.mpr hij)) _)
    have hfirst := mul_nonneg (hc 0) hw.total
    have he : (∑ i : Fin (n+1), w i*c i) =
        c 0*(∑ i : Fin (n+1), w i)+∑ i : Fin n, w i.succ*(c i.succ-c 0) := by
      rw [Fin.sum_univ_succ,Fin.sum_univ_succ]
      simp_rw [mul_sub]
      rw [Finset.sum_sub_distrib,← Finset.sum_mul]
      ring
    rw [he]
    exact add_nonneg hfirst hnext

end IsingPerceptron

end

end OAI