| import Mathlib |
| import OAI.Probability.Perceptron.Variational.ProductMarkLaw |
| import OAI.Probability.Perceptron.Variational.MarkedBlockParameter |
| import OAI.Probability.Perceptron.Variational.MarkTiltKernel |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace SphericalPerceptronFreeEnergy |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal ENNReal BigOperators |
|
|
| section |
|
|
| lemma exponentialMarkTilt_eq_density_of_one {S : Type*} [MeasurableSpace S] |
| (ν : Measure S) {b : ℝ} {F : S → ℝ} |
| (hI : Integrable (fun s => Real.exp (b*F s)) ν) |
| (hM : (∫ s, Real.exp (b*F s) ∂ν) = 1) : |
| exponentialMarkTilt ν b F = ν.withDensity (fun s => ENNReal.ofReal (Real.exp (b*F s))) := by |
| unfold exponentialMarkTilt normalizedMeasure |
| rw [withDensity_apply _ MeasurableSet.univ,Measure.restrict_univ, |
| ← ofReal_integral_eq_lintegral_ofReal hI (ae_of_all _ fun s => (Real.exp_pos _).le),hM] |
| simp |
|
|
| variable {X S : Type} [MeasurableSpace X] [MeasurableSpace S] [Nonempty S] |
|
|
| theorem decoratedShapeProbability_integral (ν : ProbabilityMeasure S) (step : X×S → X) |
| (hs : Measurable step) (n : ℕ) (z : Fin n → ℝ) (hz : StrictMono z) |
| (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1) |
| (F : Fin n → X×S → ℝ) (hF : ∀ i, Measurable (F i)) |
| (hI : ∀ i x, Integrable (fun s => Real.exp (z i*F i (x,s))) ν) |
| (hM : ∀ i x, (∫ s, Real.exp (z i*F i (x,s)) ∂ν) = 1) |
| (a : ℝ) (ha : ∀ i, a < z i) (s : DecoratedVisitShape X n) |
| (hv : s.Valid n) (x : X) : |
| (∫⁻ η, decoratedShapeProbability ν step n z F s (x,η) |
| ∂decoratedBiasedLaw ν step n z F x a) = |
| cascadeShapeLikelihood n z a (s.bare n)*decoratedShapeMarkValue ν step n z F s x := by |
| induction n generalizing a x with |
| | zero => |
| have := decoratedBiasedLaw_probability ν step hs 0 z hz hz0 hz1 F hF hI hM x a ha |
| simp only [decoratedShapeProbability,cascadeShapeLikelihood,decoratedShapeMarkValue, |
| lintegral_const,measure_univ,mul_one,one_mul] |
| | succ n ih => |
| have htail : StrictMono (fun i : Fin n => z i.succ) := |
| fun i j h => hz (Fin.succ_lt_succ_iff.mpr h) |
| have hrange : ∀ i : Fin n, z 0 < z i.succ := fun i => hz (by simp) |
| let ns : List (ℕ×(S×DecoratedCascade S n → ℝ≥0∞)) := s.map (fun t => |
| (cascadeVisitCount n (t.bare n),fun p => |
| decoratedShapeProbability ν step n (fun i => z i.succ) (fun i => F i.succ) t |
| (step (x,p.1),p.2))) |
| have hne : ns ≠ [] := by simpa [ns] using hv.1 |
| have hn : ∀ nf ∈ ns, 1 ≤ nf.1 := by |
| intro nf hnf; obtain ⟨t,ht,rfl⟩ := List.mem_map.mp hnf |
| exact cascadeVisitCount_pos n _ (t.bare_valid n (hv.2 t ht)) |
| have hm : ∀ nf ∈ ns, Measurable nf.2 := by |
| intro nf hnf; obtain ⟨t,ht,rfl⟩ := List.mem_map.mp hnf |
| exact (decoratedShapeProbability_measurable ν step hs n (fun i => z i.succ) |
| (fun i => F i.succ) (fun i => hF i.succ) t (hv.2 t ht)).comp |
| ((hs.comp (measurable_const.prodMk measurable_fst)).prodMk measurable_snd) |
| have he := decoratedRootBlock_factor ν step hs n z hz hz0 hz1 F hF hI hM x a |
| (ha 0) ns hne hn hm |
| change (∫⁻ η, markedBlockProbability ns |
| ((markedStableCountKernel η).map (logMarkShift |
| (centeredLogMark ((ν : Measure S).prod |
| (decoratedCascadeLaw ν n (fun i => z i.succ))) (z 0) |
| (fun p => decoratedRootPotential step n F (x,p))))) |
| (Fin.elim0 : Fin 0 → ℝ) ∂decoratedBiasedLaw ν step (n+1) z F x a) = _ |
| rw [he,stableBlockProbability_eppf_value (hz0 0) (hz1 0) (ha 0) |
| (ns.map Prod.fst) (by simpa using hne) |
| (by intro k hk; obtain ⟨nf,hmem,rfl⟩ := List.mem_map.mp hk; exact hn nf hmem)] |
| have hchild (t : DecoratedVisitShape X n) (ht : t ∈ s) : |
| (∫⁻ u, (∫⁻ C, decoratedShapeProbability ν step n (fun i => z i.succ) |
| (fun i => F i.succ) t (step (x,u),C) ∂decoratedBiasedLaw ν step n |
| (fun i => z i.succ) (fun i => F i.succ) (step (x,u)) (z 0)) |
| ∂exponentialMarkTilt ν (z 0) (fun u => F 0 (x,u))) = |
| cascadeShapeLikelihood n (fun i => z i.succ) (z 0) (t.bare n)* |
| ∫⁻ u, ENNReal.ofReal (Real.exp (z 0*F 0 (x,u)))* |
| decoratedShapeMarkValue ν step n (fun i => z i.succ) (fun i => F i.succ) |
| t (step (x,u)) ∂ν := by |
| have hval : Measurable (fun u => decoratedShapeMarkValue ν step n |
| (fun i => z i.succ) (fun i => F i.succ) t (step (x,u))) := |
| (decoratedShapeMarkValue_measurable ν step hs n (fun i => z i.succ) |
| (fun i => F i.succ) (fun i => hF i.succ) t (hv.2 t ht)).comp |
| (hs.comp (measurable_const.prodMk measurable_id)) |
| calc |
| _ = ∫⁻ u, cascadeShapeLikelihood n (fun i => z i.succ) (z 0) (t.bare n)* |
| decoratedShapeMarkValue ν step n (fun i => z i.succ) (fun i => F i.succ) |
| t (step (x,u)) ∂exponentialMarkTilt ν (z 0) (fun u => F 0 (x,u)) := by |
| apply lintegral_congr |
| intro u |
| exact ih (fun i => z i.succ) htail (fun i => hz0 i.succ) (fun i => hz1 i.succ) |
| (fun i => F i.succ) (fun i => hF i.succ) (fun i => hI i.succ) |
| (fun i => hM i.succ) (z 0) hrange t (hv.2 t ht) (step (x,u)) |
| _ = _ := by |
| have hweight : Measurable (fun u : S => ENNReal.ofReal (Real.exp (z 0*F 0 (x,u)))) := |
| (((hF 0).comp (measurable_const.prodMk measurable_id)).const_mul _).exp.ennreal_ofReal |
| rw [lintegral_const_mul _ hval, |
| exponentialMarkTilt_eq_density_of_one (ν : Measure S) (b := z 0) |
| (F := fun u => F 0 (x,u)) (hI 0 x) (hM 0 x), |
| lintegral_withDensity_eq_lintegral_mul _ hweight hval] |
| rfl |
| simp only [ns,List.map_map,Function.comp_def] at * |
| rw [show (s.map (fun t => ∫⁻ u, (∫⁻ C, decoratedShapeProbability ν step n |
| (fun i => z i.succ) (fun i => F i.succ) t (step (x,u),C) |
| ∂decoratedBiasedLaw ν step n (fun i => z i.succ) (fun i => F i.succ) |
| (step (x,u)) (z 0)) ∂exponentialMarkTilt ν (z 0) (fun u => F 0 (x,u)))) = |
| s.map (fun t => cascadeShapeLikelihood n (fun i => z i.succ) (z 0) (t.bare n)* |
| ∫⁻ u, ENNReal.ofReal (Real.exp (z 0*F 0 (x,u)))* |
| decoratedShapeMarkValue ν step n (fun i => z i.succ) (fun i => F i.succ) |
| t (step (x,u)) ∂ν) by exact List.map_congr_left hchild] |
| rw [List.prod_map_mul] |
| simp only [cascadeShapeLikelihood,DecoratedVisitShape.bare,decoratedShapeMarkValue, |
| List.map_map,Function.comp_def] |
| ac_rfl |
|
|
| end |
|
|
| @[reducible] def PairedVisitShape (X Y : Type) : ℕ → Type |
| | 0 => ℕ × ((X → ℝ≥0∞) × (Y → ℝ≥0∞)) |
| | n+1 => List (PairedVisitShape X Y n) |
|
|
| def PairedVisitShape.first {X Y : Type} : (n : ℕ) → PairedVisitShape X Y n → DecoratedVisitShape X n |
| | 0, s => (s.1,s.2.1) |
| | n+1, s => s.map (PairedVisitShape.first n) |
|
|
| def PairedVisitShape.second {X Y : Type} : (n : ℕ) → PairedVisitShape X Y n → DecoratedVisitShape Y n |
| | 0, s => (s.1,s.2.2) |
| | n+1, s => s.map (PairedVisitShape.second n) |
|
|
| def PairedVisitShape.product {X Y : Type} : (n : ℕ) → PairedVisitShape X Y n → DecoratedVisitShape (X×Y) n |
| | 0, s => (s.1,fun p => s.2.1 p.1*s.2.2 p.2) |
| | n+1, s => s.map (PairedVisitShape.product n) |
|
|
| lemma PairedVisitShape.bare_first_second {X Y : Type} (n : ℕ) (s : PairedVisitShape X Y n) : |
| (s.first n).bare n = (s.second n).bare n := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| simp only [first,second,DecoratedVisitShape.bare,List.map_map,Function.comp_def] |
| exact List.map_congr_left (fun t _ => ih t) |
|
|
| lemma PairedVisitShape.product_valid {X Y : Type} [MeasurableSpace X] [MeasurableSpace Y] |
| (n : ℕ) (s : PairedVisitShape X Y n) |
| (h₁ : (s.first n).Valid n) (h₂ : (s.second n).Valid n) : |
| (s.product n).Valid n := by |
| induction n with |
| | zero => exact ⟨h₁.1,(h₁.2.comp measurable_fst).mul (h₂.2.comp measurable_snd)⟩ |
| | succ n ih => |
| refine ⟨by simpa [product,first] using h₁.1,?_⟩ |
| intro t ht |
| obtain ⟨u,hu,rfl⟩ := List.mem_map.mp ht |
| exact ih u (h₁.2 _ (List.mem_map.mpr ⟨u,hu,rfl⟩)) |
| (h₂.2 _ (List.mem_map.mpr ⟨u,hu,rfl⟩)) |
|
|
| theorem decoratedShapeMarkValue_product {X Y S T : Type} |
| [MeasurableSpace X] [MeasurableSpace Y] [MeasurableSpace S] [MeasurableSpace T] |
| [Nonempty S] [Nonempty T] |
| (ν : ProbabilityMeasure S) (ρ : ProbabilityMeasure T) |
| (step₁ : X×S → X) (step₂ : Y×T → Y) |
| (hs₁ : Measurable step₁) (hs₂ : Measurable step₂) |
| (n : ℕ) (z : Fin n → ℝ) |
| (F : Fin n → X×S → ℝ) (G : Fin n → Y×T → ℝ) |
| (hF : ∀ i, Measurable (F i)) (hG : ∀ i, Measurable (G i)) |
| (s : PairedVisitShape X Y n) (h₁ : (s.first n).Valid n) (h₂ : (s.second n).Valid n) |
| (x : X) (y : Y) : |
| decoratedShapeMarkValue (productMarkLaw ν ρ) |
| (fun p : (X×Y)×(S×T) => (step₁ (p.1.1,p.2.1),step₂ (p.1.2,p.2.2))) n z |
| (fun i p => F i (p.1.1,p.2.1)+G i (p.1.2,p.2.2)) (s.product n) (x,y) = |
| decoratedShapeMarkValue ν step₁ n z F (s.first n) x * |
| decoratedShapeMarkValue ρ step₂ n z G (s.second n) y := by |
| induction n generalizing x y with |
| | zero => rfl |
| | succ n ih => |
| simp only [PairedVisitShape.product,PairedVisitShape.first,PairedVisitShape.second, |
| decoratedShapeMarkValue,List.map_map,Function.comp_def] |
| rw [← List.prod_map_mul] |
| apply congrArg List.prod |
| apply List.map_congr_left |
| intro t ht |
| have ht₁ := h₁.2 _ (List.mem_map.mpr ⟨t,ht,rfl⟩) |
| have ht₂ := h₂.2 _ (List.mem_map.mpr ⟨t,ht,rfl⟩) |
| simp_rw [ih (fun i => z i.succ) (fun i => F i.succ) (fun i => G i.succ) |
| (fun i => hF i.succ) (fun i => hG i.succ) t ht₁ ht₂] |
| have hm₁ : Measurable (fun u => ENNReal.ofReal (Real.exp (z 0*F 0 (x,u)))* |
| decoratedShapeMarkValue ν step₁ n (fun i => z i.succ) (fun i => F i.succ) |
| (t.first n) (step₁ (x,u))) := |
| ((((hF 0).comp (measurable_const.prodMk measurable_id)).const_mul _).exp.ennreal_ofReal).mul |
| ((decoratedShapeMarkValue_measurable ν step₁ hs₁ n (fun i => z i.succ) |
| (fun i => F i.succ) (fun i => hF i.succ) _ ht₁).comp |
| (hs₁.comp (measurable_const.prodMk measurable_id))) |
| have hm₂ : Measurable (fun u => ENNReal.ofReal (Real.exp (z 0*G 0 (y,u)))* |
| decoratedShapeMarkValue ρ step₂ n (fun i => z i.succ) (fun i => G i.succ) |
| (t.second n) (step₂ (y,u))) := |
| ((((hG 0).comp (measurable_const.prodMk measurable_id)).const_mul _).exp.ennreal_ofReal).mul |
| ((decoratedShapeMarkValue_measurable ρ step₂ hs₂ n (fun i => z i.succ) |
| (fun i => G i.succ) (fun i => hG i.succ) _ ht₂).comp |
| (hs₂.comp (measurable_const.prodMk measurable_id))) |
| simp only [mul_add,Real.exp_add,ENNReal.ofReal_mul (Real.exp_pos _).le] |
| convert lintegral_prod_mul (μ := (ν : Measure S)) (ν := (ρ : Measure T)) |
| hm₁.aemeasurable hm₂.aemeasurable using 1 |
| apply lintegral_congr |
| intro p |
| exact mul_mul_mul_comm _ _ _ _ |
|
|
| end SphericalPerceptronFreeEnergy |
|
|
| end |
|
|
| end OAI |
|
|
