import Mathlib
import OAI.Probability.JammingConcavity.RPCPatternInsertionEvents

namespace OAI

/-! R P C Rank Uniqueness. -/

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 Filter Set
open scoped Topology BigOperators

namespace MicroscopicJamming

lemma measurable_rpcStepLevel (ms : List ℝ) : Measurable (rpcStepLevel ms) := by
  induction ms with
  | nil => change Measurable (fun _ : ℝ => (0:ℕ)); exact measurable_const
  | cons m ms ih =>
    have he : rpcStepLevel (m::ms) = fun u => if m≤u then rpcStepLevel ms u+1 else rpcStepLevel ms u := by
      funext u
      simp only [rpcStepLevel,List.filter_cons,decide_eq_true_eq]
      split_ifs <;> simp
    rw [he]
    exact Measurable.ite (measurableSet_le measurable_const measurable_id) (ih.add_const 1) ih

lemma measurable_rankCovarianceArray (ms : List ℝ) (q : ℕ → ℝ) (Q : ℝ) :
    Measurable (rankCovarianceArray ms q Q) := by
  apply Measurable.of_eval
  intro i
  apply Measurable.of_eval
  intro j
  by_cases hij : i=j
  · simp only [rankCovarianceArray,ite_eq_left hij]
    exact measurable_const
  · simp only [rankCovarianceArray,ite_eq_right hij]
    exact (measurable_of_countable q).comp ((measurable_rpcStepLevel ms).comp (by fun_prop))

def rankMeshArray (n : ℕ) : RankArray → RankArray :=
  rankCovarianceArray (rankMesh n) (fun i => (i:ℝ)/((n:ℝ)+1)) 1

lemma measurable_rankMeshArray (n : ℕ) : Measurable (rankMeshArray n) :=
  measurable_rankCovarianceArray _ _ _

lemma rankMeshArray_tendsto {U : RankArray} (hb : ∀ i j, U i j ∈ Set.Icc (0:ℝ) 1)
    (hd : ∀ i, U i i=1) : Tendsto (fun n => rankMeshArray n U) atTop (𝓝 U) := by
  apply tendsto_pi_nhds.mpr
  intro i
  apply tendsto_pi_nhds.mpr
  intro j
  by_cases hij : i=j
  · subst j
    simp only [rankMeshArray,rankCovarianceArray,ite_true,hd]
    exact tendsto_const_nhds
  · simpa only [rankMeshArray,rankCovarianceArray,ite_eq_right hij,rankMeshValue] using
      rankMeshValue_tendsto (hb i j)

lemma hasRPC_rankMesh_law {μ ν : Measure RankArray} (hμ : HasRPCFiniteRankLaws μ)
    (hν : HasRPCFiniteRankLaws ν) (n : ℕ) : μ.map (rankMeshArray n)=ν.map (rankMeshArray n) := by
  have hq0 : (0:ℝ)≤(0:ℕ)/((n:ℝ)+1) := by positivity
  have hqmon : ∀ i j : ℕ, i≤j → j≤(rankMesh n).length →
      (i:ℝ)/((n:ℝ)+1)≤(j:ℝ)/((n:ℝ)+1) := by
    intro i j hij _
    exact div_le_div_of_nonneg_right (by exact_mod_cast hij) (by positivity)
  have hqtop : ((rankMesh n).length:ℝ)/((n:ℝ)+1)≤1 := by
    simp only [rankMesh,List.length_map,List.length_range]
    rw [div_le_one (by positivity)]
    linarith
  exact (hμ _ (rankMesh_increasing n) (rankMesh_valid n) _ 1 hq0 hqmon hqtop).trans
    (hν _ (rankMesh_increasing n) (rankMesh_valid n) _ 1 hq0 hqmon hqtop).symm

 

theorem rpcRankLaw_unique (μ ν : Measure RankArray) [IsProbabilityMeasure μ] [IsProbabilityMeasure ν]
    (hbμ : ∀ᵐ U ∂μ, ∀ i j, 0≤U i j ∧ U i j≤1)
    (hbν : ∀ᵐ U ∂ν, ∀ i j, 0≤U i j ∧ U i j≤1)
    (hdμ : ∀ᵐ U ∂μ, ∀ i, U i i=1) (hdν : ∀ᵐ U ∂ν, ∀ i, U i i=1)
    (hrμ : HasRPCFiniteRankLaws μ) (hrν : HasRPCFiniteRankLaws ν) : μ=ν := by
  apply ext_of_forall_integral_eq_of_IsFiniteMeasure
  intro f
  have hlim (ξ : Measure RankArray) [IsProbabilityMeasure ξ]
      (hb : ∀ᵐ U ∂ξ, ∀ i j, 0≤U i j ∧ U i j≤1)
      (hd : ∀ᵐ U ∂ξ, ∀ i, U i i=1) :
      Tendsto (fun n => ∫ U, f (rankMeshArray n U) ∂ξ) atTop (𝓝 (∫ U, f U ∂ξ)) := by
    apply tendsto_integral_of_dominated_convergence (fun _ => ‖f‖)
    · intro n
      exact (f.continuous.measurable.comp (measurable_rankMeshArray n)).aestronglyMeasurable
    · exact integrable_const _
    · intro n
      exact ae_of_all _ fun U => f.norm_coe_le_norm _
    · filter_upwards [hb,hd] with U hb hd
      exact f.continuous.continuousAt.tendsto.comp (rankMeshArray_tendsto hb hd)
  have he (n : ℕ) : (∫ U, f (rankMeshArray n U) ∂μ)=(∫ U, f (rankMeshArray n U) ∂ν) := by
    rw [← integral_map (measurable_rankMeshArray n).aemeasurable f.continuous.aestronglyMeasurable,
      ← integral_map (measurable_rankMeshArray n).aemeasurable f.continuous.aestronglyMeasurable,
      hasRPC_rankMesh_law hrμ hrν]
  have hm := hlim μ hbμ hdμ
  simp_rw [he] at hm
  exact tendsto_nhds_unique hm (hlim ν hbν hdν)
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set
open scoped ENNReal NNReal BigOperators Classical

