import Mathlib
import OAI.Probability.SKFluctuations.ScalarGapWeighted

namespace OAI

/-! Clock Flatten Schedule. -/

noncomputable section

open MeasureTheory ProbabilityTheory Filter
open scoped BigOperators Topology
open MeasureTheory Filter Set
open scoped Topology
open MeasureTheory ProbabilityTheory Filter Set
namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set GaussianCalculus
open scoped Topology NNReal BigOperators

def clockLength (cs : List HeatClock) : ℝ := (cs.map (fun c => (c.time:ℝ))).sum
def clockExcess (a : ℝ) (cs : List HeatClock) : ℝ :=
  (cs.map (fun c => (c.mass-a)*(c.time:ℝ))).sum

@[simp] theorem clockLength_nil : clockLength [] = 0 := rfl
@[simp] theorem clockLength_cons (c : HeatClock) (cs : List HeatClock) :
    clockLength (c::cs) = c.time+clockLength cs := rfl
@[simp] theorem clockExcess_nil (a : ℝ) : clockExcess a [] = 0 := rfl
@[simp] theorem clockExcess_cons (a : ℝ) (c : HeatClock) (cs : List HeatClock) :
    clockExcess a (c::cs) = (c.mass-a)*c.time+clockExcess a cs := rfl

theorem clockLength_nonneg (cs : List HeatClock) : 0 ≤ clockLength cs := by
  induction cs with
  | nil => exact le_rfl
  | cons c cs ih => exact add_nonneg c.time.coe_nonneg ih

theorem clockExcess_nonneg (a : ℝ) (cs : List HeatClock)
    (hc : ∀ c ∈ cs, a ≤ c.mass) : 0 ≤ clockExcess a cs := by
  induction cs with
  | nil => exact le_rfl
  | cons c cs ih =>
    exact add_nonneg (mul_nonneg (sub_nonneg.mpr (hc c (List.mem_cons_self ..))) c.time.coe_nonneg)
      (ih (fun d hd => hc d (List.mem_cons_of_mem _ hd)))

theorem HeatJet.flatten_schedule_energy {J : HeatJet 0} (hJ : J.ScalarAdmissible)
    (hA : J.GradientTest) (cs : List HeatClock) (hc : ∀ c ∈ cs, c.mass ≤ 1)
    {a A : ℝ} (ha : a ∈ Icc (0:ℝ) 1) (hA0 : 0 ≤ A) (x : Fin 1 → ℝ) :
    |(J.schedule cs).observedSquare a A x-J.observedSquare a (A+clockLength cs) x| ≤
      4*clockLength cs := by
  induction cs generalizing A with
  | nil => simp only [HeatJet.schedule,clockLength_nil,add_zero,sub_self,abs_zero,mul_zero,le_refl]
  | cons c cs ih =>
    have hcs : ∀ d ∈ cs, d.mass ≤ 1 := fun d hd => hc d (List.mem_cons_of_mem _ hd)
    have hh := HeatJet.flatten_one_energy (hJ.schedule cs hcs) (hA.schedule cs) ha
      c.positive (hc c (List.mem_cons_self ..)) hA0 c.time.coe_nonneg x
    have hi := ih hcs (A:=A+c.time) (by positivity)
    have ht := (abs_sub_le ((J.schedule (c::cs)).observedSquare a A x)
      ((J.schedule cs).observedSquare a (A+c.time) x)
      (J.observedSquare a (A+c.time+clockLength cs) x)).trans (add_le_add hh hi)
    simpa only [clockLength_cons,add_assoc,mul_add] using ht

 

theorem HeatJet.flatten_schedule_error {J : HeatJet 0} (hJ : J.ScalarAdmissible)
    (hA : J.GradientTest) (cs : List HeatClock) {a A : ℝ}
    (ha : 0 < a) (ha1 : a ≤ 1) (hc : ∀ c ∈ cs, a ≤ c.mass ∧ c.mass ≤ 1)
    (hA0 : 0 ≤ A) (x : Fin 1 → ℝ) :
    |clockContinuation a (J.schedule cs).F A x-clockContinuation a J.F (A+clockLength cs) x-
      (clockExcess a cs/2)*J.observedSquare a (A+clockLength cs) x| ≤
      2*clockLength cs*clockExcess a cs := by
  induction cs generalizing A with
  | nil => simp only [HeatJet.schedule,clockLength_nil,clockExcess_nil,add_zero,sub_self,
      zero_div,zero_mul,abs_zero,mul_zero,le_refl]
  | cons c cs ih =>
    have hcs : ∀ d ∈ cs, a ≤ d.mass ∧ d.mass ≤ 1 := fun d hd => hc d (List.mem_cons_of_mem _ hd)
    have hcc := hc c (List.mem_cons_self ..)
    have hh := HeatJet.flatten_one_error (hJ.schedule cs (fun d hd => (hcs d hd).2))
      (hA.schedule cs) ha ha1 c.positive hcc.2 hcc.1 hA0 c.time.coe_nonneg x
    have hi := ih hcs (A:=A+c.time) (by positivity)
    have he := HeatJet.flatten_schedule_energy hJ hA cs (fun d hd => (hcs d hd).2)
      ⟨ha.le,ha1⟩ (A:=A+c.time) (by positivity) x
    let F₀ := clockContinuation a (J.schedule (c::cs)).F A x
    let F₁ := clockContinuation a (J.schedule cs).F (A+c.time) x
    let F₂ := clockContinuation a J.F (A+c.time+clockLength cs) x
    let E₁ := (J.schedule cs).observedSquare a (A+c.time) x
    let E₂ := J.observedSquare a (A+c.time+clockLength cs) x
    let w := (c.mass-a)*(c.time:ℝ)
    have hw : 0 ≤ w := mul_nonneg (sub_nonneg.mpr hcc.1) c.time.coe_nonneg
    have hW : 0 ≤ clockExcess a cs := clockExcess_nonneg a cs (fun d hd => (hcs d hd).1)
    change |F₀-F₁-w/2*E₁| ≤ 2*(c.mass-a)*(c.time:ℝ)^2 at hh
    change |F₁-F₂-clockExcess a cs/2*E₂| ≤ _ at hi
    change |E₁-E₂| ≤ _ at he
    have h3 : |w/2*(E₁-E₂)| ≤ 2*w*clockLength cs := by
      rw [abs_mul,abs_of_nonneg (by positivity : 0 ≤ w/2)]
      calc
        _ ≤ w/2*(4*clockLength cs) := mul_le_mul_of_nonneg_left he (by positivity)
        _ = _ := by ring
    have ht : |F₀-F₂-(w+clockExcess a cs)/2*E₂| ≤
        2*(c.mass-a)*(c.time:ℝ)^2+2*clockLength cs*clockExcess a cs+2*w*clockLength cs := by
      calc
        _ = |(F₀-F₁-w/2*E₁)+(F₁-F₂-clockExcess a cs/2*E₂)+w/2*(E₁-E₂)| := by congr 1; ring
        _ ≤ |F₀-F₁-w/2*E₁|+|F₁-F₂-clockExcess a cs/2*E₂|+|w/2*(E₁-E₂)| :=
          (abs_add_le _ _).trans (add_le_add (abs_add_le _ _) le_rfl)
        _ ≤ _ := add_le_add (add_le_add hh hi) h3
    have hb : 2*(c.mass-a)*(c.time:ℝ)^2+2*clockLength cs*clockExcess a cs+2*w*clockLength cs ≤
        2*((c.time:ℝ)+clockLength cs)*(w+clockExcess a cs) := by
      dsimp only [w]
      nlinarith [mul_nonneg c.time.coe_nonneg hW]
    simpa only [clockLength_cons,clockExcess_cons,add_assoc,F₀,F₂,E₂,w]
      using ht.trans hb

