| import Mathlib |
| import OAI.Probability.LogConcave.Numerics.ChainTaylor |
| import OAI.Probability.LogConcave.Dynamics.Squared |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace LogConcaveSampling.Coupling |
| open MeasureTheory ProbabilityTheory Function SeedCompiler |
| open scoped Classical BigOperators |
|
|
| variable {Ω : Type*} [MeasurableSpace Ω] {d k : ℕ} |
|
|
| theorem SquaredAt.absorb_fixed (μ : Measure Ω) [IsProbabilityMeasure μ] |
| (f : Ω → Point d) (hf : Measurable f) (c b : Point d) {r D K S B τ : ℝ} |
| (hD : 0<D) (hK : 0≤K) (v : Fin k → ℝ) (hv : (∑i,v i^2)≤D^2) |
| (M : Point d → (Fin k → Point d) → Point d) (hm : Measurable (uncurry M)) |
| (hshift : ShiftInvariant r v M) |
| (hLip : ∀x y g,‖M x g-M y g‖≤K*‖x-y‖) |
| (hC : SquaredAt μ (stdGaussian (Point d)) f (fun g => c+(r/(2*D)) • g) S) |
| (hM : SquaredAt (Measure.pi fun _ : Fin k => stdGaussian (Point d)) (stdGaussian (Point d)) |
| (M c) (fun g => b+τ • g) B) : |
| SquaredAt (μ.prod (Measure.pi fun _ : Fin k => stdGaussian (Point d))) (stdGaussian (Point d)) |
| (fun z => M (f z.1) (slotTransform (sqrtCoefficient (fun i => v i/(2*D))) |
| (fun i => v i/(2*D)) z.2)) (fun g => b+τ • g) (2*K^2*S+2*B) := by |
| let γ := stdGaussian (Point d) |
| let θ := Measure.pi fun _ : Fin k => γ |
| obtain ⟨κ,hκ,hcl,hcr,hci,hce⟩ := hC |
| let := hκ |
| have hMR := hM.reindex (fun g => ((),g)) id (by fun_prop) measurable_id |
| (fun z : Unit × (Fin k → Point d) => M c z.2) (fun g => b+τ • g) |
| (hm.comp (measurable_const.prodMk measurable_snd)) (by fun_prop) (by intro; rfl) (by intro; rfl) |
| rw [←Measure.dirac_prod (),Measure.map_id] at hMR |
| obtain ⟨π,hπ,hpl,hpr,hpi,hpe⟩ := hMR |
| let := hπ |
| have hlaw : κ.map (fun z : Ω × Point d => ((),z.2))=(Measure.dirac ()).prod γ := by |
| dsimp only [γ] |
| rw [Measure.dirac_prod,←hcr] |
| change _=(κ.map Prod.snd).map (Prod.mk ()) |
| rw [Measure.map_map (by fun_prop) measurable_snd] |
| rfl |
| have hnoise : π.map (fun z : (Unit × (Fin k → Point d)) × Point d => (z.1.1,z.2))= |
| (Measure.dirac ()).prod γ := by |
| dsimp only [γ] |
| rw [Measure.dirac_prod,←hpr] |
| change _=(π.map Prod.snd).map (Prod.mk ()) |
| rw [Measure.map_map (by fun_prop) measurable_snd] |
| rfl |
| obtain ⟨Λ,hΛ,hLl,hLr,hLi,hLe⟩ := absorb_coupling κ (Measure.dirac ()) γ |
| (fun _ => ()) Prod.snd (fun z => f z.1) measurable_const measurable_snd |
| (hf.comp measurable_fst) hlaw (fun _ => c) measurable_const hD hK v hv M hm hshift hLip |
| (fun _ g => b+τ • g) (by fun_prop) hci hce π hpl hnoise hpi hpe |
| let := hΛ |
| let T : ((Ω × Point d) × (Fin k → Point d)) × Point d → Ω × (Fin k → Point d) := |
| fun z => (z.1.1.1,z.1.2) |
| have hT : Measurable T := by unfold T; fun_prop |
| have hTl : Λ.map T=μ.prod θ := by |
| change Λ.map ((Prod.map Prod.fst id) ∘ Prod.fst)=_ |
| rw [←Measure.map_map (by fun_prop) measurable_fst] |
| change Λ.fst.map (Prod.map Prod.fst id)=_ |
| rw [hLl,←Measure.map_prod_map _ _ measurable_fst measurable_id,Measure.map_id] |
| change κ.fst.prod θ=μ.prod θ |
| rw [hcl] |
| have hLright : Λ.map Prod.snd=γ := by |
| have H := congrArg (Measure.map Prod.snd) hLr |
| rw [Measure.map_map measurable_snd (by fun_prop),Measure.map_snd_prod] at H |
| simpa only [Function.comp_def,measure_univ,one_smul] using H |
| exact SquaredAt.of_joint Λ (μ.prod θ) γ T Prod.snd hT measurable_snd hTl hLright |
| _ _ (hm.comp ((hf.comp measurable_fst).prodMk (by |
| dsimp only [slotTransform,slotSum]; fun_prop))) (by fun_prop) hLi hLe |
| end LogConcaveSampling.Coupling |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace LogConcaveSampling.Coupling |
| open MeasureTheory ProbabilityTheory |
| open scoped Classical BigOperators |
|
|
| variable {ι : Type*} [Fintype ι] {Ω Γ : ι → Type*} |
| [∀i,MeasurableSpace (Ω i)] [∀i,MeasurableSpace (Γ i)] {d : ℕ} |
|
|
| theorem SquaredAt.weighted_pi (μ : ∀i,Measure (Ω i)) (ν : ∀i,Measure (Γ i)) |
| [∀i,IsProbabilityMeasure (μ i)] [∀i,IsProbabilityMeasure (ν i)] |
| (f : ∀i,Ω i → Point d) (g : ∀i,Γ i → Point d) |
| (hf : ∀i,Measurable (f i)) (hg : ∀i,Measurable (g i)) |
| (w B : ι → ℝ) (h : ∀i,SquaredAt (μ i) (ν i) (f i) (g i) (B i)) : |
| SquaredAt (Measure.pi μ) (Measure.pi ν) |
| (fun z => ∑i,w i • f i (z i)) (fun z => ∑i,w i • g i (z i)) |
| ((∑i,|w i|)*(∑i,|w i| * B i)) := by |
| choose κ hκ hl hr hi he using h |
| let : ∀i,IsProbabilityMeasure (κ i) := hκ |
| let Λ := Measure.pi κ |
| let T : (∀i,Ω i × Γ i) → (∀i,Ω i) := fun z i => (z i).1 |
| let U : (∀i,Ω i × Γ i) → (∀i,Γ i) := fun z i => (z i).2 |
| have hT : Measurable T := by unfold T; fun_prop |
| have hU : Measurable U := by unfold U; fun_prop |
| have hTl : Λ.map T=Measure.pi μ := |
| (measurePreserving_pi κ μ (fun i => ⟨measurable_fst,hl i⟩)).map_eq |
| have hUl : Λ.map U=Measure.pi ν := |
| (measurePreserving_pi κ ν (fun i => ⟨measurable_snd,hr i⟩)).map_eq |
| have hm (i : ι) : Measurable (fun z : Ω i × Γ i => f i z.1-g i z.2) := by fun_prop |
| have hip (i : ι) : Integrable (fun z : ∀i,Ω i × Γ i => ‖f i (z i).1-g i (z i).2‖^2) Λ := |
| (measurePreserving_eval κ i).integrable_comp_of_integrable (hi i) |
| have hep (i : ι) : (∫z : ∀i,Ω i × Γ i,‖f i (z i).1-g i (z i).2‖^2 ∂Λ)≤B i := by |
| exact ((measurePreserving_eval κ i).hasLaw.integral_comp |
| ((hm i).norm.pow_const 2).aestronglyMeasurable).trans_le (he i) |
| have hs := RMSIntegral.weighted_sum_sq_varying w |
| (fun i (z : ∀i,Ω i × Γ i) => f i (z i).1-g i (z i).2) B |
| (fun i => ((hm i).comp (measurable_pi_apply i)).aestronglyMeasurable) hip hep |
| have hid (z : ∀i,Ω i × Γ i) : |
| (∑i,w i • f i (T z i))-(∑i,w i • g i (U z i))= |
| ∑i,w i • (f i (z i).1-g i (z i).2) := by |
| simp only [T,U,smul_sub,Finset.sum_sub_distrib] |
| refine SquaredAt.of_joint Λ (Measure.pi μ) (Measure.pi ν) T U hT hU hTl hUl |
| _ _ (by fun_prop) (by fun_prop) ?_ ?_ |
| · simpa only [hid] using hs.1 |
| · simpa only [hid] using hs.2 |
| end LogConcaveSampling.Coupling |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace LogConcaveSampling.Coupling |
| open MeasureTheory ProbabilityTheory Function |
| open scoped Classical BigOperators |
|
|
| variable {Ω Γ W : Type*} [MeasurableSpace Ω] [MeasurableSpace Γ] [MeasurableSpace W] {d : ℕ} |
|
|
| theorem SquaredAt.common_noise {μ : Measure Ω} {ν : Measure Γ} |
| {f : Ω → Point d} {g : Γ → Point d} (hf : Measurable f) (hg : Measurable g) |
| {B : ℝ} (h : SquaredAt μ ν f g B) (ρ : Measure W) [IsProbabilityMeasure ρ] |
| (hnoise : W → Point d) (hm : Measurable hnoise) : |
| SquaredAt (μ.prod ρ) (ν.prod ρ) (fun z => f z.1+hnoise z.2) |
| (fun z => g z.1+hnoise z.2) B := by |
| obtain ⟨κ,hκ,hl,hr,hi,he⟩ := h |
| let := hκ |
| let T : (Ω × Γ) × W → Ω × W := Prod.map Prod.fst id |
| let U : (Ω × Γ) × W → Γ × W := Prod.map Prod.snd id |
| have hT : Measurable T := by fun_prop |
| have hU : Measurable U := by fun_prop |
| have hTl : (κ.prod ρ).map T=μ.prod ρ := by |
| rw [←Measure.map_prod_map _ _ measurable_fst measurable_id,Measure.map_id] |
| change κ.fst.prod ρ=μ.prod ρ |
| rw [hl] |
| have hUl : (κ.prod ρ).map U=ν.prod ρ := by |
| rw [←Measure.map_prod_map _ _ measurable_snd measurable_id,Measure.map_id] |
| change κ.snd.prod ρ=ν.prod ρ |
| rw [hr] |
| have hcost (z : (Ω × Γ) × W) : |
| ‖(f (T z).1+hnoise (T z).2)-(g (U z).1+hnoise (U z).2)‖^2=‖f z.1.1-g z.1.2‖^2 := by |
| dsimp only [T,U,Prod.map]; rw [add_sub_add_right_eq_sub] |
| refine SquaredAt.of_joint (κ.prod ρ) (μ.prod ρ) (ν.prod ρ) T U hT hU hTl hUl |
| _ _ (by fun_prop) (by fun_prop) ?_ ?_ |
| · simpa only [hcost] using hi.comp_fst ρ |
| · simp_rw [hcost] |
| rw [integral_prod _ (hi.comp_fst ρ)] |
| simpa only [integral_const,probReal_univ,one_smul] using he |
| end LogConcaveSampling.Coupling |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
