lean/OAI/Probability/SKFluctuations/ClockRetainedSamples.lean

import Mathlib
import OAI.Probability.SKFluctuations.ClockSplitSteps

namespace OAI

/-! Clock Retained Samples. -/

noncomputable section


namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology NNReal BigOperators
variable {S ι : Type*} [Fintype S] [Nonempty S] [Fintype ι] [Nonempty ι]
attribute [local instance] Classical.propDecidable

 def retainedBefore (u : PositiveMass) (as : List PositiveMass) : List PositiveMass :=
  (splitMassPartition u as).1
 def retainedAfter (u : PositiveMass) (as : List PositiveMass) : List PositiveMass :=
  (splitMassPartition u as).2++[⟨1,by norm_num⟩]

 theorem retainedBefore_end (u : PositiveMass) (as : List PositiveMass) :
    partitionEnd 0 (retainedBefore u as)=u.val := splitMassPartition_end _ _ _
 theorem retainedAfter_end (u : PositiveMass) (as : List PositiveMass) :
    partitionEnd u.val (retainedAfter u as)=1 := by
  rw [retainedAfter,partitionEnd_append]
  rfl
 theorem retainedBefore_bounds (u : PositiveMass) (as : List PositiveMass) :
    ∀ a ∈ retainedBefore u as, a.val≤u.val := splitMassPartition_bounds _ _
 theorem retainedMasses_ordered (u : PositiveMass) (hu : u.val≤1)
    (as : List PositiveMass) (ha : MassOrdered 0 as) :
    MassOrdered 0 (retainedBefore u as) ∧ MassOrdered u.val (retainedAfter u as) := by
  have ho := splitMassPartition_ordered u hu as ha u.property.le
  exact ⟨ho.1,ho.2.append_end ⟨ho.2.end_bounds.1,ho.2.end_bounds.2,by norm_num,by norm_num⟩⟩
 theorem retainedMasses_mesh (u : PositiveMass) (hu : u.val≤1)
    (as : List PositiveMass) (ha : MassOrdered 0 as) {h : ℝ} (hh : 0≤h)
    (hm : PartitionMesh h 0 as) :
    PartitionMesh h 0 (retainedBefore u as++retainedAfter u as) := by
  simpa only [retainedBefore,retainedAfter,List.append_assoc] using
    (splitMassPartition_mesh u hu as ha u.property.le hm).append_one hh

 def retainedPairSample (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ)
    (q : ℝ → ι → ℝ≥0) (u : PositiveMass) (as : List PositiveMass)
    (P : S → S → ℝ) (x : ι → ℝ) : ℝ :=
  sampledPairDisorder w φ q u.val (retainedBefore u as) (retainedAfter u as) P x

 theorem retainedPairSample_comparison {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (D : ι → ℝ) (hD : ∀ i, 0≤D i)
    (hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i)
    (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (u : PositiveMass) (hu : u.val≤1) (as bs : List PositiveMass)
    (ha : MassOrdered 0 as) (hb : MassOrdered 0 bs)
    {h k : ℝ} (hh : 0≤h) (hk : 0≤k) (hmesh : PartitionMesh h 0 as) (kmesh : PartitionMesh k 0 bs)
    (P : S → S → ℝ) {K : ℝ} (hK : 0≤K) (hP : ∀ σ τ, |P σ τ|≤K) (x : ι → ℝ) :
    |retainedPairSample w φ q u as P x-retainedPairSample w φ q u bs P x| ≤
      ClockTree.errorJetVariation 2 0 0*K*(2*(h+k)*clockVariationBound D q) := by
  have h₁ := retainedMasses_ordered u hu as ha
  have h₂ := retainedMasses_ordered u hu bs hb
  exact sampledPairDisorder_mesh_comparison hw φ D hD hφ q hq u.property.le
    _ _ _ _ h₁.1 h₁.2 h₂.1 h₂.2 (retainedBefore_bounds u as) (retainedBefore_bounds u bs)
    (retainedBefore_end u as) (retainedBefore_end u bs)
    (retainedAfter_end u as) (retainedAfter_end u bs)
    (retainedMasses_mesh u hu as ha hh hmesh) (retainedMasses_mesh u hu bs hb hk kmesh) P hK hP x

 theorem retainedPairSample_cauchy {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (D : ι → ℝ) (hD : ∀ i, 0≤D i)
    (hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i)
    (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (u : PositiveMass) (hu : u.val≤1) (P : S → S → ℝ)
    {K : ℝ} (hK : 0≤K) (hP : ∀ σ τ, |P σ τ|≤K) (x : ι → ℝ) :
    CauchySeq (fun k => retainedPairSample w φ q u (uniformMasses k) P x) := by
  apply Metric.cauchySeq_iff.mpr
  intro ε hε
  let C := ClockTree.errorJetVariation 2 0 0*K*(2*clockVariationBound D q)
  have ht : Tendsto (fun n : ℕ => ((n+1:ℕ):ℝ)⁻¹*C) atTop (𝓝 0) := by
    simpa using uniformMasses_mesh_tendsto.mul_const C
  obtain ⟨N,hN⟩ := eventually_atTop.mp (ht.eventually (gt_mem_nhds (half_pos hε)))
  refine ⟨N,fun n hn m hm => ?_⟩
  rw [Real.dist_eq]
  have hb := retainedPairSample_comparison hw φ D hD hφ q hq u hu
    (uniformMasses n) (uniformMasses m) (uniformMasses_ordered n) (uniformMasses_ordered m)
    (by positivity) (by positivity) (uniformMasses_mesh n) (uniformMasses_mesh m) P hK hP x
  apply hb.trans_lt
  have he : ClockTree.errorJetVariation 2 0 0*K*
      (2*(((n+1:ℕ):ℝ)⁻¹+((m+1:ℕ):ℝ)⁻¹)*clockVariationBound D q)=
      ((n+1:ℕ):ℝ)⁻¹*C+((m+1:ℕ):ℝ)⁻¹*C := by dsimp [C]; ring
  rw [he]
  linarith [hN n hn,hN m hm]

 def pathPairDisorder (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ)
    (q : ℝ → ι → ℝ≥0) (u : PositiveMass) (P : S → S → ℝ) (x : ι → ℝ) : ℝ :=
  limUnder atTop (fun k => retainedPairSample w φ q u (uniformMasses k) P x)

 theorem retainedPairSample_tendsto {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (D : ι → ℝ) (hD : ∀ i, 0≤D i)
    (hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i)
    (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (u : PositiveMass) (hu : u.val≤1) (P : S → S → ℝ)
    {K : ℝ} (hK : 0≤K) (hP : ∀ σ τ, |P σ τ|≤K) (x : ι → ℝ) :
    Tendsto (fun k => retainedPairSample w φ q u (uniformMasses k) P x) atTop
      (𝓝 (pathPairDisorder w φ q u P x)) :=
  (retainedPairSample_cauchy hw φ D hD hφ q hq u hu P hK hP x).tendsto_limUnder

end SKFluctuations.Hierarchy

 

 

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology NNReal BigOperators
variable {ι S : Type*} [Fintype ι] [Fintype S]

 theorem partitionSample_cross_error {q r : ℝ → ℝ}
    (hq : MonotoneOn q (Icc (0:ℝ) 1)) (hr : MonotoneOn r (Icc (0:ℝ) 1))
    (as bs : List PositiveMass) (ha : MassOrdered 0 as) (hb : MassOrdered 0 bs)
    {h k : ℝ} (hm : PartitionMesh h 0 as) (hk : PartitionMesh k 0 bs) :
    (∫ u in (0:ℝ)..1, |partitionSample q 0 as u-partitionSample r 0 bs u|) ≤
      h*(q 1-q 0)+k*(r 1-r 0)+(∫ u in (0:ℝ)..1, |q u-r u|) := by
  have hiq : IntervalIntegrable q volume 0 1 :=
    (show MonotoneOn q (uIcc (0:ℝ) 1) by simpa using hq).intervalIntegrable
  have hir : IntervalIntegrable r volume 0 1 :=
    (show MonotoneOn r (uIcc (0:ℝ) 1) by simpa using hr).intervalIntegrable
  have hia := partitionSample_intervalIntegrable q 0 as 0 1
  have hib := partitionSample_intervalIntegrable r 0 bs 0 1
  calc
    _ ≤ ∫ u in (0:ℝ)..1, (|q u-partitionSample q 0 as u|+
        |r u-partitionSample r 0 bs u|+|q u-r u|) := by
      apply intervalIntegral.integral_mono_on (by norm_num) (hia.sub hib).abs
        (((hiq.sub hia).abs.add (hir.sub hib).abs).add (hiq.sub hir).abs)
      intro u hu
      have h₁ := abs_sub_le (partitionSample q 0 as u) (q u) (partitionSample r 0 bs u)
      have h₂ := abs_sub_le (q u) (r u) (partitionSample r 0 bs u)
      rw [abs_sub_comm (partitionSample q 0 as u) (q u)] at h₁
      linarith
    _ = (∫ u in (0:ℝ)..1, |q u-partitionSample q 0 as u|)+
        (∫ u in (0:ℝ)..1, |r u-partitionSample r 0 bs u|)+
        (∫ u in (0:ℝ)..1, |q u-r u|) := by
      rw [intervalIntegral.integral_add
        ((hiq.sub hia).abs.add (hir.sub hib).abs) (hiq.sub hir).abs,
        intervalIntegral.integral_add (hiq.sub hia).abs (hir.sub hib).abs]
    _ ≤ _ := by linarith [partitionSample_l1_error hq as ha hm, partitionSample_l1_error hr bs hb hk]

 def clockL1Distance (D : ι → ℝ) (q r : ℝ → ι → ℝ≥0) : ℝ :=
  (1/2:ℝ)*∑ i, (D i)^2*(∫ u in (0:ℝ)..1, |(q u i:ℝ)-(r u i:ℝ)|)

 theorem sampledDisorderPressure_cross_comparison [Nonempty S] [Nonempty ι] [DecidableEq ι]
    {w : S → ℝ} (hw : ∀ σ, 0 < w σ) (φ : S → (ι → ℝ) →L[ℝ] ℝ)
    (C D : ι → ℝ) (hC : ∀ σ i, (φ σ (Pi.single i 1))^2 = C i)
    (hD : ∀ i σ, |φ σ (Pi.single i 1)| ≤ D i)
    (q r : ℝ → ι → ℝ≥0)
    (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (hr : ∀ i, MonotoneOn (fun u => r u i) (Icc (0:ℝ) 1))
    (as bs : List PositiveMass) (ha : MassOrdered 0 as) (hb : MassOrdered 0 bs)
    {h k : ℝ} (hm : PartitionMesh h 0 as) (hk : PartitionMesh k 0 bs) (x : ι → ℝ) :
    |sampledDisorderPressure w φ C q as x-sampledDisorderPressure w φ C r bs x| ≤
      h*clockVariationBound D q+k*clockVariationBound D r+clockL1Distance D q r := by
  have ht := stepDisorderPressure_l1_comparison hw φ C D hC hD (q 0) (r 0)
    (sampleClockSteps q 0 as) (sampleClockSteps r 0 bs)
    (sampleClockSteps_ordered q as ha) (sampleClockSteps_ordered r bs hb) x
  simp_rw [sampleClockSteps_function q hq as ha,sampleClockSteps_function r hr bs hb] at ht
  apply ht.trans
  calc
    _ ≤ (1/2:ℝ)*∑ i, (D i)^2*(h*((q 1 i:ℝ)-(q 0 i:ℝ))+
        k*((r 1 i:ℝ)-(r 0 i:ℝ))+(∫ u in (0:ℝ)..1, |(q u i:ℝ)-(r u i:ℝ)|)) := by
      apply mul_le_mul_of_nonneg_left (Finset.sum_le_sum _) (by norm_num)
      intro i _
      apply mul_le_mul_of_nonneg_left _ (sq_nonneg _)
      apply partitionSample_cross_error _ _ as bs ha hb hm hk
      · intro u hu v hv huv
        exact_mod_cast (hq i) hu hv huv
      · intro u hu v hv huv
        exact_mod_cast (hr i) hu hv huv
    _ = _ := by
      unfold clockVariationBound clockL1Distance
      simp only [Finset.mul_sum,← Finset.sum_add_distrib]
      apply Finset.sum_congr rfl
      intro i _
      ring

 theorem pathDisorderPressure_l1_comparison [Nonempty S] [Nonempty ι] [DecidableEq ι]
    {w : S → ℝ} (hw : ∀ σ, 0 < w σ) (φ : S → (ι → ℝ) →L[ℝ] ℝ)
    (C D : ι → ℝ) (hC : ∀ σ i, (φ σ (Pi.single i 1))^2 = C i)
    (hD : ∀ i σ, |φ σ (Pi.single i 1)| ≤ D i)
    (q r : ℝ → ι → ℝ≥0)
    (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (hr : ∀ i, MonotoneOn (fun u => r u i) (Icc (0:ℝ) 1)) (x : ι → ℝ) :
    |pathDisorderPressure w φ C q x-pathDisorderPressure w φ C r x| ≤ clockL1Distance D q r := by
  have ht := ((sampledDisorderPressure_tendsto hw φ C D hC hD q hq x).sub
    (sampledDisorderPressure_tendsto hw φ C D hC hD r hr x)).abs
  have hu : Tendsto (fun n : ℕ => ((n+1:ℕ):ℝ)⁻¹*clockVariationBound D q+
      ((n+1:ℕ):ℝ)⁻¹*clockVariationBound D r+clockL1Distance D q r)
      atTop (𝓝 (clockL1Distance D q r)) := by
    simpa using ((uniformMasses_mesh_tendsto.mul_const (clockVariationBound D q)).add
      (uniformMasses_mesh_tendsto.mul_const (clockVariationBound D r))).add_const (clockL1Distance D q r)
  exact le_of_tendsto_of_tendsto ht hu (Eventually.of_forall fun n =>
    sampledDisorderPressure_cross_comparison hw φ C D hC hD q r hq hr
      (uniformMasses n) (uniformMasses n) (uniformMasses_ordered n) (uniformMasses_ordered n)
      (uniformMasses_mesh n) (uniformMasses_mesh n) x)

end SKFluctuations.Hierarchy

 

 

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology NNReal BigOperators
variable {ι S : Type*} [Fintype ι] [Fintype S]

 omit [Fintype ι] in
 theorem stepClockFunction_intervalIntegrable (q₀ : ι → ℝ) {L : List (GaussianStep ι)}
    {a : ℝ} (ho : OrderedSteps a L) (i : ι) (c d : ℝ) :
    IntervalIntegrable (fun u => stepClockFunction q₀ L u i) volume c d := by
  simp_rw [stepClockFunction_eq q₀ ho]
  exact massStepFunction_intervalIntegrable _ _ _ _

 theorem partitionSample_compare_integral {f q : ℝ → ℝ}
    (hf : IntervalIntegrable f volume 0 1) (hq : MonotoneOn q (Icc (0:ℝ) 1))
    (as : List PositiveMass) (ha : MassOrdered 0 as) {h : ℝ} (hm : PartitionMesh h 0 as) :
    (∫ u in (0:ℝ)..1, |f u-partitionSample q 0 as u|) ≤
      (∫ u in (0:ℝ)..1, |f u-q u|)+h*(q 1-q 0) := by
  have hiq : IntervalIntegrable q volume 0 1 :=
    (show MonotoneOn q (uIcc (0:ℝ) 1) by simpa using hq).intervalIntegrable
  have hia := partitionSample_intervalIntegrable q 0 as 0 1
  calc
    _ ≤ ∫ u in (0:ℝ)..1, (|f u-q u|+|q u-partitionSample q 0 as u|) :=
      intervalIntegral.integral_mono_on (by norm_num) (hf.sub hia).abs
        ((hf.sub hiq).abs.add (hiq.sub hia).abs) (fun u _ => abs_sub_le _ _ _)
    _ = (∫ u in (0:ℝ)..1, |f u-q u|)+(∫ u in (0:ℝ)..1, |q u-partitionSample q 0 as u|) :=
      intervalIntegral.integral_add (hf.sub hiq).abs (hiq.sub hia).abs
    _ ≤ _ := by linarith [partitionSample_l1_error hq as ha hm]

 def stepPathClockDistance (D : ι → ℝ) (q₀ : ι → ℝ≥0) (L : List (GaussianStep ι))
    (q : ℝ → ι → ℝ≥0) : ℝ :=
  (1/2:ℝ)*∑ i, (D i)^2*(∫ u in (0:ℝ)..1, |stepClockFunction (fun i => (q₀ i:ℝ)) L u i-(q u i:ℝ)|)

 theorem stepDisorderPressure_path_comparison [Nonempty S] [Nonempty ι] [DecidableEq ι]
    {w : S → ℝ} (hw : ∀ σ, 0 < w σ) (φ : S → (ι → ℝ) →L[ℝ] ℝ)
    (C D : ι → ℝ) (hC : ∀ σ i, (φ σ (Pi.single i 1))^2 = C i)
    (hD : ∀ i σ, |φ σ (Pi.single i 1)| ≤ D i)
    (q₀ : ι → ℝ≥0) (L : List (GaussianStep ι)) (ho : OrderedSteps 0 L)
    (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (x : ι → ℝ) :
    |stepDisorderPressure w φ C q₀ L x-pathDisorderPressure w φ C q x| ≤
      stepPathClockDistance D q₀ L q := by
  have hb (n : ℕ) : |stepDisorderPressure w φ C q₀ L x-
      sampledDisorderPressure w φ C q (uniformMasses n) x| ≤
      stepPathClockDistance D q₀ L q+((n+1:ℕ):ℝ)⁻¹*clockVariationBound D q := by
    have ht := stepDisorderPressure_l1_comparison hw φ C D hC hD q₀ (q 0) L
      (sampleClockSteps q 0 (uniformMasses n)) ho
      (sampleClockSteps_ordered q _ (uniformMasses_ordered n)) x
    simp_rw [sampleClockSteps_function q hq _ (uniformMasses_ordered n)] at ht
    apply ht.trans
    calc
      _ ≤ (1/2:ℝ)*∑ i, (D i)^2*((∫ u in (0:ℝ)..1,
            |stepClockFunction (fun i => (q₀ i:ℝ)) L u i-(q u i:ℝ)|)+
          ((n+1:ℕ):ℝ)⁻¹*((q 1 i:ℝ)-(q 0 i:ℝ))) := by
        apply mul_le_mul_of_nonneg_left (Finset.sum_le_sum _) (by norm_num)
        intro i _
        apply mul_le_mul_of_nonneg_left _ (sq_nonneg _)
        apply partitionSample_compare_integral
          (stepClockFunction_intervalIntegrable _ ho i 0 1) _ _ (uniformMasses_ordered n) (uniformMasses_mesh n)
        intro u hu v hv huv
        exact_mod_cast (hq i) hu hv huv
      _ = _ := by
        unfold stepPathClockDistance clockVariationBound
        simp only [Finset.mul_sum,← Finset.sum_add_distrib]
        apply Finset.sum_congr rfl
        intro i _
        ring
  have hl := ((tendsto_const_nhds (x := stepDisorderPressure w φ C q₀ L x)).sub
    (sampledDisorderPressure_tendsto hw φ C D hC hD q hq x)).abs
  have hr : Tendsto (fun n : ℕ => stepPathClockDistance D q₀ L q+
      ((n+1:ℕ):ℝ)⁻¹*clockVariationBound D q) atTop (𝓝 (stepPathClockDistance D q₀ L q)) := by
    simpa using tendsto_const_nhds.add (uniformMasses_mesh_tendsto.mul_const (clockVariationBound D q))
  exact le_of_tendsto_of_tendsto hl hr (Eventually.of_forall hb)

 theorem stepDisorderPressure_tendsto_path [Nonempty S] [Nonempty ι] [DecidableEq ι]
    {w : S → ℝ} (hw : ∀ σ, 0 < w σ) (φ : S → (ι → ℝ) →L[ℝ] ℝ)
    (C D : ι → ℝ) (hC : ∀ σ i, (φ σ (Pi.single i 1))^2 = C i)
    (hD : ∀ i σ, |φ σ (Pi.single i 1)| ≤ D i)
    (q₀ : ℕ → ι → ℝ≥0) (L : ℕ → List (GaussianStep ι)) (ho : ∀ n, OrderedSteps 0 (L n))
    (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (hL : Tendsto (fun n => stepPathClockDistance D (q₀ n) (L n) q) atTop (𝓝 0)) (x : ι → ℝ) :
    Tendsto (fun n => stepDisorderPressure w φ C (q₀ n) (L n) x) atTop
      (𝓝 (pathDisorderPressure w φ C q x)) := by
  rw [tendsto_iff_norm_sub_tendsto_zero]
  simp only [Real.norm_eq_abs]
  exact squeeze_zero (fun _ => abs_nonneg _) (fun n =>
    stepDisorderPressure_path_comparison hw φ C D hC hD (q₀ n) (L n) (ho n) q hq x) hL

end SKFluctuations.Hierarchy

 

 

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology NNReal BigOperators
variable {ι : Type*} [Fintype ι]

 theorem clockCoordinateDistance_integral (D : ι → ℝ) (f g : ℝ → ι → ℝ)
    (hf : ∀ i, IntervalIntegrable (fun u => f u i) volume 0 1)
    (hg : ∀ i, IntervalIntegrable (fun u => g u i) volume 0 1) :
    (∫ u in (0:ℝ)..1, clockCoordinateDistance D (f u) (g u))=
      ∑ i, (∫ u in (0:ℝ)..1, |f u i-g u i|)*(D i)^2 := by
  unfold clockCoordinateDistance
  rw [intervalIntegral.integral_finsetSum]
  · simp_rw [intervalIntegral.integral_mul_const]
  · exact fun i _ => ((hf i).sub (hg i)).abs.mul_const _

 theorem stepClock_sample_distance (D : ι → ℝ) (q₀ : ι → ℝ≥0)
    (L : List (GaussianStep ι)) (hL : OrderedSteps 0 L)
    (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (as : List PositiveMass) (ha : MassOrdered 0 as) {h : ℝ} (hm : PartitionMesh h 0 as) :
    (∫ u in (0:ℝ)..1, clockCoordinateDistance D
      (stepClockFunction (fun i => (q₀ i:ℝ)) L u)
      (fun i => partitionSample (fun u => (q u i:ℝ)) 0 as u)) ≤
      2*stepPathClockDistance D q₀ L q+2*h*clockVariationBound D q := by
  rw [clockCoordinateDistance_integral D _ _
    (fun i => stepClockFunction_intervalIntegrable _ hL i 0 1)
    (fun i => partitionSample_intervalIntegrable _ _ _ _ _)]
  calc
    _ ≤ ∑ i, ((∫ u in (0:ℝ)..1, |stepClockFunction (fun i => (q₀ i:ℝ)) L u i-(q u i:ℝ)|)+
        h*((q 1 i:ℝ)-(q 0 i:ℝ)))*(D i)^2 := by
      apply Finset.sum_le_sum
      intro i _
      apply mul_le_mul_of_nonneg_right _ (sq_nonneg _)
      apply partitionSample_compare_integral (stepClockFunction_intervalIntegrable _ hL i 0 1)
        _ as ha hm
      intro u hu v hv huv
      exact_mod_cast (hq i) hu hv huv
    _ = _ := by
      unfold stepPathClockDistance clockVariationBound
      simp only [Finset.mul_sum,←Finset.sum_add_distrib]
      apply Finset.sum_congr rfl
      intro i _
      ring

 def stepPathPairDistance (D : ι → ℝ) (q₀ : ι → ℝ≥0) (A B : List (GaussianStep ι))
    (q : ℝ → ι → ℝ≥0) (u : ℝ) : ℝ :=
    clockCoordinateDistance D (stepClockValues (fun i => (q₀ i:ℝ)) A A.length) (fun i => (q u i:ℝ))+
      2*stepPathClockDistance D q₀ (A++B) q+
    clockCoordinateDistance D (stepClockValues (fun i => (q₀ i:ℝ)) (A++B) (A++B).length)
      (fun i => (q 1 i:ℝ))

end SKFluctuations.Hierarchy

 

 

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology NNReal BigOperators
variable {S ι : Type*} [Fintype S] [Nonempty S] [Fintype ι] [Nonempty ι]
attribute [local instance] Classical.propDecidable

 theorem stepPairDisorder_sample_comparison {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (D : ι → ℝ) (hD : ∀ i, 0≤D i)
    (hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i)
    (q₀ : ι → ℝ≥0) (A B : List (GaussianStep ι)) {u : ℝ}
    (hu : 0≤u) (hA : OrderedSteps 0 A) (hB : OrderedSteps u B) (hAu : ∀ s ∈ A, s.1≤u)
    (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (as bs : List PositiveMass) (ha : MassOrdered 0 as) (hb : MassOrdered u bs)
    (hau : ∀ a ∈ as, a.val≤u) (heA : partitionEnd 0 as=u) (hetB : partitionEnd u bs=1)
    {h : ℝ} (hmesh : PartitionMesh h 0 (as++bs))
    (P : S → S → ℝ) {K : ℝ} (hK : 0≤K) (hP : ∀ σ τ, |P σ τ|≤K) (x : ι → ℝ) :
    |stepPairDisorder w φ q₀ A B P x-sampledPairDisorder w φ q u as bs P x| ≤
      ClockTree.errorJetVariation 2 0 0*K*
        (stepPathPairDistance D q₀ A B q u+2*h*clockVariationBound D q) := by
  have hoa : MassOrdered 0 (as++bs) := ha.append_end (heA.symm ▸ hb)
  have ht := stepPairDisorder_l1_comparison hw φ D hD hφ q₀ (q 0)
    A B (sampleClockSteps q 0 as) (sampleClockSteps q u bs) hu hA hB
    (sampleClockSteps_ordered q as ha) (sampleClockSteps_ordered q bs hb)
    hAu (sampleClockSteps_mass_le q 0 as hau) P hK hP x
  rw [sampleClockSteps_terminal q hq 0 as ha,heA] at ht
  have hAB : sampleClockSteps q 0 as++sampleClockSteps q u bs=sampleClockSteps q 0 (as++bs) := by
    rw [sampleClockSteps_append,heA]
  rw [hAB,sampleClockSteps_terminal q hq 0 (as++bs) hoa,
    partitionEnd_append,heA,hetB] at ht
  have hfun : stepClockFunction (fun i => (q 0 i:ℝ)) (sampleClockSteps q 0 (as++bs)) =
      fun u i => partitionSample (fun v => (q v i:ℝ)) 0 (as++bs) u := by
    funext u i
    exact sampleClockSteps_function q hq _ hoa u i
  rw [hfun] at ht
  apply ht.trans
  apply mul_le_mul_of_nonneg_left _ (mul_nonneg (ClockTree.errorJetVariation_nonneg 2 0 0) hK)
  have hh := stepClock_sample_distance D q₀ (A++B) (hA.append_bound hu hAu hB) q hq (as++bs) hoa hmesh
  dsimp only [stepPathPairDistance]
  linarith

 theorem stepPairDisorder_path_comparison {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (D : ι → ℝ) (hD : ∀ i, 0≤D i)
    (hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i)
    (q₀ : ι → ℝ≥0) (A B : List (GaussianStep ι)) (u : PositiveMass) (hu : u.val≤1)
    (hA : OrderedSteps 0 A) (hB : OrderedSteps u.val B) (hAu : ∀ s ∈ A, s.1≤u.val)
    (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (P : S → S → ℝ) {K : ℝ} (hK : 0≤K) (hP : ∀ σ τ, |P σ τ|≤K) (x : ι → ℝ) :
    |stepPairDisorder w φ q₀ A B P x-pathPairDisorder w φ q u P x| ≤
      ClockTree.errorJetVariation 2 0 0*K*stepPathPairDistance D q₀ A B q u.val := by
  have hb (n : ℕ) : |stepPairDisorder w φ q₀ A B P x-
      retainedPairSample w φ q u (uniformMasses n) P x| ≤
      ClockTree.errorJetVariation 2 0 0*K*
        (stepPathPairDistance D q₀ A B q u.val+2*((n+1:ℕ):ℝ)⁻¹*clockVariationBound D q) := by
    have ho := retainedMasses_ordered u hu (uniformMasses n) (uniformMasses_ordered n)
    exact stepPairDisorder_sample_comparison hw φ D hD hφ q₀ A B u.property.le hA hB hAu
      q hq _ _ ho.1 ho.2 (retainedBefore_bounds u _) (retainedBefore_end u _) (retainedAfter_end u _)
      (retainedMasses_mesh u hu _ (uniformMasses_ordered n) (by positivity) (uniformMasses_mesh n)) P hK hP x
  have hl := ((tendsto_const_nhds (x := stepPairDisorder w φ q₀ A B P x)).sub (retainedPairSample_tendsto hw φ D hD hφ q hq u hu P hK hP x)).abs
  have hr : Tendsto (fun n : ℕ => ClockTree.errorJetVariation 2 0 0*K*
      (stepPathPairDistance D q₀ A B q u.val+2*((n+1:ℕ):ℝ)⁻¹*clockVariationBound D q)) atTop
      (𝓝 (ClockTree.errorJetVariation 2 0 0*K*stepPathPairDistance D q₀ A B q u.val)) := by
    simpa using (tendsto_const_nhds.add ((uniformMasses_mesh_tendsto.const_mul 2).mul_const
      (clockVariationBound D q))).const_mul (ClockTree.errorJetVariation 2 0 0*K)
  exact le_of_tendsto_of_tendsto hl hr (Eventually.of_forall hb)

 theorem stepPairDisorder_tendsto_path {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (D : ι → ℝ) (hD : ∀ i, 0≤D i)
    (hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i)
    (q₀ : ℕ → ι → ℝ≥0) (A B : ℕ → List (GaussianStep ι)) (u : PositiveMass) (hu : u.val≤1)
    (hA : ∀ n, OrderedSteps 0 (A n)) (hB : ∀ n, OrderedSteps u.val (B n))
    (hAu : ∀ n s, s ∈ A n → s.1≤u.val)
    (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (hpath : Tendsto (fun n => stepPathPairDistance D (q₀ n) (A n) (B n) q u.val) atTop (𝓝 0))
    (P : S → S → ℝ) {K : ℝ} (hK : 0≤K) (hP : ∀ σ τ, |P σ τ|≤K) (x : ι → ℝ) :
    Tendsto (fun n => stepPairDisorder w φ (q₀ n) (A n) (B n) P x) atTop
      (𝓝 (pathPairDisorder w φ q u P x)) := by
  rw [tendsto_iff_norm_sub_tendsto_zero]
  simp only [Real.norm_eq_abs]
  apply squeeze_zero (fun _ => abs_nonneg _) (fun n =>
    stepPairDisorder_path_comparison hw φ D hD hφ (q₀ n) (A n) (B n) u hu (hA n) (hB n) (hAu n) q hq P hK hP x)
  simpa using hpath.const_mul (ClockTree.errorJetVariation 2 0 0*K)

end SKFluctuations.Hierarchy

 

 

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

 theorem partitionSample_comp (q : ℝ → ℝ) (a : ℝ) (as : List PositiveMass) (u : ℝ) :
    partitionSample q a as u=q (partitionSample id a as u) := by
  induction as generalizing a with
  | nil => rfl
  | cons b bs ih =>
    simp only [partitionSample_cons]
    split_ifs <;> simp_all

 theorem partitionSample_id_bounds {h a u : ℝ} (as : List PositiveMass)
    (ho : MassOrdered a as) (hm : PartitionMesh h a as) (hu : u ∈ Icc a 1) :
    a ≤ partitionSample id a as u ∧ partitionSample id a as u ≤ u ∧
      u-partitionSample id a as u ≤ h := by
  induction as generalizing a with
  | nil =>
    change 1-a≤h at hm
    simpa only [partitionSample_nil,id_eq] using
      (show a≤a ∧ a≤u ∧ u-a≤h from ⟨le_rfl,hu.1,by linarith [hu.2]⟩)
  | cons b bs ih =>
    rw [partitionSample_cons]
    split_ifs with hb
    · exact ⟨le_rfl,hu.1,by dsimp; linarith [hm.1]⟩
    · obtain ⟨h₁,h₂,h₃⟩ := ih ho.2.2 hm.2 ⟨le_of_not_gt hb,hu.2⟩
      exact ⟨ho.2.1.trans h₁,h₂,h₃⟩

 theorem partitionSample_tendsto {q : ℝ → ℝ} {a u : ℝ}
    (as : ℕ → List PositiveMass) (h : ℕ → ℝ)
    (ho : ∀ n, MassOrdered a (as n)) (hm : ∀ n, PartitionMesh (h n) a (as n))
    (hh : Tendsto h atTop (𝓝 0)) (hu : u ∈ Icc a 1)
    (hc : ContinuousWithinAt q (Icc a 1) u) :
    Tendsto (fun n => partitionSample q a (as n) u) atTop (𝓝 (q u)) := by
  have ht : Tendsto (fun n => partitionSample id a (as n) u) atTop (𝓝 u) := by
    rw [tendsto_iff_norm_sub_tendsto_zero]
    simp only [Real.norm_eq_abs]
    apply squeeze_zero (fun _ => abs_nonneg _) _ hh
    intro n
    have hb := partitionSample_id_bounds (as n) (ho n) (hm n) hu
    rw [abs_of_nonpos (sub_nonpos.mpr hb.2.1)]
    linarith [hb.2.2]
  have hw : Tendsto (fun n => partitionSample id a (as n) u) atTop (𝓝[Icc a 1] u) :=
    tendsto_nhdsWithin_iff.mpr ⟨ht,Eventually.of_forall fun n =>
      let hb := partitionSample_id_bounds (as n) (ho n) (hm n) hu
      ⟨hb.1,hb.2.1.trans hu.2⟩⟩
  have he : (fun n => partitionSample q a (as n) u) =
      (fun n => q (partitionSample id a (as n) u)) := funext (fun n => partitionSample_comp q a (as n) u)
  rw [he]
  exact hc.tendsto.comp hw

 theorem uniformSample_tendsto {q : ℝ → ℝ} {u : ℝ} (hu : u ∈ Icc (0:ℝ) 1)
    (hc : ContinuousWithinAt q (Icc (0:ℝ) 1) u) :
    Tendsto (fun n => partitionSample q 0 (uniformMasses n) u) atTop (𝓝 (q u)) :=
  partitionSample_tendsto _ _ uniformMasses_ordered uniformMasses_mesh
    uniformMasses_mesh_tendsto hu hc

end SKFluctuations.Hierarchy

 

 

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology NNReal BigOperators
variable {S ι : Type*} [Fintype S] [Nonempty S] [Fintype ι] [Nonempty ι]
attribute [local instance] Classical.propDecidable

 def pathPairMoment (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ)
    (q : ℝ → ι → ℝ≥0) (P : S → S → ℝ) (u : ℝ) : ℝ :=
  if h : 0<u then pathPairDisorder w φ q ⟨u,h⟩ P 0 else 0

 theorem stepPairMoment_path_comparison {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (D : ι → ℝ) (hD : ∀ i, 0≤D i)
    (hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i)
    (q₀ : ι → ℝ≥0) (L : List (GaussianStep ι)) (hL : OrderedSteps 0 L)
    (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (P : S → S → ℝ) {K : ℝ} (hK : 0≤K) (hP : ∀ σ τ, |P σ τ|≤K)
    {u : ℝ} (hu : u ∈ Ioc (0:ℝ) 1) :
    |stepPairMoment w φ q₀ L hL.mem_pos P u-pathPairMoment w φ q P u| ≤
      ClockTree.errorJetVariation 2 0 0*K*(
        clockCoordinateDistance D (stepClockFunction (fun i => (q₀ i:ℝ)) L u)
          (fun i => (q u i:ℝ))+2*stepPathClockDistance D q₀ L q+
        clockCoordinateDistance D (stepClockValues (fun i => (q₀ i:ℝ)) L L.length)
          (fun i => (q 1 i:ℝ))) := by
  have ho := splitClockSteps_ordered u ⟨hu.1.le,hu.2⟩ L hL hu.1.le
  rw [stepPairMoment_eq_split hw φ q₀ L hL, pathPairMoment,dite_eq_left hu.1]
  have hb := stepPairDisorder_path_comparison hw φ D hD hφ q₀
    (splitClockSteps u L).1 (splitClockSteps u L).2 ⟨u,hu.1⟩ hu.2
    ho.1 ho.2.1 ho.2.2 q hq P hK hP 0
  simpa only [stepPathPairDistance,splitClockSteps_append,←stepClockFunction_split _ _ _ hL] using hb

 omit [Nonempty ι] in
 theorem sample_stepPathClockDistance_le (D : ι → ℝ) (q : ℝ → ι → ℝ≥0)
    (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (as : List PositiveMass) (ha : MassOrdered 0 as) {h : ℝ} (hm : PartitionMesh h 0 as) :
    stepPathClockDistance D (q 0) (sampleClockSteps q 0 as) q≤h*clockVariationBound D q := by
  unfold stepPathClockDistance clockVariationBound
  simp_rw [sampleClockSteps_function q hq as ha]
  calc
    _ ≤ (1/2:ℝ)*∑ i, (D i)^2*(h*((q 1 i:ℝ)-(q 0 i:ℝ))) := by
      apply mul_le_mul_of_nonneg_left (Finset.sum_le_sum _) (by norm_num)
      intro i _
      apply mul_le_mul_of_nonneg_left _ (sq_nonneg _)
      simp_rw [abs_sub_comm (partitionSample _ _ _ _)]
      exact partitionSample_l1_error (fun u hu v hv huv => by exact_mod_cast hq i hu hv huv) as ha hm
    _ = _ := by simp only [Finset.mul_sum]; apply Finset.sum_congr rfl; intro i _; ring

 omit [Nonempty ι] in
 theorem stepPathClockDistance_nonneg (D : ι → ℝ) (q₀ : ι → ℝ≥0)
    (L : List (GaussianStep ι)) (q : ℝ → ι → ℝ≥0) :
    0 ≤ stepPathClockDistance D q₀ L q := by
  unfold stepPathClockDistance
  exact mul_nonneg (by norm_num) (Finset.sum_nonneg (fun i _ =>
    mul_nonneg (sq_nonneg _) (intervalIntegral.integral_nonneg (by norm_num) (fun _ _ => abs_nonneg _))))

 theorem uniformMassTail_end {h : ℝ} (hh : 0<h) (k n : ℕ) :
    partitionEnd ((k:ℝ)*h) (uniformMassTail h hh k n)=(k+n:ℕ)*h := by
  induction n generalizing k with
  | zero => simp [uniformMassTail,partitionEnd]
  | succ n ih =>
    simp only [uniformMassTail,partitionEnd]
    simpa only [Nat.add_assoc, Nat.add_comm 1 n] using ih (k+1)

 theorem uniformMasses_end (n : ℕ) : partitionEnd 0 (uniformMasses n)=1 := by
  have he := uniformMassTail_end (show 0<((n+1:ℕ):ℝ)⁻¹ by positivity) 0 (n+1)
  simpa [uniformMasses, mul_inv_cancel₀ (show ((n:ℝ)+1)≠0 by positivity)] using he

 theorem sampledPairMoment_tendsto {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (D : ι → ℝ) (hD : ∀ i, 0≤D i)
    (hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i)
    (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (P : S → S → ℝ) {K : ℝ} (hK : 0≤K) (hP : ∀ σ τ, |P σ τ|≤K)
    {u : ℝ} (hu : u ∈ Ioc (0:ℝ) 1)
    (hc : ∀ i, ContinuousWithinAt (fun v => (q v i:ℝ)) (Icc (0:ℝ) 1) u) :
    Tendsto (fun n => stepPairMoment w φ (q 0) (sampleClockSteps q 0 (uniformMasses n))
      (sampleClockSteps_ordered q _ (uniformMasses_ordered n)).mem_pos P u)
      atTop (𝓝 (pathPairMoment w φ q P u)) := by
  have ht : Tendsto (fun n => clockCoordinateDistance D
      (stepClockFunction (fun i => (q 0 i:ℝ)) (sampleClockSteps q 0 (uniformMasses n)) u)
      (fun i => (q u i:ℝ))) atTop (𝓝 0) := by
    unfold clockCoordinateDistance
    simp_rw [sampleClockSteps_function q hq _ (uniformMasses_ordered _)]
    have hh := tendsto_finsetSum Finset.univ (fun i _ =>
      ((uniformSample_tendsto ⟨hu.1.le,hu.2⟩ (hc i)).sub_const (q u i:ℝ)).abs.mul_const ((D i)^2))
    simpa using hh
  have hl : Tendsto (fun n => stepPathClockDistance D (q 0)
      (sampleClockSteps q 0 (uniformMasses n)) q) atTop (𝓝 0) :=
    squeeze_zero (fun _ => stepPathClockDistance_nonneg _ _ _ _) (fun n =>
      sample_stepPathClockDistance_le D q hq _ (uniformMasses_ordered n) (uniformMasses_mesh n))
      (by simpa using uniformMasses_mesh_tendsto.mul_const (clockVariationBound D q))
  rw [tendsto_iff_norm_sub_tendsto_zero]
  simp only [Real.norm_eq_abs]
  apply squeeze_zero (fun _ => abs_nonneg _) (fun n => stepPairMoment_path_comparison hw φ D hD hφ
    (q 0) _ (sampleClockSteps_ordered q _ (uniformMasses_ordered n)) q hq P hK hP hu)
  simp_rw [sampleClockSteps_terminal q hq _ _ (uniformMasses_ordered _),uniformMasses_end]
  simpa [clockCoordinateDistance] using (ht.add (hl.const_mul 2)).const_mul (ClockTree.errorJetVariation 2 0 0*K)

end SKFluctuations.Hierarchy

 

 

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology NNReal BigOperators
variable {S ι : Type*} [Fintype S] [Nonempty S] [Fintype ι] [Nonempty ι]
attribute [local instance] Classical.propDecidable

 omit [Nonempty ι] in
 theorem ClockTree.disorderExpect_bound {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) {as : List PositiveMass} (T : ClockTree S as)
    {a : ℝ} (ha : MassOrdered a as) (v : ι → ℝ) (q : ℕ → ι → ℝ)
    (P : T.Assignment → ℝ) {K : ℝ} (hP : ∀ σ, |P σ|≤K) (x : ι → ℝ) :
    |T.disorderExpect w φ v q P x|≤K := by
  rw [T.disorderExpect_integral hw φ ha]
  have hb (y : ι → ℝ) : |T.expect w φ (cumulativeIncrements (q 0) (fun j => q (j+1))) P (x+y)|≤K := by
    rw [T.expect_realize]
    exact (T.realize _).expect_abs_le hw φ (clockSteps_ordered ha _) (fun σ => hP _) _
  have hi := norm_integral_le_of_norm_le_const (f := fun y =>
    T.expect w φ (cumulativeIncrements (q 0) (fun j => q (j+1))) P (x+y))
    (μ := Measure.pi fun i => gaussianReal 0 (q 0 i-v i).toNNReal)
    (Eventually.of_forall (fun y => by simpa only [Real.norm_eq_abs] using hb y))
  simpa only [zeroContinuation,Real.norm_eq_abs,probReal_univ,mul_one] using hi

 omit [Nonempty ι] in
 theorem cumulativePair_bound {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (as : List PositiveMass) (ha : MassOrdered 0 as)
    (q : ℕ → ι → ℝ) (j : ℕ) (P : S → S → ℝ) {K : ℝ} (hP : ∀ σ τ, |P σ τ|≤K) :
    |cumulativePair w φ as q j P|≤K :=
  ClockTree.disorderExpect_bound hw φ _ ha _ _ _ (fun _ => hP _ _) _

 theorem stepPairMoment_bound {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (q₀ : ι → ℝ≥0)
    (L : List (GaussianStep ι)) (hL : OrderedSteps 0 L) (P : S → S → ℝ)
    {K : ℝ} (hP : ∀ σ τ, |P σ τ|≤K) (u : ℝ) :
    |stepPairMoment w φ q₀ L hL.mem_pos P u|≤K := by
  unfold stepPairMoment
  rw [massStepFunction_split_index]
  exact cumulativePair_bound hw φ _ (positiveStepMasses_ordered hL _) _ _ P hP

 omit [Nonempty ι] in
 theorem stepPairDisorder_bound {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (q₀ : ι → ℝ≥0)
    (A B : List (GaussianStep ι)) (ho : OrderedSteps 0 (A++B)) (P : S → S → ℝ)
    {K : ℝ} (hP : ∀ σ τ, |P σ τ|≤K) (x : ι → ℝ) :
    |stepPairDisorder w φ q₀ A B P x|≤K := by
  have hA : ∀ s ∈ A, 0<s.1 := fun s hs => ho.mem_pos s (List.mem_append_left _ hs)
  have hB : ∀ s ∈ B, 0<s.1 := fun s hs => ho.mem_pos s (List.mem_append_right _ hs)
  have hc := congr_fun (ClockTree.pairDisorder_coordinates hw φ A B hA hB ho q₀ P) x
  rw [←hc]
  apply ClockTree.disorderExpect_bound hw φ
  · rw [←positiveStepMasses_append]
    exact positiveStepMasses_ordered ho _
  · exact fun σ => hP _ _

 theorem pathPairMoment_bound {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (D : ι → ℝ) (hD : ∀ i, 0≤D i)
    (hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i)
    (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (P : S → S → ℝ) {K : ℝ} (hK : 0≤K) (hP : ∀ σ τ, |P σ τ|≤K)
    {u : ℝ} (hu : u ∈ Ioc (0:ℝ) 1) : |pathPairMoment w φ q P u|≤K := by
  rw [pathPairMoment,dite_eq_left hu.1]
  apply le_of_tendsto ((retainedPairSample_tendsto hw φ D hD hφ q hq ⟨u,hu.1⟩ hu.2 P hK hP 0).abs)
  apply Eventually.of_forall
  intro n
  change |stepPairDisorder w φ (q 0)
    (sampleClockSteps q 0 (retainedBefore ⟨u,hu.1⟩ (uniformMasses n)))
    (sampleClockSteps q u (retainedAfter ⟨u,hu.1⟩ (uniformMasses n))) P 0|≤K
  have ho := retainedMasses_ordered (⟨u,hu.1⟩ : PositiveMass) hu.2 (uniformMasses n) (uniformMasses_ordered n)
  apply stepPairDisorder_bound hw φ _ _ _ _ P hP
  exact (sampleClockSteps_ordered q _ ho.1).append_bound hu.1.le
    (sampleClockSteps_mass_le q _ _ (retainedBefore_bounds ⟨u,hu.1⟩ _))
    (sampleClockSteps_ordered q _ ho.2)

end SKFluctuations.Hierarchy

end

end OAI