import Mathlib
import OAI.Probability.JammingConcavity.RowFiniteDiagonal

namespace OAI

/-! Row Finite Diagonal Row Direction Pairing Tendsto. -/

noncomputable section

open MeasureTheory ProbabilityTheory Set
open scoped NNReal ENNReal
open Set Filter
open scoped Topology
open MeasureTheory ProbabilityTheory Filter Set
open scoped ENNReal NNReal Topology BigOperators
open MeasureTheory Filter Set
open scoped ENNReal NNReal BigOperators
open MeasureTheory ProbabilityTheory Set Filter
open scoped ENNReal NNReal Topology
open scoped NNReal ENNReal Topology
open scoped NNReal Topology
open Set
open Set Filter MeasureTheory
open scoped BigOperators
open scoped Topology NNReal
open scoped Topology BigOperators
open scoped ENNReal NNReal
open MeasureTheory Set
open MeasureTheory ProbabilityTheory
open scoped ENNReal NNReal BigOperators Classical
open Classical
open scoped ENNReal NNReal Topology BigOperators MatrixOrder
open scoped NNReal BigOperators
open MeasureTheory Metric Set
open Metric
open scoped RealInnerProductSpace
open Filter
open Finset Set
open MeasureTheory ProbabilityTheory Filter
open scoped ENNReal NNReal BigOperators Topology
open MeasureTheory ProbabilityTheory Filter Metric
open scoped ENNReal NNReal Topology BigOperators BoundedContinuousFunction
open scoped BigOperators Classical
open scoped ENNReal NNReal Topology BigOperators Matrix MatrixOrder
open scoped BigOperators RealInnerProductSpace
open scoped NNReal Topology BigOperators
open scoped NNReal BigOperators RealInnerProductSpace
open scoped ENNReal NNReal BigOperators MatrixOrder
open scoped MatrixOrder
open scoped NNReal
open scoped BigOperators NNReal
open scoped NNReal ENNReal BigOperators Topology
open scoped Topology ENNReal NNReal
open scoped Matrix.Norms.L2Operator MatrixOrder Topology NNReal ENNReal BigOperators
open scoped Topology ENNReal NNReal BigOperators MatrixOrder Matrix.Norms.L2Operator
open scoped Topology NNReal ENNReal BigOperators
open scoped BigOperators NNReal Topology
open scoped Topology NNReal ENNReal BigOperators MatrixOrder
open scoped Topology NNReal ENNReal BigOperators MatrixOrder Matrix.Norms.L2Operator
open MeasureTheory ProbabilityTheory Set Filter
open scoped Topology

namespace MicroscopicJamming
 

def RowFiniteFTCStatement : Prop :=
  ∀ (u : ℝ → ℝ) (L H : ℝ), ContDiff ℝ 2 u → 0 ≤ L → 0 ≤ H →
    (∀ x, |deriv u x| ≤ L ∧ |deriv (deriv u) x| ≤ H) →
    ∀ bs : List (ℝ × ℝ × ℝ),
      (∀ c ∈ bs, 0 ≤ c.1 ∧ c.1 ≤ 1 ∧ 0 ≤ c.2.1 ∧ 0 ≤ c.2.2) →
      bs.Pairwise (fun c d => c.1 ≤ d.1) → rowVarianceTotal bs=0 →
      ∀ x : ℝ,
        gaussianRowComposition (rowInterpolatedBlocks bs 1) u x-
          gaussianRowComposition (rowInterpolatedBlocks bs 0) u x =
        ∫ t in (0:ℝ)..1, -(1/2:ℝ)*(∫ s in (0:ℝ)..1,
          (gaussianRankProfile (bs.map (fun c => (c.1,c.2.2))) s-
           gaussianRankProfile (bs.map (fun c => (c.1,c.2.1))) s)*
           rowDerivativeRankMoment (rowInterpolatedBlocks bs t) u s x)
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped Topology NNReal ENNReal BigOperators

namespace MicroscopicJamming

lemma rowBoundedFamily_composed_continuousAt {f : ℝ → ℝ → ℝ} {L H t₀ : ℝ}
    (hf : ∀ t, RowBoundedTerminal (f t) L H)
    (hc : ∀ y, ContinuousAt (fun t => f t y) t₀)
    {g : ℝ → ℝ} (hg : ContinuousAt g t₀) : ContinuousAt (fun t => f t (g t)) t₀ := by
  have hb (t : ℝ) : ‖f t (g t)-f t (g t₀)‖ ≤ L*‖g t-g t₀‖ := by
    exact Convex.norm_image_sub_le_of_norm_deriv_le (f := f t) (s := univ)
      (fun y _ => (hf t).diff y) (fun y _ => by simpa only [Real.norm_eq_abs] using (hf t).slope y)
      convex_univ (mem_univ _) (mem_univ _)
  have ht : Tendsto (fun t => f t (g t)-f t (g t₀)) (𝓝 t₀) (𝓝 0) := by
    apply squeeze_zero_norm hb
    simpa only [sub_self,norm_zero,mul_zero] using
      (tendsto_const_nhds.mul ((hg.tendsto.sub tendsto_const_nhds).norm) :
        Tendsto (fun t => L*‖g t-g t₀‖) (𝓝 t₀) (𝓝 (L*‖g t₀-g t₀‖)))
  have hh := ht.add (hc (g t₀)).tendsto
  change Tendsto (fun t => f t (g t)) (𝓝 t₀) (𝓝 (f t₀ (g t₀)))
  simpa only [sub_add_cancel,zero_add] using hh

