| import Mathlib |
| import OAI.Probability.LogConcave.OraclePrograms.FullTape |
| import OAI.Probability.LogConcave.Sampling.ProdMapEventReal |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace LogConcaveSampling.OracleCompiler |
| open MeasureTheory ProbabilityTheory Coupling Function |
| open scoped Classical NNReal |
|
|
| variable {d : ℕ} |
|
|
| lemma ReservedProgram.tv_of_pre {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam) |
| (S : ReservedProgram d) (x : Point d) {r η e : ℝ} |
| (hr : 0≤r) (hl : (lam:ℝ)*r^2<1) (hη : 0<η) (he : 0≤e) |
| (hres : S.reserve=η/2) |
| (hpre : SquaredAt (gaussianTape d S.slots) |
| ((gibbs (primitivePotential F x r)).prod (stdGaussian (Point d))) |
| (fun g => S.pre.run F (x,g)) (fun z => z.1+(Real.sqrt 3*η/2) • z.2) |
| (e^2*(circuitD F x)^2)) : |
| TVAtMost ((gaussianTape d S.full.slots).map (fun g => S.full.program.run F (x,g))) |
| (((gibbs (primitivePotential F x r)).prod (stdGaussian (Point d))).map |
| (fun z => z.1+η • z.2)) (2*e*circuitD F x/η) := by |
| let := probability_gibbs_of_partition |
| (partition_pos_of_continuous (hF.continuous_potential x r)).ne' |
| (partition_ne_top_of_integrable (hF.integrable_exp_neg_potential x hr hl)) |
| have hV : Measurable (fun z => (F z,gradient F z)) := |
| hF.smooth.continuous.measurable.prodMk hF.gradient_lipschitz.continuous.measurable |
| have hf : Measurable (fun g => S.pre.run F (x,g)) := |
| (S.pre.measurable_run F hV).comp (by fun_prop) |
| have hh := hpre.gaussian_smoothing hf (by fun_prop) (show 0<η/2 by positivity) |
| have hfull : ((gaussianTape d S.slots).prod (stdGaussian (Point d))).map |
| (fun z => S.pre.run F (x,z.1)+(η/2) • z.2)= |
| (gaussianTape d S.full.slots).map (fun g => S.full.program.run F (x,g)) := by |
| let f : (Fin (S.slots+1) → Point d) → Point d := fun g => S.full.program.run F (x,g) |
| have hfm : Measurable f := |
| (S.full.program.measurable_run F hV).comp (measurable_const.prodMk measurable_id) |
| have hp := ReservedProgram.fullTape_preserving (d:=d) S.slots |
| have heq : (fun z : (Fin S.slots → Point d) × Point d => |
| S.pre.run F (x,z.1)+(η/2) • z.2)=f ∘ ReservedProgram.fullTape S.slots := by |
| funext z |
| dsimp only [f,comp_apply] |
| rw [ReservedProgram.full_run] |
| simp only [ReservedProgram.fullTape,Fin.append_left,Fin.append_right,hres] |
| exact (congrArg (fun k => ((gaussianTape d S.slots).prod (stdGaussian (Point d))).map k) heq).trans |
| ((Measure.map_map hfm hp.measurable).symm.trans (congrArg (Measure.map f) hp.map_eq)) |
| have hnoise := smoothing_add_gaussian |
| ((gibbs (primitivePotential F x r)).prod (stdGaussian (Point d))) (gibbs (primitivePotential F x r)) |
| (fun z => z.1+(Real.sqrt 3*η/2) • z.2) id (by fun_prop) measurable_id |
| (Real.sqrt 3*η/2) (η/2) η (by |
| rw [div_pow,mul_pow,Real.sq_sqrt (by norm_num : (0:ℝ)≤3),div_pow]; ring) rfl |
| rw [hfull,hnoise] at hh |
| have hs : Real.sqrt (e^2*(circuitD F x)^2)=e*circuitD F x := by |
| rw [←mul_pow,Real.sqrt_sq (mul_nonneg he (circuitD_nonneg F x))] |
| have heq : e*circuitD F x/(η/2)=2*e*circuitD F x/η := by ring |
| simpa only [id_eq,hs,heq] using hh |
|
|
| end LogConcaveSampling.OracleCompiler |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
