lean/OAI/Probability/SKFluctuations/ClockRetainTwo.lean

import Mathlib
import OAI.Probability.SKFluctuations.ComparisonCapTravel
import OAI.Probability.SKFluctuations.InverseConstraintNonempty

namespace OAI

/-! Clock Retain Two. -/

noncomputable section


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

 theorem MassOrdered.le_of_mem {a : ℝ} {as : List PositiveMass}
    (ha : MassOrdered a as) {b : PositiveMass} (hb : b ∈ as) : a≤b.val := by
  induction as generalizing a with
  | nil => simp at hb
  | cons c cs ih =>
    rcases List.mem_cons.mp hb with rfl|hb
    · exact ha.2.1
    · exact ha.2.1.trans (ih ha.2.2 hb)

 theorem partitionSample_at_start (q : ℝ → ℝ) {a : ℝ} (as : List PositiveMass)
    (ha : MassOrdered a as) : partitionSample q a as a=q a := by
  induction as generalizing a with
  | nil => rfl
  | cons b bs ih =>
    rw [partitionSample_cons]
    split_ifs with hab
    · rfl
    · have he : a=b.val := le_antisymm ha.2.1 (le_of_not_gt hab)
      subst a
      exact ih ha.2.2

 theorem partitionSample_at_node (q : ℝ → ℝ) {a : ℝ} (as : List PositiveMass)
    (ha : MassOrdered a as) {u : PositiveMass} (hu : u ∈ as) :
    partitionSample q a as u.val=q u.val := by
  induction as generalizing a with
  | nil => simp at hu
  | cons b bs ih =>
    rcases List.mem_cons.mp hu with rfl|hu
    · rw [partitionSample_cons,ite_eq_right (lt_irrefl _)]
      exact partitionSample_at_start q _ ha.2.2
    · rw [partitionSample_cons,ite_eq_right (not_lt.mpr (ha.2.2.le_of_mem hu))]
      exact ih ha.2.2 hu

 def insertMass (u : PositiveMass) (as : List PositiveMass) : List PositiveMass :=
   (splitMassPartition u as).1++(splitMassPartition u as).2

 theorem insertMass_ordered (u : PositiveMass) (hu : u.val≤1)
    (as : List PositiveMass) (ha : MassOrdered 0 as) : MassOrdered 0 (insertMass u as) := by
  obtain ⟨h₁,h₂⟩ := splitMassPartition_ordered u hu as ha u.property.le
  apply h₁.append_end
  simpa only [splitMassPartition_end] using h₂

 theorem mem_insertMass_self (u : PositiveMass) (as : List PositiveMass) : u ∈ insertMass u as := by
  induction as with
  | nil => simp [insertMass,splitMassPartition]
  | cons b bs ih =>
    unfold insertMass splitMassPartition
    split_ifs
    · exact List.mem_cons_of_mem _ ih
    · simp

 theorem mem_insertMass_of_mem (u : PositiveMass) {as : List PositiveMass}
    {v : PositiveMass} (hv : v ∈ as) : v ∈ insertMass u as := by
  induction as with
  | nil => simp at hv
  | cons b bs ih =>
    unfold insertMass splitMassPartition
    split_ifs
    · rcases List.mem_cons.mp hv with rfl|hv
      · exact List.mem_cons_self
      · exact List.mem_cons_of_mem _ (ih hv)
    · exact List.mem_cons_of_mem _ hv

 theorem insertMass_end (u : PositiveMass) (as : List PositiveMass)
    (hu : u.val≤1) (he : partitionEnd 0 as=1) : partitionEnd 0 (insertMass u as)=1 := by
  have hgen : ∀ {a : ℝ} (bs : List PositiveMass), a≤u.val → u.val≤partitionEnd a bs →
      partitionEnd a (insertMass u bs)=partitionEnd a bs := by
    intro a bs
    induction bs generalizing a with
    | nil =>
      intro hau hua
      exact le_antisymm hua hau
    | cons b bs ih =>
      intro hau hue
      unfold insertMass splitMassPartition
      split_ifs with hbu
      · exact ih hbu.le hue
      · rfl
  exact (hgen as u.property.le (he ▸ hu)).trans he

 def twoCutMasses (u v : PositiveMass) (n : ℕ) : List PositiveMass :=
   insertMass u (insertMass v (uniformMasses n))

 theorem twoCutMasses_ordered (u v : PositiveMass) (hu : u.val≤1) (hv : v.val≤1) (n : ℕ) :
    MassOrdered 0 (twoCutMasses u v n) :=
  insertMass_ordered u hu _ (insertMass_ordered v hv _ (uniformMasses_ordered n))

 theorem twoCutMasses_mesh (u v : PositiveMass) (hu : u.val≤1) (hv : v.val≤1) (n : ℕ) :
    PartitionMesh (((n+1:ℕ):ℝ)⁻¹) 0 (twoCutMasses u v n) :=
  splitMassPartition_mesh u hu _ (insertMass_ordered v hv _ (uniformMasses_ordered n)) u.property.le
    (splitMassPartition_mesh v hv _ (uniformMasses_ordered n) v.property.le (uniformMasses_mesh n))

 theorem twoCutMasses_nodes (u v : PositiveMass) (n : ℕ) :
    u ∈ twoCutMasses u v n ∧ v ∈ twoCutMasses u v n :=
  ⟨mem_insertMass_self u _,mem_insertMass_of_mem u (mem_insertMass_self v _)⟩

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 retainedMoment_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))
    (as : ℕ → List PositiveMass) (h : ℕ → ℝ)
    (ho : ∀ n, MassOrdered 0 (as n)) (hm : ∀ n, PartitionMesh (h n) 0 (as n))
    (he : ∀ n, partitionEnd 0 (as n)=1) (hh : Tendsto h atTop (𝓝 0))
    (u : PositiveMass) (hu : u.val≤1) (hnode : ∀ n, u ∈ as n)
    (P : S → S → ℝ) {K : ℝ} (hK : 0≤K) (hP : ∀ σ τ, |P σ τ|≤K) :
    Tendsto (fun n => stepPairMoment w φ (q 0) (sampleClockSteps q 0 (as n))
      (sampleClockSteps_ordered q _ (ho n)).mem_pos P u.val)
      atTop (𝓝 (pathPairMoment w φ q P u.val)) := by
  have ht (n : ℕ) : clockCoordinateDistance D
      (stepClockFunction (fun i => (q 0 i:ℝ)) (sampleClockSteps q 0 (as n)) u.val)
      (fun i => (q u.val i:ℝ))=0 := by
    unfold clockCoordinateDistance
    simp_rw [sampleClockSteps_function q hq _ (ho n),partitionSample_at_node _ _ (ho n) (hnode n)]
    simp
  have hl : Tendsto (fun n => stepPathClockDistance D (q 0)
      (sampleClockSteps q 0 (as n)) q) atTop (𝓝 0) :=
    squeeze_zero (fun _ => stepPathClockDistance_nonneg _ _ _ _) (fun n =>
      sample_stepPathClockDistance_le D q hq _ (ho n) (hm n))
      (by simpa using hh.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 _ (ho n)) q hq P hK hP ⟨u.property,hu⟩)
  simp_rw [ht,sampleClockSteps_terminal q hq _ _ (ho _),he]
  simpa [clockCoordinateDistance] using (hl.const_mul 2).const_mul (ClockTree.errorJetVariation 2 0 0*K)

 theorem retainedMoment_tendsto_all {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ)
    (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (as : ℕ → List PositiveMass) (h : ℕ → ℝ)
    (ho : ∀ n, MassOrdered 0 (as n)) (hm : ∀ n, PartitionMesh (h n) 0 (as n))
    (he : ∀ n, partitionEnd 0 (as n)=1) (hh : Tendsto h atTop (𝓝 0))
    (u : PositiveMass) (hu : u.val≤1) (hnode : ∀ n, u ∈ as n) (P : S → S → ℝ) :
    Tendsto (fun n => stepPairMoment w φ (q 0) (sampleClockSteps q 0 (as n))
      (sampleClockSteps_ordered q _ (ho n)).mem_pos P u.val)
      atTop (𝓝 (pathPairMoment w φ q P u.val)) := by
  let D : ι → ℝ := fun i => ∑ σ, |φ σ (Pi.single i 1)|
  have hD : ∀ i, 0≤D i := by intro i; exact Finset.sum_nonneg fun σ _ => abs_nonneg _
  have hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i := by
    intro σ i
    exact Finset.single_le_sum (fun τ _ => abs_nonneg (φ τ (Pi.single i 1))) (Finset.mem_univ σ)
  let K : ℝ := ∑ σ, ∑ τ, |P σ τ|
  have hK : 0≤K := by dsimp [K]; positivity
  have hP (σ τ : S) : |P σ τ|≤K := by
    exact (Finset.single_le_sum (fun ρ _ => abs_nonneg (P σ ρ)) (Finset.mem_univ τ)).trans
      (Finset.single_le_sum (fun ρ _ => Finset.sum_nonneg fun η _ => abs_nonneg (P ρ η)) (Finset.mem_univ σ))
  exact retainedMoment_tendsto hw φ D hD hφ q hq as h ho hm he hh u hu hnode P hK hP

end SKFluctuations.Hierarchy

 

 

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

 theorem rootLevelPairMean_product_monotone {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (q : ι → ℝ≥0) (A : S → ℝ)
    (steps : List (GaussianStep ι)) {a : ℝ} (ha : OrderedSteps a steps) :
    Monotone (fun j => rootLevelPairMean w φ q (fun σ τ => A σ*A τ) steps j) := by
  intro j k hjk
  apply integral_mono
    ((levelPairMean_smooth hw φ _ steps ha j 0).integrable_zero_shift 0)
    ((levelPairMean_smooth hw φ _ steps ha k 0).integrable_zero_shift 0)
  intro x
  exact levelPairMean_product_monotone hw φ A steps ha (0+x) hjk

 theorem cumulativePair_product_monotone {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (as : List PositiveMass)
    (ha : MassOrdered 0 as) (q : ℕ → ι → ℝ) (A : S → ℝ) :
    Monotone (fun j => cumulativePair w φ as q j (fun σ τ => A σ*A τ)) := by
  have he (j : ℕ) : cumulativePair w φ as q j (fun σ τ => A σ*A τ)=
      rootLevelPairMean w φ (fun i => (q 0 i).toNNReal) (fun σ τ => A σ*A τ)
        (diagonalBoundarySteps as (q 0) (fun k => q (k+1))) j :=
    ClockTree.pairDisorder_eq_rootLevelPairMean hw φ as ha q j (fun σ τ => A σ*A τ)
  simp_rw [he]
  apply rootLevelPairMean_product_monotone hw φ
  rw [←clockSteps_cumulative]
  exact clockSteps_ordered ha _

omit [Fintype ι] in
 theorem splitClockSteps_length_monotone [Fintype ι] (L : List (GaussianStep ι)) :
    Monotone (fun u : ℝ => (splitClockSteps u L).1.length) := by
  intro u v huv
  induction L with
  | nil => exact le_rfl
  | cons s L ih =>
    simp only [splitClockSteps]
    split_ifs with hsu hsv hsv
    · simpa only [List.length_cons] using Nat.succ_le_succ ih
    · exact False.elim (hsv (hsu.trans huv))
    · exact Nat.zero_le _
    · exact le_rfl

 theorem stepPairMoment_product_monotone [Nonempty ι] {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (q₀ : ι → ℝ≥0)
    (L : List (GaussianStep ι)) (ho : OrderedSteps 0 L) (A : S → ℝ) :
    Monotone (stepPairMoment w φ q₀ L ho.mem_pos (fun σ τ => A σ*A τ)) := by
  intro u v huv
  unfold stepPairMoment
  rw [massStepFunction_split_index,massStepFunction_split_index]
  exact cumulativePair_product_monotone hw φ _ (positiveStepMasses_ordered ho _) _ A
    (splitClockSteps_length_monotone L huv)

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 ι]

 theorem pathPairMoment_product_monotone {w : S → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ)
    (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1))
    (A : S → ℝ) : MonotoneOn (pathPairMoment w φ q (fun σ τ => A σ*A τ)) (Ioc (0:ℝ) 1) := by
  intro u hu v hv huv
  let u' : PositiveMass := ⟨u,hu.1⟩
  let v' : PositiveMass := ⟨v,hv.1⟩
  let as := twoCutMasses u' v'
  have ho (n : ℕ) : MassOrdered 0 (as n) := twoCutMasses_ordered u' v' hu.2 hv.2 n
  have hm (n : ℕ) : PartitionMesh (((n+1:ℕ):ℝ)⁻¹) 0 (as n) :=
    twoCutMasses_mesh u' v' hu.2 hv.2 n
  have he (n : ℕ) : partitionEnd 0 (as n)=1 :=
    insertMass_end u' _ hu.2 (insertMass_end v' _ hv.2 (uniformMasses_end n))
  have h₁ := retainedMoment_tendsto_all hw φ q hq as _ ho hm he uniformMasses_mesh_tendsto
    u' hu.2 (fun n => (twoCutMasses_nodes u' v' n).1) (fun σ τ => A σ*A τ)
  have h₂ := retainedMoment_tendsto_all hw φ q hq as _ ho hm he uniformMasses_mesh_tendsto
    v' hv.2 (fun n => (twoCutMasses_nodes u' v' n).2) (fun σ τ => A σ*A τ)
  exact le_of_tendsto_of_tendsto h₁ h₂ (Filter.Eventually.of_forall fun n =>
    stepPairMoment_product_monotone hw φ (q 0) _ (sampleClockSteps_ordered q _ (ho n)) A huv)

end SKFluctuations.Hierarchy

 

 

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

 theorem pathPairMoment_overlap_monotone (n : ℕ) {w : Spin n → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : Spin n → (ι → ℝ) →L[ℝ] ℝ) (q : ℝ → ι → ℝ≥0)
    (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1)) :
    MonotoneOn (pathPairMoment w φ q (orderedOverlap n)) (Ioc (0:ℝ) 1) := by
  have he : orderedOverlap n = fun σ τ => (1/(n:ℝ))*∑ i, spinValue (σ i)*spinValue (τ i) := by
    funext σ τ
    unfold orderedOverlap
    ring
  intro u hu v hv huv
  rw [he,pathPairMoment_const_mul hw φ q hq _ _ hu,
    pathPairMoment_const_mul hw φ q hq _ _ hv,
    pathPairMoment_finsetSum hw φ q hq _ _ hu,pathPairMoment_finsetSum hw φ q hq _ _ hv]
  exact mul_le_mul_of_nonneg_left (Finset.sum_le_sum fun i _ =>
    pathPairMoment_product_monotone hw φ q hq (fun σ => spinValue (σ i)) hu hv huv) (by positivity)

 theorem pathPairMoment_overlap_sq_monotone (n : ℕ) {w : Spin n → ℝ} (hw : ∀ σ, 0<w σ)
    (φ : Spin n → (ι → ℝ) →L[ℝ] ℝ) (q : ℝ → ι → ℝ≥0)
    (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1)) :
    MonotoneOn (pathPairMoment w φ q (fun σ τ => (orderedOverlap n σ τ)^2)) (Ioc (0:ℝ) 1) := by
  have he : (fun σ τ => (orderedOverlap n σ τ)^2) =
      fun σ τ => (1/(n:ℝ)^2)*∑ i, ∑ j,
        (spinValue (σ i)*spinValue (σ j))*(spinValue (τ i)*spinValue (τ j)) := by
    funext σ τ
    unfold orderedOverlap
    rw [div_pow,pow_two,Finset.sum_mul_sum,one_div_mul_eq_div]
    congr 1
    apply Finset.sum_congr rfl
    intro i hi
    apply Finset.sum_congr rfl
    intro j hj
    ring
  intro u hu v hv huv
  rw [he,pathPairMoment_const_mul hw φ q hq _ _ hu,
    pathPairMoment_const_mul hw φ q hq _ _ hv,
    pathPairMoment_finsetSum hw φ q hq _ _ hu,pathPairMoment_finsetSum hw φ q hq _ _ hv]
  apply mul_le_mul_of_nonneg_left _ (by positivity)
  apply Finset.sum_le_sum
  intro i hi
  rw [pathPairMoment_finsetSum hw φ q hq _ _ hu,pathPairMoment_finsetSum hw φ q hq _ _ hv]
  exact Finset.sum_le_sum fun j _ => pathPairMoment_product_monotone hw φ q hq
    (fun σ => spinValue (σ i)*spinValue (σ j)) hu hv huv

 theorem orderedPath_SK_monotone (n : ℕ) (hn : 0<n) (b h : ℝ → ℝ≥0)
    (hb : MonotoneOn b (Icc (0:ℝ) 1)) (hh : MonotoneOn h (Icc (0:ℝ) 1)) :
    MonotoneOn (orderedPathS n b h) (Ioc (0:ℝ) 1) ∧
      MonotoneOn (orderedPathB n b h) (Ioc (0:ℝ) 1) := by
  let : NeZero n := ⟨Nat.ne_of_gt hn⟩
  exact ⟨pathPairMoment_overlap_monotone n (uniformWeight_pos n) (orderedFeature n)
      (orderedPathClock n b h) (orderedPathClock_monotone n hb hh),
    pathPairMoment_overlap_sq_monotone n (uniformWeight_pos n) (orderedFeature n)
      (orderedPathClock n b h) (orderedPathClock_monotone n hb hh)⟩

