| import Mathlib |
| import OAI.Probability.Perceptron.Cascade.IndexedCascadeRegular |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open MeasureTheory ProbabilityTheory Set |
| open scoped ENNReal NNReal BigOperators |
| namespace SphericalPerceptronFreeEnergy |
|
|
| lemma injective_of_simple_count_map {I A : Type*} [Countable I] |
| [MeasurableSpace I] [MeasurableSingletonClass I] |
| [MeasurableSpace A] [MeasurableSingletonClass A] |
| (p : I → A) (hp : Measurable p) |
| (hs : ∀ᵐ x ∂(Measure.count.map p), (Measure.count.map p) {x} = 1) : |
| Function.Injective p := by |
| classical |
| have h : ∀ i, (Measure.count.map p) {p i} = 1 := |
| Measure.ae_count_iff.mp (ae_of_ae_map hp.aemeasurable hs) |
| intro i j hij |
| by_contra hn |
| have hle : (Measure.count : Measure I) {i,j} ≤ 1 := by |
| rw [← h i,Measure.map_apply hp (measurableSet_singleton _)] |
| apply measure_mono |
| intro k hk |
| rcases hk with rfl | hk |
| · rfl |
| · simpa only [mem_singleton_iff] using hk ▸ hij.symm |
| have htwo : (Measure.count : Measure I) {i,j} = 2 := by |
| have he : (↑({i,j} : Finset I) : Set I) = {i,j} := by ext k; simp |
| rw [← he,Measure.count_apply_finset] |
| simp [hn] |
| rw [htwo] at hle |
| norm_num at hle |
| |
| lemma markedStableMassKernel_count_map {I S : Type*} [Countable I] |
| [MeasurableSpace I] [MeasurableSingletonClass I] [MeasurableSpace S] |
| (p : I → ℝ×S) (hp : Measurable p) : |
| markedStableMassKernel (Measure.count.map p) = |
| (normalizedMeasure (Measure.count.withDensity |
| (fun i => ENNReal.ofReal (Real.exp (p i).1)))).map p := by |
| rw [normalizedMeasure_map _ hp] |
| change normalizedMeasure ((Measure.count.map p).withDensity |
| (fun t : ℝ×S => ENNReal.ofReal (Real.exp t.1))) = _ |
| rw [map_withDensity_comp Measure.count hp (by fun_prop)] |
| rfl |
|
|
| lemma stableMassKernel_count_map_atom {I S : Type*} [Countable I] |
| [MeasurableSpace I] [MeasurableSingletonClass I] [MeasurableSpace S] |
| (p : I → ℝ×S) (hp : Measurable p) (hinj : Function.Injective (fun i => (p i).1)) |
| (i : I) : |
| stableMassKernel ((Measure.count.map p).map Prod.fst) {(p i).1} = |
| ((∑' j, ENNReal.ofReal (Real.exp (p j).1))⁻¹) * |
| ENNReal.ofReal (Real.exp (p i).1) := by |
| rw [Measure.map_map measurable_fst hp] |
| change normalizedMeasure ((Measure.count.map (fun j => (p j).1)).withDensity |
| (fun x => ENNReal.ofReal (Real.exp x))) {(p i).1} = _ |
| have hp' : Measurable (fun j => (p j).1) := hp.fst |
| rw [map_withDensity_comp Measure.count hp' (by fun_prop), |
| ← normalizedMeasure_map _ hp', |
| Measure.map_apply hp' (measurableSet_singleton _)] |
| have hpre : (fun j => (p j).1) ⁻¹' {(p i).1} = {i} := by |
| ext j |
| simp only [mem_preimage,mem_singleton_iff,hinj.eq_iff] |
| rw [hpre,normalizedMeasure,Measure.smul_apply,smul_eq_mul, |
| withDensity_apply _ (measurableSet_singleton i),withDensity_apply _ MeasurableSet.univ, |
| Measure.restrict_univ,lintegral_count] |
| simp |
|
|
| def countedBlockProbability {I S : Type*} (p : I → ℝ×S) : |
| List (ℕ×(S → ℝ≥0∞)) → {m : ℕ} → (Fin m → ℝ) → ℝ≥0∞ |
| | [],_,_ => 1 |
| | nf::ns,_,z => ∑' i, if ∃ j, z j = (p i).1 then 0 else |
| (((∑' k, ENNReal.ofReal (Real.exp (p k).1))⁻¹)* |
| ENNReal.ofReal (Real.exp (p i).1))^nf.1 * nf.2 (p i).2 * |
| countedBlockProbability p ns (Fin.cons (p i).1 z) |
|
|
| lemma markedBlockProbability_count_map {I S : Type*} [Countable I] |
| [MeasurableSpace I] [MeasurableSingletonClass I] [MeasurableSpace S] |
| (p : I → ℝ×S) (hp : Measurable p) (hinj : Function.Injective (fun i => (p i).1)) |
| (ns : List (ℕ×(S → ℝ≥0∞))) |
| (hn : ∀ nf ∈ ns, 1 ≤ nf.1) (hm : ∀ nf ∈ ns, Measurable nf.2) |
| {m : ℕ} (z : Fin m → ℝ) : |
| markedBlockProbability ns (Measure.count.map p) z = countedBlockProbability p ns z := by |
| classical |
| induction ns generalizing m with |
| | nil => rfl |
| | cons nf ns ih => |
| have hnf := hn nf (by simp) |
| have hn' : ∀ n ∈ ns, 1 ≤ n.1 := fun n h => hn n (by simp [h]) |
| have hm' : ∀ n ∈ ns, Measurable n.2 := fun n h => hm n (by simp [h]) |
| unfold markedBlockProbability countedBlockProbability |
| rw [markedStableMassKernel_count_map p hp] |
| have ha : Measurable (fun t : ℝ×S => |
| stableMassKernel ((Measure.count.map p).map Prod.fst) {t.1}) := |
| stableMassAtom_measurable_comp measurable_const measurable_fst |
| have ht : Measurable (fun t : ℝ×S => |
| markedBlockProbability ns (Measure.count.map p) (Fin.cons t.1 z)) := |
| (markedBlockProbability_measurable ns hm' (m+1)).comp |
| (measurable_const.prodMk (measurable_fin_cons measurable_fst measurable_const)) |
| have hf : Measurable (fun t : ℝ×S => if ∃ j, z j = t.1 then (0:ℝ≥0∞) else |
| (stableMassKernel ((Measure.count.map p).map Prod.fst) {t.1})^(nf.1-1)* |
| nf.2 t.2*markedBlockProbability ns (Measure.count.map p) (Fin.cons t.1 z)) := |
| measurable_const.ite (cascadeMeasurableSet_exists fun j => |
| measurableSet_eq_fun measurable_const measurable_fst) |
| (((ha.pow_const _).mul ((hm nf (by simp)).comp measurable_snd)).mul ht) |
| have hweight : Measurable (fun i => ENNReal.ofReal (Real.exp (p i).1)) := |
| hp.fst.exp.ennreal_ofReal |
| have hfp : Measurable (fun i => if ∃ j, z j = (p i).1 then (0:ℝ≥0∞) else |
| (stableMassKernel ((Measure.count.map p).map Prod.fst) {(p i).1})^(nf.1-1)* |
| nf.2 (p i).2*markedBlockProbability ns (Measure.count.map p) (Fin.cons (p i).1 z)) := |
| hf.comp hp |
| rw [lintegral_map hf hp,normalizedMeasure,lintegral_smul_measure,smul_eq_mul, |
| withDensity_apply _ MeasurableSet.univ,Measure.restrict_univ, |
| lintegral_withDensity_eq_lintegral_mul _ hweight hfp, |
| lintegral_count,lintegral_count,← ENNReal.tsum_mul_left] |
| apply tsum_congr |
| intro i |
| simp only [Pi.mul_apply] |
| split_ifs with hi |
| · simp |
| · rw [stableMassKernel_count_map_atom p hp hinj,ih hn' hm'] |
| have hpw := pow_succ (((∑' k, ENNReal.ofReal (Real.exp (p k).1))⁻¹)* |
| ENNReal.ofReal (Real.exp (p i).1)) (nf.1-1) |
| rw [Nat.sub_add_cancel hnf] at hpw |
| rw [hpw] |
| ring |
|
|
| instance finiteSigmaMeasurableSingleton (k : ℕ → ℕ) : |
| MeasurableSingletonClass (Σ j, Fin (k j)) := by |
| constructor |
| intro x |
| apply MeasurableSpace.measurableSet_iInf.mpr |
| intro j |
| change MeasurableSet ((Sigma.mk j) ⁻¹' {x}) |
| exact (Set.toFinite _).measurableSet |
|
|
| lemma indexedPoissonMeasure_eq_map_count {A : Type*} [MeasurableSpace A] |
| (a : ℕ → ℕ×(ℕ → A)) : |
| indexedPoissonMeasure a = Measure.count.map |
| (fun i : Σ j, Fin ((a j).1) => (a i.1).2 i.2.val) := by |
| apply Measure.ext_of_lintegral |
| intro f hf |
| rw [indexedPoissonMeasure_lintegral a hf, |
| lintegral_map hf (measurable_of_countable _),lintegral_count,ENNReal.tsum_sigma'] |
| simp only [tsum_fintype] |
|
|
| end SphericalPerceptronFreeEnergy |
| end |
|
|
| end OAI |
|
|