end SKFluctuations.Hierarchy

 

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set GaussianCalculus
open scoped Topology NNReal BigOperators

@[simp] theorem clockExcess_append (a : ℝ) (cs ds : List HeatClock) :
    clockExcess a (cs++ds) = clockExcess a cs+clockExcess a ds := by
  simp only [clockExcess,List.map_append,List.sum_append]

theorem PositiveMassProfile.grid_excess (α : PositiveMassProfile) (a l : ℝ) (t : ℝ≥0) (k : ℕ) :
    clockExcess a (α.grid l t k) = dyadicLowerSum (fun s => α.mass s-a) l t k := by
  induction k generalizing l t with
  | zero => simp [PositiveMassProfile.grid,clockExcess,dyadicLowerSum,mul_comm]
  | succ k ih => simp only [PositiveMassProfile.grid,clockExcess_append,ih,dyadicLowerSum]

theorem dyadicLowerSum_abs_sub {f g : ℝ → ℝ} {C : ℝ} (h : ∀ s, |f s-g s| ≤ C)
    (l : ℝ) (t : ℝ≥0) (k : ℕ) :
    |dyadicLowerSum f l t k-dyadicLowerSum g l t k| ≤ (t:ℝ)*C := by
  induction k generalizing l t with
  | zero =>
    simp only [dyadicLowerSum,← mul_sub,abs_mul,abs_of_nonneg t.coe_nonneg]
    exact mul_le_mul_of_nonneg_left (h l) t.coe_nonneg
  | succ k ih =>
    simp only [dyadicLowerSum]
    have he : dyadicLowerSum f l (t/2) k+dyadicLowerSum f (l+t/2) (t/2) k-
        (dyadicLowerSum g l (t/2) k+dyadicLowerSum g (l+t/2) (t/2) k) =
        (dyadicLowerSum f l (t/2) k-dyadicLowerSum g l (t/2) k)+
        (dyadicLowerSum f (l+t/2) (t/2) k-dyadicLowerSum g (l+t/2) (t/2) k) := by ring
    rw [he]
    apply (abs_add_le _ _).trans ((add_le_add (ih l (t/2)) (ih (l+t/2) (t/2))).trans_eq _)
    simp only [NNReal.coe_div,NNReal.coe_ofNat]
    ring

theorem capped_grid_excess_tendsto (α : NonnegativeMassProfile) (a l : ℝ) (t : ℝ≥0) :
    Tendsto (fun k => clockExcess a ((α.cappedApprox k).grid l t k)) atTop
      (𝓝 (∫ s in l..l+t, α.mass s-a)) := by
  have hp : Tendsto (fun k : ℕ => (1/2:ℝ)^k) atTop (𝓝 0) :=
    tendsto_pow_atTop_nhds_zero_of_lt_one (by norm_num) (by norm_num)
  have hb (k : ℕ) :
      dist (clockExcess a ((α.cappedApprox k).grid l t k)) (∫ s in l..l+t, α.mass s-a) ≤
        (t:ℝ)*(1+α.mass (l+t)-α.mass l)*(1/2:ℝ)^k := by
    rw [PositiveMassProfile.grid_excess,Real.dist_eq]
    have h1 := dyadicLowerSum_abs_sub (f:=fun s => (α.cappedApprox k).mass s-a)
      (g:=fun s => α.mass s-a) (C:=(1/2:ℝ)^k) (fun s => by
        dsimp only [NonnegativeMassProfile.cappedApprox]
        rw [sub_sub_sub_cancel_right,abs_of_nonneg (sub_nonneg.mpr (le_max_left _ _))]
        exact sub_le_iff_le_add.mpr (max_le (by linarith [show 0 ≤ (1/2:ℝ)^k by positivity]) (by linarith [α.nonneg s]))) l t k
    have h2 := dyadicLowerSum_integral_error (show Monotone (fun s => α.mass s-a) from fun _ _ h => sub_le_sub_right (α.monotone h) a) l t k
    have ht := (abs_sub_le (dyadicLowerSum (fun s => (α.cappedApprox k).mass s-a) l t k)
      (dyadicLowerSum (fun s => α.mass s-a) l t k) (∫ s in l..l+t, α.mass s-a)).trans
      (add_le_add h1 (by simpa only [abs_sub_comm] using h2))
    apply ht.trans_eq
    ring
  apply tendsto_iff_dist_tendsto_zero.mpr
  exact squeeze_zero (fun _ => dist_nonneg) hb (by simpa only [mul_zero] using
    (hp.const_mul ((t:ℝ)*(1+α.mass (l+t)-α.mass l))))

 