namespace MicroscopicJamming

def rankLabelEvent {n : ℕ} (ms : List ℝ) (h : PatternLabelling ms.length n) :
    Set (Fin (n+1) → Fin (n+1) → ℝ) := {R | ∀ i j, rpcStepLevel ms (R i j)=h.signature i j}

lemma measurableSet_rankLabelEvent {n : ℕ} (ms : List ℝ) (h : PatternLabelling ms.length n) :
    MeasurableSet (rankLabelEvent ms h) := by
  simp only [rankLabelEvent,ofPred_forall]
  apply MeasurableSet.iInter
  intro i
  apply MeasurableSet.iInter
  intro j
  exact measurableSet_eq_fun ((measurable_rpcStepLevel ms).comp (by fun_prop)) measurable_const

lemma rankLabelEvent_iff_sample {n : ℕ} {R : Fin (n+1) → Fin (n+1) → ℝ}
    (hR : FiniteRank R) (ms : List ℝ) (hms : ms.Pairwise (· < ·))
    (h01 : ∀ m ∈ ms, m ≤ 1) (h : PatternLabelling ms.length n)
    (hh : ValidReplicaPattern ms.length h.pattern) :
    R ∈ rankLabelEvent ms h ↔ RPCSamplePattern ms.length h.pattern
      (fun j => rankProfilePath ms (R (h.index.symm j))) := by
  rw [h.sample_iff_signature hh (fun i => rankProfilePath ms (R i))]
  exact forall_congr' fun i => forall_congr' fun j => by
    rw [rankProfilePath_rows hR ms hms h01]

lemma cascadeSharedEdges_symm (k : ℕ) (x y : CascadePath k) :
    cascadeSharedEdges k x y=cascadeSharedEdges k y x := by
  induction k with
  | zero => rfl
  | succ k ih =>
    simp only [cascadeSharedEdges]
    by_cases h : x.1=y.1
    · rw [ite_eq_left h,ite_eq_left h.symm,ih]
    · rw [ite_eq_right h,ite_eq_right (Ne.symm h)]

def rankMixedSample {n : ℕ} (R : Fin (n+1) → Fin (n+1) → ℝ) (ms : List ℝ)
    (z : Fin (n+1) × ℝ) : Fin (n+2) → CascadePath ms.length :=
  Fin.lastCases (rankProfilePath ms (rankLink R z.1 z.2)) (fun i => rankProfilePath ms (R i))

lemma rankMixedSample_signature {n : ℕ} {R : Fin (n+1) → Fin (n+1) → ℝ}
    (hR : FiniteRank R) (ms : List ℝ) (hms : ms.Pairwise (· < ·))
    (h01 : ∀ m ∈ ms, m ≤ 1) (z : Fin (n+1) × ℝ) (i j : Fin (n+2)) :
    cascadeSharedEdges ms.length (rankMixedSample R ms z i) (rankMixedSample R ms z j)=
      rpcStepLevel ms (rankInsert R z.1 z.2 i j) := by
  refine Fin.lastCases ?_ (fun i => ?_) i <;> refine Fin.lastCases ?_ (fun j => ?_) j
  all_goals simp only [rankMixedSample,rankInsert,Fin.lastCases_last,Fin.lastCases_castSucc]
  · rw [cascadeSharedEdges_self]
    unfold rpcStepLevel
    rw [List.filter_eq_self.mpr (fun m hm => by simpa using h01 m hm)]
  · exact rankProfilePath_link hR ms hms h01 j z.1 z.2
  · rw [cascadeSharedEdges_symm]
    exact rankProfilePath_link hR ms hms h01 i z.1 z.2
  · exact rankProfilePath_rows hR ms hms h01 i j