lemma rowOperator_parameter_continuousAt {f : ℝ → ℝ → ℝ} {L H t₀ : ℝ}
    (hf : ∀ t, RowBoundedTerminal (f t) L H)
    (hc : ∀ y, ContinuousAt (fun t => f t y) t₀)
    {T : ℝ → ℝ} (hT : ContinuousAt T t₀) (a x : ℝ) :
    ContinuousAt (fun t => gaussianRowOperator a (T t) (f t) x) t₀ := by
  let A := |f t₀ 0|+1
  let B := |Real.sqrt (T t₀)|+1
  have hA : 0 ≤ A := by dsimp [A]; positivity
  have hB : 0 ≤ B := by dsimp [B]; positivity
  have hL := (hf t₀).L_nonneg
  have heA : ∀ᶠ t in 𝓝 t₀, |f t 0| ≤ A := by
    exact ((hc 0).abs.eventually_lt continuousAt_const (by dsimp [A]; linarith)).mono (fun _ h => h.le)
  have heB : ∀ᶠ t in 𝓝 t₀, |Real.sqrt (T t)| ≤ B := by
    exact ((Real.continuous_sqrt.continuousAt.comp hT).abs.eventually_lt continuousAt_const
      (by dsimp [B]; linarith)).mono (fun _ h => h.le)
  have hlinear : ∀ᶠ t in 𝓝 t₀, ∀ z : ℝ, |f t (x+Real.sqrt (T t)*z)| ≤ A+L*|x|+(L*B)*|z| := by
    filter_upwards [heA,heB] with t ha hb
    intro z
    have h := bounded_deriv_linear (hf t).diff (hf t).slope (x+Real.sqrt (T t)*z)
    have hg : |x+Real.sqrt (T t)*z| ≤ |x|+B*|z| := by
      calc
        _ ≤ |x|+|Real.sqrt (T t)*z| := abs_add_le _ _
        _ ≤ _ := by rw [abs_mul]; gcongr
    nlinarith [mul_le_mul_of_nonneg_left hg hL]
  have hcomp (z : ℝ) : ContinuousAt (fun t => f t (x+Real.sqrt (T t)*z)) t₀ :=
    rowBoundedFamily_composed_continuousAt hf hc (continuousAt_const.add ((Real.continuous_sqrt.continuousAt.comp hT).mul_const z))
  by_cases ha : a=0
  · subst a
    simp only [gaussianRowOperator,gaussianHeat]
    let C := A+L*|x|+L*B
    have hC : 0 ≤ C := by dsimp [C]; positivity
    apply continuousAt_of_dominated (bound := fun z => C*Real.exp |z|)
      (Eventually.of_forall (fun t => ((hf t).diff.continuous.measurable.comp (by fun_prop)).aestronglyMeasurable)) ?_
      ((gaussian_exp_abs_integrable 1).const_mul C |>.congr (Eventually.of_forall (by intro z; simp)))
      (Eventually.of_forall hcomp)
    filter_upwards [hlinear] with t ht
    apply Eventually.of_forall
    intro z
    rw [Real.norm_eq_abs]
    have h₁ : 1 ≤ Real.exp |z| := Real.one_le_exp (abs_nonneg z)
    have h₂ : |z| ≤ Real.exp |z| := by linarith [Real.add_one_le_exp |z|]
    apply (ht z).trans
    calc
      _ ≤ (A+L*|x|)*Real.exp |z|+(L*B)*Real.exp |z| :=
        add_le_add (le_mul_of_one_le_right (by positivity) h₁)
          (mul_le_mul_of_nonneg_left h₂ (mul_nonneg hL hB))
      _ = _ := by dsimp [C]; ring
  · have hci : ContinuousAt (fun t => ∫ z, Real.exp (a*f t (x+Real.sqrt (T t)*z)) ∂gaussianReal 0 1) t₀ := by
      apply continuousAt_of_dominated
        (bound := fun z => Real.exp (|a| *(A+L*|x|))*Real.exp ((|a| *L*B)*|z|))
        (Eventually.of_forall (fun t => (((hf t).diff.continuous.measurable.comp (by fun_prop)).const_mul a).exp.aestronglyMeasurable)) ?_
        ((gaussian_exp_abs_integrable (|a| *L*B)).const_mul (Real.exp (|a| *(A+L*|x|))))
        (Eventually.of_forall (fun z => Real.continuous_exp.continuousAt.comp ((hcomp z).const_mul a)))
      filter_upwards [hlinear] with t ht
      apply Eventually.of_forall
      intro z
      rw [Real.norm_eq_abs,abs_of_pos (Real.exp_pos _),← Real.exp_add]
      apply Real.exp_le_exp.mpr
      have hb : a*f t (x+Real.sqrt (T t)*z) ≤ |a| *|f t (x+Real.sqrt (T t)*z)| := by
        simpa only [abs_mul] using le_abs_self (a*f t (x+Real.sqrt (T t)*z))
      dsimp only [Function.comp_def]
      calc
        _ ≤ |a| * |f t (x+Real.sqrt (T t)*z)| := hb
        _ ≤ |a| * (A+L*|x|+L*B*|z|) := mul_le_mul_of_nonneg_left (ht z) (abs_nonneg a)
        _ = _ := by ring
    have hp : (∫ z, Real.exp (a*f t₀ (x+Real.sqrt (T t₀)*z)) ∂gaussianReal 0 1) ≠ 0 :=
      (integral_exp_pos (rowTiltStep_weight_integrable (hf t₀).diff.continuous.measurable
        (rowBounded_exp_growth (hf t₀) a).1 (T t₀) x)).ne'
    simpa only [gaussianRowOperator,ite_eq_right ha,gaussianHeat] using (hci.log hp).const_mul (1/a)

lemma rowVarianceComposition_continuous {u : ℝ → ℝ} {L H : ℝ} (hu : RowBoundedTerminal u L H)
    (bs : List (ℝ × ℝ × ℝ)) (hbs : ∀ b ∈ bs, 0 ≤ b.1 ∧ b.1 ≤ 1) (x : ℝ) :
    Continuous (fun t => gaussianRowComposition (rowInterpolatedBlocks bs t) u x) := by
  induction bs generalizing x with
  | nil => exact continuous_const
  | cons b bs ih =>
    rcases b with ⟨a,T,R⟩
    have htail := fun c hc => hbs c (List.mem_cons_of_mem _ hc)
    obtain ⟨K,C,hC,hf,hm,hb⟩ := rowVarianceFamily_bounds hu bs htail
    apply continuous_iff_continuousAt.mpr
    intro t
    exact rowOperator_parameter_continuousAt hf (fun y => (ih htail y).continuousAt) (by fun_prop) a x
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped Topology

namespace MicroscopicJamming

