| import Mathlib |
| import OAI.Probability.IsingPerceptron.WeightedPartitionNumeratorIncrement |
|
|
| namespace OAI |
|
|
| /-! Noise Tree Keep. -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal BoundedContinuousFunction |
| namespace IsingPerceptron |
| variable {A S : Type} [MeasurableSpace A] [MeasurableSpace S] [Nonempty A] |
|
|
| def noiseTreeKeep : (n : ℕ) → (ℕ → ℝ) → (ℕ → ProbabilityMeasure A) → |
| (ℕ → S × A → ℝ) → (ℕ → S × A → S) → S → NoiseTree A n → NoiseTree A n |
| | 0, _, _, _, _, _, _ => PUnit.unit |
| | n+1, b, μ, c, u, s, ν => |
| (sigmaPart ((powerIntensity (b 0)).prod ((μ 0 : Measure A).prod |
| (noiseCascadeLaw A n (fun j => b (j+1)) (fun j => μ (j+1))))) ν).map |
| (fun p => (c 0 (s,p.2.1)*p.1, (p.2.1, |
| noiseTreeKeep n (fun j => b (j+1)) (fun j => μ (j+1)) |
| (fun j => c (j+1)) (fun j => u (j+1)) (u 0 (s,p.2.1)) p.2.2))) |
|
|
| lemma measurable_noiseTreeKeep (n : ℕ) (b : ℕ → ℝ) (μ : ℕ → ProbabilityMeasure A) |
| {c : ℕ → S × A → ℝ} {u : ℕ → S × A → S} |
| (hc : ∀ i, Measurable (c i)) (hu : ∀ i, Measurable (u i)) : |
| Measurable (fun p : S × NoiseTree A n => noiseTreeKeep n b μ c u p.1 p.2) := by |
| induction n generalizing b μ c u with |
| | zero => exact measurable_const |
| | succ n ih => |
| unfold noiseTreeKeep |
| apply measurable_map_sigmaPart_param _ measurable_snd |
| (G := fun p : (S × NoiseTree A (n+1)) × (ℝ × (A × NoiseTree A n)) => |
| (c 0 (p.1.1,p.2.2.1) * p.2.1, (p.2.2.1, |
| noiseTreeKeep n (fun j => b (j+1)) (fun j => μ (j+1)) |
| (fun j => c (j+1)) (fun j => u (j+1)) (u 0 (p.1.1,p.2.2.1)) p.2.2.2))) |
| exact (((hc 0).comp (by fun_prop)).mul (by fun_prop)).prodMk |
| ((by fun_prop : Measurable (fun p : (S × NoiseTree A (n+1)) × |
| (ℝ × (A × NoiseTree A n)) => p.2.2.1)).prodMk |
| ((ih _ _ (fun i => hc (i+1)) (fun i => hu (i+1))).comp |
| (((hu 0).comp (by fun_prop)).prodMk (by fun_prop)))) |
|
|
| lemma noiseTreeKeep_forget (n : ℕ) (b : ℕ → ℝ) (μ : ℕ → ProbabilityMeasure A) |
| {c : ℕ → S × A → ℝ} {u : ℕ → S × A → S} |
| (hc : ∀ i, Measurable (c i)) (hu : ∀ i, Measurable (u i)) |
| (s : S) (ν : NoiseTree A n) : |
| noiseTreeForget A n (noiseTreeKeep n b μ c u s ν) = noiseTreeDisplace n b μ c u s ν := by |
| induction n generalizing b μ c u s with |
| | zero => rfl |
| | succ n ih => |
| unfold noiseTreeKeep noiseTreeForget noiseTreeDisplace |
| rw [Measure.map_map] |
| · congr 1 |
| funext p |
| dsimp only [Function.comp_apply] |
| rw [ih _ _ (fun i => hc (i+1)) (fun i => hu (i+1))] |
| · exact measurable_fst.prodMk ((measurable_noiseTreeForget A n).comp (by fun_prop)) |
| · exact (((hc 0).comp (measurable_const.prodMk (by fun_prop))).mul |
| measurable_fst).prodMk |
| ((by fun_prop : Measurable (fun p : ℝ × (A × NoiseTree A n) => p.2.1)).prodMk |
| ((measurable_noiseTreeKeep n _ _ (fun i => hc (i+1)) (fun i => hu (i+1))).comp |
| (((hu 0).comp (measurable_const.prodMk (by fun_prop))).prodMk (by fun_prop)))) |
|
|
| end IsingPerceptron |
|
|
| namespace IsingPerceptron |
|
|
| lemma map_powerIntensity_keep_subtree {A B C : Type*} [MeasurableSpace A] |
| [MeasurableSpace B] [MeasurableSpace C] (b : ℝ) |
| (μ : Measure A) (P : Measure B) [IsProbabilityMeasure μ] [IsProbabilityMeasure P] |
| {c : A → ℝ} (hc : Measurable c) (hcpos : ∀ a, 0 < c a) |
| {T : A × B → C} (hT : Measurable T) : |
| ((powerIntensity b).prod (μ.prod P)).map |
| (fun p : ℝ × (A × B) => (c p.2.1 * p.1,(p.2.1,T p.2))) = |
| (powerIntensity b).prod |
| (((μ.prod P).withDensity (fun p => ENNReal.ofReal (c p.1^b))).map (fun p => (p.1,T p))) := by |
| have hF : Measurable (fun p : ℝ × (A × B) => (c p.2.1 * p.1,(p.2.1,T p.2))) := |
| ((hc.comp (measurable_fst.comp measurable_snd)).mul measurable_fst).prodMk |
| ((measurable_fst.comp measurable_snd).prodMk (hT.comp measurable_snd)) |
| have hD : Measurable (fun p : A × B => ENNReal.ofReal (c p.1^b)) := by fun_prop |
| apply Measure.ext_of_lintegral |
| intro f hf |
| rw [lintegral_map hf hF] |
| rw [lintegral_prod_symm _ (show Measurable (fun p : ℝ × (A × B) => |
| f (c p.2.1*p.1,(p.2.1,T p.2))) from hf.comp hF).aemeasurable] |
| have hx (p : A × B) : (∫⁻ x, f (c p.1*x,(p.1,T p)) ∂powerIntensity b) = |
| ENNReal.ofReal (c p.1^b) * ∫⁻ x, f (x,(p.1,T p)) ∂powerIntensity b := by |
| calc |
| _ = ∫⁻ x, f (x,(p.1,T p)) ∂(powerIntensity b).map (fun x => c p.1*x) := |
| (lintegral_map (hf.comp (measurable_id.prodMk measurable_const)) |
| (measurable_const_mul (c p.1))).symm |
| _ = _ := by |
| rw [map_powerIntensity_mul (hcpos p.1), lintegral_smul_measure] |
| rfl |
| simp_rw [hx] |
| have hg : Measurable (fun p : A × B => ∫⁻ x, f (x,(p.1,T p)) ∂powerIntensity b) := by |
| have hh : Measurable (fun p : (A × B) × ℝ => f (p.2,(p.1.1,T p.1))) := |
| hf.comp (measurable_snd.prodMk |
| ((measurable_fst.comp measurable_fst).prodMk (hT.comp measurable_fst))) |
| exact hh.lintegral_prod_right' |
| calc |
| _ = ∫⁻ p, (∫⁻ x, f (x,(p.1,T p)) ∂powerIntensity b) |
| ∂(μ.prod P).withDensity (fun p => ENNReal.ofReal (c p.1^b)) := |
| (lintegral_withDensity_eq_lintegral_mul _ hD hg).symm |
| _ = ∫⁻ p, (∫⁻ x, f (x,p) ∂powerIntensity b) |
| ∂(((μ.prod P).withDensity (fun p => ENNReal.ofReal (c p.1^b))).map |
| (fun p => (p.1,T p))) := |
| (lintegral_map hf.lintegral_prod_left' (measurable_fst.prodMk hT)).symm |
| _ = _ := (lintegral_prod_symm _ hf.aemeasurable).symm |
|
|
| variable {A S : Type} [MeasurableSpace A] [MeasurableSpace S] [Nonempty A] |
|
|
| theorem noiseTreeKeep_law_succ (n : ℕ) (b : ℕ → ℝ) (μ : ℕ → ProbabilityMeasure A) |
| {c : ℕ → S × A → ℝ} {u : ℕ → S × A → S} |
| (hc : ∀ i, Measurable (c i)) (hu : ∀ i, Measurable (u i)) |
| (hcpos : ∀ i s a, 0 < c i (s,a)) (s : S) : |
| let P := (noiseCascadeLaw A n (fun j => b (j+1)) (fun j => μ (j+1)) : Measure (NoiseTree A n)) |
| let G := fun p : A × NoiseTree A n => (p.1, |
| noiseTreeKeep n (fun j => b (j+1)) (fun j => μ (j+1)) |
| (fun j => c (j+1)) (fun j => u (j+1)) (u 0 (s,p.1)) p.2) |
| (noiseCascadeLaw A (n+1) b μ : Measure (NoiseTree A (n+1))).map |
| (noiseTreeKeep (n+1) b μ c u s) = |
| poissonLaw ((powerIntensity (b 0)).prod |
| ((((μ 0 : Measure A).prod P).withDensity (fun p => ENNReal.ofReal (c 0 (s,p.1)^b 0))).map G)) := by |
| dsimp only |
| let P := (noiseCascadeLaw A n (fun j => b (j+1)) (fun j => μ (j+1)) : Measure (NoiseTree A n)) |
| let I := (powerIntensity (b 0)).prod ((μ 0 : Measure A).prod P) |
| let T : A × NoiseTree A n → NoiseTree A n := fun p => |
| noiseTreeKeep n (fun j => b (j+1)) (fun j => μ (j+1)) |
| (fun j => c (j+1)) (fun j => u (j+1)) (u 0 (s,p.1)) p.2 |
| have hT : Measurable T := |
| (measurable_noiseTreeKeep n _ _ (fun i => hc (i+1)) (fun i => hu (i+1))).comp |
| (((hu 0).comp (measurable_const.prodMk measurable_fst)).prodMk measurable_snd) |
| let G : ℝ × (A × NoiseTree A n) → ℝ × (A × NoiseTree A n) := |
| fun p => (c 0 (s,p.2.1)*p.1,(p.2.1,T p.2)) |
| have hG : Measurable G := |
| (((hc 0).comp (measurable_const.prodMk (measurable_fst.comp measurable_snd))).mul |
| measurable_fst).prodMk |
| ((measurable_fst.comp measurable_snd).prodMk (hT.comp measurable_snd)) |
| rw [noiseCascadeLaw_succ] |
| calc |
| _ = (poissonLaw I).map (fun ν => ν.map G) := by |
| apply Measure.map_congr |
| filter_upwards [sigmaPart_eq_ae I] with ν hν |
| change (sigmaPart I ν).map G = ν.map G |
| rw [hν] |
| _ = poissonLaw (I.map G) := poissonLaw_map I hG |
| _ = _ := by |
| apply poissonLaw_congr |
| exact map_powerIntensity_keep_subtree (b 0) (μ 0 : Measure A) P |
| ((hc 0).comp (measurable_const.prodMk measurable_id)) (hcpos 0 s) hT |
|
|
| end IsingPerceptron |
|
|
| namespace IsingPerceptron |
|
|
| lemma measurable_measure_ae {E : Type*} [MeasurableSpace E] {p : E → Prop} |
| (hp : MeasurableSet {x | p x}) : MeasurableSet {ν : Measure E | ∀ᵐ x ∂ν, p x} := by |
| simp only [ae_iff] |
| exact measurableSet_eq_fun (Measure.measurable_coe hp.compl) measurable_const |
|
|
| lemma normalizeMass_map {E F : Type*} [MeasurableSpace E] [MeasurableSpace F] |
| [Nonempty E] [Nonempty F] (ν : Measure E) {f : E → F} (hf : Measurable f) |
| (hν : 0 < ν univ ∧ ν univ < ∞) : |
| (normalizeMass ν).map f = normalizeMass (ν.map f) := by |
| have ht : ν.map f univ = ν univ := by rw [Measure.map_apply hf MeasurableSet.univ]; rfl |
| rw [normalizeMass, ite_eq_left hν, normalizeMass, ht, ite_eq_left hν, |
| Measure.map_smul _ hf.aemeasurable] |
|
|
| lemma withDensity_map_pullback {E F : Type*} [MeasurableSpace E] [MeasurableSpace F] |
| (ν : Measure E) {f : E → F} (hf : Measurable f) {w : F → ℝ≥0∞} (hw : Measurable w) : |
| (ν.withDensity (fun x => w (f x))).map f = (ν.map f).withDensity w := by |
| apply Measure.ext_of_lintegral |
| intro g hg |
| calc |
| _ = ∫⁻ x, g (f x) ∂ν.withDensity (fun x => w (f x)) := |
| lintegral_map' hg.aemeasurable hf.aemeasurable |
| _ = ∫⁻ x, w (f x) * g (f x) ∂ν := |
| lintegral_withDensity_eq_lintegral_mul _ (hw.comp hf) (hg.comp hf) |
| _ = ∫⁻ x, w x * g x ∂ν.map f := |
| (lintegral_map' (hw.mul hg).aemeasurable hf.aemeasurable).symm |
| _ = _ := (lintegral_withDensity_eq_lintegral_mul _ hw hg).symm |
|
|
| variable (A : Type) [MeasurableSpace A] [Nonempty A] |
|
|
| def GoodNoiseTree : (n : ℕ) → NoiseTree A n → Prop |
| | 0, _ => True |
| | n+1, ν => (0 < noiseTreeTotal A (n+1) ν ∧ noiseTreeTotal A (n+1) ν < ∞) ∧ |
| ∀ᵐ p ∂ν, GoodNoiseTree n p.2.2 |
|
|
| omit [Nonempty A] in |
| lemma measurableSet_GoodNoiseTree (n : ℕ) : MeasurableSet {ν | GoodNoiseTree A n ν} := by |
| induction n with |
| | zero => exact MeasurableSet.univ |
| | succ n ih => |
| exact ((measurableSet_lt measurable_const (measurable_noiseTreeTotal A (n+1))).inter |
| (measurableSet_lt (measurable_noiseTreeTotal A (n+1)) measurable_const)).inter |
| (measurable_measure_ae (ih.preimage (measurable_snd.comp measurable_snd))) |
|
|
| lemma noiseCascade_good (n : ℕ) (b : ℕ → ℝ) (hb : CascadeExponents n b) |
| (μ : ℕ → ProbabilityMeasure A) : |
| ∀ᵐ ν ∂(noiseCascadeLaw A n b μ : Measure (NoiseTree A n)), GoodNoiseTree A n ν := by |
| induction n generalizing b μ with |
| | zero => exact ae_of_all _ (fun _ => trivial) |
| | succ n ih => |
| have htot : ∀ᵐ ν ∂(noiseCascadeLaw A (n+1) b μ : Measure (NoiseTree A (n+1))), |
| 0 < noiseTreeTotal A (n+1) ν ∧ noiseTreeTotal A (n+1) ν < ∞ := by |
| apply ae_of_ae_map (μ := (noiseCascadeLaw A (n+1) b μ : Measure (NoiseTree A (n+1)))) |
| (p := fun T : RawTree (n+1) => 0 < rawTreeTotal (n+1) T ∧ rawTreeTotal (n+1) T < ∞) |
| (measurable_noiseTreeForget A (n+1)).aemeasurable |
| rw [noiseCascadeLaw_forget] |
| exact (rawCascade_total_moments (n+1) b hb).1 |
| have hm : MeasurableSet {p : ℝ × (A × NoiseTree A n) | GoodNoiseTree A n p.2.2} := |
| (measurableSet_GoodNoiseTree A n).preimage (by fun_prop) |
| have hdesc : ∀ᵐ p ∂(powerIntensity (b 0)).prod ((μ 0 : Measure A).prod |
| (noiseCascadeLaw A n (fun j => b (j+1)) (fun j => μ (j+1)))), GoodNoiseTree A n p.2.2 := by |
| apply (Measure.ae_prod_iff_ae_ae hm).mpr |
| apply ae_of_all |
| intro _ |
| apply (Measure.ae_prod_iff_ae_ae ((measurableSet_GoodNoiseTree A n).preimage measurable_snd)).mpr |
| exact ae_of_all _ (fun _ => ih (fun j => b (j+1)) hb.tail (fun j => μ (j+1))) |
| have hc := poissonLaw_ae_intensity _ hm hdesc |
| filter_upwards [htot, hc] with ν ht hd |
| exact ⟨ht, hd⟩ |
|
|
| def noiseChildMass (n : ℕ) (ν : NoiseTree A (n+1)) : Measure (ℝ × (A × NoiseTree A n)) := |
| ν.withDensity (fun p => ENNReal.ofReal (max p.1 0)*noiseTreeTotal A n p.2.2) |
|
|
| omit [Nonempty A] in |
| lemma noiseChildMass_univ (n : ℕ) (ν : NoiseTree A (n+1)) : |
| noiseChildMass A n ν univ = noiseTreeTotal A (n+1) ν := by |
| rw [noiseTreeTotal_succ] |
| simp [noiseChildMass, withDensity_apply] |
|
|
| omit [Nonempty A] in |
| lemma measurable_noiseChildMass (n : ℕ) : Measurable (noiseChildMass A n) := |
| measurable_withDensity_fixed ((by fun_prop : Measurable (fun p : ℝ × (A × NoiseTree A n) => |
| ENNReal.ofReal (max p.1 0))).mul ((measurable_noiseTreeTotal A n).comp (by fun_prop))) |
|
|
| def noiseChildKernel (n : ℕ) : Kernel (NoiseTree A (n+1)) (ℝ × (A × NoiseTree A n)) := |
| ⟨fun ν => normalizeMass (noiseChildMass A n ν), |
| measurable_normalizeMass.comp (measurable_noiseChildMass A n)⟩ |
|
|
| instance noiseChildKernel_markov (n : ℕ) : IsMarkovKernel (noiseChildKernel A n) := |
| ⟨fun _ => normalizeMass_probability _⟩ |
|
|
| @[reducible] def NoiseLeaf : ℕ → Type |
| | 0 => PUnit |
| | n+1 => ℝ × (A × NoiseLeaf n) |
|
|
| instance noiseLeafMeasurableSpace : (n : ℕ) → MeasurableSpace (NoiseLeaf A n) |
| | 0 => inferInstanceAs (MeasurableSpace PUnit) |
| | n+1 => letI := noiseLeafMeasurableSpace n |
| inferInstanceAs (MeasurableSpace (ℝ × (A × NoiseLeaf A n))) |
|
|
| instance noiseLeafNonempty : (n : ℕ) → Nonempty (NoiseLeaf A n) |
| | 0 => ⟨PUnit.unit⟩ |
| | n+1 => letI := noiseLeafNonempty n |
| inferInstanceAs (Nonempty (ℝ × (A × NoiseLeaf A n))) |
|
|
| def noiseLeafKernelData : (n : ℕ) → {κ : Kernel (NoiseTree A n) (NoiseLeaf A n) |
| | 0 => ⟨Kernel.const _ (Measure.dirac PUnit.unit), by |
| change IsMarkovKernel (Kernel.const PUnit (Measure.dirac (PUnit.unit : PUnit))) |
| infer_instance⟩ |
| | n+1 => |
| let κ := (noiseLeafKernelData n).val |
| letI : IsMarkovKernel κ := (noiseLeafKernelData n).property |
| ⟨((Kernel.id : Kernel ℝ ℝ) ∥ₖ ((Kernel.id : Kernel A A) ∥ₖ κ)) ∘ₖ noiseChildKernel A n, by |
| change IsMarkovKernel (((Kernel.id : Kernel ℝ ℝ) ∥ₖ ((Kernel.id : Kernel A A) ∥ₖ κ)) ∘ₖ noiseChildKernel A n) |
| infer_instance⟩ |
|
|
| def noiseLeafKernel (n : ℕ) : Kernel (NoiseTree A n) (NoiseLeaf A n) := (noiseLeafKernelData A n).val |
|
|
| instance noiseLeafKernel_markov (n : ℕ) : IsMarkovKernel (noiseLeafKernel A n) := |
| (noiseLeafKernelData A n).property |
|
|
| def noiseLeafForget : (n : ℕ) → NoiseLeaf A n → RawLeaf n |
| | 0, _ => PUnit.unit |
| | n+1, p => (p.1, noiseLeafForget n p.2.2) |
|
|
| omit [Nonempty A] in |
| lemma measurable_noiseLeafForget (n : ℕ) : Measurable (noiseLeafForget A n) := by |
| induction n with |
| | zero => exact measurable_const |
| | succ n ih => exact measurable_fst.prodMk (ih.comp (measurable_snd.comp measurable_snd)) |
|
|
| end IsingPerceptron |
|
|
| namespace IsingPerceptron |
| open scoped ProbabilityTheory |
| variable (A : Type) [MeasurableSpace A] [Nonempty A] |
|
|
| omit [Nonempty A] in |
| lemma noiseChildMass_forget (n : ℕ) (ν : NoiseTree A (n+1)) : |
| (noiseChildMass A n ν).map (fun p => (p.1, noiseTreeForget A n p.2.2)) = |
| childMass n (noiseTreeForget A (n+1) ν) := by |
| change (ν.withDensity (fun p => ENNReal.ofReal (max p.1 0) * rawTreeTotal n (noiseTreeForget A n p.2.2))).map |
| (fun p => (p.1,noiseTreeForget A n p.2.2)) = (ν.map (fun p => (p.1,noiseTreeForget A n p.2.2))).withDensity |
| (fun p => ENNReal.ofReal (max p.1 0) * rawTreeTotal n p.2) |
| exact withDensity_map_pullback ν |
| (f := fun p : ℝ × (A × NoiseTree A n) => (p.1,noiseTreeForget A n p.2.2)) |
| (w := fun p : ℝ × RawTree n => ENNReal.ofReal (max p.1 0) * rawTreeTotal n p.2) |
| (measurable_fst.prodMk ((measurable_noiseTreeForget A n).comp (by fun_prop))) |
| ((by fun_prop : Measurable (fun p : ℝ × RawTree n => ENNReal.ofReal (max p.1 0))).mul |
| ((measurable_rawTreeTotal n).comp measurable_snd)) |
|
|
| lemma noiseChildKernel_forget (n : ℕ) (ν : NoiseTree A (n+1)) |
| (hν : 0 < noiseTreeTotal A (n+1) ν ∧ noiseTreeTotal A (n+1) ν < ∞) : |
| (noiseChildKernel A n ν).map (fun p => (p.1, noiseTreeForget A n p.2.2)) = |
| rawChildKernel n (noiseTreeForget A (n+1) ν) := by |
| change (normalizeMass (noiseChildMass A n ν)).map _ = normalizeMass _ |
| rw [normalizeMass_map (noiseChildMass A n ν) |
| (f := fun p : ℝ × (A × NoiseTree A n) => (p.1,noiseTreeForget A n p.2.2)) |
| (measurable_fst.prodMk |
| ((measurable_noiseTreeForget A n).comp (by fun_prop))) |
| (by simpa only [noiseChildMass_univ] using hν), noiseChildMass_forget] |
|
|
| lemma noiseChildKernel_ae (n : ℕ) (ν : NoiseTree A (n+1)) |
| (hν : 0 < noiseTreeTotal A (n+1) ν ∧ noiseTreeTotal A (n+1) ν < ∞) |
| {p : ℝ × (A × NoiseTree A n) → Prop} (hp : ∀ᵐ x ∂ν, p x) : |
| ∀ᵐ x ∂noiseChildKernel A n ν, p x := by |
| change ∀ᵐ x ∂normalizeMass (noiseChildMass A n ν), p x |
| rw [normalizeMass, ite_eq_left (by simpa only [noiseChildMass_univ] using hν)] |
| exact Measure.ae_smul_measure ((withDensity_absolutelyContinuous ν _).ae_le hp) _ |
|
|
| lemma noiseLeafKernel_succ (n : ℕ) : noiseLeafKernel A (n+1) = |
| ((Kernel.id : Kernel ℝ ℝ) ∥ₖ ((Kernel.id : Kernel A A) ∥ₖ noiseLeafKernel A n)) ∘ₖ |
| noiseChildKernel A n := rfl |
|
|
| lemma noiseLeafKernel_step (n : ℕ) (ν : NoiseTree A (n+1)) |
| {F : NoiseLeaf A (n+1) → ℝ≥0∞} (hF : Measurable F) : |
| (∫⁻ v, F v ∂noiseLeafKernel A (n+1) ν) = |
| ∫⁻ p, ∫⁻ v, F (p.1,(p.2.1,v)) ∂noiseLeafKernel A n p.2.2 ∂noiseChildKernel A n ν := by |
| rw [noiseLeafKernel_succ, Kernel.lintegral_comp _ _ _ hF] |
| apply lintegral_congr |
| intro p |
| rw [Kernel.parallelComp_apply, Kernel.id_apply, lintegral_prod _ hF.aemeasurable, |
| lintegral_dirac'] |
| swap |
| · exact hF.lintegral_prod_right' |
| rw [Kernel.parallelComp_apply, Kernel.id_apply, |
| lintegral_prod _ (show AEMeasurable (fun y : A × NoiseLeaf A n => F (p.1,y)) _ from |
| (hF.comp measurable_prodMk_left).aemeasurable), |
| lintegral_dirac'] |
| exact (hF.comp measurable_prodMk_left).lintegral_prod_right' |
|
|
| omit [Nonempty A] in |
| lemma rawLeafKernel_step (n : ℕ) (ν : RawTree (n+1)) |
| {F : RawLeaf (n+1) → ℝ≥0∞} (hF : Measurable F) : |
| (∫⁻ v, F v ∂rawLeafKernel (n+1) ν) = |
| ∫⁻ p, ∫⁻ v, F (p.1,v) ∂rawLeafKernel n p.2 ∂rawChildKernel n ν := by |
| rw [rawLeafKernel_succ, Kernel.lintegral_comp _ _ _ hF] |
| apply lintegral_congr |
| intro p |
| rw [Kernel.parallelComp_apply, Kernel.id_apply, lintegral_prod _ hF.aemeasurable, |
| lintegral_dirac'] |
| exact hF.lintegral_prod_right' |
|
|
| theorem noiseLeafKernel_forget (n : ℕ) (ν : NoiseTree A n) (hν : GoodNoiseTree A n ν) : |
| (noiseLeafKernel A n ν).map (noiseLeafForget A n) = rawLeafKernel n (noiseTreeForget A n ν) := by |
| induction n with |
| | zero => |
| change (Measure.dirac (PUnit.unit : PUnit)).map (fun _ => PUnit.unit) = Measure.dirac PUnit.unit |
| rw [Measure.map_dirac' measurable_const] |
| | succ n ih => |
| apply Measure.ext_of_lintegral |
| intro F hF |
| rw [lintegral_map' hF.aemeasurable (measurable_noiseLeafForget A (n+1)).aemeasurable, |
| noiseLeafKernel_step A n ν (F := fun v => F (noiseLeafForget A (n+1) v)) |
| (hF.comp (measurable_noiseLeafForget A (n+1))), |
| rawLeafKernel_step n _ hF] |
| have hm : Measurable (fun p : ℝ × RawTree n => |
| ∫⁻ v, F (p.1,v) ∂rawLeafKernel n p.2) := |
| (hF.comp (by fun_prop : Measurable (fun p : (ℝ × RawTree n) × RawLeaf n => (p.1.1,p.2)))).lintegral_kernel_prod_right' |
| (κ := (rawLeafKernel n).comap Prod.snd measurable_snd) |
| rw [← noiseChildKernel_forget A n ν hν.1, |
| lintegral_map' hm.aemeasurable (show AEMeasurable (fun p : ℝ × (A × NoiseTree A n) => |
| (p.1,noiseTreeForget A n p.2.2)) _ from (measurable_fst.prodMk |
| ((measurable_noiseTreeForget A n).comp (by fun_prop))).aemeasurable)] |
| apply lintegral_congr_ae |
| filter_upwards [noiseChildKernel_ae A n ν hν.1 hν.2] with p hp |
| change (∫⁻ v, F (p.1,noiseLeafForget A n v) ∂noiseLeafKernel A n p.2.2) = _ |
| rw [← ih p.2.2 hp, |
| lintegral_map' (show AEMeasurable (fun v : RawLeaf n => F (p.1,v)) _ from |
| (hF.comp measurable_prodMk_left).aemeasurable) (measurable_noiseLeafForget A n).aemeasurable] |
| |
| end IsingPerceptron |
| |
| namespace IsingPerceptron |
| open scoped ProbabilityTheory |
| variable {A S : Type} [MeasurableSpace A] [MeasurableSpace S] [Nonempty A] |
| |
| def noiseLeafTerminal : (n : ℕ) → (ℕ → S → ℝ) → (ℕ → S × A → S) → |
| S → NoiseLeaf A n → ℝ |
| | 0, X, _, s, _ => X 0 s |
| | n+1, X, u, s, v => noiseLeafTerminal n (fun i => X (i+1)) |
| (fun i => u (i+1)) (u 0 (s,v.2.1)) v.2.2 |
| |
| omit [Nonempty A] in |
| lemma measurable_noiseLeafTerminal (n : ℕ) {X : ℕ → S → ℝ} {u : ℕ → S × A → S} |
| (hX : ∀ i, Measurable (X i)) (hu : ∀ i, Measurable (u i)) : |
| Measurable (fun p : S × NoiseLeaf A n => noiseLeafTerminal n X u p.1 p.2) := by |
| induction n generalizing X u with |
| | zero => exact (hX 0).comp measurable_fst |
| | succ n ih => |
| exact (ih (fun i => hX (i+1)) (fun i => hu (i+1))).comp |
| (((hu 0).comp (by fun_prop)).prodMk (by fun_prop)) |
| |
| lemma noiseChildKernel_lintegral (n : ℕ) (ν : NoiseTree A (n+1)) |
| (hν : 0 < noiseTreeTotal A (n+1) ν ∧ noiseTreeTotal A (n+1) ν < ∞) |
| {F : ℝ × (A × NoiseTree A n) → ℝ≥0∞} (hF : Measurable F) : |
| (∫⁻ p, F p ∂noiseChildKernel A n ν) = (noiseTreeTotal A (n+1) ν)⁻¹ * |
| ∫⁻ p, ENNReal.ofReal (max p.1 0) * noiseTreeTotal A n p.2.2 * F p ∂ν := by |
| change (∫⁻ p, F p ∂normalizeMass (noiseChildMass A n ν)) = _ |
| rw [normalizeMass, ite_eq_left (by simpa only [noiseChildMass_univ] using hν), |
| lintegral_smul_measure, smul_eq_mul, noiseChildMass_univ, noiseChildMass] |
| congr 1 |
| exact lintegral_withDensity_eq_lintegral_mul ν |
| (show Measurable (fun p : ℝ × (A × NoiseTree A n) => |
| ENNReal.ofReal (max p.1 0) * noiseTreeTotal A n p.2.2) from |
| ((by fun_prop : Measurable (fun p : ℝ × (A × NoiseTree A n) => |
| ENNReal.ofReal (max p.1 0))).mul ((measurable_noiseTreeTotal A n).comp (by fun_prop)))) hF |
| |
| lemma noiseLeafKernel_lintegral (n : ℕ) (ν : NoiseTree A (n+1)) |
| (hν : 0 < noiseTreeTotal A (n+1) ν ∧ noiseTreeTotal A (n+1) ν < ∞) |
| {F : NoiseLeaf A (n+1) → ℝ≥0∞} (hF : Measurable F) : |
| (∫⁻ v, F v ∂noiseLeafKernel A (n+1) ν) = (noiseTreeTotal A (n+1) ν)⁻¹ * |
| ∫⁻ p, ENNReal.ofReal (max p.1 0) * noiseTreeTotal A n p.2.2 * |
| (∫⁻ v, F (p.1,(p.2.1,v)) ∂noiseLeafKernel A n p.2.2) ∂ν := by |
| rw [noiseLeafKernel_step A n ν hF] |
| apply noiseChildKernel_lintegral n ν hν |
| exact (hF.comp (by fun_prop : Measurable (fun p : |
| (ℝ × (A × NoiseTree A n)) × NoiseLeaf A n => (p.1.1,(p.1.2.1,p.2))))).lintegral_kernel_prod_right' |
| (κ := (noiseLeafKernel A n).comap (fun p : ℝ × (A × NoiseTree A n) => p.2.2) (by fun_prop)) |
|
|
| lemma measurable_noiseLeafIntegral (n : ℕ) {X : ℕ → S → ℝ} {u : ℕ → S × A → S} |
| (hX : ∀ i, Measurable (X i)) (hu : ∀ i, Measurable (u i)) : |
| Measurable (fun p : S × NoiseTree A n => ∫⁻ v, |
| ENNReal.ofReal (Real.exp (noiseLeafTerminal n X u p.1 v)) ∂noiseLeafKernel A n p.2) := |
| (((measurable_noiseLeafTerminal n hX hu).comp (by fun_prop : Measurable |
| (fun p : (S × NoiseTree A n) × NoiseLeaf A n => (p.1.1,p.2)))).exp.ennreal_ofReal).lintegral_kernel_prod_right' |
| (κ := (noiseLeafKernel A n).comap Prod.snd measurable_snd) |
| |
| theorem noiseTreeFactor_leafIntegral (n : ℕ) (b : ℕ → ℝ) (hb : CascadeExponents n b) |
| (μ : ℕ → ProbabilityMeasure A) {X : ℕ → S → ℝ} {u : ℕ → S × A → S} |
| (hX : ∀ i, Measurable (X i)) (hu : ∀ i, Measurable (u i)) (s : S) : |
| ∀ᵐ ν ∂(noiseCascadeLaw A n b μ : Measure (NoiseTree A n)), |
| noiseTreeFactor n b μ X u s ν = noiseTreeTotal A n ν * |
| ∫⁻ v, ENNReal.ofReal (Real.exp (noiseLeafTerminal n X u s v)) ∂noiseLeafKernel A n ν := by |
| induction n generalizing b μ X u s with |
| | zero => |
| apply ae_of_all |
| intro ν |
| simp [noiseTreeFactor, noiseTreeTotal, rawTreeTotal, noiseLeafTerminal, |
| noiseLeafKernel, noiseLeafKernelData, Kernel.const_apply] |
| | succ n ih => |
| let bt := fun j => b (j+1) |
| let μt := fun j => μ (j+1) |
| let Xt := fun j => X (j+1) |
| let ut := fun j => u (j+1) |
| let P := (noiseCascadeLaw A n bt μt : Measure (NoiseTree A n)) |
| let I := (powerIntensity (b 0)).prod ((μ 0 : Measure A).prod P) |
| let E := fun p : ℝ × (A × NoiseTree A n) => |
| noiseTreeFactor n bt μt Xt ut (u 0 (s,p.2.1)) p.2.2 = noiseTreeTotal A n p.2.2 * |
| ∫⁻ v, ENNReal.ofReal (Real.exp (noiseLeafTerminal n Xt ut (u 0 (s,p.2.1)) v)) |
| ∂noiseLeafKernel A n p.2.2 |
| have hme : MeasurableSet {p | E p} := by |
| apply measurableSet_eq_fun |
| · exact (measurable_noiseTreeFactor n bt μt (fun i => hX (i+1)) |
| (fun i => hu (i+1))).comp (((hu 0).comp (measurable_const.prodMk (by fun_prop))).prodMk (by fun_prop)) |
| · exact ((measurable_noiseTreeTotal A n).comp (by fun_prop)).mul |
| ((measurable_noiseLeafIntegral n (fun i => hX (i+1)) (fun i => hu (i+1))).comp |
| (((hu 0).comp (measurable_const.prodMk (by fun_prop))).prodMk (by fun_prop))) |
| have he : ∀ᵐ p ∂I, E p := by |
| apply (Measure.ae_prod_iff_ae_ae hme).mpr |
| apply ae_of_all |
| intro x |
| apply (Measure.ae_prod_iff_ae_ae (hme.preimage (measurable_const.prodMk measurable_id))).mpr |
| apply ae_of_all |
| intro a |
| exact ih bt hb.tail μt (fun i => hX (i+1)) (fun i => hu (i+1)) (u 0 (s,a)) |
| have ha := poissonLaw_ae_intensity I hme he |
| have hg := noiseCascade_good A n.succ b hb μ |
| have hσ := sigmaPart_eq_ae I |
| filter_upwards [ha,hg,hσ] with ν hν hg hσ |
| rw [noiseTreeFactor] |
| change (∫⁻ p, ENNReal.ofReal (max p.1 0) * |
| noiseTreeFactor n bt μt Xt ut (u 0 (s,p.2.1)) p.2.2 ∂sigmaPart I ν) = _ |
| rw [hσ, noiseLeafKernel_lintegral n ν hg.1 |
| (F := fun v => ENNReal.ofReal (Real.exp (noiseLeafTerminal (n+1) X u s v))) |
| (((measurable_noiseLeafTerminal (n+1) hX hu).comp |
| (measurable_const.prodMk measurable_id)).exp.ennreal_ofReal)] |
| rw [← mul_assoc, ENNReal.mul_inv_cancel hg.1.1.ne' hg.1.2.ne, one_mul] |
| apply lintegral_congr_ae |
| filter_upwards [hν] with p hp |
| rw [hp] |
| exact (mul_assoc _ _ _).symm |
|
|
| end IsingPerceptron |
|
|
| namespace IsingPerceptron |
| variable {A S : Type} [MeasurableSpace A] [MeasurableSpace S] [Nonempty A] |
|
|
| def noiseLeafProduct : (n : ℕ) → (ℕ → S × A → ℝ) → (ℕ → S × A → S) → |
| S → NoiseLeaf A n → ℝ≥0∞ |
| | 0, _, _, _, _ => 1 |
| | n+1, c, u, s, v => ENNReal.ofReal (c 0 (s,v.2.1)) * |
| noiseLeafProduct n (fun i => c (i+1)) (fun i => u (i+1)) (u 0 (s,v.2.1)) v.2.2 |
|
|
| def noiseLeafKeep : (n : ℕ) → (ℕ → S × A → ℝ) → (ℕ → S × A → S) → |
| S → NoiseLeaf A n → NoiseLeaf A n |
| | 0, _, _, _, _ => PUnit.unit |
| | n+1, c, u, s, v => (c 0 (s,v.2.1)*v.1, (v.2.1, |
| noiseLeafKeep n (fun i => c (i+1)) (fun i => u (i+1)) (u 0 (s,v.2.1)) v.2.2)) |
|
|
| omit [Nonempty A] in |
| lemma measurable_noiseLeafProduct (n : ℕ) {c : ℕ → S × A → ℝ} {u : ℕ → S × A → S} |
| (hc : ∀ i, Measurable (c i)) (hu : ∀ i, Measurable (u i)) : |
| Measurable (fun p : S × NoiseLeaf A n => noiseLeafProduct n c u p.1 p.2) := by |
| induction n generalizing c u with |
| | zero => exact measurable_const |
| | succ n ih => |
| exact ((hc 0).comp (by fun_prop)).ennreal_ofReal.mul |
| ((ih (fun i => hc (i+1)) (fun i => hu (i+1))).comp |
| (((hu 0).comp (by fun_prop)).prodMk (by fun_prop))) |
|
|
| omit [Nonempty A] in |
| lemma measurable_noiseLeafKeep (n : ℕ) {c : ℕ → S × A → ℝ} {u : ℕ → S × A → S} |
| (hc : ∀ i, Measurable (c i)) (hu : ∀ i, Measurable (u i)) : |
| Measurable (fun p : S × NoiseLeaf A n => noiseLeafKeep n c u p.1 p.2) := by |
| induction n generalizing c u with |
| | zero => exact measurable_const |
| | succ n ih => |
| exact (((hc 0).comp (by fun_prop)).mul (by fun_prop)).prodMk |
| ((by fun_prop : Measurable (fun p : S × NoiseLeaf A (n+1) => p.2.2.1)).prodMk |
| ((ih (fun i => hc (i+1)) (fun i => hu (i+1))).comp |
| (((hu 0).comp (by fun_prop)).prodMk (by fun_prop)))) |
|
|
| def noiseWeightedLeafMeasure (n : ℕ) (c : ℕ → S × A → ℝ) (u : ℕ → S × A → S) |
| (s : S) (ν : NoiseTree A n) : Measure (NoiseLeaf A n) := |
| ((noiseLeafKernel A n ν).withDensity |
| (fun v => noiseTreeTotal A n ν * noiseLeafProduct n c u s v)).map (noiseLeafKeep n c u s) |
|
|
| lemma noiseWeightedLeafMeasure_lintegral (n : ℕ) {c : ℕ → S × A → ℝ} {u : ℕ → S × A → S} |
| (hc : ∀ i, Measurable (c i)) (hu : ∀ i, Measurable (u i)) |
| (s : S) (ν : NoiseTree A n) {F : NoiseLeaf A n → ℝ≥0∞} (hF : Measurable F) : |
| (∫⁻ v, F v ∂noiseWeightedLeafMeasure n c u s ν) = noiseTreeTotal A n ν * |
| ∫⁻ v, noiseLeafProduct n c u s v * F (noiseLeafKeep n c u s v) ∂noiseLeafKernel A n ν := by |
| have hp : Measurable (noiseLeafProduct n c u s) := |
| (measurable_noiseLeafProduct n hc hu).comp (measurable_const.prodMk measurable_id) |
| have hk : Measurable (noiseLeafKeep n c u s) := |
| (measurable_noiseLeafKeep n hc hu).comp (measurable_const.prodMk measurable_id) |
| rw [noiseWeightedLeafMeasure, lintegral_map' hF.aemeasurable hk.aemeasurable, |
| lintegral_withDensity_eq_lintegral_mul _ |
| (show Measurable (fun v => noiseTreeTotal A n ν * noiseLeafProduct n c u s v) from measurable_const.mul hp) |
| (show Measurable (fun v => F (noiseLeafKeep n c u s v)) from hF.comp hk)] |
| change (∫⁻ v, (noiseTreeTotal A n ν * noiseLeafProduct n c u s v) * |
| F (noiseLeafKeep n c u s v) ∂noiseLeafKernel A n ν) = _ |
| simp_rw [mul_assoc] |
| exact lintegral_const_mul _ (hp.mul (hF.comp hk)) |
| |
| lemma measurable_noiseWeightedLeafMeasure (n : ℕ) {c : ℕ → S × A → ℝ} {u : ℕ → S × A → S} |
| (hc : ∀ i, Measurable (c i)) (hu : ∀ i, Measurable (u i)) : |
| Measurable (fun p : S × NoiseTree A n => noiseWeightedLeafMeasure n c u p.1 p.2) := by |
| apply Measure.measurable_of_measurable_coe |
| intro B hB |
| have he (p : S × NoiseTree A n) : noiseWeightedLeafMeasure n c u p.1 p.2 B = |
| noiseTreeTotal A n p.2 * ∫⁻ v, noiseLeafProduct n c u p.1 v * |
| B.indicator (fun _ => (1 : ℝ≥0∞)) (noiseLeafKeep n c u p.1 v) ∂noiseLeafKernel A n p.2 := by |
| rw [← setLIntegral_one, ← lintegral_indicator hB (fun _ => (1 : ℝ≥0∞)), |
| noiseWeightedLeafMeasure_lintegral n hc hu p.1 p.2 (measurable_const.indicator hB)] |
| simp_rw [he] |
| apply ((measurable_noiseTreeTotal A n).comp measurable_snd).mul |
| have hh : Measurable (fun p : (S × NoiseTree A n) × NoiseLeaf A n => |
| noiseLeafProduct n c u p.1.1 p.2 * |
| B.indicator (fun _ => (1 : ℝ≥0∞)) (noiseLeafKeep n c u p.1.1 p.2)) := |
| ((measurable_noiseLeafProduct n hc hu).comp (show Measurable (fun p : (S × NoiseTree A n) × NoiseLeaf A n => (p.1.1,p.2)) from (by fun_prop))).mul |
| ((measurable_const.indicator hB).comp ((measurable_noiseLeafKeep n hc hu).comp (show Measurable (fun p : (S × NoiseTree A n) × NoiseLeaf A n => (p.1.1,p.2)) from (by fun_prop)))) |
| exact hh.lintegral_kernel_prod_right' |
| (κ := (noiseLeafKernel A n).comap Prod.snd measurable_snd) |
|
|
| lemma measurable_noiseUnnormalizedLeaf (n : ℕ) : |
| Measurable (fun ν : NoiseTree A n => noiseTreeTotal A n ν • noiseLeafKernel A n ν) := by |
| apply Measure.measurable_of_measurable_coe |
| intro B hB |
| simp only [Measure.smul_apply, smul_eq_mul] |
| exact (measurable_noiseTreeTotal A n).mul ((noiseLeafKernel A n).measurable_coe hB) |
|
|
| end IsingPerceptron |
|
|
| end |
|
|
| end OAI |
|
|