theorem HeatJet.flatten_profile_error {J K : HeatJet 0} (hJ : J.ScalarAdmissible)
    (hA : J.GradientTest) (α : NonnegativeMassProfile) (hα : ∀ s, α.mass s ≤ 1)
    {a A l : ℝ} (t : ℝ≥0) (ha : 0 < a) (ha1 : a ≤ 1) (hal : a ≤ α.mass l)
    (hA0 : 0 ≤ A) (hK : K.F = J.nonnegativeProfileValue α l t) (x : Fin 1 → ℝ) :
    |clockContinuation a K.F A x-clockContinuation a J.F (A+t) x-
      ((∫ s in l..l+t, α.mass s-a)/2)*J.observedSquare a (A+t) x| ≤
      2*(t:ℝ)*(∫ s in l..l+t, α.mass s-a) := by
  have hg (k : ℕ) (y : Fin 1 → ℝ) :
      |(J.schedule ((α.cappedApprox k).grid l t k)).F y-K.F y| ≤ (t:ℝ)*(1/2:ℝ)^k := by
    rw [hK,(α.cappedApprox k).grid_eq_linear]
    have he : ((2^k:ℕ):ℝ≥0)*(t/(2^k:ℝ≥0)) = t := by simp only [Nat.cast_pow,Nat.cast_ofNat]; field_simp
    have hh := J.capped_linear_error (fun _ => 1) (fun i y => by rw [Fin.eq_zero i]; exact hJ.gradient y) α hα k l (t/(2^k:ℝ≥0)) (2^k) y
    rw [he] at hh
    apply hh.trans_eq
    norm_num only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,Nat.reduceAdd,
      nsmul_eq_mul,Nat.cast_one,one_pow,one_mul,NNReal.coe_div,NNReal.coe_pow,NNReal.coe_ofNat,
      Nat.cast_pow,Nat.cast_ofNat,div_pow,one_div]
    field_simp
    ring
  have ht : Tendsto (fun k => clockContinuation a (J.schedule ((α.cappedApprox k).grid l t k)).F A x)
      atTop (𝓝 (clockContinuation a K.F A x)) := by
    apply tendsto_iff_dist_tendsto_zero.mpr
    have hdist (k : ℕ) : dist (clockContinuation a (J.schedule ((α.cappedApprox k).grid l t k)).F A x)
        (clockContinuation a K.F A x) ≤ (t:ℝ)*(1/2:ℝ)^k := by
      rw [Real.dist_eq]
      exact clockContinuation_abs_sub_le (J.schedule _).lipschitz K.lipschitz ha (hg k) A x
    exact squeeze_zero (fun _ => dist_nonneg) hdist
      (by simpa only [mul_zero] using (tendsto_pow_atTop_nhds_zero_of_lt_one
        (by norm_num : (0:ℝ) ≤ 1/2) (by norm_num : (1/2:ℝ) < 1)).const_mul (t:ℝ))
  have hw := capped_grid_excess_tendsto α a l t
  apply le_of_tendsto_of_tendsto ((ht.sub_const _).sub ((hw.div_const 2).mul_const _)).abs
    (hw.const_mul (2*(t:ℝ)))
  apply Eventually.of_forall
  intro k
  have hh := HeatJet.flatten_schedule_error hJ hA ((α.cappedApprox k).grid l t k) ha ha1
    (fun c hc => ⟨hal.trans ((le_max_left _ _).trans ((α.cappedApprox k).grid_mass_bounds l t k hc).1),
      ((α.cappedApprox k).grid_mass_bounds l t k hc).2.trans (α.cappedApprox_le_one hα k _)⟩) hA0 x
  simpa only [clockLength,PositiveMassProfile.grid_total_time] using hh

end SKFluctuations.Hierarchy

 

 

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set GaussianCalculus
open scoped Topology NNReal BigOperators

theorem scalarProfile_constant_head (α : NonnegativeMassProfile) (hα : ∀ s, α.mass s ≤ 1)
    (l : ℝ) {s : ℝ≥0} (hs : 0 < (s:ℝ)) (t : ℝ≥0) {m : ℝ} (hm : 0 < m)
    (hf : ∀ r ∈ Ico l (l+s), α.mass r = m) (x : Fin 1 → ℝ) :
    scalarTerminal.nonnegativeProfileValue α l (s+t) x =
      clockContinuation m (scalarProfileHeatJet α hα (l+s) t).F s x := by
  rw [scalarProfile_concat α hα]
  exact HeatJet.nonnegativeProfileValue_constant _ α hm l s hs hf x

noncomputable def scalarTailJet {T : ℝ} (hT : 0 < T) (α : boundedMassProfiles) (q : ℝ) : HeatJet 0 :=
  scalarProfileHeatJet (rescaledMassProfile α hT) (fun s => (α.property.1 (s/T)).2)
    (T*q) (Real.toNNReal (T*(1-q)))

theorem scalarTailJet_G_bound {T : ℝ} (hT : 0 < T) (α : boundedMassProfiles) (q : ℝ) :
    ∀ i x, |(scalarTailJet hT α q).G i x| ≤ 1 :=
  scalarProfileHeatJet_G_bound _ _ _ _

