| import Mathlib |
| import OAI.Probability.LogConcave.Sampling.TapeSnocEquiv |
| import OAI.Probability.LogConcave.OraclePrograms.Program |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace LogConcaveSampling.OracleCompiler.Program |
| open MeasureTheory ProbabilityTheory Function |
| open scoped Classical |
|
|
| variable {E R : Type*} [MeasurableSpace E] [MeasurableSpace R] {d q : ℕ} |
|
|
| def fresh (A : ℕ → Program (E × R) d q E) : |
| (n : ℕ) → Program (E × (Fin n → R)) d (q*n) E |
| | 0 => pure Prod.fst measurable_fst |
| | n+1 => |
| (((fresh A n).seedMap (fun p : E × (Fin (n+1) → R) => (p.1,Fin.init p.2)) |
| (measurable_fst.prodMk (Measurable.of_eval |
| (fun index => (measurable_pi_apply index.castSucc).comp measurable_snd)))).seq |
| ((A n).seedMap (fun p : (E × (Fin (n+1) → R)) × E => (p.2,p.1.2 (Fin.last n))) |
| (by fun_prop))) |
|
|
| lemma fresh_run (A : ℕ → Program (E × R) d q E) (V : Point d → ℝ) (n : ℕ) |
| (p : E × (Fin n → R)) : |
| (fresh A n).run V p=stateRun id (fun j => (A j).run V) n p := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| simp only [fresh,seq_run,seedMap_run,stateRun] |
| rw [ih] |
|
|
| lemma fresh_law (A : ℕ → Program (E × R) d q E) {V : Point d → ℝ} |
| (hV : Measurable (firstOrderReply V)) (μ : Measure E) (γ : Measure R) |
| [IsProbabilityMeasure μ] [IsProbabilityMeasure γ] (n : ℕ) : |
| (μ.prod (Measure.pi (fun _ : Fin n => γ))).map ((fresh A n).run V)= |
| stateLaw μ γ (fun j => (A j).run V) n := by |
| have h := stateRun_law μ γ id measurable_id (fun j => (A j).run V) |
| (fun j => (A j).measurable_run V hV) n |
| simpa only [←funext (fresh_run A V n),Measure.map_id] using h |
|
|
| end LogConcaveSampling.OracleCompiler.Program |
|
|
| end |
| end |
|
|
| end OAI |
|
|