lemma rankLabelEvent_insert_iff {n : ℕ} {R : Fin (n+1) → Fin (n+1) → ℝ}
    (hR : FiniteRank R) (ms : List ℝ) (hms : ms.Pairwise (· < ·))
    (h01 : ∀ m ∈ ms, m ≤ 1) (h : PatternLabelling ms.length n)
    (hh : ValidReplicaPattern ms.length h.pattern) (s : PatternSite ms.length h.pattern)
    (z : Fin (n+1) × ℝ) :
    rankInsert R z.1 z.2 ∈ rankLabelEvent ms (h.extend s) ↔
      RPCSamplePattern ms.length (patternExtension ms.length h.pattern s).next
        (insertedSample (patternExtension ms.length h.pattern s)
          (fun j => rankProfilePath ms (R (h.index.symm j))) (rankProfilePath ms (rankLink R z.1 z.2))) := by
  have he := h.extend_sample s (rankMixedSample R ms z)
  simp only [rankMixedSample,Fin.lastCases_castSucc,Fin.lastCases_last] at he
  rw [he]
  change _ ↔ RPCSamplePattern ms.length (h.extend s).pattern
    (fun j => rankMixedSample R ms z ((h.extend s).index.symm j))
  rw [(h.extend s).sample_iff_signature (patternExtension_valid_generic _ _ hh s) (rankMixedSample R ms z)]
  exact forall_congr' fun i => forall_congr' fun j => by
    rw [rankMixedSample_signature hR ms hms h01]

lemma rankLabelEvent_insert_parent {n : ℕ} {R : Fin (n+1) → Fin (n+1) → ℝ}
    (hR : FiniteRank R) (ms : List ℝ) (hms : ms.Pairwise (· < ·))
    (h01 : ∀ m ∈ ms, m ≤ 1) (h : PatternLabelling ms.length n)
    (hh : ValidReplicaPattern ms.length h.pattern) (s : PatternSite ms.length h.pattern)
    (z : Fin (n+1) × ℝ) (hz : rankInsert R z.1 z.2 ∈ rankLabelEvent ms (h.extend s)) :
    R ∈ rankLabelEvent ms h := by
  have hn := (rankLabelEvent_insert_iff hR ms hms h01 h hh s z).mp hz
  exact (rankLabelEvent_iff_sample hR ms hms h01 h hh).mpr
    (rpcSamplePattern_delete _ _ hh s _ _ hn)

lemma rankLabelEvent_kernel {n : ℕ} {R : Fin (n+1) → Fin (n+1) → ℝ}
    (hR : FiniteRank R) (ms : List ℝ) (hms : ms.Pairwise (· < ·))
    (h01 : ∀ m ∈ ms, 0 < m ∧ m < 1) (h : PatternLabelling ms.length n)
    (hh : ValidReplicaPattern ms.length h.pattern) (s : PatternSite ms.length h.pattern) :
    (rankInnovationLaw n) {z | rankInsert R z.1 z.2 ∈ rankLabelEvent ms (h.extend s)} =
      if R ∈ rankLabelEvent ms h then ENNReal.ofReal (patternSiteWeight ms 0 h.pattern s/((n:ℝ)+1)) else 0 := by
  have hmax : ∀ m ∈ ms, m ≤ 1 := fun m hm => (h01 m hm).2.le
  by_cases hx : R ∈ rankLabelEvent ms h
  · rw [ite_eq_left hx]
    have he : {z : Fin (n+1) × ℝ | rankInsert R z.1 z.2 ∈ rankLabelEvent ms (h.extend s)} =
        rankPatternInsertEvent R ms 0 0 h.pattern h.index.symm s := by
      ext z
      change (rankInsert R z.1 z.2 ∈ rankLabelEvent ms (h.extend s)) ↔ _
      rw [rankLabelEvent_insert_iff hR ms hms hmax h hh s z]
      change _ ↔ 0 ≤ rankLink R z.1 z.2 0 ∧ _
      exact (and_iff_right (le_min (hR.2.2.1 0 z.1).1 (le_max_of_le_left (rankBirth_nonneg R z.1)))).symm
    rw [he]
    have hc (q : Fin (n+1)) : 0 ≤ R 0 q ↔ ∃ j, h.index.symm j=q := by
      exact iff_of_true (hR.2.2.1 0 q).1 (h.index.symm.surjective q)
    have hr := rankPatternInsertEvent_real hR ms hms h01 0 le_rfl zero_le_one
      (fun m hm => (h01 m hm).1) 0 h.pattern hh h.index.symm h.index.symm.injective hc
      ((rankLabelEvent_iff_sample hR ms hms hmax h hh).mp hx) s
    rw [← hr]
    exact (ENNReal.ofReal_toReal (measure_ne_top _ _)).symm
  · rw [ite_eq_right hx]
    have he : {z : Fin (n+1) × ℝ | rankInsert R z.1 z.2 ∈ rankLabelEvent ms (h.extend s)}=∅ := by
      ext z
      simp only [mem_ofPred_eq,mem_empty_iff_false,iff_false]
      intro hz
      exact hx (rankLabelEvent_insert_parent hR ms hms hmax h hh s z hz)
    rw [he,measure_empty]

end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set
open scoped ENNReal NNReal BigOperators Classical

namespace MicroscopicJamming