theorem rowFiniteFTC : RowFiniteFTCStatement := by
  intro u L H hu hL hH hb bs hbs hord htotal x
  have hbu := rowTerminal_of_C2 hu hL hH hb
  let F := fun t => gaussianRowComposition (rowInterpolatedBlocks bs t) u x
  let F' := fun t => -(1/2:ℝ)*(∫ s in (0:ℝ)..1,
    (gaussianRankProfile (bs.map (fun c => (c.1,c.2.2))) s-
      gaussianRankProfile (bs.map (fun c => (c.1,c.2.1))) s)*
      rowDerivativeRankMoment (rowInterpolatedBlocks bs t) u s x)
  have hd : ∀ t ∈ Set.Ioo (0:ℝ) 1, HasDerivAt F (F' t) t :=
    fun t ht => rowFiniteIntegral u L H hu hL hH hb bs hbs hord htotal t ht x
  obtain ⟨K,C,hC,hf,hm,hbound⟩ := rowVarianceFamily_bounds hbu bs (fun c hc => ⟨(hbs c hc).1,(hbs c hc).2.1⟩)
  have he : F' =ᵐ[volume.restrict (Set.Ioo (0:ℝ) 1)] deriv F := by
    filter_upwards [ae_restrict_mem measurableSet_Ioo] with t ht
    exact (hd t ht).deriv.symm
  have hi : IntervalIntegrable F' volume 0 1 := by
    rw [intervalIntegrable_iff_integrableOn_Ioo_of_le (by norm_num : (0:ℝ) ≤ 1)]
    apply (integrable_const C).mono' ((aestronglyMeasurable_deriv F _).congr he.symm)
    filter_upwards [ae_restrict_mem measurableSet_Ioo] with t ht
    have hv := rowFiniteVariance u L H hu hL hH hb bs hbs t ht x
    have heq : F' t = rowFiniteVarianceResponse bs u t x := (hd t ht).deriv.symm.trans hv.deriv
    rw [Real.norm_eq_abs,heq]
    exact hbound t x
  exact (intervalIntegral.integral_eq_sub_of_hasDerivAt_of_le (by norm_num : (0:ℝ)≤1)
    (rowVarianceComposition_continuous hbu bs (fun c hc => ⟨(hbs c hc).1,(hbs c hc).2.1⟩) x).continuousOn hd hi).symm
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped Topology NNReal ENNReal

namespace MicroscopicJamming
 

def RowFiniteProfile.functional {Q : ℝ} (P : RowFiniteProfile Q) (u : ℝ → ℝ) : ℝ :=
  gaussianRowComposition ((0,(P.root:ℝ))::(rowGaussianBlocks P.ranks P.increment ++ [(1,(P.residual:ℝ))])) u 0

 

def RowFiniteFunctionalStatement : Prop :=
  ∀ (u : ℝ → ℝ) (L H : ℝ), ContDiff ℝ 2 u → 0 ≤ L → 0 ≤ H →
    (∀ x, |deriv u x| ≤ L ∧ |deriv (deriv u) x| ≤ H) →
    ∀ Q : ℝ, ∀ P : RowFiniteProfile Q,
      (∫ ω, Real.log (replicaZ (rowReplicaKernel P.ranks P.residual) (rowFullPotential P.ranks u) ω)
        ∂rowReplicaEnvironmentLaw P.ranks P.increment P.root) = P.functional u
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped Topology NNReal ENNReal

namespace MicroscopicJamming
lemma gaussianRowComposition_append_eq (bs cs : List (ℝ × ℝ)) (u : ℝ → ℝ) :
    gaussianRowComposition (bs++cs) u = gaussianRowComposition bs (gaussianRowComposition cs u) := by
  induction bs with
  | nil => rfl
  | cons b bs ih => simp only [List.cons_append,gaussianRowComposition,ih]

lemma integrable_cascade_coordinates {E : Type} [MeasurableSpace E] [AddCommMonoid E]
    [MeasurableAdd₂ E] (ms : List ℝ) (μ : Measure E) [IsProbabilityMeasure μ]
    (ν : ℕ → Measure E) [∀ j, IsProbabilityMeasure (ν j)]
    {f : E × FamilyCascadeTree E ms.length → ℝ} (hf : Measurable f)
    {g : CascadeTree ms.length × (Option (CascadeMarkIndex ms.length) → E) → ℝ} (hg : Measurable g)
    (he : ∀ ω x y, f (x,zipCascade ms.length (ω,y)) = g (ω,rootMarkCoordinates ms.length (x,y))) :
    Integrable f (μ.prod (familyCascadeLaw ms.length ν)) ↔
      Integrable g ((cascadeLaw ms).prod (Measure.infinitePi
        (fun i : Option (CascadeMarkIndex ms.length) => i.elim μ (fun j => ν (cascadeMarkDepth ms.length j))))) := by
  rw [← zipRootCascade_law ms μ ν,
    integrable_map_measure hf.aestronglyMeasurable (measurable_zipRootCascade ms.length).aemeasurable]
  have hmap := rootMarkCoordinates_law ms.length μ ν
  rw [← hmap, ← (Measure.map_id (μ := cascadeLaw ms)),
    Measure.map_prod_map _ _ measurable_id (measurable_rootMarkCoordinates ms.length),
    integrable_map_measure hg.aestronglyMeasurable (measurable_id.prodMap (measurable_rootMarkCoordinates ms.length)).aemeasurable]
  rw [Measure.map_id]
  apply integrable_congr
  exact Eventually.of_forall fun z => he z.1 z.2.1 z.2.2

lemma replica_log_integrable
    {Ω S : Type*} [MeasurableSpace Ω] [MeasurableSpace S]
    (ν : Measure Ω) [IsProbabilityMeasure ν] (G : Kernel Ω S) [IsMarkovKernel G]
    {V : Ω × S → ℝ} (hV : Measurable V)
    (h4 : Integrable (fun z => Real.exp (4*|V z|)) (ν ⊗ₘ G)) :
    Integrable (fun ω => Real.log (replicaZ G V ω)) ν := by
  have hsplit := (Measure.integrable_compProd_iff h4.aestronglyMeasurable).mp h4
  have hAi : Integrable (fun ω => ∫ x, Real.exp (4*|V (ω,x)|) ∂G ω) ν := by
    simpa only [Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)] using hsplit.2
  apply (hAi.const_mul 2).mono' (Real.measurable_log.comp (measurable_replicaZ G hV)).aestronglyMeasurable
  filter_upwards [hsplit.1] with ω hω
  simpa only [Real.norm_eq_abs,Function.comp_apply,id_eq,replicaZ] using
    (replica_fiber_log_estimates (G ω) (hV.comp (measurable_const.prodMk measurable_id)) hω (le_refl (0:ℝ))).2.2.1

lemma rowResidual_partition_pointwise {u : ℝ → ℝ} {L H : ℝ} (hu : RowBoundedTerminal u L H)
    (ms : List ℝ) (Δ : ℝ≥0) (ω : RowReplicaEnvironment ms.length) :
    replicaZ (rowReplicaKernel ms Δ) (rowFullPotential ms u) ω =
      replicaZ (rowCoordinateLeafKernel ms) (rowCoordinatePotential ms (gaussianRowOperator 1 Δ u)) ω := by
  let := cascadeLeafLaw_probability ms ω.1
  exact residual_partition_eq (cascadeLeafLaw ms ω.1) (rootPathField ms.length ω.2)
    (measurable_of_countable _) hu Δ
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped Topology NNReal ENNReal

namespace MicroscopicJamming