theorem scalarTailJet_G_smooth {T : ℝ} (hT : 0 < T) (α : boundedMassProfiles) (q : ℝ) :
    ∀ k i, BddSmooth k ((scalarTailJet hT α q).G i) := by
  intro k i
  exact scalarProfileJet_bddSmooth_all (rescaledMassProfile α hT)
    (fun s => (α.property.1 (s/T)).2) (T*q) (Real.toNNReal (T*(1-q))) k 0

theorem scalarParisiValue_constant_head {T q m : ℝ} (hT : 0 < T) (hq : q ∈ Ioc (0:ℝ) 1)
    (α : boundedMassProfiles) (hm : 0 < m) (hf : ∀ r ∈ Ico (0:ℝ) q, α.val r = m) :
    scalarParisiValue hT α = clockContinuation m (scalarTailJet hT α q).F (T*q) 0-
      T/2*scalarPenalty α-T/4 := by
  have hs : 0 < T*q := mul_pos hT hq.1
  have ht : 0 ≤ T*(1-q) := mul_nonneg hT.le (sub_nonneg.mpr hq.2)
  have he : Real.toNNReal (T*q)+Real.toNNReal (T*(1-q)) = (⟨T,hT.le⟩:ℝ≥0) := by
    apply NNReal.eq
    change ((Real.toNNReal (T*q):ℝ)+(Real.toNNReal (T*(1-q)):ℝ)) = T
    rw [Real.coe_toNNReal _ hs.le,Real.coe_toNNReal _ ht]
    ring
  have hh := scalarProfile_constant_head (rescaledMassProfile α hT)
    (fun s => (α.property.1 (s/T)).2) 0
    (s:=Real.toNNReal (T*q)) (by rwa [Real.coe_toNNReal _ hs.le])
    (Real.toNNReal (T*(1-q))) hm (by
      intro r hr
      change α.val (r/T) = m
      apply hf
      simp only [zero_add,Real.coe_toNNReal _ hs.le] at hr
      exact ⟨div_nonneg hr.1 hT.le,(div_lt_iff₀ hT).mpr (by nlinarith [hr.2])⟩) 0
  rw [he] at hh
  simp only [zero_add,Real.coe_toNNReal _ hs.le] at hh
  unfold scalarParisiValue
  rw [hh]
  rfl

 
theorem scalarHead_hasDerivAt {T q m : ℝ} (hT : 0 < T) (hq : 0 ≤ q)
    (α : boundedMassProfiles) (hm : 0 < m) (hm1 : m < 1) :
    HasDerivAt (fun b => clockContinuation b (scalarTailJet hT α q).F (T*q) 0-
      T*b*q^2/4)
      ((1/2:ℝ)*(∫ s in 0..T*q, (scalarTailJet hT α q).filledSquare hm (T*q) s 0)-T*q^2/4) m := by
  have hh := (scalarTailJet hT α q).hasDerivAt_mass_clockContinuation
    (scalarTailJet_G_smooth hT α q) (scalarTailJet_G_bound hT α q 0) hm hm1 (mul_nonneg hT.le hq) 0
  have he (s : ℝ) : (scalarTailJet hT α q).massEnergy m hm (T*q) s 0 =
      (scalarTailJet hT α q).filledSquare hm (T*q) s 0 := by
    unfold HeatJet.massEnergy HeatJet.filledSquare HeatJet.potentialEnergy
    congr 1
    funext y
    rw [Fin.sum_univ_one]
    rfl
  simp_rw [he] at hh
  convert hh.fun_sub ((hasDerivAt_id m).const_mul T |>.mul_const (q^2) |>.div_const 4) using 1 <;>
    first | rfl | simp only [mul_one]

end SKFluctuations.Hierarchy

 

 

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set GaussianCalculus
open scoped Topology NNReal BigOperators

noncomputable def replaceHeadProfile (α : boundedMassProfiles) {q b : ℝ}
    (hb0 : 0 ≤ b) (hb1 : b ≤ 1) (hbq : b ≤ α.val q) : boundedMassProfiles :=
  ⟨fun s => if s < 0 then 0 else if s < q then b else α.val s, by
    constructor
    · intro s
      change (if s < 0 then 0 else if s < q then b else α.val s) ∈ Icc 0 1
      split_ifs <;> first | exact ⟨hb0,hb1⟩ | exact α.property.1 s | constructor <;> norm_num
    · intro s t hst
      change (if s < 0 then 0 else if s < q then b else α.val s) ≤
        (if t < 0 then 0 else if t < q then b else α.val t)
      by_cases hs : s < 0
      · rw [ite_eq_left hs]
        split_ifs <;> first | exact hb0 | exact (α.property.1 t).1 | exact le_rfl
      · rw [ite_eq_right hs]
        have ht : ¬ t < 0 := fun ht => hs (lt_of_le_of_lt hst ht)
        rw [ite_eq_right ht]
        by_cases hsq : s < q
        · rw [ite_eq_left hsq]
          split_ifs with htq
          · exact le_rfl
          · exact hbq.trans (α.property.2 (le_of_not_gt htq))
        · rw [ite_eq_right hsq, ite_eq_right (not_lt.mpr ((le_of_not_gt hsq).trans hst))]
          exact α.property.2 hst⟩

theorem replaceHeadProfile_mem {α : boundedMassProfiles} (hα : α ∈ scalarProfiles)
    {q b : ℝ} (hq : q ≤ 1) (hb0 : 0 ≤ b) (hb1 : b ≤ 1) (hbq : b ≤ α.val q) :
    replaceHeadProfile α hb0 hb1 hbq ∈ scalarProfiles := by
  constructor
  · intro s hs
    exact ite_eq_left hs
  · intro s hs
    change (if s < 0 then 0 else if s < q then b else α.val s) = 1
    rw [ite_eq_right (by linarith),ite_eq_right (by linarith)]
    exact hα.2 s hs