lemma rankGrowing_congr (n : ℕ) {z z' : RankSeed} (h : ∀ i < n, z i=z' i) :
    rankGrowing n z=rankGrowing n z' := by
  induction n with
  | zero => rfl
  | succ n ih =>
    simp only [rankGrowing,ih (fun i hi => h i (Nat.lt_succ_of_lt hi)),h n (Nat.lt_succ_self _)]

def rankPastEmbed (n : ℕ) (z : (i : ↑(Finset.range n)) → Fin (i.val+1) × ℝ) : RankSeed :=
  fun i => if h : i < n then z ⟨i,Finset.mem_range.mpr h⟩ else (0,0)

lemma continuous_rankPastEmbed (n : ℕ) : Continuous (rankPastEmbed n) := by
  apply continuous_pi
  intro i
  by_cases h : i < n
  · simpa only [rankPastEmbed,dite_eq_left h] using
      (continuous_apply (⟨i,Finset.mem_range.mpr h⟩ : ↑(Finset.range n)))
  · simpa only [rankPastEmbed,dite_eq_right h] using
      (continuous_const : Continuous (fun _ : (i : ↑(Finset.range n)) → Fin (i.val+1) × ℝ => ((0,0) : Fin (i+1) × ℝ)))

lemma rankGrowing_past (n : ℕ) (z : RankSeed) :
    rankGrowing n (rankPastEmbed n (fun i => z i))=rankGrowing n z := by
  apply rankGrowing_congr
  intro i hi
  simp [rankPastEmbed,hi]

lemma rankGrowing_indep_innovation (n : ℕ) :
    IndepFun (rankGrowing n) (fun z : RankSeed => z n) rankSeedLaw := by
  have hcoords : iIndepFun (fun i (z : RankSeed) => z i) rankSeedLaw :=
    iIndepFun_infinitePi (X := fun _ x => x) (by fun_prop)
  have hdis : Disjoint (Finset.range n) {n} := by simp
  have h := hcoords.indepFun_finset (Finset.range n) {n} hdis (fun _ => measurable_pi_apply _)
  have hc := h.comp ((continuous_rankGrowing n).comp (continuous_rankPastEmbed n)).measurable
    (measurable_pi_apply (⟨n,by simp⟩ : ↑({n} : Finset ℕ)))
  convert hc using 1
  · funext z
    exact (rankGrowing_past n z).symm
  · rfl

lemma rankGrowing_joint_law (n : ℕ) :
    rankSeedLaw.map (fun z => (rankGrowing n z,z n)) =
      (rankSeedLaw.map (rankGrowing n)).prod (rankInnovationLaw n) := by
  rw [(rankGrowing_indep_innovation n).map_prod_eq_prod_map_map
    (continuous_rankGrowing n).measurable.aemeasurable (measurable_pi_apply n).aemeasurable]
  congr 1
  exact Measure.infinitePi_map_eval rankInnovationLaw n

lemma rankGrowing_succ_law (n : ℕ) :
    rankSeedLaw.map (rankGrowing (n+1)) =
      ((rankSeedLaw.map (rankGrowing n)).prod (rankInnovationLaw n)).map
        (fun z => rankInsert z.1 z.2.1 z.2.2) := by
  rw [← rankGrowing_joint_law,Measure.map_map (continuous_rankInsert _).measurable
    ((continuous_rankGrowing n).measurable.prodMk (measurable_pi_apply n))]
  rfl

end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set
open scoped ENNReal NNReal BigOperators Classical

namespace MicroscopicJamming

lemma measurableSet_finiteRank (n : ℕ) :
    MeasurableSet {R : Fin n → Fin n → ℝ | FiniteRank R} := by
  simp only [FiniteRank,ofPred_and,ofPred_forall]
  apply MeasurableSet.inter
  · exact MeasurableSet.iInter fun i => measurableSet_eq_fun (by fun_prop) measurable_const
  · apply MeasurableSet.inter
    · exact MeasurableSet.iInter fun i => MeasurableSet.iInter fun j => measurableSet_eq_fun (by fun_prop) (by fun_prop)
    · apply MeasurableSet.inter
      · exact MeasurableSet.iInter fun i => MeasurableSet.iInter fun j =>
          (measurableSet_le measurable_const (by fun_prop)).inter (measurableSet_le (by fun_prop) measurable_const)
      · exact MeasurableSet.iInter fun i => MeasurableSet.iInter fun j => MeasurableSet.iInter fun k =>
          measurableSet_le (by fun_prop) (by fun_prop)

lemma rankGrowing_law_finiteRank (n : ℕ) :
    ∀ᵐ R ∂rankSeedLaw.map (rankGrowing n), FiniteRank R := by
  apply (ae_map_iff (continuous_rankGrowing n).measurable.aemeasurable (measurableSet_finiteRank (n+1))).mpr
  exact rankSeed_valid.mono fun z hz => rankGrowing_finiteRank hz n