theorem rowGaussianCascade : RowGaussianCascadeStatement := by
  intro u L H hu hL hH hb ms hord hms d Δ p₀
  let v := gaussianRowOperator 1 Δ u
  have ht := rowTerminal_of_C2 hu hL hH hb
  have hv := rowBoundedOperator_terminal ht (by norm_num : (0:ℝ)≤1) le_rfl (Δ:ℝ)
  obtain ⟨he,hf⟩ := rowGaussian_recursion hv ms hms d
  have he' (x : ℝ) : familyRecursion ms (rowGaussianLaw d) v x =
      gaussianRowComposition (rowGaussianBlocks ms d++[(1,(Δ:ℝ))]) u x := by
    rw [gaussianRowComposition_append_eq]
    exact congrFun he x
  have (k : ℕ) : IsProbabilityMeasure (rowGaussianLaw d k) := inferInstanceAs (IsProbabilityMeasure (gaussianReal 0 (d k)))
  have hg := familyCascadeLog ℝ inferInstance inferInstance inferInstance ms hord hms
    (rowGaussianLaw d) (fun _ => inferInstance) v hv.diff.continuous.measurable hf
  refine ⟨hf,he',fun x => (hg x).2.2.1,?_⟩
  change (∫ z, ∫ ω, familyLogPartition ms v z ω ∂familyCascadeLaw ms.length (rowGaussianLaw d) ∂gaussianReal 0 p₀) = _
  have hinner (z : ℝ) : (∫ ω, familyLogPartition ms v z ω ∂familyCascadeLaw ms.length (rowGaussianLaw d)) =
      gaussianRowComposition (rowGaussianBlocks ms d) v z := (hg z).2.2.2.trans (congrFun he z)
  simp_rw [hinner]
  obtain ⟨K,hK⟩ := rowBoundedComposition_terminal hv (rowGaussianBlocks ms d)
    (rowGaussianBlocks_valid ms (fun a ha => ⟨(hms a ha).1.le,(hms a ha).2.le⟩) d)
  simp only [gaussianRowComposition]
  rw [gaussianRowComposition_append_eq]
  change (∫ z, gaussianRowComposition (rowGaussianBlocks ms d) v z ∂gaussianReal 0 p₀) =
    gaussianRowOperator 0 (p₀:ℝ) (gaussianRowComposition (rowGaussianBlocks ms d) v) 0
  rw [rowGaussian_integral p₀ hK.diff.continuous.measurable]
  simp [gaussianRowOperator,gaussianHeat]
  rfl
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped Topology NNReal ENNReal

namespace MicroscopicJamming

lemma rowFiniteFunctional_log_integrable {u : ℝ → ℝ} {L H : ℝ}
    (hu : RowBoundedTerminal u L H) {Q : ℝ} (P : RowFiniteProfile Q) :
    Integrable (fun ω => Real.log (replicaZ (rowReplicaKernel P.ranks P.residual)
      (rowFullPotential P.ranks u) ω)) (rowReplicaEnvironmentLaw P.ranks P.increment P.root) := by
  have : IsProbabilityMeasure (rowReplicaEnvironmentLaw P.ranks P.increment P.root) := by
    unfold rowReplicaEnvironmentLaw; infer_instance
  obtain ⟨C,hC⟩ := rowUniformMoments hu Q (fun _ => P) 4 (by norm_num)
  exact replica_log_integrable _ _ (measurable_rowFullPotential _ _ hu.diff.continuous.measurable) (hC 0).1

lemma familyCoordinate_log_expectation {u : ℝ → ℝ} {L H : ℝ}
    (hu : RowBoundedTerminal u L H) (ms : List ℝ) (hord : ms.Pairwise (· < ·))
    (hms : ∀ m ∈ ms, 0 < m ∧ m < 1) (d : ℕ → ℝ≥0) (x : ℝ) :
    (∫ ω, Real.log (replicaZ (familyCoordinateKernel ms) (familyCoordinatePotential ms u) (x,ω))
      ∂familyCascadeLaw ms.length (rowGaussianLaw d)) =
      gaussianRowComposition (rowGaussianBlocks ms d) u x := by
  have (k : ℕ) : IsProbabilityMeasure (rowGaussianLaw d k) := inferInstanceAs (IsProbabilityMeasure (gaussianReal 0 (d k)))
  obtain ⟨he,hf⟩ := rowGaussian_recursion hu ms hms d
  have hg := familyCascadeLog ℝ inferInstance inferInstance inferInstance ms hord hms
    (rowGaussianLaw d) (fun _ => inferInstance) u hu.diff.continuous.measurable hf x
  rw [← congrFun he x,← hg.2.2.2]
  apply integral_congr_ae
  filter_upwards [(familyUnmarkedTotal_properties ms hord hms (rowGaussianLaw d) (fun _ => inferInstance)).1] with ω hω
  change Real.log (∫ ℓ, Real.exp (u (familyPathMark ms.length x ω ℓ))
    ∂cascadeLeafLaw ms (forgetFamilyMarks ms.length ω)) = _
  rw [familyBaseLeaf_Z ms u x ω hω,ENNReal.toReal_div]
  simp only [familyLogPartition,familyLeafTotal_zero]