theorem replaceHeadProfile_head (α : boundedMassProfiles) {q b : ℝ}
    (hb0 : 0 ≤ b) (hb1 : b ≤ 1) (hbq : b ≤ α.val q) {s : ℝ} (hs : s ∈ Ico (0:ℝ) q) :
    (replaceHeadProfile α hb0 hb1 hbq).val s = b := by
  change (if s < 0 then 0 else if s < q then b else α.val s) = b
  rw [ite_eq_right (not_lt.mpr hs.1),ite_eq_left hs.2]

theorem replaceHeadProfile_tail (α : boundedMassProfiles) {q b : ℝ} (hq : 0 ≤ q)
    (hb0 : 0 ≤ b) (hb1 : b ≤ 1) (hbq : b ≤ α.val q) {s : ℝ} (hs : q ≤ s) :
    (replaceHeadProfile α hb0 hb1 hbq).val s = α.val s := by
  change (if s < 0 then 0 else if s < q then b else α.val s) = α.val s
  rw [ite_eq_right (not_lt.mpr (hq.trans hs)),ite_eq_right (not_lt.mpr hs)]

theorem scalarPenalty_head_difference (α : boundedMassProfiles) {q b m : ℝ}
    (hq : q ∈ Icc (0:ℝ) 1) (hb0 : 0 ≤ b) (hb1 : b ≤ 1) (hbq : b ≤ α.val q)
    (hf : ∀ s ∈ Ico (0:ℝ) q, α.val s = m) :
    scalarPenalty (replaceHeadProfile α hb0 hb1 hbq)-scalarPenalty α = (b-m)*q^2/2 := by
  let β := replaceHeadProfile α hb0 hb1 hbq
  have hαi := weightedProfile_monotone α
  have hβi := weightedProfile_monotone β
  have hh : (∫ s in (0:ℝ)..q, weightedProfile β s-weightedProfile α s) = (b-m)*q^2/2 := by
    trans ∫ s in (0:ℝ)..q, s*(b-m)
    · apply intervalIntegral.integral_congr_Ioo_of_le hq.1
      intro s hs
      change max s 0*β.val s-max s 0*α.val s = s*(b-m)
      rw [max_eq_left hs.1.le,hf s ⟨hs.1.le,hs.2⟩,
        replaceHeadProfile_head α hb0 hb1 hbq ⟨hs.1.le,hs.2⟩]
      ring
    · rw [intervalIntegral.integral_mul_const,integral_id]
      ring
  have ht : (∫ s in q..1, weightedProfile β s-weightedProfile α s) = 0 := by
    trans ∫ _s in q..1, (0:ℝ)
    · apply intervalIntegral.integral_congr_Ioo_of_le hq.2
      intro s hs
      change max s 0*β.val s-max s 0*α.val s = 0
      rw [replaceHeadProfile_tail α hq.1 hb0 hb1 hbq hs.1.le,sub_self]
    · simp
  unfold scalarPenalty
  rw [← intervalIntegral.integral_sub hβi.intervalIntegrable hαi.intervalIntegrable,
    ← intervalIntegral.integral_add_adjacent_intervals
      (hβi.intervalIntegrable.sub hαi.intervalIntegrable)
      (hβi.intervalIntegrable.sub hαi.intervalIntegrable),hh,ht,add_zero]

end SKFluctuations.Hierarchy

 

 

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set GaussianCalculus
open scoped Topology NNReal BigOperators

theorem scalarTailJet_F {T : ℝ} (hT : 0 < T) (α : boundedMassProfiles) (q : ℝ) (x : Fin 1 → ℝ) :
    (scalarTailJet hT α q).F x = scalarTerminal.nonnegativeProfileValue
      (rescaledMassProfile α hT) (T*q) (Real.toNNReal (T*(1-q))) x :=
  scalarProfileHeatJet_F _ _ _ _ _

theorem scalarTailJet_congr {T q : ℝ} (hT : 0 < T) (hq : q ≤ 1)
    {α β : boundedMassProfiles} (he : ∀ r ∈ Ioc q 1, α.val r = β.val r) :
    (scalarTailJet hT α q).F = (scalarTailJet hT β q).F := by
  funext x
  rw [scalarTailJet_F,scalarTailJet_F]
  apply scalarTerminal.nonnegativeProfileValue_congr_ae
  filter_upwards [ae_restrict_mem measurableSet_Ioc] with s hs
  change α.val (s/T) = β.val (s/T)
  apply he
  simp only [Real.coe_toNNReal _ (mul_nonneg hT.le (sub_nonneg.mpr hq))] at hs
  constructor
  · exact (lt_div_iff₀ hT).mpr (by nlinarith [hs.1])
  · exact (div_le_iff₀ hT).mpr (by nlinarith [hs.2])

noncomputable def scalarHeadValue {T : ℝ} (hT : 0 < T) (α : boundedMassProfiles)
    (q b : ℝ) : ℝ := clockContinuation b (scalarTailJet hT α q).F (T*q) 0-T*b*q^2/4

theorem scalarHeadValue_hasDerivAt {T q m : ℝ} (hT : 0 < T) (hq : 0 ≤ q)
    (α : boundedMassProfiles) (hm : 0 < m) (hm1 : m < 1) :
    HasDerivAt (scalarHeadValue hT α q)
      ((1/2:ℝ)*(∫ s in 0..T*q, (scalarTailJet hT α q).filledSquare hm (T*q) s 0)-T*q^2/4) m :=
  scalarHead_hasDerivAt hT hq α hm hm1

