| import Mathlib |
| import OAI.Probability.IsingPerceptron.EnergyShift |
|
|
| namespace OAI |
|
|
| /-! Retained Displacement. -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| |
| lemma map_powerIntensity_retained {A B C : Type*} [MeasurableSpace A] |
| [MeasurableSpace B] [MeasurableSpace C] (b : ℝ) |
| (μ : Measure A) (P : Measure B) (Q : Measure C) |
| [IsProbabilityMeasure μ] [IsProbabilityMeasure P] [IsProbabilityMeasure Q] |
| {c : A → ℝ} (hc : Measurable c) (hcpos : ∀ a, 0 < c a) |
| {T : B → C} (hT : Measurable T) (hLaw : P.map T = Q) : |
| ((powerIntensity b).prod (μ.prod P)).map |
| (fun p : ℝ × (A × B) => (c p.2.1 * p.1,(p.2.1,T p.2.2))) = |
| (powerIntensity b).prod ((μ.withDensity (fun a => ENNReal.ofReal (c a ^ b))).prod Q) := by |
| have hF : Measurable (fun p : ℝ × (A × B) => (c p.2.1*p.1,(p.2.1,T p.2.2))) := by fun_prop |
| have hw : Measurable (fun a => ENNReal.ofReal (c a ^ b)) := (hc.pow_const b).ennreal_ofReal |
| apply Measure.ext_of_lintegral |
| intro f hf |
| rw [lintegral_map hf hF,lintegral_prod |
| (fun p : ℝ × (A × B) => f (c p.2.1*p.1,(p.2.1,T p.2.2))) (hf.comp hF).aemeasurable] |
| have hv (x : ℝ) (a : A) : |
| (∫⁻ v, f (c a*x,(a,T v)) ∂P) = ∫⁻ w, f (c a*x,(a,w)) ∂Q := by |
| rw [← hLaw,lintegral_map] |
| · fun_prop |
| · exact hT |
| have hp (x : ℝ) : (∫⁻ v : A × B, f (c v.1*x,(v.1,T v.2)) ∂μ.prod P) = |
| ∫⁻ a, ∫⁻ w, f (c a*x,(a,w)) ∂Q ∂μ := by |
| rw [lintegral_prod (fun v : A × B => f (c v.1*x,(v.1,T v.2))) |
| ((hf.comp hF).comp (measurable_const.prodMk measurable_id)).aemeasurable] |
| simp_rw [hv] |
| simp_rw [hp] |
| have hG : Measurable (fun p : ℝ × A => ∫⁻ w, f (c p.2*p.1,(p.2,w)) ∂Q) := |
| (hf.comp (by fun_prop : Measurable (fun p : (ℝ × A) × C => (c p.1.2*p.1.1,(p.1.2,p.2))))).lintegral_prod_right' |
| rw [lintegral_lintegral_swap hG.aemeasurable] |
| have hx (a : A) : (∫⁻ x, ∫⁻ w, f (c a*x,(a,w)) ∂Q ∂powerIntensity b) = |
| ENNReal.ofReal (c a ^ b) * (∫⁻ x, ∫⁻ w, f (x,(a,w)) ∂Q ∂powerIntensity b) := by |
| have hfa : Measurable (fun x : ℝ => ∫⁻ w, f (x,(a,w)) ∂Q) := |
| (hf.comp (by fun_prop : Measurable (fun z : ℝ × C => (z.1,(a,z.2))))).lintegral_prod_right' |
| rw [← lintegral_map hfa (measurable_const_mul (c a)),map_powerIntensity_mul (hcpos a),lintegral_smul_measure] |
| rfl |
| simp_rw [hx] |
| have hga : Measurable (fun a : A => ∫⁻ x, ∫⁻ w, f (x,(a,w)) ∂Q ∂powerIntensity b) := |
| ((hf.comp (by fun_prop : Measurable (fun z : (A × ℝ) × C => (z.1.2,(z.1.1,z.2))))).lintegral_prod_right').lintegral_prod_right' |
| calc |
| _ = ∫⁻ a, ∫⁻ x, ∫⁻ w, f (x,(a,w)) ∂Q ∂powerIntensity b |
| ∂μ.withDensity (fun a => ENNReal.ofReal (c a ^ b)) := |
| (lintegral_withDensity_eq_lintegral_mul μ hw hga).symm |
| _ = _ := by |
| rw [lintegral_lintegral_swap] |
| · rw [lintegral_prod _ hf.aemeasurable] |
| congr 1; funext x |
| exact (lintegral_prod _ (hf.comp (measurable_const.prodMk measurable_id)).aemeasurable).symm |
| · exact ((hf.comp (by fun_prop : Measurable (fun z : (A × ℝ) × C => (z.1.2,(z.1.1,z.2))))).lintegral_prod_right').aemeasurable |
|
|
| |
|
|
| theorem noiseTreeKeep_independent_law {A : Type} [MeasurableSpace A] [Nonempty A] |
| (n : ℕ) (b : ℕ → ℝ) (μ ν : ℕ → ProbabilityMeasure A) (c : ℕ → A → ℝ) |
| (hc : ∀ i, Measurable (c i)) (hcpos : ∀ i a, 0 < c i a) |
| (hν : ∀ i, (ν i : Measure A) = (μ i : Measure A).withDensity (fun a => ENNReal.ofReal (c i a ^ b i))) : |
| (noiseCascadeLaw A n b μ : Measure (NoiseTree A n)).map |
| (noiseTreeKeep n b μ (fun i (p : PUnit × A) => c i p.2) (fun _ _ => PUnit.unit) PUnit.unit) = |
| noiseCascadeLaw A n b ν := by |
| induction n generalizing b μ ν c with |
| | zero => exact Measure.map_dirac' measurable_const _ |
| | succ n ih => |
| let μ' := fun i => μ (i+1) |
| let ν' := fun i => ν (i+1) |
| let b' := fun i => b (i+1) |
| let c' := fun i => c (i+1) |
| let P : Measure (NoiseTree A n) := noiseCascadeLaw A n b' μ' |
| let Q : Measure (NoiseTree A n) := noiseCascadeLaw A n b' ν' |
| let T := noiseTreeKeep n b' μ' (fun i (p : PUnit × A) => c' i p.2) (fun _ _ => PUnit.unit) PUnit.unit |
| have hT : Measurable T := (measurable_noiseTreeKeep n b' μ' (fun i => (hc (i+1)).comp measurable_snd) |
| (fun _ => measurable_const)).comp (measurable_const.prodMk measurable_id) |
| have hLaw : P.map T = Q := ih b' μ' ν' c' (fun i => hc (i+1)) (fun i => hcpos (i+1)) (fun i => hν (i+1)) |
| let I := (powerIntensity (b 0)).prod ((μ 0 : Measure A).prod P) |
| let G : ℝ × (A × NoiseTree A n) → ℝ × (A × NoiseTree A n) := fun p => (c 0 p.2.1*p.1,(p.2.1,T p.2.2)) |
| have hG : Measurable G := by fun_prop |
| have hI : I.map G = (powerIntensity (b 0)).prod ((ν 0 : Measure A).prod Q) := by |
| rw [hν 0] |
| exact map_powerIntensity_retained (b 0) (μ 0 : Measure A) P Q (hc 0) (hcpos 0) hT hLaw |
| rw [noiseCascadeLaw_succ,noiseCascadeLaw_succ] |
| change (poissonLaw I).map _ = poissonLaw ((powerIntensity (b 0)).prod ((ν 0 : Measure A).prod Q)) |
| calc |
| _ = (poissonLaw I).map (fun V => V.map G) := by |
| apply Measure.map_congr |
| filter_upwards [sigmaPart_eq_ae I] with V hV |
| change (sigmaPart I V).map G = V.map G |
| rw [hV] |
| _ = poissonLaw (I.map G) := poissonLaw_map I hG |
| _ = _ := poissonLaw_congr hI |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma measurable_probability_pi {Ω I X : Type*} [MeasurableSpace Ω] [Fintype I] |
| [MeasurableSpace X] {ν : Ω → Measure X} (hν : Measurable ν) |
| [∀ ω, IsProbabilityMeasure (ν ω)] : Measurable (fun ω => Measure.pi (fun _ : I => ν ω)) := by |
| apply Measure.measurable_of_measurable_coe |
| intro s hs |
| refine MeasurableSpace.induction_on_inter |
| (C := fun s _ => Measurable (fun ω => (Measure.pi (fun _ : I => ν ω)) s)) |
| _root_.generateFrom_pi.symm isPiSystem_pi ?_ ?_ ?_ ?_ s hs |
| · simp only [measure_empty]; exact measurable_const |
| · rintro s ⟨t,ht,rfl⟩ |
| simp only [Measure.pi_pi] |
| exact Finset.measurable_prod _ (fun i _ => (Measure.measurable_coe (ht i (mem_univ _))).comp hν) |
| · intro s hs ih |
| have he (ω : Ω) : (Measure.pi (fun _ : I => ν ω)) sᶜ = 1-(Measure.pi (fun _ : I => ν ω)) s := by |
| rw [measure_compl hs (measure_ne_top _ _),measure_univ] |
| simp_rw [he]; exact measurable_const.sub ih |
| · intro s hd hs ih |
| have he (ω : Ω) : (Measure.pi (fun _ : I => ν ω)) (⋃ n,s n) = |
| ∑' n, (Measure.pi (fun _ : I => ν ω)) (s n) := measure_iUnion hd hs |
| simp_rw [he]; exact Measurable.tsum ih |
|
|
| lemma measurable_probability_infinitePi {Ω I X : Type*} [MeasurableSpace Ω] |
| [MeasurableSpace X] {ν : Ω → Measure X} (hν : Measurable ν) |
| [∀ ω, IsProbabilityMeasure (ν ω)] : Measurable (fun ω => Measure.infinitePi (fun _ : I => ν ω)) := by |
| apply Measure.measurable_of_measurable_coe |
| intro s hs |
| refine MeasurableSpace.induction_on_inter |
| (C := fun s _ => Measurable (fun ω => (Measure.infinitePi (fun _ : I => ν ω)) s)) |
| (s := measurableCylinders (fun _ : I => X)) |
| generateFrom_measurableCylinders.symm isPiSystem_measurableCylinders ?_ ?_ ?_ ?_ s hs |
| · simp only [measure_empty]; exact measurable_const |
| · intro s hs |
| obtain ⟨J,S,hS,rfl⟩ := (mem_measurableCylinders s).mp hs |
| have he (ω : Ω) : (Measure.infinitePi (fun _ : I => ν ω)) (cylinder J S) = |
| (Measure.pi (fun _ : J => ν ω)) S := Measure.infinitePi_cylinder _ hS |
| simp_rw [he] |
| exact (Measure.measurable_coe hS).comp (measurable_probability_pi hν) |
| · intro s hs ih |
| have he (ω : Ω) : (Measure.infinitePi (fun _ : I => ν ω)) sᶜ = |
| 1-(Measure.infinitePi (fun _ : I => ν ω)) s := by rw [measure_compl hs (measure_ne_top _ _),measure_univ] |
| simp_rw [he]; exact measurable_const.sub ih |
| · intro s hd hs ih |
| have he (ω : Ω) : (Measure.infinitePi (fun _ : I => ν ω)) (⋃ n,s n) = |
| ∑' n, (Measure.infinitePi (fun _ : I => ν ω)) (s n) := measure_iUnion hd hs |
| simp_rw [he]; exact Measurable.tsum ih |
|
|
| def probabilityReplicaKernel {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X] |
| (ν : Ω → Measure X) (hν : Measurable ν) [∀ ω, IsProbabilityMeasure (ν ω)] : Kernel Ω (ℕ → X) := |
| ⟨fun ω => Measure.infinitePi (fun _ : ℕ => ν ω),measurable_probability_infinitePi hν⟩ |
|
|
| instance probabilityReplicaKernel_markov {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X] |
| (ν : Ω → Measure X) (hν : Measurable ν) [∀ ω, IsProbabilityMeasure (ν ω)] : |
| IsMarkovKernel (probabilityReplicaKernel ν hν) := by |
| constructor |
| intro ω |
| change IsProbabilityMeasure (Measure.infinitePi (fun _ : ℕ => ν ω)) |
| infer_instance |
|
|
| def markedReplicaLaw {A : Type} [MeasurableSpace A] [Nonempty A] |
| (n : ℕ) (b : ℕ → ℝ) (μ : ℕ → ProbabilityMeasure A) : Measure (ℕ → NoiseLeaf A n) := |
| probabilityReplicaKernel (noiseLeafKernel A n) (noiseLeafKernel A n).measurable ∘ₘ |
| (noiseCascadeLaw A n b μ : Measure (NoiseTree A n)) |
|
|
| instance markedReplicaLaw_probability {A : Type} [MeasurableSpace A] [Nonempty A] |
| (n : ℕ) (b : ℕ → ℝ) (μ : ℕ → ProbabilityMeasure A) : IsProbabilityMeasure (markedReplicaLaw n b μ) := |
| inferInstanceAs (IsProbabilityMeasure (_ ∘ₘ _)) |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| variable {A : Type} [MeasurableSpace A] |
|
|
| def noiseLeafMark : (n : ℕ) → NoiseLeaf A n → Fin n → A |
| | 0, _, i => i.elim0 |
| | n+1, v, i => Fin.cases v.2.1 (noiseLeafMark n v.2.2) i |
|
|
| lemma measurable_noiseLeafMark (n : ℕ) (i : Fin n) : Measurable (fun v : NoiseLeaf A n => noiseLeafMark n v i) := by |
| induction n with |
| | zero => exact i.elim0 |
| | succ n ih => |
| refine Fin.cases ?_ (fun j => ?_) i |
| · exact measurable_fst.comp measurable_snd |
| · exact (ih j).comp (measurable_snd.comp measurable_snd) |
|
|
| omit [MeasurableSpace A] in |
| lemma noiseLeafMark_keep {S : Type} (n : ℕ) (c : ℕ → S × A → ℝ) (u : ℕ → S × A → S) |
| (s : S) (v : NoiseLeaf A n) (i : Fin n) : |
| noiseLeafMark n (noiseLeafKeep n c u s v) i = noiseLeafMark n v i := by |
| induction n generalizing c u s with |
| | zero => exact i.elim0 |
| | succ n ih => |
| refine Fin.cases rfl (fun j => ?_) i |
| exact ih _ _ _ _ j |
|
|
| lemma noiseLeafMark_labeled (n : ℕ) (ω : LabeledTree n) (g : ForestVertex n → A) |
| (v : LabeledLeaf n) (i : Fin n) : |
| noiseLeafMark n (labeledNoiseLeaf A n (ω,markForestOfCoords A n g) v) i = g (edgeAt n v i) := by |
| induction n with |
| | zero => exact i.elim0 |
| | succ n ih => |
| refine Fin.cases ?_ (fun j => ?_) i |
| · simp [noiseLeafMark,labeledNoiseLeaf,markForestOfCoords,edgeAt,nodeAt_zero] |
| · simpa only [noiseLeafMark,Fin.cases_succ,labeledNoiseLeaf,markForestOfCoords,edgeAt,nodeAt_succ] using |
| ih (ω.2 v.1.1 v.1.2) (fun w => g (v.1.1,v.1.2,some w)) v.2 j |
|
|
| lemma edgeAt_eq_iff_prefix (n : ℕ) (v w : LabeledLeaf n) (d : Fin n) : |
| edgeAt n v d = edgeAt n w d ↔ (labeledAddress n v).take (d+1) = (labeledAddress n w).take (d+1) := by |
| rw [← Option.some_inj,← (nodeAddress_injective n).eq_iff,← nodeAt_succ,← nodeAt_succ, |
| nodeAddress_nodeAt,nodeAddress_nodeAt] |
| rfl |
|
|
| lemma noiseLeafMark_eq_iff_prefix (n : ℕ) (ω : LabeledTree n) (g : ForestVertex n → A) |
| (hg : Function.Injective g) (v w : LabeledLeaf n) (d : Fin n) : |
| noiseLeafMark n (labeledNoiseLeaf A n (ω,markForestOfCoords A n g) v) d = |
| noiseLeafMark n (labeledNoiseLeaf A n (ω,markForestOfCoords A n g) w) d ↔ |
| (labeledAddress n v).take (d+1) = (labeledAddress n w).take (d+1) := by |
| rw [noiseLeafMark_labeled,noiseLeafMark_labeled,hg.eq_iff,edgeAt_eq_iff_prefix] |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma sampling_replica_morphism {Ω Ω' X Y : Type*} [MeasurableSpace Ω] [MeasurableSpace Ω'] |
| [MeasurableSpace X] [MeasurableSpace Y] (P : Measure Ω) [IsProbabilityMeasure P] (Q : Measure Ω') |
| {ν : Ω → Measure X} {κ : Ω' → Measure Y} (hν : Measurable ν) (hκ : Measurable κ) |
| [∀ ω, IsProbabilityMeasure (ν ω)] [∀ ω, IsProbabilityMeasure (κ ω)] |
| {T : Ω → Ω'} (hT : Measurable T) (hPQ : P.map T = Q) |
| {ψ : Ω → X → Y} (hψ : Measurable (fun p : Ω × X => ψ p.1 p.2)) |
| (h : ∀ᵐ ω ∂P, (ν ω).map (ψ ω) = κ (T ω)) : |
| (P ⊗ₘ probabilityReplicaKernel ν hν).map (fun p i => ψ p.1 (p.2 i)) = |
| probabilityReplicaKernel κ hκ ∘ₘ Q := by |
| have hΨ : Measurable (fun p : Ω × (ℕ → X) => fun i => ψ p.1 (p.2 i)) := by |
| apply Measurable.of_eval |
| intro i |
| exact hψ.comp (measurable_fst.prodMk ((measurable_pi_apply i).comp measurable_snd)) |
| apply Measure.ext_of_lintegral |
| intro F hF |
| rw [lintegral_map hF hΨ,Measure.lintegral_compProd |
| (show Measurable (fun p : Ω × (ℕ → X) => F (fun i => ψ p.1 (p.2 i))) from hF.comp hΨ)] |
| have he : (∫⁻ ω, ∫⁻ σ, F (fun i => ψ ω (σ i)) ∂(probabilityReplicaKernel ν hν) ω ∂P) = |
| ∫⁻ ω, ∫⁻ σ, F σ ∂(probabilityReplicaKernel κ hκ) (T ω) ∂P := by |
| apply lintegral_congr_ae |
| filter_upwards [h] with ω hω |
| change (∫⁻ σ, F (fun i => ψ ω (σ i)) ∂Measure.infinitePi (fun _ : ℕ => ν ω)) = |
| ∫⁻ σ, F σ ∂Measure.infinitePi (fun _ : ℕ => κ (T ω)) |
| have hψω : Measurable (ψ ω) := hψ.comp (measurable_const.prodMk measurable_id) |
| rw [← lintegral_map hF (by fun_prop : Measurable (fun σ : ℕ → X => fun i => ψ ω (σ i))), |
| Measure.infinitePi_map_pi _ (fun _ => hψω)] |
| simp only [hω] |
| rw [he] |
| have hI : Measurable (fun ω => ∫⁻ σ, F σ ∂(probabilityReplicaKernel κ hκ) ω) := hF.lintegral_kernel |
| rw [← lintegral_map hI hT,hPQ] |
| change _ = ∫⁻ σ, F σ ∂Q.bind (probabilityReplicaKernel κ hκ) |
| exact (Measure.lintegral_bind (Kernel.aemeasurable _) hF.aemeasurable).symm |
|
|
| |
|
|
| theorem labeled_marked_replica_law {A : Type} [MeasurableSpace A] [Nonempty A] |
| (n : ℕ) (b : ℕ → ℝ) (hb : CascadeExponents n b) (μ : ℕ → ProbabilityMeasure A) : |
| let P := (labeledCascadeLaw n b : Measure (LabeledTree n)).prod |
| (Measure.infinitePi (fun v : ForestVertex n => (μ (forestVertexDepth n v) : Measure A))) |
| (P ⊗ₘ probabilityReplicaKernel (fun p => labeledLeafLaw n p.1) |
| ((measurable_labeledLeafLaw n).comp measurable_fst)).map |
| (fun p i => labeledNoiseLeaf A n (p.1.1,markForestOfCoords A n p.1.2) (p.2 i)) = |
| markedReplicaLaw n b μ := by |
| intro P |
| let T := fun p : LabeledTree n × (ForestVertex n → A) => |
| labeledNoiseJoin A n (p.1,markForestOfCoords A n p.2) |
| have hT : Measurable T := by fun_prop |
| have hPQ : P.map T = (noiseCascadeLaw A n b μ : Measure (NoiseTree A n)) := |
| labeledNoiseCoordinates_law A n b μ |
| have hp : MeasurePreserving T P (noiseCascadeLaw A n b μ : Measure (NoiseTree A n)) := ⟨hT,hPQ⟩ |
| apply sampling_replica_morphism P _ (ν := fun p : LabeledTree n × (ForestVertex n → A) => labeledLeafLaw n p.1) |
| (κ := noiseLeafKernel A n) ((measurable_labeledLeafLaw n).comp measurable_fst) |
| (noiseLeafKernel A n).measurable hT hPQ |
| (ψ := fun p v => labeledNoiseLeaf A n (p.1,markForestOfCoords A n p.2) v) |
| · apply measurable_from_prod_countable_left |
| intro v |
| exact (measurable_labeledNoiseLeaf A n v).comp (by fun_prop) |
| · filter_upwards [hp.quasiMeasurePreserving.tendsto_ae.eventually (noiseCascade_good A n b hb μ)] with p hp |
| apply labeledLeafLaw_noiseMap A n p.1 (markForestOfCoords A n p.2) hp |
| cases n with |
| | zero => simp [noiseTreeTotal,rawTreeTotal] |
| | succ n => exact hp.1 |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma normalizeMass_exp {X : Type*} [MeasurableSpace X] [Nonempty X] |
| (ν : Measure X) [IsProbabilityMeasure ν] (H : X → ℝ) (hH : Measurable H) |
| (he : Integrable (fun x => Real.exp (H x)) ν) : |
| normalizeMass (ν.withDensity (fun x => ENNReal.ofReal (Real.exp (H x)))) = ν.tilted H := by |
| have hZ : (ν.withDensity (fun x => ENNReal.ofReal (Real.exp (H x)))) univ = |
| ENNReal.ofReal (∫ x, Real.exp (H x) ∂ν) := by |
| rw [withDensity_apply _ MeasurableSet.univ,setLIntegral_univ, |
| ← ofReal_integral_eq_lintegral_ofReal he (ae_of_all _ (fun x => (Real.exp_pos _).le))] |
| have hpos := _root_.MeasureTheory.integral_exp_pos he |
| rw [normalizeMass,ite_eq_left (by rw [hZ]; exact ⟨ENNReal.ofReal_pos.mpr hpos,ENNReal.ofReal_lt_top⟩), |
| hZ,Measure.tilted,← withDensity_smul _ hH.exp.ennreal_ofReal] |
| congr 1; funext x |
| simp only [Pi.smul_apply,smul_eq_mul,div_eq_mul_inv,ENNReal.ofReal_mul (Real.exp_pos _).le, |
| ENNReal.ofReal_inv_of_pos hpos,mul_comm] |
|
|
| lemma normalizeMass_weight_map {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y] |
| [Nonempty X] [Nonempty Y] (ν : Measure X) {ψ : X → Y} (hψ : Measurable ψ) |
| {w : Y → ℝ≥0∞} (hw : Measurable w) |
| (hm : 0 < ((ν.map ψ).withDensity w) univ ∧ ((ν.map ψ).withDensity w) univ < ∞) : |
| (normalizeMass (ν.withDensity (fun x => w (ψ x)))).map ψ = |
| normalizeMass ((ν.map ψ).withDensity w) := by |
| have he := withDensity_map_pullback ν hψ hw |
| have hmass : (ν.withDensity (fun x => w (ψ x))) univ = ((ν.map ψ).withDensity w) univ := by |
| rw [← he,Measure.map_apply hψ MeasurableSet.univ]; rfl |
| rw [normalizeMass_map _ hψ (by simpa only [hmass] using hm),he] |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma kernel_comap_comp_measure {Ω Ω' X : Type*} [MeasurableSpace Ω] [MeasurableSpace Ω'] |
| [MeasurableSpace X] (P : Measure Ω) (K : Kernel Ω' X) {T : Ω → Ω'} (hT : Measurable T) : |
| K.comap T hT ∘ₘ P = K ∘ₘ P.map T := by |
| ext s hs |
| rw [Measure.bind_apply hs (Kernel.aemeasurable _),Measure.bind_apply hs K.aemeasurable, |
| lintegral_map (K.measurable_coe hs) hT] |
| rfl |
|
|
| lemma replica_mark_transport {Ω Ω' X Y : Type*} [MeasurableSpace Ω] [MeasurableSpace Ω'] |
| [MeasurableSpace X] [MeasurableSpace Y] (P : Measure Ω) (Q : Measure Ω') |
| {ν : Ω → Measure X} {κ : Ω' → Measure X} (hν : Measurable ν) (hκ : Measurable κ) |
| [∀ ω, IsProbabilityMeasure (ν ω)] [∀ ω, IsProbabilityMeasure (κ ω)] |
| {T : Ω → Ω'} (hT : Measurable T) (hPQ : P.map T = Q) |
| {ψ : X → Y} (hψ : Measurable ψ) |
| (h : ∀ᵐ ω ∂P, (ν ω).map ψ = (κ (T ω)).map ψ) : |
| ((probabilityReplicaKernel ν hν) ∘ₘ P).map (fun σ i => ψ (σ i)) = |
| ((probabilityReplicaKernel κ hκ) ∘ₘ Q).map (fun σ i => ψ (σ i)) := by |
| let K := (probabilityReplicaKernel κ hκ).map (fun σ i => ψ (σ i)) |
| have hΨ : Measurable (fun σ : ℕ → X => fun i => ψ (σ i)) := by fun_prop |
| rw [Measure.map_comp _ _ hΨ,Measure.map_comp _ _ hΨ] |
| calc |
| _ = K.comap T hT ∘ₘ P := by |
| apply Measure.comp_congr |
| filter_upwards [h] with ω hω |
| simp only [Kernel.map_apply _ hΨ,Kernel.comap_apply,probabilityReplicaKernel,K] |
| change (Measure.infinitePi (fun _ : ℕ => ν ω)).map (fun σ i => ψ (σ i)) = |
| (Measure.infinitePi (fun _ : ℕ => κ (T ω))).map (fun σ i => ψ (σ i)) |
| rw [Measure.infinitePi_map_pi _ (fun _ => hψ),Measure.infinitePi_map_pi _ (fun _ => hψ)] |
| simp only [hω] |
| _ = K ∘ₘ Q := by rw [kernel_comap_comp_measure,hPQ] |
|
|
| lemma measurable_noiseTiltedLeafLaw {A S : Type} [MeasurableSpace A] [MeasurableSpace S] |
| [Nonempty A] (n : ℕ) {c : ℕ → S × A → ℝ} {u : ℕ → S × A → S} |
| (hc : ∀ i, Measurable (c i)) (hu : ∀ i, Measurable (u i)) (s : S) : |
| Measurable (noiseTiltedLeafLaw n c u s) := |
| measurable_normalizeMass.comp ((measurable_withDensity_fixed |
| ((measurable_noiseLeafProduct n hc hu).comp (measurable_const.prodMk measurable_id))).comp |
| (noiseLeafKernel A n).measurable) |
|
|
| |
|
|
| theorem noise_mark_replica_transport {A : Type} [MeasurableSpace A] [Nonempty A] |
| (n : ℕ) (b : ℕ → ℝ) (hb : CascadeExponents n b) (μ ν : ℕ → ProbabilityMeasure A) |
| (c : ℕ → A → ℝ) (hc : ∀ i, Measurable (c i)) (hcpos : ∀ i a, 0 < c i a) |
| (hν : ∀ i, (ν i : Measure A) = (μ i : Measure A).withDensity (fun a => ENNReal.ofReal (c i a ^ b i))) : |
| ((probabilityReplicaKernel |
| (noiseTiltedLeafLaw n (fun i (p : PUnit × A) => c i p.2) (fun _ _ => PUnit.unit) PUnit.unit) |
| (measurable_noiseTiltedLeafLaw n (fun i => (hc i).comp measurable_snd) (fun _ => measurable_const) PUnit.unit)) ∘ₘ |
| (noiseCascadeLaw A n b μ : Measure (NoiseTree A n))).map |
| (fun σ i => noiseLeafMark n (σ i)) = |
| (markedReplicaLaw n b ν).map (fun σ i => noiseLeafMark n (σ i)) := by |
| let c' := fun i (p : PUnit × A) => c i p.2 |
| let u := fun (_ : ℕ) (_ : PUnit × A) => PUnit.unit |
| let T := noiseTreeKeep n b μ c' u PUnit.unit |
| let ψ := noiseLeafMark (A := A) n |
| have hc' : ∀ i, Measurable (c' i) := fun i => (hc i).comp measurable_snd |
| have hu : ∀ i, Measurable (u i) := fun _ => measurable_const |
| have hT : Measurable T := (measurable_noiseTreeKeep n b μ hc' hu).comp (measurable_const.prodMk measurable_id) |
| have hψ : Measurable ψ := Measurable.of_eval (measurable_noiseLeafMark n) |
| have hm (i : ℕ) (s : PUnit) : ∫⁻ a, ENNReal.ofReal (c' i (s,a)^b i) ∂(μ i : Measure A) = 1 := by |
| have he := congrArg (fun P : Measure A => P univ) (hν i) |
| simpa only [withDensity_apply _ MeasurableSet.univ,setLIntegral_univ,measure_univ] using he.symm |
| apply replica_mark_transport _ _ (measurable_noiseTiltedLeafLaw n hc' hu PUnit.unit) |
| (noiseLeafKernel A n).measurable hT (noiseTreeKeep_independent_law n b μ ν c hc hcpos hν) hψ |
| filter_upwards [noiseGibbsRegular_ae n b hb μ hc' hu (fun i _ a => hcpos i a) hm PUnit.unit] with ω hω |
| have he := noiseTiltedLeafLaw_keep n b μ hc' hu (fun i _ a => hcpos i a) PUnit.unit ω hω |
| have hk : Measurable (noiseLeafKeep n c' u PUnit.unit) := |
| (measurable_noiseLeafKeep n hc' hu).comp (measurable_const.prodMk measurable_id) |
| rw [← he,Measure.map_map hψ hk] |
| congr 1 |
| funext v i |
| exact (noiseLeafMark_keep n c' u PUnit.unit v i).symm |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma measurable_random_withDensity {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X] |
| {ν : Ω → Measure X} (hν : Measurable ν) [∀ ω, IsProbabilityMeasure (ν ω)] |
| {W : Ω × X → ℝ≥0∞} (hW : Measurable W) : |
| Measurable (fun ω => (ν ω).withDensity (fun x => W (ω,x))) := by |
| let K : Kernel Ω X := ⟨ν,hν⟩ |
| have : IsMarkovKernel K := ⟨fun _ => inferInstance⟩ |
| apply Measure.measurable_of_measurable_coe |
| intro s hs |
| simp only [withDensity_apply _ hs,← lintegral_indicator hs] |
| exact (hW.indicator (hs.preimage measurable_snd)).lintegral_kernel_prod_right' (κ := K) |
|
|
| lemma regular_product_mass {A S : Type} [MeasurableSpace A] [MeasurableSpace S] [Nonempty A] |
| {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} {ν : NoiseTree A n} |
| (hν : NoiseGibbsRegular n b μ c u s ν) : |
| 0 < ((noiseLeafKernel A n ν).withDensity (noiseLeafProduct n c u s)) univ ∧ |
| ((noiseLeafKernel A n ν).withDensity (noiseLeafProduct n c u s)) univ < ∞ := by |
| let m := (noiseLeafKernel A n ν).withDensity (noiseLeafProduct n c u s) |
| 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) |
| have he : (noiseTreeTotal A n ν • m).map (noiseLeafKeep n c u s) = |
| noiseTreeTotal A n (noiseTreeKeep n b μ c u s ν) • |
| noiseLeafKernel A n (noiseTreeKeep n b μ c u s ν) := by |
| have hh := noiseWeightedLeafMeasure_eq n b μ hc hu hcpos s ν hν |
| unfold noiseWeightedLeafMeasure at hh |
| change Measure.map (noiseLeafKeep n c u s) |
| ((noiseLeafKernel A n ν).withDensity (noiseTreeTotal A n ν • noiseLeafProduct n c u s)) = _ at hh |
| rwa [withDensity_smul _ hp] at hh |
| have hm : noiseTreeTotal A n ν * m univ = noiseTreeTotal A n (noiseTreeKeep n b μ c u s ν) := by |
| have hh := congrArg (fun η : Measure (NoiseLeaf A n) => η univ) he |
| simpa only [Measure.map_apply hk MeasurableSet.univ, preimage_univ, |
| Measure.smul_apply, smul_eq_mul, measure_univ, mul_one] using hh |
| have hm0 : 0 < m univ := by |
| by_contra hh |
| have hz : m univ = 0 := le_antisymm (le_of_not_gt hh) bot_le |
| rw [hz,mul_zero] at hm |
| exact hν.masses.2.1.ne' hm.symm |
| refine ⟨hm0,?_⟩ |
| have hlt : noiseTreeTotal A n ν * m univ < ∞ := hm ▸ hν.masses.2.2 |
| rcases ENNReal.mul_lt_top_iff.mp hlt with h | h | h |
| · exact h.2 |
| · exact (hν.masses.1.1.ne' h).elim |
| · exact (hm0.ne' h).elim |
|
|
| def labeledWeight {A S : Type} [MeasurableSpace A] (n : ℕ) |
| (c : ℕ → S × A → ℝ) (u : ℕ → S × A → S) (s : S) |
| (p : (LabeledTree n × (ForestVertex n → A)) × LabeledLeaf n) : ℝ≥0∞ := |
| noiseLeafProduct n c u s (labeledNoiseLeaf A n (p.1.1,markForestOfCoords A n p.1.2) p.2) |
|
|
| def labeledWeightedMass {A S : Type} [MeasurableSpace A] (n : ℕ) |
| (c : ℕ → S × A → ℝ) (u : ℕ → S × A → S) (s : S) |
| (p : LabeledTree n × (ForestVertex n → A)) : Measure (LabeledLeaf n) := |
| (labeledLeafLaw n p.1).withDensity (fun v => labeledWeight n c u s (p,v)) |
|
|
| def labeledWeightedLeafLaw {A S : Type} [MeasurableSpace A] (n : ℕ) |
| (c : ℕ → S × A → ℝ) (u : ℕ → S × A → S) (s : S) |
| (p : LabeledTree n × (ForestVertex n → A)) : Measure (LabeledLeaf n) := |
| normalizeMass (labeledWeightedMass n c u s p) |
|
|
| instance labeledWeightedLeafLaw_probability {A S : Type} [MeasurableSpace A] (n : ℕ) |
| (c : ℕ → S × A → ℝ) (u : ℕ → S × A → S) (s : S) |
| (p : LabeledTree n × (ForestVertex n → A)) : IsProbabilityMeasure (labeledWeightedLeafLaw n c u s p) := |
| normalizeMass_probability _ |
|
|
| lemma measurable_labeledWeight {A S : Type} [MeasurableSpace A] [MeasurableSpace S] |
| (n : ℕ) {c : ℕ → S × A → ℝ} {u : ℕ → S × A → S} |
| (hc : ∀ i, Measurable (c i)) (hu : ∀ i, Measurable (u i)) (s : S) : |
| Measurable (labeledWeight (A := A) n c u s) := by |
| apply measurable_from_prod_countable_left |
| intro v |
| exact (measurable_noiseLeafProduct n hc hu).comp (measurable_const.prodMk |
| ((measurable_labeledNoiseLeaf A n v).comp (by fun_prop))) |
|
|
| lemma measurable_labeledWeightedMass {A S : Type} [MeasurableSpace A] [MeasurableSpace S] |
| (n : ℕ) {c : ℕ → S × A → ℝ} {u : ℕ → S × A → S} |
| (hc : ∀ i, Measurable (c i)) (hu : ∀ i, Measurable (u i)) (s : S) : |
| Measurable (labeledWeightedMass (A := A) n c u s) := by |
| have hν : Measurable (fun p : LabeledTree n × (ForestVertex n → A) => labeledLeafLaw n p.1) := |
| (measurable_labeledLeafLaw n).comp measurable_fst |
| exact measurable_random_withDensity hν (measurable_labeledWeight n hc hu s) |
|
|
| lemma measurable_labeledWeightedLeafLaw {A S : Type} [MeasurableSpace A] [MeasurableSpace S] |
| (n : ℕ) {c : ℕ → S × A → ℝ} {u : ℕ → S × A → S} |
| (hc : ∀ i, Measurable (c i)) (hu : ∀ i, Measurable (u i)) (s : S) : |
| Measurable (labeledWeightedLeafLaw (A := A) n c u s) := |
| measurable_normalizeMass.comp (measurable_labeledWeightedMass n hc hu s) |
|
|
| |
|
|
| theorem labeled_weighted_marked_replica_law {A S : Type} [MeasurableSpace A] |
| [MeasurableSpace S] [Nonempty A] (n : ℕ) (b : ℕ → ℝ) (hb : CascadeExponents 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)) |
| (hm : ∀ i s, ∫⁻ a, ENNReal.ofReal (c i (s,a)^b i) ∂(μ i : Measure A) = 1) (s : S) : |
| let P := (labeledCascadeLaw n b : Measure (LabeledTree n)).prod |
| (Measure.infinitePi (fun v : ForestVertex n => (μ (forestVertexDepth n v) : Measure A))) |
| (P ⊗ₘ probabilityReplicaKernel (labeledWeightedLeafLaw n c u s) |
| (measurable_labeledWeightedLeafLaw n hc hu s)).map |
| (fun p i => labeledNoiseLeaf A n (p.1.1,markForestOfCoords A n p.1.2) (p.2 i)) = |
| probabilityReplicaKernel (noiseTiltedLeafLaw n c u s) |
| (measurable_noiseTiltedLeafLaw n hc hu s) ∘ₘ (noiseCascadeLaw A n b μ : Measure (NoiseTree A n)) := by |
| intro P |
| let T := fun p : LabeledTree n × (ForestVertex n → A) => |
| labeledNoiseJoin A n (p.1,markForestOfCoords A n p.2) |
| have hT : Measurable T := by fun_prop |
| have hPQ : P.map T = (noiseCascadeLaw A n b μ : Measure (NoiseTree A n)) := |
| labeledNoiseCoordinates_law A n b μ |
| have hp : MeasurePreserving T P (noiseCascadeLaw A n b μ : Measure (NoiseTree A n)) := ⟨hT,hPQ⟩ |
| apply sampling_replica_morphism P _ (measurable_labeledWeightedLeafLaw n hc hu s) |
| (measurable_noiseTiltedLeafLaw n hc hu s) hT hPQ |
| (ψ := fun p v => labeledNoiseLeaf A n (p.1,markForestOfCoords A n p.2) v) |
| · apply measurable_from_prod_countable_left |
| intro v |
| exact (measurable_labeledNoiseLeaf A n v).comp (by fun_prop) |
| · filter_upwards [hp.quasiMeasurePreserving.tendsto_ae.eventually (noiseCascade_good A n b hb μ), |
| hp.quasiMeasurePreserving.tendsto_ae.eventually (noiseGibbsRegular_ae n b hb μ hc hu hcpos hm s)] with p hg hr |
| have hleaf := labeledLeafLaw_noiseMap A n p.1 (markForestOfCoords A n p.2) hg hr.masses.1 |
| have hw : Measurable (noiseLeafProduct n c u s) := |
| (measurable_noiseLeafProduct n hc hu).comp (measurable_const.prodMk measurable_id) |
| have he := normalizeMass_weight_map (labeledLeafLaw n p.1) |
| (measurable_of_countable (labeledNoiseLeaf A n (p.1,markForestOfCoords A n p.2))) hw |
| (by rw [hleaf]; exact regular_product_mass hc hu hcpos hr) |
| simpa only [hleaf,labeledWeightedLeafLaw,labeledWeightedMass,labeledWeight,noiseTiltedLeafLaw] using he |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma gaussianReal_shift_density (m : ℝ) : |
| (gaussianReal 0 1).withDensity (fun x => ENNReal.ofReal (Real.exp (m*x-m^2/2))) = |
| gaussianReal m 1 := by |
| rw [gaussianReal_of_var_ne_zero _ one_ne_zero,gaussianReal_of_var_ne_zero _ one_ne_zero, |
| ← withDensity_mul volume (measurable_gaussianPDF _ _) (by fun_prop)] |
| congr 1 |
| funext x |
| dsimp only [Pi.mul_apply,gaussianPDF] |
| rw [← ENNReal.ofReal_mul (gaussianPDFReal_nonneg _ _ _)] |
| congr 1 |
| simp only [gaussianPDFReal,NNReal.coe_one,mul_one,sub_zero,mul_assoc,← Real.exp_add] |
| congr 2 |
| ring |
|
|
| def retainedGaussianScale (b a x : ℝ) : ℝ := Real.exp (a*x-b*a^2/2) |
|
|
| lemma retainedGaussianScale_density (b a : ℝ) : |
| (gaussianReal 0 1).withDensity (fun x => ENNReal.ofReal (retainedGaussianScale b a x ^ b)) = |
| gaussianReal (b*a) 1 := by |
| convert gaussianReal_shift_density (b*a) using 1 |
| congr 1; funext x |
| rw [retainedGaussianScale,← Real.exp_mul] |
| congr 2 |
| ring |
|
|
| lemma retainedGaussianScale_normalized (b a : ℝ) : |
| (∫⁻ x, ENNReal.ofReal (retainedGaussianScale b a x ^ b) ∂gaussianReal 0 1) = 1 := by |
| have h := congrArg (fun μ : Measure ℝ => μ univ) (retainedGaussianScale_density b a) |
| simpa only [withDensity_apply _ MeasurableSet.univ,setLIntegral_univ,measure_univ] using h |
|
|
| |
|
|
| theorem noiseTreeKeep_gaussian_law (n : ℕ) (b a : ℕ → ℝ) : |
| (noiseCascadeLaw ℝ n b (fun _ => ⟨gaussianReal 0 1,inferInstance⟩) : Measure (NoiseTree ℝ n)).map |
| (noiseTreeKeep n b (fun _ => ⟨gaussianReal 0 1,inferInstance⟩) |
| (fun i (p : PUnit × ℝ) => retainedGaussianScale (b i) (a i) p.2) |
| (fun _ _ => PUnit.unit) PUnit.unit) = |
| noiseCascadeLaw ℝ n b (fun i => ⟨gaussianReal (b i*a i) 1,inferInstance⟩) := by |
| apply noiseTreeKeep_independent_law |
| · intro i; unfold retainedGaussianScale; fun_prop |
| · intro i x; exact Real.exp_pos _ |
| · intro i; exact (retainedGaussianScale_density _ _).symm |
|
|
| end IsingPerceptron |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped BigOperators Topology ENNReal NNReal |
| namespace IsingPerceptron |
|
|
| lemma independent_atomless_injective {I : Type*} [Countable I] |
| (μ : I → Measure ℝ) [∀ i, IsProbabilityMeasure (μ i)] [∀ i, NullSingletonClass (μ i)] : |
| ∀ᵐ g ∂Measure.infinitePi μ, Function.Injective g := by |
| change ∀ᵐ g ∂Measure.infinitePi μ, ∀ i j, g i=g j → i=j |
| rw [ae_all_iff] |
| intro i |
| rw [ae_all_iff] |
| intro j |
| by_cases hij : i=j |
| · subst j; exact ae_of_all _ (fun _ _ => rfl) |
| have hp : MeasurePreserving (fun g : I → ℝ => (g i,g j)) (Measure.infinitePi μ) ((μ i).prod (μ j)) := |
| ⟨by fun_prop,Measure.infinitePi_map_eval_prod hij⟩ |
| have ha : ∀ᵐ p : ℝ × ℝ ∂(μ i).prod (μ j), p.1 ≠ p.2 := by |
| apply (Measure.ae_prod_iff_ae_ae (measurableSet_eq_fun measurable_fst measurable_snd).compl).mpr |
| exact ae_of_all _ (fun x => by simp only [ae_iff]; simp) |
| filter_upwards [hp.quasiMeasurePreserving.tendsto_ae.eventually ha] with g hg |
| exact fun h => (hg h).elim |
|
|
| lemma gaussian_marks_injective (n : ℕ) (m : ℕ → ℝ) : |
| ∀ᵐ g ∂Measure.infinitePi (fun v : ForestVertex n => gaussianReal (m (forestVertexDepth n v)) 1), |
| Function.Injective g := by |
| let (v : ForestVertex n) : NullSingletonClass (gaussianReal (m (forestVertexDepth n v)) 1) := |
| nullSingletonClass_gaussianReal one_ne_zero |
| exact independent_atomless_injective _ |
|
|
| end IsingPerceptron |
|
|
| end |
|
|
| end OAI |
|
|