end SKFluctuations

 

 

namespace SKFluctuations
open MeasureTheory Filter Set Hierarchy
open scoped Topology NNReal

 theorem comparison_minimum_future_center {N δ U L E d r₀ u₀ : ℝ}
    (hN : 0<N) (hU : 0<U) (hL : 0<L) (hLU : L≤U) (hE : 0<E) (hd : 0≤d)
    (hq : 2≤N^δ) (hr₀ : r₀ ∈ Icc (0:ℝ) (1/4)) (hu₀ : u₀ ∈ Icc (0:ℝ) (1/4))
    (n : ℕ) (hn : 0<n) (g : ℝ → ℝ) :
    let k := comparisonFloor N δ U
    let M := comparisonCap N δ U L E d
    let _M' := comparisonCapSlope N δ U L E d
    let c := k 1
    let hr : r₀ ≤ 1 := le_trans hr₀.2 (by norm_num)
    let hu : u₀ ∈ Icc (0:ℝ) 1 := ⟨hu₀.1,le_trans hu₀.2 (by norm_num)⟩
    let hc : 0<c := comparisonFloor_pos hN hU (by norm_num)
    let hk := comparisonFloor_continuousOn (δ:=δ) hN hU hr₀.1
    let hkc := fun r (hri : r ∈ Icc r₀ 1) => comparisonFloor_lower_on (δ:=δ) hN hU hr₀.1 hri
    let hm := comparisonCap_monotoneOn (δ:=δ) hN hU.le hL hE hd
    let hM := comparisonCap_nonneg (δ:=δ) hN hU.le hL hE hd (show (0:ℝ)≤1 by norm_num)
    ∀ (α : inverseIntegralConstraints r₀ u₀ k M)
    (hg : ContDiff ℝ 1 g)
    (_hgpos : ∀ r ∈ Icc r₀ 1, 0<g r)
    (_hp : ∀ r ∈ Ioc r₀ 1, comparisonLogSlope g r ∈ Icc (0:ℝ) 1)
    (b h : ℝ → ℝ)
    (_hb : ∀ β : inverseIntegralConstraints r₀ u₀ k M,
      MonotoneOn (fun u => b u-omittedExtension hu.2
        (constrainedCoefficient hr hc hk hkc hm hM g hg.continuous β) u) (Icc (0:ℝ) 1))
    (_hh : ∀ β : inverseIntegralConstraints r₀ u₀ k M,
      MonotoneOn (fun u => h u+omittedExtension hu.2
        (constrainedCoefficient hr hc hk hkc hm hM (fun r => g r*r)
          (hg.continuous.mul continuous_id) β) u) (Icc (0:ℝ) 1))
    (_hbn : ∀ β : inverseIntegralConstraints r₀ u₀ k M,
      0 ≤ b 0-omittedExtension hu.2 (constrainedCoefficient hr hc hk hkc hm hM g hg.continuous β) 0)
    (_hhn : ∀ β : inverseIntegralConstraints r₀ u₀ k M,
      0 ≤ h 0+omittedExtension hu.2 (constrainedCoefficient hr hc hk hkc hm hM (fun r => g r*r)
        (hg.continuous.mul continuous_id) β) 0)
    (_hmin : ∀ β : inverseIntegralConstraints r₀ u₀ k M,
      inverseCompensatedPressure hr hu.2 hc hk hkc hm hM g hg.continuous n b h 0 α ≤
      inverseCompensatedPressure hr hu.2 hc hk hkc hm hM g hg.continuous n b h 0 β),
    let b' := fun u => (b u-omittedExtension hu.2
      (constrainedCoefficient hr hc hk hkc hm hM g hg.continuous α) u).toNNReal
    let h' := fun u => (h u+omittedExtension hu.2
      (constrainedCoefficient hr hc hk hkc hm hM (fun r => g r*r)
        (hg.continuous.mul continuous_id) α) u).toNNReal
    ∀ r ∈ Ioc r₀ 1, ∀ s ∈ Icc r 1,
      N^(-δ)*U < α.val.val s-α.val.val r →
      orderedPathS n b' h' (α.val.val r)≤
        s+(L/N^δ)*Real.log ((1+U)/U) := by
  dsimp only
  intro α hg hgpos hp b h hb hh hbn hhn hmin
  let k := comparisonFloor N δ U
  let M := comparisonCap N δ U L E d
  let c := k 1
  let hr : r₀≤1 := le_trans hr₀.2 (by norm_num)
  let hu : u₀≤1 := le_trans hu₀.2 (by norm_num)
  let hc : 0<c := comparisonFloor_pos hN hU (by norm_num)
  let hk := comparisonFloor_continuousOn (δ:=δ) hN hU hr₀.1
  let hkc := fun r (hri : r ∈ Icc r₀ 1) => comparisonFloor_lower_on (δ:=δ) hN hU hr₀.1 hri
  let hm := comparisonCap_monotoneOn (δ:=δ) hN hU.le hL hE hd
  let hM := comparisonCap_nonneg (δ:=δ) hN hU.le hL hE hd (show (0:ℝ)≤1 by norm_num)
  let b' := fun u => (b u-omittedExtension hu
    (constrainedCoefficient hr hc hk hkc hm hM g hg.continuous α) u).toNNReal
  let h' := fun u => (h u+omittedExtension hu
    (constrainedCoefficient hr hc hk hkc hm hM (fun r => g r*r)
      (hg.continuous.mul continuous_id) α) u).toNNReal
  let S := fun r => orderedPathS n b' h' (α.val.val r)
  let B := fun r => orderedPathB n b' h' (α.val.val r)
  let J := inverseControlFactor r₀ (fun r => inverseControlWeight α.val.val k M r*
    comparisonCapSlope N δ U L E d (α.val.val r))
  obtain ⟨H,hH,hD,hbang,hzero⟩ := comparison_minimum_contact_potential hN hU hL hLU hE hd
    hq hr₀ hu₀ n hn g α hg (fun r hr => hgpos r ⟨hr.1.le,hr.2⟩) hp b h hb hh hbn hhn hmin
  have hα := inverseConstraint_strictMonoOn hc hk hkc α.property
  have hαL := inverseIntegralConstraints_lipschitz hm hM α.property
  have hαr (r : ℝ) (hri : r ∈ Ioc r₀ 1) : α.val.val r ∈ Ioc (0:ℝ) 1 := by
    refine ⟨?_,(α.val.property.1 r).2⟩
    have ht := hα ⟨le_rfl,hr⟩ ⟨hri.1.le,hri.2⟩ hri.1
    rw [α.property.1] at ht
    exact hu₀.1.trans_lt ht
  have hb' : MonotoneOn b' (Icc (0:ℝ) 1) :=
    fun u hu v hv huv => Real.toNNReal_mono ((hb α) hu hv huv)
  have hh' : MonotoneOn h' (Icc (0:ℝ) 1) :=
    fun u hu v hv huv => Real.toNNReal_mono ((hh α) hu hv huv)
  have hSm : MonotoneOn S (Ioc r₀ 1) := by
    intro r hr s hs hrs
    exact (orderedPath_SK_monotone n hn b' h' hb' hh').1 (hαr r hr) (hαr s hs)
      (α.val.property.2 hrs)
  have hbounds (r : ℝ) (hr : r ∈ Ioc r₀ 1) := orderedPath_SK_bounds n hn b' h' hb' hh' (hαr r hr)
  have hD' : ∀ᵐ r, r ∈ Icc r₀ 1 → HasDerivAt H
      ((J r*g r)*comparisonBracket (comparisonLogSlope g r) r (S r) (B r)) r := by
    filter_upwards [hD,volume.ae_ne r₀] with r hDr hrne hri
    have hrpos : 0<r := hr₀.1.trans_lt (lt_of_le_of_ne hri.1 hrne.symm)
    have ht := hDr hri
    change HasDerivAt H (J r*radiusComparisonGradient g α.val.val
      (orderedPathS n b' h') (orderedPathB n b' h') r) r at ht
    rw [comparison_gradient_slope hrpos.ne' (hgpos r hri).ne'] at ht
    exact ht.congr_deriv (by dsimp only [S,B,comparisonBracket]; ring)
  intro r hr s hs hinc
  have hf := potential_future_center_bound hr₀.1 hr hs.1 hs.2 hH
    (fun t ht => mul_pos (inverseControlFactor_pos _ _ _) (hgpos t ht)) hD'
    (hbang.mono fun t ht hti => (ht hti).1)
    (hbang.mono fun t ht hti => (ht hti).2)
    (hzero.mono fun t ht hti hh => (ht hti hh).2.1)
    (fun t ht => (hp t ht).1) hSm (fun t ht => (hbounds t ht).2.1)
    (fun t ht => (hbounds t ht).2.2.1) hαL hα (fun t _ => α.val.property.1 t)
    (comparisonCap_continuous N δ U L E d).continuousOn
    (fun u hu => (comparisonCap_first_term hN hU hL hE hd hu.1).1)
    (comparisonFloor_continuousOn (δ:=δ) hN hU (show (0:ℝ)≤0 by rfl)).integrableOn_Icc
    (fun t ht => (comparisonFloor_pos (δ:=δ) hN hU ht.1).le)
    ((comparisonFloor_total_mass hN hU).trans_lt hinc)
  have hcT := comparisonCap_log_travel (δ:=δ) hN hU hL hE hd (show (0:ℝ)≤0 by rfl)
    (show (0:ℝ)≤1 by norm_num)
  simp only [zero_add] at hcT
  exact hf.trans (by linarith)