theorem scalarParisiValue_replace_head {T q m b : ℝ} (hT : 0 < T)
    (hq : q ∈ Ioc (0:ℝ) 1) (α : boundedMassProfiles) (hm : 0 < m) (hb : 0 < b)
    (hb1 : b ≤ 1) (hbq : b ≤ α.val q) (hf : ∀ r ∈ Ico (0:ℝ) q, α.val r = m) :
    scalarParisiValue hT (replaceHeadProfile α hb.le hb1 hbq)-scalarParisiValue hT α =
      scalarHeadValue hT α q b-scalarHeadValue hT α q m := by
  have he : (scalarTailJet hT (replaceHeadProfile α hb.le hb1 hbq) q).F =
      (scalarTailJet hT α q).F := scalarTailJet_congr hT hq.2 (fun r hr =>
        replaceHeadProfile_tail α hq.1.le hb.le hb1 hbq hr.1.le)
  rw [scalarParisiValue_constant_head hT hq α hm hf,
    scalarParisiValue_constant_head hT hq _ hb (fun r hr =>
      replaceHeadProfile_head α hb.le hb1 hbq hr),he]
  have hp := scalarPenalty_head_difference α ⟨hq.1.le,hq.2⟩ hb.le hb1 hbq hf
  unfold scalarHeadValue
  nlinarith

 
theorem scalarMinimizer_head_derivative_nonpos {T q m : ℝ} (hT : 0 < T)
    (hq : q ∈ Ioc (0:ℝ) 1) (α : boundedMassProfiles) (hα : α ∈ scalarProfiles)
    (hm : 0 < m) (hm1 : m < 1)
    (hf : ∀ r ∈ Ico (0:ℝ) q, α.val r = m)
    (hmin : ∀ β ∈ scalarProfiles, scalarParisiValue hT α ≤ scalarParisiValue hT β) :
    (1/2:ℝ)*(∫ s in 0..T*q, (scalarTailJet hT α q).filledSquare hm (T*q) s 0)-T*q^2/4 ≤ 0 := by
  have hmq : m ≤ α.val q := by
    rw [← hf 0 ⟨le_rfl,hq.1⟩]
    exact α.property.2 hq.1.le
  have hd := (hasDerivAt_iff_tendsto_slope_left_right.mp
    (scalarHeadValue_hasDerivAt hT hq.1.le α hm hm1)).1
  apply le_of_tendsto hd
  filter_upwards [self_mem_nhdsWithin,
    (show ∀ᶠ b : ℝ in 𝓝[<] m, 0 < b from
      Filter.Eventually.filter_mono nhdsWithin_le_nhds (eventually_gt_nhds hm))] with b hbm hb
  have hb1 : b ≤ 1 := hbm.le.trans hm1.le
  have hbq : b ≤ α.val q := hbm.le.trans hmq
  have hh := hmin _ (replaceHeadProfile_mem hα hq.2 hb.le hb1 hbq)
  have he := scalarParisiValue_replace_head hT hq α hm hb hb1 hbq hf
  rw [slope_def_field]
  exact div_nonpos_of_nonneg_of_nonpos (by linarith) (sub_nonpos.mpr hbm.le)

 

theorem scalarMinimizer_atomic_head_balance {T q m : ℝ} (hT : 0 < T)
    (hq : q ∈ Ioc (0:ℝ) 1) (α : boundedMassProfiles) (hα : α ∈ scalarProfiles)
    (hm : 0 < m) (hmq : m < α.val q)
    (hf : ∀ r ∈ Ico (0:ℝ) q, α.val r = m)
    (hmin : ∀ β ∈ scalarProfiles, scalarParisiValue hT α ≤ scalarParisiValue hT β) :
    2*(∫ s in 0..T*q, (scalarTailJet hT α q).filledSquare hm (T*q) s 0) = T*q^2 := by
  have hm1 : m < 1 := hmq.trans_le (α.property.1 q).2
  have hl : IsLocalMin (scalarHeadValue hT α q) m := by
    filter_upwards [Ioo_mem_nhds hm hmq] with b hb
    have hb1 : b ≤ 1 := hb.2.le.trans (α.property.1 q).2
    have hh := hmin _ (replaceHeadProfile_mem hα hq.2 hb.1.le hb1 hb.2.le)
    have he := scalarParisiValue_replace_head hT hq α hm hb.1 hb1 hb.2.le hf
    linarith
  have hz := hl.hasDerivAt_eq_zero (scalarHeadValue_hasDerivAt hT hq.1.le α hm hm1)
  linarith