lemma rankGrowing_pattern (ms : List ℝ) (hms : ms.Pairwise (· < ·))
    (h01 : ∀ m ∈ ms, 0 < m ∧ m < 1) {n : ℕ} (h : PatternLabelling ms.length n)
    (hh : ReachablePatternLabelling ms.length h) :
    (rankSeedLaw.map (rankGrowing n)) (rankLabelEvent ms h)=
      ENNReal.ofReal (rpcPatternProduct ms 0 h.pattern) := by
  induction hh with
  | singleton =>
    rw [Measure.map_apply (continuous_rankGrowing 0).measurable (measurableSet_rankLabelEvent ms _)]
    have hs : rankGrowing 0 ⁻¹' rankLabelEvent ms (PatternLabelling.singleton ms.length)=univ := by
      apply Set.eq_univ_of_forall
      intro z
      have hR : FiniteRank (rankGrowing 0 z) := by
        refine ⟨fun _ => rfl,fun _ _ => rfl,fun _ _ => ?_,fun _ _ _ => ?_⟩ <;> norm_num [rankGrowing]
      apply (rankLabelEvent_iff_sample hR ms hms (fun m hm => (h01 m hm).2.le) _
        (singletonReplicaPattern_valid _)).mpr
      exact rpcSamplePattern_singleton _ _
    rw [hs]
    simp [PatternLabelling.singleton,singletonReplicaPattern_product]
  | @extend n h hh s ih =>
    have hm := measurableSet_rankLabelEvent ms (h.extend s)
    have hf : Measurable (fun z : (Fin (n+1) → Fin (n+1) → ℝ) × (Fin (n+1) × ℝ) =>
        rankInsert z.1 z.2.1 z.2.2) := (continuous_rankInsert _).measurable
    rw [rankGrowing_succ_law,Measure.map_apply hf hm,Measure.prod_apply (hf hm)]
    have hp : (∫⁻ R, (rankInnovationLaw n) (Prod.mk R ⁻¹'
          ((fun z : (Fin (n+1) → Fin (n+1) → ℝ) × (Fin (n+1) × ℝ) =>
            rankInsert z.1 z.2.1 z.2.2) ⁻¹' rankLabelEvent ms (h.extend s)))
          ∂rankSeedLaw.map (rankGrowing n)) =
        ∫⁻ R, (rankLabelEvent ms h).indicator
          (fun _ => ENNReal.ofReal (patternSiteWeight ms 0 h.pattern s/((n:ℝ)+1))) R
          ∂rankSeedLaw.map (rankGrowing n) := by
      apply lintegral_congr_ae
      filter_upwards [rankGrowing_law_finiteRank n] with R hR
      exact rankLabelEvent_kernel hR ms hms h01 h hh.valid s
    rw [hp,lintegral_indicator_const (measurableSet_rankLabelEvent ms h),ih]
    have hp := (rpcInsertion_properties (patternExtension_insertion ms 0 h.pattern s) hms h01
      le_rfl zero_lt_one (fun m hm => (h01 m hm).1) hh.valid).2.2.2
    have hn := rpcPatternProduct_nonneg ms hms h01 0 (fun m hm => (h01 m hm).1) h.pattern
    change _=ENNReal.ofReal (rpcPatternProduct ms 0 (patternExtension ms.length h.pattern s).next)
    rw [hp,h.size,Nat.cast_add,Nat.cast_one,sub_zero,ENNReal.ofReal_mul hn,mul_comm]

end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology BigOperators

namespace MicroscopicJamming

def rankReindex (p : Equiv.Perm ℕ) (U : RankArray) : RankArray := fun i j => U (p i) (p j)
lemma measurable_rankReindex (p : Equiv.Perm ℕ) : Measurable (rankReindex p) := by
  unfold rankReindex
  fun_prop

lemma infinitePi_exchangeable {A : Type*} [MeasurableSpace A] (μ : Measure A)
    [IsProbabilityMeasure μ] (p : Equiv.Perm ℕ) :
    (Measure.infinitePi (fun _ : ℕ => μ)).map (fun x i => x (p i)) = Measure.infinitePi (fun _ : ℕ => μ) := by
  have h := Measure.infinitePi_map_piCongrLeft (fun _ : ℕ => μ) p.symm
  convert h using 1
  congr 1
  funext x i
  simp [MeasurableEquiv.piCongrLeft,Equiv.piCongrLeft_apply]

lemma cascadeReplicaLaw_exchangeable (ms : List ℝ) (p : Equiv.Perm ℕ) :
    (cascadeReplicaLaw ms).map (fun x i => x (p i)) = cascadeReplicaLaw ms := by
  let := cascadeLeafLaw_probability ms
  have hS : Measurable (fun x : ℕ → CascadePath ms.length => fun i => x (p i)) := by fun_prop
  ext A hA
  rw [Measure.map_apply hS hA,cascadeReplicaLaw,
    Measure.bind_apply (hS hA) (measurable_cascadeReplicaKernel ms).aemeasurable,
    Measure.bind_apply hA (measurable_cascadeReplicaKernel ms).aemeasurable]
  apply lintegral_congr
  intro ω
  rw [← Measure.map_apply hS hA,infinitePi_exchangeable]

lemma measurable_cascadeCovarianceArray (ms : List ℝ) (q : ℕ → ℝ) (Q : ℝ) :
    Measurable (cascadeCovarianceArray ms q Q) := by
  apply Measurable.of_eval
  intro i
  apply Measurable.of_eval
  intro j
  by_cases hij : i=j
  · simp only [cascadeCovarianceArray,ite_eq_left hij]; exact measurable_const
  · simp only [cascadeCovarianceArray,ite_eq_right hij]
    exact (measurable_of_countable (fun z : CascadePath ms.length × CascadePath ms.length =>
      q (cascadeSharedEdges ms.length z.1 z.2))).comp
        (show Measurable (fun x : ℕ → CascadePath ms.length => (x i,x j)) by fun_prop)

lemma rankReindex_cascadeCovariance (ms : List ℝ) (q : ℕ → ℝ) (Q : ℝ) (p : Equiv.Perm ℕ) :
    rankReindex p ∘ cascadeCovarianceArray ms q Q =
      cascadeCovarianceArray ms q Q ∘ (fun x i => x (p i)) := by
  funext x i j
  simp [rankReindex,cascadeCovarianceArray,p.injective.eq_iff]

lemma cascadeCovarianceLaw_exchangeable (ms : List ℝ) (q : ℕ → ℝ) (Q : ℝ) (p : Equiv.Perm ℕ) :
    ((cascadeReplicaLaw ms).map (cascadeCovarianceArray ms q Q)).map (rankReindex p)=
      (cascadeReplicaLaw ms).map (cascadeCovarianceArray ms q Q) := by
  rw [Measure.map_map (measurable_rankReindex p) (measurable_cascadeCovarianceArray _ _ _),
    rankReindex_cascadeCovariance,
    ← Measure.map_map (measurable_cascadeCovarianceArray _ _ _) (by fun_prop),
    cascadeReplicaLaw_exchangeable]

lemma hasRPCFiniteRankLaws_reindex {μ : Measure RankArray} (hμ : HasRPCFiniteRankLaws μ)
    (p : Equiv.Perm ℕ) : HasRPCFiniteRankLaws (μ.map (rankReindex p)) := by
  intro ms hms h01 q Q hq0 hq hQ
  have he : rankCovarianceArray ms q Q ∘ rankReindex p =
      rankReindex p ∘ rankCovarianceArray ms q Q := by
    funext U i j
    simp [rankReindex,rankCovarianceArray,p.injective.eq_iff]
  rw [Measure.map_map (measurable_rankCovarianceArray _ _ _) (measurable_rankReindex p),he,
    ← Measure.map_map (measurable_rankReindex p) (measurable_rankCovarianceArray _ _ _),
    hμ ms hms h01 q Q hq0 hq hQ,cascadeCovarianceLaw_exchangeable]

end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set
open scoped ENNReal NNReal BigOperators Classical

namespace MicroscopicJamming

def cascadeFiniteEdges {n : ℕ} (ms : List ℝ) (x : ℕ → CascadePath ms.length) :
    Fin (n+1) → Fin (n+1) → ℕ :=
  fun i j => cascadeSharedEdges ms.length (x i) (x j)

lemma measurable_cascadeFiniteEdges (n : ℕ) (ms : List ℝ) :
    Measurable (cascadeFiniteEdges (n:=n) ms) := by
  apply Measurable.of_eval
  intro i
  apply Measurable.of_eval
  intro j
  exact (measurable_of_countable (fun z : CascadePath ms.length × CascadePath ms.length =>
    cascadeSharedEdges ms.length z.1 z.2)).comp
      (show Measurable (fun x : ℕ → CascadePath ms.length => (x i.val,x j.val)) by fun_prop)

lemma cascadeReplicaLaw_pattern (ms : List ℝ) (hms : ms.Pairwise (· < ·))
    (h01 : ∀ m ∈ ms, 0 < m ∧ m < 1) {n : ℕ} (h : PatternLabelling ms.length n)
    (hh : ValidReplicaPattern ms.length h.pattern) :
    (cascadeReplicaLaw ms) {x | cascadeFiniteEdges ms x=h.signature} =
      ENNReal.ofReal (rpcPatternProduct ms 0 h.pattern) := by
  let f (x : ℕ → CascadePath ms.length) (j : PatternIndex ms.length h.pattern) := x (h.index.symm j).val
  have hf : Measurable f := by unfold f; fun_prop
  have hA : MeasurableSet {x | RPCSamplePattern ms.length h.pattern x} := Set.to_countable _ |>.measurableSet
  have he : {x | cascadeFiniteEdges ms x=h.signature} = f ⁻¹' {x | RPCSamplePattern ms.length h.pattern x} := by
    ext x
    change (cascadeFiniteEdges ms x=h.signature) ↔
      RPCSamplePattern ms.length h.pattern (fun j => x (h.index.symm j).val)
    rw [h.sample_iff_signature hh (fun i => x i.val)]
    exact funext_iff.trans (forall_congr' fun i => funext_iff)
  rw [he,cascadeReplicaLaw,Measure.bind_apply (hf hA) (measurable_cascadeReplicaKernel ms).aemeasurable]
  have hi (ω : CascadeTree ms.length) :
      (Measure.infinitePi (fun _ : ℕ => cascadeLeafLaw ms ω))
        (f ⁻¹' {x | RPCSamplePattern ms.length h.pattern x}) = sampledPatternProbability ms h.pattern ω := by
    let := cascadeLeafLaw_probability ms ω
    have hm := Measure.map_infinitePi_infinitePi_of_inj
      (P:=fun _ : ℕ => cascadeLeafLaw ms ω)
      (f:=fun j : PatternIndex ms.length h.pattern => (h.index.symm j).val)
      (Fin.val_injective.comp h.index.symm.injective)
    rw [← Measure.map_apply hf hA,hm,Measure.infinitePi_eq_pi]
    rfl
  simp_rw [hi]
  have hp := (rpcSamplePattern ms hms h01).2 0 le_rfl (fun m hm => (h01 m hm).1) h.pattern hh
  simpa using hp

end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set
open scoped ENNReal NNReal BigOperators Classical

namespace MicroscopicJamming

def rankFiniteSteps {n : ℕ} (ms : List ℝ) (R : Fin (n+1) → Fin (n+1) → ℝ) :
    Fin (n+1) → Fin (n+1) → ℕ := fun i j => rpcStepLevel ms (R i j)

lemma measurable_rankFiniteSteps (n : ℕ) (ms : List ℝ) : Measurable (rankFiniteSteps (n:=n) ms) := by
  apply Measurable.of_eval
  intro i
  apply Measurable.of_eval
  intro j
  exact (measurable_rpcStepLevel ms).comp (by fun_prop)

lemma rankFiniteSteps_preimage {n : ℕ} (ms : List ℝ) (h : PatternLabelling ms.length n) :
    rankFiniteSteps ms ⁻¹' {h.signature}=rankLabelEvent ms h := by
  ext R
  simp only [Set.mem_preimage,Set.mem_singleton_iff,rankFiniteSteps,rankLabelEvent,Set.mem_ofPred_eq,funext_iff]

lemma rankFiniteSteps_covered {n : ℕ} {R : Fin (n+1) → Fin (n+1) → ℝ}
    (hR : FiniteRank R) (ms : List ℝ) (hms : ms.Pairwise (· < ·))
    (h01 : ∀ m ∈ ms, m ≤ 1) :
    ∃ h : PatternLabelling ms.length n, ReachablePatternLabelling ms.length h ∧
      rankFiniteSteps ms R=h.signature := by
  obtain ⟨h,hh,hx⟩ := reachablePatternLabelling_covers ms.length n (fun i => rankProfilePath ms (R i))
  refine ⟨h,hh,?_⟩
  have hr := (h.sample_iff_signature hh.valid (fun i => rankProfilePath ms (R i))).mp hx
  funext i j
  exact (rankProfilePath_rows hR ms hms h01 i j).symm.trans (hr i j)

lemma cascadeFiniteEdges_covered (n : ℕ) (ms : List ℝ) (x : ℕ → CascadePath ms.length) :
    ∃ h : PatternLabelling ms.length n, ReachablePatternLabelling ms.length h ∧
      cascadeFiniteEdges ms x=h.signature := by
  obtain ⟨h,hh,hx⟩ := reachablePatternLabelling_covers ms.length n (fun i => x i.val)
  exact ⟨h,hh,funext fun i => funext fun j => (h.sample_iff_signature hh.valid (fun i => x i.val)).mp hx i j⟩

 

lemma rankGrowing_finiteSteps_law (n : ℕ) (ms : List ℝ) (hms : ms.Pairwise (· < ·))
    (h01 : ∀ m ∈ ms, 0 < m ∧ m < 1) :
    (rankSeedLaw.map (rankGrowing n)).map (rankFiniteSteps ms)=
      (cascadeReplicaLaw ms).map (cascadeFiniteEdges (n:=n) ms) := by
  apply Measure.ext_of_singleton
  intro B
  rw [Measure.map_apply (measurable_rankFiniteSteps n ms) (measurableSet_singleton _),
    Measure.map_apply (measurable_cascadeFiniteEdges n ms) (measurableSet_singleton _)]
  by_cases hb : ∃ h : PatternLabelling ms.length n, ReachablePatternLabelling ms.length h ∧ h.signature=B
  · obtain ⟨h,hh,rfl⟩ := hb
    rw [rankFiniteSteps_preimage,rankGrowing_pattern ms hms h01 h hh]
    exact (cascadeReplicaLaw_pattern ms hms h01 h hh.valid).symm
  · have hl : (rankSeedLaw.map (rankGrowing n)) (rankFiniteSteps ms ⁻¹' {B})=0 := by
      rw [measure_eq_zero_iff_ae_notMem]
      filter_upwards [rankGrowing_law_finiteRank n] with R hR hB
      obtain ⟨h,hh,hs⟩ := rankFiniteSteps_covered hR ms hms (fun m hm => (h01 m hm).2.le)
      exact hb ⟨h,hh,hs.symm.trans hB⟩
    have hr : cascadeFiniteEdges (n:=n) ms ⁻¹' {B}=∅ := by
      ext x
      simp only [Set.mem_preimage,Set.mem_singleton_iff,Set.mem_empty_iff_false,iff_false]
      intro hB
      obtain ⟨h,hh,hs⟩ := cascadeFiniteEdges_covered n ms x
      exact hb ⟨h,hh,hs.symm.trans hB⟩
    rw [hl,hr,measure_empty]

end MicroscopicJamming

 

 

open MeasureTheory ProbabilityTheory Filter Set
open scoped ENNReal NNReal Topology BigOperators

namespace MicroscopicJamming

def coordinateLaw (ε : ℝ) : Measure ℝ :=
  (1 / 2 : ℝ≥0∞) • gaussianReal 0 (Real.toNNReal (1 - ε)) +
  (1 / 2 : ℝ≥0∞) • gaussianReal 0 (Real.toNNReal (1 + ε))

instance coordinateLaw_probability (ε : ℝ) : IsProbabilityMeasure (coordinateLaw ε) := by
  constructor
  simpa [coordinateLaw] using ENNReal.inv_two_add_inv_two

lemma coordinateLaw_mgf {ε : ℝ} (he : ε ∈ Set.Icc (0 : ℝ) 1) (t : ℝ) :
    mgf id (coordinateLaw ε) t =
      (Real.exp ((1-ε)*t^2/2) + Real.exp ((1+ε)*t^2/2))/2 := by
  have h1 := integrable_exp_mul_gaussianReal (μ := 0) (v := Real.toNNReal (1-ε)) t
  have h2 := integrable_exp_mul_gaussianReal (μ := 0) (v := Real.toNNReal (1+ε)) t
  unfold coordinateLaw mgf
  simp only [id_eq]
  rw [integral_add_measure (h1.smul_measure (by norm_num))
    (h2.smul_measure (by norm_num)), integral_smul_measure, integral_smul_measure]
  change (1/2 : ℝ≥0∞).toReal * mgf id (gaussianReal 0 (Real.toNNReal (1-ε))) t +
    (1/2 : ℝ≥0∞).toReal * mgf id (gaussianReal 0 (Real.toNNReal (1+ε))) t = _
  simp only [mgf_id_gaussianReal, zero_mul, zero_add,
    Real.coe_toNNReal _ (by linarith [he.2] : 0 ≤ 1-ε),
    Real.coe_toNNReal _ (by linarith [he.1] : 0 ≤ 1+ε)]
  norm_num
  ring

lemma coordinateLaw_subGaussian {ε : ℝ} (he : ε ∈ Set.Icc (0 : ℝ) (1/2)) :
    HasSubgaussianMGF id (3/2) (coordinateLaw ε) := by
  constructor
  · intro t
    apply Integrable.add_measure
    · exact (integrable_exp_mul_gaussianReal t).smul_measure (by norm_num)
    · exact (integrable_exp_mul_gaussianReal t).smul_measure (by norm_num)
  · intro t
    rw [coordinateLaw_mgf ⟨he.1, by linarith [he.2]⟩]
    have hl : Real.exp ((1-ε)*t^2/2) ≤ Real.exp ((3/2:ℝ)*t^2/2) := by
      apply Real.exp_le_exp.mpr
      nlinarith [sq_nonneg t, mul_nonneg he.1 (sq_nonneg t)]
    have hr : Real.exp ((1+ε)*t^2/2) ≤ Real.exp ((3/2:ℝ)*t^2/2) := by
      apply Real.exp_le_exp.mpr
      nlinarith [mul_nonneg (sub_nonneg.mpr he.2) (sq_nonneg t)]
    norm_num only [NNReal.coe_div, NNReal.coe_ofNat]
    linarith

lemma mixture_linear_subGaussian {ι : Type*} [Fintype ι] {ε : ℝ}
    (he : ε ∈ Set.Icc (0 : ℝ) (1/2)) (w : ι → ℝ) :
    HasSubgaussianMGF (fun a : ι → ℝ => ∑ i, w i * a i)
      (∑ i, (NNReal.mk ((w i)^2) (sq_nonneg (w i))) * (3/2))
      (Measure.pi fun _ : ι => coordinateLaw ε) := by
  classical
  have hi := iIndepFun_pi (μ := fun _ : ι => coordinateLaw ε)
    (X := fun i x => w i * x) (fun _ => (measurable_const.mul measurable_id).aemeasurable)
  have hc : ∀ i ∈ (Finset.univ : Finset ι),
      HasSubgaussianMGF (fun a : ι → ℝ => w i * a i)
        ((NNReal.mk ((w i)^2) (sq_nonneg (w i))) * (3/2))
        (Measure.pi fun _ : ι => coordinateLaw ε) := by
    intro i _
    have h := (coordinateLaw_subGaussian he).const_mul (w i)
    rw [← (measurePreserving_eval (fun _ : ι => coordinateLaw ε) i).map_eq] at h
    exact h.of_map (measurable_pi_apply i).aemeasurable
  simpa using HasSubgaussianMGF.sum_of_iIndepFun hi hc

end MicroscopicJamming

end

end OAI