end SKFluctuations

 

 

namespace SKFluctuations
open Set

 theorem finite_dyadic_future_cover {x B μ : ℝ} (hx : 0 < x) (hB : 0 < B)
    (hμ : 0 < μ) (hμB : 3*B*μ ≤ 1) :
    ∃ vs : Finset ℝ, (∀ v ∈ vs, 0 < v ∧ 3*B*v ≤ 1) ∧
      ∀ y : ℝ, x ≤ y → μ ≤ y ∨ ∃ v ∈ vs, v ≤ y ∧ y < 2*v := by
  obtain ⟨N,hN⟩ := exists_nat_gt (max 0 (μ/x))
  rw [max_eq_right (div_pos hμ hx).le] at hN
  classical
  let vs := ((Finset.range N).image (fun j : ℕ => (2:ℝ)^j*x)).filter (fun v => 3*B*v ≤ 1)
  refine ⟨vs,?_,?_⟩
  · intro v hv
    obtain ⟨hj,hv⟩ := Finset.mem_filter.mp hv
    obtain ⟨j,hj,rfl⟩ := Finset.mem_image.mp hj
    exact ⟨by positivity,hv⟩
  · intro y hxy
    by_cases hmy : μ ≤ y
    · exact Or.inl hmy
    · right
      have hym : y < μ := lt_of_not_ge hmy
      have hrat : 1 ≤ y/x := (le_div_iff₀ hx).mpr (by simpa using hxy)
      obtain ⟨j,hlo,hhi⟩ := exists_nat_pow_near hrat (show (1:ℝ) < 2 by norm_num)
      have hvy : (2:ℝ)^j*x ≤ y := (le_div_iff₀ hx).mp hlo
      have hyv : y < 2*((2:ℝ)^j*x) := by
        have hh := (div_lt_iff₀ hx).mp hhi
        rw [pow_succ] at hh
        nlinarith
      have hjpow : (j:ℝ) < (2:ℝ)^j := by exact_mod_cast (Nat.lt_two_pow_self (n := j))
      have hjN : j < N := by
        have hyx : y/x < μ/x := div_lt_div_of_pos_right hym hx
        have hh : (j:ℝ) < N := lt_trans (hjpow.trans_le hlo) (hyx.trans hN)
        exact_mod_cast hh
      refine ⟨(2:ℝ)^j*x,Finset.mem_filter.mpr ⟨Finset.mem_image.mpr ⟨j,Finset.mem_range.mpr hjN,rfl⟩,?_⟩,hvy,hyv⟩
      exact (mul_le_mul_of_nonneg_left (hvy.trans hym.le) (by positivity : 0 ≤ 3*B)).trans hμB

 theorem future_window_radius_geometry {α : ℝ → ℝ} {x y v B cl cu R a b A : ℝ}
    (hx : 0 < x) (hxy : x ≤ y) (hvy : v ≤ y) (hyv : y < 2*v)
    (hcl : 0 < cl) (hcu : 0 < cu) (hB : 2 ≤ B) (hA : 1 ≤ A)
    (hBA : 2*cu*A ≤ B) (hyR : B*y ≤ cl*R)
    (ha : α a=B*v) (hb : α b=2*B*v)
    (hregA : cl*a ≤ α a ∧ α a ≤ cu*a)
    (hregB : cl*b ≤ α b ∧ α b ≤ cu*b) :
    0 < v ∧ A*x ≤ a ∧ a ≤ R ∧ b ≤ (2*cu/cl)*a ∧
      cl*a ≤ B*v ∧ B*v ≤ cu*a ∧ y-x < B*v := by
  have hv : 0 < v := by linarith
  have hB0 : 0 < B := by linarith
  have hAx : 0 < A*x := mul_pos (by linarith) hx
  have hAv : A*x < 2*A*v := by nlinarith
  have hBv : 2*cu*A*v ≤ B*v := mul_le_mul_of_nonneg_right hBA hv.le
  rw [ha] at hregA
  rw [hb] at hregB
  have hAa : A*x ≤ a := by nlinarith
  refine ⟨hv,hAa,?_,?_,hregA.1,hregA.2,?_⟩
  · have hh := mul_le_mul_of_nonneg_left hvy hB0.le
    nlinarith
  · rw [div_mul_eq_mul_div]
    apply (le_div_iff₀ hcl).mpr
    have hh := mul_le_mul_of_nonneg_left hregA.2 (show (0:ℝ) ≤ 2 by norm_num)
    nlinarith [hregB.1]
  · nlinarith