end SKFluctuations.Hierarchy

 

 

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set GaussianCalculus
open scoped Topology NNReal BigOperators

 
theorem scalarTailJet_error {T q r d : ℝ} (hT : 0 < T)
    (hq : q ≤ r) (hr : r ≤ 1) (α β : boundedMassProfiles)
    (hb : ∀ s ∈ Ioo q r, |β.val s-α.val s| ≤ d)
    (he : ∀ s ∈ Ioo r 1, β.val s = α.val s) (x : Fin 1 → ℝ) :
    |(scalarTailJet hT β q).F x-(scalarTailJet hT α q).F x| ≤ T/2*d*(r-q) := by
  have hq1 : q ≤ 1 := hq.trans hr
  have hqt : 0 ≤ T*(1-q) := mul_nonneg hT.le (sub_nonneg.mpr hq1)
  have hqr : T*q ≤ T*r := mul_le_mul_of_nonneg_left hq hT.le
  have hr1 : T*r ≤ T := by nlinarith
  let f := fun s => |β.val (s/T)-α.val (s/T)|
  have hfi : ∀ a b, IntervalIntegrable f volume a b := fun _ _ =>
    (((rescaledMassProfile β hT).monotone.intervalIntegrable).sub
      ((rescaledMassProfile α hT).monotone.intervalIntegrable)).abs
  have hfirst : (∫ s in T*q..T*r, f s) ≤ T*d*(r-q) := by
    have hh := intervalIntegral.integral_mono_on_of_le_Ioo (μ:=volume) hqr (hfi _ _)
      (intervalIntegrable_const (c:=d)) (by
        intro s hs
        exact hb (s/T) ⟨(lt_div_iff₀ hT).mpr (by nlinarith [hs.1]),
          (div_lt_iff₀ hT).mpr (by nlinarith [hs.2])⟩)
    simp only [intervalIntegral.integral_const,smul_eq_mul] at hh
    nlinarith
  have hlast : (∫ s in T*r..T, f s) = 0 := by
    trans ∫ _s in T*r..T, (0:ℝ)
    · apply intervalIntegral.integral_congr_Ioo_of_le hr1
      intro s hs
      dsimp [f]
      rw [he (s/T) ⟨(lt_div_iff₀ hT).mpr (by nlinarith [hs.1]),
        (div_lt_iff₀ hT).mpr (by nlinarith [hs.2])⟩,sub_self,abs_zero]
    · simp
  have hi : (∫ s in T*q..T, f s) ≤ T*d*(r-q) := by
    rw [← intervalIntegral.integral_add_adjacent_intervals (hfi (T*q) (T*r)) (hfi (T*r) T),
      hlast,add_zero]
    exact hfirst
  have hh := scalarTerminal.nonnegativeProfileValue_L1_comparison (fun _ => 1)
    scalarTerminal_G_bound (rescaledMassProfile β hT) (rescaledMassProfile α hT)
    (T*q) (Real.toNNReal (T*(1-q))) x
  norm_num only [one_pow,Finset.sum_const,Finset.card_univ,Fintype.card_fin,
    Nat.reduceAdd,nsmul_eq_mul,Nat.cast_one,one_mul,Real.coe_toNNReal _ hqt] at hh
  have heq : T*q+T*(1-q) = T := by ring
  rw [heq] at hh
  rw [scalarTailJet_F,scalarTailJet_F]
  change |_ - _| ≤ _
  change |_ - _| ≤ (1:ℝ)/2*(∫ s in T*q..T, f s) at hh
  linarith

theorem scalarPenalty_tail_error {q r m b d : ℝ}
    (hq : 0 ≤ q) (hqr : q ≤ r) (hr : r ≤ 1) (α β : boundedMassProfiles)
    (hα : ∀ s ∈ Ico (0:ℝ) q, α.val s = m)
    (hβ : ∀ s ∈ Ico (0:ℝ) q, β.val s = b)
    (hb : ∀ s ∈ Ioo q r, |β.val s-α.val s| ≤ d)
    (he : ∀ s ∈ Ioo r 1, β.val s = α.val s) :
    |scalarPenalty β-scalarPenalty α-(b-m)*q^2/2| ≤ d*(r-q) := by
  let f := fun s => weightedProfile β s-weightedProfile α s
  have hfi : ∀ a b, IntervalIntegrable f volume a b := fun _ _ =>
    (weightedProfile_monotone β).intervalIntegrable.sub (weightedProfile_monotone α).intervalIntegrable
  have hh : (∫ s in (0:ℝ)..q, f s) = (b-m)*q^2/2 := by
    trans ∫ s in (0:ℝ)..q, s*(b-m)
    · apply intervalIntegral.integral_congr_Ioo_of_le hq
      intro s hs
      change max s 0*β.val s-max s 0*α.val s = s*(b-m)
      rw [max_eq_left hs.1.le,hα s ⟨hs.1.le,hs.2⟩,hβ s ⟨hs.1.le,hs.2⟩]
      ring
    · rw [intervalIntegral.integral_mul_const,integral_id]
      ring
  have ht : (∫ s in r..1, f s) = 0 := by
    trans ∫ _s in r..1, (0:ℝ)
    · apply intervalIntegral.integral_congr_Ioo_of_le hr
      intro s hs
      change max s 0*β.val s-max s 0*α.val s = 0
      rw [he s hs,sub_self]
    · simp
  have hm : |∫ s in q..r, f s| ≤ d*(r-q) := by
    have hm := intervalIntegral.integral_mono_on_of_le_Ioo (μ:=volume) hqr (hfi q r).abs
      (intervalIntegrable_const (c:=d)) (fun s hs => by
        change |max s 0*β.val s-max s 0*α.val s| ≤ d
        have hs0 : 0 ≤ s := hq.trans hs.1.le
        rw [← mul_sub,max_eq_left hs0,abs_mul,abs_of_nonneg hs0]
        have hd : 0 ≤ d := (abs_nonneg _).trans (hb s hs)
        calc
          s*|β.val s-α.val s| ≤ s*d := mul_le_mul_of_nonneg_left (hb s hs) hs0
          _ ≤ d := by nlinarith [hs.2.le.trans hr])
    simp only [intervalIntegral.integral_const,smul_eq_mul] at hm
    exact (intervalIntegral.abs_integral_le_integral_abs hqr).trans (by nlinarith)
  have heq : scalarPenalty β-scalarPenalty α =
      (b-m)*q^2/2+(∫ s in q..r, f s) := by
    unfold scalarPenalty
    rw [← intervalIntegral.integral_sub (weightedProfile_monotone β).intervalIntegrable
      (weightedProfile_monotone α).intervalIntegrable]
    change (∫ s in (0:ℝ)..1, f s) = _
    rw [← intervalIntegral.integral_add_adjacent_intervals (hfi 0 q) (hfi q 1),hh,
      ← intervalIntegral.integral_add_adjacent_intervals (hfi q r) (hfi r 1),ht,add_zero]
  rw [heq,add_sub_cancel_left]
  exact hm

