| import Mathlib |
| import OAI.Probability.Perceptron.Variational.FocusedShapeProbability |
| import OAI.Probability.Perceptron.Cascade.IndexedPoisson |
| import OAI.Probability.Perceptron.Variational.InfinitePiSplit |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace SphericalPerceptronFreeEnergy |
| open MeasureTheory ProbabilityTheory Set |
| open scoped ENNReal NNReal BigOperators |
|
|
| lemma law_count_iid_zip {A B : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| (r : ℝ≥0) (ρ : Measure A) (ν : Measure B) |
| [IsProbabilityMeasure ρ] [IsProbabilityMeasure ν] : |
| (((poissonMeasure r).prod (Measure.infinitePi (fun _ : ℕ => ρ))).prod |
| (Measure.infinitePi (fun _ : ℕ => ν))).map |
| (fun p => (p.1.1, fun j => (p.1.2 j,p.2 j))) = |
| (poissonMeasure r).prod (Measure.infinitePi (fun _ : ℕ => ρ.prod ν)) := by |
| let z : ((ℕ → A) × (ℕ → B)) → ℕ → A × B := fun p j => (p.1 j,p.2 j) |
| have hz : Measurable z := by fun_prop |
| calc |
| _ = ((((poissonMeasure r).prod (Measure.infinitePi (fun _ : ℕ => ρ))).prod |
| (Measure.infinitePi (fun _ : ℕ => ν))).map |
| (MeasurableEquiv.prodAssoc : ((ℕ × (ℕ → A)) × (ℕ → B)) ≃ᵐ (ℕ × ((ℕ → A) × (ℕ → B))))).map (Prod.map id z) := by |
| rw [Measure.map_map (by fun_prop) (by fun_prop)] |
| rfl |
| _ = _ := by |
| rw [Measure.prodAssoc_prod, ← Measure.map_prod_map _ _ measurable_id hz, |
| Measure.map_id, infinitePi_zip] |
|
|
| lemma indexedMarkedPoisson_law {A B : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| (r : ℕ → ℝ≥0) (ρ : ℕ → Measure A) (ν : Measure B) |
| [∀ i, IsProbabilityMeasure (ρ i)] [IsProbabilityMeasure ν] : |
| ((Measure.infinitePi (fun i => (poissonMeasure (r i)).prod |
| (Measure.infinitePi (fun _ : ℕ => ρ i)))).prod |
| (Measure.infinitePi (fun _ : ℕ => Measure.infinitePi (fun _ : ℕ => ν)))).map |
| (fun p => indexedPoissonMeasure (fun i => (p.1 i |>.1, |
| fun j => ((p.1 i).2 j,p.2 i j)))) = |
| countablePoissonLaw r (fun i => (ρ i).prod ν) := by |
| let z : (ℕ × (ℕ → A)) × (ℕ → B) → ℕ × (ℕ → A × B) := |
| fun p => (p.1.1,fun j => (p.1.2 j,p.2 j)) |
| have hz : Measurable z := by fun_prop |
| let L := Measure.infinitePi (fun i => (poissonMeasure (r i)).prod |
| (Measure.infinitePi (fun _ : ℕ => ρ i))) |
| let M := Measure.infinitePi (fun _ : ℕ => Measure.infinitePi (fun _ : ℕ => ν)) |
| have hp : (L.prod M).map (fun p i => z (p.1 i,p.2 i)) = |
| Measure.infinitePi (fun i => (poissonMeasure (r i)).prod |
| (Measure.infinitePi (fun _ : ℕ => (ρ i).prod ν))) := by |
| calc |
| _ = ((L.prod M).map (fun p i => (p.1 i,p.2 i))).map (fun p i => z (p i)) := by |
| rw [Measure.map_map (by fun_prop) (by fun_prop)] |
| rfl |
| _ = _ := by |
| dsimp [L,M] |
| rw [infinitePi_zip, Measure.infinitePi_map_pi] |
| simp_rw [show ∀ i, ((poissonMeasure (r i)).prod |
| (Measure.infinitePi (fun _ : ℕ => ρ i)) |>.prod |
| (Measure.infinitePi (fun _ : ℕ => ν))).map z = |
| (poissonMeasure (r i)).prod (Measure.infinitePi (fun _ : ℕ => (ρ i).prod ν)) |
| from fun i => law_count_iid_zip (r i) (ρ i) ν] |
| exact fun _ => hz |
| change (L.prod M).map (indexedPoissonMeasure ∘ (fun p i => z (p.1 i,p.2 i))) = _ |
| rw [← Measure.map_map indexedPoissonMeasure_measurable (by fun_prop),hp, |
| indexedPoissonMeasure_law] |
|
|
| lemma countablePoissonLaw_product_intensity {A B : Type*} |
| [MeasurableSpace A] [MeasurableSpace B] [Nonempty A] [Nonempty B] |
| (κ : Measure A) [SFinite κ] (ν : Measure B) [IsProbabilityMeasure ν] : |
| countablePoissonLaw (fun i => ((sfiniteSeq κ i) univ).toNNReal) |
| (fun i => (finiteIntensityMarks (sfiniteSeq κ i)).prod ν) = |
| poissonRandomMeasureLaw (κ.prod ν) := by |
| apply measureLaw_eq_of_laplace |
| intro f hf hf0 |
| rw [countablePoissonLaw_laplace_intensity _ _ hf hf0, |
| poissonRandomMeasureLaw_laplace _ hf hf0] |
| congr 2 |
| have he : countablePoissonIntensity (fun i => ((sfiniteSeq κ i) univ).toNNReal) |
| (fun i => (finiteIntensityMarks (sfiniteSeq κ i)).prod ν) = κ.prod ν := by |
| unfold countablePoissonIntensity |
| simp_rw [← Measure.prod_smul_left, finiteIntensityMarks_smul] |
| rw [← Measure.prod_sum_left,sum_sfiniteSeq] |
| rw [he] |
|
|
| lemma indexedMarkedPoisson_canonical_law {A B : Type*} |
| [MeasurableSpace A] [MeasurableSpace B] [Nonempty A] [Nonempty B] |
| (κ : Measure A) [SFinite κ] (ν : Measure B) [IsProbabilityMeasure ν] : |
| ((Measure.infinitePi (fun i => |
| (poissonMeasure (((sfiniteSeq κ i) univ).toNNReal)).prod |
| (Measure.infinitePi (fun _ : ℕ => finiteIntensityMarks (sfiniteSeq κ i))))).prod |
| (Measure.infinitePi (fun _ : ℕ => Measure.infinitePi (fun _ : ℕ => ν)))).map |
| (fun p => indexedPoissonMeasure (fun i => ((p.1 i).1, |
| fun j => ((p.1 i).2 j,p.2 i j)))) = |
| poissonRandomMeasureLaw (κ.prod ν) := by |
| rw [indexedMarkedPoisson_law,countablePoissonLaw_product_intensity] |
|
|
| @[reducible] def IndexedCascadeBase : ℕ → MeasCat |
| | 0 => MeasCat.of Unit |
| | n+1 => MeasCat.of (ℕ → ℕ × (ℕ → ℝ × IndexedCascadeBase n)) |
|
|
| @[reducible] def IndexedCascadeMarks (S : Type) [MeasurableSpace S] : ℕ → MeasCat |
| | 0 => MeasCat.of Unit |
| | n+1 => MeasCat.of (ℕ → ℕ → S × IndexedCascadeMarks S n) |
|
|
| instance indexedCascadeBase_nonempty (n : ℕ) : Nonempty (IndexedCascadeBase n) := by |
| induction n with |
| | zero => exact ⟨()⟩ |
| | succ n ih => dsimp [IndexedCascadeBase]; infer_instance |
|
|
| instance indexedCascadeMarks_nonempty (S : Type) [MeasurableSpace S] [Nonempty S] (n : ℕ) : |
| Nonempty (IndexedCascadeMarks S n) := by |
| induction n with |
| | zero => exact ⟨()⟩ |
| | succ n ih => dsimp [IndexedCascadeMarks]; infer_instance |
|
|
| def indexedCascadeBaseLaw : (n : ℕ) → (Fin n → ℝ) → ProbabilityMeasure (IndexedCascadeBase n) |
| | 0,_ => ⟨Measure.dirac (),inferInstance⟩ |
| | n+1,z => ⟨Measure.infinitePi (fun i => |
| (poissonMeasure (((sfiniteSeq (stableLogIntensity (z 0)) i) univ).toNNReal)).prod |
| (Measure.infinitePi (fun _ : ℕ => |
| (finiteIntensityMarks (sfiniteSeq (stableLogIntensity (z 0)) i)).prod |
| (indexedCascadeBaseLaw n (fun j => z j.succ))))),by infer_instance⟩ |
|
|
| def indexedCascadeMarksLaw {S : Type} [MeasurableSpace S] (ν : ProbabilityMeasure S) : |
| (n : ℕ) → ProbabilityMeasure (IndexedCascadeMarks S n) |
| | 0 => ⟨Measure.dirac (),inferInstance⟩ |
| | n+1 => ⟨Measure.infinitePi (fun _ : ℕ => Measure.infinitePi (fun _ : ℕ => |
| (ν : Measure S).prod (indexedCascadeMarksLaw ν n))),by infer_instance⟩ |
|
|
| def indexedCascadeRealize {S : Type} [MeasurableSpace S] : (n : ℕ) → |
| IndexedCascadeBase n × IndexedCascadeMarks S n → DecoratedCascade S n |
| | 0,_ => () |
| | n+1,p => indexedPoissonMeasure (fun i => ((p.1 i).1,fun j => |
| (((p.1 i).2 j).1,((p.2 i j).1, |
| indexedCascadeRealize n (((p.1 i).2 j).2,(p.2 i j).2))))) |
|
|
| lemma indexedCascadeRealize_measurable {S : Type} [MeasurableSpace S] (n : ℕ) : |
| Measurable (indexedCascadeRealize (S := S) n) := by |
| induction n with |
| | zero => exact measurable_const |
| | succ n ih => |
| dsimp only [indexedCascadeRealize] |
| apply indexedPoissonMeasure_measurable.comp |
| fun_prop |
|
|
| instance countablePoissonIntensity_sfinite {A : Type*} [MeasurableSpace A] |
| (r : ℕ → ℝ≥0) (ρ : ℕ → Measure A) [∀ i, IsProbabilityMeasure (ρ i)] : |
| SFinite (countablePoissonIntensity r ρ) := by |
| unfold countablePoissonIntensity |
| infer_instance |
|
|
| lemma countablePoissonLaw_eq_canonical {A : Type*} [MeasurableSpace A] [Nonempty A] |
| (r : ℕ → ℝ≥0) (ρ : ℕ → Measure A) [∀ i, IsProbabilityMeasure (ρ i)] : |
| countablePoissonLaw r ρ = poissonRandomMeasureLaw (countablePoissonIntensity r ρ) := by |
| apply measureLaw_eq_of_laplace |
| intro f hf hf0 |
| rw [countablePoissonLaw_laplace_intensity _ _ hf hf0, |
| poissonRandomMeasureLaw_laplace _ hf hf0] |
|
|
| lemma prod_rotate_front {A B C : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| [MeasurableSpace C] (μ : Measure A) (ν : Measure B) (τ : Measure C) |
| [SFinite μ] [SFinite ν] [SFinite τ] : |
| (μ.prod (ν.prod τ)).map (fun p => (p.2.1,(p.1,p.2.2))) = ν.prod (μ.prod τ) := by |
| have h := (measurePreserving_prodAssoc ν μ τ).comp |
| (((Measure.measurePreserving_swap (μ := μ) (ν := ν)).prod (MeasurePreserving.id τ)).comp |
| (measurePreserving_prodAssoc μ ν τ).symm) |
| exact h.map_eq |
|
|
| lemma indexedPoissonMeasure_map {A B : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| {g : A → B} (hg : Measurable g) (a : ℕ → ℕ × (ℕ → A)) : |
| (indexedPoissonMeasure a).map g = |
| indexedPoissonMeasure (fun i => ((a i).1,fun j => g ((a i).2 j))) := by |
| unfold indexedPoissonMeasure indexedFiniteCloud finitePointMeasure |
| rw [Measure.map_sum hg.aemeasurable] |
| simp_rw [Measure.map_finset_sum hg.aemeasurable,Measure.map_dirac' hg] |
| |
| lemma prod_interlace_law {A B C D E : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| [MeasurableSpace C] [MeasurableSpace D] [MeasurableSpace E] |
| (α : Measure A) (β : Measure B) (γ : Measure C) (δ : Measure D) (ε : Measure E) |
| [SFinite α] [SFinite β] [SFinite γ] [SFinite δ] [SFinite ε] |
| {g : B × D → E} (hg : MeasurePreserving g (β.prod δ) ε) : |
| ((α.prod β).prod (γ.prod δ)).map |
| (fun p => (p.1.1,(p.2.1,g (p.1.2,p.2.2)))) = α.prod (γ.prod ε) := by |
| have h₁ := measurePreserving_prodAssoc α β (γ.prod δ) |
| have h₂ : MeasurePreserving (fun p : B × (C × D) => (p.2.1,(p.1,p.2.2))) |
| (β.prod (γ.prod δ)) (γ.prod (β.prod δ)) := |
| ⟨by fun_prop,prod_rotate_front β γ δ⟩ |
| exact (((MeasurePreserving.id α).prod ((MeasurePreserving.id γ).prod hg)).comp |
| (((MeasurePreserving.id α).prod h₂).comp h₁)).map_eq |
| |
| lemma indexedCascadeRealize_law {S : Type} [MeasurableSpace S] [Nonempty S] |
| (ν : ProbabilityMeasure S) (n : ℕ) (z : Fin n → ℝ) : |
| ((indexedCascadeBaseLaw n z : Measure (IndexedCascadeBase n)).prod |
| (indexedCascadeMarksLaw ν n)).map (indexedCascadeRealize n) = |
| (decoratedCascadeLaw ν n z : Measure (DecoratedCascade S n)) := by |
| induction n with |
| | zero => simp [indexedCascadeBaseLaw,indexedCascadeMarksLaw,indexedCascadeRealize,decoratedCascadeLaw] |
| | succ n ih => |
| let κ := stableLogIntensity (z 0) |
| let r : ℕ → ℝ≥0 := fun i => ((sfiniteSeq κ i) univ).toNNReal |
| let ρ := fun i => finiteIntensityMarks (sfiniteSeq κ i) |
| let B := (indexedCascadeBaseLaw n (fun j => z j.succ) : Measure (IndexedCascadeBase n)) |
| let M := (indexedCascadeMarksLaw ν n : Measure (IndexedCascadeMarks S n)) |
| let D := (decoratedCascadeLaw ν n (fun j => z j.succ) : Measure (DecoratedCascade S n)) |
| let f : ((ℝ × IndexedCascadeBase n) × (S × IndexedCascadeMarks S n)) → |
| ℝ × (S × DecoratedCascade S n) := |
| fun p => (p.1.1,(p.2.1,indexedCascadeRealize n (p.1.2,p.2.2))) |
| have hf : Measurable f := by |
| exact measurable_fst.fst.prodMk (measurable_snd.fst.prodMk |
| ((indexedCascadeRealize_measurable n).comp (measurable_fst.snd.prodMk measurable_snd.snd))) |
| have hR : MeasurePreserving (indexedCascadeRealize (S := S) n) (B.prod M) D := |
| ⟨indexedCascadeRealize_measurable n,ih (fun j => z j.succ)⟩ |
| have hi : (countablePoissonIntensity r (fun i => (ρ i).prod B |>.prod ((ν : Measure S).prod M))).map f = |
| κ.prod ((ν : Measure S).prod D) := by |
| unfold countablePoissonIntensity |
| rw [Measure.map_sum hf.aemeasurable] |
| simp_rw [Measure.map_smul _ hf.aemeasurable] |
| have hfi (i : ℕ) : (((ρ i).prod B).prod ((ν : Measure S).prod M)).map f = |
| (ρ i).prod ((ν : Measure S).prod D) := |
| prod_interlace_law (ρ i) B (ν : Measure S) M D hR |
| simp_rw [hfi] |
| dsimp only [r,ρ] |
| simp_rw [← Measure.prod_smul_left,finiteIntensityMarks_smul] |
| rw [← Measure.prod_sum_left,sum_sfiniteSeq] |
| let P := Measure.infinitePi (fun i => (poissonMeasure (r i)).prod |
| (Measure.infinitePi (fun _ : ℕ => (ρ i).prod B))) |
| let Q := Measure.infinitePi (fun _ : ℕ => Measure.infinitePi (fun _ : ℕ => (ν : Measure S).prod M)) |
| let a : ((ℕ → ℕ × (ℕ → ℝ × IndexedCascadeBase n)) × |
| (ℕ → ℕ → S × IndexedCascadeMarks S n)) → |
| ℕ → ℕ × (ℕ → (ℝ × IndexedCascadeBase n) × (S × IndexedCascadeMarks S n)) := |
| fun p i => ((p.1 i).1,fun j => ((p.1 i).2 j,p.2 i j)) |
| have ha : Measurable a := by fun_prop |
| have he : indexedCascadeRealize (S := S) (n+1) = |
| Measure.map f ∘ (indexedPoissonMeasure ∘ a) := by |
| funext p |
| exact (indexedPoissonMeasure_map hf (a p)).symm |
| change (P.prod Q).map (indexedCascadeRealize (S := S) (n+1)) = |
| poissonRandomMeasureLaw (κ.prod ((ν : Measure S).prod D)) |
| rw [he,← Measure.map_map (Measure.measurable_map f hf) |
| (indexedPoissonMeasure_measurable.comp ha)] |
| have hP := indexedMarkedPoisson_law r (fun i => (ρ i).prod B) ((ν : Measure S).prod M) |
| change (P.prod Q).map (indexedPoissonMeasure ∘ a) = _ at hP |
| rw [hP,countablePoissonLaw_eq_canonical,poissonRandomMeasureLaw_map _ hf] |
| congr 1 |
| |
| end SphericalPerceptronFreeEnergy |
| |
| end |
| |
| end OAI |
| |
