| import Mathlib |
| import OAI.Probability.Perceptron.Pressure.EnrichedPatternVariance |
| import OAI.Probability.Perceptron.Cascade.PoissonCountMoments |
| import OAI.Probability.Perceptron.Variational.CountMixtureVariance |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal ENNReal BigOperators BoundedContinuousFunction |
| namespace SphericalPerceptronFreeEnergy |
|
|
| def infinitePatternRowsLaw (N : ℕ) : Measure (ℕ → Fin N → ℝ) := |
| Measure.infinitePi fun _ : ℕ => Measure.pi fun _ : Fin N => gaussianReal 0 1 |
| |
| instance (N : ℕ) : IsProbabilityMeasure (infinitePatternRowsLaw N) := by |
| unfold infinitePatternRowsLaw |
| infer_instance |
| |
| def patternPrefix (N M : ℕ) (g : ℕ → Fin N → ℝ) : Fin M → Fin N → ℝ := |
| fun a => g a.val |
| |
| lemma patternPrefix_measurable (N M : ℕ) : Measurable (patternPrefix N M) := by |
| unfold patternPrefix |
| fun_prop |
| |
| lemma patternPrefix_measurePreserving (N M : ℕ) : MeasurePreserving (patternPrefix N M) |
| (infinitePatternRowsLaw N) (finitePatternRowsLaw N M) := by |
| refine ⟨patternPrefix_measurable N M,?_⟩ |
| change Measure.map (fun g : ℕ → Fin N → ℝ => fun a : Fin M => g a.val) |
| (Measure.infinitePi fun _ : ℕ => Measure.pi fun _ : Fin N => gaussianReal 0 1)= |
| Measure.pi fun _ : Fin M => Measure.pi fun _ : Fin N => gaussianReal 0 1 |
| rw [Measure.map_infinitePi_infinitePi_of_inj Fin.val_injective,Measure.infinitePi_eq_pi] |
| |
| lemma normalizedPatternEnergy_prefix_succ (N M : ℕ) (f : ℝ →ᵇ ℝ) |
| (g : ℕ → Fin N → ℝ) (x : NormalizedSpin N) : |
| |normalizedPatternEnergy N (M+1) f (patternPrefix N (M+1) g) x- |
| normalizedPatternEnergy N M f (patternPrefix N M g) x| ≤ ‖f‖ := by |
| unfold normalizedPatternEnergy |
| rw [Fin.sum_univ_castSucc] |
| simp only [patternPrefix,Fin.val_castSucc,Fin.val_last,add_sub_cancel_left] |
| simpa only [Real.norm_eq_abs] using f.norm_coe_le_norm (∑ i, g M i*x.val i) |
| |
| def enrichedPoissonLog (n k : ℕ) (f : ℝ →ᵇ ℝ) |
| (p d : Fin (n+1) → ℕ) (u : Fin (n+1) → ℝ) (h : Fin (k+1) → ℝ) |
| (a : ℕ × ((ℕ → Fin (n+1) → ℝ) × |
| (EnrichedMark (n+1) (n+1) p × DecoratedCascade (EnrichedMark (n+1) (n+1) p) k))) : ℝ := |
| enrichedCascadeLog n a.1 k f (patternPrefix (n+1) a.1 a.2.1) p d u h a.2.2 |
| |
| def enrichedRowsDisorderLaw (n k : ℕ) (p : Fin (n+1) → ℕ) (z : Fin k → ℝ) := |
| (infinitePatternRowsLaw (n+1)).prod (enrichedDisorderLaw n k p z) |
| |
| instance (n k : ℕ) (p : Fin (n+1) → ℕ) (z : Fin k → ℝ) : |
| IsProbabilityMeasure (enrichedRowsDisorderLaw n k p z) := by |
| unfold enrichedRowsDisorderLaw |
| infer_instance |
| |
| lemma enrichedPoissonLog_measurable (n k : ℕ) (f : ℝ →ᵇ ℝ) |
| (p d : Fin (n+1) → ℕ) (u : Fin (n+1) → ℝ) (h : Fin (k+1) → ℝ) (z : Fin k → ℝ) : |
| Measurable (enrichedPoissonLog n k f p d u h) := by |
| apply measurable_from_prod_countable_right |
| intro M |
| have hh := (enrichedCascadeLog_parameters_measurable n M k f p d u h z).comp |
| (((patternPrefix_measurable (n+1) M).comp |
| (measurable_fst (α := ℕ → Fin (n+1) → ℝ) |
| (β := EnrichedMark (n+1) (n+1) p × DecoratedCascade (EnrichedMark (n+1) (n+1) p) k))).prodMk measurable_snd) |
| simpa only [enrichedPoissonLog,Function.comp_def] using hh |
| |
| lemma enrichedPoissonLog_section_variance (n M k : ℕ) (f : ℝ →ᵇ ℝ) |
| (p d : Fin (n+1) → ℕ) (u : Fin (n+1) → ℝ) (h : Fin (k+1) → ℝ) (z : Fin k → ℝ) |
| (hz : StrictMono z) (hz0 : ∀ i, 0<z i) (hz1 : ∀ i, z i<1) : |
| MemLp (fun a => enrichedPoissonLog n k f p d u h (M,a)) 2 (enrichedRowsDisorderLaw n k p z) ∧ |
| variance (fun a => enrichedPoissonLog n k f p d u h (M,a)) (enrichedRowsDisorderLaw n k p z) ≤ |
| cascadeLogFluctuationConstant k z+(Real.pi^2/8)* |
| ((enrichedFeatureBound (n+1) u:ℝ)*‖enrichedRootMap p d h‖)^2+(M:ℝ)*(2*‖f‖)^2 := by |
| let E := EnrichedMark (n+1) (n+1) p |
| let D := E × DecoratedCascade E k |
| have hp : MeasurePreserving (fun a : (ℕ → Fin (n+1) → ℝ) × D => |
| (patternPrefix (n+1) M a.1,a.2)) |
| ((infinitePatternRowsLaw (n+1)).prod (enrichedDisorderLaw n k p z)) |
| ((finitePatternRowsLaw (n+1) M).prod (enrichedDisorderLaw n k p z)) := |
| (patternPrefix_measurePreserving (n+1) M).prod |
| (MeasurePreserving.id (enrichedDisorderLaw n k p z)) |
| have hs := enrichedFixedCountLog_variance n M k f p d u h z hz hz0 hz1 |
| have hl := hs.1.comp_measurePreserving hp |
| have hv := (hp.variance_fun_comp hs.1.aestronglyMeasurable.aemeasurable).trans_le hs.2 |
| constructor |
| · simpa only [Function.comp_def,enrichedFixedCountLog,enrichedPoissonLog,enrichedRowsDisorderLaw] using hl |
| · simpa only [enrichedFixedCountLog,enrichedPoissonLog,enrichedRowsDisorderLaw] using hv |
| |
| lemma enrichedPoissonLog_mean_succ (n k : ℕ) (f : ℝ →ᵇ ℝ) |
| (p d : Fin (n+1) → ℕ) (u : Fin (n+1) → ℝ) (h : Fin (k+1) → ℝ) (z : Fin k → ℝ) |
| (hz : StrictMono z) (hz0 : ∀ i, 0<z i) (hz1 : ∀ i, z i<1) (M : ℕ) : |
| |(∫ a, enrichedPoissonLog n k f p d u h (M+1,a) ∂enrichedRowsDisorderLaw n k p z)- |
| ∫ a, enrichedPoissonLog n k f p d u h (M,a) ∂enrichedRowsDisorderLaw n k p z| ≤ ‖f‖ := by |
| let μ := infinitePatternRowsLaw (n+1) |
| let G (M : ℕ) := fun g => enrichedExpectedLog n M k f p d u h z (patternPrefix (n+1) M g) |
| have hG (M : ℕ) : MemLp (G M) 2 μ := |
| (enrichedExpectedLog_memLp n M k f p d u h z hz hz0 hz1).comp_measurePreserving |
| (patternPrefix_measurePreserving (n+1) M) |
| have he (M : ℕ) : (∫ a, enrichedPoissonLog n k f p d u h (M,a) ∂enrichedRowsDisorderLaw n k p z)= |
| ∫ g, G M g ∂μ := |
| integral_prod _ ((enrichedPoissonLog_section_variance n M k f p d u h z hz hz0 hz1).1.integrable (by norm_num)) |
| rw [he,he,← integral_sub ((hG (M+1)).integrable (by norm_num)) ((hG M).integrable (by norm_num))] |
| have hh (g) : |G (M+1) g-G M g| ≤ ‖f‖ := |
| enrichedExpectedLog_pattern_change n (M+1) M k f _ _ p d u h z hz hz0 hz1 |
| (normalizedPatternEnergy_prefix_succ (n+1) M f g) |
| simpa using norm_integral_le_of_norm_le_const (μ := μ) (f := fun g => G (M+1) g-G M g) |
| (ae_of_all _ hh) |
| |
| lemma enrichedPoissonLog_variance (n k : ℕ) (f : ℝ →ᵇ ℝ) |
| (p d : Fin (n+1) → ℕ) (u : Fin (n+1) → ℝ) (h : Fin (k+1) → ℝ) (z : Fin k → ℝ) |
| (hz : StrictMono z) (hz0 : ∀ i, 0<z i) (hz1 : ∀ i, z i<1) (r : ℝ≥0) : |
| let μ := (poissonMeasure r).prod (enrichedRowsDisorderLaw n k p z) |
| MemLp (enrichedPoissonLog n k f p d u h) 2 μ ∧ |
| variance (enrichedPoissonLog n k f p d u h) μ ≤ |
| cascadeLogFluctuationConstant k z+(Real.pi^2/8)* |
| ((enrichedFeatureBound (n+1) u:ℝ)*‖enrichedRootMap p d h‖)^2+ |
| (r:ℝ)*(2*‖f‖)^2+‖f‖^2*((r:ℝ)+1) := by |
| let ν := enrichedRowsDisorderLaw n k p z |
| let F := enrichedPoissonLog n k f p d u h |
| let G := fun M => ∫ a, F (M,a) ∂ν |
| let K := cascadeLogFluctuationConstant k z+(Real.pi^2/8)* |
| ((enrichedFeatureBound (n+1) u:ℝ)*‖enrichedRootMap p d h‖)^2 |
| let A := fun M : ℕ => K+(M:ℝ)*(2*‖f‖)^2 |
| have hGdiff := enrichedPoissonLog_mean_succ n k f p d u h z hz hz0 hz1 |
| have hG : MemLp G 2 (poissonMeasure r) := poisson_bounded_increment_memLp r (norm_nonneg f) hGdiff |
| have hAi : Integrable A (poissonMeasure r) := |
| (integrable_const K).add ((poisson_nat_memLp r).integrable (by norm_num) |>.mul_const _) |
| have hs (M) := enrichedPoissonLog_section_variance n M k f p d u h z hz hz0 hz1 |
| have hp : MemLp F 2 ((poissonMeasure r).prod ν) := |
| memLp_prod_of_conditional_square_function (poissonMeasure r) ν |
| (enrichedPoissonLog_measurable n k f p d u h z) hG hAi (fun M => (hs M).1) |
| (fun M => by |
| have hv := (hs M).2 |
| rw [variance_eq_integral (hs M).1.aestronglyMeasurable.aemeasurable] at hv |
| exact hv) |
| refine ⟨hp,?_⟩ |
| have hv := variance_prod_le_integral (poissonMeasure r) ν hp (fun M => (hs M).1) hG hAi |
| (fun M => (hs M).2) (poisson_bounded_increment_variance r (norm_nonneg f) hGdiff) |
| have he : (∫ M, A M ∂poissonMeasure r)=K+(r:ℝ)*(2*‖f‖)^2 := by |
| rw [integral_add (integrable_const K) ((poisson_nat_memLp r).integrable (by norm_num) |>.mul_const _)] |
| simp only [integral_const,integral_mul_const,poisson_nat_mean] |
| simp |
| rw [he] at hv |
| exact hv |
| |
| end SphericalPerceptronFreeEnergy |
| end |
| |
| end OAI |
| |