theorem scalarParisiValue_head_error {T q r m b d : ℝ} (hT : 0 < T)
    (hq : 0 < q) (hqr : q ≤ r) (hr : r ≤ 1) (α β : boundedMassProfiles)
    (hm : 0 < m) (hb0 : 0 < b)
    (hα : ∀ s ∈ Ico (0:ℝ) q, α.val s = m)
    (hβ : ∀ s ∈ Ico (0:ℝ) q, β.val s = b)
    (hb : ∀ s ∈ Ioo q r, |β.val s-α.val s| ≤ d)
    (he : ∀ s ∈ Ioo r 1, β.val s = α.val s) :
    |scalarParisiValue hT β-scalarParisiValue hT α-
      (scalarHeadValue hT α q b-scalarHeadValue hT α q m)| ≤ T*d*(r-q) := by
  have hp := clockContinuation_abs_sub_le (scalarTailJet hT β q).lipschitz
    (scalarTailJet hT α q).lipschitz hb0 (scalarTailJet_error hT hqr hr α β hb he) (T*q) 0
  have hpen := scalarPenalty_tail_error hq.le hqr hr α β hα hβ hb he
  rw [scalarParisiValue_constant_head hT ⟨hq,hqr.trans hr⟩ β hb0 hβ,
    scalarParisiValue_constant_head hT ⟨hq,hqr.trans hr⟩ α hm hα]
  unfold scalarHeadValue
  have heq : (clockContinuation b (scalarTailJet hT β q).F (T*q) 0-T/2*scalarPenalty β-T/4)-
      (clockContinuation m (scalarTailJet hT α q).F (T*q) 0-T/2*scalarPenalty α-T/4)-
      ((clockContinuation b (scalarTailJet hT α q).F (T*q) 0-T*b*q^2/4)-
      (clockContinuation m (scalarTailJet hT α q).F (T*q) 0-T*m*q^2/4)) =
      (clockContinuation b (scalarTailJet hT β q).F (T*q) 0-
      clockContinuation b (scalarTailJet hT α q).F (T*q) 0)-
      T/2*(scalarPenalty β-scalarPenalty α-(b-m)*q^2/2) := by ring
  rw [heq]
  calc
    |_ - _| ≤ |clockContinuation b (scalarTailJet hT β q).F (T*q) 0-
        clockContinuation b (scalarTailJet hT α q).F (T*q) 0|+
        |T/2*(scalarPenalty β-scalarPenalty α-(b-m)*q^2/2)| := abs_sub _ _
    _ ≤ T/2*d*(r-q)+(T/2)*(d*(r-q)) := by
      rw [abs_mul,abs_of_nonneg (div_nonneg hT.le (by norm_num))]
      exact add_le_add hp (mul_le_mul_of_nonneg_left hpen (by positivity))
    _ = _ := by ring

end SKFluctuations.Hierarchy

 

 

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set GaussianCalculus
open scoped Topology NNReal BigOperators

noncomputable def floorMassProfile (α : boundedMassProfiles) {b : ℝ}
    (hb0 : 0 ≤ b) (hb1 : b ≤ 1) : boundedMassProfiles :=
  ⟨fun s => if s < 0 then 0 else max b (α.val s), by
    constructor
    · intro s
      change (if s < 0 then 0 else max b (α.val s)) ∈ Icc (0:ℝ) 1
      split_ifs
      · exact ⟨le_rfl,zero_le_one⟩
      · exact ⟨hb0.trans (le_max_left _ _),max_le hb1 (α.property.1 s).2⟩
    · intro s t hst
      change (if s < 0 then 0 else max b (α.val s)) ≤ (if t < 0 then 0 else max b (α.val t))
      by_cases hs : s < 0
      · rw [ite_eq_left hs]
        split_ifs
        · exact le_rfl
        · exact hb0.trans (le_max_left _ _)
      · rw [ite_eq_right hs,ite_eq_right (fun ht => hs (lt_of_le_of_lt hst ht))]
        exact max_le_max_left b (α.property.2 hst)⟩

theorem floorMassProfile_mem {α : boundedMassProfiles} (hα : α ∈ scalarProfiles)
    {b : ℝ} (hb0 : 0 ≤ b) (hb1 : b ≤ 1) : floorMassProfile α hb0 hb1 ∈ scalarProfiles := by
  constructor
  · intro s hs; exact ite_eq_left hs
  · intro s hs
    change (if s < 0 then 0 else max b (α.val s)) = 1
    rw [ite_eq_right (by linarith),hα.2 s hs,max_eq_right hb1]

theorem floorMassProfile_head (α : boundedMassProfiles) {q m b : ℝ}
    (hb0 : 0 ≤ b) (hb1 : b ≤ 1) (hmb : m ≤ b)
    (hf : ∀ r ∈ Ico (0:ℝ) q, α.val r = m) {s : ℝ} (hs : s ∈ Ico (0:ℝ) q) :
    (floorMassProfile α hb0 hb1).val s = b := by
  change (if s < 0 then 0 else max b (α.val s)) = b
  rw [ite_eq_right (not_lt.mpr hs.1),hf s hs,max_eq_left hmb]

theorem floorMassProfile_tail (α : boundedMassProfiles) {r b : ℝ}
    (hr : 0 ≤ r) (hb0 : 0 ≤ b) (hb1 : b ≤ 1) (hbr : b ≤ α.val r)
    {s : ℝ} (hs : r ≤ s) : (floorMassProfile α hb0 hb1).val s = α.val s := by
  change (if s < 0 then 0 else max b (α.val s)) = α.val s
  rw [ite_eq_right (not_lt.mpr (hr.trans hs)),max_eq_right (hbr.trans (α.property.2 hs))]

theorem floorMassProfile_bound (α : boundedMassProfiles) {m b : ℝ}
    (hb0 : 0 ≤ b) (hb1 : b ≤ 1) (hmb : m ≤ b) {s : ℝ} (hs : 0 ≤ s) (hms : m ≤ α.val s) :
    |(floorMassProfile α hb0 hb1).val s-α.val s| ≤ b-m := by
  change |(if s < 0 then 0 else max b (α.val s))-α.val s| ≤ b-m
  rw [ite_eq_right (not_lt.mpr hs),abs_of_nonneg (sub_nonneg.mpr (le_max_right _ _))]
  exact sub_le_iff_le_add.mpr (max_le (by linarith) (by linarith))

end SKFluctuations.Hierarchy

end

end OAI