| import Mathlib |
| import OAI.Probability.IsingPerceptron.ArrayGeometry |
|
|
| namespace OAI |
|
|
| /-! Ordered Quantile. -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal |
| namespace IsingPerceptron |
|
|
| lemma map_restrict_fst_rectangle (μ : Measure (ℝ × ℝ)) {S T : Set ℝ} (hS : MeasurableSet S) : |
| ((μ.restrict (univ ×ˢ T)).map Prod.fst) S = μ (S ×ˢ T) := by |
| rw [Measure.map_apply measurable_fst hS,Measure.restrict_apply (hS.preimage measurable_fst)] |
| congr 1 |
| ext x |
| simp |
|
|
| lemma map_restrict_snd_rectangle (μ : Measure (ℝ × ℝ)) {S T : Set ℝ} (hT : MeasurableSet T) : |
| ((μ.restrict (S ×ˢ univ)).map Prod.snd) T = μ (S ×ˢ T) := by |
| rw [Measure.map_apply measurable_snd hT,Measure.restrict_apply (hT.preimage measurable_snd)] |
| congr 1 |
| ext x |
| simp [and_comm] |
|
|
| lemma measure_pair_eq_of_lower_rectangles {μ ν : Measure (ℝ × ℝ)} [IsFiniteMeasure μ] |
| (h : ∀ a b : ℝ, μ (Iic a ×ˢ Iic b) = ν (Iic a ×ˢ Iic b)) |
| (hU : μ univ = ν univ) : μ = ν := by |
| have hfirst (a : ℝ) : (μ.restrict (Iic a ×ˢ univ)).map Prod.snd = |
| (ν.restrict (Iic a ×ˢ univ)).map Prod.snd := by |
| apply Measure.ext_of_Iic |
| intro b |
| rw [map_restrict_snd_rectangle μ measurableSet_Iic,map_restrict_snd_rectangle ν measurableSet_Iic] |
| exact h a b |
| have hsecond (T : Set ℝ) (hT : MeasurableSet T) : |
| (μ.restrict (univ ×ˢ T)).map Prod.fst = (ν.restrict (univ ×ˢ T)).map Prod.fst := by |
| apply Measure.ext_of_Iic |
| intro a |
| rw [map_restrict_fst_rectangle μ measurableSet_Iic,map_restrict_fst_rectangle ν measurableSet_Iic] |
| have he := congrArg (fun ρ : Measure ℝ => ρ T) (hfirst a) |
| simpa only [map_restrict_snd_rectangle μ hT,map_restrict_snd_rectangle ν hT] using he |
| apply ext_of_generate_finite _ generateFrom_prod.symm isPiSystem_prod _ hU |
| rintro _ ⟨S,hS,T,hT,rfl⟩ |
| have he := congrArg (fun ρ : Measure ℝ => ρ S) (hsecond T hT) |
| simpa only [map_restrict_fst_rectangle μ hS,map_restrict_fst_rectangle ν hS] using he |
|
|
| lemma ordered_pair_cdf (μ : Measure (ℝ × ℝ)) |
| (ho : ∀ x ∈ μ.support, ∀ y ∈ μ.support, x.1 < y.1 → x.2 ≤ y.2) (a b : ℝ) : |
| μ (Iic a ×ˢ Iic b) = min (μ (Prod.fst ⁻¹' Iic a)) (μ (Prod.snd ⁻¹' Iic b)) := by |
| let S : Set (ℝ × ℝ) := Prod.fst ⁻¹' Iic a |
| let T : Set (ℝ × ℝ) := Prod.snd ⁻¹' Iic b |
| have hrect : Iic a ×ˢ Iic b = S ∩ T := rfl |
| rw [hrect] |
| change μ (S ∩ T) = min (μ S) (μ T) |
| have hsupport : ∀ᵐ x ∂μ, x ∈ μ.support := μ.support_mem_ae |
| by_cases h : ∀ x ∈ μ.support, x ∈ S → x ∈ T |
| · have hst : S ≤ᵐ[μ] T := hsupport.mono (fun x hx => h x hx) |
| rw [min_eq_left (measure_mono_ae hst)] |
| apply measure_congr |
| filter_upwards [hst] with x hx |
| exact propext ⟨fun hh => hh.1,fun hh => ⟨hh,hx hh⟩⟩ |
| · push Not at h |
| obtain ⟨x,hx,hxs,hxt⟩ := h |
| have hts : T ≤ᵐ[μ] S := by |
| filter_upwards [hsupport] with y hy |
| intro hyt |
| change y.1 ≤ a |
| by_contra! hy' |
| have hxy := ho x hx y hy (lt_of_le_of_lt hxs hy') |
| exact hxt (hxy.trans hyt) |
| rw [min_eq_right (measure_mono_ae hts)] |
| apply measure_congr |
| filter_upwards [hts] with y hy |
| exact propext ⟨fun hh => hh.2,fun hh => ⟨hy hh,hh⟩⟩ |
|
|
| lemma pair_quantile_cdf {μ ν : Measure ℝ} [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] |
| (hμ : ∀ᵐ x ∂μ, x ∈ Icc (0:ℝ) 1) (hν : ∀ᵐ x ∂ν, x ∈ Icc (0:ℝ) 1) (a b : ℝ) : |
| (unitUniform.map (fun u => (quantileFunction μ u,quantileFunction ν u))) (Iic a ×ˢ Iic b) = |
| min (μ (Iic a)) (ν (Iic b)) := by |
| rw [Measure.map_apply ((monotone_quantileFunction hμ).measurable.prodMk (monotone_quantileFunction hν).measurable) (measurableSet_Iic.prod measurableSet_Iic)] |
| have he : (fun u => (quantileFunction μ u,quantileFunction ν u)) ⁻¹' (Iic a ×ˢ Iic b) =ᵐ[unitUniform] |
| Iic (min (cdf μ a) (cdf ν b)) := by |
| filter_upwards [quantile_preimage_Iic hμ a,quantile_preimage_Iic hν b] with u hu hv |
| change (quantileFunction μ u ≤ a ∧ quantileFunction ν u ≤ b) = (u ≤ min (cdf μ a) (cdf ν b)) |
| rw [le_min_iff] |
| exact congrArg₂ And hu hv |
| rw [measure_congr he,unitUniform_Iic ⟨le_min (cdf_nonneg μ a) (cdf_nonneg ν b), |
| (min_le_left _ _).trans (cdf_le_one μ a)⟩,ENNReal.ofReal_min,ofReal_cdf,ofReal_cdf] |
| |
| |
| |
| theorem ordered_pair_quantile_law {ρ : Measure (ℝ × ℝ)} [IsProbabilityMeasure ρ] |
| (ho : ∀ x ∈ ρ.support, ∀ y ∈ ρ.support, x.1 < y.1 → x.2 ≤ y.2) |
| (hs : ∀ᵐ x ∂ρ, x.1 ∈ Icc (0:ℝ) 1 ∧ x.2 ∈ Icc (0:ℝ) 1) : |
| unitUniform.map (fun u => (quantileFunction (ρ.map Prod.fst) u,quantileFunction (ρ.map Prod.snd) u)) = ρ := by |
| let : IsProbabilityMeasure (ρ.map Prod.fst) := |
| (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance |
| let : IsProbabilityMeasure (ρ.map Prod.snd) := |
| (Measure.isProbabilityMeasure_map_iff measurable_snd.aemeasurable).mpr inferInstance |
| have hμ : ∀ᵐ x ∂ρ.map Prod.fst, x ∈ Icc (0:ℝ) 1 := |
| (ae_map_iff measurable_fst.aemeasurable measurableSet_Icc).mpr (hs.mono (fun _ h => h.1)) |
| have hν : ∀ᵐ x ∂ρ.map Prod.snd, x ∈ Icc (0:ℝ) 1 := |
| (ae_map_iff measurable_snd.aemeasurable measurableSet_Icc).mpr (hs.mono (fun _ h => h.2)) |
| let : IsProbabilityMeasure (unitUniform.map (fun u => |
| (quantileFunction (ρ.map Prod.fst) u,quantileFunction (ρ.map Prod.snd) u))) := |
| (Measure.isProbabilityMeasure_map_iff ((monotone_quantileFunction hμ).measurable.prodMk |
| (monotone_quantileFunction hν).measurable).aemeasurable).mpr inferInstance |
| apply measure_pair_eq_of_lower_rectangles _ (by simp) |
| intro a b |
| rw [pair_quantile_cdf hμ hν,ordered_pair_cdf ρ ho, |
| Measure.map_apply measurable_fst measurableSet_Iic,Measure.map_apply measurable_snd measurableSet_Iic] |
| |
| end IsingPerceptron |
| |
| |
| |
| |
| |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
| |
| |
| def treeTail (n d : ℕ) (t : ℝ) : ℝ := max 0 (min 1 (((n+1:ℕ):ℝ)*t-d)) |
| |
| lemma continuous_treeTail (n d : ℕ) : Continuous (treeTail n d) := by |
| unfold treeTail; fun_prop |
| |
| lemma treeTail_mem (n d : ℕ) (t : ℝ) : treeTail n d t ∈ Icc (0:ℝ) 1 := |
| ⟨le_max_left _ _, max_le zero_le_one (min_le_left _ _)⟩ |
| |
| lemma treeTail_level (n d j : ℕ) : treeTail n d ((j:ℝ)/(n+1:ℕ)) = |
| if d < j then 1 else 0 := by |
| have hn : ((n+1:ℕ):ℝ) ≠ 0 := by positivity |
| simp only [treeTail,mul_div_cancel₀ _ hn] |
| split_ifs with h |
| · have h' : (d:ℝ)+1 ≤ j := by exact_mod_cast h |
| rw [min_eq_left (by linarith),max_eq_right zero_le_one] |
| · have h' : (j:ℝ) ≤ d := by exact_mod_cast (Nat.le_of_not_gt h) |
| rw [min_eq_right (by linarith),max_eq_left (by linarith)] |
| |
| lemma treeTail_overlap (n : ℕ) (d : Fin n) (x y : LabeledLeaf n) : |
| treeTail n d (treeOverlap n x y) = |
| if (labeledAddress n x).take (d+1) = (labeledAddress n y).take (d+1) then 1 else 0 := by |
| rw [treeOverlap,treeTail_level] |
| simp only [labeled_prefix_eq_iff n x y (d := d+1) (by omega),Nat.add_one_le_iff] |
| |
| lemma enrichedArrayLaw_treeTail {N : ℕ} (hN : 0 < N) (n : ℕ) (b : ℕ → ℝ) |
| (hb : CascadeExponents n b) {h : ℕ → ℝ} (hh : Monotone h) (h0 : 0 ≤ h 0) |
| (u : Fin N → ℝ) (hu : ∀ j, |u j| ≤ 2) (ν : Measure (Spin N)) [IsProbabilityMeasure ν] |
| {A : Type*} [MeasurableSpace A] (P : Measure A) [IsProbabilityMeasure P] |
| {φ : A → Spin N → ℝ} (hm : Measurable φ) {K : ℝ} (hK : 0 ≤ K) |
| (hφ : ∀ y x, |φ y x| ≤ K) (r : ℝ≥0) (d : Fin n) : |
| (∫ x, treeTail n d (treeArray x 0 1) |
| ∂(enrichedArrayLaw P r n b h u ν hm : Measure JointArray)) = 1-b d := by |
| rw [enrichedArrayLaw_integral P r n b h u ν hm (fun x => treeTail n d (treeArray x 0 1)) |
| ((continuous_treeTail n d).comp (by unfold treeArray; fun_prop)).measurable] |
| let D : (Fin 2 → Spin N × LabeledLeaf n) → ℝ := fun σ => |
| if (labeledAddress n (σ 1).2).take (d+1) = (labeledAddress n (σ 0).2).take (d+1) then 1 else 0 |
| have hbD (σ) : |D σ| ≤ 1 := by dsimp only [D]; split_ifs <;> norm_num |
| have he := enrichedReplicaLaw_integral hN n b hh h0 u hu ν P hm hK hφ r D hbD |
| (fun i : Fin 2 => i.val) Fin.val_injective |
| rw [← enriched_tilted_label_tail P r n b hb h u ν hm d] |
| change _ = enrichedReplicaAverage P r n b h u ν φ D |
| rw [← he] |
| apply integral_congr_ae |
| apply ae_of_all |
| intro σ |
| change treeTail n d (treeOverlap n (σ 0).2 (σ 1).2) = _ |
| rw [treeTail_overlap] |
| simp only [D,Fin.val_zero,Fin.val_one,eq_comm] |
| |
| def treeLevels (n : ℕ) : Set ℝ := range (fun j : Fin (n+1) => (j:ℝ)/(n+1:ℕ)) |
| |
| lemma isClosed_treeLevels (n : ℕ) : IsClosed (treeLevels n) := (finite_range _).isClosed |
| |
| lemma treeOverlap_mem_levels (n : ℕ) (x y : LabeledLeaf n) : treeOverlap n x y ∈ treeLevels n := |
| ⟨⟨labeledCommonDepth n x y,by have := labeledCommonDepth_le n x y; omega⟩,rfl⟩ |
| |
| lemma enrichedArrayLaw_treeLevels {N : ℕ} {A : Type*} [MeasurableSpace A] |
| (P : Measure A) [IsProbabilityMeasure P] (r : ℝ≥0) (n : ℕ) (b h : ℕ → ℝ) |
| (u : Fin N → ℝ) (ν : Measure (Spin N)) [IsProbabilityMeasure ν] |
| {φ : A → Spin N → ℝ} (hm : Measurable φ) : |
| ∀ᵐ x ∂(enrichedArrayLaw P r n b h u ν hm : Measure JointArray), treeArray x 0 1 ∈ treeLevels n := by |
| rw [enrichedArrayLaw] |
| apply (ae_map_iff (measurable_sampledOverlapArray (enrichedJointEntry n)).aemeasurable |
| ((isClosed_treeLevels n).measurableSet.preimage (by unfold treeArray; fun_prop))).mpr |
| exact ae_of_all _ (fun σ => treeOverlap_mem_levels n (σ 0).2 (σ 1).2) |
| |
| |
| |
| theorem enrichedArrayLaw_limit_tree |
| (N : ℕ → ℕ) (hN : ∀ k, 0 < N k) (n : ℕ) (b : ℕ → ℝ) (hb : CascadeExponents n b) |
| (h : ℕ → ℕ → ℝ) (hh : ∀ k, Monotone (h k)) (h0 : ∀ k, 0 ≤ h k 0) |
| (u : (k : ℕ) → Fin (N k) → ℝ) (hu : ∀ k j, |u k j| ≤ 2) |
| (ν : (k : ℕ) → Measure (Spin (N k))) [∀ k, IsProbabilityMeasure (ν k)] |
| (A : ℕ → Type*) [∀ k, MeasurableSpace (A k)] |
| (P : (k : ℕ) → Measure (A k)) [∀ k, IsProbabilityMeasure (P k)] |
| (φ : (k : ℕ) → A k → Spin (N k) → ℝ) (hm : ∀ k, Measurable (φ k)) |
| (K : ℝ) (hK : 0 ≤ K) (hφ : ∀ k y x, |φ k y x| ≤ K) |
| (r : ℕ → ℝ≥0) (μ : ProbabilityMeasure JointArray) |
| (hL : Tendsto (fun k => enrichedArrayLaw (P k) (r k) n b (h k) (u k) (ν k) (hm k)) atTop (𝓝 μ)) : |
| (∀ᵐ x ∂(μ : Measure JointArray), treeArray x 0 1 ∈ treeLevels n) ∧ |
| ∀ d : Fin n, (∫ x, treeTail n d (treeArray x 0 1) ∂(μ : Measure JointArray)) = 1-b d := by |
| constructor |
| · exact ae_closed_of_weak_limit hL ((isClosed_treeLevels n).preimage (by unfold treeArray; fun_prop)) |
| (fun k => enrichedArrayLaw_treeLevels (P k) (r k) n b (h k) (u k) (ν k) (hm k)) |
| · intro d |
| have he := jointArray_tendsto_integral hL |
| (hF := (continuous_treeTail n d).comp (by unfold treeArray; fun_prop : Continuous (fun x : JointArray => treeArray x 0 1))) |
| have ha (k) := enrichedArrayLaw_treeTail (hN k) n b hb (hh k) (h0 k) (u k) (hu k) |
| (ν k) (P k) (hm k) hK (hφ k) (r k) d |
| have he' := he.congr' (Eventually.of_forall ha) |
| exact tendsto_nhds_unique he' tendsto_const_nhds |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma treeTail_eq_level_indicator {n d : ℕ} {t : ℝ} (ht : t ∈ treeLevels n) : |
| treeTail n d t = if (d:ℝ)/(n+1:ℕ) < t then 1 else 0 := by |
| obtain ⟨j,rfl⟩ := ht |
| rw [treeTail_level] |
| simp only [div_lt_div_iff_of_pos_right (by positivity : (0:ℝ) < (n+1:ℕ)),Nat.cast_lt] |
|
|
| lemma cdf_of_treeTail {ρ : Measure ℝ} [IsProbabilityMeasure ρ] {n d : ℕ} |
| (hρ : ∀ᵐ t ∂ρ, t ∈ treeLevels n) {b : ℝ} |
| (hb : (∫ t, treeTail n d t ∂ρ) = 1-b) : cdf ρ ((d:ℝ)/(n+1:ℕ)) = b := by |
| have hi : Integrable (treeTail n d) ρ := |
| integrable_of_measurable_abs_le (continuous_treeTail n d).measurable |
| (fun t => by rw [abs_of_nonneg (treeTail_mem n d t).1]; exact (treeTail_mem n d t).2) |
| calc |
| _ = ∫ t, (Iic ((d:ℝ)/(n+1:ℕ))).indicator (fun _ => (1:ℝ)) t ∂ρ := by |
| rw [integral_indicator_const _ measurableSet_Iic,cdf_eq_real,smul_eq_mul,mul_one] |
| _ = ∫ t, 1-treeTail n d t ∂ρ := integral_congr_ae (hρ.mono (fun t ht => by |
| simp only [treeTail_eq_level_indicator (d := d) ht] |
| by_cases h : (d:ℝ)/(n+1:ℕ) < t |
| · simp only [Set.indicator,Set.mem_Iic,h,not_le.mpr h,ite_false,ite_true,sub_self] |
| · simp only [Set.indicator,Set.mem_Iic,h,le_of_not_gt h,ite_false,ite_true,sub_zero])) |
| _ = b := by rw [integral_sub (integrable_const _) hi,hb]; simp |
|
|
| lemma quantile_treeTail {ρ : Measure ℝ} [IsProbabilityMeasure ρ] {n d : ℕ} |
| (hs : ∀ᵐ t ∂ρ, t ∈ Icc (0:ℝ) 1) |
| (hρ : ∀ᵐ t ∂ρ, t ∈ treeLevels n) {b : ℝ} |
| (hb : (∫ t, treeTail n d t ∂ρ) = 1-b) : |
| ∀ᵐ u ∂unitUniform, treeTail n d (quantileFunction ρ u) = if b < u then 1 else 0 := by |
| have hm := (monotone_quantileFunction hs).measurable |
| have hl := quantileFunction_law hs |
| have hlev : ∀ᵐ u ∂unitUniform, quantileFunction ρ u ∈ treeLevels n := by |
| apply (ae_map_iff hm.aemeasurable (isClosed_treeLevels n).measurableSet).mp |
| rw [hl] |
| exact hρ |
| have hc := cdf_of_treeTail hρ hb |
| filter_upwards [hlev,ae_restrict_mem (μ := volume) measurableSet_Ioo] with u hu hu' |
| rw [treeTail_eq_level_indicator hu] |
| have he := quantileFunction_le_iff hs hu' (x := (d:ℝ)/(n+1:ℕ)) |
| rw [hc] at he |
| have he' : (d:ℝ)/(n+1:ℕ) < quantileFunction ρ u ↔ b < u := by |
| simpa only [not_le] using not_congr he |
| simp only [he'] |
|
|
| |
|
|
| theorem ordered_pair_tree_tail_integral {ρ : Measure (ℝ × ℝ)} [IsProbabilityMeasure ρ] |
| (ho : ∀ x ∈ ρ.support, ∀ y ∈ ρ.support, x.1 < y.1 → x.2 ≤ y.2) |
| (hs : ∀ᵐ x ∂ρ, x.1 ∈ Icc (0:ℝ) 1 ∧ x.2 ∈ Icc (0:ℝ) 1) |
| {n d : ℕ} (hl : ∀ᵐ x ∂ρ, x.2 ∈ treeLevels n) {b : ℝ} |
| (ht : (∫ x, treeTail n d x.2 ∂ρ) = 1-b) : |
| (∫ x, x.1*treeTail n d x.2 ∂ρ) = |
| ∫ u in Ioi b, quantileFunction (ρ.map Prod.fst) u ∂unitUniform := by |
| let : IsProbabilityMeasure (ρ.map Prod.fst) := |
| (Measure.isProbabilityMeasure_map_iff measurable_fst.aemeasurable).mpr inferInstance |
| let : IsProbabilityMeasure (ρ.map Prod.snd) := |
| (Measure.isProbabilityMeasure_map_iff measurable_snd.aemeasurable).mpr inferInstance |
| have hr : ∀ᵐ t ∂ρ.map Prod.fst, t ∈ Icc (0:ℝ) 1 := |
| (ae_map_iff measurable_fst.aemeasurable measurableSet_Icc).mpr (hs.mono (fun _ h => h.1)) |
| have hT : ∀ᵐ t ∂ρ.map Prod.snd, t ∈ Icc (0:ℝ) 1 := |
| (ae_map_iff measurable_snd.aemeasurable measurableSet_Icc).mpr (hs.mono (fun _ h => h.2)) |
| have hlev : ∀ᵐ t ∂ρ.map Prod.snd, t ∈ treeLevels n := |
| (ae_map_iff measurable_snd.aemeasurable (isClosed_treeLevels n).measurableSet).mpr hl |
| have hti : (∫ t, treeTail n d t ∂ρ.map Prod.snd) = 1-b := by |
| rw [integral_map measurable_snd.aemeasurable (continuous_treeTail n d).measurable.aestronglyMeasurable] |
| exact ht |
| have hqt := quantile_treeTail hT hlev hti |
| have hm := (monotone_quantileFunction hr).measurable.prodMk (monotone_quantileFunction hT).measurable |
| have hF : Measurable (fun x : ℝ × ℝ => x.1*treeTail n d x.2) := |
| measurable_fst.mul ((continuous_treeTail n d).measurable.comp measurable_snd) |
| have hi := integral_map (μ := unitUniform) hm.aemeasurable hF.aestronglyMeasurable |
| rw [ordered_pair_quantile_law ho hs] at hi |
| rw [hi,← integral_indicator measurableSet_Ioi] |
| apply integral_congr_ae |
| filter_upwards [hqt] with u hu |
| rw [hu] |
| by_cases h : b < u <;> simp [h] |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma enrichedMeanPressure_field_cost {N : ℕ} (hN : 0 < N) (n : ℕ) (b : ℕ → ℝ) |
| (hb : CascadeExponents n b) {h l : ℕ → ℝ} |
| (hh : Monotone h) (h0 : 0 ≤ h 0) (hl : Monotone l) (l0 : 0 ≤ l 0) |
| (u : Fin N → ℝ) (hu : ∀ j, |u j| ≤ 2) (ν : Measure (Spin N)) [IsProbabilityMeasure ν] |
| {A : Type*} [MeasurableSpace A] (P : Measure A) [IsProbabilityMeasure P] |
| {φ : A → Spin N → ℝ} (hm : Measurable φ) {K : ℝ} (hK : 0 ≤ K) |
| (hφ : ∀ y x, |φ y x| ≤ K) (r : ℝ≥0) : |
| |enrichedMeanPressure P r n b (fun i => h i+l i) u ν φ- |
| enrichedMeanPressure P r n b h u ν φ| ≤ l n/2 := by |
| have he := enrichedMeanPressure_field_insert hN n b hb hh h0 hl l0 u hu ν P hm hK hφ r |
| (a := 1) zero_le_one |
| simp only [one_mul,Real.sqrt_one] at he |
| have hc := random_cylinder_cgf_mean_bounds (P := enrichedCylinderLaw P r n b) |
| (measurable_enrichedGibbsReference n h u ν hm) (externalFieldCoefficients n l) |
| (fun s => (externalFieldCoefficients_variance n hl l0 s).le) 1 |
| simp only [one_pow,one_mul] at hc |
| have hn : (0:ℝ)<N := by exact_mod_cast hN |
| have hc' := (div_le_iff₀ hn).mpr (show (∫ z, cgf (fun x => cylinderField |
| (externalFieldCoefficients n l x) z.2) (enrichedGibbsReference n h u ν φ z.1) 1 |
| ∂(enrichedCylinderLaw P r n b).prod gaussianCoordinates) ≤ l n/2*(N:ℝ) by nlinarith [hc.2]) |
| have hc0 := div_nonneg hc.1 hn.le |
| rw [he] |
| apply abs_le.mpr |
| constructor <;> nlinarith |
| |
| |
| |
| def finiteFieldPath {n : ℕ} (a : Fin (n+1) → ℝ) (i : ℕ) : ℝ := |
| ∑ j, if j.val ≤ i then a j else 0 |
| |
| lemma finiteFieldPath_last {n : ℕ} (a : Fin (n+1) → ℝ) : finiteFieldPath a n = ∑ j, a j := by |
| simp only [finiteFieldPath,show ∀ j : Fin (n+1), j.val ≤ n from fun j => by omega,ite_true] |
| |
| lemma finiteFieldPath_nonneg {n : ℕ} {a : Fin (n+1) → ℝ} (ha : ∀ j, 0 ≤ a j) (i : ℕ) : |
| 0 ≤ finiteFieldPath a i := Finset.sum_nonneg (fun j _ => by split_ifs; exact ha j; exact le_refl 0) |
| |
| lemma monotone_finiteFieldPath {n : ℕ} {a : Fin (n+1) → ℝ} (ha : ∀ j, 0 ≤ a j) : |
| Monotone (finiteFieldPath a) := by |
| intro i k hik |
| apply Finset.sum_le_sum |
| intro j _ |
| by_cases hj : j.val ≤ i |
| · simp [hj,hj.trans hik] |
| · simp only [hj,ite_false] |
| split_ifs; exact ha j; exact le_refl 0 |
| |
| lemma finiteFieldPath_add {n : ℕ} (a c : Fin (n+1) → ℝ) : |
| finiteFieldPath (fun i => a i+c i) = fun i => finiteFieldPath a i+finiteFieldPath c i := by |
| funext i |
| simp only [finiteFieldPath,← Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro j _ |
| split_ifs <;> simp |
| |
| lemma finiteFieldPath_sub {n : ℕ} (a c : Fin (n+1) → ℝ) : |
| finiteFieldPath (fun i => a i-c i) = fun i => finiteFieldPath a i-finiteFieldPath c i := by |
| funext i |
| simp only [finiteFieldPath,← Finset.sum_sub_distrib] |
| apply Finset.sum_congr rfl |
| intro j _ |
| split_ifs <;> simp |
| |
| lemma enrichedMeanPressure_field_lipschitz {N : ℕ} (hN : 0 < N) (n : ℕ) (b : ℕ → ℝ) |
| (hb : CascadeExponents n b) {a c : Fin (n+1) → ℝ} |
| (ha : ∀ j, 0 ≤ a j) (hc : ∀ j, 0 ≤ c j) |
| (u : Fin N → ℝ) (hu : ∀ j, |u j| ≤ 2) (ν : Measure (Spin N)) [IsProbabilityMeasure ν] |
| {A : Type*} [MeasurableSpace A] (P : Measure A) [IsProbabilityMeasure P] |
| {φ : A → Spin N → ℝ} (hm : Measurable φ) {K : ℝ} (hK : 0 ≤ K) |
| (hφ : ∀ y x, |φ y x| ≤ K) (r : ℝ≥0) : |
| |enrichedMeanPressure P r n b (finiteFieldPath a) u ν φ- |
| enrichedMeanPressure P r n b (finiteFieldPath c) u ν φ| ≤ (∑ j, |a j-c j|)/2 := by |
| let d : Fin (n+1) → ℝ := fun j => min (a j) (c j) |
| have hd : ∀ j, 0 ≤ d j := fun j => le_min (ha j) (hc j) |
| have had : ∀ j, 0 ≤ a j-d j := fun j => sub_nonneg.mpr (min_le_left _ _) |
| have hcd : ∀ j, 0 ≤ c j-d j := fun j => sub_nonneg.mpr (min_le_right _ _) |
| have heA := enrichedMeanPressure_field_cost hN n b hb (monotone_finiteFieldPath hd) |
| (finiteFieldPath_nonneg hd 0) (monotone_finiteFieldPath had) (finiteFieldPath_nonneg had 0) |
| u hu ν P hm hK hφ r |
| have heC := enrichedMeanPressure_field_cost hN n b hb (monotone_finiteFieldPath hd) |
| (finiteFieldPath_nonneg hd 0) (monotone_finiteFieldPath hcd) (finiteFieldPath_nonneg hcd 0) |
| u hu ν P hm hK hφ r |
| simp only [finiteFieldPath_sub,add_sub_cancel] at heA heC |
| have hs : finiteFieldPath a n-finiteFieldPath d n + (finiteFieldPath c n-finiteFieldPath d n) = |
| ∑ j, |a j-c j| := by |
| simp only [finiteFieldPath_last,← Finset.sum_sub_distrib,← Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro j _ |
| dsimp only [d] |
| rcases le_total (a j) (c j) with h | h |
| · rw [min_eq_left h,abs_of_nonpos (sub_nonpos.mpr h)]; ring |
| · rw [min_eq_right h,abs_of_nonneg (sub_nonneg.mpr h)]; ring |
| have ht := abs_sub_le (enrichedMeanPressure P r n b (finiteFieldPath a) u ν φ) |
| (enrichedMeanPressure P r n b (finiteFieldPath d) u ν φ) |
| (enrichedMeanPressure P r n b (finiteFieldPath c) u ν φ) |
| rw [abs_sub_comm (enrichedMeanPressure P r n b (finiteFieldPath d) u ν φ)] at ht |
| linarith |
| |
| end IsingPerceptron |
| |
| |
| |
| |
| |
| open MeasureTheory ProbabilityTheory |
| open scoped BigOperators NNReal ENNReal |
| |
| namespace IsingPerceptron |
| open Set Filter |
| open scoped Topology |
| |
| lemma factorial_successor_term (n : ℕ) (x : ℝ) : |
| (n+1 : ℝ) * x^(n+1) / (n+1).factorial = x * (x^n / n.factorial) := by |
| rw [Nat.factorial_succ,Nat.cast_mul,Nat.cast_add,Nat.cast_one,pow_succ] |
| have hn : (n.factorial : ℝ) ≠ 0 := by positivity |
| have hn1 : (n : ℝ)+1 ≠ 0 := by positivity |
| field_simp |
| |
| lemma summable_count_pow_div_factorial (x : ℝ) : |
| Summable (fun n : ℕ => (n : ℝ)*x^n/n.factorial) := by |
| apply (summable_nat_add_iff 1).mp |
| simpa only [Nat.cast_add,Nat.cast_one,factorial_successor_term] using |
| (Real.summable_pow_div_factorial x).mul_left x |
| |
| lemma summable_linear_pow_div_factorial (C K x : ℝ) : |
| Summable (fun n : ℕ => (C+K*n)*x^n/n.factorial) := by |
| have hs := ((Real.summable_pow_div_factorial x).mul_left C).add |
| ((summable_count_pow_div_factorial x).mul_left K) |
| apply hs.congr |
| intro n |
| ring |
| |
| lemma summable_growth_exponentialSeries {a : ℕ → ℝ} {C K : ℝ} |
| (_hC : 0 ≤ C) (_hK : 0 ≤ K) (ha : ∀ n, |a n| ≤ C+K*n) (x : ℝ) : |
| Summable (fun n : ℕ => a n*x^n/n.factorial) := by |
| apply Summable.of_norm_bounded (summable_linear_pow_div_factorial C K |x|) |
| intro n |
| simp only [Real.norm_eq_abs,abs_div,abs_mul,abs_pow,Nat.abs_cast] |
| gcongr |
| exact ha n |
| |
| lemma hasDerivAt_exponentialSeries {a : ℕ → ℝ} {C K : ℝ} |
| (hC : 0 ≤ C) (hK : 0 ≤ K) (ha : ∀ n, |a n| ≤ C+K*n) (x : ℝ) : |
| HasDerivAt (fun y => ∑' n : ℕ, a n*y^n/n.factorial) |
| (∑' n : ℕ, a (n+1)*x^n/n.factorial) x := by |
| let B := |x|+1 |
| have hB : 0 < B := by dsimp [B]; positivity |
| have hshift n : |a (n+1)| ≤ (C+K)+K*n := by |
| have H := ha (n+1) |
| push_cast at H |
| linarith |
| have hu := summable_linear_pow_div_factorial (C+K) K B |
| have hg (n : ℕ) (y : ℝ) : |
| HasDerivAt (fun y : ℝ => a (n+1)*y^(n+1)/(n+1).factorial) |
| (a (n+1)*y^n/n.factorial) y := by |
| convert (((hasDerivAt_id y).pow (n+1)).const_mul (a (n+1))).div_const ((n+1).factorial : ℝ) using 1 <;> try rfl |
| simp only [id_eq,Nat.add_sub_cancel,Nat.cast_add,Nat.cast_one,mul_one,Nat.factorial_succ,Nat.cast_mul] |
| have hn : (n.factorial : ℝ) ≠ 0 := by positivity |
| have hn1 : (n : ℝ)+1 ≠ 0 := by positivity |
| field_simp |
| have hbound (n : ℕ) (y : ℝ) (hy : y ∈ Ioo (-B) B) : |
| ‖a (n+1)*y^n/n.factorial‖ ≤ ((C+K)+K*n)*B^n/n.factorial := by |
| have hab : |y| ≤ B := le_of_lt (abs_lt.mpr hy) |
| simp only [Real.norm_eq_abs,abs_div,abs_mul,abs_pow,Nat.abs_cast] |
| gcongr |
| exact hshift n |
| have hzero : Summable (fun n : ℕ => a (n+1)*(0:ℝ)^(n+1)/(n+1).factorial) := by simp |
| have hs := hasDerivAt_tsum_of_isPreconnected hu isOpen_Ioo (convex_Ioo (-B) B).isPreconnected |
| (fun n y _ => hg n y) hbound (show (0:ℝ) ∈ Ioo (-B) B from ⟨by linarith, hB⟩) hzero |
| (show x ∈ Ioo (-B) B from abs_lt.mp (by dsimp [B]; linarith)) |
| have he (y : ℝ) : (∑' n : ℕ, a n*y^n/n.factorial) = |
| a 0 + ∑' n : ℕ, a (n+1)*y^(n+1)/(n+1).factorial := by |
| rw [← (summable_growth_exponentialSeries hC hK ha y).sum_add_tsum_nat_add 1] |
| simp |
| simpa only [← he] using hs.const_add (a 0) |
| |
| |
| |
| def poissonMean (a : ℕ → ℝ) (t : ℝ) : ℝ := |
| Real.exp (-t) * ∑' n : ℕ, a n*t^n/n.factorial |
|
|
| lemma poissonMean_eq_integral (a : ℕ → ℝ) (r : ℝ≥0) : |
| poissonMean a r = ∫ n, a n ∂poissonMeasure r := by |
| rw [poissonMean,integral_poissonMeasure,← tsum_mul_left] |
| apply tsum_congr |
| intro n |
| ring |
|
|
| lemma hasDerivAt_poissonMean {a : ℕ → ℝ} {C K : ℝ} |
| (hC : 0 ≤ C) (hK : 0 ≤ K) (ha : ∀ n, |a n| ≤ C+K*n) (t : ℝ) : |
| HasDerivAt (poissonMean a) (poissonMean (fun n => a (n+1)-a n) t) t := by |
| have hshift n : |a (n+1)| ≤ (C+K)+K*n := by |
| have H := ha (n+1) |
| push_cast at H |
| linarith |
| have hd := (((hasDerivAt_id t).neg.exp).mul (hasDerivAt_exponentialSeries hC hK ha t)) |
| have he : (∑' n : ℕ, (a (n+1)-a n)*t^n/n.factorial) = |
| (∑' n : ℕ, a (n+1)*t^n/n.factorial) - ∑' n : ℕ, a n*t^n/n.factorial := by |
| rw [← (summable_growth_exponentialSeries (add_nonneg hC hK) hK hshift t).tsum_sub |
| (summable_growth_exponentialSeries hC hK ha t)] |
| apply tsum_congr |
| intro n |
| ring |
| convert hd using 1 <;> try rfl |
| change Real.exp (-t) * (∑' n : ℕ, (a (n+1)-a n)*t^n/n.factorial) = |
| Real.exp (-t) * (-1) * (∑' n : ℕ, a n*t^n/n.factorial) + |
| Real.exp (-t) * (∑' n : ℕ, a (n+1)*t^n/n.factorial) |
| rw [he] |
| ring |
|
|
| lemma poissonMean_derivative_bound {a : ℕ → ℝ} {K : ℝ} (_hK : 0 ≤ K) |
| (ha : ∀ n, |a (n+1)-a n| ≤ K) (r : ℝ≥0) : |
| |poissonMean (fun n => a (n+1)-a n) r| ≤ K := by |
| rw [poissonMean_eq_integral] |
| exact (abs_integral_le_integral_abs).trans (by |
| have hi : Integrable (fun n => |a (n+1)-a n|) (poissonMeasure r) := |
| Integrable.of_bound Measurable.of_discrete.aestronglyMeasurable K |
| (ae_of_all _ (fun n => by simpa only [Real.norm_eq_abs,abs_abs] using ha n)) |
| simpa using integral_mono hi (integrable_const K) ha) |
|
|
| |
|
|
| theorem poisson_count_derivative {a : ℕ → ℝ} {K : ℝ} (hK : 0 ≤ K) |
| (ha : ∀ n, |a (n+1)-a n| ≤ K) (t : ℝ) : |
| HasDerivAt (poissonMean a) (poissonMean (fun n => a (n+1)-a n) t) t := by |
| have hg : ∀ n, |a n| ≤ |a 0|+K*n := by |
| intro n |
| induction n with |
| | zero => simp |
| | succ n ih => |
| have hh : |a (n+1)| ≤ |a n|+K := by |
| calc |
| _ = |a n+(a (n+1)-a n)| := by congr 1; ring |
| _ ≤ |a n|+|a (n+1)-a n| := abs_add_le _ _ |
| _ ≤ _ := add_le_add_right (ha n) _ |
| push_cast |
| linarith |
| exact hasDerivAt_poissonMean (abs_nonneg _) hK hg t |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| abbrev EnrichedFixedData (n : ℕ) (A : Type*) := ((ℕ → A) × LabeledTree n) × (ℕ → ℝ) |
|
|
| def enrichedFixedLaw {A : Type*} [MeasurableSpace A] (P : Measure A) |
| (n : ℕ) (b : ℕ → ℝ) : Measure (EnrichedFixedData n A) := |
| ((Measure.infinitePi (fun _ : ℕ => P)).prod (labeledCascadeLaw n b)).prod gaussianCoordinates |
|
|
| instance enrichedFixedLaw_probability {A : Type*} [MeasurableSpace A] (P : Measure A) |
| [IsProbabilityMeasure P] (n : ℕ) (b : ℕ → ℝ) : IsProbabilityMeasure (enrichedFixedLaw P n b) := by |
| unfold enrichedFixedLaw |
| infer_instance |
|
|
| def enrichedCountJoin {n : ℕ} {A : Type*} (z : ℕ × EnrichedFixedData n A) : EnrichedCylinderData n A := |
| (((z.1,z.2.1.1),z.2.1.2),z.2.2) |
|
|
| lemma enrichedCountJoin_preserving {A : Type*} [MeasurableSpace A] (P : Measure A) |
| [IsProbabilityMeasure P] (r : ℝ≥0) (n : ℕ) (b : ℕ → ℝ) : |
| MeasurePreserving (enrichedCountJoin (n := n) (A := A)) |
| ((poissonMeasure r).prod (enrichedFixedLaw P n b)) (enrichedCylinderLaw P r n b) := by |
| let μ := poissonMeasure r |
| let ν := Measure.infinitePi (fun _ : ℕ => P) |
| let ρ := (labeledCascadeLaw n b : Measure (LabeledTree n)) |
| let τ := gaussianCoordinates |
| have h1 := (measurePreserving_prodAssoc μ (ν.prod ρ) τ).symm MeasurableEquiv.prodAssoc |
| have h2 := ((measurePreserving_prodAssoc μ ν ρ).symm MeasurableEquiv.prodAssoc).prod |
| (MeasurePreserving.id τ) |
| exact h2.comp h1 |
|
|
| lemma poisson_ae_all {p : ℕ → Prop} {r : ℝ≥0} (hr : 0 < r) (hp : ∀ᵐ m ∂poissonMeasure r, p m) : |
| ∀ m, p m := by |
| intro m |
| apply ae_iff_of_countable.mp hp m |
| rw [poissonMeasure_singleton] |
| apply ne_of_gt |
| apply ENNReal.ofReal_pos.mpr |
| positivity |
|
|
| lemma enrichedFixed_pressure_integrable {N : ℕ} (hN : 0 < N) (n : ℕ) (b : ℕ → ℝ) |
| (hb : CascadeExponents n b) {h : ℕ → ℝ} (hh : Monotone h) (h0 : 0 ≤ h 0) |
| (u : Fin N → ℝ) (hu : ∀ j, |u j| ≤ 2) (ν : Measure (Spin N)) [IsProbabilityMeasure ν] |
| {A : Type*} [MeasurableSpace A] (P : Measure A) [IsProbabilityMeasure P] |
| {φ : A → Spin N → ℝ} (hm : Measurable φ) {K : ℝ} (hK : 0 ≤ K) |
| (hφ : ∀ y x, |φ y x| ≤ K) (m : ℕ) : |
| Integrable (fun z => enrichedCylinderPressure n h u ν φ (enrichedCountJoin (m,z))) (enrichedFixedLaw P n b) := by |
| have hn : (N:ℝ) ≠ 0 := by exact_mod_cast hN.ne' |
| have hi := (enrichedCylinderPressure_field_cap hN n b hb hh h0 (le_refl (h n)) u hu ν P hm hK hφ |
| (1:ℝ≥0) (α := 1/N) (by simp [hn])).1 |
| have hi' := (hi.comp_measurePreserving (enrichedCountJoin_preserving P 1 n b)).integrable (by norm_num) |
| exact poisson_ae_all (by norm_num : (0:ℝ≥0)<1) hi'.prod_right_ae m |
| |
| lemma enrichedFixed_exp_ae {N : ℕ} (hN : 0 < N) (n : ℕ) (b : ℕ → ℝ) |
| {h : ℕ → ℝ} (hh : Monotone h) (h0 : 0 ≤ h 0) |
| (u : Fin N → ℝ) (hu : ∀ j, |u j| ≤ 2) (ν : Measure (Spin N)) [IsProbabilityMeasure ν] |
| {A : Type*} [MeasurableSpace A] (P : Measure A) [IsProbabilityMeasure P] |
| {φ : A → Spin N → ℝ} {K : ℝ} (hK : 0 ≤ K) |
| (hφ : ∀ y x, |φ y x| ≤ K) (m : ℕ) : |
| ∀ᵐ z ∂enrichedFixedLaw P n b, |
| Integrable (fun s => Real.exp (enrichedHamiltonian n h u φ (enrichedCountJoin (m,z)) s)) |
| (labeledSpinReference n ν z.1.2) := by |
| have he := (enrichedCountJoin_preserving P 1 n b).quasiMeasurePreserving.ae |
| (enrichedCylinder_exp_ae hN n b hh h0 u hu ν P hK hφ (1:ℝ≥0)) |
| exact poisson_ae_all (by norm_num : (0:ℝ≥0)<1) (Measure.ae_ae_of_ae_prod he) m |
| |
| lemma abs_cgf_one_le {X : Type*} [MeasurableSpace X] (ν : Measure X) [IsProbabilityMeasure ν] |
| {Y : X → ℝ} (hY : Measurable Y) {K : ℝ} (hYb : ∀ x, |Y x| ≤ K) : |
| |cgf Y ν 1| ≤ K := by |
| have hi : Integrable (fun x => Real.exp (Y x)) ν := Integrable.of_bound |
| hY.exp.aestronglyMeasurable (Real.exp K) (ae_of_all _ (fun x => by |
| simpa only [Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)] using |
| Real.exp_le_exp.mpr (le_trans (le_abs_self _) (hYb x)))) |
| have hp : 0 < ∫ x, Real.exp (Y x) ∂ν := MeasureTheory.integral_exp_pos hi |
| have hu : (∫ x, Real.exp (Y x) ∂ν) ≤ Real.exp K := by |
| simpa using integral_mono hi (integrable_const (Real.exp K)) |
| (fun x => Real.exp_le_exp.mpr (le_trans (le_abs_self _) (hYb x))) |
| have hl : Real.exp (-K) ≤ ∫ x, Real.exp (Y x) ∂ν := by |
| simpa using integral_mono (integrable_const (Real.exp (-K))) hi |
| (fun x => Real.exp_le_exp.mpr (neg_le.mp (le_trans (neg_le_abs _) (hYb x)))) |
| unfold cgf mgf |
| simp only [one_mul] |
| apply abs_le.mpr |
| exact ⟨by simpa using Real.log_le_log (Real.exp_pos (-K)) hl, |
| by simpa using Real.log_le_log hp hu⟩ |
| |
| end IsingPerceptron |
| |
| end |
| |
| end OAI |
| |
