Download data/lean/OAI/Probability/JammingConcavity/RowCommonRankContinuity.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 30.3 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/JammingConcavity/RowCommonRankContinuity.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/JammingConcavity/RowCommonRankContinuity.lean
-
curl -L -o RowCommonRankContinuity.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/JammingConcavity/RowCommonRankContinuity.lean
30.3 kB
| import Mathlib | |
| import OAI.Probability.JammingConcavity.WeightedMarkedFactorial | |
| namespace OAI | |
| /-! Row Common Rank Continuity. -/ | |
| 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 ProbabilityTheory Filter Set | |
| open scoped ENNReal NNReal Topology BigOperators | |
| namespace MicroscopicJamming | |
| def rowClosedProfile (p : SphericalProfile) (s : β) : β := p.val (min 1 (max 0 s)) | |
| def rowFullRankCovariance (r : β) (Q : β) (p : SphericalProfile) | |
| (U : RankArray) : Matrix (Fin r) (Fin r) β := | |
| fun i j => if i=j then Q else rowClosedProfile p (U i.val j.val) | |
| def RowCommonRankContinuityStatement : Prop := | |
| β (Q : β) (pn : β β SphericalProfile) (p : SphericalProfile), | |
| (β n, (pn n).val 1 β€ Q) β p.val 1 β€ Q β | |
| Tendsto (fun n => sphericalProfileDistance (pn n).val p.val) atTop (π 0) β | |
| β r : β, β (Ο : β β ProbabilityMeasure (RankArray Γ EuclideanSpace β (Fin r))) | |
| (Οβ : ProbabilityMeasure (RankArray Γ EuclideanSpace β (Fin r))), | |
| (β n, (Ο n : Measure _) = gaussianAdjunctionMeasure r (rowFullRankCovariance r Q (pn n)) realizedRankLaw) β§ | |
| (Οβ : Measure _) = gaussianAdjunctionMeasure r (rowFullRankCovariance r Q p) realizedRankLaw β§ | |
| Tendsto Ο atTop (π Οβ) | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Set | |
| open scoped ENNReal NNReal | |
| namespace MicroscopicJamming | |
| def rowReplicaDiagonal (k : β) (d : β β ββ₯0) (pβ Ξ : ββ₯0) : ββ₯0 := | |
| pβ + β j : Fin k, d j + Ξ | |
| def RowReplicaMomentsStatement : Prop := | |
| β (ms : List β) (d : β β ββ₯0) (pβ Ξ : ββ₯0), | |
| ((rowReplicaEnvironmentLaw ms d pβ) ββ (rowReplicaKernel ms Ξ)).map | |
| (rowReplicaSiteField ms.length) = gaussianReal 0 (rowReplicaDiagonal ms.length d pβ Ξ) β§ | |
| β (u : β β β) (A L a : β), Measurable u β 0 β€ A β 0 β€ L β 0 < a β | |
| (β z, |u z| β€ A+L*|z|) β | |
| Integrable (fun z => Real.exp (a*|u (rowReplicaSiteField ms.length z)|)) | |
| ((rowReplicaEnvironmentLaw ms d pβ) ββ (rowReplicaKernel ms Ξ)) β§ | |
| (β« z, Real.exp (a*|u (rowReplicaSiteField ms.length z)|) | |
| β((rowReplicaEnvironmentLaw ms d pβ) ββ (rowReplicaKernel ms Ξ))) β€ | |
| 2*Real.exp (a*A+(rowReplicaDiagonal ms.length d pβ Ξ : β)*(a*L)^2/2) | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped ENNReal NNReal Topology BigOperators | |
| namespace MicroscopicJamming | |
| lemma rpcStepLevel_monotone (ms : List β) : Monotone (rpcStepLevel ms) := by | |
| intro s t hst | |
| unfold rpcStepLevel | |
| induction ms with | |
| | nil => simp | |
| | cons a ms ih => | |
| simp only [List.filter_cons, decide_eq_true_eq] | |
| split_ifs with hs ht | |
| Β· simpa using ih | |
| Β· exact False.elim (ht (le_trans hs hst)) | |
| Β· simp only [List.length_cons]; omega | |
| Β· exact ih | |
| def rowCascadeProfile (ms : List β) (d : β β ββ₯0) (pβ : ββ₯0) : SphericalProfile where | |
| val s := (pβ:β) + β a : Fin ms.length, if a.val+1 β€ rpcStepLevel ms s then (d a:β) else 0 | |
| mono := by | |
| intro s hs t ht hst | |
| apply add_le_add le_rfl | |
| apply Finset.sum_le_sum | |
| intro a _ | |
| split_ifs with ha hb | |
| Β· rfl | |
| Β· exact False.elim (hb (ha.trans (rpcStepLevel_monotone ms hst))) | |
| Β· exact (d a).coe_nonneg | |
| Β· rfl | |
| nonneg := by | |
| intro s hs | |
| apply add_nonneg pβ.coe_nonneg | |
| apply Finset.sum_nonneg | |
| intro a _ | |
| split_ifs | |
| Β· exact (d a).coe_nonneg | |
| Β· rfl | |
| def RowCascadeLogContinuityStatement : Prop := | |
| β (u : β β β) (L H : β), ContDiff β 2 u β 0 β€ L β 0 β€ H β | |
| (β x, |deriv u x| β€ L β§ |deriv (deriv u) x| β€ H) β | |
| β (ms : β β List β), (β n, (ms n).Pairwise (Β· < Β·)) β | |
| (β n m, m β ms n β 0 < m β§ m < 1) β | |
| β (d : β β β β ββ₯0) (pβ Ξ : β β ββ₯0) (Q : ββ₯0) (p : SphericalProfile), | |
| (β n, rowReplicaDiagonal (ms n).length (d n) (pβ n) (Ξ n) = Q) β p.val 1 β€ Q β | |
| Tendsto (fun n => sphericalProfileDistance (rowCascadeProfile (ms n) (d n) (pβ n)).val p.val) | |
| atTop (π 0) β | |
| β β : β, Tendsto (fun n => β« Ο, Real.log | |
| (replicaZ (rowReplicaKernel (ms n) (Ξ n)) (rowFullPotential (ms n) u) Ο) | |
| βrowReplicaEnvironmentLaw (ms n) (d n) (pβ n)) atTop (π β) | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped ENNReal NNReal Topology BigOperators | |
| namespace MicroscopicJamming | |
| def replicaFirst {S : Type*} (r k : β) (xs : Fin (r+k) β S) : Fin r β S := | |
| fun i => xs (Fin.castAdd k i) | |
| def replicaFieldView {Ξ© S : Type*} {r : β} (V : Ξ© Γ S β β) | |
| (B : Ξ© Γ (Fin r β S) β β) (k : β) | |
| (z : Ξ© Γ (Fin (r+k) β S)) : β Γ (Fin (r+k) β β) := | |
| (B (z.1,replicaFirst r k z.2),fun i => V (z.1,z.2 i)) | |
| def replicaFieldLaw {Ξ© S : Type*} [MeasurableSpace Ξ©] [MeasurableSpace S] | |
| (Ξ½ : Measure Ξ©) (G : Kernel Ξ© S) {r : β} (V : Ξ© Γ S β β) | |
| (B : Ξ© Γ (Fin r β S) β β) (k : β) : Measure (β Γ (Fin (r+k) β β)) := | |
| (Ξ½ ββ replicaKernel G (r+k)).map (replicaFieldView V B k) | |
| def ReplicaLawContinuityStatement : Prop := | |
| β (Ξ© S : β β Type) (_mΞ© : β n, MeasurableSpace (Ξ© n)) | |
| (_mS : β n, MeasurableSpace (S n)), | |
| β (Ξ½ : β n, Measure (Ξ© n)) (G : β n, Kernel (Ξ© n) (S n)), | |
| (β n, IsProbabilityMeasure (Ξ½ n)) β (β n, IsMarkovKernel (G n)) β | |
| β (V : β n, Ξ© n Γ S n β β), (β n, Measurable (V n)) β | |
| (β a : β, 0 < a β β C : β, β n, | |
| Integrable (fun z => Real.exp (a * |V n z|)) ((Ξ½ n) ββ (G n)) β§ | |
| (β« z, Real.exp (a * |V n z|) β((Ξ½ n) ββ (G n))) β€ C) β | |
| β (r : β) (B : β n, Ξ© n Γ (Fin r β S n) β β), | |
| (β n, Measurable (B n)) β (β K : β, β n z, |B n z| β€ K) β | |
| (β k : β, β (Ο : β β ProbabilityMeasure (β Γ (Fin (r+k) β β))) | |
| (Οβ : ProbabilityMeasure (β Γ (Fin (r+k) β β))), | |
| (β n, (Ο n : Measure _) = replicaFieldLaw (Ξ½ n) (G n) (V n) (B n) k) β§ | |
| Tendsto Ο atTop (π Οβ)) β | |
| (β β : β, Tendsto (fun n => β« Ο, Real.log (replicaZ (G n) (V n) Ο) βΞ½ n) | |
| atTop (π β)) β§ | |
| (β b : β, Tendsto (fun n => β« Ο, | |
| replicaNum (G n) (V n) (B n) Ο / (replicaZ (G n) (V n) Ο)^r βΞ½ n) | |
| atTop (π b)) | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Set Filter | |
| open scoped ENNReal NNReal BigOperators | |
| namespace MicroscopicJamming | |
| def RowRetainedRankLawStatement : Prop := | |
| β (u : β β β) (L H : β), ContDiff β 2 u β 0 β€ L β 0 β€ H β | |
| (β x, |deriv u x| β€ L β§ |deriv (deriv u) x| β€ H) β | |
| β ms : List β, ms.Pairwise (Β· < Β·) β (β m β ms, 0 < m β§ m < 1) β | |
| β (d : β β ββ₯0) (pβ Ξ : ββ₯0) (B : β β β) (k : β), | |
| replicaFieldLaw (rowReplicaEnvironmentLaw ms d pβ) (rowReplicaKernel ms Ξ) | |
| (rowFullPotential ms u) (rowFullPair ms u B) k = | |
| (gaussianAdjunctionMeasure (2+k) | |
| (rowFullRankCovariance (2+k) (rowReplicaDiagonal ms.length d pβ Ξ) | |
| (rowCascadeProfile ms d pβ)) realizedRankLaw).map (fun z => | |
| (B (rpcStepLevel ms (z.1 0 1)) * | |
| (deriv u (z.2 (Fin.castAdd k (0:Fin 2))) * | |
| deriv u (z.2 (Fin.castAdd k (1:Fin 2)))), | |
| fun i => u (z.2 i))) | |
| end MicroscopicJamming | |
| open MeasureTheory Set | |
| open scoped NNReal BigOperators | |
| namespace MicroscopicJamming | |
| lemma rankBirth_nonneg {n : β} (R : Fin n β Fin n β β) (j : Fin n) : 0 β€ rankBirth R j := | |
| NNReal.coe_nonneg _ | |
| lemma rankBirth_le_one {n : β} {R : Fin n β Fin n β β} (hR : FiniteRank R) (j : Fin n) : | |
| rankBirth R j β€ 1 := by | |
| change β((Finset.univ.filter (fun i => i < j)).sup (fun i => (R i j).toNNReal)) β€ (1:β) | |
| rw [β NNReal.coe_one, NNReal.coe_le_coe] | |
| exact Finset.sup_le fun i _ => (Real.toNNReal_le_iff_le_coe).mpr (hR.2.2.1 i j).2 | |
| lemma le_rankBirth_iff {n : β} {R : Fin n β Fin n β β} (_hR : FiniteRank R) | |
| (j : Fin n) {m : β} (hm : 0 < m) : | |
| m β€ rankBirth R j β β i : Fin n, i < j β§ m β€ R i j := by | |
| unfold rankBirth | |
| rw [β Real.toNNReal_le_iff_le_coe, Finset.le_sup_iff (Real.toNNReal_pos.mpr hm)] | |
| simp only [Finset.mem_filter, Finset.mem_univ, true_and, | |
| Real.toNNReal_le_toNNReal_iff_of_pos hm] | |
| lemma birth_cluster_iff {n : β} {R : Fin n β Fin n β β} (hR : FiniteRank R) | |
| (i j : Fin n) {m : β} (hm : 0 < m) (hj : j β rankCluster R i m) : | |
| m β€ rankBirth R j β β k β rankCluster R i m, k < j := by | |
| rw [le_rankBirth_iff hR j hm] | |
| have hj' : m β€ R i j := (Finset.mem_filter.mp hj).2 | |
| constructor | |
| Β· rintro β¨k,hk,hkjβ© | |
| refine β¨k,Finset.mem_filter.mpr β¨Finset.mem_univ _,?_β©,hkβ© | |
| calc m β€ min (R i j) (R j k) := le_min hj' (by rwa [hR.2.1 j k]) | |
| _ β€ R i k := hR.2.2.2 i j k | |
| Β· rintro β¨k,hk,hkjβ© | |
| refine β¨k,hkj,?_β© | |
| calc m β€ min (R k i) (R i j) := le_min (by rw [hR.2.1 k i]; exact (Finset.mem_filter.mp hk).2) hj' | |
| _ β€ R k j := hR.2.2.2 k i j | |
| lemma rankCluster_nonempty {n : β} {R : Fin n β Fin n β β} (hR : FiniteRank R) | |
| (i : Fin n) {m : β} (hm : m β€ 1) : (rankCluster R i m).Nonempty := by | |
| refine β¨i,Finset.mem_filter.mpr β¨Finset.mem_univ _,?_β©β© | |
| simpa [hR.1 i] using hm | |
| lemma rankBirth_lt_at_min {n : β} {R : Fin n β Fin n β β} (hR : FiniteRank R) | |
| (i : Fin n) {m : β} (hm : 0 < m) (hm1 : m β€ 1) : | |
| rankBirth R ((rankCluster R i m).min' (rankCluster_nonempty hR i hm1)) < m := by | |
| apply lt_of_not_ge | |
| rw [birth_cluster_iff hR i _ hm (Finset.min'_mem _ _)] | |
| rintro β¨k,hk,hltβ© | |
| exact (not_lt_of_ge (Finset.min'_le _ k hk)) hlt | |
| lemma le_rankBirth_of_not_min {n : β} {R : Fin n β Fin n β β} (hR : FiniteRank R) | |
| (i j : Fin n) {m : β} (hm : 0 < m) (hm1 : m β€ 1) | |
| (hj : j β rankCluster R i m) | |
| (hne : j β (rankCluster R i m).min' (rankCluster_nonempty hR i hm1)) : | |
| m β€ rankBirth R j := by | |
| rw [birth_cluster_iff hR i j hm hj] | |
| exact β¨_, Finset.min'_mem _ _, lt_of_le_of_ne (Finset.min'_le _ j hj) (Ne.symm hne)β© | |
| lemma rankInsert_finiteRank {n : β} {R : Fin n β Fin n β β} (hR : FiniteRank R) | |
| (j : Fin n) {v : β} (_hv : v β Set.Icc (0:β) 1) : FiniteRank (rankInsert R j v) := by | |
| have hb0 := rankBirth_nonneg R j | |
| have hb1 := rankBirth_le_one hR j | |
| have hL0 : β i, 0 β€ rankLink R j v i := fun i => le_min (hR.2.2.1 i j).1 (le_max_of_le_left hb0) | |
| have hL1 : β i, rankLink R j v i β€ 1 := fun i => min_le_left _ _ |>.trans (hR.2.2.1 i j).2 | |
| have hU1 : β i k, min (rankLink R j v i) (rankLink R j v k) β€ R i k := by | |
| intro i k | |
| apply le_trans _ (hR.2.2.2 i j k) | |
| exact min_le_min (min_le_left _ _) ((min_le_left _ _).trans_eq (hR.2.1 k j)) | |
| have hU2 : β i k, min (R i k) (rankLink R j v k) β€ rankLink R j v i := by | |
| intro i k | |
| apply le_min | |
| Β· exact (min_le_min_left _ (min_le_left _ _)).trans (hR.2.2.2 i k j) | |
| Β· exact (min_le_right _ _).trans (min_le_right _ _) | |
| refine β¨?_,?_,?_,?_β© | |
| Β· intro a; refine Fin.lastCases ?_ (fun i => ?_) a | |
| Β· simp [rankInsert] | |
| Β· simpa [rankInsert] using hR.1 i | |
| Β· intro a b; refine Fin.lastCases ?_ (fun i => ?_) a <;> refine Fin.lastCases ?_ (fun k => ?_) b | |
| all_goals simp [rankInsert, hR.2.1] | |
| Β· intro a b; refine Fin.lastCases ?_ (fun i => ?_) a <;> refine Fin.lastCases ?_ (fun k => ?_) b | |
| all_goals simp only [rankInsert, Fin.lastCases_last, Fin.lastCases_castSucc] | |
| Β· norm_num | |
| Β· exact β¨hL0 _,hL1 _β© | |
| Β· exact β¨hL0 _,hL1 _β© | |
| Β· exact hR.2.2.1 _ _ | |
| Β· intro a b c | |
| refine Fin.lastCases ?_ (fun i => ?_) a <;> | |
| refine Fin.lastCases ?_ (fun k => ?_) b <;> | |
| refine Fin.lastCases ?_ (fun l => ?_) c | |
| all_goals simp only [rankInsert, Fin.lastCases_last, Fin.lastCases_castSucc] | |
| Β· simp | |
| Β· exact min_le_right _ _ | |
| Β· exact (min_le_left _ _).trans (hL1 _) | |
| Β· rw [min_comm, hR.2.1 k l]; exact hU2 _ _ | |
| Β· exact min_le_left _ _ | |
| Β· exact hU1 _ _ | |
| Β· exact hU2 _ _ | |
| Β· exact hR.2.2.2 _ _ _ | |
| end MicroscopicJamming | |
| open MeasureTheory Set | |
| open scoped NNReal BigOperators | |
| namespace MicroscopicJamming | |
| lemma continuous_rankBirth {n : β} (j : Fin n) : | |
| Continuous (fun R : Fin n β Fin n β β => rankBirth R j) := by | |
| unfold rankBirth | |
| apply NNReal.continuous_coe.comp | |
| apply Continuous.finset_sup_apply | |
| intro i _ | |
| fun_prop | |
| lemma continuous_rankInsert_fixed {n : β} (j : Fin n) : | |
| Continuous (fun z : (Fin n β Fin n β β) Γ β => rankInsert z.1 j z.2) := by | |
| apply continuous_pi | |
| intro a | |
| apply continuous_pi | |
| intro b | |
| refine Fin.lastCases ?_ (fun i => ?_) a <;> refine Fin.lastCases ?_ (fun k => ?_) b | |
| all_goals simp only [rankInsert, Fin.lastCases_last, Fin.lastCases_castSucc, rankLink] | |
| Β· exact continuous_const | |
| Β· exact (show Continuous (fun z : (Fin n β Fin n β β) Γ β => z.1 k j) by fun_prop).min | |
| (((continuous_rankBirth j).comp continuous_fst).max continuous_snd) | |
| Β· exact (show Continuous (fun z : (Fin n β Fin n β β) Γ β => z.1 i j) by fun_prop).min | |
| (((continuous_rankBirth j).comp continuous_fst).max continuous_snd) | |
| Β· fun_prop | |
| lemma continuous_rankInsert (n : β) : | |
| Continuous (fun z : (Fin n β Fin n β β) Γ (Fin n Γ β) => | |
| rankInsert z.1 z.2.1 z.2.2) := by | |
| have h : Continuous (fun z : Fin n Γ ((Fin n β Fin n β β) Γ β) => | |
| rankInsert z.2.1 z.1 z.2.2) := | |
| continuous_prod_of_discrete_left.mpr continuous_rankInsert_fixed | |
| exact h.comp (show Continuous (fun z : (Fin n β Fin n β β) Γ (Fin n Γ β) => | |
| (z.2.1,(z.1,z.2.2))) by fun_prop) | |
| lemma rankLink_volume {n : β} {R : Fin n β Fin n β β} (hR : FiniteRank R) | |
| (i j : Fin n) {m : β} (hm : 0 < m) (hm1 : m β€ 1) : | |
| (volume {v : β | v β Set.Icc (0:β) 1 β§ m β€ rankLink R j v i}).toReal = | |
| (if j β rankCluster R i m then (1:β) else 0) - | |
| (if j = (rankCluster R i m).min' (rankCluster_nonempty hR i hm1) then m else 0) := by | |
| classical | |
| let C := rankCluster R i m | |
| let b : Fin n := C.min' (rankCluster_nonempty hR i hm1) | |
| by_cases hj : j β C | |
| Β· by_cases hje : j=b | |
| Β· subst j | |
| have hb := rankBirth_lt_at_min hR i hm hm1 | |
| have hi : m β€ R i b := (Finset.mem_filter.mp (Finset.min'_mem C _)).2 | |
| have he : {v : β | v β Set.Icc (0:β) 1 β§ m β€ rankLink R b v i} = Set.Icc m 1 := by | |
| ext v | |
| simp only [Set.mem_ofPred_eq, Set.mem_Icc, rankLink, le_min_iff, le_max_iff] | |
| have hh : Β¬ m β€ rankBirth R b := not_le.mpr hb | |
| simp only [hi,hh,false_or,true_and] | |
| constructor | |
| Β· rintro β¨β¨_,hvβ©,hmvβ©; exact β¨hmv,hvβ© | |
| Β· rintro β¨hmv,hvβ©; exact β¨β¨hm.le.trans hmv,hvβ©,hmvβ© | |
| rw [he,Real.volume_Icc, ENNReal.toReal_ofReal (sub_nonneg.mpr hm1)] | |
| simp [C,b,Finset.min'_mem] | |
| Β· have hb := le_rankBirth_of_not_min hR i j hm hm1 hj hje | |
| have hi : m β€ R i j := (Finset.mem_filter.mp hj).2 | |
| have he : {v : β | v β Set.Icc (0:β) 1 β§ m β€ rankLink R j v i} = Set.Icc (0:β) 1 := by | |
| ext v | |
| simp [rankLink, le_max_iff, hi, hb] | |
| rw [he,Real.volume_Icc] | |
| simp only [sub_zero, ENNReal.ofReal_one, ENNReal.toReal_one] | |
| simp only [show j β rankCluster R i m from hj, ite_true, | |
| show j β (rankCluster R i m).min' _ from hje, ite_false, sub_zero] | |
| Β· have hi : Β¬ m β€ R i j := by simpa [C,rankCluster] using hj | |
| have hje : j β b := by rintro rfl; exact hj (Finset.min'_mem C _) | |
| have he : {v : β | v β Set.Icc (0:β) 1 β§ m β€ rankLink R j v i} = β := by | |
| ext v; simp [rankLink,hi] | |
| rw [he,measure_empty,ENNReal.toReal_zero] | |
| simp only [show j β rankCluster R i m from hj, ite_false, | |
| show j β (rankCluster R i m).min' _ from hje, sub_self] | |
| lemma rankInsert_cluster_probability {n : β} {R : Fin n β Fin n β β} (hR : FiniteRank R) | |
| (i : Fin n) {m : β} (hm : 0 < m) (hm1 : m β€ 1) : | |
| (β j : Fin n, (volume {v : β | v β Set.Icc (0:β) 1 β§ m β€ rankLink R j v i}).toReal) / | |
| (n:β) = ((rankCluster R i m).card-m)/(n:β) := by | |
| classical | |
| simp_rw [rankLink_volume hR i _ hm hm1] | |
| congr 1 | |
| rw [Finset.sum_sub_distrib] | |
| simp | |
| theorem rpcRankInsertion : RPCRankInsertionStatement := by | |
| refine β¨?_, continuous_rankInsert, ?_β© | |
| Β· intro n R j v hR hv | |
| exact rankInsert_finiteRank hR j hv | |
| Β· intro n R i m hR hm hm1 | |
| exact rankInsert_cluster_probability hR i hm hm1 | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Set | |
| open scoped NNReal BigOperators | |
| namespace MicroscopicJamming | |
| lemma continuous_rankGrowing (n : β) : Continuous (rankGrowing n) := by | |
| induction n with | |
| | zero => exact continuous_const | |
| | succ n ih => | |
| exact (continuous_rankInsert (n+1)).comp (ih.prodMk (continuous_apply n)) | |
| lemma rankGrowing_stable {n N : β} (h : n β€ N) (z : RankSeed) (i j : Fin (n+1)) : | |
| rankGrowing N z (Fin.castLE (Nat.succ_le_succ h) i) (Fin.castLE (Nat.succ_le_succ h) j) = | |
| rankGrowing n z i j := by | |
| induction N with | |
| | zero => | |
| have hn : n=0 := Nat.eq_zero_of_le_zero h | |
| subst n | |
| simp | |
| | succ N ih => | |
| by_cases hn : n=N+1 | |
| Β· subst n; simp | |
| Β· have hnN : n β€ N := by omega | |
| change rankInsert (rankGrowing N z) (z N).1 (z N).2 | |
| (Fin.castLE (Nat.succ_le_succ hnN) i).castSucc | |
| (Fin.castLE (Nat.succ_le_succ hnN) j).castSucc = _ | |
| simp only [rankInsert,Fin.lastCases_castSucc] | |
| exact ih hnN | |
| lemma realizedRank_stage (n : β) (z : RankSeed) (i j : Fin (n+1)) : | |
| realizedRank z i j=rankGrowing n z i j := by | |
| have h : max i.val j.val β€ n := max_le (Nat.le_of_lt_succ i.isLt) (Nat.le_of_lt_succ j.isLt) | |
| have hh := rankGrowing_stable h z | |
| (β¨i.val,Nat.lt_succ_of_le (le_max_left _ _)β© : Fin (max i.val j.val+1)) | |
| (β¨j.val,Nat.lt_succ_of_le (le_max_right _ _)β© : Fin (max i.val j.val+1)) | |
| exact hh.symm | |
| lemma continuous_realizedRank : Continuous realizedRank := by | |
| apply continuous_pi | |
| intro i | |
| apply continuous_pi | |
| intro j | |
| exact ((continuous_apply _).comp ((continuous_apply _).comp (continuous_rankGrowing (max i j)))) | |
| lemma rankGrowing_finiteRank {z : RankSeed} (hz : β k, (z k).2 β Set.Icc (0:β) 1) (n : β) : | |
| FiniteRank (rankGrowing n z) := by | |
| induction n with | |
| | zero => | |
| refine β¨fun i => rfl,fun i j => rfl,fun i j => ?_,fun i j k => ?_β© | |
| Β· norm_num [rankGrowing] | |
| Β· simp [rankGrowing] | |
| | succ n ih => exact rankInsert_finiteRank ih (z n).1 (hz n) | |
| lemma realizedRank_constraints {z : RankSeed} (hz : β k, (z k).2 β Set.Icc (0:β) 1) : | |
| (β i, realizedRank z i i=1) β§ (β i j, realizedRank z i j=realizedRank z j i) β§ | |
| (β i j, 0 β€ realizedRank z i j β§ realizedRank z i j β€ 1) β§ | |
| (β i j k, min (realizedRank z i j) (realizedRank z j k) β€ realizedRank z i k) := by | |
| have hpair (i j : β) : | |
| realizedRank z i j=rankGrowing (max i j) z | |
| β¨i,Nat.lt_succ_of_le (le_max_left _ _)β© β¨j,Nat.lt_succ_of_le (le_max_right _ _)β© := rfl | |
| refine β¨?_,?_,?_,?_β© | |
| Β· intro i | |
| exact (realizedRank_stage i z (Fin.last i) (Fin.last i)).trans | |
| ((rankGrowing_finiteRank hz i).1 (Fin.last i)) | |
| Β· intro i j | |
| let a : Fin (max i j+1) := β¨i,Nat.lt_succ_of_le (le_max_left _ _)β© | |
| let b : Fin (max i j+1) := β¨j,Nat.lt_succ_of_le (le_max_right _ _)β© | |
| change realizedRank z a b=realizedRank z b a | |
| rw [realizedRank_stage,realizedRank_stage] | |
| exact (rankGrowing_finiteRank hz _).2.1 _ _ | |
| Β· intro i j | |
| rw [hpair] | |
| exact (rankGrowing_finiteRank hz _).2.2.1 _ _ | |
| Β· intro i j k | |
| let n := max (max i j) k | |
| let a : Fin (n+1) := β¨i,Nat.lt_succ_of_le ((le_max_left i j).trans (le_max_left _ _))β© | |
| let b : Fin (n+1) := β¨j,Nat.lt_succ_of_le ((le_max_right i j).trans (le_max_left _ _))β© | |
| let c : Fin (n+1) := β¨k,Nat.lt_succ_of_le (le_max_right _ _)β© | |
| change min (realizedRank z a b) (realizedRank z b c) β€ realizedRank z a c | |
| rw [realizedRank_stage,realizedRank_stage,realizedRank_stage] | |
| exact (rankGrowing_finiteRank hz n).2.2.2 a b c | |
| lemma realizedRank_pair {z : RankSeed} (hz : (z 0).2 β Set.Icc (0:β) 1) : | |
| realizedRank z 0 1 = (z 0).2 := by | |
| have hj : (z 0).1 = 0 := by | |
| apply Fin.ext | |
| have h := (z 0).1.isLt | |
| change (z 0).1.val = 0 | |
| omega | |
| change rankGrowing 1 z (0 : Fin 2) (Fin.last 1) = _ | |
| change rankInsert (rankGrowing 0 z) (z 0).1 (z 0).2 (Fin.castSucc 0) (Fin.last 1) = _ | |
| simp only [rankInsert,Fin.lastCases_castSucc,Fin.lastCases_last,rankLink,hj,rankGrowing] | |
| have hb : rankBirth (fun _ _ : Fin 1 => (1:β)) 0 = 0 := by | |
| simp [rankBirth] | |
| rw [hb,max_eq_right hz.1,min_eq_right hz.2] | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Set | |
| open scoped NNReal BigOperators | |
| namespace MicroscopicJamming | |
| instance rankUnitInterval_probability : IsProbabilityMeasure (volume.restrict (Set.Icc (0:β) 1)) := | |
| β¨by simp [Real.volume_Icc]β© | |
| instance rankInnovationLaw_probability (n : β) : IsProbabilityMeasure (rankInnovationLaw n) := by | |
| unfold rankInnovationLaw | |
| infer_instance | |
| instance rankSeedLaw_probability : IsProbabilityMeasure rankSeedLaw := by | |
| unfold rankSeedLaw | |
| infer_instance | |
| instance realizedRankLaw_probability : IsProbabilityMeasure realizedRankLaw := by | |
| unfold realizedRankLaw | |
| infer_instance | |
| lemma rankInnovation_second (n : β) : | |
| (rankInnovationLaw n).map Prod.snd = volume.restrict (Set.Icc (0:β) 1) := by | |
| simp [rankInnovationLaw,Measure.map_snd_prod] | |
| lemma rankSeed_coordinate (n : β) : | |
| rankSeedLaw.map (fun z => (z n).2) = volume.restrict (Set.Icc (0:β) 1) := by | |
| have h1 : Measurable (fun z : RankSeed => z n) := by fun_prop | |
| rw [show (fun z : RankSeed => (z n).2) = Prod.snd β (fun z : RankSeed => z n) from rfl, | |
| β Measure.map_map measurable_snd h1,rankSeedLaw,Measure.infinitePi_map_eval,rankInnovation_second] | |
| lemma rankSeed_valid : βα΅ z βrankSeedLaw, β n, (z n).2 β Set.Icc (0:β) 1 := by | |
| rw [ae_all_iff] | |
| intro n | |
| have h : βα΅ v βrankSeedLaw.map (fun z => (z n).2), v β Set.Icc (0:β) 1 := by | |
| rw [rankSeed_coordinate] | |
| exact ae_restrict_mem measurableSet_Icc | |
| exact ae_of_ae_map (show Measurable (fun z : RankSeed => (z n).2) by fun_prop).aemeasurable h | |
| lemma realizedRankLaw_constraints : | |
| βα΅ U βrealizedRankLaw, (β i, U i i=1) β§ (β i j, U i j=U j i) β§ | |
| (β i j, 0 β€ U i j β§ U i j β€ 1) β§ | |
| (β i j k, min (U i j) (U j k) β€ U i k) := by | |
| apply (ae_map_iff continuous_realizedRank.measurable.aemeasurable ?_).mpr | |
| Β· exact rankSeed_valid.mono fun z hz => realizedRank_constraints hz | |
| Β· simp only [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 realizedRankLaw_uniform : | |
| realizedRankLaw.map (fun U => U 0 1) = volume.restrict (Set.Icc (0:β) 1) := by | |
| rw [realizedRankLaw,Measure.map_map (by fun_prop) continuous_realizedRank.measurable] | |
| trans rankSeedLaw.map (fun z => (z 0).2) | |
| Β· apply Measure.map_congr | |
| exact rankSeed_valid.mono fun z hz => realizedRank_pair (hz 0) | |
| Β· exact rankSeed_coordinate 0 | |
| theorem rpcRankRealization : RPCRankRealizationStatement := | |
| β¨continuous_realizedRank,inferInstance,realizedRank_stage, | |
| realizedRankLaw_constraints,realizedRankLaw_uniformβ© | |
| end MicroscopicJamming | |
| open MeasureTheory ProbabilityTheory Set | |
| open scoped ENNReal NNReal BigOperators | |
| namespace MicroscopicJamming | |
| def rankJoinEvent {n : β} (R : Fin (n+1) β Fin (n+1) β β) (i : Fin (n+1)) (m : β) : | |
| Set (Fin (n+1) Γ β) := {z | m β€ rankLink R z.1 z.2 i} | |
| lemma measurableSet_rankJoinEvent {n : β} (R : Fin (n+1) β Fin (n+1) β β) | |
| (i : Fin (n+1)) (m : β) : MeasurableSet (rankJoinEvent R i m) := by | |
| apply measurableSet_le measurable_const | |
| unfold rankLink | |
| have h1 : Measurable (fun z : Fin (n+1) Γ β => R i z.1) := | |
| (measurable_of_countable (R i)).comp measurable_fst | |
| have h2 : Measurable (fun z : Fin (n+1) Γ β => rankBirth R z.1) := | |
| (measurable_of_countable (rankBirth R)).comp measurable_fst | |
| exact h1.min (h2.max measurable_snd) | |
| lemma rankJoinEvent_real {n : β} {R : Fin (n+1) β Fin (n+1) β β} (hR : FiniteRank R) | |
| (i : Fin (n+1)) {m : β} (hm : 0 < m) (hm1 : m β€ 1) : | |
| (rankInnovationLaw n).real (rankJoinEvent R i m) = | |
| ((rankCluster R i m).card-m)/((n:β)+1) := by | |
| classical | |
| have he (j : Fin (n+1)) : | |
| (volume.restrict (Set.Icc (0:β) 1)) (Prod.mk j β»ΒΉ' rankJoinEvent R i m) = | |
| volume {v : β | v β Set.Icc (0:β) 1 β§ m β€ rankLink R j v i} := by | |
| rw [Measure.restrict_apply ((measurableSet_rankJoinEvent R i m).preimage (by fun_prop))] | |
| congr 1 | |
| ext v | |
| simp only [Set.mem_inter_iff,Set.mem_preimage,rankJoinEvent,Set.mem_ofPred_eq] | |
| exact and_comm | |
| have hf (j : Fin (n+1)) : volume {v : β | v β Set.Icc (0:β) 1 β§ m β€ rankLink R j v i} β β := by | |
| apply ne_of_lt | |
| exact (measure_mono (by intro v hv; exact hv.1)).trans_lt (by simp [Real.volume_Icc]) | |
| unfold Measure.real rankInnovationLaw | |
| rw [Measure.prod_apply (measurableSet_rankJoinEvent R i m),lintegral_fintype] | |
| simp_rw [he,PMF.toMeasure_apply_singleton _ _ (measurableSet_singleton _),PMF.uniformOfFintype_apply, | |
| Fintype.card_fin] | |
| rw [β Finset.sum_mul,ENNReal.toReal_mul,ENNReal.toReal_sum (fun j _ => hf j)] | |
| simp only [ENNReal.toReal_inv,Nat.cast_add,Nat.cast_one,β div_eq_mul_inv] | |
| simpa [ENNReal.toReal_add] using rankInsert_cluster_probability hR i hm hm1 | |
| lemma rankJoinEvent_zero {n : β} {R : Fin (n+1) β Fin (n+1) β β} (hR : FiniteRank R) | |
| (i : Fin (n+1)) : rankJoinEvent R i 0=univ := by | |
| apply Set.eq_univ_of_forall | |
| intro z | |
| exact le_min (hR.2.2.1 i z.1).1 (le_max_of_le_left (rankBirth_nonneg R z.1)) | |
| lemma rankJoinEvent_real_nonneg {n : β} {R : Fin (n+1) β Fin (n+1) β β} (hR : FiniteRank R) | |
| (i : Fin (n+1)) {m : β} (hm : 0 β€ m) (hm1 : m β€ 1) : | |
| (rankInnovationLaw n).real (rankJoinEvent R i m) = | |
| ((rankCluster R i m).card-m)/((n:β)+1) := by | |
| rcases hm.eq_or_lt with rfl|hm | |
| Β· rw [rankJoinEvent_zero hR i] | |
| have hc : rankCluster R i 0 = Finset.univ := by | |
| ext j | |
| simp [rankCluster,(hR.2.2.1 i j).1] | |
| simp [hc,show (n:β)+1β 0 by positivity] | |
| Β· exact rankJoinEvent_real hR i hm hm1 | |
| lemma rankLink_parent_le {n : β} {R : Fin n β Fin n β β} (hR : FiniteRank R) | |
| (p i j : Fin n) (v : β) : min (R p i) (rankLink R j v i) β€ rankLink R j v p := by | |
| unfold rankLink | |
| exact le_min ((min_le_min_left _ (min_le_left _ _)).trans (hR.2.2.2 p i j)) | |
| ((min_le_right _ _).trans (min_le_right _ _)) | |
| lemma rankLink_pair_le {n : β} {R : Fin n β Fin n β β} (hR : FiniteRank R) | |
| (i k j : Fin n) (v : β) : min (rankLink R j v i) (rankLink R j v k) β€ R i k := by | |
| unfold rankLink | |
| exact (min_le_min (min_le_left _ _) ((min_le_left _ _).trans_eq (hR.2.1 k j))).trans | |
| (hR.2.2.2 i j k) | |
| lemma rankJoinEvent_subset {n : β} {R : Fin (n+1) β Fin (n+1) β β} (hR : FiniteRank R) | |
| (p i : Fin (n+1)) {Ξ· m : β} (hΞ·m : Ξ· β€ m) (hpi : Ξ· β€ R p i) : | |
| rankJoinEvent R i m β rankJoinEvent R p Ξ· := by | |
| intro z hz | |
| exact (le_min hpi (hΞ·m.trans hz)).trans (rankLink_parent_le hR p i z.1 z.2) | |
| lemma rankJoinEvent_disjoint {n : β} {R : Fin (n+1) β Fin (n+1) β β} (hR : FiniteRank R) | |
| (i k : Fin (n+1)) {m : β} (hik : R i k < m) : | |
| Disjoint (rankJoinEvent R i m) (rankJoinEvent R k m) := by | |
| apply Set.disjoint_left.mpr | |
| intro z hi hk | |
| exact not_le_of_gt hik ((le_min hi hk).trans (rankLink_pair_le hR i k z.1 z.2)) | |
| lemma rankFreshBranch_real {n r : β} {R : Fin (n+1) β Fin (n+1) β β} | |
| (hR : FiniteRank R) (p : Fin (n+1)) (c : Fin r β Fin (n+1)) | |
| {Ξ· m : β} (hΞ· : 0 β€ Ξ·) (hΞ·m : Ξ· β€ m) (hm : 0 < m) (hm1 : m β€ 1) | |
| (hparent : β a, Ξ· β€ R p (c a)) | |
| (hchild : β a b, a β b β R (c a) (c b) < m) | |
| (hcover : (rankCluster R p Ξ·).card = β a, (rankCluster R (c a) m).card) : | |
| (rankInnovationLaw n).real | |
| (rankJoinEvent R p Ξ· \ β a, rankJoinEvent R (c a) m) = | |
| ((r:β)*m-Ξ·)/((n:β)+1) := by | |
| have hsub : (β a, rankJoinEvent R (c a) m) β rankJoinEvent R p Ξ· := by | |
| simp only [iUnion_subset_iff] | |
| exact fun a => rankJoinEvent_subset hR p (c a) hΞ·m (hparent a) | |
| rw [measureReal_sdiff hsub (MeasurableSet.iUnion (fun a => measurableSet_rankJoinEvent R (c a) m))] | |
| rw [rankJoinEvent_real_nonneg hR p hΞ· (hΞ·m.trans hm1), | |
| measureReal_iUnion_fintype (fun a b hab => rankJoinEvent_disjoint hR _ _ (hchild a b hab)) | |
| (fun a => measurableSet_rankJoinEvent R (c a) m)] | |
| simp_rw [rankJoinEvent_real hR _ hm hm1] | |
| rw [β Finset.sum_div,Finset.sum_sub_distrib] | |
| push_cast [hcover] | |
| simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul] | |
| ring | |
| end MicroscopicJamming | |
| end | |
| end OAI | |