theorem rowFiniteFunctional : RowFiniteFunctionalStatement := by
  intro u L H hu hL hH hb Q P
  have ht := rowTerminal_of_C2 hu hL hH hb
  let v := gaussianRowOperator 1 P.residual u
  have hv := rowBoundedOperator_terminal ht (by norm_num : (0:ℝ)≤1) le_rfl (P.residual:ℝ)
  let f := fun z : ℝ × FamilyCascadeTree ℝ P.ranks.length =>
    Real.log (replicaZ (familyCoordinateKernel P.ranks) (familyCoordinatePotential P.ranks v) z)
  let g := fun ω : RowReplicaEnvironment P.ranks.length =>
    Real.log (replicaZ (rowCoordinateLeafKernel P.ranks) (rowCoordinatePotential P.ranks v) ω)
  have hf : Measurable f := Real.measurable_log.comp (measurable_replicaZ _ (measurable_familyCoordinatePotential _ hv.diff.continuous.measurable))
  have hg : Measurable g := Real.measurable_log.comp (measurable_replicaZ _ (measurable_rowCoordinatePotential _ hv.diff.continuous.measurable))
  have (k : ℕ) : IsProbabilityMeasure (rowGaussianLaw P.increment k) := inferInstanceAs (IsProbabilityMeasure (gaussianReal 0 (P.increment k)))
  let := familyCascadeLaw_probability P.ranks.length (rowGaussianLaw P.increment) (fun _ => inferInstance)
  have heq : ∀ ω x y, f (x,zipCascade P.ranks.length (ω,y)) = g (ω,rootMarkCoordinates P.ranks.length (x,y)) := by
    intro ω x y
    simp only [f,g,replicaZ,familyCoordinateKernel,Kernel.coe_mk,familyCoordinatePotential,
      rowCoordinateLeafKernel,rowCoordinatePotential,forgetFamilyMarks_zip,rootPathField_eq]
  have hlaw : (fun i : Option (CascadeMarkIndex P.ranks.length) => i.elim (gaussianReal 0 P.root)
        (fun j => rowGaussianLaw P.increment (cascadeMarkDepth P.ranks.length j))) =
      (fun i => gaussianReal 0 (rootCoordinateVariance P.ranks.length P.increment P.root i)) := by
    funext i
    cases i <;> rfl
  have hgi : Integrable g (rowReplicaEnvironmentLaw P.ranks P.increment P.root) := by
    apply (rowFiniteFunctional_log_integrable ht P).congr
    exact Eventually.of_forall (fun ω => congrArg Real.log (rowResidual_partition_pointwise ht P.ranks P.residual ω))
  have hfi : Integrable f ((gaussianReal 0 P.root).prod (familyCascadeLaw P.ranks.length (rowGaussianLaw P.increment))) := by
    apply (integrable_cascade_coordinates P.ranks (gaussianReal 0 P.root) (rowGaussianLaw P.increment) hf hg heq).mpr
    simpa only [hlaw,rowReplicaEnvironmentLaw] using hgi
  have he := integral_cascade_coordinates P.ranks (gaussianReal 0 P.root) (rowGaussianLaw P.increment) hf hg heq
  rw [hlaw] at he
  calc
    _ = ∫ ω, g ω ∂rowReplicaEnvironmentLaw P.ranks P.increment P.root := by
      apply integral_congr_ae
      exact Eventually.of_forall (fun ω => congrArg Real.log (rowResidual_partition_pointwise ht P.ranks P.residual ω))
    _ = ∫ z, f z ∂(gaussianReal 0 P.root).prod (familyCascadeLaw P.ranks.length (rowGaussianLaw P.increment)) := he.symm
    _ = ∫ x, gaussianRowComposition (rowGaussianBlocks P.ranks P.increment) v x ∂gaussianReal 0 P.root := by
      rw [integral_prod _ hfi]
      apply integral_congr_ae
      exact Eventually.of_forall (familyCoordinate_log_expectation hv P.ranks P.ordered P.valid P.increment)
    _ = P.functional u := by
      obtain ⟨K,hK⟩ := rowBoundedComposition_terminal hv (rowGaussianBlocks P.ranks P.increment)
        (rowGaussianBlocks_valid P.ranks (fun a ha => ⟨(P.valid a ha).1.le,(P.valid a ha).2.le⟩) P.increment)
      rw [rowGaussian_integral P.root hK.diff.continuous.measurable]
      simp only [RowFiniteProfile.functional,gaussianRowComposition,gaussianRowOperator,gaussianHeat,zero_add]
      rw [gaussianRowComposition_append_eq]
      rfl
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped Topology NNReal ENNReal

