| import Mathlib |
| import OAI.Probability.IsingPerceptron.CascadeFreshMoments |
| import OAI.Probability.IsingPerceptron.FieldChain |
|
|
| namespace OAI |
|
|
| /-! Moment Log Limit. -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal Matrix |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology Polynomial |
| namespace IsingPerceptron |
|
|
| lemma integrable_pow_of_pos_bounds {Ω : Type*} [MeasurableSpace Ω] |
| {P : Measure Ω} [IsProbabilityMeasure P] {Z : Ω → ℝ} (hZ : Measurable Z) |
| {a b : ℝ} (ha : 0 < a) (hb : ∀ ω, Z ω ∈ Icc a b) (k : ℕ) : |
| Integrable (fun ω => Z ω ^ k) P := by |
| apply Integrable.of_bound (hZ.pow_const k).aestronglyMeasurable (b^k) |
| exact ae_of_all _ (fun ω => by |
| rw [Real.norm_eq_abs,abs_pow,abs_of_nonneg (ha.le.trans (hb ω).1)] |
| exact pow_le_pow_left₀ (ha.le.trans (hb ω).1) (hb ω).2 _) |
|
|
| lemma integral_polynomial_of_pos_bounds {Ω : Type*} [MeasurableSpace Ω] |
| {P : Measure Ω} [IsProbabilityMeasure P] {Z : Ω → ℝ} (hZ : Measurable Z) |
| {a b : ℝ} (ha : 0 < a) (hb : ∀ ω, Z ω ∈ Icc a b) (p : ℝ[X]) : |
| (∫ ω, p.eval (Z ω) ∂P) = ∑ k ∈ p.support, p.coeff k * ∫ ω, Z ω ^ k ∂P := by |
| simp only [Polynomial.eval_eq_sum,Polynomial.sum] |
| rw [integral_finsetSum _ (fun k _ => (integrable_pow_of_pos_bounds hZ ha hb k).const_mul _)] |
| simp only [integral_const_mul] |
|
|
| lemma integral_log_polynomial_error {Ω' : Type*} [MeasurableSpace Ω'] (P' : Measure Ω') |
| [IsProbabilityMeasure P'] (Z' : Ω' → ℝ) (hZ' : Measurable Z') |
| {a b : ℝ} (hc : ContinuousOn Real.log (Icc a b)) |
| (hb' : ∀ ω, Z' ω ∈ Icc a b) (p : ℝ[X]) {ε : ℝ} (_hε : 0 < ε) |
| (hp : ∀ x ∈ Icc a b, |p.eval x - Real.log x| < ε) : |
| |(∫ ω, p.eval (Z' ω) ∂P') - ∫ ω, Real.log (Z' ω) ∂P'| ≤ ε := by |
| have hip : Integrable (fun ω => p.eval (Z' ω)) P' := by |
| have hpc : ContinuousOn (fun x => p.eval x) (Icc a b) := p.continuous.continuousOn |
| obtain ⟨C,hC⟩ := isCompact_Icc.exists_bound_of_continuousOn hpc |
| exact Integrable.of_bound (p.continuous.measurable.comp hZ').aestronglyMeasurable C |
| (ae_of_all _ (fun ω => hC _ (hb' ω))) |
| have hil : Integrable (fun ω => Real.log (Z' ω)) P' := by |
| obtain ⟨C,hC⟩ := isCompact_Icc.exists_bound_of_continuousOn hc |
| exact Integrable.of_bound (hZ'.log).aestronglyMeasurable C |
| (ae_of_all _ (fun ω => hC _ (hb' ω))) |
| rw [← integral_sub hip hil,← Real.norm_eq_abs] |
| simpa only [probReal_univ,mul_one] using norm_integral_le_of_norm_le_const |
| (μ := P') (C := ε) (ae_of_all _ (fun ω => by |
| simpa only [Real.norm_eq_abs] using (hp _ (hb' ω)).le)) |
|
|
| |
|
|
| theorem tendsto_integral_log_of_moments |
| {Ω : ℕ → Type*} [∀ n, MeasurableSpace (Ω n)] {Ωlim : Type*} [MeasurableSpace Ωlim] |
| (P : ∀ n, Measure (Ω n)) [∀ n, IsProbabilityMeasure (P n)] |
| (Q : Measure Ωlim) [IsProbabilityMeasure Q] |
| (Z : ∀ n, Ω n → ℝ) (W : Ωlim → ℝ) |
| (hZ : ∀ n, Measurable (Z n)) (hW : Measurable W) |
| {a b : ℝ} (ha : 0 < a) (_hb : a ≤ b) |
| (hbound : ∀ n ω, Z n ω ∈ Icc a b) (hwbound : ∀ ω, W ω ∈ Icc a b) |
| (hmoment : ∀ k : ℕ, Tendsto (fun n => ∫ ω, Z n ω ^ k ∂P n) atTop |
| (𝓝 (∫ ω, W ω ^ k ∂Q))) : |
| Tendsto (fun n => ∫ ω, Real.log (Z n ω) ∂P n) atTop |
| (𝓝 (∫ ω, Real.log (W ω) ∂Q)) := by |
| have hc : ContinuousOn Real.log (Icc a b) := Real.continuousOn_log.mono |
| (fun x hx => ne_of_gt (ha.trans_le hx.1)) |
| apply Metric.tendsto_atTop.mpr |
| intro ε hε |
| obtain ⟨p,hp⟩ := exists_polynomial_near_of_continuousOn a b Real.log hc (ε/3) (by positivity) |
| have ht : Tendsto (fun n => ∫ ω, p.eval (Z n ω) ∂P n) atTop |
| (𝓝 (∫ ω, p.eval (W ω) ∂Q)) := by |
| simp_rw [integral_polynomial_of_pos_bounds (hZ _) ha (hbound _) p, |
| integral_polynomial_of_pos_bounds hW ha hwbound p] |
| exact tendsto_finsetSum _ (fun k _ => tendsto_const_nhds.mul (hmoment k)) |
| obtain ⟨N,hN⟩ := Metric.tendsto_atTop.mp ht (ε/3) (by positivity) |
| use N |
| intro n hn |
| rw [Real.dist_eq] |
| have h1 := integral_log_polynomial_error (P n) (Z n) (hZ n) hc (hbound n) p (by positivity : 0 < ε/3) hp |
| have h2 := integral_log_polynomial_error Q W hW hc hwbound p (by positivity : 0 < ε/3) hp |
| have h3 := hN n hn |
| rw [Real.dist_eq] at h3 |
| have htri := abs_add_three |
| ((∫ ω, Real.log (Z n ω) ∂P n) - ∫ ω, p.eval (Z n ω) ∂P n) |
| ((∫ ω, p.eval (Z n ω) ∂P n) - ∫ ω, p.eval (W ω) ∂Q) |
| ((∫ ω, p.eval (W ω) ∂Q) - ∫ ω, Real.log (W ω) ∂Q) |
| rw [abs_sub_comm] at h1 |
| have he : ((∫ ω, Real.log (Z n ω) ∂P n) - ∫ ω, p.eval (Z n ω) ∂P n) + |
| ((∫ ω, p.eval (Z n ω) ∂P n) - ∫ ω, p.eval (W ω) ∂Q) + |
| ((∫ ω, p.eval (W ω) ∂Q) - ∫ ω, Real.log (W ω) ∂Q) = |
| (∫ ω, Real.log (Z n ω) ∂P n) - ∫ ω, Real.log (W ω) ∂Q := by ring |
| rw [he] at htri |
| linarith |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal BoundedContinuousFunction |
| namespace IsingPerceptron |
|
|
| |
|
|
| theorem exists_positive_factor_of_moments |
| {Ω : ℕ → Type*} [∀ n, MeasurableSpace (Ω n)] |
| (P : ∀ n, Measure (Ω n)) [∀ n, IsProbabilityMeasure (P n)] |
| (Z : ∀ n, Ω n → ℝ) (hZ : ∀ n, Measurable (Z n)) |
| {a b : ℝ} (hab : a ≤ b) (hb : ∀ n ω, Z n ω ∈ Icc a b) |
| (L : ℕ → ℝ) (hL : ∀ k, Tendsto (fun n => ∫ ω, Z n ω^k ∂P n) atTop (𝓝 (L k))) : |
| ∃ Q : ProbabilityMeasure (Icc a b), ∀ k, (∫ x, (x:ℝ)^k ∂(Q : Measure (Icc a b))) = L k := by |
| let : Nonempty (Icc a b) := ⟨⟨a,le_rfl,hab⟩⟩ |
| let F (n : ℕ) : Ω n → Icc a b := fun ω => ⟨Z n ω,hb n ω⟩ |
| have hF (n) : Measurable (F n) := (hZ n).subtype_mk |
| let M (n : ℕ) : ProbabilityMeasure (Icc a b) := ⟨(P n).map (F n),inferInstance⟩ |
| obtain ⟨Q,_,ns,hns,hQ⟩ := isSeqCompact_univ.subseq_of_frequently_in |
| (x := M) (Filter.Frequently.of_forall (fun _ => Set.mem_univ _)) |
| refine ⟨Q,?_⟩ |
| intro k |
| have hT := (ProbabilityMeasure.tendsto_iff_forall_integral_tendsto.mp hQ) |
| (BoundedContinuousFunction.mkOfCompact ⟨fun x : Icc a b => (x:ℝ)^k,by fun_prop⟩) |
| have he (n) : (∫ x : Icc a b, (x:ℝ)^k ∂(M n : Measure (Icc a b))) = ∫ ω, Z n ω^k ∂P n := by |
| exact integral_map (hF n).aemeasurable (by fun_prop : Continuous (fun x : Icc a b => (x:ℝ)^k)).aestronglyMeasurable |
| change Tendsto (fun n => ∫ x : Icc a b, (x:ℝ)^k ∂(M (ns n) : Measure (Icc a b))) atTop |
| (𝓝 (∫ x : Icc a b, (x:ℝ)^k ∂(Q : Measure (Icc a b)))) at hT |
| simp only [he] at hT |
| exact tendsto_nhds_unique hT ((hL k).comp hns.tendsto_atTop) |
|
|
| lemma factor_log_converges_of_moments |
| {Ω : ℕ → Type*} [∀ n, MeasurableSpace (Ω n)] |
| (P : ∀ n, Measure (Ω n)) [∀ n, IsProbabilityMeasure (P n)] |
| (Z : ∀ n, Ω n → ℝ) (hZ : ∀ n, Measurable (Z n)) |
| {a b : ℝ} (ha : 0 < a) (hab : a ≤ b) (hb : ∀ n ω, Z n ω ∈ Icc a b) |
| (L : ℕ → ℝ) (hL : ∀ k, Tendsto (fun n => ∫ ω, Z n ω^k ∂P n) atTop (𝓝 (L k))) : |
| ∃ Q : ProbabilityMeasure (Icc a b), |
| (∀ k, (∫ x, (x:ℝ)^k ∂(Q : Measure (Icc a b))) = L k) ∧ |
| Tendsto (fun n => ∫ ω, Real.log (Z n ω) ∂P n) atTop |
| (𝓝 (∫ x, Real.log (x:ℝ) ∂(Q : Measure (Icc a b)))) := by |
| obtain ⟨Q,hQ⟩ := exists_positive_factor_of_moments P Z hZ hab hb L hL |
| refine ⟨Q,hQ,?_⟩ |
| exact tendsto_integral_log_of_moments P (Q : Measure (Icc a b)) Z (fun x => (x:ℝ)) hZ |
| measurable_subtype_coe ha hab hb (fun x => x.property) (fun k => by rw [hQ k]; exact hL k) |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal Matrix |
| namespace IsingPerceptron |
|
|
| |
|
|
| theorem patternFunctional_factor_law (q : OverlapPath) (p : ℝ → ℝ) |
| (hpq : p =ᵐ[pathMeasure] q.val) (hp : Monotone p) (hb : ∀ u, p u ∈ Icc (0:ℝ) 1) |
| (μ : ProbabilityMeasure JointArray) (hGG : HasGhirlandaGuerra spinArray (μ : Measure JointArray)) |
| (hG : ∀ᵐ x ∂(μ : Measure JointArray), GramDiagonal 1 (spinArray x)) |
| (hU : ∀ᵐ x ∂(μ : Measure JointArray), IsUltrametricArray (spinArray x)) |
| (hpair : (μ : Measure JointArray).map (fun x => spinArray x 0 1) = unitUniform.map p) |
| {f : ℝ → ℝ} (hf : Continuous f) {K : ℝ} (hK : ∀ x, |f x| ≤ K) : |
| ∃ Q : ProbabilityMeasure (Icc (Real.exp (-K)) (Real.exp K)), |
| (∀ m, (∫ x, (x:ℝ)^m ∂(Q : Measure (Icc (Real.exp (-K)) (Real.exp K)))) = |
| ∫ x, gaussianMoment m f (fun i j => spinArray x i j) ∂(μ : Measure JointArray)) ∧ |
| (∫ x, Real.log (x:ℝ) ∂(Q : Measure (Icc (Real.exp (-K)) (Real.exp K)))) = patternFunctional f q ∧ |
| Tendsto (uniformPattern f q) atTop (𝓝 (patternFunctional f q)) := by |
| have hK0 : 0 ≤ K := (abs_nonneg (f 0)).trans (hK 0) |
| have he : Real.exp (-K) ≤ Real.exp K := Real.exp_le_exp.mpr (by linarith) |
| obtain ⟨Q,hQ,hT⟩ := factor_log_converges_of_moments |
| (fun n => (labeledCascadeLaw n (uniformExponent n) : Measure (LabeledTree n)).prod gaussianCoordinates) |
| (fun n => cascadeFreshFactor n (uniformCellAverage p n) f) |
| (fun n => measurable_cascadeFreshFactor n _ hf.measurable) (Real.exp_pos _) he |
| (fun n x => cascadeFreshFactor_bound n _ hf.measurable hK x) |
| (fun m => ∫ x, gaussianMoment m f (fun i j => spinArray x i j) ∂(μ : Measure JointArray)) |
| (cascadeFresh_moments_tendsto hp hb μ hGG hG hU hpair hf hK) |
| have hv : Tendsto (uniformPattern f q) atTop (𝓝 (∫ x, Real.log (x:ℝ) ∂(Q : Measure (Icc (Real.exp (-K)) (Real.exp K))))) := by |
| simpa only [cascadeFresh_uniformPattern q p hpq _ hf.measurable hK] using hT |
| have heq : patternFunctional f q = ∫ x, Real.log (x:ℝ) ∂(Q : Measure (Icc (Real.exp (-K)) (Real.exp K))) := hv.limUnder_eq |
| exact ⟨Q,hQ,heq.symm,by simpa only [heq] using hv⟩ |
|
|
| |
|
|
| theorem freshLog_tendsto_patternFunctional |
| {Ω : ℕ → Type*} [∀ n, MeasurableSpace (Ω n)] |
| (P : ∀ n, Measure (Ω n)) [∀ n, IsProbabilityMeasure (P n)] |
| (Z : ∀ n, Ω n → ℝ) (hZ : ∀ n, Measurable (Z n)) |
| (q : OverlapPath) (p : ℝ → ℝ) (hpq : p =ᵐ[pathMeasure] q.val) |
| (hp : Monotone p) (hb : ∀ u, p u ∈ Icc (0:ℝ) 1) |
| (μ : ProbabilityMeasure JointArray) (hGG : HasGhirlandaGuerra spinArray (μ : Measure JointArray)) |
| (hG : ∀ᵐ x ∂(μ : Measure JointArray), GramDiagonal 1 (spinArray x)) |
| (hU : ∀ᵐ x ∂(μ : Measure JointArray), IsUltrametricArray (spinArray x)) |
| (hpair : (μ : Measure JointArray).map (fun x => spinArray x 0 1) = unitUniform.map p) |
| {f : ℝ → ℝ} (hf : Continuous f) {K : ℝ} (hK : ∀ x, |f x| ≤ K) |
| (hbound : ∀ n x, Z n x ∈ Icc (Real.exp (-K)) (Real.exp K)) |
| (hMom : ∀ m, Tendsto (fun n => ∫ x, (Z n x)^m ∂P n) atTop |
| (𝓝 (∫ x, gaussianMoment m f (fun i j => spinArray x i j) ∂(μ : Measure JointArray)))) : |
| Tendsto (fun n => ∫ x, Real.log (Z n x) ∂P n) atTop (𝓝 (patternFunctional f q)) := by |
| obtain ⟨Q,hQ,hlog,_⟩ := patternFunctional_factor_law q p hpq hp hb μ hGG hG hU hpair hf hK |
| rw [← hlog] |
| have hK0 : 0 ≤ K := (abs_nonneg (f 0)).trans (hK 0) |
| apply tendsto_integral_log_of_moments P (Q : Measure (Icc (Real.exp (-K)) (Real.exp K))) Z (fun x => (x:ℝ)) hZ measurable_subtype_coe |
| (Real.exp_pos _) (Real.exp_le_exp.mpr (by linarith)) hbound (fun x => x.property) |
| intro m |
| rw [hQ m] |
| exact hMom m |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal Matrix |
| namespace IsingPerceptron |
|
|
| |
|
|
| theorem uniformPattern_tendsto (q : OverlapPath) {f : ℝ → ℝ} |
| (hf : Continuous f) {K : ℝ} (hK : ∀ x, |f x| ≤ K) : |
| Tendsto (uniformPattern f q) atTop (𝓝 (patternFunctional f q)) := by |
| obtain ⟨p,hpq,hp,hb⟩ := overlapPath_representative q |
| obtain ⟨μ,ns,hns,hL⟩ := jointArrayLaw_subsequence |
| (fun k => cascadeCompactLaw k (uniformExponent k) (uniformCellAverage p k)) |
| have hL' : Tendsto (fun k => cascadeCompactLaw (ns k) (uniformExponent (ns k)) |
| (uniformCellAverage p (ns k))) atTop (𝓝 μ) := hL |
| have hgeom := cascadeCompact_limit_geometry |
| (fun k => uniformCellAverage_monotone hp hb (ns k)) |
| (fun k => (uniformCellAverage_mem hp hb (ns k) 0).1) |
| (fun k => (uniformCellAverage_mem hp hb (ns k) (ns k)).2) hL' |
| have hGG : HasGhirlandaGuerra spinArray (μ : Measure JointArray) := |
| (cascadeCompact_limit_GG (fun k => uniformExponent_cascade (ns k)) hL').real_map |
| (f := fun x => x.1.1) (by fun_prop) |
| have hpair := cascadeCompact_limit_pairLaw hp hb hns.tendsto_atTop hL' |
| obtain ⟨Q,hQ,hlog,hlim⟩ := patternFunctional_factor_law q p hpq hp hb μ hGG |
| hgeom.1 hgeom.2 hpair hf hK |
| exact hlim |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma uniformNodal_congr (a b : ℕ → ℝ) (n : ℕ) (h : ∀ i ≤ n, a i=b i) : |
| uniformNodal a n=uniformNodal b n := by |
| funext j |
| unfold uniformNodal |
| split |
| · rfl |
| · split |
| · exact h (j-1) (by omega) |
| · rfl |
|
|
| lemma uniformNodal_tail_weights {p q : ℝ → ℝ} (hp : Monotone p) (hq : Monotone q) |
| (n : ℕ) (ht : ∀ s ∈ Icc (0:ℝ) 1, |
| (∫ u in Ioo s 1, q u) ≤ ∫ u in Ioo s 1, p u) : |
| FinTailNonneg (fun i : Fin (n+2) => |
| (nextCoefficient (uniformCoefficient n) i-uniformCoefficient n i)* |
| (uniformNodal (uniformCellAverage p n) n (i.val+1)- |
| uniformNodal (uniformCellAverage q n) n (i.val+1))) := by |
| intro j |
| rw [Fin.sum_univ_castSucc] |
| simp only [uniformWeight_last,ite_self,add_zero] |
| simp only [Fin.le_def,Fin.val_castSucc] |
| have hw (i : Fin (n+1)) := uniformWeight_castSucc (uniformCellAverage q n) (uniformCellAverage p n) n i |
| simp only [Fin.val_castSucc] at hw |
| simp_rw [hw] |
| have he (i : Fin (n+1)) : |
| (if j.val ≤ i.val then (1/(n+1:ℕ))*(uniformCellAverage p n i.val-uniformCellAverage q n i.val) else 0) = |
| (1/(n+1:ℕ))*(if j.val ≤ i.val then uniformCellAverage p n i.val-uniformCellAverage q n i.val else 0) := by |
| split <;> simp |
| simp_rw [he] |
| rw [← Finset.mul_sum] |
| apply mul_nonneg (by positivity) |
| apply uniformCellAverage_tail_difference hp hq n j.val (by omega) |
| apply ht |
| constructor |
| · positivity |
| · exact (div_le_one (by positivity : (0:ℝ) < (n+1:ℕ))).mpr (by exact_mod_cast Nat.le_of_lt_succ j.isLt) |
|
|
| lemma uniformPattern_tail_comparison (p q : OverlapPath) |
| (p' q' : ℝ → ℝ) (hpq : p' =ᵐ[pathMeasure] p.val) (hqq : q' =ᵐ[pathMeasure] q.val) |
| (hp : Monotone p') (hq : Monotone q') |
| (hpb : ∀ u, p' u ∈ Icc (0:ℝ) 1) (hqb : ∀ u, q' u ∈ Icc (0:ℝ) 1) |
| (ht : ∀ s ∈ Icc (0:ℝ) 1, (∫ u in Ioo s 1, q' u) ≤ ∫ u in Ioo s 1, p' u) |
| {f : ℝ → ℝ} (F : BoundedC2Data f) (n : ℕ) : |
| uniformPattern f p n ≤ uniformPattern f q n := by |
| rw [uniformPattern_eq_nodal,uniformPattern_eq_nodal] |
| have hpn := uniformNodal_congr (uniformCellAverage p' n) (cellAverage p (n+1)) n |
| (uniformCellAverage_eq_cellAverage p p' hpq n) |
| have hqn := uniformNodal_congr (uniformCellAverage q' n) (cellAverage q (n+1)) n |
| (uniformCellAverage_eq_cellAverage q q' hqq n) |
| rw [← hpn,← hqn] |
| exact nodalGaussianFold_antitone _ _ _ |
| (uniformNodal_increasing n (uniformCellAverage_monotone hq hqb n) |
| (uniformCellAverage_mem hq hqb n)) |
| (uniformNodal_increasing n (uniformCellAverage_monotone hp hpb n) |
| (uniformCellAverage_mem hp hpb n)) |
| (uniformCoefficient_nonneg n) |
| (by simp only [uniformNodal_zero]) (by simp only [uniformNodal_last]) |
| (uniformNodal_tail_weights hp hq n ht) F 0 |
|
|
| lemma tail_integral_representative (q : OverlapPath) {p : ℝ → ℝ} |
| (hp : p =ᵐ[pathMeasure] q.val) {s : ℝ} (hs : 0 ≤ s) : |
| (∫ u in Ioo s 1, p u) = ∫ u in Ioo s 1, q.val u ∂pathMeasure := by |
| have hm : pathMeasure.restrict (Ioo s 1)=volume.restrict (Ioo s 1) := by |
| rw [pathMeasure,Measure.restrict_restrict measurableSet_Ioo,inter_eq_left.mpr] |
| intro u hu |
| exact ⟨hs.trans_lt hu.1,hu.2⟩ |
| rw [← hm] |
| exact integral_congr_ae hp.restrict |
|
|
| |
|
|
| theorem patternFunctional_tail_order {f : ℝ → ℝ} (F : BoundedC2Data f) |
| (p q : OverlapPath) |
| (ht : ∀ s ∈ Icc (0:ℝ) 1, |
| (∫ u in Ioo s 1, q.val u ∂pathMeasure) ≤ ∫ u in Ioo s 1, p.val u ∂pathMeasure) : |
| patternFunctional f p ≤ patternFunctional f q := by |
| obtain ⟨p',hpp,hp,hpb⟩ := overlapPath_representative p |
| obtain ⟨q',hqq,hq,hqb⟩ := overlapPath_representative q |
| apply le_of_tendsto_of_tendsto (uniformPattern_tendsto p F.continuous F.bf) |
| (uniformPattern_tendsto q F.continuous F.bf) |
| apply Eventually.of_forall |
| intro n |
| apply uniformPattern_tail_comparison p q p' q' hpp hqq hp hq hpb hqb _ F n |
| intro s hs |
| rw [tail_integral_representative p hpp hs.1,tail_integral_representative q hqq hs.1] |
| exact ht s hs |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| |
|
|
| lemma monotone_tail_chord_lower {p : ℝ → ℝ} (hp : Monotone p) |
| {a s b c A B T : ℝ} (has : a ≤ s) (hsb : s ≤ b) |
| (hA : A ≤ ∫ u in a..1, p u) (hB : B ≤ ∫ u in b..1, p u) |
| (hAT : A=T+(s-a)*c) (hTB : T=B+(b-s)*c) : |
| T ≤ ∫ u in s..1, p u := by |
| by_cases hc : p s ≤ c |
| · have H := intervalIntegral.integral_mono_on (μ := volume) has hp.intervalIntegrable |
| (f := p) (g := fun _ => c) intervalIntegrable_const |
| (fun u hu => (hp hu.2).trans hc) |
| rw [intervalIntegral.integral_const,smul_eq_mul] at H |
| have he := intervalIntegral.integral_add_adjacent_intervals (μ := volume) |
| (f := p) (a := a) (b := s) (c := 1) hp.intervalIntegrable hp.intervalIntegrable |
| linarith |
| · have H := intervalIntegral.integral_mono_on (μ := volume) hsb intervalIntegrable_const hp.intervalIntegrable |
| (f := fun _ => c) (g := p) (fun u hu => (le_of_not_ge hc).trans (hp hu.1)) |
| rw [intervalIntegral.integral_const,smul_eq_mul] at H |
| have he := intervalIntegral.integral_add_adjacent_intervals (μ := volume) |
| (f := p) (a := s) (b := b) (c := 1) hp.intervalIntegrable hp.intervalIntegrable |
| linarith |
|
|
| lemma monotone_tail_of_cell {p q : ℝ → ℝ} (hp : Monotone p) (hq : Monotone q) |
| {a s b c : ℝ} (has : a ≤ s) (hsb : s ≤ b) |
| (hc : ∀ u ∈ Ioo a b, q u=c) |
| (ha : (∫ u in a..1, q u) ≤ ∫ u in a..1, p u) |
| (hb : (∫ u in b..1, q u) ≤ ∫ u in b..1, p u) : |
| (∫ u in s..1, q u) ≤ ∫ u in s..1, p u := by |
| have he₁ : (∫ u in a..s, q u)=(s-a)*c := by |
| calc |
| _ = ∫ _ in a..s, c := intervalIntegral.integral_congr_Ioo_of_le has |
| (fun u hu => hc u ⟨hu.1,hu.2.trans_le hsb⟩) |
| _ = _ := by rw [intervalIntegral.integral_const,smul_eq_mul] |
| have he₂ : (∫ u in s..b, q u)=(b-s)*c := by |
| calc |
| _ = ∫ _ in s..b, c := intervalIntegral.integral_congr_Ioo_of_le hsb |
| (fun u hu => hc u ⟨has.trans_lt hu.1,hu.2⟩) |
| _ = _ := by rw [intervalIntegral.integral_const,smul_eq_mul] |
| have h₁ := intervalIntegral.integral_add_adjacent_intervals (μ := volume) |
| (f := q) (a := a) (b := s) (c := 1) hq.intervalIntegrable hq.intervalIntegrable |
| have h₂ := intervalIntegral.integral_add_adjacent_intervals (μ := volume) |
| (f := q) (a := s) (b := b) (c := 1) hq.intervalIntegrable hq.intervalIntegrable |
| rw [he₁] at h₁ |
| rw [he₂] at h₂ |
| exact monotone_tail_chord_lower (c := c) hp has hsb ha hb (by linarith) (by linarith) |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma path_tail_interval (p : ℝ → ℝ) {s : ℝ} (hs0 : 0 ≤ s) (hs1 : s ≤ 1) : |
| (∫ u in Ioi s, p u ∂pathMeasure) = ∫ u in s..1, p u := by |
| have he : Ioi s ∩ Ioo (0:ℝ) 1=Ioo s 1 := by |
| ext u |
| simp only [mem_inter_iff,mem_Ioi,mem_Ioo] |
| exact ⟨fun h => ⟨h.1,h.2.2⟩,fun h => ⟨h.1,hs0.trans_lt h.1,h.2⟩⟩ |
| rw [pathMeasure,Measure.restrict_restrict measurableSet_Ioi,he, |
| intervalIntegral.integral_of_le hs1,integral_Ioc_eq_integral_Ioo] |
|
|
| lemma finite_partition_cell {k : ℕ} (ζ : Fin (k+1) → ℝ) |
| {s : ℝ} (hs0 : ζ 0 ≤ s) (hs1 : s < ζ (Fin.last k)) : |
| ∃ i : Fin k, ζ i.castSucc ≤ s ∧ s < ζ i.succ := by |
| classical |
| let T := Finset.univ.filter (fun i => s < ζ i) |
| have hT : T.Nonempty := ⟨Fin.last k,by simp [T,hs1]⟩ |
| let d := T.min' hT |
| have hd : s < ζ d := (Finset.mem_filter.mp (Finset.min'_mem T hT)).2 |
| have hd0 : 0 < d.val := by |
| by_contra h |
| have he : d=0 := Fin.ext (by change d.val=0; omega) |
| rw [he] at hd |
| linarith |
| let i : Fin k := ⟨d.val-1,by have := d.isLt; omega⟩ |
| have he : i.succ=d := Fin.ext (by dsimp [i]; omega) |
| refine ⟨i,?_,by simpa only [he] using hd⟩ |
| by_contra! h |
| have hm : i.castSucc∈T := by simp [T,h] |
| have H := Finset.min'_le T i.castSucc hm |
| change d.val ≤ i.val at H |
| dsimp [i] at H |
| omega |
|
|
| lemma intervalIntegral_const_of_ae_cell {q : ℝ → ℝ} {a b x y c : ℝ} |
| (hxy : x ≤ y) (hax : a ≤ x) (hyb : y ≤ b) |
| (hc : q =ᵐ[volume.restrict (Ioo a b)] (fun _ => c)) : |
| (∫ u in x..y, q u) = (y-x)*c := by |
| calc |
| _ = ∫ _ in x..y, c := by |
| rw [intervalIntegral.integral_of_le hxy,intervalIntegral.integral_of_le hxy, |
| integral_Ioc_eq_integral_Ioo,integral_Ioc_eq_integral_Ioo] |
| apply integral_congr_ae |
| exact ae_restrict_of_ae_restrict_of_subset (t := Ioo a b) (s := Ioo x y) |
| (fun u hu => ⟨hax.trans_lt hu.1,hu.2.trans_le hyb⟩) hc |
| _ = _ := by rw [intervalIntegral.integral_const,smul_eq_mul] |
|
|
| lemma monotone_tail_of_ae_cell {p q : ℝ → ℝ} (hp : Monotone p) (hq : Monotone q) |
| {a s b c : ℝ} (has : a ≤ s) (hsb : s ≤ b) |
| (hc : q =ᵐ[volume.restrict (Ioo a b)] (fun _ => c)) |
| (ha : (∫ u in a..1, q u) ≤ ∫ u in a..1, p u) |
| (hb : (∫ u in b..1, q u) ≤ ∫ u in b..1, p u) : |
| (∫ u in s..1, q u) ≤ ∫ u in s..1, p u := by |
| have he₁ := intervalIntegral_const_of_ae_cell has le_rfl hsb hc |
| have he₂ := intervalIntegral_const_of_ae_cell hsb has le_rfl hc |
| have h₁ := intervalIntegral.integral_add_adjacent_intervals (μ := volume) |
| (f := q) (a := a) (b := s) (c := 1) hq.intervalIntegrable hq.intervalIntegrable |
| have h₂ := intervalIntegral.integral_add_adjacent_intervals (μ := volume) |
| (f := q) (a := s) (b := b) (c := 1) hq.intervalIntegrable hq.intervalIntegrable |
| rw [he₁] at h₁ |
| rw [he₂] at h₂ |
| exact monotone_tail_chord_lower (c := c) hp has hsb ha hb (by linarith) (by linarith) |
|
|
| lemma nodal_tails_imply_all_tails {n : ℕ} (ζ : Fin (n+2) → ℝ) |
| (hz : StrictMono ζ) (hz0 : ζ 0=0) (hz1 : ζ (Fin.last (n+1))=1) |
| (v : Fin (n+1) → ℝ) {p q : ℝ → ℝ} (hp : Monotone p) (hq : Monotone q) |
| (hstep : finiteStepFunction ζ v =ᵐ[pathMeasure] q) |
| (ht : ∀ j : Fin (n+1), (∑ i, if j ≤ i then chainWeight ζ i*v i else 0) ≤ |
| ∫ u in Ioi (ζ j.castSucc), p u ∂pathMeasure) : |
| ∀ s ∈ Icc (0:ℝ) 1, (∫ u in Ioo s 1, q u) ≤ ∫ u in Ioo s 1, p u := by |
| have hzbound (j) : ζ j∈Icc (0:ℝ) 1 := |
| ⟨by rw [← hz0]; exact hz.monotone (Fin.zero_le _),by rw [← hz1]; exact hz.monotone (Fin.le_last _)⟩ |
| have hn : ∀ j : Fin (n+2), (∫ u in ζ j..1, q u) ≤ ∫ u in ζ j..1, p u := by |
| intro j |
| refine Fin.lastCases ?_ (fun i => ?_) j |
| · simp only [hz1,intervalIntegral.integral_same,le_refl] |
| · rw [← path_tail_interval q (hzbound i.castSucc).1 (hzbound i.castSucc).2, |
| ← path_tail_interval p (hzbound i.castSucc).1 (hzbound i.castSucc).2, |
| ← integral_congr_ae hstep.restrict,integral_finiteStep_tail ζ hz hz0 hz1] |
| simpa only [Fin.le_def,Fin.val_castSucc,chainWeight] using ht i |
| intro s hs |
| by_cases he : s=1 |
| · simp [he] |
| have hs1 : s < 1 := lt_of_le_of_ne hs.2 he |
| obtain ⟨i,hia,hib⟩ := finite_partition_cell ζ (by simpa only [hz0] using hs.1) (by simpa only [hz1] using hs1) |
| have hcell : q =ᵐ[volume.restrict (Ioo (ζ i.castSucc) (ζ i.succ))] (fun _ => v i) := by |
| have heq : finiteStepFunction ζ v =ᵐ[volume.restrict (Ioo (ζ i.castSucc) (ζ i.succ))] q := |
| ae_restrict_of_ae_restrict_of_subset (t := Ioo (0:ℝ) 1) |
| (s := Ioo (ζ i.castSucc) (ζ i.succ)) (fun u hu => |
| ⟨(hzbound i.castSucc).1.trans_lt hu.1,hu.2.trans_le (hzbound i.succ).2⟩) hstep |
| filter_upwards [heq,ae_restrict_mem measurableSet_Ioo] with u hu hu' |
| exact hu.symm.trans (finiteStepFunction_on_cell hz v hu') |
| have H := monotone_tail_of_ae_cell hp hq hia hib.le hcell (hn i.castSucc) (hn i.succ) |
| simpa only [intervalIntegral.integral_of_le hs.2,integral_Ioc_eq_integral_Ioo] using H |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal Matrix |
| namespace IsingPerceptron |
|
|
| lemma overlapArrayLaw_gram {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X] |
| [Countable X] [MeasurableSingletonClass X] |
| (P : Measure Ω) [IsProbabilityMeasure P] (ν : Ω → Measure X) |
| (hν : Measurable ν) [∀ ω, IsProbabilityMeasure (ν ω)] |
| (A : X → ℕ →₀ ℝ) (κ : X → X → JointEntry) |
| (hA : ∀ x y, cylinderCross (A x) (A y) = (κ x y).1.1) |
| (hd : ∀ x, (κ x x).1.1 = 1) : |
| ∀ᵐ x ∂(overlapArrayLaw P ν hν κ : Measure JointArray), GramDiagonal 1 (spinArray x) := by |
| change ∀ᵐ x ∂(replicaLaw P ν hν).map (sampledOverlapArray κ), _ |
| apply (ae_map_iff (measurable_sampledOverlapArray κ).aemeasurable |
| ((isClosed_gramDiagonal 1).preimage continuous_spinArray).measurableSet).mpr |
| filter_upwards [] with σ |
| constructor |
| · intro m |
| have he : (fun i j : Fin m => spinArray (sampledOverlapArray κ σ) i j) = |
| (fun i j : Fin m => cylinderCross (A (σ i)) (A (σ j))) := by |
| funext i j |
| exact (hA (σ i) (σ j)).symm |
| rw [he] |
| exact cylinderCross_matrix_posSemidef (fun i : Fin m => A (σ i)) |
| · intro i |
| exact hd (σ i) |
|
|
| |
|
|
| theorem freshPattern_array_limit |
| {Ω X : ℕ → Type*} [∀ n, MeasurableSpace (Ω n)] [∀ n, MeasurableSpace (X n)] |
| [∀ n, Countable (X n)] [∀ n, MeasurableSingletonClass (X n)] |
| (P : ∀ n, Measure (Ω n)) [∀ n, IsProbabilityMeasure (P n)] |
| (ν : ∀ n, Ω n → Measure (X n)) (hν : ∀ n, Measurable (ν n)) |
| [∀ n ω, IsProbabilityMeasure (ν n ω)] |
| (A : ∀ n, X n → ℕ →₀ ℝ) (κ : ∀ n, X n → X n → JointEntry) |
| (hA : ∀ n x y, cylinderCross (A n x) (A n y) = (κ n x y).1.1) |
| (hd : ∀ n x, (κ n x x).1.1 = 1) |
| (μ : ProbabilityMeasure JointArray) |
| (hL : Tendsto (fun n => overlapArrayLaw (P n) (ν n) (hν n) (κ n)) atTop (𝓝 μ)) |
| (hGG : HasGhirlandaGuerra spinArray (μ : Measure JointArray)) |
| (q : OverlapPath) |
| (hq : quantileFunction ((μ : Measure JointArray).map (fun x => spinArray x 0 1)) =ᵐ[pathMeasure] q.val) |
| {f : ℝ → ℝ} (hf : Continuous f) {K : ℝ} (hK : ∀ x, |f x| ≤ K) : |
| Tendsto (fun n => ∫ z : Ω n × (ℕ → ℝ), Real.log (freshPatternFactor (ν n z.1) (A n) f z.2) |
| ∂(P n).prod gaussianCoordinates) atTop (𝓝 (patternFunctional f q)) := by |
| have hGn (n) := overlapArrayLaw_gram (P n) (ν n) (hν n) (A n) (κ n) (hA n) (hd n) |
| have hG := ae_closed_of_weak_limit hL ((isClosed_gramDiagonal 1).preimage continuous_spinArray) hGn |
| have hE : ∀ e : Equiv.Perm ℕ, (μ : Measure JointArray).map (permuteJointArray e) = μ := by |
| intro e |
| exact jointArray_limit_reindex hL e (fun n => overlapArrayLaw_map_reindex (P n) (ν n) (hν n) (κ n) e e.injective) |
| have hU := gg_ultrametric_ae continuous_spinArray.measurable |
| (scalar_of_joint_exchangeable hE (fun x => x.1.1) (by fun_prop)) hGG (by norm_num : (0:ℝ) ≤ 1) hG |
| have hpos := gg_pair_nonnegative_ae continuous_spinArray.measurable hGG (by norm_num : (0:ℝ) ≤ 1) hG |
| let Q := (μ : Measure JointArray).map (fun x => spinArray x 0 1) |
| have hm : Measurable (fun x : JointArray => spinArray x 0 1) := by unfold spinArray; fun_prop |
| let : IsProbabilityMeasure Q := inferInstance |
| have hs : ∀ᵐ r ∂Q, r ∈ Icc (0:ℝ) 1 := by |
| apply (ae_map_iff hm.aemeasurable measurableSet_Icc).mpr |
| filter_upwards [hpos] with x hx |
| exact ⟨hx,(x (0,1)).1.property.2⟩ |
| have hqp := monotone_quantileFunction hs |
| have hqb := quantileFunction_mem hs |
| apply freshLog_tendsto_patternFunctional (fun n => (P n).prod gaussianCoordinates) |
| (fun n z => freshPatternFactor (ν n z.1) (A n) f z.2) |
| (fun n => measurable_random_freshPatternFactor (hν n) (A n) hf.measurable) |
| q (quantileFunction Q) hq hqp hqb μ hGG hG hU (quantileFunction_law hs).symm hf hK |
| (fun n z => freshPatternFactor_bound (ν n z.1) (A n) f hK z.2) |
| intro m |
| simp_rw [freshPatternFactor_array_moment (P _) (ν _) (hν _) (A _) (κ _) (hA _) hf hK m] |
| exact jointArray_tendsto_gaussianMoment hL hGn hG m hf hK |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma prefix_next_preserving {A : Type*} [MeasurableSpace A] (P : Measure A) |
| [IsProbabilityMeasure P] (m : ℕ) : |
| MeasurePreserving (fun y : ℕ → A => ((fun i : Fin m => y i), y m)) |
| (Measure.infinitePi (fun _ : ℕ => P)) ((Measure.pi (fun _ : Fin m => P)).prod P) := by |
| have hp := (Measure.measurePreserving_swap (μ := P) (ν := Measure.pi (fun _ : Fin m => P))).comp |
| ((measurePreserving_piFinSuccAbove (fun _ : Fin (m+1) => P) (Fin.last m)).comp |
| (infinite_prefix_preserving P (m+1))) |
| convert hp using 1 |
| funext y |
| apply Prod.ext |
| · funext i |
| simp [Function.comp_def,MeasurableEquiv.piFinSuccAbove,Fin.init] |
| · simp [Function.comp_def,MeasurableEquiv.piFinSuccAbove,Fin.snocEquiv] |
|
|
| |
|
|
| theorem integral_next_row_of_prefix {A B : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| (P : Measure A) [IsProbabilityMeasure P] (Q : Measure B) [IsProbabilityMeasure Q] |
| (m : ℕ) (F : (Fin m → A) × B × A → ℝ) (hF : Measurable F) |
| : |
| (∫ z : (ℕ → A) × B, F ((fun i => z.1 i),z.2,z.1 m) |
| ∂(Measure.infinitePi (fun _ : ℕ => P)).prod Q) = |
| ∫ z : ((ℕ → A) × B) × A, F ((fun i => z.1.1 i),z.1.2,z.2) |
| ∂((Measure.infinitePi (fun _ : ℕ => P)).prod Q).prod P := by |
| let R := Measure.pi (fun _ : Fin m => P) |
| let H : ((Fin m → A) × A) × B → ℝ := fun z => F (z.1.1,z.2,z.1.2) |
| have hH : Measurable H := hF.comp (by fun_prop) |
| have he1 := ((prefix_next_preserving P m).prod (MeasurePreserving.id Q)).hasLaw.integral_comp |
| hH.aestronglyMeasurable |
| have hm : Measurable (fun z : ((Fin m → A) × B) × A => F (z.1.1,z.1.2,z.2)) := hF.comp (by fun_prop) |
| have he2 := (((infinite_prefix_preserving P m).prod (MeasurePreserving.id Q)).prod |
| (MeasurePreserving.id P)).hasLaw.integral_comp hm.aestronglyMeasurable |
| have hs := ((measurePreserving_prodAssoc R Q P).symm MeasurableEquiv.prodAssoc).comp |
| (((MeasurePreserving.id R).prod (Measure.measurePreserving_swap (μ := P) (ν := Q))).comp |
| (measurePreserving_prodAssoc R P Q)) |
| calc |
| _ = ∫ z : ((Fin m → A) × A) × B, F (z.1.1,z.2,z.1.2) ∂(R.prod P).prod Q := he1 |
| _ = ∫ z : ((Fin m → A) × B) × A, F (z.1.1,z.1.2,z.2) ∂(R.prod Q).prod P := |
| hs.hasLaw.integral_comp hm.aestronglyMeasurable |
| _ = _ := he2.symm |
|
|
| end IsingPerceptron |
|
|
| end |
|
|
| end OAI |
|
|