end SKFluctuations

 

 

namespace SKFluctuations
open Set Hierarchy

 theorem radius_in_regular_region {α : ℝ → ℝ} {r₀ z a p cl cu : ℝ}
    (hα : Monotone α) (ha : a ∈ Icc r₀ 1) (hz : z ∈ Icc r₀ 1)
    (heq : α a=p) (hp : cu*z<p)
    (hreg : ∀ t ∈ Icc z 1, cl*t≤α t ∧ α t≤cu*t) :
    z<a ∧ cl*a≤p ∧ p≤cu*a := by
  have hza : z<a := by
    by_contra hza
    have ham := hα (le_of_not_gt hza)
    have hh := (hreg z ⟨le_rfl,hz.2⟩).2
    rw [heq] at ham
    linarith
  refine ⟨hza,?_⟩
  simpa only [heq] using hreg a ⟨hza.le,ha.2⟩

 theorem constrainedFutureBand_geometry {r₀ u₀ c : ℝ} {k M : ℝ → ℝ}
    (hr : r₀≤1) (hc : 0<c) (hk : ContinuousOn k (Icc r₀ 1))
    (hkc : ∀ t ∈ Icc r₀ 1, c≤k t)
    (hm : MonotoneOn M (Icc (0:ℝ) 1)) (hM : 0≤M 1)
    (α : inverseIntegralConstraints r₀ u₀ k M)
    (p q t : Icc u₀ 1) {v B z cl cu : ℝ}
    (hv : 0<v) (hB : 0<B) (hcl : 0<cl) (hcu : 0<cu)
    (hp : p.val=B*v) (hq : q.val=2*B*v) (ht : t.val=3*B*v)
    (hz : z ∈ Icc r₀ 1) (hstart : cu*z<B*v)
    (hreg : ∀ r ∈ Icc z 1, cl*r≤α.val.val r ∧ α.val.val r≤cu*r) :
    let a := (constrainedQuantile hr hc hk hkc hm hM α p).val
    let ab := (constrainedQuantile hr hc hk hkc hm hM α q).val
    let ac := (constrainedQuantile hr hc hk hkc hm hM α t).val
    z<a ∧ a<ab ∧ ab<ac ∧ ac≤(3*B/cl)*v ∧
      ab≤(2*cu/cl)*a ∧ cl*a≤q.val-p.val ∧ q.val-p.val≤cu*a := by
  dsimp only
  let Q := constrainedQuantile hr hc hk hkc hm hM α
  have hQa : α.val.val (Q p)=p.val := constrainedQuantile_spec hr hc hk hkc hm hM α p
  have hQb : α.val.val (Q q)=q.val := constrainedQuantile_spec hr hc hk hkc hm hM α q
  have hQc : α.val.val (Q t)=t.val := constrainedQuantile_spec hr hc hk hkc hm hM α t
  have hrA := radius_in_regular_region α.val.property.2 (Q p).property hz hQa
    (by rwa [hp]) hreg
  have hrB := radius_in_regular_region α.val.property.2 (Q q).property hz hQb
    (by rw [hq]; nlinarith [mul_pos hB hv]) hreg
  have hrC := radius_in_regular_region α.val.property.2 (Q t).property hz hQc
    (by rw [ht]; nlinarith [mul_pos hB hv]) hreg
  have hpq : p<q := by change p.val<q.val; rw [hp,hq]; nlinarith [mul_pos hB hv]
  have hqt : q<t := by change q.val<t.val; rw [hq,ht]; nlinarith [mul_pos hB hv]
  have hmono : StrictMono Q := (inverseConstraintOrderIso hr hc hk hkc hm hM α).symm.strictMono
  refine ⟨hrA.1,hmono hpq,hmono hqt,?_,?_,?_,?_⟩
  · have hh := hrC.2.1
    rw [ht] at hh
    have hb : (Q t).val≤3*B*v/cl := (le_div_iff₀ hcl).mpr (by nlinarith)
    convert hb using 1
    ring
  · have ha := hrA.2.2
    have hb := hrB.2.1
    rw [hp] at ha
    rw [hq] at hb
    have ha' : B*v/cu ≤ (Q p).val := (div_le_iff₀ hcu).mpr (by nlinarith)
    calc
      (Q q).val ≤ 2*B*v/cl := (le_div_iff₀ hcl).mpr (by nlinarith)
      _ = (2*cu/cl)*(B*v/cu) := by
        field_simp
      _ ≤ (2*cu/cl)*(Q p).val := mul_le_mul_of_nonneg_left ha' (by positivity)
  · have hh := hrA.2.1
    rw [hp,hq] at *
    linarith
  · have hh := hrA.2.2
    rw [hp,hq] at *
    linarith

end SKFluctuations

end

end OAI