| import Mathlib |
| import OAI.Probability.Perceptron.Variational.BlockFocus |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace SphericalPerceptronFreeEnergy |
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped Classical ENNReal NNReal BigOperators Topology |
|
|
| lemma indexedDepthLaw_block_mass (k : ℕ) (z : Fin k → ℝ) |
| (r : ℕ) (A : FiniteBlock (Fin (k+1)) r) : |
| (indexedDepthLaw k z : Measure (FiniteOverlap (Fin (k+1)))) {R | finiteBlock r R = A} = |
| ∫⁻ b, indexedBlockSample k A b ∂indexedCascadeBaseLaw k z := by |
| have hE : MeasurableSet {R : FiniteOverlap (Fin (k+1)) | finiteBlock r R = A} := |
| measurableSet_eq_fun (finiteBlock_measurable r) measurable_const |
| rw [← lintegral_indicator_one hE] |
| simp only [Set.indicator_apply, Pi.one_apply, Set.mem_ofPred_eq] |
| rw [indexedDepthLaw_lintegral_prefix k z r (fun B => if B = A then 1 else 0)] |
| apply lintegral_congr |
| intro b |
| rw [indexedBlockSample_eq_measure,← lintegral_indicator_one ((Set.to_countable _).measurableSet)] |
| simp only [Set.indicator_apply, Pi.one_apply, Set.mem_ofPred_eq] |
|
|
| lemma indexedDepthLaw_focused_mass (k : ℕ) (z : Fin k → ℝ) (r d : ℕ) |
| (A : FiniteBlock (Fin (k+1)) r) (i : Fin r) : |
| (indexedDepthLaw k z : Measure (FiniteOverlap (Fin (k+1)))) |
| {R | finiteBlock r R = A ∧ d ≤ (R i r).val} = |
| ∫⁻ b, indexedBlockFocused k d A i b ∂indexedCascadeBaseLaw k z := by |
| let E : Set (FiniteOverlap (Fin (k+1))) := {R | finiteBlock r R = A ∧ d ≤ (R i r).val} |
| have hE : MeasurableSet E := by |
| exact (measurableSet_eq_fun (finiteBlock_measurable r) measurable_const).inter |
| ((Set.to_countable {l : Fin (k+1) | d ≤ l.val}).measurableSet.preimage (by fun_prop)) |
| change (indexedDepthLaw k z : Measure (FiniteOverlap (Fin (k+1)))) E = _ |
| rw [← lintegral_indicator_one hE] |
| rw [indexedDepthLaw_lintegral k z (E.indicator 1) (measurable_const.indicator hE)] |
| apply lintegral_congr |
| intro b |
| let S : Set ((Fin r → IndexedLeaf k) × IndexedLeaf k) := |
| {p | (fun a c => indexedCommonDepth k (p.1 a) (p.1 c)) = A ∧ |
| d ≤ (indexedCommonDepth k (p.1 i) p.2).val} |
| have hh := (infiniteReplica_prefix_fresh_preserving (indexedLeafProbability k b) r).lintegral_comp |
| (f := S.indicator (fun _ => (1 : ℝ≥0∞))) |
| (measurable_const.indicator ((Set.to_countable S).measurableSet)) |
| calc |
| _ = ∫⁻ xs, S.indicator 1 ((fun j : Fin r => xs j.val),xs r) |
| ∂Measure.infinitePi (fun _ : ℕ => indexedLeafProbability k b) := rfl |
| _ = ∫⁻ p, S.indicator 1 p |
| ∂(Measure.pi (fun _ : Fin r => indexedLeafProbability k b)).prod (indexedLeafProbability k b) := hh |
| _ = _ := by |
| rw [lintegral_indicator_one ((Set.to_countable S).measurableSet),indexedBlockFocused_eq_measure] |
|
|
| theorem indexedDepthLaw_focused_formula (k : ℕ) (z : Fin k → ℝ) |
| (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1) |
| (r d : ℕ) (hd : d ≤ k) (A : FiniteBlock (Fin (k+1)) r) (i : Fin r) : |
| (indexedDepthLaw k z : Measure (FiniteOverlap (Fin (k+1)))) |
| {R | finiteBlock r R = A ∧ d ≤ (R i r).val} = |
| (indexedDepthLaw k z : Measure (FiniteOverlap (Fin (k+1)))) {R | finiteBlock r R = A} * |
| ENNReal.ofReal (((∑ j, if d ≤ (A i j).val then (1:ℝ) else 0) - |
| (if h : d = 0 then 0 else z ⟨d-1,by omega⟩)) / r) := by |
| rw [indexedDepthLaw_focused_mass,indexedDepthLaw_block_mass, |
| indexedBlockFocused_integral k z hz hz0 hz1 d hd A i,Fintype.card_fin] |
|
|
| lemma indexedDepthLaw_one_block_ae (k : ℕ) (z : Fin k → ℝ) : |
| ∀ᵐ R ∂(indexedDepthLaw k z : Measure (FiniteOverlap (Fin (k+1)))), |
| finiteBlock 1 R = fun _ _ => Fin.last k := by |
| filter_upwards [indexedDepthLaw_geometry k z] with R hR |
| funext i j |
| have hi : i = 0 := Subsingleton.elim _ _ |
| have hj : j = 0 := Subsingleton.elim _ _ |
| simpa only [hi,hj,finiteBlock,Fin.val_zero] using hR.2.1 0 |
|
|
| lemma indexedDepthLaw_pair_tail (k : ℕ) (z : Fin k → ℝ) |
| (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1) |
| (d : ℕ) (hd : d ≤ k) : |
| (indexedDepthLaw k z : Measure (FiniteOverlap (Fin (k+1)))) {R | d ≤ (R 0 1).val} = |
| ENNReal.ofReal (1 - (if h : d = 0 then 0 else z ⟨d-1,by omega⟩)) := by |
| let μ := (indexedDepthLaw k z : Measure (FiniteOverlap (Fin (k+1)))) |
| let A : FiniteBlock (Fin (k+1)) 1 := fun _ _ => Fin.last k |
| have hB : μ {R | finiteBlock 1 R = A} = 1 := by |
| rw [← measure_univ (μ := μ)] |
| apply measure_congr |
| filter_upwards [indexedDepthLaw_one_block_ae k z] with R hR |
| change (finiteBlock 1 R = A) = True |
| exact propext ⟨fun _ => trivial, fun _ => hR⟩ |
| have hC : μ {R | finiteBlock 1 R = A ∧ d ≤ (R (0:Fin 1) 1).val} = |
| μ {R | d ≤ (R 0 1).val} := by |
| apply measure_congr |
| filter_upwards [indexedDepthLaw_one_block_ae k z] with R hR |
| change (finiteBlock 1 R = A ∧ d ≤ (R 0 1).val) = (d ≤ (R 0 1).val) |
| exact propext ⟨fun h => h.2, fun h => ⟨hR,h⟩⟩ |
| have h := indexedDepthLaw_focused_formula k z hz hz0 hz1 1 d hd A 0 |
| change μ _ = μ _ * _ at h |
| rw [hB,hC] at h |
| simpa only [A,Fintype.sum_unique,Fin.val_last,ite_eq_left hd,Nat.cast_one,div_one,one_mul] using h |
|
|
| lemma measureReal_fin_atom_from_tails {Ω : Type*} [MeasurableSpace Ω] |
| (μ : Measure Ω) [IsFiniteMeasure μ] (k : ℕ) |
| (f : Ω → Fin (k+1)) (hf : Measurable f) (E : Set Ω) (hE : MeasurableSet E) |
| (c : Fin (k+1)) : |
| μ.real {x | x ∈ E ∧ f x = c} = |
| μ.real {x | x ∈ E ∧ c.val ≤ (f x).val} - |
| μ.real {x | x ∈ E ∧ c.val+1 ≤ (f x).val} := by |
| have hs : MeasurableSet {x | x ∈ E ∧ c.val+1 ≤ (f x).val} := |
| hE.inter ((Set.to_countable {l : Fin (k+1) | c.val+1 ≤ l.val}).measurableSet.preimage hf) |
| have he : {x | x ∈ E ∧ f x = c} = |
| {x | x ∈ E ∧ c.val ≤ (f x).val} \ {x | x ∈ E ∧ c.val+1 ≤ (f x).val} := by |
| apply Set.ext |
| intro x |
| change (x ∈ E ∧ f x = c) ↔ |
| (x ∈ E ∧ c.val ≤ (f x).val) ∧ ¬ (x ∈ E ∧ c.val+1 ≤ (f x).val) |
| constructor |
| · rintro ⟨hx,hxc⟩ |
| simp only [hxc,le_refl,and_true,Nat.not_succ_le_self,and_false,not_false_eq_true] |
| exact hx |
| · intro hx |
| have hn : ¬ c.val+1 ≤ (f x).val := fun h => hx.2 ⟨hx.1.1,h⟩ |
| have hl := hx.1.2 |
| exact ⟨hx.1.1,Fin.ext (by omega)⟩ |
| rw [he,measureReal_sdiff (by intro x hx; exact ⟨hx.1, Nat.le_trans (Nat.le_succ _) hx.2⟩) hs] |
|
|
| theorem finiteGG_of_depth_thresholds (k : ℕ) |
| (μ : Measure (FiniteOverlap (Fin (k+1)))) [IsProbabilityMeasure μ] |
| (hh : ∀ r, 1 ≤ r → ∀ (i : Fin r) (A : FiniteBlock (Fin (k+1)) r) |
| (d : ℕ), d ≤ k+1 → |
| μ.real {R | finiteBlock r R = A ∧ d ≤ (R i r).val} = |
| μ.real {R | finiteBlock r R = A} * μ.real {R | d ≤ (R 0 1).val} / r + |
| (∑ j ∈ Finset.univ.erase i, |
| μ.real {R | finiteBlock r R = A ∧ d ≤ (R i j).val}) / r) : FiniteGG μ := by |
| classical |
| intro r hr i A c |
| have hE : MeasurableSet {R : FiniteOverlap (Fin (k+1)) | finiteBlock r R = A} := |
| measurableSet_eq_fun (finiteBlock_measurable r) measurable_const |
| have hm (i j : ℕ) : Measurable (fun R : FiniteOverlap (Fin (k+1)) => R i j) := by fun_prop |
| have hAtom (a b : ℕ) : μ.real {R | finiteBlock r R = A ∧ R a b = c} = |
| μ.real {R | finiteBlock r R = A ∧ c.val ≤ (R a b).val} - |
| μ.real {R | finiteBlock r R = A ∧ c.val+1 ≤ (R a b).val} := |
| measureReal_fin_atom_from_tails μ k (fun R => R a b) |
| (hm a b) {R | finiteBlock r R = A} hE c |
| have hPair := measureReal_fin_atom_from_tails μ k (fun R => R 0 1) |
| (hm 0 1) univ MeasurableSet.univ c |
| simp only [Set.mem_univ,true_and] at hPair |
| simp_rw [hAtom] |
| rw [hPair,hh r hr i A c.val (by omega),hh r hr i A (c.val+1) (by omega), |
| Finset.sum_sub_distrib] |
| ring |
|
|
| end SphericalPerceptronFreeEnergy |
| end |
|
|
| end OAI |
|
|