namespace MicroscopicJamming
abbrev RowProfile (Q : ℝ) := {q : SphericalProfile // q.val 1 ≤ Q}
def rowUnitClip (t : ℝ) : ℝ := max 0 (min 1 t)
lemma rowUnitClip_mem (t : ℝ) : rowUnitClip t ∈ Set.Icc (0:ℝ) 1 := by
  exact ⟨le_max_left _ _,max_le (by norm_num) (min_le_left _ _)⟩
lemma rowUnitClip_eq {t : ℝ} (ht : t ∈ Set.Icc (0:ℝ) 1) : rowUnitClip t=t := by
  simp [rowUnitClip,min_eq_right ht.2,max_eq_right ht.1]
 

def rowProfileMix {Q : ℝ} (q r : RowProfile Q) (t : ℝ) : RowProfile Q :=
  ⟨{val := fun s => (1-rowUnitClip t)*q.1.val s+rowUnitClip t*r.1.val s
    mono := by
      intro a ha b hb hab
      exact add_le_add (mul_le_mul_of_nonneg_left (q.1.mono ha hb hab) (sub_nonneg.mpr (rowUnitClip_mem t).2))
        (mul_le_mul_of_nonneg_left (r.1.mono ha hb hab) (rowUnitClip_mem t).1)
    nonneg := by
      intro s hs
      exact add_nonneg (mul_nonneg (sub_nonneg.mpr (rowUnitClip_mem t).2) (q.1.nonneg s hs))
        (mul_nonneg (rowUnitClip_mem t).1 (r.1.nonneg s hs))},by
      have h1 := mul_le_mul_of_nonneg_left q.2 (sub_nonneg.mpr (rowUnitClip_mem t).2)
      have h2 := mul_le_mul_of_nonneg_left r.2 (rowUnitClip_mem t).1
      dsimp
      nlinarith⟩
 

def RowGeneralInterpolationStatement : Prop :=
  ∀ (u : ℝ → ℝ) (L H : ℝ), ContDiff ℝ 2 u → 0 ≤ L → 0 ≤ H →
    (∀ x, |deriv u x| ≤ L ∧ |deriv (deriv u) x| ≤ H) →
  ∀ Q : ℝ, ∃ (Phi : RowProfile Q → ℝ) (D : RowProfile Q → SphericalProfile),
    (∀ q s, s ∈ Set.Icc 0 1 → (D q).val s ≤ L^2) ∧
    (∀ (q : RowProfile Q) (P : ℕ → RowFiniteProfile Q),
      Tendsto (fun n => sphericalProfileDistance (P n).profile.val q.1.val) atTop (𝓝 0) →
      Tendsto (fun n => (P n).functional u) atTop (𝓝 (Phi q)) ∧
      Tendsto (fun n => sphericalProfileDistance ((P n).derivative u) (D q).val) atTop (𝓝 0)) ∧
    (∀ (q : RowProfile Q) (qn : ℕ → RowProfile Q),
      Tendsto (fun n => sphericalProfileDistance (qn n).1.val q.1.val) atTop (𝓝 0) →
      Tendsto (fun n => Phi (qn n)) atTop (𝓝 (Phi q)) ∧
      Tendsto (fun n => sphericalProfileDistance (D (qn n)).val (D q).val) atTop (𝓝 0)) ∧
    (∀ q r : RowProfile Q, ∀ t ∈ Set.Icc (0:ℝ) 1,
      HasDerivWithinAt (fun v => Phi (rowProfileMix q r v))
        (-(1/2:ℝ)*(∫ s in (0:ℝ)..1, (r.1.val s-q.1.val s)*(D (rowProfileMix q r t)).val s))
        (Set.Icc (0:ℝ) 1) t) ∧
    (∀ q r : RowProfile Q, |Phi q-Phi r| ≤ (1/2:ℝ)*L^2*sphericalProfileDistance q.1.val r.1.val) ∧
    (∀ q : RowProfile Q, ∀ a b c : ℝ, 0 ≤ a → a < b → b ≤ 1 →
      (∀ᵐ s ∂volume.restrict (Set.Ioo a b), q.1.val s=c) →
      ∃ d : ℝ, ∀ᵐ s ∂volume.restrict (Set.Ioo a b), (D q).val s=d)
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped Topology NNReal ENNReal BigOperators

namespace MicroscopicJamming
lemma rowUnitClip_continuous : Continuous rowUnitClip := continuous_const.max (continuous_const.min continuous_id)
lemma rowProfileMix_zero {Q : ℝ} (q r : RowProfile Q) : rowProfileMix q r 0=q := by
  apply Subtype.ext
  apply sphericalProfile_ext
  funext s
  simp [rowProfileMix,rowUnitClip]
lemma rowProfileMix_one {Q : ℝ} (q r : RowProfile Q) : rowProfileMix q r 1=r := by
  apply Subtype.ext
  apply sphericalProfile_ext
  funext s
  simp [rowProfileMix,rowUnitClip]

lemma rowFiniteProfile_top_le {Q : ℝ} (P : RowFiniteProfile Q) : P.profile.val 1 ≤ Q := by
  have hs : P.profile.val 1 = (P.root:ℝ)+∑ j : Fin P.ranks.length, (P.increment j:ℝ) := by
    rw [RowFiniteProfile.profile,rowCascadeProfile_sum _ P.ordered,rowGaussianBlocks_cumulative]
    congr 1
    apply Finset.sum_congr rfl
    intro j hj
    have hjm : P.ranks[j.val]! ∈ P.ranks := by
      rw [getElem!_pos P.ranks j.val j.isLt]
      exact List.getElem_mem j.isLt
    rw [ite_eq_left (P.valid _ hjm).2.le]
  rw [hs]
  have hd := P.diagonal
  simp only [rowReplicaDiagonal,NNReal.coe_add,NNReal.coe_sum] at hd
  linarith [P.residual.coe_nonneg]

def RowFiniteProfile.asProfile {Q : ℝ} (P : RowFiniteProfile Q) : RowProfile Q := ⟨P.profile,rowFiniteProfile_top_le P⟩

lemma rowProfileMix_distance {Q : ℝ} (q r p v : RowProfile Q) (t : ℝ) :
    sphericalProfileDistance (rowProfileMix q r t).1.val (rowProfileMix p v t).1.val ≤
      (1-rowUnitClip t)*sphericalProfileDistance q.1.val p.1.val +
        rowUnitClip t*sphericalProfileDistance r.1.val v.1.val := by
  unfold sphericalProfileDistance
  rw [← intervalIntegral.integral_const_mul,← intervalIntegral.integral_const_mul,
    ←intervalIntegral.integral_add ((q.1.integrable.sub p.1.integrable).abs.const_mul _)
      ((r.1.integrable.sub v.1.integrable).abs.const_mul _)]
  apply intervalIntegral.integral_mono_on (by norm_num)
    ((rowProfileMix q r t).1.integrable.sub (rowProfileMix p v t).1.integrable).abs
    (((q.1.integrable.sub p.1.integrable).abs.const_mul _).add ((r.1.integrable.sub v.1.integrable).abs.const_mul _))
  intro s hs
  change |(1-rowUnitClip t)*q.1.val s+rowUnitClip t*r.1.val s-
    ((1-rowUnitClip t)*p.1.val s+rowUnitClip t*v.1.val s)| ≤ _
  calc
    _ = |(1-rowUnitClip t)*(q.1.val s-p.1.val s)+rowUnitClip t*(r.1.val s-v.1.val s)| := by congr 1; ring
    _ ≤ |(1-rowUnitClip t)*(q.1.val s-p.1.val s)|+|rowUnitClip t*(r.1.val s-v.1.val s)| := abs_add_le _ _
    _ = _ := by rw [abs_mul,abs_mul,abs_of_nonneg (sub_nonneg.mpr (rowUnitClip_mem t).2),abs_of_nonneg (rowUnitClip_mem t).1]

lemma rowProfileMix_parameter_distance {Q : ℝ} (q r : RowProfile Q) (t v : ℝ) :
    sphericalProfileDistance (rowProfileMix q r t).1.val (rowProfileMix q r v).1.val =
      |rowUnitClip t-rowUnitClip v| *sphericalProfileDistance r.1.val q.1.val := by
  unfold sphericalProfileDistance
  rw [←intervalIntegral.integral_const_mul]
  apply intervalIntegral.integral_congr
  intro s hs
  change |(1-rowUnitClip t)*q.1.val s+rowUnitClip t*r.1.val s-
    ((1-rowUnitClip v)*q.1.val s+rowUnitClip v*r.1.val s)| = _
  dsimp only
  rw [←abs_mul]
  congr 1
  ring

lemma rowProfileMix_parameter_tendsto {Q : ℝ} (q r : RowProfile Q) {t : ℝ} {ts : ℕ → ℝ}
    (ht : Tendsto ts atTop (𝓝 t)) :
    Tendsto (fun n => sphericalProfileDistance (rowProfileMix q r (ts n)).1.val (rowProfileMix q r t).1.val) atTop (𝓝 0) := by
  simp_rw [rowProfileMix_parameter_distance]
  simpa using (((rowUnitClip_continuous.tendsto t).comp ht).sub (tendsto_const_nhds (x := rowUnitClip t))).abs.mul_const
    (sphericalProfileDistance r.1.val q.1.val)
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped Topology NNReal ENNReal BigOperators

namespace MicroscopicJamming
lemma rowFunctional_converges {u : ℝ → ℝ} {L H : ℝ} (hu : ContDiff ℝ 2 u)
    (hL : 0 ≤ L) (hH : 0 ≤ H) (hb : ∀ x, |deriv u x| ≤ L ∧ |deriv (deriv u) x| ≤ H)
    {Q : ℝ} (P : ℕ → RowFiniteProfile Q) (q : RowProfile Q)
    (hP : Tendsto (fun n => sphericalProfileDistance (P n).profile.val q.1.val) atTop (𝓝 0)) :
    ∃ b : ℝ, Tendsto (fun n => (P n).functional u) atTop (𝓝 b) := by
  simpa only [rowFiniteFunctional u L H hu hL hH hb] using rowLog_converges hu hL hH hb P q.1 q.2 hP

lemma rowFunctionalLimits_eq {u : ℝ → ℝ} {L H : ℝ} (hu : ContDiff ℝ 2 u)
    (hL : 0 ≤ L) (hH : 0 ≤ H) (hb : ∀ x, |deriv u x| ≤ L ∧ |deriv (deriv u) x| ≤ H)
    {Q : ℝ} (P R : ℕ → RowFiniteProfile Q) (q : RowProfile Q) {a b : ℝ}
    (hP : Tendsto (fun n => sphericalProfileDistance (P n).profile.val q.1.val) atTop (𝓝 0))
    (hR : Tendsto (fun n => sphericalProfileDistance (R n).profile.val q.1.val) atTop (𝓝 0))
    (hPa : Tendsto (fun n => (P n).functional u) atTop (𝓝 a))
    (hRb : Tendsto (fun n => (R n).functional u) atTop (𝓝 b)) : a=b := by
  let Z : ℕ → RowFiniteProfile Q := fun n => if n%2=0 then P n else R n
  have hZ : Tendsto (fun n => sphericalProfileDistance (Z n).profile.val q.1.val) atTop (𝓝 0) := by
    apply squeeze_zero (fun n => sphericalProfileDistance_nonneg _ _) (fun n => ?_)
      (show Tendsto (fun n => sphericalProfileDistance (P n).profile.val q.1.val +
        sphericalProfileDistance (R n).profile.val q.1.val) atTop (𝓝 0) by simpa using hP.add hR)
    dsimp [Z]
    split_ifs
    · exact le_add_of_nonneg_right (sphericalProfileDistance_nonneg _ _)
    · exact le_add_of_nonneg_left (sphericalProfileDistance_nonneg _ _)
  obtain ⟨c,hc⟩ := rowFunctional_converges hu hL hH hb Z q hZ
  have hte : Tendsto (fun n : ℕ => 2*n) atTop atTop := tendsto_atTop_mono (fun n => by dsimp; omega) tendsto_id
  have hto : Tendsto (fun n : ℕ => 2*n+1) atTop atTop := tendsto_atTop_mono (fun n => by dsimp; omega) tendsto_id
  have he : ∀ n, Z (2*n) = P (2*n) := by intro n; simp [Z]
  have ho : ∀ n, Z (2*n+1) = R (2*n+1) := by intro n; simp [Z,Nat.add_mod]
  have ha : a=c := tendsto_nhds_unique (hPa.comp hte) (by simpa only [Function.comp_def,he] using hc.comp hte)
  have hb' : b=c := tendsto_nhds_unique (hRb.comp hto) (by simpa only [Function.comp_def,ho] using hc.comp hto)
  exact ha.trans hb'.symm

lemma rowGeneralFunctional {u : ℝ → ℝ} {L H : ℝ} (hu : ContDiff ℝ 2 u)
    (hL : 0 ≤ L) (hH : 0 ≤ H) (hb : ∀ x, |deriv u x| ≤ L ∧ |deriv (deriv u) x| ≤ H)
    (Q : ℝ) : ∃ Phi : RowProfile Q → ℝ,
    (∀ (q : RowProfile Q) (P : ℕ → RowFiniteProfile Q),
      Tendsto (fun n => sphericalProfileDistance (P n).profile.val q.1.val) atTop (𝓝 0) →
      Tendsto (fun n => (P n).functional u) atTop (𝓝 (Phi q))) ∧
    (∀ (q : RowProfile Q) (qn : ℕ → RowProfile Q),
      Tendsto (fun n => sphericalProfileDistance (qn n).1.val q.1.val) atTop (𝓝 0) →
      Tendsto (fun n => Phi (qn n)) atTop (𝓝 (Phi q))) := by
  have hex (q : RowProfile Q) := rowFunctional_converges hu hL hH hb (q.1.rowGrid q.2) q (rowGrid_distance_tendsto q.1 q.2)
  choose Phi hPhi using hex
  have hall (q : RowProfile Q) (P : ℕ → RowFiniteProfile Q)
      (hP : Tendsto (fun n => sphericalProfileDistance (P n).profile.val q.1.val) atTop (𝓝 0)) :
      Tendsto (fun n => (P n).functional u) atTop (𝓝 (Phi q)) := by
    obtain ⟨a,ha⟩ := rowFunctional_converges hu hL hH hb P q hP
    have he := rowFunctionalLimits_eq hu hL hH hb P (q.1.rowGrid q.2) q hP (rowGrid_distance_tendsto q.1 q.2) ha (hPhi q)
    rwa [he] at ha
  refine ⟨Phi,hall,?_⟩
  intro q qn hqn
  have hchoose (n : ℕ) : ∃ k : ℕ,
      sphericalProfileDistance ((qn n).1.rowGrid (qn n).2 k).profile.val (qn n).1.val < 1/((n:ℝ)+1) ∧
      |((qn n).1.rowGrid (qn n).2 k).functional u-Phi (qn n)| < 1/((n:ℝ)+1) := by
    have he : (0:ℝ) < 1/((n:ℝ)+1) := by positivity
    have hlim : Tendsto (fun k => |((qn n).1.rowGrid (qn n).2 k).functional u-Phi (qn n)|) atTop (𝓝 0) := by
      simpa using ((hPhi (qn n)).sub (tendsto_const_nhds (x := Phi (qn n)))).abs
    exact (((tendsto_order.mp (rowGrid_distance_tendsto (qn n).1 (qn n).2)).2 _ he).and
      ((tendsto_order.mp hlim).2 _ he)).exists
  choose k hk1 hk2 using hchoose
  let P : ℕ → RowFiniteProfile Q := fun n => (qn n).1.rowGrid (qn n).2 (k n)
  have hP : Tendsto (fun n => sphericalProfileDistance (P n).profile.val q.1.val) atTop (𝓝 0) := by
    apply squeeze_zero (fun n => sphericalProfileDistance_nonneg _ _) (fun n => ?_)
      (show Tendsto (fun n : ℕ => 1/((n:ℝ)+1)+sphericalProfileDistance (qn n).1.val q.1.val) atTop (𝓝 0)
        by simpa using rowPrecision_tendsto.add hqn)
    exact (sphericalProfileDistance_triangle (P n).profile (qn n).1 q.1).trans (add_le_add (hk1 n).le le_rfl)
  have hlim : Tendsto (fun n => Phi (qn n)-(P n).functional u) atTop (𝓝 0) := by
    apply squeeze_zero_norm (fun n => ?_) rowPrecision_tendsto
    simpa only [Real.norm_eq_abs,abs_sub_comm] using (hk2 n).le
  have hh := hlim.add (hall q P hP)
  simpa only [sub_add_cancel,zero_add] using hh
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped Topology NNReal ENNReal BigOperators

namespace MicroscopicJamming
lemma rowProfile_mul_integrable (p q : SphericalProfile) :
    IntervalIntegrable (fun s => p.val s*q.val s) volume 0 1 := by
  rw [intervalIntegrable_iff_integrableOn_Ioc_of_le (by norm_num : (0:ℝ)≤1)]
  have hi := q.integrable.1
  apply p.integrable.1.mul_bdd hi.aestronglyMeasurable
  filter_upwards [ae_restrict_mem measurableSet_Ioc] with s hs
  rw [Real.norm_eq_abs,abs_of_nonneg (q.nonneg s ⟨hs.1.le,hs.2⟩)]
  exact q.mono ⟨hs.1.le,hs.2⟩ (by norm_num) hs.2

lemma rowDirection_integrable (q r D : SphericalProfile) :
    IntervalIntegrable (fun s => (r.val s-q.val s)*D.val s) volume 0 1 := by
  simpa only [sub_mul] using (rowProfile_mul_integrable r D).sub (rowProfile_mul_integrable q D)

def rowDirectionPairing (q r D : SphericalProfile) : ℝ :=
  ∫ s in (0:ℝ)..1, (r.val s-q.val s)*D.val s

lemma rowDirectionPairing_bound (q r D : SphericalProfile) {B : ℝ}
    (hD : ∀ s ∈ Set.Icc (0:ℝ) 1, D.val s ≤ B) :
    |rowDirectionPairing q r D| ≤ B*sphericalProfileDistance r.val q.val := by
  unfold rowDirectionPairing sphericalProfileDistance
  rw [←intervalIntegral.integral_const_mul]
  refine (intervalIntegral.abs_integral_le_integral_abs (by norm_num)).trans ?_
  apply intervalIntegral.integral_mono_on (by norm_num) (rowDirection_integrable q r D).abs
    ((r.integrable.sub q.integrable).abs.const_mul B)
  intro s hs
  try dsimp only
  rw [abs_mul,abs_of_nonneg (D.nonneg s hs)]
  nlinarith [abs_nonneg (r.val s-q.val s),hD s hs]

lemma rowDirectionPairing_difference_bound (q r p v D E : SphericalProfile) {B C : ℝ}
    (hD : ∀ s ∈ Set.Icc (0:ℝ) 1, D.val s ≤ B)
    (hpv : ∀ s ∈ Set.Icc (0:ℝ) 1, |v.val s-p.val s| ≤ C) :
    |rowDirectionPairing q r D-rowDirectionPairing p v E| ≤
      B*(sphericalProfileDistance r.val v.val+sphericalProfileDistance q.val p.val)+
        C*sphericalProfileDistance D.val E.val := by
  unfold rowDirectionPairing sphericalProfileDistance
  rw [←intervalIntegral.integral_sub (rowDirection_integrable q r D) (rowDirection_integrable p v E)]
  rw [mul_add,←intervalIntegral.integral_const_mul,←intervalIntegral.integral_const_mul,
    ←intervalIntegral.integral_const_mul]
  rw [←intervalIntegral.integral_add ((r.integrable.sub v.integrable).abs.const_mul B)
    ((q.integrable.sub p.integrable).abs.const_mul B)]
  rw [←intervalIntegral.integral_add
    (((r.integrable.sub v.integrable).abs.const_mul B).add ((q.integrable.sub p.integrable).abs.const_mul B))
    ((D.integrable.sub E.integrable).abs.const_mul C)]
  refine (intervalIntegral.abs_integral_le_integral_abs (by norm_num)).trans ?_
  apply intervalIntegral.integral_mono_on (by norm_num)
    ((rowDirection_integrable q r D).sub (rowDirection_integrable p v E)).abs
    ((((r.integrable.sub v.integrable).abs.const_mul B).add ((q.integrable.sub p.integrable).abs.const_mul B)).add ((D.integrable.sub E.integrable).abs.const_mul C))
  intro s hs
  try dsimp only
  have hd := D.nonneg s hs
  calc
    _ = |((r.val s-v.val s)-(q.val s-p.val s))*D.val s+(v.val s-p.val s)*(D.val s-E.val s)| := by congr 1; ring
    _ ≤ |((r.val s-v.val s)-(q.val s-p.val s))*D.val s|+|(v.val s-p.val s)*(D.val s-E.val s)| := abs_add_le _ _
    _ = |(r.val s-v.val s)-(q.val s-p.val s)| *D.val s+|v.val s-p.val s| *|D.val s-E.val s| := by rw [abs_mul,abs_mul,abs_of_nonneg hd]
    _ ≤ (|r.val s-v.val s|+|q.val s-p.val s|)*D.val s+C*|D.val s-E.val s| :=
      add_le_add (mul_le_mul_of_nonneg_right (abs_sub _ _) hd)
        (mul_le_mul_of_nonneg_right (hpv s hs) (abs_nonneg _))
    _ ≤ (|r.val s-v.val s|+|q.val s-p.val s|)*B+C*|D.val s-E.val s| :=
      add_le_add (mul_le_mul_of_nonneg_left (hD s hs) (add_nonneg (abs_nonneg _) (abs_nonneg _))) le_rfl
    _ = _ := by ring

lemma rowProfile_difference_bound {Q : ℝ} (q r : RowProfile Q) {s : ℝ} (hs : s ∈ Set.Icc (0:ℝ) 1) :
    |r.1.val s-q.1.val s| ≤ Q := by
  have hq := (q.1.mono hs (by norm_num) hs.2).trans q.2
  have hr := (r.1.mono hs (by norm_num) hs.2).trans r.2
  exact abs_le.mpr ⟨by linarith [r.1.nonneg s hs],by linarith [q.1.nonneg s hs]⟩

lemma rowDirectionPairing_tendsto {Q B : ℝ} (q r : RowProfile Q) (D : SphericalProfile)
    (qn rn : ℕ → RowProfile Q) (Dn : ℕ → SphericalProfile)
    (hD : ∀ n s, s ∈ Set.Icc (0:ℝ) 1 → (Dn n).val s ≤ B)
    (hq : Tendsto (fun n => sphericalProfileDistance (qn n).1.val q.1.val) atTop (𝓝 0))
    (hr : Tendsto (fun n => sphericalProfileDistance (rn n).1.val r.1.val) atTop (𝓝 0))
    (hd : Tendsto (fun n => sphericalProfileDistance (Dn n).val D.val) atTop (𝓝 0)) :
    Tendsto (fun n => rowDirectionPairing (qn n).1 (rn n).1 (Dn n)) atTop (𝓝 (rowDirectionPairing q.1 r.1 D)) := by
  apply (tendsto_iff_norm_sub_tendsto_zero).mpr
  apply squeeze_zero (fun n => norm_nonneg _) (fun n => ?_)
    (show Tendsto (fun n => B*(sphericalProfileDistance (rn n).1.val r.1.val+sphericalProfileDistance (qn n).1.val q.1.val)+Q*sphericalProfileDistance (Dn n).val D.val) atTop (𝓝 0) by
      simpa using ((hr.add hq).const_mul B).add (hd.const_mul Q))
  rw [Real.norm_eq_abs]
  exact rowDirectionPairing_difference_bound _ _ _ _ _ _ (hD n) (fun s hs => rowProfile_difference_bound q r hs)
end MicroscopicJamming

end

end OAI